}{
		{-1, -1},
		{0, 0},
		{5 * time.Second, 5 * time.Second},
		{30 * time.Second, 30 * time.Second},
	}

	var got time.Duration = -1
	testHookSetKeepAlive = func(cfg KeepAliveConfig) { got = cfg.Idle }

	for _, test := range tests {
		got = -1
		d := Dialer{KeepAlive: test.ka}
		c, err := d.Dial("tcp", ls.Listener.Addr().String())
		if err != nil {
			t.Fatal(err)
		}
		c.Close()

---

Imagine you are the computer / program 🤖 in that story.

While you are at the line, you are just idle 😴, waiting for your turn, not doing anything very "productive". But the line is fast because the cashier is only taking the orders (not preparing them), so that's fine.

// That error implements the Timeout method, and calling the Timeout
// method will return true, but there are other possible errors for which
// the Timeout will return true even if the deadline has not been exceeded.
//
// An idle timeout can be implemented by repeatedly extending
// the deadline after successful Read or Write calls.
//
// A zero value for t means I/O operations will not time out.
func (f *File) SetDeadline(t time.Time) error {

		// Older linux kernels seem to have some hiccups delivering the signal
		// in a timely manner on ppc64 and ppc64le. When running on a
		// ppc64le/ubuntu 16.04/linux 4.4 host the time can vary quite
		// substantially even on an idle system. 5 seconds is twice any value
		// observed when running 10000 tests on such a system.
		settleTime = 5 * time.Second
	} else if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" {

	// kubelet will configure all containers to use this for DNS resolution
	// instead of the host's DNS servers.
	ClusterDNS []string
	// streamingConnectionIdleTimeout is the maximum time a streaming connection
	// can be idle before the connection is automatically closed.
	StreamingConnectionIdleTimeout metav1.Duration
	// nodeStatusUpdateFrequency is the frequency that kubelet computes node

`-Dorg.gradle.daemon.idletimeout=(number of milliseconds)`::
A <<build_environment.adoc#sec:gradle_configuration_properties,Gradle property>> wherein the Gradle Daemon will stop itself after this number of milliseconds of idle time. _Default is 10800000_ (3 hours).

[[sec:command_line_logging]]
== Logging options

=== Setting log level

	if err != nil {
		return nil, err
	}
	return c.Do(req)
}

// CloseIdleConnections closes any connections on its [Transport] which
// were previously connected from previous requests but are now
// sitting idle in a "keep-alive" state. It does not interrupt any
// connections currently in use.
//
// If [Client.Transport] does not have a [Client.CloseIdleConnections] method
// then this method does nothing.

	systemstack(func() {
		lock(&trace.lock)
		trace.flushedGen.Store(gen)
		unlock(&trace.lock)
	})

	// Perform status reset on dead Ps because they just appear as idle.
	//
	// Preventing preemption is sufficient to access allp safely. allp is only
	// mutated by GOMAXPROCS calls, which require a STW.
	//
	// TODO(mknyszek): Consider explicitly emitting ProcCreate and ProcDestroy

	scannerCycle                         = uatomic.NewDuration(dataScannerStartDelay)
	scannerIdleMode                      = uatomic.NewInt32(0) // default is throttled when idle
	scannerExcessObjectVersions          = uatomic.NewInt64(100)
	scannerExcessObjectVersionsTotalSize = uatomic.NewInt64(1024 * 1024 * 1024 * 1024) // 1 TB
	scannerExcessFolders                 = uatomic.NewInt64(50000)
)

	// at any time, including between the ts := assignment and the
	// call to ts.lock. If a reschedule happened then, we would be
	// adding t to some other P's timers, perhaps even a P that the scheduler
	// has marked as idle with no timers, in which case the timer could
	// go unnoticed until long after t.when.
	// Calling acquirem instead of using getg().m makes sure that
	// we end up locking and inserting into the current P's timers.