// Write to buffer
        SMBUtil.writeInt4(testCapabilities, buffer, bufferIndex);
        System.arraycopy(testGuid, 0, buffer, bufferIndex + 4, 16);
        SMBUtil.writeInt2(testSecurityMode, buffer, bufferIndex + 20);
        SMBUtil.writeInt2(testDialect, buffer, bufferIndex + 22);

        // Execute decode
        int bytesDecoded = response.decode(buffer, bufferIndex, 24);

        // Verify results

        // Arrange
        byte[] buffer = new byte[100];
        SMBUtil.writeInt2(0, buffer, 0);
        SMBUtil.writeInt2(0, buffer, 2);
        SMBUtil.writeInt2(0, buffer, 4);

        // Act & Assert
        assertEquals(0, response.readSetupWireFormat(buffer, 0, 100));
        assertEquals(6, response.readParametersWireFormat(buffer, 0, 100));

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

            fileFsSizeInfo.decode(buffer1.array(), 0, 24);
            long firstCapacity = fileFsSizeInfo.getCapacity();

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

            // Then
            assertEquals(4, bytesRead);
        }

        @Test
        @DisplayName("Should handle concurrent access safely")
        void testConcurrentAccess() throws InterruptedException {
            // Given
            byte[] buffer1 = new byte[10];
            byte[] buffer2 = new byte[10];
            SMBUtil.writeInt2(4, buffer1, 0);

        byte[] buffer = new byte[28];

        // Fill resume key with test pattern
        for (int i = 0; i < 24; i++) {
            buffer[i] = (byte) (i + 1);
        }

        // Add context length (reserved) - 4 bytes
        buffer[24] = 0x00;
        buffer[25] = 0x00;
        buffer[26] = 0x00;
        buffer[27] = 0x00;

        // Decode

            // 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());

	c.Assert(err, nil)
	c.Assert(response.StatusCode, http.StatusOK)

	var buffer bytes.Buffer
	// data to be written into buffer.
	data := "1234567890"
	// seed the random number generator once.
	rand.Seed(3)
	// generate a random number between 13 and 200.
	randInt := getRandomRange(13, 200, -1)
	// write into buffer till length of the buffer is greater than the generated random number.
	for i := 0; i <= randInt; i += 10 {

        // Encode multiple times to verify consistency
        byte[] buffer1 = new byte[8];
        byte[] buffer2 = new byte[8];

        int bytes1 = info.encode(buffer1, 0);
        int bytes2 = info.encode(buffer2, 0);

        assertEquals(8, bytes1);
        assertEquals(8, bytes2);
        assertArrayEquals(buffer1, buffer2);
    }

    @Test
    @DisplayName("Test multiple decode operations")

    }

    @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