}

  @ParameterizedTest
  @MethodSource("data")
  fun testCustomSocket(adapter: SocketAdapter) {
    val socketFactory = DelegatingSSLSocketFactory(context.socketFactory)

    assertFalse(adapter.matchesSocketFactory(socketFactory))

    val sslSocket =
      object : DelegatingSSLSocket(context.socketFactory.createSocket() as SSLSocket) {}
    assertFalse(adapter.matchesSocket(sslSocket))

  )
  fun proxyAuthenticator(): Authenticator = proxyAuthenticator

  @JvmName("-deprecated_socketFactory")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "socketFactory"),
    level = DeprecationLevel.ERROR,
  )
  fun socketFactory(): SocketFactory = socketFactory

  @JvmName("-deprecated_sslSocketFactory")
  @Deprecated(
    message = "moved to val",

    level = DeprecationLevel.ERROR,
  )
  fun dns(): Dns = dns

  @JvmName("-deprecated_socketFactory")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "socketFactory"),
    level = DeprecationLevel.ERROR,
  )
  fun socketFactory(): SocketFactory = socketFactory

  @JvmName("-deprecated_proxyAuthenticator")
  @Deprecated(
    message = "moved to val",

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import javax.net.SocketFactory;
import jnr.unixsocket.UnixSocketChannel;

/** Impersonate TCP-style SocketFactory over UNIX domain sockets. */
public final class UnixDomainSocketFactory extends SocketFactory {
  private final File path;

  public UnixDomainSocketFactory(File path) {
    this.path = path;
  }

  ) {
    this.server1 = server
    this.server2 = server2

    socketFactory = SpecificHostSocketFactory(InetSocketAddress(server.hostName, server.port))

    client =
      clientTestRule.newClientBuilder()
        .dns(dns)
        .socketFactory(socketFactory)
        .eventListenerFactory(clientTestRule.wrap(listener))
        .build()
  }

  @Test

      server.useHttps(handshakeCertificates.sslSocketFactory())
    }
    server.start()

    client =
      clientTestRule.newClientBuilder()
        .socketFactory(
          object : DelegatingSocketFactory(SocketFactory.getDefault()) {
            @Throws(IOException::class)
            override fun configureSocket(socket: Socket): Socket {
              socket.sendBufferSize = SOCKET_BUFFER_SIZE

        .build()
  }

  @Test
  fun clientAuthForWants() {
    val client = buildClient(clientCert, clientIntermediateCa.certificate)
    val socketFactory = buildServerSslSocketFactory()
    server.useHttps(socketFactory)
    server.requestClientAuth()
    server.enqueue(
      MockResponse.Builder()
        .body("abc")
        .build(),
    )

        .signedBy(compromisedIntermediateCa)
        .commonName(server.hostName)
        .build()
    val socketFactory =
      newServerSocketFactory(
        rogueCertificate,
        compromisedIntermediateCa.certificate,
        goodCertificate.certificate,
      )
    server.useHttps(socketFactory)
    server.enqueue(
      MockResponse.Builder()
        .body("abc")

import java.io.IOException
import java.net.InetAddress
import java.net.Socket
import javax.net.SocketFactory

/**
 * A [SocketFactory] that delegates calls. Sockets can be configured after creation by
 * overriding [.configureSocket].
 */
open class DelegatingSocketFactory(private val delegate: SocketFactory) : SocketFactory() {
  @Throws(IOException::class)
  override fun createSocket(): Socket {

        .writeTimeout(2, SECONDS)
        .readTimeout(2, SECONDS)
        .apply {
          if (socketMode is TlsInstance) {
            if (socketMode.socketMode == Channel) {
              socketFactory(ChannelSocketFactory())
            }

            connectionSpecs(
              listOf(
                ConnectionSpec.Builder(ConnectionSpec.COMPATIBLE_TLS)