auth1.equals(auth2);
        }
    }

    /**
     * Test that password comparison is constant-time by comparing execution times
     * for passwords that differ at different positions.
     */
    @Test
    public void testConstantTimePasswordComparison() throws Exception {
        char[] basePassword = "supersecretpassword123456789".toCharArray();

        this.totalReleased = new AtomicLong();
        
        // Pre-allocate buffer pool
        initializeBufferPool();
    }
    
    private void initializeBufferPool() {
        // Allocate send buffers
        for (int i = 0; i < initialSendBuffers; i++) {
            try {
                ByteBuffer buffer = ByteBuffer.allocateDirect(sendBufferSize);
                RdmaMemoryRegion region = provider.registerMemory(buffer,

 * information for authenticating with an SMB1 server.
 *
 * <p>
 * It provides methods to set and retrieve the server address, port, username,
 * password, and domain. Additionally, it offers a method to construct a path
 * prefix for SMB1 URLs based on the configured server and port.
 * </p>
 *
 * <p>
 * The path prefix is in the format "smb1://server:port/", where the port is

        // Subsequent get should still work
        assertEquals(4, impl.getBuffer().length);
    }

    // Capacity behavior: when full, additional releases are dropped; only cached buffers are returned
    @Test
    @DisplayName("Cache capacity respected: extra releases dropped; retrieval order by first free slot")
    void cacheCapacityAndRetrievalOrder() {

            // Encode to different buffers
            int result1 = request.encode(buffer1, 0);
            int result2 = request.encode(buffer2, 50);

            // Both should succeed independently
            assertTrue(result1 > 0);
            assertTrue(result2 > 0);

            // Verify headers in both buffers
            for (int i = 0; i < 8; i++) {

     *             If the underlying constructor represents an abstract class
     * @throws IllegalAccessRuntimeException
     *             If the number of actual and formal parameters differ, if unwrapping of primitive arguments fails,
     *             or if after unwrapping, the parameter values cannot be converted to the corresponding formal parameter types,

        byte[] b = new byte[] { 10, 11, 12 };
        spyTarget.send(b, 1, 2);
        verify(out).writeDirect(b, 1, 2, 1);
    }

    @Test
    @DisplayName("sendrecv with null buffers throws relevant exceptions")
    void testSendRecvInvalidInputs() throws CIFSException {
        // Null out buffer for SMB2 path -> expect NPE when building request
        when(pipe.ensureTreeConnected()).thenReturn(tree);

            assertNotNull(hash2);
            assertEquals(64, hash2.length);
            assertNotEquals(new String(hash1), new String(hash2), "Chained hash should differ");
        }

        @Test
        @DisplayName("createEncryptionContext rejects when SMB2/3 not negotiated")
        void createEncryptionContext_rejects_noNegotiation() {

- **SMB 3.1.1**: Windows 10/Server 2016+ (0x0311) - AES-128-GCM + Pre-Auth Integrity

**Protocol Selection:**
- Default Range: SMB1 to SMB 3.1.1
- Automatic Negotiation: Client offers all supported dialects, server selects highest common version
- Configurable: Min/max versions can be set via configuration properties

### SMB3 Encryption Support
- **SMB2 Transform Header**: Encrypted message wrapping

    }

    @Test
    @DisplayName("Methods should handle null buffer without validation")
    void testMethodsWithNullBuffer() {
        // The implementation doesn't validate null buffers
        // These methods simply return 0 without accessing the buffer

        // Write methods return 0 without accessing null buffer
        assertEquals(0, response.writeSetupWireFormat(null, 0));