* because the TLS ecosystem is dynamic and staying up to date is necessary to stay secure. See
 * [OkHttp's TLS Configuration History][tls_history] to track these changes.
 *
 * [tls_history]: https://square.github.io/okhttp/tls_configuration_history/
 */
class ConnectionSpec internal constructor(
  @get:JvmName("isTls") val isTls: Boolean,

    throw new UnsupportedOperationException();
  }

  /**
   * {@inheritDoc}
   *
   * <p>This implementation of {@code getAllPresent} lacks any insight into the internal cache data
   * structure, and is thus forced to return the query keys instead of the cached keys. This is only
   * possible with an unsafe cast which requires {@code keys} to actually be of type {@code K}.

  /**
   * Returns the number of edges in this graph; used to calculate the size of {@link Graph#edges()}.
   * This implementation requires O(|N|) time. Classes extending this one may manually keep track of
   * the number of edges as the graph is updated, and override this method for better performance.
   */
  protected long edgeCount() {
    long degreeSum = 0L;
    for (N node : nodes()) {

        assertFalse(exception.isAuthenticationError());
        assertFalse(exception.isFileSystemError());
        assertTrue(exception.isTransientError());
    }

    @Test
    @DisplayName("Should track elapsed time")
    void testElapsedTime() throws InterruptedException {
        // Given
        exception = new SmbOperationException(SmbOperationException.ErrorCode.BUSY, "Server busy");

        // When

        .Builder()
        .addTrustedCertificate(rootCa.certificate)
        .build()
    client =
      clientTestRule
        .newClientBuilder()
        .fastFallback(false) // Avoid data races.
        .dns(dns)
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).build()
    val serverHandshakeCertificates =

        log.info("Skip masking for debug level {}", enable ? "enabled" : "disabled");
    }

    /**
     * Enable or disable stack trace inclusion
     *
     * @param enable true to include stack traces
     */
    public void setIncludeStackTrace(boolean enable) {
        this.includeStackTrace = enable;
    }

    /**
     * Set minimum log level
     *

   * call. To prevent this problem, create a key object that includes all values that affect the
   * result of the query. Or use {@code LoadingCache.get(K)}, which lacks the ability to refer to
   * state other than that in the key.
   *
   * <p><b>Warning:</b> as with {@link CacheLoader#load}, {@code loader} <b>must not</b> return

        if (log.isDebugEnabled()) {
            log.debug("New transport connection " + conn + " (pool size: " + connections.size() + "/" + maxPoolSize + ")");
        }

        // Track connection metrics
        String key = getConnectionKey(address, port);
        connectionMetrics.computeIfAbsent(key, k -> new ConnectionMetrics()).recordConnection();
        activeConnections.incrementAndGet();

      new AtomicReference<>(immediateVoidFuture());

  @LazyInit private ThreadConfinedTaskQueue latestTaskQueue = new ThreadConfinedTaskQueue();

  /**
   * This object is unsafely published, but avoids problematic races by relying exclusively on the
   * identity equality of its Thread field so that the task field is only accessed by a single
   * thread.
   */
  private static final class ThreadConfinedTaskQueue {
    /**

    }

    @Test
    @DisplayName("send retries on transport errors and restores request/response state")
    void send_retries_on_transportError() throws Exception {
        // Create a spy to track method calls
        SmbTreeConnection c = spy(newConn());

        // Prepare a minimal locator
        SmbResourceLocatorImpl loc = new SmbResourceLocatorImpl(ctx, smbUrl("smb://srv/share/path"));