void createOptionsAddedWhenLow() {
        // createOptions less than 0x0001 (i.e., 0) should be padded with 0x0040
        SmbComNTCreateAndX req = createRequest(0, 0);
        int actual = (int) getPrivateField(req, "createOptions");
        assertEquals(0x0040, actual, "createOptions should be padded with 0x0040");
    }

    @Test
    @DisplayName("addFlags0 combines flags correctly")
    void addFlags0() {

        assertEquals((short) 0x0007, SmbComTransaction.TRANS2_QUERY_FILE_INFORMATION);
        assertEquals((short) 0x0008, SmbComTransaction.TRANS2_SET_FILE_INFORMATION);
        assertEquals((short) 0x0010, SmbComTransaction.TRANS2_GET_DFS_REFERRAL);
    }

    @Test
    @DisplayName("Test encode and decode operations")
    void testEncodeDecodeOperations() {
        byte[] buffer = new byte[1024];

        // informationLevel (2 bytes, LE) -> 0x0104
        assertEquals((byte) 0x04, dst[4]);
        assertEquals((byte) 0x01, dst[5]);

        // resumeKey (4 bytes, LE)
        assertEquals((byte) 0xEF, dst[6]);
        assertEquals((byte) 0xCD, dst[7]);
        assertEquals((byte) 0xAB, dst[8]);
        assertEquals((byte) 0x89, dst[9]);

        // flags (2 bytes, LE) -> 0x0000
        assertEquals((byte) 0x00, dst[10]);

    /** SMB2 query info command */
    protected static final short SMB2_QUERY_INFO = 0x0010;
    /** SMB2 set info command */
    protected static final short SMB2_SET_INFO = 0x0011;
    /** SMB2 opportunistic lock break notification */
    protected static final short SMB2_OPLOCK_BREAK = 0x0012;

    /**
     * Flag indicating the message is a response from server to client.
     */

        assertEquals(0x00, dst[dstIndex + 2]);
        assertEquals(0x00, dst[dstIndex + 3]);

        // Verify security information (4 bytes)
        assertEquals(securityInfo, SMBUtil.readInt4(dst, dstIndex + 4));
    }

    @ParameterizedTest
    @DisplayName("Test writeParametersWireFormat with various FID values")
    @ValueSource(ints = { 0x0000, 0x0001, 0x7FFF, 0xFFFF, 0x1234, 0xABCD })

    @Test
    void testPipeTypeCall() {
        assertEquals(0x0100, SmbPipeResource.PIPE_TYPE_CALL, "PIPE_TYPE_CALL should be 0x0100");
    }

    /**
     * Test if the PIPE_TYPE_TRANSACT constant has the correct value.
     */
    @Test
    void testPipeTypeTransact() {
        assertEquals(0x0200, SmbPipeResource.PIPE_TYPE_TRANSACT, "PIPE_TYPE_TRANSACT should be 0x0200");
    }

    /**

            }
        } else {
            createDisposition = FILE_OPEN;
        }

        if ((createOptions & 0x0001) == 0) {
            this.createOptions = createOptions | 0x0040;
        } else {
            this.createOptions = createOptions;
        }
        impersonationLevel = 0x02; // As seen on NT :~)
        securityFlags = (byte) 0x03; // SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY
    }

        int bodyStart = headerStart + Smb2Constants.SMB2_HEADER_LENGTH;
        // Error response structure: size(2)=9, errorContextCount(1), reserved(1), bc(4), errorData(bc)
        SMBUtil.writeInt2(9, buf, bodyStart);
        buf[bodyStart + 2] = 0x02; // errorContextCount
        buf[bodyStart + 3] = 0x00; // reserved
        int bc = 4;

        byte[] buffer = new byte[512];
        request.setNotifyFlags(0x0001);
        request.setCompletionFilter(0x000000FF);

        // When
        int written = request.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(32, written);
        assertEquals(32, SMBUtil.readInt2(buffer, offset));
        assertEquals(0x0001, SMBUtil.readInt2(buffer, offset + 2));

        return transformCount > 0 && rdmaTransformId == 0x0001;
    }

    /**
     * Get the transform count
     *
     * @return number of transforms
     */
    public int getTransformCount() {
        return transformCount;
    }

    /**
     * Get the RDMA transform ID
     *
     * @return transform ID (should be 0x0001 for V1)
     */
    public int getRdmaTransformId() {