← Back to branch summary

~niemeyer/gocheck/old-trunk

« back to all changes in this revision

Viewing changes to fixture_test.go

  • Committer: Gustavo Niemeyer
  • Date: 2011-04-14 11:45:36 UTC
  • Revision ID: gustavo@niemeyer.net-20110414114536-ug726tol52c7seat
gofmt

Show diffs side-by-side

added added

removed removed

Lines of Context:
fixture_test.go
4
4
 
5
5
 
6
6
import (
7
 
    .   "launchpad.net/gocheck"
 
7
        . "launchpad.net/gocheck"
8
8
)
9
9
 
10
10
 
16
16
var fixtureS = Suite(&FixtureS{})
17
17
 
18
18
func (s *FixtureS) TestCountSuite(c *C) {
19
 
    suitesRun += 1
 
19
        suitesRun += 1
20
20
}
21
21
 
22
22
 
24
24
// Basic fixture ordering verification.
25
25
 
26
26
func (s *FixtureS) TestOrder(c *C) {
27
 
    helper := FixtureHelper{}
28
 
    Run(&helper, nil)
29
 
    c.Check(helper.calls[0], Equals, "SetUpSuite")
30
 
    c.Check(helper.calls[1], Equals, "SetUpTest")
31
 
    c.Check(helper.calls[2], Equals, "Test1")
32
 
    c.Check(helper.calls[3], Equals, "TearDownTest")
33
 
    c.Check(helper.calls[4], Equals, "SetUpTest")
34
 
    c.Check(helper.calls[5], Equals, "Test2")
35
 
    c.Check(helper.calls[6], Equals, "TearDownTest")
36
 
    c.Check(helper.calls[7], Equals, "TearDownSuite")
37
 
    c.Check(helper.n, Equals, 8)
 
27
        helper := FixtureHelper{}
 
28
        Run(&helper, nil)
 
29
        c.Check(helper.calls[0], Equals, "SetUpSuite")
 
30
        c.Check(helper.calls[1], Equals, "SetUpTest")
 
31
        c.Check(helper.calls[2], Equals, "Test1")
 
32
        c.Check(helper.calls[3], Equals, "TearDownTest")
 
33
        c.Check(helper.calls[4], Equals, "SetUpTest")
 
34
        c.Check(helper.calls[5], Equals, "Test2")
 
35
        c.Check(helper.calls[6], Equals, "TearDownTest")
 
36
        c.Check(helper.calls[7], Equals, "TearDownSuite")
 
37
        c.Check(helper.n, Equals, 8)
38
38
}
39
39
 
40
40
 
42
42
// Check the behavior when panics occur within tests and fixtures.
43
43
 
44
44
func (s *FixtureS) TestPanicOnTest(c *C) {
45
 
    helper := FixtureHelper{panicOn: "Test1"}
46
 
    output := String{}
47
 
    Run(&helper, &RunConf{Output: &output})
48
 
    c.Check(helper.calls[0], Equals, "SetUpSuite")
49
 
    c.Check(helper.calls[1], Equals, "SetUpTest")
50
 
    c.Check(helper.calls[2], Equals, "Test1")
51
 
    c.Check(helper.calls[3], Equals, "TearDownTest")
52
 
    c.Check(helper.calls[4], Equals, "SetUpTest")
53
 
    c.Check(helper.calls[5], Equals, "Test2")
54
 
    c.Check(helper.calls[6], Equals, "TearDownTest")
55
 
    c.Check(helper.calls[7], Equals, "TearDownSuite")
56
 
    c.Check(helper.n, Equals, 8)
57
 
 
58
 
    expected := "^\n-+\n" +
59
 
        "PANIC: gocheck_test\\.go:[0-9]+: FixtureHelper.Test1\n\n" +
60
 
        "\\.\\.\\. Panic: Test1 \\(PC=[xA-F0-9]+\\)\n\n" +
61
 
        ".+:[0-9]+\n" +
62
 
        "  in runtime.panic\n" +
63
 
        ".*gocheck_test.go:[0-9]+\n" +
64
 
        "  in FixtureHelper.trace\n" +
65
 
        ".*gocheck_test.go:[0-9]+\n" +
66
 
        "  in FixtureHelper.Test1\n$"
67
 
 
68
 
    c.Check(output.value, Matches, expected)
 
45
        helper := FixtureHelper{panicOn: "Test1"}
 
46
        output := String{}
 
47
        Run(&helper, &RunConf{Output: &output})
 
48
        c.Check(helper.calls[0], Equals, "SetUpSuite")
 
49
        c.Check(helper.calls[1], Equals, "SetUpTest")
 
50
        c.Check(helper.calls[2], Equals, "Test1")
 
51
        c.Check(helper.calls[3], Equals, "TearDownTest")
 
52
        c.Check(helper.calls[4], Equals, "SetUpTest")
 
53
        c.Check(helper.calls[5], Equals, "Test2")
 
54
        c.Check(helper.calls[6], Equals, "TearDownTest")
 
55
        c.Check(helper.calls[7], Equals, "TearDownSuite")
 
56
        c.Check(helper.n, Equals, 8)
 
57
 
 
58
        expected := "^\n-+\n" +
 
59
                "PANIC: gocheck_test\\.go:[0-9]+: FixtureHelper.Test1\n\n" +
 
60
                "\\.\\.\\. Panic: Test1 \\(PC=[xA-F0-9]+\\)\n\n" +
 
61
                ".+:[0-9]+\n" +
 
62
                "  in runtime.panic\n" +
 
63
                ".*gocheck_test.go:[0-9]+\n" +
 
64
                "  in FixtureHelper.trace\n" +
 
65
                ".*gocheck_test.go:[0-9]+\n" +
 
66
                "  in FixtureHelper.Test1\n$"
 
67
 
 
68
        c.Check(output.value, Matches, expected)
69
69
}
70
70
 
