byte[] buffer = new byte[request.size()];
        request.encode(buffer, 0);

        // Verify max capabilities value (comparing as unsigned long)
        assertEquals(0xFFFFFFFFL, SMBUtil.readInt4(buffer, 0) & 0xFFFFFFFFL);
    }

    @Test
    @DisplayName("Test encode with zero capabilities")
    void testEncodeWithZeroCapabilities() {

        SMBUtil.writeInt2(TransPeekNamedPipeResponse.STATUS_CONNECTION_OK, buffer, 4);

        response.readParametersWireFormat(buffer, 0, 6);
        assertEquals(0, response.getAvailable());

        // Test maximum unsigned 16-bit value (65535)
        SMBUtil.writeInt2(0xFFFF, buffer, 0);
        TransPeekNamedPipeResponse response2 = new TransPeekNamedPipeResponse(mockConfig);
        response2.readParametersWireFormat(buffer, 0, 6);

        @Test
        @DisplayName("Should handle signed/unsigned integer boundaries")
        void shouldHandleSignedUnsignedBoundaries() {
            // Test that GENERIC_READ is the highest bit (0x80000000)
            assertEquals(0x80000000, ACE.GENERIC_READ, "GENERIC_READ should be 0x80000000");
            assertTrue(ACE.GENERIC_READ < 0, "GENERIC_READ should be negative when treated as signed int");

        assertEquals(123456789, serverData.sessionKey);
        assertEquals(SmbConstants.CAP_UNICODE | SmbConstants.CAP_NT_SMBS, serverData.capabilities);
        // readInt2 returns unsigned value, so -480 becomes 65056
        assertEquals(65056, serverData.serverTimeZone);
        assertEquals(8, serverData.encryptionKeyLength);
    }

    @Test
    void testReadParameterWordsWireFormat_InvalidDialect() {

            byte[] buffer = new byte[256];
            int bytesWritten = request.writeBytesWireFormat(buffer, 0);

            // Negative value should be written as-is (interpreted as unsigned by receiver)
            assertEquals(-1L, SMBUtil.readInt8(buffer, 8));
        }

        @Test
        @DisplayName("Should handle zero-length file ID")
        void testZeroLengthFileId() {

        assertEquals(80, bytesRead);
        assertEquals(0, response.getDataLength());
        assertEquals(0, response.getDataRemaining());
    }

    @Test
    @DisplayName("Should handle data offset byte as unsigned")
    void testReadBytesWireFormatUnsignedDataOffset() throws Exception {
        // Given
        byte[] buffer = new byte[256];
        int bodyStart = 0;
        int dataLength = 5;

            int bytesWritten = copy.encode(buffer, 0);

            // Then
            assertEquals(HEADER_SIZE + CHUNK_SIZE, bytesWritten);

            // Negative values should be encoded as their unsigned representation
            int chunkStart = HEADER_SIZE;
            assertEquals(-1L, SMBUtil.readInt8(buffer, chunkStart));
            assertEquals(-100L, SMBUtil.readInt8(buffer, chunkStart + 8));

    class SignatureTests {

        @Test
        @DisplayName("Should detect signed packet")
        void testIsSigned() {
            response.setFlagsForTest(ServerMessageBlock2.SMB2_FLAGS_SIGNED);

            assertTrue(response.isSigned());
        }

        @Test
        @DisplayName("Should detect unsigned packet")
        void testIsNotSigned() {
            response.setFlagsForTest(0);

            assertEquals(0, response.getChunkBytesWritten());
            assertEquals(0, response.getTotalBytesWritten());
        }

        @Test
        @DisplayName("Should handle negative values as unsigned")
        void testDecodeNegativeValuesAsUnsigned() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[12];
            SMBUtil.writeInt4(-1, buffer, 0); // chunksWritten

        @Test
        @DisplayName("Should handle negative values in buffer")
        void shouldHandleNegativeValuesInBuffer() throws SMBProtocolDecodingException {
            // Given - negative values (treated as unsigned in protocol)
            ByteBuffer buffer = ByteBuffer.allocate(24);
            buffer.order(ByteOrder.LITTLE_ENDIAN);
            buffer.putLong(-1L);
            buffer.putLong(-1L);
            buffer.putInt(-1);