ListenableFuture<V> delegate, Duration time, ScheduledExecutorService scheduledExecutor) {
    return withTimeout(delegate, toNanosSaturated(time), TimeUnit.NANOSECONDS, scheduledExecutor);
  }

  /**
   * Returns a future that delegates to another but will finish early (via a {@link
   * TimeoutException} wrapped in an {@link ExecutionException}) if the specified duration expires.
   *

import com.google.common.annotations.J2ktIncompatible;
import com.google.common.base.Function;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.DoNotMock;
import java.time.Duration;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

	return err
}

// Netperf - To initiate netperf on peer
func (client *peerRESTClient) Netperf(ctx context.Context, duration time.Duration) (madmin.NetperfNodeResult, error) {
	var result madmin.NetperfNodeResult
	values := make(url.Values)
	values.Set(peerRESTDuration, duration.String())
	respBody, err := client.callWithContext(context.Background(), peerRESTMethodNetperf, values, nil, -1)
	if err != nil {

package handlers

import (
	"context"
	"net"
	"net/http"
	"net/http/httputil"
	"net/url"
	"strings"
	"sync"
	"time"
)

const defaultFlushInterval = time.Duration(100) * time.Millisecond

// Forwarder forwards all incoming HTTP requests to configured transport.
type Forwarder struct {
	RoundTripper http.RoundTripper
	PassHost     bool
	Logger       func(error)

	if p := handlerPrefixes[h]; p != "" {
		prefix = p
	}
	trace := madmin.TraceInfo{
		TraceType: t.TraceType,
		FuncName:  prefix + "." + h.String(),
		NodeName:  remote,
		Time:      start,
		Duration:  end.Sub(start),
		Path:      t.Subroute,
		Error:     errString,
		Bytes:     int64(len(req) + len(resp)),
		HTTP: &madmin.TraceHTTPStats{
			ReqInfo: madmin.TraceRequestInfo{
				Time:    start,

	"strings"
	"testing"
	"time"

	"github.com/minio/minio/internal/color"
)

// Tests update notifier string builder.
func TestPrepareUpdateMessage(t *testing.T) {
	testCases := []struct {
		older time.Duration
		dlURL string

		expectedSubStr string
	}{
		// Testcase index 0
		{72 * time.Hour, "my_download_url", "3 days before the latest release"},

		// it with quantiles summarizing the distribution of pause time.
		// For example, if len(stats.PauseQuantiles) is 5, it will be
		// filled with the minimum, 25%, 50%, 75%, and maximum pause times.
		PauseQuantiles: make([]time.Duration, 5),
	}
	debug.ReadGCStats(&gcStats)
	// Truncate GC stats to max 5 entries.
	if len(gcStats.PauseEnd) > 5 {
		gcStats.PauseEnd = gcStats.PauseEnd[len(gcStats.PauseEnd)-5:]
	}
	if len(gcStats.Pause) > 5 {

	// while counting the number of concurrent connections
	return int(globalHTTPListen.Subscribers()) + int(globalTrace.Subscribers())
}

func waitForLowIO(maxIO int, maxWait time.Duration, currentIO func() int) {
	// No need to wait run at full speed.
	if maxIO <= 0 {
		return
	}

	const waitTick = 100 * time.Millisecond

	tmpMaxWait := maxWait

	for currentIO() >= maxIO {

A central part of the Gradle architecture is the "build state model", which holds the state for each piece and coordinates state transitions and other mutations. 
Most source code in Gradle is arranged by which part(s) of the build state model it acts on.
This affects the lifecycle of the code and the set of services available for dependency injection.

	var versions []FileInfo
	var allVersionIDs, freeVersionIDs []string
	for i := 0; i < 5; i++ {
		fi := basefi
		fi.VersionID = mustGetUUID()
		fi.DataDir = mustGetUUID()
		fi.ModTime = basefi.ModTime.Add(time.Duration(i) * time.Second)
		if err := xl.AddVersion(fi); err != nil {
			t.Fatalf("%d: Failed to add version %v", i+1, err)
		}

		if i > 3 {
			// Simulate transition of a version
			transfi := fi