71
71
func (s *FixtureS) TestPanicOnSetUpTest(c *C) {
72
 
    helper := FixtureHelper{panicOn: "SetUpTest"}
73
 
    output := String{}
74
 
    Run(&helper, &RunConf{Output: &output})
75
 
    c.Check(helper.calls[0], Equals, "SetUpSuite")
76
 
    c.Check(helper.calls[1], Equals, "SetUpTest")
77
 
    c.Check(helper.calls[2], Equals, "TearDownTest")
78
 
    c.Check(helper.calls[3], Equals, "TearDownSuite")
79
 
    c.Check(helper.n, Equals, 4)
80
 
 
81
 
    expected := "^\n-+\n" +
82
 
        "PANIC: gocheck_test\\.go:[0-9]+: " +
83
 
        "FixtureHelper\\.SetUpTest\n\n" +
84
 
        "\\.\\.\\. Panic: SetUpTest \\(PC=[xA-F0-9]+\\)\n\n" +
85
 
        ".+:[0-9]+\n" +
86
 
        "  in runtime.panic\n" +
87
 
        ".*gocheck_test.go:[0-9]+\n" +
88
 
        "  in FixtureHelper.trace\n" +
89
 
        ".*gocheck_test.go:[0-9]+\n" +
90
 
        "  in FixtureHelper.SetUpTest\n" +
91
 
        "\n-+\n" +
92
 
        "PANIC: gocheck_test\\.go:[0-9]+: " +
93
 
        "FixtureHelper\\.Test1\n\n" +
94
 
        "\\.\\.\\. Panic: Fixture has panicked " +
95
 
        "\\(see related PANIC\\)\n$"
96
 
 
97
 
    c.Check(output.value, Matches, expected)
 
72
        helper := FixtureHelper{panicOn: "SetUpTest"}
 
73
        output := String{}
 
74
        Run(&helper, &RunConf{Output: &output})
 
75
        c.Check(helper.calls[0], Equals, "SetUpSuite")
 
76
        c.Check(helper.calls[1], Equals, "SetUpTest")
 
77
        c.Check(helper.calls[2], Equals, "TearDownTest")
 
78
        c.Check(helper.calls[3], Equals, "TearDownSuite")
 
79
        c.Check(helper.n, Equals, 4)
 
80
 
 
81
        expected := "^\n-+\n" +
 
82
                "PANIC: gocheck_test\\.go:[0-9]+: " +
 
83
                "FixtureHelper\\.SetUpTest\n\n" +
 
84
                "\\.\\.\\. Panic: SetUpTest \\(PC=[xA-F0-9]+\\)\n\n" +
 
85
                ".+:[0-9]+\n" +
 
86
                "  in runtime.panic\n" +
 
87
                ".*gocheck_test.go:[0-9]+\n" +
 
88
                "  in FixtureHelper.trace\n" +
 
89
                ".*gocheck_test.go:[0-9]+\n" +
 
90
                "  in FixtureHelper.SetUpTest\n" +
 
91
                "\n-+\n" +
 
92
                "PANIC: gocheck_test\\.go:[0-9]+: " +
 
93
                "FixtureHelper\\.Test1\n\n" +
 
94
                "\\.\\.\\. Panic: Fixture has panicked " +
 
95
                "\\(see related PANIC\\)\n$"
 
96
 
 
97
        c.Check(output.value, Matches, expected)
98
98
}
99
99
 
