int bytesRead = response.readBytesWireFormat(buffer, 0);

            assertEquals(16, bytesRead);
            assertEquals(-1, response.getCount()); // -1 as signed int represents max unsigned value
            assertEquals(-2, response.getRemaining());
        }

        private byte[] createValidWriteResponse(int count, int remaining) {
            byte[] buffer = new byte[64];

        void testEncodeVariousCipherCounts(int cipherCount) {
            int[] ciphers = new int[cipherCount];
            for (int i = 0; i < cipherCount; i++) {
                ciphers[i] = i + 1;
            }
            EncryptionNegotiateContext context = new EncryptionNegotiateContext(mockConfig, ciphers);

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

    @DisplayName("Test decode with aligned next entry offsets")
    @ValueSource(ints = { 0, 4, 8, 16, 32, 64, 128, 256, 1024 })
    void testDecodeWithAlignedOffsets(int nextOffset) throws SMBProtocolDecodingException {
        byte[] buffer = createNotificationBufferWithNextOffset("aligned.txt", FileNotifyInformation.FILE_ACTION_ADDED, nextOffset);

        int bytesRead = notifyInfo.decode(buffer, 0, buffer.length);

    @ParameterizedTest
    @DisplayName("hasCapability returns expected values for various caps")
    @ValueSource(ints = { -1, 0, 1, 1024 })
    void hasCapability_variousCaps(int cap) throws SmbException {
        when(transport.hasCapability(anyInt())).thenAnswer(inv -> ((int) inv.getArgument(0)) >= 0);

        boolean result = transport.hasCapability(cap);

        assertEquals(cap >= 0, result);

            assertEquals(expectedSize, request.size());
        }

        @ParameterizedTest
        @DisplayName("Should calculate size for various data lengths")
        @ValueSource(ints = { 0, 1, 7, 8, 100, 512, 1024, 4096, 65536 })
        void testSizeWithVariousDataLengths(int dataLength) {

        assertEquals(response.getTreeId(), response.getTid());
    }

    /**
     * Helper method to create a valid response buffer
     */
    private byte[] createValidResponseBuffer(int shareType, int shareFlags, int capabilities, int maxAccess) {
        byte[] buffer = new byte[256];
        SMBUtil.writeInt2(16, buffer, 0);
        buffer[2] = (byte) shareType;
        buffer[3] = 0;

    private static final int FILE_NOTIFY_CHANGE_EA = 0x00000080;
    private static final int FILE_NOTIFY_CHANGE_SECURITY = 0x00000100;
    private static final int FILE_NOTIFY_CHANGE_STREAM_NAME = 0x00000200;
    private static final int FILE_NOTIFY_CHANGE_STREAM_SIZE = 0x00000400;
    private static final int FILE_NOTIFY_CHANGE_STREAM_WRITE = 0x00000800;

                "1000, 4096, 4096000" })
        void testDecodeCombinations(int chunks, int chunkBytes, int totalBytes) throws SMBProtocolDecodingException {
            byte[] buffer = createValidCopyChunkResponse(chunks, chunkBytes, totalBytes);

            int bytesDecoded = response.decode(buffer, 0, buffer.length);

            assertEquals(12, bytesDecoded);

        @ValueSource(ints = { 0, 1, 2, 5, 10 })
        void testEncodeWithDifferentCipherCounts(int count) {
            int[] ciphers = new int[count];
            for (int i = 0; i < count; i++) {
                ciphers[i] = i + 1;
            }

            context = new EncryptionNegotiateContext(mockConfig, ciphers);
            int encoded = context.encode(buffer, 0);

        // Given
        byte[] buffer = new byte[256];
        int offset = 10;

        // When
        int bytesWritten = response.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(0, bytesWritten);
    }

    @DisplayName("Should write zero bytes at various offsets")
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 10, 50, 100, 255 })