// Verify path length
        assertEquals(pathBytes.length, SMBUtil.readInt2(buffer, bodyOffset + 6));

        // Verify path content
        byte[] actualPath = new byte[pathBytes.length];
        System.arraycopy(buffer, bodyOffset + 8, actualPath, 0, pathBytes.length);
        assertArrayEquals(pathBytes, actualPath);
    }

    @Test

        System.arraycopy(testData, 0, buffer, 10, testData.length);

        int result = response.readDataWireFormat(buffer, 10, testData.length);

        assertEquals(testData.length, result);
        // Verify data was copied to outputBuffer
        byte[] expectedData = new byte[testData.length];
        System.arraycopy(outputBuffer, 0, expectedData, 0, testData.length);
        assertArrayEquals(testData, expectedData);
    }

        @DisplayName("Should handle various data lengths")
        void testVariousDataLengths(int length) throws SMBProtocolDecodingException {
            int result = testResponse.decode(testBuffer, 0, length);

            assertEquals(length, result);
            assertNotNull(testResponse.getData());
            assertEquals(length, testResponse.getData().length);
        }
    }

    @Nested

                offset += name.length;
            }

            // Write data if present
            if (data != null && data.length > 0) {
                System.arraycopy(data, 0, dst, offset, data.length);
                offset += data.length;
            }

            // Pad to 8-byte boundary
            while ((offset - dstIndex) % 8 != 0) {
                dst[offset++] = 0;
            }

        int length = testData.length;

        // Act
        signingDigest.sign(testData, offset, length, null, null);

        // Assert
        verify(signingDigest, times(1)).sign(testData, offset, length, null, null);
    }

    @Test
    @DisplayName("Test verify method with null message")
    void testVerifyWithNullMessage() {
        // Arrange
        int offset = 0;
        int length = testData.length;

        byte[] outputBuffer = new byte[testData.length + 100];
        int writtenBytes =
                compressionService.decompress(compressed, 0, compressed.length, outputBuffer, 50, CompressionService.COMPRESSION_LZ77);

        assertEquals(testData.length, writtenBytes);

        byte[] extracted = new byte[testData.length];
        System.arraycopy(outputBuffer, 50, extracted, 0, testData.length);

        assertFalse(result.isEmpty());
        assertEquals(size * 2, result.length()); // Each byte becomes 2 hex chars
    }

    @Test
    @DisplayName("Should format with specific offset and length")
    void testHexdumpWithOffsetAndLength() {
        // Given
        byte[] data = createTestData(64);
        int offset = 16;
        int length = 32;

        // When

        }
        if (isDirect) {
            out.writeDirect(buf, off, length, 1);
            return;
        }
        out.write(buf, off, length);
    }

    @Override
    protected void doReceiveFragment(final byte[] buf, final boolean isDirect) throws IOException {
        int off, flags, length;

        if (buf.length < max_recv) {
            throw new IllegalArgumentException("buffer too small");
        }

    void testReadLengthMaximum() {
        byte[] src = { (byte) 0x00, (byte) 0x01, (byte) 0xFF, (byte) 0xFF };
        int length = SessionServicePacket.readLength(src, 0);

        assertEquals(0x01FFFF, length);
    }

    @Test
    @DisplayName("readLength should handle zero length")
    void testReadLengthZero() {
        byte[] src = { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 };

        // Skip 8 bytes for RootDirectory (8-15)
        SMBUtil.writeInt4(nameBytes.length, buffer, 16);
        System.arraycopy(nameBytes, 0, buffer, 20, nameBytes.length);

        FileRenameInformation2 info = new FileRenameInformation2();
        int bytesRead = info.decode(buffer, 0, buffer.length);

        assertEquals(20 + nameBytes.length, bytesRead);
    }

    @Test