byte[] smallBuffer = new byte[24];
            lock = new Smb2Lock(100L, 200L, 1);

            int encoded = lock.encode(smallBuffer, 0);

            assertEquals(24, encoded);
            assertEquals(100L, SMBUtil.readInt8(smallBuffer, 0));
            assertEquals(200L, SMBUtil.readInt8(smallBuffer, 8));
            assertEquals(1, SMBUtil.readInt4(smallBuffer, 16));
        }

    void testBufferBounds() {
        // Given
        byte[] smallBuffer = new byte[2];

        // When/Then
        assertThrows(IndexOutOfBoundsException.class, () -> {
            Encdec.enc_uint32le(0x12345678, smallBuffer, 0);
        });

        assertThrows(IndexOutOfBoundsException.class, () -> {
            Encdec.dec_uint32le(smallBuffer, 0);
        });
    }

    @Test

        byte[] smallBuffer = new byte[1];
        byte[] largeBuffer = new byte[1000];

        // Act & Assert
        assertEquals(0, transPeekNamedPipe.readSetupWireFormat(smallBuffer, 0, 1));
        assertEquals(0, transPeekNamedPipe.readSetupWireFormat(largeBuffer, 500, 500));
        assertEquals(0, transPeekNamedPipe.readParametersWireFormat(smallBuffer, 0, 1));

    void testBoundaryConditions() {
        byte[] smallBuffer = new byte[10];

        // Test with maximum offset
        int result = response.writeSetupWireFormat(smallBuffer, Integer.MAX_VALUE);
        assertEquals(0, result);

        result = response.readSetupWireFormat(smallBuffer, Integer.MAX_VALUE, 0);
        assertEquals(0, result);

        // Given
        byte[] smallBuffer = new byte[100];
        int bodyStart = 0;
        int dataLength = 50;
        int dataOffsetValue = 80; // Data would extend beyond buffer

        // Write structure
        SMBUtil.writeInt2(17, smallBuffer, bodyStart);
        smallBuffer[bodyStart + 2] = (byte) dataOffsetValue;
        SMBUtil.writeInt4(dataLength, smallBuffer, bodyStart + 4);

    }

    @Test
    @DisplayName("Test invalid buffer size for decoding")
    public void testInvalidBufferSize() {
        byte[] smallBuffer = new byte[4]; // Too small

        assertThrows(SMBProtocolDecodingException.class, () -> {
            context.decode(smallBuffer, 0, smallBuffer.length);
        });
    }

    @Test
    @DisplayName("Test algorithm name resolution")
    public void testAlgorithmNames() {

    @DisplayName("Test buffer overflow protection")
    void testBufferOverflowProtection() {
        byte[] smallBuffer = new byte[23]; // One byte too small

        // Should throw ArrayIndexOutOfBoundsException
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
            request.writeBytesWireFormat(smallBuffer, 0);
        });
    }

    @Test
    @DisplayName("Test file ID boundary values")

        int offset = 50;

        byte[] smallBuffer = createValidNotificationBuffer(fileName, action);
        byte[] buffer = new byte[smallBuffer.length + offset + 50];
        System.arraycopy(smallBuffer, 0, buffer, offset, smallBuffer.length);

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

        assertTrue(bytesRead > 0);

        byte[] compressed = compressionService.compress(testData, CompressionService.COMPRESSION_LZ77);
        byte[] smallBuffer = new byte[10]; // Too small

        assertThrows(CIFSException.class, () -> {
            compressionService.decompress(compressed, 0, compressed.length, smallBuffer, 0, CompressionService.COMPRESSION_LZ77);
        });
    }

    /**

    void testWithDifferentBufferSizes() {
        // Test with buffers of different sizes
        byte[] smallBuffer = new byte[] { 0x01 };
        byte[] mediumBuffer = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05 };

        SmbNegotiation negotiationDifferentSizes = new SmbNegotiation(mockRequest, mockResponse, smallBuffer, mediumBuffer);

        assertEquals(1, negotiationDifferentSizes.getRequestRaw().length);