call.execute()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("timeout")
      assertThat(call.isCanceled()).isTrue()
    }
  }

  @Flaky
  @Test
  fun noTimeout() {
    // Flaky https://github.com/square/okhttp/issues/5304
    server.enqueue(
      MockResponse
        .Builder()
        .headersDelay(250, TimeUnit.MILLISECONDS)
        .body(BIG_ENOUGH_BODY)

        this.connectionTimeout = connectionTimeout;
    }

    /**
     * Sets the socket timeout.
     * @param soTimeout The socket timeout in milliseconds.
     */
    public void setSoTimeout(final Integer soTimeout) {
        this.soTimeout = soTimeout;
    }

    /**
     * Sets the map of authentication scheme providers.

        if (calledName == null) {
            this.calledName = address.hostName;
        } else {
            this.calledName = new Name(calledName, 0x20, null);
        }
        soTimeout = Config.getInt("jcifs.smb1.netbios.soTimeout", DEFAULT_SO_TIMEOUT);
        connect();
    }

    /**
     * Returns the NetBIOS address associated with this socket.
     *
     * @return the NetBIOS address
     */

                new RequestParam[] { RequestParam.NONE, RequestParam.NO_TIMEOUT, RequestParam.NO_RETRY, RequestParam.RETAIN_PAYLOAD },
                values, "values() order should match declaration order");
    }

    // Happy path: valueOf resolves each constant name; toString equals name; ordinal is stable
    @ParameterizedTest
    @ValueSource(strings = { "NONE", "NO_TIMEOUT", "NO_RETRY", "RETAIN_PAYLOAD" })

        // Arrange
        when(tree.send(eq(request), eq(RequestParam.NO_TIMEOUT), eq(RequestParam.NO_RETRY))).thenReturn(response);

        // Act
        CommonServerMessageBlockResponse out = tree.send(request, RequestParam.NO_TIMEOUT, RequestParam.NO_RETRY);

        // Assert
        assertSame(response, out);
        verify(tree).send(request, RequestParam.NO_TIMEOUT, RequestParam.NO_RETRY);
    }

    @Test

  @Throws(SocketException::class)
  override fun getSendBufferSize(): Int = delegate!!.sendBufferSize

  @Throws(SocketException::class)
  override fun getSoTimeout(): Int = delegate!!.soTimeout

  @Throws(SocketException::class)
  override fun getTcpNoDelay(): Boolean = delegate!!.tcpNoDelay

  @Throws(SocketException::class)
  override fun setKeepAlive(keepAlive: Boolean) {

        props.setProperty("jcifs.netbios.hostname", "testhost");
        props.setProperty("jcifs.netbios.scope", "");
        props.setProperty("jcifs.smb.client.connTimeout", "35000");
        props.setProperty("jcifs.smb.client.soTimeout", "35000");

        config = new PropertyConfiguration(props);
    }

    @Test
    @DisplayName("Should create configuration from Properties")
    void testConfigurationCreation() throws CIFSException {

    @Override
    public void init(final ServletConfig config) throws ServletException {
        super.init(config);

        /* Set jcifs.smb1 properties we know we want; soTimeout and cachePolicy to 10min.
         */
        Config.setProperty("jcifs.smb1.smb.client.soTimeout", "300000");
        Config.setProperty("jcifs.smb1.netbios.cachePolicy", "600");

        final Enumeration e = config.getInitParameterNames();
        String name;

 * @param source the source used to read bytes from the socket.
 */
internal fun Socket.isHealthy(source: BufferedSource): Boolean =
  try {
    val readTimeout = soTimeout
    try {
      soTimeout = 1
      !source.exhausted()
    } finally {
      soTimeout = readTimeout
    }
  } catch (_: SocketTimeoutException) {
    true // Read timed out; socket is good.
  } catch (_: IOException) {

    } 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()
  }