int currentSize = this.connections.size();
            if (currentSize >= maxPoolSize) {
                // Try to remove idle connections
                removeIdleConnections();

                // If still at limit, throw exception
                if (this.connections.size() >= maxPoolSize) {
                    throw new IllegalStateException("Connection pool has reached maximum size of " + maxPoolSize

        assertTrue(pool.contains(pooled), "Pooled connection should be tracked");
        assertFalse(pool.contains(nonPooled), "Non-pooled connection should not be tracked");
    }

    @Test
    @DisplayName("Should create new connections when reuse conditions are not met")
    void testNoConnectionReuse() throws Exception {
        // Given: Create a new pool for this test to ensure isolation

/**
 * Hc4ConnectionMonitorTarget is responsible for monitoring and managing HTTP client connections
 * for Apache HttpComponents 4.x. It implements the TimeoutTarget interface to handle connection
 * expiration events.
 *
 * <p>This class uses an instance of HttpClientConnectionManager to manage the connections.
 * It closes expired connections and idle connections that have exceeded a specified timeout.
 * </p>
 *

* kubeadm: avoid double deletion of the upgrade prepull DaemonSet ([#80798](https://github.com/kubernetes/kubernetes/pull/80798), [@xlgao-zju](https://github.com/xlgao-zju))
* Fixes problems with connecting to services on localhost on some systems; in particular, DNS queries to systemd-resolved on Ubuntu. ([#80591](https://github.com/kubernetes/kubernetes/pull/80591), [@danwinship](https://github.com/danwinship))

      ioe,
    ),
  )

  override fun connectionAcquired(
    call: Call,
    connection: Connection,
  ) = onEvent(ConnectionAcquired(System.nanoTime(), call, connection))

  override fun connectionReleased(
    call: Call,
    connection: Connection,
  ) = onEvent(ConnectionReleased(System.nanoTime(), call, connection))

  override fun callStart(call: Call) = onEvent(CallStart(System.nanoTime(), call))

 * limitations under the License.
 */
package okhttp3.internal.connection

/**
 * A policy for how the pool should treat a specific address.
 */
class AddressPolicy(
  /**
   * How many concurrent calls should be possible to make at any time.
   * The pool will routinely try to pre-emptively open connections to satisfy this minimum.
   * Connections will still be closed if they idle beyond the keep-alive but will be replaced.

            info.reconnecting = true;
            return info;
        }
        return null;
    }
    
    public void completeReconnect(String path, boolean success) {
        HandleInfo info = handles.get(path);
        if (info != null) {
            if (success) {
                info.updateAccessTime();
                info.reconnecting = false;
            } else {

import okhttp3.internal.connection.ConnectionListener
import okhttp3.internal.connection.RealConnectionPool

/**
 * Manages reuse of HTTP and HTTP/2 connections for reduced network latency. HTTP requests that
 * share the same [Address] may share a [Connection]. This class implements the policy
 * of which connections to keep open for future use.
 *

    assertThat(connectStart.proxy).isEqualTo(Proxy.NO_PROXY)
    val connectEnd = eventRecorder.removeUpToEvent<CallEvent.ConnectEnd>()
    assertThat(connectEnd.call).isSameInstanceAs(call)
    assertThat(connectEnd.inetSocketAddress).isEqualTo(expectedAddress)
    assertThat(connectEnd.protocol).isEqualTo(Protocol.HTTP_1_1)
  }

  @Test
  fun failedConnect() {
    enableTlsWithTunnel()

     * Get transport connection
     *
     * @param tc
     *            context to use
     * @param address the server address
     * @param port the port number
     * @param exclusive
     *            whether to acquire an unshared connection
     * @param forceSigning
     *            whether to enforce SMB signing on this connection
     * @return a transport connection to the target
     */