package http

import (
	"context"
	"net"
	"time"
)

// LookupHost is a function to make custom lookupHost for optional cached DNS requests
type LookupHost func(ctx context.Context, host string) (addrs []string, err error)

// DialContextWithLookupHost is a helper function which returns `net.DialContext` function.
// It randomly fetches an IP via custom LookupHost function and dials it by the given dial

The [strings] package adds several functions that work with iterators:
- [Lines] returns an iterator over
  the newline-terminated lines in the string s.
- [SplitSeq] returns an iterator over
  all substrings of s separated by sep.
- [SplitAfterSeq] returns an iterator
  over substrings of s split after each instance of sep.
- [FieldsSeq] returns an iterator over
  substrings of s split around runs of whitespace characters,
  as defined by unicode.IsSpace.

      // modify this builder, so we make a copy instead.
      this.mutableValueGraph =
          graphBuilder.copy().incidentEdgeOrder(ElementOrder.<N>stable()).build();
    }

    /**
     * Adds {@code node} if it is not already present.
     *
     * <p><b>Nodes must be unique</b>, just as {@code Map} keys must be. They must also be non-null.
     *
     * @return this {@code Builder} object
     */

type TraceParamsKey struct{}

// traceRequests adds request tracing to the connection.
func (c *Connection) traceRequests(p *pubsub.PubSub[madmin.TraceInfo, madmin.TraceType]) {
	c.trace = &tracer{
		Publisher: p,
		TraceType: madmin.TraceInternal,
		Prefix:    "grid",
		Local:     c.Local,
		Remote:    c.Remote,
		Subroute:  "",
	}
}

// subroute adds a specific subroute to the request.

New function [Comparable] returns the hash of comparable value v.

The [bytes] package adds several functions that work with iterators:
- [Lines] returns an iterator over the
  newline-terminated lines in the byte slice s.
- [SplitSeq] returns an iterator over
  all substrings of s separated by sep.
- [SplitAfterSeq] returns an iterator
  over substrings of s split after each instance of sep.
- [FieldsSeq] returns an iterator over
  substrings of s split around runs of whitespace characters,
  as defined by unicode.IsSpace.

   * #add(Range) add} any range not {@linkplain Range#encloses(Range) enclosed} by {@code view}.
   */
  RangeSet<C> subRangeSet(Range<C> view);

  // Modification

  /**
   * Adds the specified range to this {@code RangeSet} (optional operation). That is, for equal
   * range sets a and b, the result of {@code a.add(range)} is that {@code a} will be the minimal

	for _, sub := range ps.subs {
		if sub.types.Contains(Mask(item.Mask())) && (sub.filter == nil || sub.filter(item)) {
			select {
			case sub.ch <- item:
			default:
			}
		}
	}
}

// Subscribe - Adds a subscriber to pubsub system
func (ps *PubSub[T, M]) Subscribe(mask M, subCh chan T, doneCh <-chan struct{}, filter func(entry T) bool) error {
	totalSubs := atomic.AddInt32(&ps.numSubscribers, 1)

    }

    def "adds implicit end of element at end of input"() {
        expect:
        parse(source) == transformed

        where:
        source         | transformed
        "<p>text"      | "<p>text</p>"
        "<ul><li>text" | "<ul><li>text</li></ul>"
    }

    def "adds implicit end of element"() {
        expect:
        parse(source) == transformed

# This shows an example local config for ztunnel that adds a workload for localhost.
# This allows local testing by sending requests through the local ztunnel to other servers running on localhost.
workloads:
- uid: cluster1//v1/Pod/default/local
  name: local
  namespace: default
  serviceAccount: default
  workloadIps: ["127.0.0.1"]
  protocol: HBONE
  node: local
  network: ""
  services:
    "default/example.com":
      80: 8080