blob: d8cd59228f0fd47adf01273d384fd48a876f44c4 [file] [log] [blame]
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package time_test
import (
"fmt"
"runtime"
"testing"
. "time"
)
func TestTicker(t *testing.T) {
// We want to test that a ticker takes as much time as expected.
// Since we don't want the test to run for too long, we don't
// want to use lengthy times. This makes the test inherently flaky.
// Start with a short time, but try again with a long one if the
// first test fails.
baseCount := 10
baseDelta := 20 * Millisecond
// On Darwin ARM64 the tick frequency seems limited. Issue 35692.
if (runtime.GOOS == "darwin" || runtime.GOOS == "ios") && runtime.GOARCH == "arm64" {
// The following test will run ticker count/2 times then reset
// the ticker to double the duration for the rest of count/2.
// Since tick frequency is limited on Darwin ARM64, use even
// number to give the ticks more time to let the test pass.
// See CL 220638.
baseCount = 6
baseDelta = 100 * Millisecond
}
var errs []string
logErrs := func() {
for _, e := range errs {
t.Log(e)
}
}
for _, test := range []struct {
count int
delta Duration
}{{
count: baseCount,
delta: baseDelta,
}, {
count: 8,
delta: 1 * Second,
}} {
count, delta := test.count, test.delta
ticker := NewTicker(delta)
t0 := Now()
for i := 0; i < count/2; i++ {
<-ticker.C
}
ticker.Reset(delta * 2)
for i := count / 2; i < count; i++ {
<-ticker.C
}
ticker.Stop()
t1 := Now()
dt := t1.Sub(t0)
target := 3 * delta * Duration(count/2)
slop := target * 3 / 10
if dt < target-slop || dt > target+slop {
errs = append(errs, fmt.Sprintf("%d %s ticks then %d %s ticks took %s, expected [%s,%s]", count/2, delta, count/2, delta*2, dt, target-slop, target+slop))
if dt > target+slop {
// System may be overloaded; sleep a bit
// in the hopes it will recover.
Sleep(Second / 2)
}
continue
}
// Now test that the ticker stopped.
Sleep(2 * delta)
select {
case <-ticker.C:
errs = append(errs, "Ticker did not shut down")
continue
default:
// ok
}
// Test passed, so all done.
if len(errs) > 0 {
t.Logf("saw %d errors, ignoring to avoid flakiness", len(errs))
logErrs()
}
return
}
t.Errorf("saw %d errors", len(errs))
logErrs()
}
// Issue 21874
func TestTickerStopWithDirectInitialization(t *testing.T) {
c := make(chan Time)
tk := &Ticker{C: c}
tk.Stop()
}
// Test that a bug tearing down a ticker has been fixed. This routine should not deadlock.
func TestTeardown(t *testing.T) {
Delta := 100 * Millisecond
if testing.Short() {
Delta = 20 * Millisecond
}
for i := 0; i < 3; i++ {
ticker := NewTicker(Delta)
<-ticker.C
ticker.Stop()
}
}
// Test the Tick convenience wrapper.
func TestTick(t *testing.T) {
// Test that giving a negative duration returns nil.
if got := Tick(-1); got != nil {
t.Errorf("Tick(-1) = %v; want nil", got)
}
}
// Test that NewTicker panics when given a duration less than zero.
func TestNewTickerLtZeroDuration(t *testing.T) {
defer func() {
if err := recover(); err == nil {
t.Errorf("NewTicker(-1) should have panicked")
}
}()
NewTicker(-1)
}
func BenchmarkTicker(b *testing.B) {
benchmark(b, func(n int) {
ticker := NewTicker(Nanosecond)
for i := 0; i < n; i++ {
<-ticker.C
}
ticker.Stop()
})
}
func BenchmarkTickerReset(b *testing.B) {
benchmark(b, func(n int) {
ticker := NewTicker(Nanosecond)
for i := 0; i < n; i++ {
ticker.Reset(Nanosecond * 2)
}
ticker.Stop()
})
}
func BenchmarkTickerResetNaive(b *testing.B) {
benchmark(b, func(n int) {
ticker := NewTicker(Nanosecond)
for i := 0; i < n; i++ {
ticker.Stop()
ticker = NewTicker(Nanosecond * 2)
}
ticker.Stop()
})
}