// Given - first decode
            ByteBuffer buffer1 = ByteBuffer.allocate(32);
            buffer1.order(ByteOrder.LITTLE_ENDIAN);
            buffer1.putLong(1000L);
            buffer1.putLong(500L);
            buffer1.putLong(500L);
            buffer1.putInt(8);
            buffer1.putInt(512);

            fileFsFullSizeInfo.decode(buffer1.array(), 0, 32);

            byte[] buffer = new byte[512];

            int bytesWritten = req.writeBytesWireFormat(buffer, 0);

            assertEquals(48, SMBUtil.readInt2(buffer, 0)); // Structure size
            assertEquals(3, SMBUtil.readInt2(buffer, 2)); // Lock count
            assertArrayEquals(testFileId, Arrays.copyOfRange(buffer, 8, 24));

            // Each lock is 24 bytes

            // First read
            byte[] buffer1 = new byte[60];
            SMBUtil.writeInt2(60, buffer1, 0);
            SMBUtil.writeInt2(1, buffer1, 2);
            SMBUtil.writeInt8(1000, buffer1, 40);
            SMBUtil.writeInt8(500, buffer1, 48);
            SMBUtil.writeInt4(0x01, buffer1, 56);

            response.readBytesWireFormat(buffer1, 0);

            assertEquals(1, response.getCloseFlags());

            byte[] buffer1 = new byte[100];
            byte[] buffer2 = new byte[200];

            Arrays.fill(buffer1, (byte) 0x11);
            Arrays.fill(buffer2, (byte) 0x22);

            // First decode
            response.decode(buffer1, 0, 50);
            byte[] data1 = response.getData();

            // Second decode should overwrite
            response.decode(buffer2, 10, 60);

    void testMultipleReadsUpdateOffset() {
        byte[] buffer1 = new byte[] { 0x10, 0x00, 0x00, 0x00 }; // 16
        byte[] buffer2 = new byte[] { 0x20, 0x00, 0x00, 0x00 }; // 32

        response.readParameterWordsWireFormat(buffer1, 0);
        assertEquals(16L, response.getOffset(), "First read should set offset to 16");

        response.readParameterWordsWireFormat(buffer2, 0);

    }

    @Test
    void testReadSetupWireFormat() {
        byte[] buffer = new byte[100];
        int result = response.readSetupWireFormat(buffer, 0, 100);
        assertEquals(0, result);
    }

    @Test
    void testReadParametersWireFormat() {
        byte[] buffer = new byte[100];
        int result = response.readParametersWireFormat(buffer, 0, 100);
        assertEquals(0, result);
    }

    @Test

            NdrShort ndrShort = new NdrShort(50);
            NdrBuffer buffer1 = mock(NdrBuffer.class);
            NdrBuffer buffer2 = mock(NdrBuffer.class);
            when(buffer2.dec_ndr_short()).thenReturn(75);

            // When: Performing multiple operations
            ndrShort.encode(buffer1);
            ndrShort.decode(buffer2);

            // Then: Should handle both operations correctly

        @Test
        @DisplayName("Should not modify buffer during write")
        void testWriteDoesNotModifyBuffer() {
            byte[] buffer = new byte[64];
            Arrays.fill(buffer, (byte) 0xAA);
            byte[] originalBuffer = buffer.clone();

            notification.writeBytesWireFormat(buffer, 0);

            assertArrayEquals(originalBuffer, buffer);
        }
    }

    @Nested

- JSON log output is configurable and now supports writing info messages to stdout and error messages to stderr. Info messages can be buffered in memory. The default is to write both to stdout without buffering, as before. ([#104873](https://github.com/kubernetes/kubernetes/pull/104873), [@pohly](https://github.com/pohly))

        );
        when(mockNdrBuffer.dec_ndr_small()).thenReturn(4, 5);
        when(mockDeferredNdrBuffer.dec_ndr_long()).thenReturn(5, 0, 5, // name buffer: buffers, 0, bufferl
                6, 0, 6, // dns_domain buffer: buffers, 0, bufferl
                7, 0, 7 // dns_forest buffer: buffers, 0, bufferl
        );
        when(mockDeferredNdrBuffer.dec_ndr_short()).thenReturn((int) (short) 'a', (int) (int) (short) 'b', (int) (int) (short) 'c',