@Benchmark
  long stopwatch(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {
      Stopwatch s = Stopwatch.createStarted();
      // here is where you would do something
      total += s.elapsed(NANOSECONDS);
    }
    return total;
  }

  @Benchmark
  long manual(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {
      long start = System.nanoTime();

	res := DB.FirstOrCreate(&user, "name = ?", user.Name)
	if res.Error != nil || res.RowsAffected != 1 {
		t.Fatalf("first or create rows affect err:%v rows:%d", res.Error, res.RowsAffected)
	}

	res = DB.FirstOrCreate(&user, "name = ?", user.Name)
	if res.Error != nil || res.RowsAffected != 0 {
		t.Fatalf("first or create rows affect err:%v rows:%d", res.Error, res.RowsAffected)
	}
}

        FilterChain chain = new FilterChain() {
            @Override
            public void doFilter(ServletRequest req, ServletResponse res) throws IOException, ServletException {
                chainCalled.set(true);
                assertSame(request, req);
                assertSame(response, res);
            }
        };

        // Setup WebApiManagerFactory that returns null

) {
	var configHistory []madmin.ConfigHistoryEntry

	// List all kvs
	marker := ""
	for {
		res, err := objAPI.ListObjects(ctx, minioMetaBucket, minioConfigHistoryPrefix, marker, "", maxObjectList)
		if err != nil {
			return nil, err
		}
		for _, obj := range res.Objects {
			cfgEntry := madmin.ConfigHistoryEntry{
				RestoreID:  strings.TrimSuffix(path.Base(obj.Name), kvPrefix),

			if len(fivs.FreeVersions) > 0 {
				res["free-versions"] = strconv.Itoa(len(fivs.FreeVersions))
			}

			if sizeS.versions > 0 {
				res["versions"] = strconv.FormatUint(sizeS.versions, 10)
			}
			res["size"] = strconv.FormatInt(sizeS.totalSize, 10)
			for name, tier := range sizeS.tiers {
				res["tier-size-"+name] = strconv.FormatUint(tier.TotalSize, 10)
				res["tier-versions-"+name] = strconv.Itoa(tier.NumVersions)

	// Initialize heal result info
	res = madmin.HealResultItem{
		Type:      madmin.HealItemBucket,
		Bucket:    bucket,
		DiskCount: len(localDrives),
		SetCount:  -1, // explicitly set an invalid value -1, for bucket heal scenario
	}

	// mutate only if not a dry-run
	if opts.DryRun {
		return res, nil
	}

	for i := range beforeState {
		res.Before.Drives = append(res.Before.Drives, madmin.HealDriveInfo{

        final String[] arr = new String[4];
        dr.ttl = ref.getTtl();
        dr.rflags = ref.getRFlags();
        dr.expiration = expire;
        if ((dr.rflags & Trans2GetDfsReferralResponse.FLAGS_NAME_LIST_REFERRAL) == Trans2GetDfsReferralResponse.FLAGS_NAME_LIST_REFERRAL) {
            final String[] expandedNames = ref.getExpandedNames();
            if (expandedNames.length > 0) {

      values[i] = new double[n];
      for (int j = 0; j < n; j++) {
        values[i][j] = rng.nextDouble();
      }
    }
  }

  @Benchmark
  int meanAndVariance(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      tmp += varianceAlgorithm.variance(values[i & 0xFF], meanAlgorithm).hashCode();
    }
    return tmp;
  }

	l.LastSec = sec
}

// Merge all recorded latencies of last minute into one
func (l *lastMinuteLatency) getTotal() AccElem {
	var res AccElem
	sec := time.Now().Unix()
	l.forwardTo(sec)
	for _, elem := range l.Totals[:] {
		res.merge(elem)
	}
	return res
}

// forwardTo time t, clearing any entries in between.
func (l *lastMinuteLatency) forwardTo(t int64) {
	if l.LastSec >= t {
		return

        ShareEnumIterator it = new ShareEnumIterator(parent, entries.iterator(), filter);

        assertTrue(it.hasNext());
        SmbResource res = it.next();
        assertNotNull(res);
        assertEquals("good/", res.getName());
        assertFalse(it.hasNext());

        verify(filter, times(2)).accept(any());
    }

    static Stream<Arguments> invalidNamesAndFilterFlag() {