/** 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;

        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {
          check(!closed)
          return data.read(sink, byteCount)
        }

        override fun timeout(): Timeout = Timeout.NONE
      }
    return source.buffer().asResponseBody(null, -1)
  }

  private fun newResponse(
    responseBody: ResponseBody,
    code: Int = 200,
  ): Response =
    Response

  override fun cancel(): Unit = error("unexpected")

  override fun isExecuted(): Boolean = error("unexpected")

  override fun isCanceled(): Boolean = error("unexpected")

  override fun timeout(): Timeout = error("unexpected")

  override fun addEventListener(eventListener: EventListener) = error("unexpected")

  override fun <T : Any> tag(type: KClass<T>): T? = error("unexpected")

    void testThrowableConstructor() {
        // Test the constructor with a cause
        Throwable cause = new RuntimeException("Root cause of timeout");
        ConnectionTimeoutException exception = new ConnectionTimeoutException(cause);
        assertEquals("java.lang.RuntimeException: Root cause of timeout", exception.getMessage(),
                "Message should be derived from the cause");

     *
     * @param timeoutTarget the target
     * @param timeout the timeout duration
     * @param permanent whether the task is permanent
     * @return the {@link TimeoutTask}
     */
    public synchronized TimeoutTask addTimeoutTarget(final TimeoutTarget timeoutTarget, final int timeout, final boolean permanent) {
        final TimeoutTask task = new TimeoutTask(timeoutTarget, timeout, permanent);
        timeoutTaskList.addLast(task);

	connRemoteLocal := remote.Connection(localHost)

	t.Run("testStreamRoundtrip", func(t *testing.T) {
		defer timeout(5 * time.Second)()
		testStreamRoundtrip(t, local, remote)
		assertNoActive(t, connRemoteLocal)
		assertNoActive(t, connLocalToRemote)
	})
	t.Run("testStreamCancel", func(t *testing.T) {
		defer timeout(5 * time.Second)()
		testStreamCancel(t, local, remote)
		assertNoActive(t, connRemoteLocal)

   * TimeoutException} wrapped in an {@link ExecutionException}) if the specified timeout expires.
   * If the timeout expires, not only will the output future finish, but also the input future
   * ({@code this}) will be cancelled and interrupted.
   *
   * @param timeout when to time out the future
   * @param scheduledExecutor The executor service to enforce the timeout.
   * @since 33.4.0 (but since 28.0 in the JRE flavor)
   */

  void awaitRunning();

  /**
   * Waits for the {@link Service} to reach the {@linkplain State#RUNNING running state} for no more
   * than the given time.
   *
   * @param timeout the maximum time to wait
   * @param unit the time unit of the timeout argument
   * @throws TimeoutException if the service has not reached the given state within the deadline

    protected boolean smbTcpNoDelay = false;
    /** Response timeout in milliseconds for SMB operations */
    protected int smbResponseTimeout = SmbConstants.DEFAULT_RESPONSE_TIMEOUT;
    /** Socket timeout in milliseconds for SMB connections */
    protected int smbSocketTimeout = SmbConstants.DEFAULT_SO_TIMEOUT;
    /** Connection timeout in milliseconds for establishing SMB connections */

- Kubeadm: fixed the bug where the v1beta4 Timeouts.EtcdAPICall field was not respected in etcd client operations, and the default timeout of 2 minutes was always used. ([#129862](https://github.com/kubernetes/kubernetes/pull/129862), [@neolit123](https://github.com/neolit123)) [SIG Cluster Lifecycle]