← Back to branch summary

~rogpeppe/juju-core/azure

« back to all changes in this revision

Viewing changes to testing/channel.go

  • Committer: Gustavo Niemeyer
  • Date: 2011-09-26 14:48:45 UTC
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: gustavo@niemeyer.net-20110926144845-atwp3u6blqngmhel
Bootstrapping store package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
testing/channel.go
1
 
// Copyright 2011, 2012, 2013 Canonical Ltd.
2
 
// Licensed under the AGPLv3, see LICENCE file for details.
3
 
 
4
 
package testing
5
 
 
6
 
import (
7
 
        "time"
8
 
 
9
 
        gc "launchpad.net/gocheck"
10
 
 
11
 
        jc "launchpad.net/juju-core/testing/checkers"
12
 
)
13
 
 
14
 
// NotifyAsserterC gives helper functions for making assertions about how a
15
 
// channel operates (whether we get a receive event or not, whether it is
16
 
// closed, etc.)
17
 
type NotifyAsserterC struct {
18
 
        // C is a gocheck C structure for doing assertions
19
 
        C *gc.C
20
 
        // Chan is the channel we want to receive on
21
 
        Chan <-chan struct{}
22
 
        // Precond will be called before waiting on the channel, can be nil
23
 
        Precond func()
24
 
}
25
 
 
26
 
// AssertReceive will ensure that we get an event on the channel and the
27
 
// channel is not closed.
28
 
func (a *NotifyAsserterC) AssertReceive() {
29
 
        if a.Precond != nil {
30
 
                a.Precond()
31
 
        }
32
 
        select {
33
 
        case _, ok := <-a.Chan:
34
 
                a.C.Assert(ok, jc.IsTrue)
35
 
        case <-time.After(LongWait):
36
 
                a.C.Fatalf("timed out waiting for channel message")
37
 
        }
38
 
}
39
 
 
40
 
// AssertOneReceive checks that we have exactly one message, and no more
41
 
func (a *NotifyAsserterC) AssertOneReceive() {
42
 
        a.AssertReceive()
43
 
        a.AssertNoReceive()
44
 
}
45
 
 
46
 
// AssertClosed ensures that we get a closed event on the channel
47
 
func (a *NotifyAsserterC) AssertClosed() {
48
 
        if a.Precond != nil {
49
 
                a.Precond()
50
 
        }
51
 
        select {
52
 
        case _, ok := <-a.Chan:
53
 
                a.C.Assert(ok, jc.IsFalse)
54
 
        case <-time.After(LongWait):
55
 
                a.C.Fatalf("timed out waiting for channel to close")
56
 
        }
57
 
}
58
 
 
59
 
// Assert that we fail to receive on the channel after a short wait.
60
 
func (a *NotifyAsserterC) AssertNoReceive() {
61
 
        select {
62
 
        case <-a.Chan:
63
 
                a.C.Fatalf("unexpected receive")
64
 
        case <-time.After(ShortWait):
65
 
        }
66
 
}
67
 
 
68
 
// ContentAsserterC is like NotifyAsserterC in that it checks the behavior of a
69
 
// channel. The difference is that we expect actual content on the channel, so
70
 
// callers need to put that into and out of an 'interface{}'
71
 
// TODO go1.1: We can use reflect.Select and reflect.Receive sort of
72
 
//      functionality in order to avoid having to write a helper function to
73
 
//      curry our requests into interface{} types.
74
 
 
75
 
type ContentAsserterC struct {
76
 
        // C is a gocheck C structure for doing assertions
77
 
        C *gc.C
78
 
        // Chan is the channel we want to receive on
79
 
        Chan <-chan interface{}
80
 
        // Precond will be called before waiting on the channel, can be nil
81
 
        Precond func()
82
 
}
83
 
 
84
 
// AssertReceive will ensure that we get an event on the channel and the
85
 
// channel is not closed. It will return the content received
86
 
func (a *ContentAsserterC) AssertReceive() interface{} {
87
 
        if a.Precond != nil {
88
 
                a.Precond()
89
 
        }
90
 
        select {
91
 
        case content, ok := <-a.Chan:
92
 
                a.C.Assert(ok, jc.IsTrue)
93
 
                return content
94
 
        case <-time.After(LongWait):
95
 
                a.C.Fatalf("timed out waiting for channel message")
96
 
        }
97
 
        return nil
98
 
}
99
 
 
100
 
// AssertOneReceive checks that we have exactly one message, and no more
101
 
func (a *ContentAsserterC) AssertOneReceive() interface{} {
102
 
        res := a.AssertReceive()
103
 
        a.AssertNoReceive()
104
 
        return res
105
 
}
106
 
 
107
 
// AssertClosed ensures that we get a closed event on the channel
108
 
func (a *ContentAsserterC) AssertClosed() {
109
 
        if a.Precond != nil {
110
 
                a.Precond()
111
 
        }
112
 
        select {
113
 
        case _, ok := <-a.Chan:
114
 
                a.C.Assert(ok, jc.IsFalse)
115
 
        case <-time.After(LongWait):
116
 
                a.C.Fatalf("timed out waiting for channel to close")
117
 
        }
118
 
}
119
 
 
120
 
// Assert that we fail to receive on the channel after a short wait.
121
 
func (a *ContentAsserterC) AssertNoReceive() {
122
 
        select {
123
 
        case content := <-a.Chan:
124
 
                a.C.Fatalf("unexpected receive: %#v", content)
125
 
        case <-time.After(ShortWait):
126
 
        }
127
 
}