int result = response.readSetupWireFormat(buffer, 0, buffer.length);

        assertEquals(0, result);
    }

    @Test
    @DisplayName("Test readParametersWireFormat reads length correctly")
    void testReadParametersWireFormat() throws Exception {
        byte[] buffer = new byte[100];
        int expectedLength = 0x12345678;

        // Write length in little-endian format

        // When
        boolean isError = response.isErrorResponseStatus();

        // Then
        assertFalse(isError);
    }

    @DisplayName("Should handle various data lengths")
    @ParameterizedTest
    @CsvSource({ "0, 0", "1, 10", "100, 200", "512, 1024" })
    void testReadBytesWireFormatVariousDataLengths(int dataLength, int dataRemaining) throws Exception {
        // Given

        @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

        // 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

            byte[] actualPathBytes = new byte[expectedPathBytes.length];
            System.arraycopy(dst, 2, actualPathBytes, 0, expectedPathBytes.length);
            assertArrayEquals(expectedPathBytes, actualPathBytes);

            // Check null terminator at the end
            int nullTerminatorIndex = 2 + expectedPathBytes.length;
            assertEquals(0, dst[nullTerminatorIndex]);

            trans2QueryFSInfo.writeDataWireFormat(buffer, 0);
            trans2QueryFSInfo.readSetupWireFormat(buffer, 0, buffer.length);
            trans2QueryFSInfo.readParametersWireFormat(buffer, 0, buffer.length);
            trans2QueryFSInfo.readDataWireFormat(buffer, 0, buffer.length);
        }

        // Object should still be in valid state
        String result = trans2QueryFSInfo.toString();

        int paramWritten = trans2SetFileInfo.writeParametersWireFormat(paramBuffer, 0);
        int dataWritten = trans2SetFileInfo.writeDataWireFormat(dataBuffer, 0);

        // Verify lengths
        assertEquals(2, setupWritten);
        assertEquals(6, paramWritten);
        assertEquals(56, dataWritten); // 50 + 6 padding

        // Verify setup content

    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 };

    }

    @Test
    @DisplayName("length(): delegates to SmbFile.length()")
    void length_delegates() throws Exception {
        SmbRandomAccessFile raf = newInstance("r", false, false, false);
        SmbFile file = (SmbFile) getField(raf, "file");
        when(file.length()).thenReturn(42L);
        assertEquals(42L, raf.length());
    }

    @Test

        }

        @ParameterizedTest
        @DisplayName("Should handle various read lengths")
        @ValueSource(ints = { 0, 1, 512, 1024, 4096, 65536, 1048576 })
        void testVariousReadLengths(int length) {
            assertDoesNotThrow(() -> request.setReadLength(length));
        }

        @ParameterizedTest
        @DisplayName("Should handle various offsets")