100
100
func (s *FixtureS) TestPanicOnTearDownTest(c *C) {
101
 
    helper := FixtureHelper{panicOn: "TearDownTest"}
102
 
    output := String{}
103
 
    Run(&helper, &RunConf{Output: &output})
104
 
    c.Check(helper.calls[0], Equals, "SetUpSuite")
105
 
    c.Check(helper.calls[1], Equals, "SetUpTest")
106
 
    c.Check(helper.calls[2], Equals, "Test1")
107
 
    c.Check(helper.calls[3], Equals, "TearDownTest")
108
 
    c.Check(helper.calls[4], Equals, "TearDownSuite")
109
 
    c.Check(helper.n, Equals, 5)
110
 
 
111
 
    expected := "^\n-+\n" +
112
 
        "PANIC: gocheck_test\\.go:[0-9]+: " +
113
 
        "FixtureHelper.TearDownTest\n\n" +
114
 
        "\\.\\.\\. Panic: TearDownTest \\(PC=[xA-F0-9]+\\)\n\n" +
115
 
        ".+:[0-9]+\n" +
116
 
        "  in runtime.panic\n" +
117
 
        ".*gocheck_test.go:[0-9]+\n" +
118
 
        "  in FixtureHelper.trace\n" +
119
 
        ".*gocheck_test.go:[0-9]+\n" +
120
 
        "  in FixtureHelper.TearDownTest\n" +
121
 
        "\n-+\n" +
122
 
        "PANIC: gocheck_test\\.go:[0-9]+: " +
123
 
        "FixtureHelper\\.Test1\n\n" +
124
 
        "\\.\\.\\. Panic: Fixture has panicked " +
125
 
        "\\(see related PANIC\\)\n$"
126
 
 
127
 
    c.Check(output.value, Matches, expected)
 
101
        helper := FixtureHelper{panicOn: "TearDownTest"}
 
102
        output := String{}
 
103
        Run(&helper, &RunConf{Output: &output})
 
104
        c.Check(helper.calls[0], Equals, "SetUpSuite")
 
105
        c.Check(helper.calls[1], Equals, "SetUpTest")
 
106
        c.Check(helper.calls[2], Equals, "Test1")
 
107
        c.Check(helper.calls[3], Equals, "TearDownTest")
 
108
        c.Check(helper.calls[4], Equals, "TearDownSuite")
 
109
        c.Check(helper.n, Equals, 5)
 
110
 
 
111
        expected := "^\n-+\n" +
 
112
                "PANIC: gocheck_test\\.go:[0-9]+: " +
 
113
                "FixtureHelper.TearDownTest\n\n" +
 
114
                "\\.\\.\\. Panic: TearDownTest \\(PC=[xA-F0-9]+\\)\n\n" +
 
115
                ".+:[0-9]+\n" +
 
116
                "  in runtime.panic\n" +
 
117
                ".*gocheck_test.go:[0-9]+\n" +
 
118
                "  in FixtureHelper.trace\n" +
 
119
                ".*gocheck_test.go:[0-9]+\n" +
 
120
                "  in FixtureHelper.TearDownTest\n" +
 
121
                "\n-+\n" +
 
122
                "PANIC: gocheck_test\\.go:[0-9]+: " +
 
123
                "FixtureHelper\\.Test1\n\n" +
 
124
                "\\.\\.\\. Panic: Fixture has panicked " +
 
125
                "\\(see related PANIC\\)\n$"
 
126
 
 
127
        c.Check(output.value, Matches, expected)
128
128
}
129
129
 
130
130
func (s *FixtureS) TestPanicOnSetUpSuite(c *C) {
131
 
    helper := FixtureHelper{panicOn: "SetUpSuite"}
132
 
    output := String{}
133
 
    Run(&helper, &RunConf{Output: &output})
134
 
    c.Check(helper.calls[0], Equals, "SetUpSuite")
135
 
    c.Check(helper.calls[1], Equals, "TearDownSuite")
136
 
    c.Check(helper.n, Equals, 2)
137
 
 
138
 
    expected := "^\n-+\n" +
139
 
        "PANIC: gocheck_test\\.go:[0-9]+: " +
140
 
        "FixtureHelper.SetUpSuite\n\n" +
141
 
        "\\.\\.\\. Panic: SetUpSuite \\(PC=[xA-F0-9]+\\)\n\n" +
142
 
        ".+:[0-9]+\n" +
143
 
        "  in runtime.panic\n" +
144
 
        ".*gocheck_test.go:[0-9]+\n" +
145
 
        "  in FixtureHelper.trace\n" +
146
 
        ".*gocheck_test.go:[0-9]+\n" +
147
 
        "  in FixtureHelper.SetUpSuite\n$"
148
 
 
149
 
    c.Check(output.value, Matches, expected)
 
131
        helper := FixtureHelper{panicOn: "SetUpSuite"}
 
132
        output := String{}
 
133
        Run(&helper, &RunConf{Output: &output})
 
134
        c.Check(helper.calls[0], Equals, "SetUpSuite")
 
135
        c.Check(helper.calls[1], Equals, "TearDownSuite")
 
136
        c.Check(helper.n, Equals, 2)
 
137
 
 
138
        expected := "^\n-+\n" +
 
139
                "PANIC: gocheck_test\\.go:[0-9]+: " +
 
140
                "FixtureHelper.SetUpSuite\n\n" +
 
141
                "\\.\\.\\. Panic: SetUpSuite \\(PC=[xA-F0-9]+\\)\n\n" +
 
142
                ".+:[0-9]+\n" +
 
143
                "  in runtime.panic\n" +
 
144
                ".*gocheck_test.go:[0-9]+\n" +
 
145
                "  in FixtureHelper.trace\n" +
 
146
                ".*gocheck_test.go:[0-9]+\n" +
 
147
                "  in FixtureHelper.SetUpSuite\n$"
 
148
 
 
149
        c.Check(output.value, Matches, expected)
150
150
}
151
151
 
