pkg net/http, type Transport struct, MaxResponseHeaderBytes int64
pkg net/http, var ErrUseLastResponse error
pkg net/http, var LocalAddrContextKey *contextKey
pkg net/http, var ServerContextKey *contextKey
pkg net/http/cgi, type Handler struct, Stderr io.Writer
pkg net/http/httptest, func NewRequest(string, string, io.Reader) *http.Request
pkg net/http/httptest, method (*ResponseRecorder) Result() *http.Response

```java
/** This interceptor compresses the HTTP request body. Many webservers can't handle this! */
final class GzipRequestInterceptor implements Interceptor {
  @Override public Response intercept(Interceptor.Chain chain) throws IOException {
    Request originalRequest = chain.request();

 *
 * <p>This class uses various utilities such as ReadingConverter, Normalizer, and SuggestAnalyzer
 * to process and analyze the input data.</p>
 *
 * <p>It also handles the exclusion of search words based on certain criteria and manages the
 * maximum length of analyzed content.</p>
 *
 * <p>Methods in this class may throw SuggesterException in case of failures during the parsing process.</p>
 *

        rpc.policy_handle mockHandle = mock(rpc.policy_handle.class);
        lsarpc.LsarClose lsarClose = new lsarpc.LsarClose(mockHandle);

        assertEquals(mockHandle, lsarClose.handle);
        assertEquals(0x00, lsarClose.getOpnum());
    }

    @Test
    void testLsarCloseEncodeIn() throws NdrException {
        rpc.policy_handle mockHandle = mock(rpc.policy_handle.class);

    val out = Buffer()
    Http2Writer(out, true).windowUpdate(expectedStreamId, windowSizeIncrement)
    return out
  }

  private fun assertHeaderBlock(): Http2Reader.Handler =
    object : BaseTestHandler() {
      override fun headers(
        inFinished: Boolean,
        streamId: Int,
        associatedStreamId: Int,
        headerBlock: List<Header>,
      ) {

    /**
     * Following the contract of {@link AbstractQueuedSynchronizer} we create a private subclass to
     * hold the synchronizer. This synchronizer is used to implement the blocking and waiting calls
     * as well as to handle state changes in a thread-safe manner. The current state of the future
     * is held in the Sync state, and the lock is released whenever the state changes to {@link
     * #COMPLETED}, {@link #CANCELLED}, or {@link #INTERRUPTED}

        assertEquals(0x00, dst[13]);

        // Check security information
        assertEquals(0x12345678, SMBUtil.readInt4(dst, 14));
    }

    @Test
    @DisplayName("Test with negative FID value (should handle as unsigned)")
    void testNegativeFidValue() {
        int fid = -1; // Will be treated as 0xFFFF in unsigned 16-bit
        querySecurityDesc = new NtTransQuerySecurityDesc(mockConfig, fid, OWNER_SECURITY_INFORMATION);

// toAPIErrorCode - Converts embedded errors. Convenience
// function written to handle all cases where we have known types of
// errors returned by underlying layers.
func toAPIErrorCode(ctx context.Context, err error) (apiErr APIErrorCode) {
	if err == nil {
		return ErrNone
	}

	// Errors that are generated by net.Conn and any context errors must be handled here.

X25519MLKEM768 by default. The default can be reverted using the
[`tlsmlkem` setting](/pkg/crypto/tls/#Config.CurvePreferences).
This can be useful when dealing with buggy TLS servers that do not handle large records correctly,
causing a timeout during the handshake (see [TLS post-quantum TL;DR fail](https://tldr.fail/)).
Go 1.24 also removed X25519Kyber768Draft00 and the Go 1.23 `tlskyber` setting.

        DataStoreFactory testFactory = new DataStoreFactory() {
            @Override
            protected List<String> loadDataStoreNameList() {
                // Will handle exception and log warning
                return super.loadDataStoreNameList();
            }
        };

        List<String> names = testFactory.loadDataStoreNameList();
        assertNotNull(names);