// Given
            byte[] dst = new byte[100];
            int dstIndex = 10;

            // When
            Method method = SmbComNtCancel.class.getDeclaredMethod("writeParameterWordsWireFormat", byte[].class, int.class);
            method.setAccessible(true);
            int result = (int) method.invoke(cancel, dst, dstIndex);

            // Then
            assertEquals(0, result);

        assertNull(req.getTicket(), "ticket should be null when tag 3 is absent");
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 4, 6, 99 })
    @DisplayName("seq ctor: invalid pvno values throw")
    void sequenceConstructor_invalidVersion_throws(int badPvno) throws Exception {
        // Arrange: Build sequence with invalid version and otherwise valid tags
        ASN1EncodableVector v = new ASN1EncodableVector();

        deskey(key, false, decryptKeys);
    }

    // Turn an 8-byte key into internal keys.
    private void deskey(final byte[] keyBlock, final boolean encrypting, final int[] KnL) {

        int i, j, l, m, n;
        final int[] pc1m = new int[56];
        final int[] pcr = new int[56];
        final int[] kn = new int[32];

        for (j = 0; j < 56; ++j) {
            l = pc1[j];
            m = l & 07;

            int[] expectedSizes = { 16, 24, 32, 40, 48 };

            for (int i = 0; i < contexts.length; i++) {
                contexts[i] = new MockCreateContextRequest("CTX" + i, expectedSizes[i]);
            }

            // Calculate total size
            int totalSize = 0;
            for (int i = 0; i < contexts.length; i++) {

    @MethodSource("knownCodeMessagePairs")
    void lookup_returns_expected_message_for_known_codes(int code, String expectedMessage) {
        // Valid inputs: each known code must map to its documented message
        assertEquals(expectedMessage, lookupMessage(code).orElse(null));
    }

    @ParameterizedTest
    @ValueSource(ints = { -1, Integer.MIN_VALUE, Integer.MAX_VALUE })

        assertEquals(0, msg.getFlags(), "Initial flags should be 0");
    }

    @ParameterizedTest(name = "setFlags({0}) ➜ getFlags() == {0}")
    @ValueSource(ints = { 0x0, 0x1, 0x2, 0xFFFFFFFF, -123456 })
    void testSetAndGetFlags(int value) {
        msg.setFlags(value);
        assertEquals(value, msg.getFlags(), "getFlags should return the value set");
    }

    @Test

    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 10, 100, 500, 1024 })
    void testReadDataWireFormatVariousSizes(int dataSize) throws SMBProtocolDecodingException {
        // Test with various data sizes within buffer limit
        byte[] testData = new byte[dataSize];
        Arrays.fill(testData, (byte) 0xAB);
        byte[] buffer = new byte[dataSize + 100];

    }

    /**
     * Test that a large file lock (bit 0x10 set) is encoded and decoded correctly.
     */
    @ParameterizedTest
    @ValueSource(ints = { 0x10, 0x11 })
    void largeFileFlagSet_and_decoded_according_to_type(int type) throws Exception {
        Configuration cfg = mock(Configuration.class);
        SmbComLockingAndX cmd = new SmbComLockingAndX(cfg);
        setField(cmd, "fid", 1);

        int actualInfoLevel = SMBUtil.readInt2(buffer, 2);
        assertEquals(0x0101, actualInfoLevel);

        // Check reserved bytes (should be 0)
        int reserved = SMBUtil.readInt2(buffer, 4);
        assertEquals(0, reserved);
    }

    @DisplayName("Test writeParametersWireFormat with different FIDs")
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 0xFFFF, 0x8000, 0x7FFF })

    class ConstructorTests {

        @ParameterizedTest
        @DisplayName("Should mask input values with 0xFF correctly")
        @ValueSource(ints = { 0, 1, 127, 128, 255, 256, -1, -128, -255, -256, 32767, -32768, 65535, 65536 })
        void testConstructorMasking(int inputValue) {
            // Given: An input value
            // When: Creating NdrShort with that value
            NdrShort ndrShort = new NdrShort(inputValue);