// When
        int bytesWritten = request.writeBytesWireFormat(buffer, 0);

        // Then
        assertTrue(bytesWritten > 0);

        // Verify negotiate context offset/count area is zeroed
        assertEquals(0, SMBUtil.readInt8(buffer, 28));
    }

    @Test
    @DisplayName("Should read empty bytes from wire format")
    void testReadBytesWireFormat() {
        // Given

        assertEquals((byte) 0x53, aad[2]);
        assertEquals((byte) 0xFD, aad[3]);

        // Verify signature is zeroed out (16 bytes of zeros)
        for (int i = 4; i < 20; i++) {
            assertEquals(0, aad[i], "Signature bytes should be zero in AAD");
        }

        // Verify nonce matches at position 20
        for (int i = 0; i < 16; i++) {

        @Test
        @DisplayName("Should handle source key with all zeros")
        void testSourceKeyAllZeros() {
            // Given
            byte[] zeroKey = new byte[SOURCE_KEY_SIZE]; // All zeros by default
            SrvCopychunk chunk = new SrvCopychunk(1, 2, 3);
            SrvCopychunkCopy copy = new SrvCopychunkCopy(zeroKey, chunk);
            byte[] buffer = new byte[100];

            // When

        messageBlock.setMid(minMid);
        assertEquals(minMid, messageBlock.getMid());

        // Test with zero
        long zeroMid = 0L;
        doNothing().when(messageBlock).setMid(zeroMid);
        when(messageBlock.getMid()).thenReturn(zeroMid);

        messageBlock.setMid(zeroMid);
        assertEquals(zeroMid, messageBlock.getMid());
    }

    @Test
    @DisplayName("Test setCommand and getCommand methods")

        assertEquals(0, response.getCapabilities(), "Capabilities should be zero");
        assertArrayEquals(new byte[16], response.getServerGuid(), "Server GUID should be all zeros");
        assertEquals(0, response.getSecurityMode(), "Security mode should be zero");
        assertEquals(0, response.getDialect(), "Dialect should be zero");
    }

    @Test
    @DisplayName("Test decode with maximum values")

            lock = new Smb2Lock(999L, 888L, 0xFF);

            // Fill buffer with non-zero values
            Arrays.fill(buffer, (byte) 0xFF);

            lock.encode(buffer, 0);

            // Reserved field bytes are not modified by the encode method
            // The implementation just skips these bytes without writing zeros
            assertEquals(-1, SMBUtil.readInt4(buffer, 20));
        }
    }

    }

    @Test
    @DisplayName("Should handle null file ID gracefully")
    void testNullFileId() {
        // Given
        byte[] nullFileId = new byte[16]; // All zeros
        Configuration config = mock(Configuration.class);
        when(config.getNotifyBufferSize()).thenReturn(8192);

        // When

        SMBUtil.writeInt4(104, buffer, 8); // NextEntryOffset to second entry
        SMBUtil.writeInt4(0, buffer, 12); // FileIndex
        // ... rest of first entry fields (zeros for simplicity)
        for (int i = 16; i < 102; i++) {
            buffer[i] = 0;
        }
        SMBUtil.writeInt4(8, buffer, 68); // FileNameLength at offset 60 from start

            assertEquals((byte) 0xFF, dst[i]);
        }

        // Test with zero
        SMBUtil.writeInt8(0L, dst, 16);
        for (int i = 16; i < 24; i++) {
            assertEquals((byte) 0x00, dst[i]);
        }
    }

    @Test
    void testReadTime() {
        byte[] src = new byte[16];

        // Test with zero time
        SMBUtil.writeInt8(0L, src, 0);

        trans2SetFileInfo = new Trans2SetFileInformation(config, TEST_FID, mockFileInfo);

        byte[] buffer = new byte[512];
        // Fill buffer with non-zero values to ensure padding writes zeros
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = (byte) 0xFF;
        }

        int written = trans2SetFileInfo.writeDataWireFormat(buffer, 0);