Add context-aware "time" library wrapper.

go/src/infra/libs/clock/systemtimer_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 clock
+
+import (
+        "testing"
+        "time"
+
+        . "github.com/smartystreets/goconvey/convey"
+)
+
+func TestSystemTimer(t *testing.T) {

[iannucci, 2015/06/03 17:37:20]

in general we should be in the habit of starting all test functions with

  t.Parallel()

As both an indicator that the test can be run independently, and so when we run
with GOMAXPROCS>1 (the default in 1.5), we'll get a speed boost.

[dnj, 2015/06/03 18:21:27]

Done.

+        Convey(`A systemTimer instance`, t, func() {
+                t := new(systemTimer)
+
+                Convey(`Should start with a nil channel.`, func() {
+                        So(t.GetC(), ShouldBeNil)
+                })
+
+                Convey(`When stopped, should return inactive.`, func() {
+                        So(t.Stop(), ShouldBeFalse)
+                })
+
+                Convey(`When reset`, func() {
+                        active := t.Reset(1 * time.Hour)
+                        So(active, ShouldBeFalse)
+
+                        Convey(`When reset to a short duration`, func() {
+                                active := t.Reset(1 * time.Microsecond)
+
+                                Convey(`Should return active.`, func() {
+                                        So(active, ShouldBeTrue)
+                                })
+
+                                Convey(`Should trigger shortly.`, func() {
+                                        tm := <-t.GetC()
+                                        So(tm, ShouldNotResemble, time.Time{})
+                                })
+                        })
+
+                        Convey(`When stopped, should return active and have a non-nil C.`, func() {
+                                active := t.Stop()
+                                So(active, ShouldBeTrue)
+                                So(t.GetC(), ShouldNotBeNil)
+                        })
+
+                        Convey(`When stopped, should return active.`, func() {
+                                active := t.Stop()
+                                So(active, ShouldBeTrue)
+                        })
+
+                        Convey(`Should have a non-nil channel.`, func() {
+                                So(t.GetC(), ShouldNotBeNil)
+                        })
+
+                        Reset(func() {
+                                t.Stop()
+                        })
+                })
+        })
+}