152
152
func (s *FixtureS) TestPanicOnTearDownSuite(c *C) {
153
 
    helper := FixtureHelper{panicOn: "TearDownSuite"}
154
 
    output := String{}
155
 
    Run(&helper, &RunConf{Output: &output})
156
 
    c.Check(helper.calls[0], Equals, "SetUpSuite")
157
 
    c.Check(helper.calls[1], Equals, "SetUpTest")
158
 
    c.Check(helper.calls[2], Equals, "Test1")
159
 
    c.Check(helper.calls[3], Equals, "TearDownTest")
160
 
    c.Check(helper.calls[4], Equals, "SetUpTest")
161
 
    c.Check(helper.calls[5], Equals, "Test2")
162
 
    c.Check(helper.calls[6], Equals, "TearDownTest")
163
 
    c.Check(helper.calls[7], Equals, "TearDownSuite")
164
 
    c.Check(helper.n, Equals, 8)
165
 
 
166
 
    expected := "^\n-+\n" +
167
 
        "PANIC: gocheck_test\\.go:[0-9]+: " +
168
 
        "FixtureHelper.TearDownSuite\n\n" +
169
 
        "\\.\\.\\. Panic: TearDownSuite \\(PC=[xA-F0-9]+\\)\n\n" +
170
 
        ".+:[0-9]+\n" +
171
 
        "  in runtime.panic\n" +
172
 
        ".*gocheck_test.go:[0-9]+\n" +
173
 
        "  in FixtureHelper.trace\n" +
174
 
        ".*gocheck_test.go:[0-9]+\n" +
175
 
        "  in FixtureHelper.TearDownSuite\n$"
176
 
 
177
 
    c.Check(output.value, Matches, expected)
 
153
        helper := FixtureHelper{panicOn: "TearDownSuite"}
 
154
        output := String{}
 
155
        Run(&helper, &RunConf{Output: &output})
 
156
        c.Check(helper.calls[0], Equals, "SetUpSuite")
 
157
        c.Check(helper.calls[1], Equals, "SetUpTest")
 
158
        c.Check(helper.calls[2], Equals, "Test1")
 
159
        c.Check(helper.calls[3], Equals, "TearDownTest")
 
160
        c.Check(helper.calls[4], Equals, "SetUpTest")
 
161
        c.Check(helper.calls[5], Equals, "Test2")
 
162
        c.Check(helper.calls[6], Equals, "TearDownTest")
 
163
        c.Check(helper.calls[7], Equals, "TearDownSuite")
 
164
        c.Check(helper.n, Equals, 8)
 
165
 
 
166
        expected := "^\n-+\n" +
 
167
                "PANIC: gocheck_test\\.go:[0-9]+: " +
 
168
                "FixtureHelper.TearDownSuite\n\n" +
 
169
                "\\.\\.\\. Panic: TearDownSuite \\(PC=[xA-F0-9]+\\)\n\n" +
 
170
                ".+:[0-9]+\n" +
 
171
                "  in runtime.panic\n" +
 
172
                ".*gocheck_test.go:[0-9]+\n" +
 
173
                "  in FixtureHelper.trace\n" +
 
174
                ".*gocheck_test.go:[0-9]+\n" +
 
175
                "  in FixtureHelper.TearDownSuite\n$"
 
176
 
 
177
        c.Check(output.value, Matches, expected)
178
178
}
179
179
 
180
180
 
182
182
// A wrong argument on a test or fixture will produce a nice error.
183
183
 
184
184
func (s *FixtureS) TestPanicOnWrongTestArg(c *C) {
185
 
    helper := WrongTestArgHelper{}
186
 
    output := String{}
187
 
    Run(&helper, &RunConf{Output: &output})
188
 
    c.Check(helper.calls[0], Equals, "SetUpSuite")
189
 
    c.Check(helper.calls[1], Equals, "SetUpTest")
190
 
    c.Check(helper.calls[2], Equals, "TearDownTest")
191
 
    c.Check(helper.calls[3], Equals, "SetUpTest")
192
 
    c.Check(helper.calls[4], Equals, "Test2")
193
 
    c.Check(helper.calls[5], Equals, "TearDownTest")
194
 
    c.Check(helper.calls[6], Equals, "TearDownSuite")
195
 
    c.Check(helper.n, Equals, 7)
196
 
 
197
 
    expected := "^\n-+\n" +
198
 
        "PANIC: fixture_test\\.go:[0-9]+: " +
199
 
        "WrongTestArgHelper\\.Test1\n\n" +
200
 
        "\\.\\.\\. Panic: WrongTestArgHelper\\.Test1 argument " +
201
 
        "should be \\*gocheck\\.C\n"
202
 
 
203
 
    c.Check(output.value, Matches, expected)
 
185
        helper := WrongTestArgHelper{}
 
186
        output := String{}
 
187
        Run(&helper, &RunConf{Output: &output})
 
188
        c.Check(helper.calls[0], Equals, "SetUpSuite")
 
189
        c.Check(helper.calls[1], Equals, "SetUpTest")
 
190
        c.Check(helper.calls[2], Equals, "TearDownTest")
 
191
        c.Check(helper.calls[3], Equals, "SetUpTest")
 
192
        c.Check(helper.calls[4], Equals, "Test2")
 
193
        c.Check(helper.calls[5], Equals, "TearDownTest")
 
194
        c.Check(helper.calls[6], Equals, "TearDownSuite")
 
195
        c.Check(helper.n, Equals, 7)
 
196
 
 
197
        expected := "^\n-+\n" +
 
198
                "PANIC: fixture_test\\.go:[0-9]+: " +
 
199
                "WrongTestArgHelper\\.Test1\n\n" +
 
200
                "\\.\\.\\. Panic: WrongTestArgHelper\\.Test1 argument " +
 
201
                "should be \\*gocheck\\.C\n"
 
202
 
 
203
        c.Check(output.value, Matches, expected)
204
204
}
205
205
 
