}

        // Next get should return the same instance from cache
        byte[] reused = impl.getBuffer();
        assertSame(b, reused, "Buffer should be reused from cache");
        // And it should still be zeroed
        for (byte value : reused) {
            assertEquals(0, value, "Reused buffer must be zeroed");
        }
    }

The wrapper will handle all serialization and de-serialization of the request and response,
and furthermore provides reuse of the structs used for the request and response.

Note that Responses sent for serialization are automatically reused for similar requests.
If the response contains shared data it will cause issues, since each unique response is reused.
To disable this behavior, use `(SingleHandler).WithSharedResponse()` to disable it.

 * buckets for the key and the value. This allows reuse in {@link RegularImmutableMap} and {@link
 * RegularImmutableBiMap}, which don't have to recopy the entries created by their {@code Builder}
 * implementations.
 *
 * <p>This base implementation has no key or value pointers, so instances of ImmutableMapEntry (but
 * not its subclasses) can be reused when copied from one ImmutableMap to another.
 *
 * @author Louis Wasserman

        byte[] buffer2 = BufferCache.getBuffer();

        // Then - Buffer should be valid
        assertNotNull(buffer2, "Reused buffer should not be null");
        assertEquals(SmbComTransaction.TRANSACTION_BUF_SIZE, buffer2.length, "Reused buffer should have correct size");

        // Note: We don't check if content is cleared as that's not a security requirement

Since HTTP requests frequently happen in parallel, connection pooling must be thread-safe.

These are the primary classes involved with establishing, sharing, and terminating connections:

     */
    int getInitialCredits();

    /**
     * Checks whether a connection can be reused for the given configuration.
     *
     * @param tc the CIFS context to check compatibility with
     * @param forceSigning whether signing is being forced
     * @return whether a connection can be reused for this config
     */
    boolean canReuse(CIFSContext tc, boolean forceSigning);

const (
	// minBufferSize is the minimum buffer size.
	// Buffers below this is not reused.
	minBufferSize = 1 << 10

	// defaultBufferSize is the default buffer allocation size.
	defaultBufferSize = 4 << 10

	// maxBufferSize is the maximum buffer size.
	// Buffers larger than this is not reused.
	maxBufferSize = 96 << 10

	// This is the assumed size of bigger buffers and allocation size.

import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Denotes that a bean should be created as a singleton instance.
 * <p>
 * Singleton-scoped beans are instantiated once and reused throughout the entire
 * Maven execution. This scope should be used for stateless services or components
 * that can be safely shared across the entire build process.
 * <p>
 * Example usage:
 * <pre>
 * {@literal @}Singleton

 * request body start and end events occur within the response header events. Similarly,
 * [duplex calls][RequestBody.isDuplex] interleave the request and response bodies.
 *
 * Since connections may be reused, the proxy selection, DNS, and connect events may not be present
 * for a call. In future releases of OkHttp these events may also occur concurrently to permit
 * multiple routes to be attempted simultaneously.
 *

   * due to any of:
   *
   *  * A stale connection. The request was made on a reused connection and that reused connection
   *    has since been closed by the server.
   *  * A client timeout (HTTP 408).
   *  * A authorization challenge (HTTP 401 and 407) that is satisfied by the [Authenticator].
   *  * A retryable server failure (HTTP 503 with a `Retry-After: 0` response header).