nextTime := time.Now().Add(10 * time.Second)
	fakeClock.SetTime(nextTime)
	if res := budget.takeAvailable(); res != budget.maxBudget {
		t.Errorf("Expected: %v, got: %v", budget.maxBudget, res)
	}
	// add two refresh intervals to accumulate 2*refresh durations
	nextTime = nextTime.Add(2 * time.Second)
	fakeClock.SetTime(nextTime)
	if res := budget.takeAvailable(); res != 2*budget.refresh {
		t.Errorf("Expected: %v, got: %v", 2*budget.refresh, res)

stale_uploads_expiry            (duration)  set to expire stale multipart uploads older than this values (default: '24h')
stale_uploads_cleanup_interval  (duration)  set to change intervals when stale multipart uploads are expired (default: '6h')
delete_cleanup_interval         (duration)  set to change intervals when deleted objects are permanently deleted from ".trash" folder (default: '5m')

  STATUS=$? ;
  until [ $STATUS = 0 ]
  do
    ATTEMPTS=`expr $ATTEMPTS + 1` ;
    echo \"Failed attempts: $ATTEMPTS\" ;
    if [ $ATTEMPTS -gt $LIMIT ]; then
      exit 1 ;
    fi ;
    sleep 2 ; # 1 second intervals between attempts
    $MC_COMMAND ;
    STATUS=$? ;
  done ;
  set -e ; # reset `e` as active
  return 0
}

# checkUserExists ()
# Check if the user exists, by using the exit code of `mc admin user info`

	$MC_COMMAND
	STATUS=$?
	until [ $STATUS = 0 ]; do
		ATTEMPTS=$(expr $ATTEMPTS + 1)
		echo \"Failed attempts: $ATTEMPTS\"
		if [ $ATTEMPTS -gt $LIMIT ]; then
			exit 1
		fi
		sleep 2 # 1 second intervals between attempts
		$MC_COMMAND
		STATUS=$?
	done
	set -e # reset `e` as active
	return 0
}

# checkBucketExists ($bucket)
# Check if the bucket exists, by using the exit code of `mc ls`

		},
		"overlapping intervals, corrupted failed interval skipped": {
			completedIndexesStr: "0,2-4,6-8,12-19",
			failedIndexesStr:    "1,y,8,9-10",
			completions:         20,
			wantError:           errors.New("failedIndexes and completedIndexes overlap at index: 8"),
		},
		"overlapping intervals, first corrupted intervals skipped": {
			completedIndexesStr: "x,0,2-4,6-8,12-19",

	dataUsageBucketLenV1 = 7
	// dataUsageBucketLen must be length of ObjectsHistogramIntervals
	dataUsageBucketLen  = 11
	dataUsageVersionLen = 7
)

// ObjectsHistogramIntervalsV1 is the list of all intervals
// of object sizes to be included in objects histogram(V1).
var ObjectsHistogramIntervalsV1 = [dataUsageBucketLenV1]objectHistogramInterval{
	{"LESS_THAN_1024_B", 0, humanize.KiByte - 1},

		args = append(args, string(arg))
	}
	return args
}

func ftToDuration(ft *syscall.Filetime) time.Duration {
	n := int64(ft.HighDateTime)<<32 + int64(ft.LowDateTime) // in 100-nanosecond intervals
	return time.Duration(n*100) * time.Nanosecond
}

func (p *ProcessState) userTime() time.Duration {
	return ftToDuration(&p.rusage.UserTime)
}

func (p *ProcessState) systemTime() time.Duration {

## Implementation

ILM tiering takes place when a object placed in the bucket meets lifecycle transition rules and becomes eligible for tiering. MinIO scanner (which runs at one minute intervals, each time scanning one sixteenth of the namespace), picks up the object for tiering. The data is moved to the remote tier in entirety, leaving only the object metadata on MinIO.

                val realEndIndex = offset + offsetRelativeIndexRange.last
                check(text.isValidIndex(realEndIndex))

                check(realEndIndex - realStartIndex >= -1) // -1 is for empty intervals

                var startLine = -1
                var startColumn = -1
                var endLine = -1
                var endColumn = -1

                var i = offset
                var line = 1

		time.Sleep(1 * time.Millisecond)
	}
	t.Errorf("Test appears to have leaked %s:\n%s", bad, stacks)
}

// waitCondition waits for fn to return true,
// checking immediately and then at exponentially increasing intervals.
func waitCondition(t testing.TB, delay time.Duration, fn func(time.Duration) bool) {
	t.Helper()
	start := time.Now()
	var since time.Duration
	for !fn(since) {
		time.Sleep(delay)