assertEquals(remaining, response.getRemaining());
        }

        @Test
        @DisplayName("Should handle maximum integer values")
        void testMaximumValues() throws SMBProtocolDecodingException {
            byte[] buffer = createValidWriteResponse(Integer.MAX_VALUE, Integer.MAX_VALUE);

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

                Arguments.of(0xFFFF, true) // All flags including DFS
        );
    }

    @Test
    @DisplayName("Should handle maximum values for all fields")
    void testMaximumValues() throws SMBProtocolDecodingException {
        // Given
        byte[] buffer = new byte[256];
        SMBUtil.writeInt2(16, buffer, 0);
        buffer[2] = (byte) 0xFF; // Max share type
        buffer[3] = 0;

        assertTrue((request.getFlags() & SMB2_FLAGS_ASYNC_COMMAND) != 0, "Async flag should be set for non-zero asyncId");
    }

    @Test
    @DisplayName("Test edge case with maximum values")
    void testMaximumValues() {
        // Given
        long maxMid = Long.MAX_VALUE;
        long maxAsyncId = Long.MAX_VALUE;
        int maxCredits = Integer.MAX_VALUE;
        int maxTreeId = Integer.MAX_VALUE;

        // When

        // Should still read 37 bytes regardless of reserved byte values
        assertEquals(37, bytesRead);
    }

    @Test
    @DisplayName("Test handling of maximum values")
    void testMaximumValues() throws Exception {
        byte[] buffer = new byte[100];
        int bufferIndex = 0;

        // Reserved bytes
        buffer[bufferIndex] = 0x00;
        buffer[bufferIndex + 1] = 0x00;

        }
    }

    @Nested
    @DisplayName("Edge Case Tests")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle maximum values")
        void testMaximumValues() throws SMBProtocolDecodingException {
            byte[] buffer = createValidCopyChunkResponse(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE);

        }
    }

    @Nested
    @DisplayName("Edge Cases and Boundary Tests")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle maximum values")
        void testMaximumValues() {
            byte[] testBuffer = new byte[8];
            ByteBuffer bb = ByteBuffer.wrap(testBuffer).order(ByteOrder.LITTLE_ENDIAN);
            bb.putShort((short) 0xFFFE); // Max even pathConsumed

    }

    @Nested
    @DisplayName("Performance and Boundary Tests")
    class PerformanceTests {

        @Test
        @DisplayName("Should handle maximum values without overflow")
        void testMaximumValues() throws SMBProtocolDecodingException {
            FileFsFullSizeInformation info = new FileFsFullSizeInformation();
            byte[] buffer = new byte[32];

            // Set all bytes to 0xFF for maximum values

            assertEquals(0, SMBUtil.readInt4(buffer, 40)); // Default remaining bytes
        }

        @Test
        @DisplayName("Should handle maximum values correctly")
        void testMaximumValues() {
            request.setPadding((byte) 0xFF);
            request.setReadFlags((byte) 0xFF);
            request.setReadLength(Integer.MAX_VALUE);
            request.setOffset(Long.MAX_VALUE);

        assertTrue(result.contains("altPath=null"));
        assertTrue(result.contains("node=NODE"));
    }

    // Edge Cases and Boundary Tests

    @Test
    public void testMaximumValues() {
        ByteBuffer bb = ByteBuffer.wrap(testBuffer).order(ByteOrder.LITTLE_ENDIAN);

        bb.putShort((short) 3);
        bb.putShort((short) 65535); // max unsigned short
        bb.putShort((short) 65535);

        }

        @Test
        @DisplayName("Should handle maximum values correctly")
        void testMaximumValues() {
            request.setOffset(Long.MAX_VALUE);
            request.setRemainingBytes(Integer.MAX_VALUE);
            request.setWriteFlags(Integer.MAX_VALUE);
            request.setData(new byte[10], 0, 10);