assertEquals(asyncId, request.getAsyncId());
        assertTrue((request.getFlags() & SMB2_FLAGS_ASYNC_COMMAND) != 0, "Async flag should be set when asyncId is non-zero");
    }

    @Test
    @DisplayName("Test constructor with zero asyncId does not set async flag")
    void testConstructorWithZeroAsyncId() {
        // Given
        long mid = 12345L;
        long asyncId = 0L;

        // When

        @Test
        @DisplayName("createCancel should return Smb2CancelRequest with same mid and asyncId")
        void testCreateCancel() {
            long mid = 123L;
            long asyncId = 456L;
            testRequest.setMid(mid);
            testRequest.setAsyncId(asyncId);

            CommonServerMessageBlockRequest cancelRequest = testRequest.createCancel();

     *            The message ID of the request to cancel
     * @param asyncId
     *            The async ID for asynchronous operations (0 for synchronous)
     */
    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);
        }
    }

     *
     * @return the asyncId
     */
    public final long getAsyncId() {
        return this.asyncId;
    }

    /**
     * Sets the asynchronous identifier for this message.
     *
     * @param asyncId
     *            the asyncId to set
     */
    public final void setAsyncId(final long asyncId) {
        this.asyncId = asyncId;
    }

    /**

            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, // Reserved / AsyncId
            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, // TreeId / AsyncId
            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, // SessionId

  protected Table<String, Integer, Character> create(@Nullable Object... data) {
    TestTable<String, Integer, Character> table = new TestTable<>();
    Table<String, Integer, Character> synced = Synchronized.table(table, table.mutex);
    populate(synced, data);
    return synced;
  }

objects or object prefixes that satisfy the replication rules and were created prior to adding replication configuration OR while replication rules were disabled will be synced to the target cluster. Depending on the number of previously existing objects, the existing objects that are now eligible to be replicated will eventually be synced to the target cluster as the scanner schedules them. This may be slower depending on the load on the cluster, latency and size of the namespace.

In the rare...

`GET/HEAD` operations if object or object version requested qualifies for replication and is missing on one site, but present on the other. This allows the applications to take full advantage of two-way replication even before the two sites get fully synced.

In the case of multi destination replication, the replication status shows `COMPLETED` only after the replication operation succeeds on each of the targets specified in the replication configuration. If multiple targets are configured to...

				})
				if err != nil {
					return errSRBucketMetaError(err)
				}
			}
		}
	}

	// Order matters from now on how the information is
	// synced to remote sites.

	// Policies should be synced first.
	{
		// Replicate IAM policies on local to all peers.
		allPolicyDocs, err := globalIAMSys.ListPolicyDocs(ctx, "")
		if err != nil {
			return errSRBackendIssue(err)
		}

	UpdateOpts UpdateMetadataOpts `msg:"uo"`
	FI         FileInfo           `msg:"fi"`
}

// UpdateMetadataOpts provides an optional input to indicate if xl.meta updates need to be fully synced to disk.
type UpdateMetadataOpts struct {
	NoPersistence bool `msg:"np"`
}

// CheckPartsHandlerParams are parameters for CheckPartsHandler
type CheckPartsHandlerParams struct {
	DiskID   string   `msg:"id"`