func (s *TickerTestSuite) TestSleepTime60s(t *check.C) {
// Fri Sep 27 18:11:37.385120 -0700 PDT 2013 =
now := int64(1380330697385120263)
c := make(chan time.Time)
et := ticker.NewEvenTicker(60, sleep)
et.Add(c)
go et.Run(now)
<-c
got := slept.Nanoseconds()
expect := int64(614879744 + (22 * time.Second))
if got != expect {
t.Errorf("Got %d, expected %d\n", got, expect)
}
et.Stop()
}
func (s *TickerTestSuite) TestSleepTime2s(t *check.C) {
/*
* To sync at intervals, we must first sleep N number of nanoseconds
* until the next interval. So we specify the curren time (now) in
* nanaseconds, and an interval time (2), and then we know how long
* the syncer should sleep to wait from now until the next interval
* time.
*/
// Fri Sep 27 18:11:37.385120 -0700 PDT 2013 =
now := int64(1380330697385120263)
// The next 2s interval, 18:11:38.000, is 0.61488 seconds away,
// so that's how long syncer should tell our sleep func to sleep.
c := make(chan time.Time)
et := ticker.NewEvenTicker(2, sleep)
et.Add(c)
// Run ticker then wait for first tick.
go et.Run(now)
<-c
// Check how long ticker slept.
got := slept.Nanoseconds()
expect := int64(614879744)
if got != expect {
t.Errorf("Got %d, expected %d\n", got, expect)
}
// ETA (time to next tick) should be reported as the same: 0.614880s
d := et.ETA(now)
if d < 0.614 || d > 0.615 {
t.Errorf("Got ETA %f, expected 0.614880\n", d)
}
et.Stop()
}
func (s *TickerTestSuite) TestTickerTime(t *check.C) {
/*
* The ticker returned by the syncer should tick at this given interval,
* 2s in this case. We test this by ensuring that the current time at
* a couple of ticks is divisible by 2, and that the fractional seconds
* part is < ~1 millisecond, e.g.:
* 00:00:02.000123456 OK
* 00:00:04.000123456 OK
* 00:00:06.001987654 BAD
* This may fail on slow test machines.
*/
c1 := make(chan time.Time)
c2 := make(chan time.Time)
et := ticker.NewEvenTicker(2, time.Sleep)
et.Add(c1)
et.Add(c2)
go et.Run(time.Now().UnixNano())
// Get 2 ticks but only on c1. "Time waits for nobody" and neither does
// the ticker, so c2 not receiving should not affect c1.
maxOffBy := 900000 // 900,000 ns = ~1ms
var lastTick time.Time
for i := 0; i < 2; i++ {
select {
case tick := <-c1:
sec := tick.Second()
if sec%2 > 0 {
t.Errorf("Tick %d not 2s interval: %d", i, sec)
}
nano := tick.Nanosecond()
if nano >= maxOffBy {
t.Errorf("Tick %d failed: %d >= %d", i, nano, maxOffBy)
}
lastTick = tick
}
}
// Remove c1 and recv on c2 now. Even though c2 missed previous 2 ticks,
// it should be able to start receiving new ticks. By contrast, c1 should
// not receive the tick.
et.Remove(c1)
timeout := time.After(2500 * time.Millisecond)
var c2Tick time.Time
TICK_LOOP:
for {
select {
case tick := <-c2:
if !c2Tick.IsZero() {
t.Error("c2 gets only 1 tick")
} else {
c2Tick = tick
}
case <-c1:
t.Error("c1 does not get current tick")
case <-timeout:
break TICK_LOOP
}
}
if c2Tick == lastTick || c2Tick.Before(lastTick) {
t.Error("c2 gets current tick")
}
et.Stop()
}