@@ -10,7 +10,7 @@ import (
10
10
"strings"
11
11
"testing"
12
12
13
- gc "gopkg.in/check.v1 "
13
+ qt "github.com/frankban/quicktest "
14
14
15
15
"gopkg.in/errgo.v1"
16
16
)
@@ -21,20 +21,14 @@ var (
21
21
_ errgo.Causer = (* errgo .Err )(nil )
22
22
)
23
23
24
- func Test (t * testing.T ) {
25
- gc .TestingT (t )
26
- }
27
-
28
- type errorsSuite struct {}
29
-
30
- var _ = gc .Suite (& errorsSuite {})
31
-
32
- func (* errorsSuite ) TestNew (c * gc.C ) {
24
+ func TestNew (t * testing.T ) {
25
+ c := qt .New (t )
33
26
err := errgo .New ("foo" ) //err TestNew
34
27
checkErr (c , err , nil , "foo" , "[{$TestNew$: foo}]" , err )
35
28
}
36
29
37
- func (* errorsSuite ) TestNewf (c * gc.C ) {
30
+ func TestNewf (t * testing.T ) {
31
+ c := qt .New (t )
38
32
err := errgo .Newf ("foo %d" , 5 ) //err TestNewf
39
33
checkErr (c , err , nil , "foo 5" , "[{$TestNewf$: foo 5}]" , err )
40
34
}
@@ -52,10 +46,11 @@ func annotate2() error {
52
46
return err
53
47
}
54
48
55
- func (* errorsSuite ) TestNoteUsage (c * gc.C ) {
49
+ func TestNoteUsage (t * testing.T ) {
50
+ c := qt .New (t )
56
51
err0 := annotate2 ()
57
52
err , ok := err0 .(errgo.Wrapper )
58
- c .Assert (ok , gc .Equals , true )
53
+ c .Assert (ok , qt .Equals , true )
59
54
underlying := err .Underlying ()
60
55
checkErr (
61
56
c , err0 , underlying ,
@@ -64,16 +59,18 @@ func (*errorsSuite) TestNoteUsage(c *gc.C) {
64
59
err0 )
65
60
}
66
61
67
- func (* errorsSuite ) TestMask (c * gc.C ) {
62
+ func TestMask (t * testing.T ) {
63
+ c := qt .New (t )
68
64
err0 := errgo .WithCausef (nil , someErr , "foo" ) //err TestMask#0
69
65
err := errgo .Mask (err0 ) //err TestMask#1
70
66
checkErr (c , err , err0 , "foo" , "[{$TestMask#1$: } {$TestMask#0$: foo}]" , err )
71
67
72
68
err = errgo .Mask (nil )
73
- c .Assert (err , gc .IsNil )
69
+ c .Assert (err , qt .IsNil )
74
70
}
75
71
76
- func (* errorsSuite ) TestNotef (c * gc.C ) {
72
+ func TestNotef (t * testing.T ) {
73
+ c := qt .New (t )
77
74
err0 := errgo .WithCausef (nil , someErr , "foo" ) //err TestNotef#0
78
75
err := errgo .Notef (err0 , "bar" ) //err TestNotef#1
79
76
checkErr (c , err , err0 , "bar: foo" , "[{$TestNotef#1$: bar} {$TestNotef#0$: foo}]" , err )
@@ -82,7 +79,8 @@ func (*errorsSuite) TestNotef(c *gc.C) {
82
79
checkErr (c , err , nil , "bar" , "[{$TestNotef#2$: bar}]" , err )
83
80
}
84
81
85
- func (* errorsSuite ) TestNoteMask (c * gc.C ) {
82
+ func TestNoteMask (t * testing.T ) {
83
+ c := qt .New (t )
86
84
err0 := errgo .WithCausef (nil , someErr , "foo" ) //err TestNoteMask#0
87
85
err := errgo .NoteMask (err0 , "bar" ) //err TestNoteMask#1
88
86
checkErr (c , err , err0 , "bar: foo" , "[{$TestNoteMask#1$: bar} {$TestNoteMask#0$: foo}]" , err )
@@ -94,7 +92,8 @@ func (*errorsSuite) TestNoteMask(c *gc.C) {
94
92
checkErr (c , err , err0 , "foo" , "[{$TestNoteMask#3$: } {$TestNoteMask#0$: foo}]" , err )
95
93
}
96
94
97
- func (* errorsSuite ) TestMaskFunc (c * gc.C ) {
95
+ func TestMaskFunc (t * testing.T ) {
96
+ c := qt .New (t )
98
97
err0 := errgo .New ("zero" )
99
98
err1 := errgo .New ("one" )
100
99
@@ -152,45 +151,49 @@ func (*errorsSuite) TestMaskFunc(c *gc.C) {
152
151
if wantCause == nil {
153
152
wantCause = err
154
153
}
155
- c .Check (cause , gc .Equals , wantCause )
154
+ c .Check (cause , qt .Equals , wantCause )
156
155
}
157
156
}
158
157
159
158
type embed struct {
160
159
* errgo.Err
161
160
}
162
161
163
- func (* errorsSuite ) TestCause (c * gc.C ) {
164
- c .Assert (errgo .Cause (someErr ), gc .Equals , someErr )
162
+ func TestCause (t * testing.T ) {
163
+ c := qt .New (t )
164
+ c .Assert (errgo .Cause (someErr ), qt .Equals , someErr )
165
165
166
166
causeErr := errgo .New ("cause error" )
167
167
underlyingErr := errgo .New ("underlying error" ) //err TestCause#1
168
168
err := errgo .WithCausef (underlyingErr , causeErr , "foo %d" , 99 ) //err TestCause#2
169
- c .Assert (errgo .Cause (err ), gc .Equals , causeErr )
169
+ c .Assert (errgo .Cause (err ), qt .Equals , causeErr )
170
170
171
171
checkErr (c , err , underlyingErr , "foo 99: underlying error" , "[{$TestCause#2$: foo 99} {$TestCause#1$: underlying error}]" , causeErr )
172
172
173
173
err = & embed {err .(* errgo.Err )}
174
- c .Assert (errgo .Cause (err ), gc .Equals , causeErr )
174
+ c .Assert (errgo .Cause (err ), qt .Equals , causeErr )
175
175
}
176
176
177
- func (* errorsSuite ) TestWithCausefNoMessage (c * gc.C ) {
177
+ func TestWithCausefNoMessage (t * testing.T ) {
178
+ c := qt .New (t )
178
179
cause := errgo .New ("cause" )
179
180
err := errgo .WithCausef (nil , cause , "" )
180
- c .Assert (err , gc .ErrorMatches , "cause" )
181
- c .Assert (errgo .Cause (err ), gc .Equals , cause )
181
+ c .Assert (err , qt .ErrorMatches , "cause" )
182
+ c .Assert (errgo .Cause (err ), qt .Equals , cause )
182
183
}
183
184
184
- func (* errorsSuite ) TestWithCausefWithUnderlyingButNoMessage (c * gc.C ) {
185
+ func TestWithCausefWithUnderlyingButNoMessage (t * testing.T ) {
186
+ c := qt .New (t )
185
187
err := errgo .New ("something" )
186
188
cause := errgo .New ("cause" )
187
189
err = errgo .WithCausef (err , cause , "" )
188
- c .Assert (err , gc .ErrorMatches , "something" )
189
- c .Assert (errgo .Cause (err ), gc .Equals , cause )
190
+ c .Assert (err , qt .ErrorMatches , "something" )
191
+ c .Assert (errgo .Cause (err ), qt .Equals , cause )
190
192
}
191
193
192
- func (* errorsSuite ) TestDetails (c * gc.C ) {
193
- c .Assert (errgo .Details (nil ), gc .Equals , "[]" )
194
+ func TestDetails (t * testing.T ) {
195
+ c := qt .New (t )
196
+ c .Assert (errgo .Details (nil ), qt .Equals , "[]" )
194
197
195
198
otherErr := fmt .Errorf ("other" )
196
199
checkErr (c , otherErr , nil , "other" , "[{other}]" , otherErr )
@@ -205,7 +208,8 @@ func (*errorsSuite) TestDetails(c *gc.C) {
205
208
checkErr (c , err2 , err1 , "bar: foo" , "[{$TestStack#2$: } {$TestStack#1$: bar} {$TestStack#0$: foo}]" , err2 )
206
209
}
207
210
208
- func (* errorsSuite ) TestMatch (c * gc.C ) {
211
+ func TestMatch (t * testing.T ) {
212
+ c := qt .New (t )
209
213
type errTest func (error ) bool
210
214
allow := func (ss ... string ) []func (error ) bool {
211
215
fns := make ([]func (error ) bool , len (ss ))
@@ -245,21 +249,21 @@ func (*errorsSuite) TestMatch(c *gc.C) {
245
249
246
250
for i , test := range tests {
247
251
c .Logf ("test %d" , i )
248
- c .Assert (errgo .Match (test .err , test .fns ... ), gc .Equals , test .ok )
252
+ c .Assert (errgo .Match (test .err , test .fns ... ), qt .Equals , test .ok )
249
253
}
250
254
}
251
255
252
- func checkErr (c * gc .C , err , underlying error , msg string , details string , cause error ) {
253
- c .Assert (err , gc . NotNil )
254
- c .Assert (err .Error (), gc .Equals , msg )
256
+ func checkErr (c * qt .C , err , underlying error , msg string , details string , cause error ) {
257
+ c .Assert (err , qt . Not ( qt . IsNil ) )
258
+ c .Assert (err .Error (), qt .Equals , msg )
255
259
if err , ok := err .(errgo.Wrapper ); ok {
256
- c .Assert (err .Underlying (), gc .Equals , underlying )
260
+ c .Assert (err .Underlying (), qt .Equals , underlying )
257
261
} else {
258
- c .Assert (underlying , gc .IsNil )
262
+ c .Assert (underlying , qt .IsNil )
259
263
}
260
- c .Assert (errgo .Cause (err ), gc .Equals , cause )
264
+ c .Assert (errgo .Cause (err ), qt .Equals , cause )
261
265
wantDetails := replaceLocations (details )
262
- c .Assert (errgo .Details (err ), gc .Equals , wantDetails )
266
+ c .Assert (errgo .Details (err ), qt .Equals , wantDetails )
263
267
}
264
268
265
269
func replaceLocations (s string ) string {
0 commit comments