*/
    Set<RdmaCapability> getSupportedCapabilities();

    /**
     * Create RDMA connection to remote endpoint
     *
     * @param remote remote socket address
     * @param local local socket address, may be null for auto-binding
     * @return new RDMA connection instance
     * @throws IOException if connection creation fails
     */

    val eventListener =
      object : EventListener() {
        var socket: SSLSocket? = null
        var closed = false

        override fun connectionAcquired(
          call: Call,
          connection: Connection,
        ) {
          socket = connection.socket() as SSLSocket
        }

        override fun requestHeadersStart(call: Call) {
          if (closed) {

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.witness;

import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**

                  }
                }.build(),
            ),
          )
        }
      }.addNetworkInterceptor {
        val socket = it.connection()!!.socket() as SSLSocket

        handshakeEnabledCipherSuites = socket.enabledCipherSuites.toList()

        it.proceed(it.request())
      }.build()

  private fun makeRequest(client: OkHttpClient): Handshake {

  fun addProxy(proxy: Proxy): FakeProxySelector {
    proxies.add(proxy)
    return this
  }

  override fun select(uri: URI): List<Proxy> {
    // Don't handle 'socket' schemes, which the RI's Socket class may request (for SOCKS).
    return if (uri.scheme == "http" || uri.scheme == "https") proxies else listOf(Proxy.NO_PROXY)
  }

  override fun connectFailed(
    uri: URI,
    sa: SocketAddress,

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.connection

import java.net.Socket as JavaNetSocket
import okio.BufferedSink
import okio.BufferedSource
import okio.Socket as OkioSocket
import okio.asOkioSocket
import okio.buffer

interface BufferedSocket : OkioSocket {
  override val source: BufferedSource
  override val sink: BufferedSink

            transport = Remote.RemoteTransport.SOCKET
            sharedMemoryAddress = "javadebug"
            host = "localhost"
            port = 5005
            autoRestart = true
        }
        create<Remote>("Launcher debug (port 5006)") {
            mode = Remote.RemoteMode.LISTEN
            transport = Remote.RemoteTransport.SOCKET
            sharedMemoryAddress = "javadebug"

    result = 31 * result + proxy.hashCode()
    result = 31 * result + socketAddress.hashCode()
    return result
  }

  /**
   * Returns a string with the URL hostname, socket IP address, and socket port, like one of these:
   *
   *  * `example.com:80 at 1.2.3.4:8888`
   *  * `example.com:443 via proxy [::1]:8888`
   *
   * This omits duplicate information when possible.
   */

 * limitations under the License.
 */
package okhttp3

import okio.ByteString

abstract class WebSocketListener {
  /**
   * Invoked when a web socket has been accepted by the remote peer and may begin transmitting
   * messages.
   */
  open fun onOpen(
    webSocket: WebSocket,
    response: Response,
  ) {
  }

   * can return other values to test HTTP edge cases, such as unhappy socket policies or throttled
   * request bodies.
   */
  public open fun peek(): MockResponse = MockResponse()

  /**
   * Release any resources held by this dispatcher. Any requests that are currently being dispatched
   * should return immediately. Responses returned after shutdown will not be transmitted: their
   * socket connections have already been closed.
   */