uv.lock
      - name: Install Dependencies
        run: uv sync --locked --no-dev --group github-actions --group translations
      # Allow debugging with tmate
      - name: Setup tmate session
        uses: mxschmitt/action-tmate@v3
        if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.debug_enabled == 'true' }}
        with:
          limit-access-to-actor: true
        env:

    /**
     * Unspecified tree ID value
     */
    public static final int UNSPECIFIED_TREEID = 0xFFFFFFFF;

    /**
     * Unspecified session ID value
     */
    public static final long UNSPECIFIED_SESSIONID = 0xFFFFFFFFFFFFFFFFL;

    /**
     * SMB2 Channel constant for RDMA V1
     * Used in SMB2 READ and WRITE requests to indicate RDMA channel

          <version>1.0.0/1.1.0</version>
          <type>String</type>
          <description>
            Specify the execution strategy: {@code once-per-session}, {@code always}.
          </description>
          <defaultValue>once-per-session</defaultValue>
        </field>
        <field>
          <name>since</name>
          <version>1.0.0+</version>
          <type>String</type>

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.SSPContext#getSigningKey()
     */
    @Override
    public byte[] getSigningKey() throws SmbException {
        /*
         * The kerberos session key is not accessible via the JGSS API. IBM and
         * Oracle both implement a similar API to make an ExtendedGSSContext
         * available. That API is accessed via reflection to make this independent

        this.openFlags &= ~(SmbFile.O_CREAT | SmbFile.O_TRUNC); /* in case close and reopen */
        writeSize = file.tree.session.transport.snd_buf_size - 70;

        useNTSmbs = file.tree.session.transport.hasCapability(SmbConstants.CAP_NT_SMBS);
        if (useNTSmbs) {
            reqx = new SmbComWriteAndX();
            rspx = new SmbComWriteAndXResponse();
        } else {

	if err := DB.Delete(&User{}).Error; err == nil || !errors.Is(err, gorm.ErrMissingWhereClause) {
		t.Errorf("should returns missing WHERE clause while deleting error")
	}

	if err := DB.Session(&gorm.Session{AllowGlobalUpdate: true}).Delete(&User{}).Error; err != nil {
		t.Errorf("should returns no error while enable global update, but got err %v", err)
	}
}

func TestDeleteWithAssociations(t *testing.T) {

        } else {
            throw new IllegalArgumentException("Invalid mode");
        }
        file.open(openFlags, access, SmbFile.ATTR_NORMAL, options);
        readSize = file.tree.session.transport.rcv_buf_size - 70;
        writeSize = file.tree.session.transport.snd_buf_size - 70;
        fp = 0L;
    }

    /**
     * Reads a single byte from the file at the current file pointer position.
     *

        public Map<String, String> extraInterpolationSource() {
            Map<String, String> extra = new HashMap<>();
            extra.put("session.topDirectory", topDirectory.toString());
            if (rootDirectory != null) {
                extra.put("session.rootDirectory", rootDirectory.toString());
            }
            return extra;
        }
    }

    @Override

        /* Downgrade one transport to the lower of the negotiated buffer sizes
         * so we can just send whatever is received.
         */

        final SmbTransport t1 = tree.session.transport;
        final SmbTransport t2 = dest.tree.session.transport;

        if (t1.snd_buf_size < t2.snd_buf_size) {
            t2.snd_buf_size = t1.snd_buf_size;
        } else {
            t1.snd_buf_size = t2.snd_buf_size;

                                                </c:when>
                                                <c:when test="${info.key == 'User Session ID'}">
                                                    <td><la:link