Add Context cancellation to clock.

common/clock/testclock/testtimer_test.go

 // Copyright 2015 The Chromium 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 testclock
 
 import (
         "testing"
         "time"
 
         "github.com/luci/luci-go/common/clock"
+        "golang.org/x/net/context"
+
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func TestTestTimer(t *testing.T) {
         t.Parallel()
 
         Convey(`A testing clock instance`, t, func() {
-                now := time.Date(2015, 01, 01, 00, 00, 00, 00, time.UTC)
+                ctx := context.Background()
+                now := TestTimeLocal
                 c := New(now)
 
                 Convey(`A timer instance`, func() {
-                        t := c.NewTimer()
+                        t := c.NewTimer(ctx)
 
                         Convey(`Should have a non-nil C.`, func() {
-                                So(t.GetC(), ShouldBeNil)
+                                So(t.GetC(), ShouldNotBeNil)
                         })
 
                         Convey(`When activated`, func() {
                                 So(t.Reset(1*time.Second), ShouldBeFalse)
 
                                 Convey(`When reset, should return active.`, func() {
                                         So(t.Reset(1*time.Hour), ShouldBeTrue)
                                         So(t.GetC(), ShouldNotBeNil)
                                 })
 
                                 Convey(`When stopped, should return active.`, func() {
                                         So(t.Stop(), ShouldBeTrue)
-                                        So(t.GetC(), ShouldBeNil)
+                                        So(t.GetC(), ShouldNotBeNil)
 
                                         Convey(`And when stopped again, should return inactive.`, func() {
                                                 So(t.Stop(), ShouldBeFalse)
-                                                So(t.GetC(), ShouldBeNil)
+                                                So(t.GetC(), ShouldNotBeNil)
                                         })
                                 })
 
                                 Convey(`When stopped after expiring, should not have a signal.`, func() {
                                         c.Add(1 * time.Second)
                                         So(t.Stop(), ShouldBeTrue)
 
                                         var signalled bool
                                         select {
                                         case <-t.GetC():
                                                 signalled = true
                                         default:
                                                 break
                                         }
                                         So(signalled, ShouldBeFalse)
                                 })
                         })
 
                         Convey(`Should successfully signal.`, func() {
                                 So(t.Reset(1*time.Second), ShouldBeFalse)
                                 c.Add(1 * time.Second)
 
-                                So(t.GetC(), ShouldNotBeNil)
-                                So(<-t.GetC(), ShouldResemble, now.Add(1*time.Second))
+                                So(<-t.GetC(), ShouldResemble, clock.AfterResult{Time: now.Add(1 * time.Second)})
                         })
                 })
 
-                Convey(`Multiple goroutines using the timer...`, func() {
+                Convey(`Multiple goroutines using timers...`, func() {
                         // Mark when timers are started, so we can ensure that our signalling
                         // happens after the timers have been instantiated.
                         timerStartedC := make(chan bool)
                         c.SetTimerCallback(func(_ time.Duration, _ clock.Timer) {
                                 timerStartedC <- true
                         })
 
-                        resultC := make(chan time.Time)
+                        resultC := make(chan clock.AfterResult)
                         for i := time.Duration(0); i < 5; i++ {
                                 go func(d time.Duration) {
-                                        timer := c.NewTimer()
+                                        timer := c.NewTimer(ctx)
                                         timer.Reset(d)
                                         resultC <- <-timer.GetC()
                                 }(i * time.Second)
                                 <-timerStartedC
                         }
 
                         moreResults := func() bool {
                                 select {
                                 case <-resultC:
                                         return true
@@ skipping 14 matching lines @@
                         <-resultC
                         So(moreResults(), ShouldBeFalse)
 
                         // Advance clock to +10s. One final timer should signal.
                         c.Set(now.Add(10 * time.Second))
                         <-resultC
                         So(moreResults(), ShouldBeFalse)
                 })
         })
 }