Merge pull request #38 from rosstimothy/master

Add Timers

Author: sagikazarmark

clockwork.go

@@ -13,6 +13,7 @@ type Clock interface {
 	Now() time.Time
 	Since(t time.Time) time.Duration
 	NewTicker(d time.Duration) Ticker
+	NewTimer(d time.Duration) Timer
 }
 
 // FakeClock provides an interface for a clock which can be
@@ -70,6 +71,10 @@ func (rc *realClock) NewTicker(d time.Duration) Ticker {
 	return &realTicker{time.NewTicker(d)}
 }
 
+func (rc *realClock) NewTimer(d time.Duration) Timer {
+	return &realTimer{time.NewTimer(d)}
+}
+
 type fakeClock struct {
 	sleepers []*sleeper
 	blockers []*blocker
@@ -132,7 +137,7 @@ func (fc *fakeClock) Sleep(d time.Duration) {
 	<-fc.After(d)
 }
 
-// Time returns the current time of the fakeClock
+// Now returns the current time of the fakeClock
 func (fc *fakeClock) Now() time.Time {
 	fc.l.RLock()
 	t := fc.time
@@ -145,6 +150,8 @@ func (fc *fakeClock) Since(t time.Time) time.Duration {
 	return fc.Now().Sub(t)
 }
 
+// NewTicker returns a ticker that will expire only after calls to fakeClock
+// Advance have moved the clock passed the given duration
 func (fc *fakeClock) NewTicker(d time.Duration) Ticker {
 	ft := &fakeTicker{
 		c:      make(chan time.Time, 1),
@@ -156,6 +163,25 @@ func (fc *fakeClock) NewTicker(d time.Duration) Ticker {
 	return ft
 }
 
+// NewTimer returns a timer that will fire only after calls to fakeClock
+// Advance have moved the clock passed the given duration
+func (fc *fakeClock) NewTimer(d time.Duration) Timer {
+	stopped := uint32(0)
+	if d <= 0 {
+		stopped = 1
+	}
+	ft := &fakeTimer{
+		c:       make(chan time.Time, 1),
+		stop:    make(chan struct{}, 1),
+		reset:   make(chan reset, 1),
+		clock:   fc,
+		stopped: stopped,
+	}
+
+	ft.run(d)
+	return ft
+}
+
 // Advance advances fakeClock to a new point in time, ensuring channels from any
 // previous invocations of After are notified appropriately before returning
 func (fc *fakeClock) Advance(d time.Duration) {

timer.go

@@ -0,0 +1,97 @@
+package clockwork
+
+import (
+	"sync/atomic"
+	"time"
+)
+
+// Timer provides an interface which can be used instead of directly
+// using the timer within the time module. The real-time timer t
+// provides events through t.C which becomes now t.Chan() to make
+// this channel requirement definable in this interface.
+type Timer interface {
+	Chan() <-chan time.Time
+	Reset(d time.Duration) bool
+	Stop() bool
+}
+
+type realTimer struct {
+	*time.Timer
+}
+
+func (r realTimer) Chan() <-chan time.Time {
+	return r.C
+}
+
+type fakeTimer struct {
+	c       chan time.Time
+	clock   FakeClock
+	stop    chan struct{}
+	reset   chan reset
+	stopped uint32
+}
+
+func (f *fakeTimer) Chan() <-chan time.Time {
+	return f.c
+}
+
+func (f *fakeTimer) Reset(d time.Duration) bool {
+	stopped := f.Stop()
+
+	f.reset <- reset{t: f.clock.Now().Add(d), next: f.clock.After(d)}
+	if d > 0 {
+		atomic.StoreUint32(&f.stopped, 0)
+	}
+
+	return stopped
+}
+
+func (f *fakeTimer) Stop() bool {
+	if atomic.CompareAndSwapUint32(&f.stopped, 0, 1) {
+		f.stop <- struct{}{}
+		return true
+	}
+	return false
+}
+
+type reset struct {
+	t    time.Time
+	next <-chan time.Time
+}
+
+// run initializes a background goroutine to send the timer event to the timer channel
+// after the period. Events are discarded if the underlying ticker channel does not have
+// enough capacity.
+func (f *fakeTimer) run(initialDuration time.Duration) {
+	nextTick := f.clock.Now().Add(initialDuration)
+	next := f.clock.After(initialDuration)
+
+	waitForReset := func() (time.Time, <-chan time.Time) {
+		for {
+			select {
+			case <-f.stop:
+				continue
+			case r := <-f.reset:
+				return r.t, r.next
+			}
+		}
+	}
+
+	go func() {
+		for {
+			select {
+			case <-f.stop:
+			case <-next:
+				atomic.StoreUint32(&f.stopped, 1)
+				select {
+				case f.c <- nextTick:
+				default:
+				}
+
+				next = nil
+			}
+
+			nextTick, next = waitForReset()
+		}
+	}()
+}

timer_test.go

@@ -0,0 +1,135 @@
+package clockwork
+
+import (
+	"testing"
+	"time"
+)
+
+func TestFakeClockTimerStop(t *testing.T) {
+	fc := &fakeClock{}
+
+	ft := fc.NewTimer(1)
+	ft.Stop()
+	select {
+	case <-ft.Chan():
+		t.Errorf("received unexpected tick!")
+	default:
+	}
+}
+
+func TestFakeClockTimers(t *testing.T) {
+	fc := &fakeClock{}
+
+	zero := fc.NewTimer(0)
+
+	if zero.Stop() {
+		t.Errorf("zero timer could be stopped")
+	}
+
+	timeout := time.NewTimer(500 * time.Millisecond)
+	defer timeout.Stop()
+
+	select {
+	case <-zero.Chan():
+	case <-timeout.C:
+		t.Errorf("zero timer didn't emit time")
+	}
+
+	one := fc.NewTimer(1)
+
+	select {
+	case <-one.Chan():
+		t.Errorf("non-zero timer did emit time")
+	default:
+	}
+	if !one.Stop() {
+		t.Errorf("non-zero timer couldn't be stopped")
+	}
+
+	fc.Advance(5)
+
+	select {
+	case <-one.Chan():
+		t.Errorf("stopped timer did emit time")
+	default:
+	}
+
+	if one.Reset(1) {
+		t.Errorf("resetting stopped timer didn't return false")
+	}
+	if !one.Reset(1) {
+		t.Errorf("resetting active timer didn't return true")
+	}
+
+	fc.Advance(1)
+
+	select {
+	case <-time.After(500 * time.Millisecond):
+	}
+
+	if one.Stop() {
+		t.Errorf("triggered timer could be stopped")
+	}
+
+	timeout2 := time.NewTimer(500 * time.Millisecond)
+	defer timeout2.Stop()
+
+	select {
+	case <-one.Chan():
+	case <-timeout2.C:
+		t.Errorf("triggered timer didn't emit time")
+	}
+
+	fc.Advance(1)
+
+	select {
+	case <-one.Chan():
+		t.Errorf("triggered timer emitted time more than once")
+	default:
+	}
+
+	one.Reset(0)
+
+	if one.Stop() {
+		t.Errorf("reset to zero timer could be stopped")
+	}
+
+	timeout3 := time.NewTimer(500 * time.Millisecond)
+	defer timeout3.Stop()
+
+	select {
+	case <-one.Chan():
+	case <-timeout3.C:
+		t.Errorf("reset to zero timer didn't emit time")
+	}
+}
+
+func TestFakeClockTimer_Race(t *testing.T) {
+	fc := NewFakeClock()
+
+	timer := fc.NewTimer(1 * time.Millisecond)
+	defer timer.Stop()
+
+	fc.Advance(1 * time.Millisecond)
+
+	timeout := time.NewTimer(500 * time.Millisecond)
+	defer timeout.Stop()
+
+	select {
+	case <-timer.Chan():
+		// Pass
+	case <-timeout.C:
+		t.Fatalf("Timer didn't detect the clock advance!")
+	}
+}
+
+func TestFakeClockTimer_Race2(t *testing.T) {
+	fc := NewFakeClock()
+	timer := fc.NewTimer(5 * time.Second)
+	for i := 0; i < 100; i++ {
+		fc.Advance(5 * time.Second)
+		<-timer.Chan()
+		timer.Reset(5 * time.Second)
+	}
+	timer.Stop()
+}