void testWriteParametersWireFormat() {
        int level = 0x1234;
        Trans2QueryFSInformation cmd = new Trans2QueryFSInformation(level);
        byte[] buf = newBuffer(10);

        int written = cmd.writeParametersWireFormat(buf, 0);
        assertEquals(2, written, "writeParametersWireFormat should write exactly 2 bytes");

        // Verify little-endian encoding (0x1234 -> 0x34 0x12)

        assertEquals(dst.length, n);

        // resumeKey (LE) at offset 6..9 should be 0x11121314 -> 14 13 12 11
        assertEquals((byte) 0x14, dst[6]);
        assertEquals((byte) 0x13, dst[7]);
        assertEquals((byte) 0x12, dst[8]);
        assertEquals((byte) 0x11, dst[9]);

        // filename content
        byte[] nameBytes = updatedName.getBytes();

        // Test different sizes
        assertEquals("00", Hexdump.toHexString(0, 2));
        assertEquals("FF", Hexdump.toHexString(255, 2));
        assertEquals("1234", Hexdump.toHexString(0x1234, 4));
    }

    @Test
    @DisplayName("Should convert long to hex string with padding")
    void testLongToHexString() {
        // Test various long values

        // Arrange
        byte[] buffer = new byte[10];
        int bufferIndex = 0;
        int len = 6;

        // Set up buffer with test data
        // available = 0x1234 (4660 in decimal)
        SMBUtil.writeInt2(0x1234, buffer, bufferIndex);
        // next 2 bytes (ignored in implementation)
        SMBUtil.writeInt2(0xABCD, buffer, bufferIndex + 2);
        // status = STATUS_CONNECTION_OK (3)

        // Given
        short value = 0x1234;
        byte[] buffer = new byte[2];

        // When - encode little endian
        Encdec.enc_uint16le(value, buffer, 0);
        short decoded = (short) Encdec.dec_uint16le(buffer, 0);

        // Then
        assertEquals(value, decoded);
        assertEquals(0x34, buffer[0] & 0xFF);
        assertEquals(0x12, buffer[1] & 0xFF);
    }

    @Test

    }

    @Test
    public void testReadParameterWordsUpdatesCount() {
        // create a buffer with count = 0x1234 (4660 decimal)
        // Using little-endian byte order as per SMBUtil.readInt2
        byte[] buf = new byte[12];
        buf[0] = 0x34; // Low byte
        buf[1] = 0x12; // High byte
        int written = resp.readParameterWordsWireFormat(buf, 0);

        // Given
        byte[] buffer = new byte[offset + 20];
        SMBUtil.writeInt2(16, buffer, offset);
        buffer[offset + 2] = 0x02; // PIPE
        buffer[offset + 3] = 0;
        SMBUtil.writeInt4(0x1234, buffer, offset + 4);
        SMBUtil.writeInt4(0x5678, buffer, offset + 8);
        SMBUtil.writeInt4(0x9ABC, buffer, offset + 12);

        // When
        int bytesRead = response.readBytesWireFormat(buffer, offset);

        Configuration cfg = mock(Configuration.class);
        SmbComLockingAndX cmd = new SmbComLockingAndX(cfg);
        // set fields via reflection
        setField(cmd, "fid", 0x1234);
        setField(cmd, "typeOfLock", (byte) 0x05);
        setField(cmd, "newOpLockLevel", (byte) 0x01);
        setField(cmd, "timeout", 3000L);
        // arrays of one lock and one unlock range

        assertEquals("FF", Hexdump.toHexString(255, 2));

        // Test larger values
        assertEquals("00001234", Hexdump.toHexString(0x1234, 8));
        assertEquals("1234", Hexdump.toHexString(0x1234, 4));
        assertEquals("34", Hexdump.toHexString(0x1234, 2));

        // Test negative values (treated as unsigned)
        assertEquals("FFFFFFFF", Hexdump.toHexString(-1, 8));

    void testInitDefaultsWithPresetFlags() throws CIFSException {
        BaseConfiguration testConfig = new BaseConfiguration(false);
        testConfig.flags2 = 0x1234;
        testConfig.capabilities = 0x5678;

        testConfig.initDefaults();

        assertEquals(0x1234, testConfig.getFlags2());
        assertEquals(0x5678, testConfig.getCapabilities());
    }

    @Test