// Assert
        assertEquals(expectedFlags, queryPolicy.getFlags());
        // Binary check for individual flags
        assertEquals(0x03, queryPolicy.getFlags()); // 0x01 | 0x02 = 0x03
    }

    @Test
    void getOpnum_shouldReturnCorrectValue() {
        // Arrange
        short level = 1;

        }

        @ParameterizedTest
        @DisplayName("Should read different oplock levels correctly")
        @ValueSource(bytes = { 0x00, 0x01, 0x02, 0x08, (byte) 0xFF })
        void testReadDifferentOplockLevels(byte oplockLevel) throws Exception {
            byte[] buffer = createValidOplockBreakBuffer(oplockLevel, createTestData(16));

        byte[] params = { 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00 };
        response.readParametersWireFormat(params, 0, params.length);

        // Data block: 2 entries
        byte[] data = new byte[100];
        // Entry 1: SHARE1, type 0 (Disk), remark "Remark 1"
        System.arraycopy("SHARE1".getBytes(StandardCharsets.US_ASCII), 0, data, 0, 6);
        data[14] = 0x00;
        data[15] = 0x00; // type = 0

    class ToStringTests {

        @Test
        @DisplayName("toString with valid data produces expected format")
        void testToStringWithValidData() {
            byte[] challenge = new byte[] { (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0xFF };
            UniAddress dc = mock(UniAddress.class);
            when(dc.toString()).thenReturn("SERVER123");

            NtlmChallenge nc = new NtlmChallenge(challenge, dc);

        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
        LockingAndXRange lock = new LockingAndXRange(false);

    void testSubcommandConstants() {
        // Test Trans2 subcommands
        assertEquals((byte) 0x01, SmbComTransaction.TRANS2_FIND_FIRST2);
        assertEquals((byte) 0x02, SmbComTransaction.TRANS2_FIND_NEXT2);
        assertEquals((byte) 0x03, SmbComTransaction.TRANS2_QUERY_FS_INFORMATION);
        assertEquals((byte) 0x05, SmbComTransaction.TRANS2_QUERY_PATH_INFORMATION);

        // Then
        assertEquals(testType, nameType);
        verify(mockNetbiosName).getNameType();
    }

    @ParameterizedTest
    @ValueSource(ints = { 0x00, 0x03, 0x06, 0x1B, 0x1C, 0x1D, 0x1E, 0x20 })
    @DisplayName("Should handle various NetBIOS name types")
    void testVariousNameTypes(int nameType) {
        // Given
        when(mockNetbiosName.getNameType()).thenReturn(nameType);

        src[srcIndex + 1] = 0x0C; // Pointer offset
        // recordType (2 bytes)
        src[srcIndex + 2] = 0x00;
        src[srcIndex + 3] = 0x20; // NB (0x0020)
        // recordClass (2 bytes)
        src[srcIndex + 4] = 0x00;
        src[srcIndex + 5] = 0x01; // IN (0x0001)
        // ttl (4 bytes)
        src[srcIndex + 6] = 0x00;
        src[srcIndex + 7] = 0x00;
        src[srcIndex + 8] = 0x00;

        }
        impersonationLevel = 0x02; // As seen on NT :~)
        securityFlags = (byte) 0x03; // SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY
    }

    @Override
    int writeParameterWordsWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        dst[dstIndex] = (byte) 0x00;
        dstIndex++;

        }
    }

    /* --- flag handling -------------------------------- */
    @Test
    void testFlagSetAndUnset() {
        TestMessage m = new TestMessage();
        int FLAG_A = 0x01;
        int FLAG_B = 0x02;
        assertFalse(m.isFlagSet(FLAG_A));
        m.setFlag(FLAG_A);
        assertTrue(m.isFlagSet(FLAG_A));
        // unset correctly removes the flag
        m.unsetFlag(FLAG_A);