206
206
func (s *FixtureS) TestPanicOnWrongSetUpTestArg(c *C) {
207
 
    helper := WrongSetUpTestArgHelper{}
208
 
    output := String{}
209
 
    Run(&helper, &RunConf{Output: &output})
210
 
    c.Check(helper.n, Equals, 0)
211
 
 
212
 
    expected :=
213
 
        "^\n-+\n" +
214
 
            "PANIC: fixture_test\\.go:[0-9]+: " +
215
 
            "WrongSetUpTestArgHelper\\.SetUpTest\n\n" +
216
 
            "\\.\\.\\. Panic: WrongSetUpTestArgHelper\\.SetUpTest argument " +
217
 
            "should be \\*gocheck\\.C\n"
218
 
 
219
 
    c.Check(output.value, Matches, expected)
 
207
        helper := WrongSetUpTestArgHelper{}
 
208
        output := String{}
 
209
        Run(&helper, &RunConf{Output: &output})
 
210
        c.Check(helper.n, Equals, 0)
 
211
 
 
212
        expected :=
 
213
                "^\n-+\n" +
 
214
                        "PANIC: fixture_test\\.go:[0-9]+: " +
 
215
                        "WrongSetUpTestArgHelper\\.SetUpTest\n\n" +
 
216
                        "\\.\\.\\. Panic: WrongSetUpTestArgHelper\\.SetUpTest argument " +
 
217
                        "should be \\*gocheck\\.C\n"
 
218
 
 
219
        c.Check(output.value, Matches, expected)
220
220
}
221
221
 
222
222
func (s *FixtureS) TestPanicOnWrongSetUpSuiteArg(c *C) {
223
 
    helper := WrongSetUpSuiteArgHelper{}
224
 
    output := String{}
225
 
    Run(&helper, &RunConf{Output: &output})
226
 
    c.Check(helper.n, Equals, 0)
227
 
 
228
 
    expected :=
229
 
        "^\n-+\n" +
230
 
            "PANIC: fixture_test\\.go:[0-9]+: " +
231
 
            "WrongSetUpSuiteArgHelper\\.SetUpSuite\n\n" +
232
 
            "\\.\\.\\. Panic: WrongSetUpSuiteArgHelper\\.SetUpSuite argument " +
233
 
            "should be \\*gocheck\\.C\n"
234
 
 
235
 
    c.Check(output.value, Matches, expected)
 
223
        helper := WrongSetUpSuiteArgHelper{}
 
224
        output := String{}
 
225
        Run(&helper, &RunConf{Output: &output})
 
226
        c.Check(helper.n, Equals, 0)
 
227
 
 
228
        expected :=
 
229
                "^\n-+\n" +
 
230
                        "PANIC: fixture_test\\.go:[0-9]+: " +
 
231
                        "WrongSetUpSuiteArgHelper\\.SetUpSuite\n\n" +
 
232
                        "\\.\\.\\. Panic: WrongSetUpSuiteArgHelper\\.SetUpSuite argument " +
 
233
                        "should be \\*gocheck\\.C\n"
 
234
 
 
235
        c.Check(output.value, Matches, expected)
236
236
}
237
237
 
238
238
 
240
240
// Nice errors also when tests or fixture have wrong arg count.
241
241
 
242
242
func (s *FixtureS) TestPanicOnWrongTestArgCount(c *C) {
243
 
    helper := WrongTestArgCountHelper{}
244
 
    output := String{}
245
 
    Run(&helper, &RunConf{Output: &output})
246
 
    c.Check(helper.calls[0], Equals, "SetUpSuite")
247
 
    c.Check(helper.calls[1], Equals, "SetUpTest")
248
 
    c.Check(helper.calls[2], Equals, "TearDownTest")
249
 
    c.Check(helper.calls[3], Equals, "SetUpTest")
250
 
    c.Check(helper.calls[4], Equals, "Test2")
251
 
    c.Check(helper.calls[5], Equals, "TearDownTest")
252
 
    c.Check(helper.calls[6], Equals, "TearDownSuite")
253
 
    c.Check(helper.n, Equals, 7)
254
 
 
255
 
    expected := "^\n-+\n" +
256
 
        "PANIC: fixture_test\\.go:[0-9]+: " +
257
 
        "WrongTestArgCountHelper\\.Test1\n\n" +
258
 
        "\\.\\.\\. Panic: WrongTestArgCountHelper\\.Test1 argument " +
259
 
        "should be \\*gocheck\\.C\n"
260
 
 
261
 
    c.Check(output.value, Matches, expected)
 
243
        helper := WrongTestArgCountHelper{}
 
244
        output := String{}
 
245
        Run(&helper, &RunConf{Output: &output})
 
246
        c.Check(helper.calls[0], Equals, "SetUpSuite")
 
247
        c.Check(helper.calls[1], Equals, "SetUpTest")
 
248
        c.Check(helper.calls[2], Equals, "TearDownTest")
 
249
        c.Check(helper.calls[3], Equals, "SetUpTest")
 
250
        c.Check(helper.calls[4], Equals, "Test2")
 
251
        c.Check(helper.calls[5], Equals, "TearDownTest")
 
252
        c.Check(helper.calls[6], Equals, "TearDownSuite")
 
253
        c.Check(helper.n, Equals, 7)
 
254
 
 
255
        expected := "^\n-+\n" +
 
256
                "PANIC: fixture_test\\.go:[0-9]+: " +
 
257
                "WrongTestArgCountHelper\\.Test1\n\n" +
 
258
                "\\.\\.\\. Panic: WrongTestArgCountHelper\\.Test1 argument " +
 
259
                "should be \\*gocheck\\.C\n"
 
260
 
 
261
        c.Check(output.value, Matches, expected)
262
262
}
263
263
 
