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 <madhav.jiv@gmail.com>

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
+// Deprecated: Use k8s.io/utils/clock.PassiveClock instead.
-	Since(time.Time) time.Duration
+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
+// Deprecated: Use k8s.io/utils/clock.WithTickerAndDelayedExecution instead.
-	After(time.Duration) <-chan time.Time
+type Clock = clocks.WithTickerAndDelayedExecution
-	AfterFunc(time.Duration, func()) Timer
-	NewTimer(time.Duration) Timer
-	Sleep(time.Duration)
-	NewTicker(time.Duration) Ticker
-}
 
-// RealClock really calls time.Now()
+// Deprecated: Use k8s.io/utils/clock.RealClock instead.
-type RealClock struct{}
+type RealClock = clocks.RealClock
-
-// 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)
-}
 
 // FakePassiveClock implements PassiveClock, but returns an arbitrary time.
-type FakePassiveClock struct {
+//
-	lock sync.RWMutex
+// Deprecated: Use k8s.io/utils/clock/testing.FakePassiveClock instead.
-	time time.Time
+type FakePassiveClock = testclocks.FakePassiveClock
-}
 
 // FakeClock implements Clock, but returns an arbitrary time.
-type FakeClock struct {
+//
-	FakePassiveClock
+// Deprecated: Use k8s.io/utils/clock/testing.FakeClock instead.
-
+type FakeClock = testclocks.FakeClock
-	// 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()
-}
 
 // NewFakePassiveClock returns a new FakePassiveClock.
-func NewFakePassiveClock(t time.Time) *FakePassiveClock {
+//
-	return &FakePassiveClock{
+// Deprecated: Use k8s.io/utils/clock/testing.NewFakePassiveClock instead.
-		time: t,
+func NewFakePassiveClock(t time.Time) *testclocks.FakePassiveClock {
-	}
+	return testclocks.NewFakePassiveClock(t)
 }
 
-// NewFakeClock returns a new FakeClock
+// NewFakeClock returns a new FakeClock.
-func NewFakeClock(t time.Time) *FakeClock {
+//
-	return &FakeClock{
+// Deprecated: Use k8s.io/utils/clock/testing.NewFakeClock instead.
-		FakePassiveClock: *NewFakePassiveClock(t),
+func NewFakeClock(t time.Time) *testclocks.FakeClock {
-	}
+	return testclocks.NewFakeClock(t)
 }
 
-// Now returns f's time.
+// IntervalClock implements Clock, but each invocation of Now steps
-func (f *FakePassiveClock) Now() time.Time {
+// the clock forward the specified duration.
-	f.lock.RLock()
+//
-	defer f.lock.RUnlock()
+// Deprecated: Use k8s.io/utils/clock/testing.IntervalClock instead.
-	return f.time
+type IntervalClock = testclocks.IntervalClock
-}
-
-// 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")
-}
 
 // 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
+// Deprecated: Use k8s.io/utils/clock.Timer instead.
-// from any state (waiting to fire, already fired, and stopped).
+type Timer = clocks.Timer
+
+// Ticker defines the Ticker interface.
 //
-// See the GoDoc for time.Timer::Reset for more context on why
+// Deprecated: Use k8s.io/utils/clock.Ticker instead.
-// the return value of Reset() is not useful.
+type Ticker = clocks.Ticker
-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() {
-}

staging/src/k8s.io/apimachinery/pkg/util/clock/clock_test.go

@@ -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)
-	}
-}