return
	}
	sm.Lock()
	defer sm.Unlock()
	st, ok := sm.resyncStatus[o.resyncID]
	if ok {
		if st.BucketStatuses == nil {
			st.BucketStatuses = map[string]ResyncStatusType{}
		}
		switch bktStatus {
		case ResyncCompleted:
			st.BucketStatuses[o.bucket] = ResyncCompleted
			st.Status = siteResyncStatus(st.Status, st.BucketStatuses)
			st.LastUpdate = UTCNow()
			sm.resyncStatus[o.resyncID] = st

		}
	}
	srs.Endpoint = st.Endpoint
	srs.Secure = st.Secure
	switch {
	case st.Completed:
		srs.ReplicatedSize += st.TransferSize
		srs.ReplicatedCount++
		if st.TransferDuration > 0 {
			srs.Latency.update(st.TransferSize, st.TransferDuration)
			srs.updateXferRate(st.TransferSize, st.TransferDuration)
		}
	case st.Failed:
		srs.Failed.addsize(st.TransferSize, st.Err)
	case st.Pending:
	}

	for arn, st := range brs.Stats {
		// make a copy of `*st`
		s := BucketReplicationStat{
			ReplicatedSize:                   st.ReplicatedSize,
			ReplicaSize:                      st.ReplicaSize,
			Latency:                          st.Latency,
			BandWidthLimitInBytesPerSecond:   st.BandWidthLimitInBytesPerSecond,
			CurrentBandwidthInBytesPerSecond: st.CurrentBandwidthInBytesPerSecond,

            throw e;
        } finally {
            /*
             * This guarantees that we leave in a valid state
             */
            st = this.state;
            if (st != 0 && st != 3 && st != 4 && st != 5 && st != 6) {
                log.error("Invalid state: " + st);
                this.state = 6;
                cleanupThread(timeout);
            }
        }
    }

    /**

            }
            this.resolverOrder.add(ResolverType.RESOLVER_BCAST);
        } else {
            final StringTokenizer st = new StringTokenizer(ro, ",");
            while (st.hasMoreTokens()) {
                final String s = st.nextToken().trim();
                if (s.equalsIgnoreCase("LMHOSTS")) {
                    this.resolverOrder.add(ResolverType.RESOLVER_LMHOSTS);

		ht := make(map[string]map[string]any)
		file := c.Args().Get(0)
		if strings.HasSuffix(file, ".zip") {
			var sz int64
			f, err := os.Open(file)
			if err != nil {
				return err
			}
			if st, err := f.Stat(); err == nil {
				sz = st.Size()
			}
			defer f.Close()
			zr, err := zip.NewReader(f, sz)
			if err != nil {
				return err
			}
			for _, file := range zr.File {

	s.Lock()
	defer s.Unlock()
	m := s.statusMap[opts.bucket]
	st := m.TargetsMap[opts.arn]
	st.Object = ts.Object
	st.ReplicatedCount += ts.ReplicatedCount
	st.FailedCount += ts.FailedCount
	st.ReplicatedSize += ts.ReplicatedSize
	st.FailedSize += ts.FailedSize
	m.TargetsMap[opts.arn] = st
	m.LastUpdate = UTCNow()
	s.statusMap[opts.bucket] = m
}

	numSites := len(info.Sites)
	for b, stat := range sinfo.BucketStats {
		for dID, st := range stat {
			if st.TagMismatch ||
				st.VersioningConfigMismatch ||
				st.OLockConfigMismatch ||
				st.SSEConfigMismatch ||
				st.PolicyMismatch ||
				st.ReplicationCfgMismatch ||
				st.QuotaCfgMismatch ||
				opts.Entity == madmin.SRBucketEntity {
				if _, ok := info.BucketStats[b]; !ok {

        // Query was processed successfully

        // Test with multiple wildcards
        QueryContext queryContext2 = new QueryContext("*te*st*", false);
        WildcardQuery wildcardQuery2 = new WildcardQuery(new Term("content", "*te*st*"));

        QueryBuilder queryBuilder2 = queryCommand.convertWildcardQuery(queryContext2, wildcardQuery2, 1.0f);
        assertNotNull(queryBuilder2);

					Type:      counterMetric,
				},
				VariableLabels: map[string]string{"target_id": st.ID.ID, "target_name": st.ID.Name},
				Value:          float64(st.FailedRequests),
			})
		}

		// Audit and system:
		audit := logger.CurrentStats()
		for id, st := range audit {
			metrics = append(metrics, MetricV2{
				Description: MetricDescription{
					Namespace: minioNamespace,