if (!(request instanceof final ServerMessageBlock req)) {
            return;
        }

        req.addFlags2(this.negotiatedFlags2);
        req.setUseUnicode(req.isForceUnicode() || this.useUnicode);
        if (req.isUseUnicode()) {
            req.addFlags2(SmbConstants.FLAGS2_UNICODE);
        }

        if (req instanceof SmbComTransaction) {

        @DisplayName("Test flags2 property")
        void testFlags2Property() {
            testBlock.setFlags2(0x1234);
            assertEquals(0x1234, testBlock.getFlags2());

            testBlock.addFlags2(0x0001);
            assertEquals(0x1235, testBlock.getFlags2());

            testBlock.remFlags2(0x0200);
            assertEquals(0x1035, testBlock.getFlags2());
        }

        @Test

    public final void setFlags2(final int fl) {
        this.flags2 = fl;
    }

    /**
     * Adds flags to the flags2 field using bitwise OR
     * @param fl flags to add
     */
    public final void addFlags2(final int fl) {
        this.flags2 |= fl;
    }

    /**
     * Removes flags from the flags2 field using bitwise AND NOT
     * @param fl flags to remove
     */

    }

    @Test
    @DisplayName("addFlags0 combines flags correctly")
    void addFlags0() {
        SmbComNTCreateAndX req = createRequest(0, 0);
        req.addFlags0(0x10);
        int flags0 = (int) getPrivateField(req, "flags0");
        assertTrue((flags0 & 0x10) != 0, "flag should be set after addFlags0");
        // Calling again should combine rather than overwrite
        req.addFlags0(0x20);

        void testAddFlags() {
            assertEquals(0, testMessage.getFlags());
            testMessage.addFlags(ServerMessageBlock2.SMB2_FLAGS_SIGNED);
            assertEquals(ServerMessageBlock2.SMB2_FLAGS_SIGNED, testMessage.getFlags());
            testMessage.addFlags(ServerMessageBlock2.SMB2_FLAGS_DFS_OPERATIONS);

        // Act
        pipe.customizeCreate(req, resp);

        // Assert: verify interactions with dependencies
        verify(req, times(1)).addFlags0(0x16);
        verify(resp, times(1)).setExtended(true);
        verify(resp, never()).setExtended(false);
    }

    @Test
    @DisplayName("openPipe returns a handle bound to this pipe")

            assertFalse(echoResponse.isSigned());

            echoResponse.addFlags(ServerMessageBlock2.SMB2_FLAGS_SIGNED);

            assertTrue(echoResponse.isSigned());
        }

        @Test
        @DisplayName("Should handle multiple flags correctly")
        void testIsSignedWithMultipleFlags() {
            echoResponse.addFlags(ServerMessageBlock2.SMB2_FLAGS_ASYNC_COMMAND);

    public Smb2CancelRequest(final Configuration config, final long mid, final long asyncId) {
        super(config, SMB2_CANCEL);
        setMid(mid);
        setAsyncId(asyncId);
        if (asyncId != 0) {
            addFlags(SMB2_FLAGS_ASYNC_COMMAND);
        }
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Request#getCreditCost()
     */
    @Override
    public int getCreditCost() {

     *      jcifs.internal.smb1.com.SmbComNTCreateAndXResponse)
     */
    @Override
    protected void customizeCreate(final SmbComNTCreateAndX request, final SmbComNTCreateAndXResponse response) {
        request.addFlags0(0x16);
        response.setExtended(true);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.SmbFile#getType()
     */
    @Override
    public int getType() throws SmbException {

        setResponse(resp);
        return resp;
    }

    /**
     * Adds flags to the flags0 field.
     *
     * @param fl
     *            the flags0 to set
     */
    public final void addFlags0(final int fl) {
        this.flags0 |= fl;
    }

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