const time.Second

107 uses

	time (current package)
		format.go#L1611: 	"s":  uint64(Second),
		time.go#L934: 	Second               = 1000 * Millisecond
		time.go#L935: 	Minute               = 60 * Second
		time.go#L963: 	if u < uint64(Second) {
		time.go#L1087: 	sec := d / Second
		time.go#L1088: 	nsec := d % Second
		time.go#L1198: 	d := Duration(t.sec()-u.sec())*Second + Duration(t.nsec()-u.nsec())
		time.go#L1824: 	case d < Second && Second%(d+d) == 0:
		time.go#L1829: 	case d%Second == 0:
		time.go#L1830: 		d1 := int64(d / Second)
		time.go#L1832: 		r = Duration(sec%d1)*Second + Duration(nsec)

	crypto/tls
		conn.go#L1469: 		c.SetWriteDeadline(time.Now().Add(time.Second * 5))
		handshake_client_tls13.go#L867: 	lifetime := time.Duration(msg.lifetime) * time.Second
		handshake_server_tls13.go#L1012: 	m.lifetime = uint32(maxSessionTicketLifetime / time.Second)

	github.com/robfig/cron/v3
		constantdelay.go#L15: 	if duration < time.Second {
		constantdelay.go#L16: 		duration = time.Second
		constantdelay.go#L19: 		Delay: duration - time.Duration(duration.Nanoseconds())%time.Second,
		spec.go#L82: 	t = t.Add(1*time.Second - time.Duration(t.Nanosecond())*time.Nanosecond)
		spec.go#L165: 			t = t.Truncate(time.Second)
		spec.go#L167: 		t = t.Add(1 * time.Second)

	go.pact.im/x/supervisor
		restart.go#L11: 	restartInitialWait  = time.Second

	go.pact.im/x/zapjournal/tests
		journalctl.go#L13: const journalctlTimeout = time.Second

	go.uber.org/zap
		config.go#L225: 				time.Second,

	go.uber.org/zap/zapcore
		buffered_write_syncer.go#L37: 	_defaultFlushInterval = 30 * time.Second
		encoder.go#L99: 	sec := float64(nanos) / float64(time.Second)
		encoder.go#L226: 	enc.AppendFloat64(float64(d) / float64(time.Second))

	golang.org/x/net/http2
		config.go#L111: 	setDefault(&conf.PingTimeout, 1, math.MaxInt64, 15*time.Second)
		server.go#L57: 	prefaceTimeout        = 10 * time.Second
		server.go#L58: 	firstSettingsTimeout  = 2 * time.Second // should be in-flight with preface anyway
		server.go#L1494: var goAwayTimeout = 1 * time.Second
		transport.go#L652: 				d := time.Second * time.Duration(backoff)
		transport.go#L2187: 	unusedWaitTime := 5 * time.Second

	golang.org/x/net/internal/timeseries
		timeseries.go#L20: 	1 * time.Second,
		timeseries.go#L21: 	10 * time.Second,
		timeseries.go#L33: 	1 * time.Second,

	golang.org/x/net/trace
		events.go#L33: 	{10 * time.Second, "errs<10s"},
		trace.go#L581: 			{Cond: minCond(1 * time.Second)},
		trace.go#L582: 			{Cond: minCond(10 * time.Second)},
		trace.go#L583: 			{Cond: minCond(100 * time.Second)},
		trace.go#L939: 	if d < time.Second {

	golang.org/x/tools/internal/gocommand
		invoke.go#L258: 	cmd.WaitDelay = 30 * time.Second
		invoke.go#L408: 		timer := time.NewTimer(5 * time.Second)
		invoke.go#L468: 			case <-time.After(5 * time.Second):

	google.golang.org/grpc
		backoff.go#L35: 	MaxDelay: 120 * time.Second,
		clientconn.go#L58: 	minConnectTimeout = 20 * time.Second
		server.go#L189: 	connectionTimeout:     120 * time.Second,
		server.go#L925: 				if max := 1 * time.Second; tempDelay > max {

	google.golang.org/grpc/backoff
		backoff.go#L48: 	BaseDelay:  1.0 * time.Second,
		backoff.go#L51: 	MaxDelay:   120 * time.Second,

	google.golang.org/grpc/internal
		internal.go#L42: 	KeepaliveMinPingTime = 10 * time.Second
		internal.go#L46: 	KeepaliveMinServerPingTime = time.Second

	google.golang.org/grpc/internal/binarylog
		sink.go#L114: 	bufFlushDuration = 60 * time.Second

	google.golang.org/grpc/internal/grpcutil
		encode_duration.go#L55: 	if d := div(t, time.Second); d <= maxTimeoutValue {

	google.golang.org/grpc/internal/resolver/dns
		dns_resolver.go#L52: 	MinResolutionInterval = 30 * time.Second
		dns_resolver.go#L59: 	ResolvingTimeout = 30 * time.Second

	google.golang.org/grpc/internal/serviceconfig
		duration.go#L43: 	sec := ns / int64(time.Second)
		duration.go#L44: 	ns = ns % int64(time.Second)
		duration.go#L117: 	const maxSeconds = math.MaxInt64 / int64(time.Second)
		duration.go#L118: 	const maxNanosAtMaxSeconds = math.MaxInt64 % int64(time.Second)
		duration.go#L119: 	const minSeconds = math.MinInt64 / int64(time.Second)
		duration.go#L120: 	const minNanosAtMinSeconds = math.MinInt64 % int64(time.Second)
		duration.go#L127: 		*d = Duration(sec*int64(time.Second) + ns)

	google.golang.org/grpc/internal/transport
		defaults.go#L33: 	defaultClientKeepaliveTimeout = 20 * time.Second
		defaults.go#L39: 	defaultServerKeepaliveTimeout = 20 * time.Second
		http2_client.go#L64: var goAwayLoopyWriterTimeout = 5 * time.Second
		http2_client.go#L992: 	t.conn.SetWriteDeadline(time.Now().Add(time.Second * 10))
		http2_client.go#L1828: 	timer := time.NewTimer(time.Second)
		http2_server.go#L353: 			timer := time.NewTimer(time.Second)
		http2_server.go#L1427: 		timer := time.NewTimer(5 * time.Second)
		http2_server.go#L1463: 	timer := time.NewTimer(time.Second)
		http_util.go#L173: 		return time.Second, true

	google.golang.org/protobuf/types/known/durationpb
		duration.pb.go#L174: 	d := time.Duration(secs) * time.Second
		duration.pb.go#L175: 	overflow := d/time.Second != time.Duration(secs)

	net
		dial.go#L19: 	defaultTCPKeepAliveIdle = 15 * time.Second
		dial.go#L23: 	defaultTCPKeepAliveInterval = 15 * time.Second
		dial.go#L280: 	const saneMinimum = 2 * time.Second
		dnsclient_unix.go#L402: 	if conf.lastChecked.After(now.Add(-5 * time.Second)) {
		dnsconfig_unix.go#L22: 		timeout:  5 * time.Second,
		dnsconfig_unix.go#L92: 					conf.timeout = time.Duration(n) * time.Second
		hosts.go#L16: const cacheMaxAge = 5 * time.Second
		interface.go#L211: 	if !force && zc.lastFetched.After(now.Add(-60*time.Second)) {
		nss.go#L59: 	if conf.lastChecked.After(now.Add(-5 * time.Second)) {
		tcpsockopt_unix.go#L23: 	secs := int(roundDurationUp(d, time.Second))
		tcpsockopt_unix.go#L37: 	secs := int(roundDurationUp(d, time.Second))

	net/http
		fs.go#L520: 	modtime = modtime.Truncate(time.Second)
		fs.go#L571: 	modtime = modtime.Truncate(time.Second)
		h2_bundle.go#L1136: 	http2setDefault(&conf.PingTimeout, 1, math.MaxInt64, 15*time.Second)
		h2_bundle.go#L4104: 	http2prefaceTimeout        = 10 * time.Second
		h2_bundle.go#L4105: 	http2firstSettingsTimeout  = 2 * time.Second // should be in-flight with preface anyway
		h2_bundle.go#L5545: var http2goAwayTimeout = 1 * time.Second
		h2_bundle.go#L8074: 				d := time.Second * time.Duration(backoff)
		h2_bundle.go#L9872: 	const unusedWaitTime = 5 * time.Second
		server.go#L3435: 				if max := 1 * time.Second; tempDelay > max {
		transport.go#L48: 		Timeout:   30 * time.Second,
		transport.go#L49: 		KeepAlive: 30 * time.Second,
		transport.go#L53: 	IdleConnTimeout:       90 * time.Second,
		transport.go#L54: 	TLSHandshakeTimeout:   10 * time.Second,
		transport.go#L55: 	ExpectContinueTimeout: 1 * time.Second,

	net/http/pprof
		pprof.go#L126: 		timeout := srv.WriteTimeout + time.Duration(seconds*float64(time.Second))
		pprof.go#L163: 	sleep(r, time.Duration(sec)*time.Second)
		pprof.go#L189: 	sleep(r, time.Duration(sec*float64(time.Second)))
		pprof.go#L300: 	t := time.NewTimer(time.Duration(sec) * time.Second)

	testing
		benchmark.go#L35: 	benchTime = durationOrCountFlag{d: 1 * time.Second} // changed during test of testing package
		fuzz.go#L33: 	minimizeDuration = durationOrCountFlag{d: 60 * time.Second, allowZero: true}
		testing.go#L1300: 	const arbitraryTimeout = 2 * time.Second
		testing.go#L2493: 		list = append(list, fmt.Sprintf("%s (%v)", k.(string), highPrecisionTimeSince(v.(highPrecisionTime)).Round(time.Second)))