-
Notifications
You must be signed in to change notification settings - Fork 0
/
i_test.go
131 lines (106 loc) · 2.74 KB
/
i_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
package r
import (
"math/rand"
"testing"
"time"
)
func TestNew(t *testing.T) {
i := NewInterval(time.Second, func() {})
if cap(i.timer) != 0 {
t.Fatalf("expected channel buffer size 1; got=%d instead", cap(i.timer))
}
if i.running {
t.Fatalf("expected running to be false")
}
}
// TODO(yawboakye): Revisit this test case. I'm not
// confident that I've tested it the best way possible.
func TestStart(t *testing.T) {
var calls int
var expected = 1 + rand.Intn(5)
i := NewInterval(time.Second, func() { calls++ })
// Start the interval, wait for the expected number of
// calls and then stop it.
i.Start()
wait(expected)
i.running = false // instead of `i.Stop()`
// expect the function to be have been called
// the expected number of times.
if calls != expected {
t.Fatalf("expected=%d; got=%d instead", expected, calls)
}
}
func TestStartStart(t *testing.T) {
i := NewInterval(time.Second, func() {})
i.Start()
if ok := i.Start(); ok {
t.Fatalf("started an already running interval")
}
i.Stop()
}
func TestStarted(t *testing.T) {
i := NewInterval(time.Second, func() {})
i.Start()
wait(1)
if i.Started() != i.started {
t.Fatalf("expected=%d; got=%d instead", i.started, i.Started())
}
}
func TestStop(t *testing.T) {
var j int
i := NewInterval(2*time.Second, func() { j++ })
i.Start()
wait(3)
i.Stop()
if j != i.started {
t.Fatalf("expected completions=%d; got=%d instead", i.started, j)
}
// expect `running` to be false
if i.running {
t.Fatalf("interval still running. not stopped")
}
// expect the timer channel to be closed
if _, ok := <-i.timer; ok {
t.Fatalf("expected timer channel to be closed")
}
// stopping an already stopped interval returns error
if err := i.Stop(); err == nil {
t.Fatalf("expected=%v; got=%v instead", errStop, nil)
}
}
func TestAbort(t *testing.T) {
var j int
// slowFn waits for 2 seconds and then increments j.
slowFn := func() {
time.Sleep(2 * time.Second)
j++
}
i := NewInterval(time.Second, slowFn)
i.Start()
wait(3)
i.Abort()
if j >= i.started {
t.Fatalf("expected completions=%d; got=%d instead", j, i.started)
}
// expect `aborted` to be true
if !i.aborted {
t.Fatal("interval not aborted")
}
// expect the abort channel to be closed
if _, ok := <-i.abort; ok {
t.Fatal("expected abort channel to be closed")
}
// expect `running` to be false
if i.running {
t.Fatal("interval still running. not stopped")
}
// expect the timer channel to be closed
if _, ok := <-i.timer; ok {
t.Fatal("expected timer channel to be closed")
}
// aborting an already aborted interval returns error
if err := i.Abort(); err == nil {
t.Fatalf("expected=%v; got=%v instead", errAborted, nil)
}
}
func wait(t int) { time.Sleep(time.Duration(t) * time.Second) }