/** Whether to use TCP_NODELAY */
    boolean TCP_NODELAY = Config.getBoolean("jcifs.smb1.smb.client.tcpNoDelay", false);
    /** Response timeout in milliseconds */
    int RESPONSE_TIMEOUT = Config.getInt("jcifs.smb1.smb.client.responseTimeout", DEFAULT_RESPONSE_TIMEOUT);

    /** List of active connections */
    LinkedList CONNECTIONS = new LinkedList();

    /** Session limit */

        Properties props = new Properties();
        props.setProperty("jcifs.smb.client.connTimeout", "30000");
        props.setProperty("jcifs.smb.client.soTimeout", "35000");
        props.setProperty("jcifs.smb.client.responseTimeout", "30000");

        // When
        PropertyConfiguration testConfig = new PropertyConfiguration(props);

        // Then
        assertEquals(30000, testConfig.getConnTimeout());

        int responseTimeout = delegatingConfig.getResponseTimeout();
        int socketTimeout = delegatingConfig.getSoTimeout();
        int connTimeout = delegatingConfig.getConnTimeout();
        int maxMpx = delegatingConfig.getMaxMpxCount();

        // Then
        assertEquals(300L, dfsTtl, "Should delegate DFS TTL");
        assertEquals(30000, responseTimeout, "Should delegate response timeout");

    val inputStream = connection.getInputStream()
    try {
      inputStream.read()
      fail<Any>()
    } catch (expected: IOException) {
    }
  }

  @Test
  fun responseTimeout() {
    server.enqueue(
      MockResponse()
        .setBody("ABC")
        .clearHeaders()
        .addHeader("Content-Length: 4"),
    )
    server.enqueue(MockResponse().setBody("DEF"))

     */

    byte command, flags;
    int headerStart, length, batchLevel, errorCode, flags2, tid, pid, uid, mid, wordCount, byteCount;
    boolean useUnicode, received, extendedSecurity;
    long responseTimeout = 1;
    int signSeq;
    boolean verifyFailed;
    NtlmPasswordAuthentication auth = null;
    String path;
    SigningDigest digest = null;
    ServerMessageBlock response;

    try {
      connection.getInputStream().read()
      fail<Unit>()
    } catch (expected: IOException) {
      // Expected.
    }
  }

  @Test
  fun responseTimeout() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("ABC")
        .clearHeaders()
        .addHeader("Content-Length: 4")
        .build(),
    )
    server.enqueue(

     *
     *
     * @return timeout for SMB sessions, in milliseconds
     */
    int getSessionTimeout();

    /**
     *
     * Property {@code jcifs.smb.client.responseTimeout} (int, default 30000)
     *
     * @return timeout for SMB responses, in milliseconds
     */
    int getResponseTimeout();

    /**
     *
     * Property {@code jcifs.smb.client.lport} (int)

    }

    boolean hasCapability(final int cap) throws SmbException {
        try {
            connect(RESPONSE_TIMEOUT);
        } catch (final IOException ioe) {
            throw new SmbException(ioe.getMessage(), ioe);
        }
        return (capabilities & cap) == cap;
    }