// so decrease the timeout towards 25 % of maximum time spent.
		maxDur = maxDur * 125 / 100

		timeout := atomic.LoadInt64(&dt.timeout)
		if maxDur < time.Duration(timeout) {
			// Move 50% toward the max.
			timeout = (int64(maxDur) + timeout) / 2
		}
		if timeout < dt.minimum {
			timeout = dt.minimum
		}
		atomic.StoreInt64(&dt.timeout, timeout)
	}

    }

    /**
     * Sets the connection timeout.
     * @param connectionTimeout The connection timeout in milliseconds.
     */
    public void setConnectionTimeout(final Integer connectionTimeout) {
        this.connectionTimeout = connectionTimeout;
    }

    /**
     * Sets the socket timeout.
     * @param soTimeout The socket timeout in milliseconds.
     */

        // When
        int timeout1 = delegatingConfig.getResponseTimeout();
        int timeout2 = delegatingConfig.getResponseTimeout();
        int timeout3 = delegatingConfig.getResponseTimeout();

        // Then
        assertEquals(30000, timeout1, "First call should return correct value");
        assertEquals(30000, timeout2, "Second call should return correct value");

            nextNameTrnId = 1;
        }
        return nextNameTrnId;
    }

    void ensureOpen(final int timeout) throws IOException {
        closeTimeout = 0;
        if (SO_TIMEOUT != 0) {
            closeTimeout = Math.max(SO_TIMEOUT, timeout);
        }
        // If socket is still good, the new closeTimeout will
        // be ignored; see tryClose comment.
        if (socket == null) {

    } else {
      javaNetSocket.soTimeout = chain.readTimeoutMillis()
      okHttpSocket.source.timeout().timeout(chain.readTimeoutMillis.toLong(), MILLISECONDS)
      okHttpSocket.sink.timeout().timeout(chain.writeTimeoutMillis.toLong(), MILLISECONDS)
      Http1ExchangeCodec(client, this, okHttpSocket)
    }
  }

  internal fun useAsSocket() {
    javaNetSocket.soTimeout = 0
    noNewExchanges()
  }

    /** Default SMB port number */
    int DEFAULT_PORT = 445;

    /** Default maximum multiplex count */
    int DEFAULT_MAX_MPX_COUNT = 10;
    /** Default response timeout in milliseconds */
    int DEFAULT_RESPONSE_TIMEOUT = 30000;
    /** Default socket timeout in milliseconds */
    int DEFAULT_SO_TIMEOUT = 35000;
    /** Default receive buffer size in bytes */
    int DEFAULT_RCV_BUF_SIZE = 60416;

    FUTURE(Timeout.SMALL, Timeout.MAX),
    SMALL(Timeout.SMALL),
    FINITE(Timeout.MIN, Timeout.MINUS_SMALL, Timeout.ZERO, Timeout.SMALL),
    INFINITE(Timeout.LARGE, Timeout.MAX);

    final ImmutableList<Timeout> timeouts;

    TimeoutsToUse(Timeout... timeouts) {
      this.timeouts = ImmutableList.copyOf(timeouts);
    }
  }

  /** Possible outcomes of calling any of the methods under test. */

   * uninterruptibly.
   */
  @J2ktIncompatible
  @GwtIncompatible // concurrency
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public static boolean awaitUninterruptibly(CountDownLatch latch, long timeout, TimeUnit unit) {
    boolean interrupted = false;
    try {
      long remainingNanos = unit.toNanos(timeout);

                            long timeout = RESPONSE_TIMEOUT;
                            resp.expiration = System.currentTimeMillis() + timeout;
                            while (resp.hasMoreElements()) {
                                wait(timeout);
                                timeout = resp.expiration - System.currentTimeMillis();
                                if (timeout <= 0) {

    }

    @Test
    @DisplayName("Should handle broadcast resolution timeout")
    @Timeout(value = 1, unit = TimeUnit.SECONDS) // Very short timeout
    void testBroadcastTimeout() {
        // Configure for broadcast-only resolution with very short timeout
        when(mockConfig.getResolveOrder()).thenReturn(Arrays.asList(ResolverType.RESOLVER_BCAST));