@@ -8,16 +8,16 @@ comparison fails. The one difference is that Assert() will end the test executio
88immediately (using t.FailNow()) whereas Check() will fail the test (using t.Fail()),
99return the value of the comparison, then proceed with the rest of the test case.
1010
11- Example Usage
11+ Example usage
1212
1313The example below shows assert used with some common types.
1414
1515
1616 import (
1717 "testing"
1818
19- "github.com/gotestyourself/gotestyourself /assert"
20- is "github.com/gotestyourself/gotestyourself /assert/cmp"
19+ "gotest.tools /assert"
20+ is "gotest.tools /assert/cmp"
2121 )
2222
2323 func TestEverything(t *testing.T) {
@@ -32,15 +32,15 @@ The example below shows assert used with some common types.
3232
3333 // errors
3434 assert.NilError(t, closer.Close())
35- assert.Assert (t, is.Error( err, "the exact error message") )
36- assert.Assert (t, is.ErrorContains( err, "includes this") )
37- assert.Assert (t, os.IsNotExist( err), "got %+v", err )
35+ assert.Error (t, err, "the exact error message")
36+ assert.ErrorContains (t, err, "includes this")
37+ assert.ErrorType (t, err, os.IsNotExist )
3838
3939 // complex types
40+ assert.DeepEqual(t, result, myStruct{Name: "title"})
4041 assert.Assert(t, is.Len(items, 3))
4142 assert.Assert(t, len(sequence) != 0) // NotEmpty
4243 assert.Assert(t, is.Contains(mapping, "key"))
43- assert.Assert(t, is.DeepEqual(result, myStruct{Name: "title"}))
4444
4545 // pointers and interface
4646 assert.Assert(t, is.Nil(ref))
@@ -49,31 +49,30 @@ The example below shows assert used with some common types.
4949
5050Comparisons
5151
52- https://godoc.org/github.com/gotestyourself/gotestyourself /assert/cmp provides
52+ Package https://godoc.org/gotest.tools /assert/cmp provides
5353many common comparisons. Additional comparisons can be written to compare
54- values in other ways.
54+ values in other ways. See the example Assert (CustomComparison).
5555
56- Below is an example of a custom comparison using a regex pattern:
56+ Automated migration from testify
57+
58+ gty-migrate-from-testify is a binary which can update source code which uses
59+ testify assertions to use the assertions provided by this package.
60+
61+ See http://bit.do/cmd-gty-migrate-from-testify.
5762
58- func RegexP(value string, pattern string) func() (bool, string) {
59- return func() (bool, string) {
60- re := regexp.MustCompile(pattern)
61- msg := fmt.Sprintf("%q did not match pattern %q", value, pattern)
62- return re.MatchString(value), msg
63- }
64- }
6563
6664*/
67- package assert
65+ package assert // import "gotest.tools/assert"
6866
6967import (
7068 "fmt"
7169 "go/ast"
7270 "go/token"
7371
74- "github.com/gotestyourself/gotestyourself/assert/cmp"
75- "github.com/gotestyourself/gotestyourself/internal/format"
76- "github.com/gotestyourself/gotestyourself/internal/source"
72+ gocmp "github.com/google/go-cmp/cmp"
73+ "gotest.tools/assert/cmp"
74+ "gotest.tools/internal/format"
75+ "gotest.tools/internal/source"
7776)
7877
7978// BoolOrComparison can be a bool, or cmp.Comparison. See Assert() for usage.
@@ -96,7 +95,7 @@ const failureMessage = "assertion failed: "
9695func assert (
9796 t TestingT ,
9897 failer func (),
99- argsFilter astExprListFilter ,
98+ argSelector argSelector ,
10099 comparison BoolOrComparison ,
101100 msgAndArgs ... interface {},
102101) bool {
@@ -123,10 +122,10 @@ func assert(
123122 t .Log (format .WithCustomMessage (failureMessage + msg + check .Error (), msgAndArgs ... ))
124123
125124 case cmp.Comparison :
126- success = runComparison (t , argsFilter , check , msgAndArgs ... )
125+ success = runComparison (t , argSelector , check , msgAndArgs ... )
127126
128127 case func () cmp.Result :
129- success = runComparison (t , argsFilter , check , msgAndArgs ... )
128+ success = runComparison (t , argSelector , check , msgAndArgs ... )
130129
131130 default :
132131 t .Log (fmt .Sprintf ("invalid Comparison: %v (%T)" , check , check ))
@@ -155,6 +154,9 @@ func runCompareFunc(
155154}
156155
157156func logFailureFromBool (t TestingT , msgAndArgs ... interface {}) {
157+ if ht , ok := t .(helperT ); ok {
158+ ht .Helper ()
159+ }
158160 const stackIndex = 3 // Assert()/Check(), assert(), formatFailureFromBool()
159161 const comparisonArgPos = 1
160162 args , err := source .CallExprArgs (stackIndex )
@@ -215,7 +217,7 @@ func Assert(t TestingT, comparison BoolOrComparison, msgAndArgs ...interface{})
215217 if ht , ok := t .(helperT ); ok {
216218 ht .Helper ()
217219 }
218- assert (t , t .FailNow , filterExprArgsFromComparison , comparison , msgAndArgs ... )
220+ assert (t , t .FailNow , argsFromComparisonCall , comparison , msgAndArgs ... )
219221}
220222
221223// Check performs a comparison. If the comparison fails the test is marked as
@@ -227,7 +229,7 @@ func Check(t TestingT, comparison BoolOrComparison, msgAndArgs ...interface{}) b
227229 if ht , ok := t .(helperT ); ok {
228230 ht .Helper ()
229231 }
230- return assert (t , t .Fail , filterExprArgsFromComparison , comparison , msgAndArgs ... )
232+ return assert (t , t .Fail , argsFromComparisonCall , comparison , msgAndArgs ... )
231233}
232234
233235// NilError fails the test immediately if err is not nil.
@@ -236,14 +238,74 @@ func NilError(t TestingT, err error, msgAndArgs ...interface{}) {
236238 if ht , ok := t .(helperT ); ok {
237239 ht .Helper ()
238240 }
239- assert (t , t .FailNow , filterExprExcludeFirst , err , msgAndArgs ... )
241+ assert (t , t .FailNow , argsAfterT , err , msgAndArgs ... )
240242}
241243
242244// Equal uses the == operator to assert two values are equal and fails the test
243- // if they are not equal. This is equivalent to Assert(t, cmp.Equal(x, y)).
245+ // if they are not equal.
246+ //
247+ // If the comparison fails Equal will use the variable names for x and y as part
248+ // of the failure message to identify the actual and expected values.
249+ //
250+ // If either x or y are a multi-line string the failure message will include a
251+ // unified diff of the two values. If the values only differ by whitespace
252+ // the unified diff will be augmented by replacing whitespace characters with
253+ // visible characters to identify the whitespace difference.
254+ //
255+ // This is equivalent to Assert(t, cmp.Equal(x, y)).
244256func Equal (t TestingT , x , y interface {}, msgAndArgs ... interface {}) {
245257 if ht , ok := t .(helperT ); ok {
246258 ht .Helper ()
247259 }
248- assert (t , t .FailNow , filterExprExcludeFirst , cmp .Equal (x , y ), msgAndArgs ... )
260+ assert (t , t .FailNow , argsAfterT , cmp .Equal (x , y ), msgAndArgs ... )
261+ }
262+
263+ // DeepEqual uses google/go-cmp (http://bit.do/go-cmp) to assert two values are
264+ // equal and fails the test if they are not equal.
265+ //
266+ // Package https://godoc.org/gotest.tools/assert/opt provides some additional
267+ // commonly used Options.
268+ //
269+ // This is equivalent to Assert(t, cmp.DeepEqual(x, y)).
270+ func DeepEqual (t TestingT , x , y interface {}, opts ... gocmp.Option ) {
271+ if ht , ok := t .(helperT ); ok {
272+ ht .Helper ()
273+ }
274+ assert (t , t .FailNow , argsAfterT , cmp .DeepEqual (x , y , opts ... ))
275+ }
276+
277+ // Error fails the test if err is nil, or the error message is not the expected
278+ // message.
279+ // Equivalent to Assert(t, cmp.Error(err, message)).
280+ func Error (t TestingT , err error , message string , msgAndArgs ... interface {}) {
281+ if ht , ok := t .(helperT ); ok {
282+ ht .Helper ()
283+ }
284+ assert (t , t .FailNow , argsAfterT , cmp .Error (err , message ), msgAndArgs ... )
285+ }
286+
287+ // ErrorContains fails the test if err is nil, or the error message does not
288+ // contain the expected substring.
289+ // Equivalent to Assert(t, cmp.ErrorContains(err, substring)).
290+ func ErrorContains (t TestingT , err error , substring string , msgAndArgs ... interface {}) {
291+ if ht , ok := t .(helperT ); ok {
292+ ht .Helper ()
293+ }
294+ assert (t , t .FailNow , argsAfterT , cmp .ErrorContains (err , substring ), msgAndArgs ... )
295+ }
296+
297+ // ErrorType fails the test if err is nil, or err is not the expected type.
298+ //
299+ // Expected can be one of:
300+ // a func(error) bool which returns true if the error is the expected type,
301+ // an instance of (or a pointer to) a struct of the expected type,
302+ // a pointer to an interface the error is expected to implement,
303+ // a reflect.Type of the expected struct or interface.
304+ //
305+ // Equivalent to Assert(t, cmp.ErrorType(err, expected)).
306+ func ErrorType (t TestingT , err error , expected interface {}, msgAndArgs ... interface {}) {
307+ if ht , ok := t .(helperT ); ok {
308+ ht .Helper ()
309+ }
310+ assert (t , t .FailNow , argsAfterT , cmp .ErrorType (err , expected ), msgAndArgs ... )
249311}
0 commit comments