pool: ConnectionPool,
    connection: RealConnection,
  ) {
    val client =
      OkHttpClient
        .Builder()
        .connectionPool(pool)
        .build()
    val call = client.newCall(Request(connection.route().address.url)) as RealCall
    call.enterNetworkInterceptorExchange(call.request(), true, factory.newChain(call))
    connection.withLock { call.acquireConnectionNoEvents(connection) }
  }

import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.concurrent.withLock
import okhttp3.internal.connection.ConnectionListener
import okhttp3.internal.connection.RealCall
import okhttp3.internal.connection.RealConnection
import okhttp3.internal.connection.RealConnectionPool
import okhttp3.internal.connection.RealRoutePlanner
import okhttp3.internal.http.RealInterceptorChain
import okhttp3.internal.http.RecordingProxySelector

Jesse Wilson <******@****.***> 1645903053 -0500

        // Validates simple property delegation to the connection
        when(treeConnection.getTreeType()).thenReturn(7);
        when(treeConnection.getConnectedShare()).thenReturn("SHARE");
        assertEquals(7, handle.getTreeType());
        assertEquals("SHARE", handle.getConnectedShare());
        verify(treeConnection).getTreeType();
        verify(treeConnection).getConnectedShare();
    }

    @Test

        connectionListener.connectionClosed(connection)
      } else if (noNewExchangesEvent) {
        connectionListener.noNewExchanges(connection)
      }
    }
    return null
  }

  fun put(connection: RealConnection) {
    connection.assertLockHeld()

    connections.add(connection)
//    connection.queueEvent { connectionListener.connectEnd(connection) }
    scheduleCloser()
  }

  /**

     * @return active tree handle
     * @throws CIFSException if connection fails
     *
     */
    synchronized SmbTreeHandleImpl ensureTreeConnected() throws CIFSException {
        // Optimization: Check connection validity more efficiently
        if (this.treeHandle != null && this.treeHandle.isConnected()) {
            // Connection is still valid - reuse it

            artifactId = id;
        }
    }

    public static class Scm {
        private String connection;

        public void setConnection(String connection) {
            this.connection = connection;
        }

        public String getConnection() {
            return connection;
        }
    }

    public static class ValueHolder {
        private final Object value;

        String src = source.getConnection();
        if (src != null) {
            if (sourceDominant) {
                target.setConnection(src);
                target.setLocation("connection", source.getLocation("connection"));
            } else if (target.getConnection() == null) {
                target.setConnection(extrapolateChildUrl(src, source.isChildScmConnectionInheritAppendPath(), context));

import okhttp3.Response
import okhttp3.internal.connection.Exchange
import okhttp3.internal.connection.RealCall
import okhttp3.internal.connection.RealConnection
import okio.FileSystem
import okio.Path

internal fun buildCache(
  file: Path,
  maxSize: Long,
  fileSystem: FileSystem,
): Cache = Cache(fileSystem, file, maxSize)

internal var RealConnection.idleAtNsAccessor: Long
  get() = idleAtNs
  set(value) {

     * @return A {@link URLConnection} object to the URL.
     */
    public static URLConnection openConnection(final URL url) {
        assertArgumentNotNull("url", url);

        try {
            final URLConnection connection = url.openConnection();
            connection.setUseCaches(false);
            return connection;
        } catch (final IOException e) {