// Name proxy specification.
    var socketAddress = InetSocketAddress.createUnresolved("host", 1234)
    assertThat(socketAddress.socketHost).isEqualTo("host")
    socketAddress = InetSocketAddress.createUnresolved("127.0.0.1", 1234)
    assertThat(socketAddress.socketHost).isEqualTo("127.0.0.1")

    // InetAddress proxy specification.
    socketAddress = InetSocketAddress(InetAddress.getByName("localhost"), 1234)

        RdmaProvider provider = RdmaProviderFactory.selectBestProvider();

        // Use localhost for testing - should work with TCP fallback
        InetSocketAddress address = new InetSocketAddress("localhost", 12345);

        try (RdmaConnection connection = provider.createConnection(address, null)) {
            assertNotNull(connection, "Connection should not be null");

    override fun connectEnd(
      call: Call,
      inetSocketAddress: InetSocketAddress,
      proxy: Proxy,
      protocol: Protocol?,
    ) {
      for (delegate in eventListeners) {
        delegate.connectEnd(call, inetSocketAddress, proxy, protocol)
      }
    }

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

     */
    Set<RdmaCapability> getSupportedCapabilities();
    
    /**
     * Create RDMA connection to remote endpoint
     */
    RdmaConnection createConnection(InetSocketAddress remote, 
                                   InetSocketAddress local) throws IOException;
    
    /**
     * Register memory region for RDMA operations
     */
    RdmaMemoryRegion registerMemory(ByteBuffer buffer, 

    val latch4 = CountDownLatch(1)
    val listener1: EventListener =
      object : EventListener() {
        override fun connectStart(
          call: Call,
          inetSocketAddress: InetSocketAddress,
          proxy: Proxy,
        ) {
          try {
            // Wait for request2 to guarantee we make 2 separate connections to the server.
            latch1.await()

import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import java.io.IOException
import java.net.InetAddress
import java.net.InetSocketAddress
import java.net.Proxy
import java.net.SocketTimeoutException
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.SocketEffect.CloseStream

        ) = TODO()

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

        override fun connectFailed(
          call: Call,
          inetSocketAddress: InetSocketAddress,
          proxy: Proxy,
          protocol: Protocol?,
          ioe: IOException,
        ) = TODO()

  }

  @Test @Disabled
  fun route() {
    val route: Route = factory.newRoute()
    val address: Address = route.address()
    val proxy: Proxy = route.proxy()
    val inetSocketAddress: InetSocketAddress = route.socketAddress()
  }

  @Test @Disabled
  fun tlsVersion() {
    val tlsVersion: TlsVersion = TlsVersion.TLS_1_3
    val javaName: String = tlsVersion.javaName()
  }

     * @param local local socket address
     * @param group DiSNI endpoint group
     * @throws IOException if connection creation fails
     */
    public DisniRdmaConnection(InetSocketAddress remote, InetSocketAddress local, Object group) throws IOException {
        super(remote, local);
        this.group = group;

        // In real implementation, this would create the endpoint:

            socket.setSoTimeout( SO_TIMEOUT );
            */

            socket = new Socket();
            if (localAddr != null) {
                socket.bind(new InetSocketAddress(localAddr, localPort));
            }
            socket.connect(new InetSocketAddress(address.getHostAddress(), 139), CONN_TIMEOUT);
            socket.setSoTimeout(SO_TIMEOUT);

            out = socket.getOutputStream();