dns[PROXY_A_HOST] = dns.allocate(2)
    val selection = routeSelector.next()
    assertRoute(selection.next(), address, proxyA, dns.lookup(PROXY_A_HOST, 0), PROXY_A_PORT)
    assertRoute(selection.next(), address, proxyA, dns.lookup(PROXY_A_HOST, 1), PROXY_A_PORT)
    assertThat(selection.hasNext()).isFalse()
    assertThat(routeSelector.hasNext()).isFalse()
    dns.assertRequests(PROXY_A_HOST)

 *
 * <p>Cache statistics are incremented according to the following rules:
 *
 * <ul>
 *   <li>When a cache lookup encounters an existing cache entry {@code hitCount} is incremented.
 *   <li>When a cache lookup first encounters a missing cache entry, a new entry is loaded.
 *       <ul>
 *         <li>After successfully loading an entry {@code missCount} and {@code loadSuccessCount}

    static final VarHandle valueUpdater;

    static {
      MethodHandles.Lookup lookup = MethodHandles.lookup();
      try {
        waiterThreadUpdater = lookup.findVarHandle(Waiter.class, "thread", Thread.class);
        waiterNextUpdater = lookup.findVarHandle(Waiter.class, "next", Waiter.class);
        waitersUpdater =
            lookup.findVarHandle(AbstractFutureState.class, "waitersField", Waiter.class);

    assertThat(cacheEvents()).containsExactly("CacheMiss")

    result = cachedDns.lookup("google.com")
    assertThat(server.takeRequest(1, TimeUnit.MILLISECONDS)).isNull()
    assertThat(result).isEqualTo(listOf(address("157.240.1.18")))

    assertThat(cacheEvents()).containsExactly("CacheHit")

    result = cachedDns.lookup("www.google.com")
    assertThat(result).containsExactly(address("157.240.1.18"))

        headers = headersOf("Location", "http://www.fakeurl:" + server!!.port),
      ),
    )
    server!!.enqueue(MockResponse())
    val dns = FakeDns()
    dns["fakeurl"] = client.dns.lookup(server!!.hostName)
    dns["www.fakeurl"] = client.dns.lookup(server!!.hostName)
    client =
      client
        .newBuilder()
        .dns(dns)
        .build()
    val call =
      client.newCall(
        Request

   */
  open fun proxySelectEnd(
    call: Call,
    url: HttpUrl,
    proxies: List<@JvmSuppressWildcards Proxy>,
  ) {
  }

  /**
   * Invoked just prior to a DNS lookup. See [Dns.lookup].
   *
   * This can be invoked more than 1 time for a single [Call]. For example, if the response to the
   * [Call.request] is a redirect to a different host.
   *

        .addSubjectAlternativeName("san.com")
        .addSubjectAlternativeName("*.wildcard.com")
        .addSubjectAlternativeName("differentdns.com")
        .build()
    serverIps = Dns.SYSTEM.lookup(server.hostName)
    dns[server.hostName] = serverIps
    dns["san.com"] = serverIps
    dns["nonsan.com"] = serverIps
    dns["www.wildcard.com"] = serverIps
    dns["differentdns.com"] = listOf()

    }

    public void test_load_sameTermDifferentHosts() {
        List<RelatedQuery> testData = new ArrayList<>();
        testData.add(createRelatedQuery("search", new String[] { "find", "lookup" }, "site1.com"));
        testData.add(createRelatedQuery("search", new String[] { "query", "discover" }, "site2.com"));
        mockBhv.setTestData(testData);

        relatedQueryHelper.load();

      return o;
    }

    @Override
    public String toString() {
      return "Functions.identity()";
    }
  }

  /**
   * Returns a function which performs a map lookup. The returned function throws an {@link
   * IllegalArgumentException} if given a key that does not exist in the map. See also {@link
   * #forMap(Map, Object)}, which returns a default value in this case.
   *

                removeWaiter(node);
                break long_wait_loop; // jump down to the busy wait loop
              }
            }
          }
          oldHead = waitersField; // re-read and loop.
        } while (oldHead != Waiter.TOMBSTONE);
      }
      // re-read valueField, if we get here then we must have observed a TOMBSTONE while trying to