From 1e1ff064c03de172da15a4610d68564f03ab5ede Mon Sep 17 00:00:00 2001 From: Madhav Jivrajani Date: Thu, 9 Dec 2021 16:16:44 +0530 Subject: [PATCH] clock: Deprecate types to use k8s.io/utils/clock * Each exposed type/func is aliased to an equilvalent in k8s.io/utils/clock. * Adds deprecation notices to each type. * This package should be completely deleted in 1.25. * The test file is deleted since types are now references to k8s.io/utils/clock Signed-off-by: Madhav Jivrajani --- .../apimachinery/pkg/util/clock/clock.go | 438 ++---------------- .../apimachinery/pkg/util/clock/clock_test.go | 389 ---------------- 2 files changed, 37 insertions(+), 790 deletions(-) delete mode 100644 staging/src/k8s.io/apimachinery/pkg/util/clock/clock_test.go diff --git a/staging/src/k8s.io/apimachinery/pkg/util/clock/clock.go b/staging/src/k8s.io/apimachinery/pkg/util/clock/clock.go index 1a544d3b2e4..ff0914f991b 100644 --- a/staging/src/k8s.io/apimachinery/pkg/util/clock/clock.go +++ b/staging/src/k8s.io/apimachinery/pkg/util/clock/clock.go @@ -17,429 +17,65 @@ limitations under the License. package clock import ( - "sync" "time" + + clocks "k8s.io/utils/clock" + testclocks "k8s.io/utils/clock/testing" ) // PassiveClock allows for injecting fake or real clocks into code // that needs to read the current time but does not support scheduling // activity in the future. -type PassiveClock interface { - Now() time.Time - Since(time.Time) time.Duration -} +// +// Deprecated: Use k8s.io/utils/clock.PassiveClock instead. +type PassiveClock = clocks.PassiveClock // Clock allows for injecting fake or real clocks into code that // needs to do arbitrary things based on time. -type Clock interface { - PassiveClock - After(time.Duration) <-chan time.Time - AfterFunc(time.Duration, func()) Timer - NewTimer(time.Duration) Timer - Sleep(time.Duration) - NewTicker(time.Duration) Ticker -} +// +// Deprecated: Use k8s.io/utils/clock.WithTickerAndDelayedExecution instead. +type Clock = clocks.WithTickerAndDelayedExecution -// RealClock really calls time.Now() -type RealClock struct{} - -// Now returns the current time. -func (RealClock) Now() time.Time { - return time.Now() -} - -// Since returns time since the specified timestamp. -func (RealClock) Since(ts time.Time) time.Duration { - return time.Since(ts) -} - -// After is the same as time.After(d). -func (RealClock) After(d time.Duration) <-chan time.Time { - return time.After(d) -} - -// AfterFunc is the same as time.AfterFunc(d, f). -func (RealClock) AfterFunc(d time.Duration, f func()) Timer { - return &realTimer{ - timer: time.AfterFunc(d, f), - } -} - -// NewTimer returns a new Timer. -func (RealClock) NewTimer(d time.Duration) Timer { - return &realTimer{ - timer: time.NewTimer(d), - } -} - -// NewTicker returns a new Ticker. -func (RealClock) NewTicker(d time.Duration) Ticker { - return &realTicker{ - ticker: time.NewTicker(d), - } -} - -// Sleep pauses the RealClock for duration d. -func (RealClock) Sleep(d time.Duration) { - time.Sleep(d) -} +// Deprecated: Use k8s.io/utils/clock.RealClock instead. +type RealClock = clocks.RealClock // FakePassiveClock implements PassiveClock, but returns an arbitrary time. -type FakePassiveClock struct { - lock sync.RWMutex - time time.Time -} +// +// Deprecated: Use k8s.io/utils/clock/testing.FakePassiveClock instead. +type FakePassiveClock = testclocks.FakePassiveClock // FakeClock implements Clock, but returns an arbitrary time. -type FakeClock struct { - FakePassiveClock - - // waiters are waiting for the fake time to pass their specified time - waiters []fakeClockWaiter -} - -type fakeClockWaiter struct { - targetTime time.Time - stepInterval time.Duration - skipIfBlocked bool - destChan chan time.Time - afterFunc func() -} +// +// Deprecated: Use k8s.io/utils/clock/testing.FakeClock instead. +type FakeClock = testclocks.FakeClock // NewFakePassiveClock returns a new FakePassiveClock. -func NewFakePassiveClock(t time.Time) *FakePassiveClock { - return &FakePassiveClock{ - time: t, - } +// +// Deprecated: Use k8s.io/utils/clock/testing.NewFakePassiveClock instead. +func NewFakePassiveClock(t time.Time) *testclocks.FakePassiveClock { + return testclocks.NewFakePassiveClock(t) } -// NewFakeClock returns a new FakeClock -func NewFakeClock(t time.Time) *FakeClock { - return &FakeClock{ - FakePassiveClock: *NewFakePassiveClock(t), - } +// NewFakeClock returns a new FakeClock. +// +// Deprecated: Use k8s.io/utils/clock/testing.NewFakeClock instead. +func NewFakeClock(t time.Time) *testclocks.FakeClock { + return testclocks.NewFakeClock(t) } -// Now returns f's time. -func (f *FakePassiveClock) Now() time.Time { - f.lock.RLock() - defer f.lock.RUnlock() - return f.time -} - -// Since returns time since the time in f. -func (f *FakePassiveClock) Since(ts time.Time) time.Duration { - f.lock.RLock() - defer f.lock.RUnlock() - return f.time.Sub(ts) -} - -// SetTime sets the time on the FakePassiveClock. -func (f *FakePassiveClock) SetTime(t time.Time) { - f.lock.Lock() - defer f.lock.Unlock() - f.time = t -} - -// After is the Fake version of time.After(d). -func (f *FakeClock) After(d time.Duration) <-chan time.Time { - f.lock.Lock() - defer f.lock.Unlock() - stopTime := f.time.Add(d) - ch := make(chan time.Time, 1) // Don't block! - f.waiters = append(f.waiters, fakeClockWaiter{ - targetTime: stopTime, - destChan: ch, - }) - return ch -} - -// AfterFunc is the Fake version of time.AfterFunc(d, callback). -func (f *FakeClock) AfterFunc(d time.Duration, cb func()) Timer { - f.lock.Lock() - defer f.lock.Unlock() - stopTime := f.time.Add(d) - ch := make(chan time.Time, 1) // Don't block! - - timer := &fakeTimer{ - fakeClock: f, - waiter: fakeClockWaiter{ - targetTime: stopTime, - destChan: ch, - afterFunc: cb, - }, - } - f.waiters = append(f.waiters, timer.waiter) - return timer -} - -// NewTimer is the Fake version of time.NewTimer(d). -func (f *FakeClock) NewTimer(d time.Duration) Timer { - f.lock.Lock() - defer f.lock.Unlock() - stopTime := f.time.Add(d) - ch := make(chan time.Time, 1) // Don't block! - timer := &fakeTimer{ - fakeClock: f, - waiter: fakeClockWaiter{ - targetTime: stopTime, - destChan: ch, - }, - } - f.waiters = append(f.waiters, timer.waiter) - return timer -} - -// NewTicker returns a new Ticker. -func (f *FakeClock) NewTicker(d time.Duration) Ticker { - f.lock.Lock() - defer f.lock.Unlock() - tickTime := f.time.Add(d) - ch := make(chan time.Time, 1) // hold one tick - f.waiters = append(f.waiters, fakeClockWaiter{ - targetTime: tickTime, - stepInterval: d, - skipIfBlocked: true, - destChan: ch, - }) - - return &fakeTicker{ - c: ch, - } -} - -// Step moves clock by Duration, notifies anyone that's called After, Tick, or NewTimer -func (f *FakeClock) Step(d time.Duration) { - f.lock.Lock() - defer f.lock.Unlock() - f.setTimeLocked(f.time.Add(d)) -} - -// SetTime sets the time on a FakeClock. -func (f *FakeClock) SetTime(t time.Time) { - f.lock.Lock() - defer f.lock.Unlock() - f.setTimeLocked(t) -} - -// Actually changes the time and checks any waiters. f must be write-locked. -func (f *FakeClock) setTimeLocked(t time.Time) { - f.time = t - newWaiters := make([]fakeClockWaiter, 0, len(f.waiters)) - for i := range f.waiters { - w := &f.waiters[i] - if !w.targetTime.After(t) { - - if w.skipIfBlocked { - select { - case w.destChan <- t: - default: - } - } else { - w.destChan <- t - } - - if w.afterFunc != nil { - w.afterFunc() - } - - if w.stepInterval > 0 { - for !w.targetTime.After(t) { - w.targetTime = w.targetTime.Add(w.stepInterval) - } - newWaiters = append(newWaiters, *w) - } - - } else { - newWaiters = append(newWaiters, f.waiters[i]) - } - } - f.waiters = newWaiters -} - -// HasWaiters returns true if After or AfterFunc has been called on f but not yet satisfied -// (so you can write race-free tests). -func (f *FakeClock) HasWaiters() bool { - f.lock.RLock() - defer f.lock.RUnlock() - return len(f.waiters) > 0 -} - -// Sleep pauses the FakeClock for duration d. -func (f *FakeClock) Sleep(d time.Duration) { - f.Step(d) -} - -// IntervalClock implements Clock, but each invocation of Now steps the clock forward the specified duration -type IntervalClock struct { - Time time.Time - Duration time.Duration -} - -// Now returns i's time. -func (i *IntervalClock) Now() time.Time { - i.Time = i.Time.Add(i.Duration) - return i.Time -} - -// Since returns time since the time in i. -func (i *IntervalClock) Since(ts time.Time) time.Duration { - return i.Time.Sub(ts) -} - -// After is currently unimplemented, will panic. -// TODO: make interval clock use FakeClock so this can be implemented. -func (*IntervalClock) After(d time.Duration) <-chan time.Time { - panic("IntervalClock doesn't implement After") -} - -// AfterFunc is currently unimplemented, will panic. -// TODO: make interval clock use FakeClock so this can be implemented. -func (*IntervalClock) AfterFunc(d time.Duration, cb func()) Timer { - panic("IntervalClock doesn't implement AfterFunc") -} - -// NewTimer is currently unimplemented, will panic. -// TODO: make interval clock use FakeClock so this can be implemented. -func (*IntervalClock) NewTimer(d time.Duration) Timer { - panic("IntervalClock doesn't implement NewTimer") -} - -// NewTicker is currently unimplemented, will panic. -// TODO: make interval clock use FakeClock so this can be implemented. -func (*IntervalClock) NewTicker(d time.Duration) Ticker { - panic("IntervalClock doesn't implement NewTicker") -} - -// Sleep is currently unimplemented; will panic. -func (*IntervalClock) Sleep(d time.Duration) { - panic("IntervalClock doesn't implement Sleep") -} +// IntervalClock implements Clock, but each invocation of Now steps +// the clock forward the specified duration. +// +// Deprecated: Use k8s.io/utils/clock/testing.IntervalClock instead. +type IntervalClock = testclocks.IntervalClock // Timer allows for injecting fake or real timers into code that // needs to do arbitrary things based on time. -type Timer interface { - C() <-chan time.Time - Stop() bool - Reset(d time.Duration) bool -} - -// realTimer is backed by an actual time.Timer. -type realTimer struct { - timer *time.Timer -} - -// C returns the underlying timer's channel. -func (r *realTimer) C() <-chan time.Time { - return r.timer.C -} - -// Stop calls Stop() on the underlying timer. -func (r *realTimer) Stop() bool { - return r.timer.Stop() -} - -// Reset calls Reset() on the underlying timer. -func (r *realTimer) Reset(d time.Duration) bool { - return r.timer.Reset(d) -} - -// fakeTimer implements Timer based on a FakeClock. -type fakeTimer struct { - fakeClock *FakeClock - waiter fakeClockWaiter -} - -// C returns the channel that notifies when this timer has fired. -func (f *fakeTimer) C() <-chan time.Time { - return f.waiter.destChan -} - -// Stop conditionally stops the timer. If the timer has neither fired -// nor been stopped then this call stops the timer and returns true, -// otherwise this call returns false. This is like time.Timer::Stop. -func (f *fakeTimer) Stop() bool { - f.fakeClock.lock.Lock() - defer f.fakeClock.lock.Unlock() - // The timer has already fired or been stopped, unless it is found - // among the clock's waiters. - stopped := false - oldWaiters := f.fakeClock.waiters - newWaiters := make([]fakeClockWaiter, 0, len(oldWaiters)) - seekChan := f.waiter.destChan - for i := range oldWaiters { - // Identify the timer's fakeClockWaiter by the identity of the - // destination channel, nothing else is necessarily unique and - // constant since the timer's creation. - if oldWaiters[i].destChan == seekChan { - stopped = true - } else { - newWaiters = append(newWaiters, oldWaiters[i]) - } - } - - f.fakeClock.waiters = newWaiters - - return stopped -} - -// Reset conditionally updates the firing time of the timer. If the -// timer has neither fired nor been stopped then this call resets the -// timer to the fake clock's "now" + d and returns true, otherwise -// it creates a new waiter, adds it to the clock, and returns true. // -// It is not possible to return false, because a fake timer can be reset -// from any state (waiting to fire, already fired, and stopped). +// Deprecated: Use k8s.io/utils/clock.Timer instead. +type Timer = clocks.Timer + +// Ticker defines the Ticker interface. // -// See the GoDoc for time.Timer::Reset for more context on why -// the return value of Reset() is not useful. -func (f *fakeTimer) Reset(d time.Duration) bool { - f.fakeClock.lock.Lock() - defer f.fakeClock.lock.Unlock() - waiters := f.fakeClock.waiters - seekChan := f.waiter.destChan - for i := range waiters { - if waiters[i].destChan == seekChan { - waiters[i].targetTime = f.fakeClock.time.Add(d) - return true - } - } - // No existing waiter, timer has already fired or been reset. - // We should still enable Reset() to succeed by creating a - // new waiter and adding it to the clock's waiters. - newWaiter := fakeClockWaiter{ - targetTime: f.fakeClock.time.Add(d), - destChan: seekChan, - } - f.fakeClock.waiters = append(f.fakeClock.waiters, newWaiter) - return true -} - -// Ticker defines the Ticker interface -type Ticker interface { - C() <-chan time.Time - Stop() -} - -type realTicker struct { - ticker *time.Ticker -} - -func (t *realTicker) C() <-chan time.Time { - return t.ticker.C -} - -func (t *realTicker) Stop() { - t.ticker.Stop() -} - -type fakeTicker struct { - c <-chan time.Time -} - -func (t *fakeTicker) C() <-chan time.Time { - return t.c -} - -func (t *fakeTicker) Stop() { -} +// Deprecated: Use k8s.io/utils/clock.Ticker instead. +type Ticker = clocks.Ticker diff --git a/staging/src/k8s.io/apimachinery/pkg/util/clock/clock_test.go b/staging/src/k8s.io/apimachinery/pkg/util/clock/clock_test.go deleted file mode 100644 index 700d15ee541..00000000000 --- a/staging/src/k8s.io/apimachinery/pkg/util/clock/clock_test.go +++ /dev/null @@ -1,389 +0,0 @@ -/* -Copyright 2015 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package clock - -import ( - "testing" - "time" -) - -var ( - _ = Clock(RealClock{}) - _ = Clock(&FakeClock{}) - _ = Clock(&IntervalClock{}) - - _ = Timer(&realTimer{}) - _ = Timer(&fakeTimer{}) - - _ = Ticker(&realTicker{}) - _ = Ticker(&fakeTicker{}) -) - -type SettablePassiveClock interface { - PassiveClock - SetTime(time.Time) -} - -func exercisePassiveClock(t *testing.T, pc SettablePassiveClock) { - t1 := time.Now() - t2 := t1.Add(time.Hour) - pc.SetTime(t1) - tx := pc.Now() - if tx != t1 { - t.Errorf("SetTime(%#+v); Now() => %#+v", t1, tx) - } - dx := pc.Since(t1) - if dx != 0 { - t.Errorf("Since() => %v", dx) - } - pc.SetTime(t2) - dx = pc.Since(t1) - if dx != time.Hour { - t.Errorf("Since() => %v", dx) - } - tx = pc.Now() - if tx != t2 { - t.Errorf("Now() => %#+v", tx) - } -} - -func TestFakePassiveClock(t *testing.T) { - startTime := time.Now() - tc := NewFakePassiveClock(startTime) - exercisePassiveClock(t, tc) -} - -func TestFakeClock(t *testing.T) { - startTime := time.Now() - tc := NewFakeClock(startTime) - exercisePassiveClock(t, tc) - tc.SetTime(startTime) - tc.Step(time.Second) - now := tc.Now() - if now.Sub(startTime) != time.Second { - t.Errorf("input: %s now=%s gap=%s expected=%s", startTime, now, now.Sub(startTime), time.Second) - } -} - -func TestFakeClockSleep(t *testing.T) { - startTime := time.Now() - tc := NewFakeClock(startTime) - tc.Sleep(time.Duration(1) * time.Hour) - now := tc.Now() - if now.Sub(startTime) != time.Hour { - t.Errorf("Fake sleep failed, expected time to advance by one hour, instead, its %v", now.Sub(startTime)) - } -} - -func TestFakeAfter(t *testing.T) { - tc := NewFakeClock(time.Now()) - if tc.HasWaiters() { - t.Errorf("unexpected waiter?") - } - oneSec := tc.After(time.Second) - if !tc.HasWaiters() { - t.Errorf("unexpected lack of waiter?") - } - - oneOhOneSec := tc.After(time.Second + time.Millisecond) - twoSec := tc.After(2 * time.Second) - select { - case <-oneSec: - t.Errorf("unexpected channel read") - case <-oneOhOneSec: - t.Errorf("unexpected channel read") - case <-twoSec: - t.Errorf("unexpected channel read") - default: - } - - tc.Step(999 * time.Millisecond) - select { - case <-oneSec: - t.Errorf("unexpected channel read") - case <-oneOhOneSec: - t.Errorf("unexpected channel read") - case <-twoSec: - t.Errorf("unexpected channel read") - default: - } - - tc.Step(time.Millisecond) - select { - case <-oneSec: - // Expected! - case <-oneOhOneSec: - t.Errorf("unexpected channel read") - case <-twoSec: - t.Errorf("unexpected channel read") - default: - t.Errorf("unexpected non-channel read") - } - tc.Step(time.Millisecond) - select { - case <-oneSec: - // should not double-trigger! - t.Errorf("unexpected channel read") - case <-oneOhOneSec: - // Expected! - case <-twoSec: - t.Errorf("unexpected channel read") - default: - t.Errorf("unexpected non-channel read") - } -} - -func TestFakeAfterFunc(t *testing.T) { - tc := NewFakeClock(time.Now()) - if tc.HasWaiters() { - t.Errorf("unexpected waiter?") - } - expectOneSecTimerFire := false - oneSecTimerFire := 0 - tc.AfterFunc(time.Second, func() { - if !expectOneSecTimerFire { - t.Errorf("oneSecTimer func fired") - } else { - oneSecTimerFire++ - } - }) - if !tc.HasWaiters() { - t.Errorf("unexpected lack of waiter?") - } - - expectOneOhOneSecTimerFire := false - oneOhOneSecTimerFire := 0 - tc.AfterFunc(time.Second+time.Millisecond, func() { - if !expectOneOhOneSecTimerFire { - t.Errorf("oneOhOneSecTimer func fired") - } else { - oneOhOneSecTimerFire++ - } - }) - - expectTwoSecTimerFire := false - twoSecTimerFire := 0 - twoSecTimer := tc.AfterFunc(2*time.Second, func() { - if !expectTwoSecTimerFire { - t.Errorf("twoSecTimer func fired") - } else { - twoSecTimerFire++ - } - }) - - tc.Step(999 * time.Millisecond) - - expectOneSecTimerFire = true - tc.Step(time.Millisecond) - if oneSecTimerFire != 1 { - t.Errorf("expected oneSecTimerFire=1, got %d", oneSecTimerFire) - } - expectOneSecTimerFire = false - - expectOneOhOneSecTimerFire = true - tc.Step(time.Millisecond) - if oneOhOneSecTimerFire != 1 { - // should not double-trigger! - t.Errorf("expected oneOhOneSecTimerFire=1, got %d", oneOhOneSecTimerFire) - } - expectOneOhOneSecTimerFire = false - - // ensure a canceled timer doesn't fire - twoSecTimer.Stop() - tc.Step(time.Second) -} - -func TestFakeTimer(t *testing.T) { - tc := NewFakeClock(time.Now()) - if tc.HasWaiters() { - t.Errorf("unexpected waiter?") - } - oneSec := tc.NewTimer(time.Second) - twoSec := tc.NewTimer(time.Second * 2) - treSec := tc.NewTimer(time.Second * 3) - if !tc.HasWaiters() { - t.Errorf("unexpected lack of waiter?") - } - select { - case <-oneSec.C(): - t.Errorf("unexpected channel read") - case <-twoSec.C(): - t.Errorf("unexpected channel read") - case <-treSec.C(): - t.Errorf("unexpected channel read") - default: - } - tc.Step(999999999 * time.Nanosecond) // t=.999,999,999 - select { - case <-oneSec.C(): - t.Errorf("unexpected channel read") - case <-twoSec.C(): - t.Errorf("unexpected channel read") - case <-treSec.C(): - t.Errorf("unexpected channel read") - default: - } - tc.Step(time.Nanosecond) // t=1 - select { - case <-twoSec.C(): - t.Errorf("unexpected channel read") - case <-treSec.C(): - t.Errorf("unexpected channel read") - default: - } - select { - case <-oneSec.C(): - // Expected! - default: - t.Errorf("unexpected channel non-read") - } - tc.Step(time.Nanosecond) // t=1.000,000,001 - select { - case <-oneSec.C(): - t.Errorf("unexpected channel read") - case <-twoSec.C(): - t.Errorf("unexpected channel read") - case <-treSec.C(): - t.Errorf("unexpected channel read") - default: - } - if oneSec.Stop() { - t.Errorf("Expected oneSec.Stop() to return false") - } - if !twoSec.Stop() { - t.Errorf("Expected twoSec.Stop() to return true") - } - tc.Step(time.Second) // t=2.000,000,001 - select { - case <-oneSec.C(): - t.Errorf("unexpected channel read") - case <-twoSec.C(): - t.Errorf("unexpected channel read") - case <-treSec.C(): - t.Errorf("unexpected channel read") - default: - } - if !twoSec.Reset(time.Second) { - t.Errorf("Expected twoSec.Reset() to return true") - } - if !treSec.Reset(time.Second) { - t.Errorf("Expected treSec.Reset() to return true") - } - tc.Step(time.Nanosecond * 999999999) // t=3.0 - select { - case <-oneSec.C(): - t.Errorf("unexpected channel read") - case <-twoSec.C(): - t.Errorf("unexpected channel read") - case <-treSec.C(): - t.Errorf("unexpected channel read") - default: - } - tc.Step(time.Nanosecond) // t=3.000,000,001 - select { - case <-oneSec.C(): - t.Errorf("unexpected channel read") - case <-twoSec.C(): - // Expected! - default: - t.Errorf("unexpected channel non-read") - } - select { - case <-treSec.C(): - // Expected! - default: - t.Errorf("unexpected channel non-read") - } -} - -func TestFakeTick(t *testing.T) { - tc := NewFakeClock(time.Now()) - if tc.HasWaiters() { - t.Errorf("unexpected waiter?") - } - oneSec := tc.NewTicker(time.Second).C() - if !tc.HasWaiters() { - t.Errorf("unexpected lack of waiter?") - } - - oneOhOneSec := tc.NewTicker(time.Second + time.Millisecond).C() - twoSec := tc.NewTicker(2 * time.Second).C() - select { - case <-oneSec: - t.Errorf("unexpected channel read") - case <-oneOhOneSec: - t.Errorf("unexpected channel read") - case <-twoSec: - t.Errorf("unexpected channel read") - default: - } - - tc.Step(999 * time.Millisecond) // t=.999 - select { - case <-oneSec: - t.Errorf("unexpected channel read") - case <-oneOhOneSec: - t.Errorf("unexpected channel read") - case <-twoSec: - t.Errorf("unexpected channel read") - default: - } - - tc.Step(time.Millisecond) // t=1.000 - select { - case <-oneSec: - // Expected! - case <-oneOhOneSec: - t.Errorf("unexpected channel read") - case <-twoSec: - t.Errorf("unexpected channel read") - default: - t.Errorf("unexpected non-channel read") - } - tc.Step(time.Millisecond) // t=1.001 - select { - case <-oneSec: - // should not double-trigger! - t.Errorf("unexpected channel read") - case <-oneOhOneSec: - // Expected! - case <-twoSec: - t.Errorf("unexpected channel read") - default: - t.Errorf("unexpected non-channel read") - } - - tc.Step(time.Second) // t=2.001 - tc.Step(time.Second) // t=3.001 - tc.Step(time.Second) // t=4.001 - tc.Step(time.Second) // t=5.001 - - // The one second ticker should not accumulate ticks - accumulatedTicks := 0 - drained := false - for !drained { - select { - case <-oneSec: - accumulatedTicks++ - default: - drained = true - } - } - if accumulatedTicks != 1 { - t.Errorf("unexpected number of accumulated ticks: %d", accumulatedTicks) - } -}