264
264
func (s *FixtureS) TestPanicOnWrongSetUpTestArgCount(c *C) {
265
 
    helper := WrongSetUpTestArgCountHelper{}
266
 
    output := String{}
267
 
    Run(&helper, &RunConf{Output: &output})
268
 
    c.Check(helper.n, Equals, 0)
269
 
 
270
 
    expected :=
271
 
        "^\n-+\n" +
272
 
            "PANIC: fixture_test\\.go:[0-9]+: " +
273
 
            "WrongSetUpTestArgCountHelper\\.SetUpTest\n\n" +
274
 
            "\\.\\.\\. Panic: WrongSetUpTestArgCountHelper\\.SetUpTest argument " +
275
 
            "should be \\*gocheck\\.C\n"
276
 
 
277
 
    c.Check(output.value, Matches, expected)
 
265
        helper := WrongSetUpTestArgCountHelper{}
 
266
        output := String{}
 
267
        Run(&helper, &RunConf{Output: &output})
 
268
        c.Check(helper.n, Equals, 0)
 
269
 
 
270
        expected :=
 
271
                "^\n-+\n" +
 
272
                        "PANIC: fixture_test\\.go:[0-9]+: " +
 
273
                        "WrongSetUpTestArgCountHelper\\.SetUpTest\n\n" +
 
274
                        "\\.\\.\\. Panic: WrongSetUpTestArgCountHelper\\.SetUpTest argument " +
 
275
                        "should be \\*gocheck\\.C\n"
 
276
 
 
277
        c.Check(output.value, Matches, expected)
278
278
}
279
279
 
280
280
func (s *FixtureS) TestPanicOnWrongSetUpSuiteArgCount(c *C) {
281
 
    helper := WrongSetUpSuiteArgCountHelper{}
282
 
    output := String{}
283
 
    Run(&helper, &RunConf{Output: &output})
284
 
    c.Check(helper.n, Equals, 0)
285
 
 
286
 
    expected :=
287
 
        "^\n-+\n" +
288
 
            "PANIC: fixture_test\\.go:[0-9]+: " +
289
 
            "WrongSetUpSuiteArgCountHelper\\.SetUpSuite\n\n" +
290
 
            "\\.\\.\\. Panic: WrongSetUpSuiteArgCountHelper" +
291
 
            "\\.SetUpSuite argument should be \\*gocheck\\.C\n"
292
 
 
293
 
    c.Check(output.value, Matches, expected)
 
281
        helper := WrongSetUpSuiteArgCountHelper{}
 
282
        output := String{}
 
283
        Run(&helper, &RunConf{Output: &output})
 
284
        c.Check(helper.n, Equals, 0)
 
285
 
 
286
        expected :=
 
287
                "^\n-+\n" +
 
288
                        "PANIC: fixture_test\\.go:[0-9]+: " +
 
289
                        "WrongSetUpSuiteArgCountHelper\\.SetUpSuite\n\n" +
 
290
                        "\\.\\.\\. Panic: WrongSetUpSuiteArgCountHelper" +
 
291
                        "\\.SetUpSuite argument should be \\*gocheck\\.C\n"
 
292
 
 
293
        c.Check(output.value, Matches, expected)
294
294
}
295
295
 
296
296
 
298
298
// Helper test suites with wrong function arguments.
299
299
 
300
300
type WrongTestArgHelper struct {
301
 
    FixtureHelper
 
301
        FixtureHelper
302
302
}
303
303
 
304
304
func (s *WrongTestArgHelper) Test1(t int) {
305
305
}
306
306
 
307
307
type WrongSetUpTestArgHelper struct {
308
 
    FixtureHelper
 
308
        FixtureHelper
309
309
}
310
310
 
311
311
func (s *WrongSetUpTestArgHelper) SetUpTest(t int) {
312
312
}
313
313
 
314
314
type WrongSetUpSuiteArgHelper struct {
315
 
    FixtureHelper
 
315
        FixtureHelper
316
316
}
317
317
 
318
318
func (s *WrongSetUpSuiteArgHelper) SetUpSuite(t int) {
319
319
}
320
320
 
321
321
type WrongTestArgCountHelper struct {
322
 
    FixtureHelper
 
322
        FixtureHelper
323
323
}
324
324
 
325
325
func (s *WrongTestArgCountHelper) Test1(c *C, i int) {
326
326
}
327
327
 
328
328
type WrongSetUpTestArgCountHelper struct {
329
 
    FixtureHelper
 
329
        FixtureHelper
330
330
}
331
331
 
332
332
func (s *WrongSetUpTestArgCountHelper) SetUpTest(c *C, i int) {
333
333
}
334
334
 
335
335
type WrongSetUpSuiteArgCountHelper struct {
336
 
    FixtureHelper
 
336
        FixtureHelper
337
337
}
338
338
 
