System.arraycopy(buffer, bodyOffset + 8, actualPath, 0, pathBytes.length);
        assertArrayEquals(pathBytes, actualPath);
    }

    @Test
    @DisplayName("Should handle chain operation correctly")
    void testChain() {
        // Given
        ServerMessageBlock2 nextMessage = mock(ServerMessageBlock2.class);

        // When
        boolean result = request.chain(nextMessage);

        assertNull(transPeekNamedPipe.name);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, -1, Integer.MAX_VALUE, Integer.MIN_VALUE, 0xFFFF })
    @DisplayName("Constructor should handle various FID values")
    void testConstructorWithVariousFids(int fid) {
        // Act
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, fid);

        // Assert

Some of the options you could use as a TLS Termination Proxy are:

* Traefik (that can also handle certificate renewals)
* Caddy (that can also handle certificate renewals)
* Nginx
* HAProxy

## Let's Encrypt { #lets-encrypt }

Before Let's Encrypt, these **HTTPS certificates** were sold by trusted third parties.

        // Then
        assertNotNull(exception);
        assertEquals(message, exception.getMessage());
        assertEquals(cause, exception.getCause());
    }

    @Test
    @DisplayName("Should handle null message gracefully")
    void testNullMessage() {
        // When/Then
        assertDoesNotThrow(() -> {
            RuntimeCIFSException exception = new RuntimeCIFSException((String) null);

    }

    /**
     * Gets the context handle returned by the server.
     *
     * @return the context handle
     */
    public byte[] getContextHandle() {
        return contextHandle != null ? contextHandle.clone() : null;
    }

    /**
     * Sets the context handle.
     *
     * @param contextHandle the context handle
     */
    public void setContextHandle(byte[] contextHandle) {

        assertEquals(0xDE, buffer[1] & 0xFF);
        assertEquals(0xBC, buffer[2] & 0xFF);
        assertEquals(0x9A, buffer[3] & 0xFF);
    }

    @Test
    @DisplayName("Should handle big endian encoding/decoding")
    void testBigEndianOperations() {
        // Given
        int value = 0x12345678;
        byte[] buffer = new byte[4];

        // When - encode big endian

        // Just verify that contexts were written
        assertTrue(bytesWritten > 60); // Should be larger than basic negotiate request
    }

    @Test
    @DisplayName("Should handle empty negotiate contexts array")
    void testWriteBytesWireFormatEmptyContexts() {
        // Given
        when(mockConfig.getMaximumVersion()).thenReturn(DialectVersion.SMB302);

            assertEquals(expectedFlags, flags);
        }

        @Test
        @DisplayName("getDefaultFlags should handle Type1Message with request target")
        void testGetDefaultFlags_CIFSContext_Type1Message_Unicode_RequestTarget_DomainPresent() {
            // Given
            CIFSContext mockContext = createMockContext();

        default:
            return "Check resource availability and retry";
        }
    }

    /**
     * Static factory for file handle exhaustion
     */
    public static SmbResourceException fileHandleExhausted(int errorCode) {
        return new SmbResourceException("File handle limit exceeded", errorCode, ResourceType.FILE_HANDLE);
    }

    /**
     * Static factory for connection pool exhaustion
     */

            assertThrows(NullPointerException.class, () -> {
                buffer.size();
            });
        }

        @ParameterizedTest
        @DisplayName("Should handle various referral levels")
        @ValueSource(ints = { 0, 1, 2, 3, 4, 5, 255, 256, 32767, 65535 })
        void testConstructorWithVariousReferralLevels(int maxReferralLevel) {
            String path = "\\\\test";