}
    }

    @Nested
    @DisplayName("Chain Tests")
    class ChainTests {

        @Test
        @DisplayName("Should chain messages successfully")
        void testChain() {
            TestServerMessageBlock2 nextMessage = new TestServerMessageBlock2(mockConfig);
            assertTrue(testMessage.chain(nextMessage));
            assertEquals(nextMessage, testMessage.getNext());

HTTP/1 [Response.Body] now automatically drains any unread content upon being
closed, up to a conservative limit, to allow better connection reuse. For most
programs, this change should be a no-op, or result in a performance improvement.
In rare cases, programs that do not benefit from connection reuse might
experience performance degradation if they had been improperly allowing an
excessive amount of idle connections to linger; usually by setting

    /**
     * Combine this referral with another to form a chain
     *
     * @param next the referral to combine with
     * @return new referral, combining a chain of referrals
     */
    DfsReferralDataInternal combine(DfsReferralData next);

    /**
     * Append another referral to this referral chain
     *
     * @param dr the referral to append
     */

OdHOim9+
-----END PRIVATE KEY-----
```

Recommendations
---------------

Typically servers need a held certificate plus a chain of intermediates. Servers only need the
private key for their own certificate. The chain served by a server doesn't need the root
certificate.

The trusted roots don't need to be the same for client and server when using client authentication.

        // pool, which should remain clean for subsequent tests.
        .connectionPool(ConnectionPool())
        .addNetworkInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            val response =
              chain!!.proceed(
                chain.request(),
              )
            responsesNotClosed.add(response)
            response
              .newBuilder()

        assertNull(exception.getCause());
    }

    @Test
    public void test_constructorWithThrowableCause_ChainedErrorsAndExceptions() {
        // Test with chain containing both Errors and Exceptions
        String message = "SSO login complex error chain";
        IllegalStateException innerException = new IllegalStateException("Bad state");
        AssertionError middleError = new AssertionError("Assertion failed", innerException);

DX, R14 // r4 += a4×b0 MOVQ 32(CX), AX MULQ (BX) ADDQ AX, R15 ADCQ DX, R14 // First reduction chain MOVQ $0x0007ffffffffffff, AX SHLQ $0x0d, DI, SI SHLQ $0x0d, R9, R8 SHLQ $0x0d, R11, R10 SHLQ $0x0d, R13, R12 SHLQ $0x0d, R15, R14 ANDQ AX, DI IMUL3Q $0x13, R14, R14 ADDQ R14, DI ANDQ AX, R9 ADDQ SI, R9 ANDQ AX, R11 ADDQ R8, R11 ANDQ AX, R13 ADDQ R10, R13 ANDQ AX, R15 ADDQ R12, R15 // Second reduction chain (carryPropagate) MOVQ DI, SI SHRQ $0x33, SI MOVQ R9, R8 SHRQ $0x33, R8 MOVQ R11, R10 SHRQ $0x33,...

    if (canceled) {
      stream!!.closeLater(ErrorCode.CANCEL)
      throw IOException("Canceled")
    }
    stream!!.readTimeout().timeout(chain.readTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
    stream!!.writeTimeout().timeout(chain.writeTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
  }

  override fun flushRequest() {
    http2Connection.flush()
  }

  override fun finishRequest() {

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#chain(jcifs.internal.smb2.ServerMessageBlock2)
     */
    @Override
    public boolean chain(final ServerMessageBlock2 n) {
        n.setSessionId(Smb2Constants.UNSPECIFIED_SESSIONID);
        return super.chain(n);
    }

    /**
     * {@inheritDoc}
     *

	public abstract fun withCache (Lokhttp3/Cache;)Lokhttp3/Interceptor$Chain;
	public abstract fun withCertificatePinner (Lokhttp3/CertificatePinner;)Lokhttp3/Interceptor$Chain;
	public abstract fun withConnectTimeout (ILjava/util/concurrent/TimeUnit;)Lokhttp3/Interceptor$Chain;
	public abstract fun withConnectionPool (Lokhttp3/ConnectionPool;)Lokhttp3/Interceptor$Chain;