339
339
func (s *WrongSetUpSuiteArgCountHelper) SetUpSuite(c *C, i int) {
344
344
// Ensure fixture doesn't run without tests.
345
345
 
346
346
type NoTestsHelper struct {
347
 
    hasRun bool
 
347
        hasRun bool
348
348
}
349
349
 
350
350
func (s *NoTestsHelper) SetUpSuite(c *C) {
351
 
    s.hasRun = true
 
351
        s.hasRun = true
352
352
}
353
353
 
354
354
func (s *NoTestsHelper) TearDownSuite(c *C) {
355
 
    s.hasRun = true
 
355
        s.hasRun = true
356
356
}
357
357
 
358
358
func (s *FixtureS) TestFixtureDoesntRunWithoutTests(c *C) {
359
 
    helper := NoTestsHelper{}
360
 
    output := String{}
361
 
    Run(&helper, &RunConf{Output: &output})
362
 
    c.Check(helper.hasRun, Equals, false)
 
359
        helper := NoTestsHelper{}
 
360
        output := String{}
 
361
        Run(&helper, &RunConf{Output: &output})
 
362
        c.Check(helper.hasRun, Equals, false)
363
363
}
364
364
 
365
365
 
367
367
// Verify that checks and assertions work correctly inside the fixture.
368
368
 
369
369
type FixtureCheckHelper struct {
370
 
    fail      string
371
 
    completed bool
 
370
        fail      string
 
371
        completed bool
372
372
}
373
373
 
374
374
func (s *FixtureCheckHelper) SetUpSuite(c *C) {
375
 
    switch s.fail {
376
 
    case "SetUpSuiteAssert":
377
 
        c.Assert(false, Equals, true)
378
 
    case "SetUpSuiteCheck":
379
 
        c.Check(false, Equals, true)
380
 
    }
381
 
    s.completed = true
 
375
        switch s.fail {
 
376
        case "SetUpSuiteAssert":
 
377
                c.Assert(false, Equals, true)
 
378
        case "SetUpSuiteCheck":
 
379
                c.Check(false, Equals, true)
 
380
        }
 
381
        s.completed = true
382
382
}
383
383
 
384
384
func (s *FixtureCheckHelper) SetUpTest(c *C) {
385
 
    switch s.fail {
386
 
    case "SetUpTestAssert":
387
 
        c.Assert(false, Equals, true)
388
 
    case "SetUpTestCheck":
389
 
        c.Check(false, Equals, true)
390
 
    }
391
 
    s.completed = true
 
385
        switch s.fail {
 
386
        case "SetUpTestAssert":
 
387
                c.Assert(false, Equals, true)
 
388
        case "SetUpTestCheck":
 
389
                c.Check(false, Equals, true)
 
390
        }
 
391
        s.completed = true
392
392
}
393
393
 
394
394
func (s *FixtureCheckHelper) Test(c *C) {
395
 
    // Do nothing.
 
395
        // Do nothing.
396
396
}
397
397
 
398
398
func (s *FixtureS) TestSetUpSuiteCheck(c *C) {
399
 
    helper := FixtureCheckHelper{fail: "SetUpSuiteCheck"}
400
 
    output := String{}
401
 
    Run(&helper, &RunConf{Output: &output})
402
 
    c.Assert(output.value, Matches,
403
 
        "\n---+\n"+
404
 
            "FAIL: fixture_test\\.go:[0-9]+: "+
405
 
            "FixtureCheckHelper\\.SetUpSuite\n\n"+
406
 
            "fixture_test\\.go:[0-9]+:\n"+
407
 
            "    c\\.Check\\(false, Equals, true\\)\n"+
408
 
            "\\.+ obtained bool = false\n"+
409
 
            "\\.+ expected bool = true\n\n")
410
 
    c.Assert(helper.completed, Equals, true)
 
399
        helper := FixtureCheckHelper{fail: "SetUpSuiteCheck"}
 
400
        output := String{}
 
401
        Run(&helper, &RunConf{Output: &output})
 
402
        c.Assert(output.value, Matches,
 
403
                "\n---+\n"+
 
404
                        "FAIL: fixture_test\\.go:[0-9]+: "+
 
405
                        "FixtureCheckHelper\\.SetUpSuite\n\n"+
 
406
                        "fixture_test\\.go:[0-9]+:\n"+
 
407
                        "    c\\.Check\\(false, Equals, true\\)\n"+
 
408
                        "\\.+ obtained bool = false\n"+
 
409
                        "\\.+ expected bool = true\n\n")
 
410
        c.Assert(helper.completed, Equals, true)
411
411
}
412
412
 
413
413
func (s *FixtureS) TestSetUpSuiteAssert(c *C) {
414
 
    helper := FixtureCheckHelper{fail: "SetUpSuiteAssert"}
415
 
    output := String{}
416
 
    Run(&helper, &RunConf{Output: &output})
417
 
    c.Assert(output.value, Matches,
418
 
        "\n---+\n"+
419
 
            "FAIL: fixture_test\\.go:[0-9]+: "+
420
 
            "FixtureCheckHelper\\.SetUpSuite\n\n"+
421
 
            "fixture_test\\.go:[0-9]+:\n"+
422
 
            "    c\\.Assert\\(false, Equals, true\\)\n"+
423
 
            "\\.+ obtained bool = false\n"+
424
 
            "\\.+ expected bool = true\n\n")
425
 
    c.Assert(helper.completed, Equals, false)
 
414
        helper := FixtureCheckHelper{fail: "SetUpSuiteAssert"}
 
415
        output := String{}
 
416
        Run(&helper, &RunConf{Output: &output})
 
417
        c.Assert(output.value, Matches,
 
418
                "\n---+\n"+
 
419
                        "FAIL: fixture_test\\.go:[0-9]+: "+
 
420
                        "FixtureCheckHelper\\.SetUpSuite\n\n"+
 
421
                        "fixture_test\\.go:[0-9]+:\n"+
 
422
                        "    c\\.Assert\\(false, Equals, true\\)\n"+
 
423
                        "\\.+ obtained bool = false\n"+
 
424
                        "\\.+ expected bool = true\n\n")
 
425
        c.Assert(helper.completed, Equals, false)
426
426
}
427
427
 
428
428
 
430
430
// Verify that logging within SetUpTest() persists within the test log itself.
431
431
 
432
432
type FixtureLogHelper struct {
433
 
    c *C
 
433
        c *C
434
434
}
435
435
 
436
436
func (s *FixtureLogHelper) SetUpTest(c *C) {
437
 
    s.c = c
438
 
    c.Log("1")
 
437
        s.c = c
 
438
        c.Log("1")
439
439
}
440
440
 
441
441
func (s *FixtureLogHelper) Test(c *C) {
442
 
    c.Log("2")
443
 
    s.c.Log("3")
444
 
    c.Log("4")
445
 
    c.Fail()
 
442
        c.Log("2")
 
443
        s.c.Log("3")
 
444
        c.Log("4")
 
445
        c.Fail()
446
446
}
447
447
 
448
448
func (s *FixtureLogHelper) TearDownTest(c *C) {
449
 
    s.c.Log("5")
 
449
        s.c.Log("5")
450
450
}
451
451
 
452
452
func (s *FixtureS) TestFixtureLogging(c *C) {
453
 
    helper := FixtureLogHelper{}
454
 
    output := String{}
455
 
    Run(&helper, &RunConf{Output: &output})
456
 
    c.Assert(output.value, Matches,
457
 
        "\n---+\n"+
458
 
            "FAIL: fixture_test\\.go:[0-9]+: "+
459
 
            "FixtureLogHelper\\.Test\n\n"+
460
 
            "1\n2\n3\n4\n5\n")
 
453
        helper := FixtureLogHelper{}
 
454
        output := String{}
 
455
        Run(&helper, &RunConf{Output: &output})
 
456
        c.Assert(output.value, Matches,
 
457
                "\n---+\n"+
 
458
                        "FAIL: fixture_test\\.go:[0-9]+: "+
 
459
                        "FixtureLogHelper\\.Test\n\n"+
 
460
                        "1\n2\n3\n4\n5\n")
461
461
}
462
462
 
463
463
 
465
465
// Skip() within fixture methods.
466
466
 
467
467
func (s *FixtureS) TestSkipSuite(c *C) {
468
 
    helper := FixtureHelper{skip: true, skipOnN: 0}
469
 
    output := String{}
470
 
    result := Run(&helper, &RunConf{Output: &output})
471
 
    c.Assert(output.value, Equals, "")
472
 
    c.Assert(helper.calls[0], Equals, "SetUpSuite")
473
 
    c.Assert(helper.calls[1], Equals, "TearDownSuite")
474
 
    c.Assert(helper.n, Equals, 2)
475
 
    c.Assert(result.Skipped, Equals, 2)
 
468
        helper := FixtureHelper{skip: true, skipOnN: 0}
 
469
        output := String{}
 
470
        result := Run(&helper, &RunConf{Output: &output})
 
471
        c.Assert(output.value, Equals, "")
 
472
        c.Assert(helper.calls[0], Equals, "SetUpSuite")
 
473
        c.Assert(helper.calls[1], Equals, "TearDownSuite")
 
474
        c.Assert(helper.n, Equals, 2)
 
475
        c.Assert(result.Skipped, Equals, 2)
476
476
}
477
477
 
478
478
func (s *FixtureS) TestSkipTest(c *C) {
479
 
    helper := FixtureHelper{skip: true, skipOnN: 1}
480
 
    output := String{}
481
 
    result := Run(&helper, &RunConf{Output: &output})
482
 
    c.Assert(helper.calls[0], Equals, "SetUpSuite")
483
 
    c.Assert(helper.calls[1], Equals, "SetUpTest")
484
 
    c.Assert(helper.calls[2], Equals, "SetUpTest")
485
 
    c.Assert(helper.calls[3], Equals, "Test2")
486
 
    c.Assert(helper.calls[4], Equals, "TearDownTest")
487
 
    c.Assert(helper.calls[5], Equals, "TearDownSuite")
488
 
    c.Assert(helper.n, Equals, 6)
489
 
    c.Assert(result.Skipped, Equals, 1)
 
479
        helper := FixtureHelper{skip: true, skipOnN: 1}
 
480
        output := String{}
 
481
        result := Run(&helper, &RunConf{Output: &output})
 
482
        c.Assert(helper.calls[0], Equals, "SetUpSuite")
 
483
        c.Assert(helper.calls[1], Equals, "SetUpTest")
 
484
        c.Assert(helper.calls[2], Equals, "SetUpTest")
 
485
        c.Assert(helper.calls[3], Equals, "Test2")
 
486
        c.Assert(helper.calls[4], Equals, "TearDownTest")
 
487
        c.Assert(helper.calls[5], Equals, "TearDownSuite")
 
488
        c.Assert(helper.n, Equals, 6)
 
489
        c.Assert(result.Skipped, Equals, 1)
490
490
}