)
  }

  @Test
  @Throws(IOException::class)
  fun successfulHttpProxyConnect() {
    server!!.enqueue(MockResponse())
    val proxy = server!!.proxyAddress
    client =
      client
        .newBuilder()
        .proxy(proxy)
        .build()
    val call =
      client.newCall(
        Request
          .Builder()
          .url("http://www.fakeurl")
          .build(),

      // If we used the ProxySelector, and got a IOException during connect, report the failure.
      if (route.address.proxy == null && route.proxy.type() != Proxy.Type.DIRECT) {
        route.address.proxySelector.connectFailed(
          route.address.url.toUri(),
          route.proxy.address(),
          e,
        )
      }
      user.connectFailed(route, null, e)

  }

  @AfterEach
  fun tearDown() {
    socksProxy.shutdown()
  }

  @Test
  fun proxy() {
    server.enqueue(MockResponse.Builder().body("abc").build())
    server.enqueue(MockResponse.Builder().body("def").build())
    val client =
      clientTestRule
        .newClientBuilder()
        .proxy(socksProxy.proxy())
        .build()
    val request1 = Request.Builder().url(server.url("/")).build()

    var client = OkHttpClient.Builder().build()
    assertThat(client.proxy).isNull()
    assertThat(client.proxySelector)
      .isNotInstanceOf(NullProxySelector::class.java)
    client =
      OkHttpClient
        .Builder()
        .proxy(Proxy.NO_PROXY)
        .build()
    assertThat(client.proxy).isSameAs(Proxy.NO_PROXY)
    assertThat(client.proxySelector)

import java.io.Serializable;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Generates a dummy interface proxy that simply returns a dummy value for each method.
 *
 * @author Ben Yu
 */
@GwtIncompatible

        assertNull(request.proxy());
        assertNull(request.body());
    }

    @Test
    public void testProxyMethod() {
        CurlRequest request = new CurlRequest(Method.GET, "https://example.com");
        Proxy proxy = Proxy.NO_PROXY;

        CurlRequest result = request.proxy(proxy);

        assertSame(request, result); // Fluent API
        assertSame(proxy, request.proxy());
    }

    @Test

    private final CountDownLatch returned = new CountDownLatch(1);
    private Object proxy;

    @SuppressWarnings("unchecked") // proxy for a generic class
    <V> Callable<V> waitFor(Callable<V> callable) {
      return waitFor(callable, Callable.class);
    }

    @SuppressWarnings("unchecked") // proxy for a generic class
    <V> ClosingCallable<V> waitFor(ClosingCallable<V> closingCallable) {

  fun proxyMoveTest(cleanClose: Boolean) {
    // Define a single Proxy at myproxy:8008 that will artificially move during the test
    val proxySelector = RecordingProxySelector()
    val socketAddress = InetSocketAddress.createUnresolved("myproxy", 8008)
    proxySelector.proxies.add(Proxy(Proxy.Type.HTTP, socketAddress))

    // Define two host names for the DNS routing of fake proxy servers

   * header to create the request URL.
   *
   * For HTTP proxy requests this will be either an absolute-form string like
   * `http://example.com/index.html` (HTTP proxy) or an authority-form string like
   * `example.com:443` (HTTPS proxy).
   *
   * For OPTIONS requests, this may be an asterisk, `*`.
   */
  public val target: String,

          proxy: Proxy,
        ) = TODO()

        override fun secureConnectStart(call: Call) = TODO()

        override fun secureConnectEnd(
          call: Call,
          handshake: Handshake?,
        ) = TODO()

        override fun connectEnd(
          call: Call,
          inetSocketAddress: InetSocketAddress,
          proxy: Proxy,
          protocol: Protocol?,