From 58bacd98ce970f3e8275902d38aa5271c83964f4 Mon Sep 17 00:00:00 2001 From: NiseVoid Date: Wed, 27 May 2020 19:56:16 +0200 Subject: [PATCH] Fix calls to t.Helper and optimize --- assert.go | 103 ++++++++++++++++++++++++------------------------------ helper.go | 9 ----- 2 files changed, 45 insertions(+), 67 deletions(-) diff --git a/assert.go b/assert.go index 37582a6..6c762c3 100644 --- a/assert.go +++ b/assert.go @@ -2,33 +2,32 @@ package assert import ( "reflect" - "runtime" "github.com/google/go-cmp/cmp" ) // Assert is a helper for tests -type Assert func(bool, ...interface{}) +type Assert struct { + t T +} + +func (a Assert) f(ok bool, msg []interface{}, format string, extra ...interface{}) { + if !ok { + if format != `` { + msg = prepMsg(msg, format, extra...) + } + if msg == nil { + msg = []interface{}{`Assertion failed`} + } + msg = append(append([]interface{}{shell(1) + shell(97) + shell(41) + `FAIL!` + shell(0) + shell(1)}, msg...), shell(0), "\n") + a.t.Helper() + a.t.Error(msg...) + } +} // New returns a new Assert func New(t T) Assert { - a := func(ok bool, msg ...interface{}) { - if !ok { - if msg == nil { - msg = []interface{}{`Assertion failed`} - } - msg = append(append([]interface{}{shell(1) + shell(97) + shell(41) + `FAIL!` + shell(0) + shell(1)}, msg...), shell(0), "\n") - t.Helper() - t.Error(msg...) - } - } - - f := runtime.FuncForPC(reflect.ValueOf(a).Pointer()) - ts[f] = t - - t.Cleanup(func() { - delete(ts, f) - }) + a := Assert{t} return a } @@ -39,16 +38,14 @@ func New(t T) Assert { // True asserts the given value is true func (a Assert) True(actual bool, msg ...interface{}) { - t(a).Helper() - msg = prepMsg(msg, `Should be true, but it isn't`) - a(actual, msg...) + a.t.Helper() + a.f(actual, msg, `Should be true, but it isn't`) } // False sserts the given value is false func (a Assert) False(actual bool, msg ...interface{}) { - t(a).Helper() - msg = prepMsg(msg, `Should be false, but it isn't`) - a(!actual, msg...) + a.t.Helper() + a.f(!actual, msg, `Should be false, but it isn't`) } ///// Nil ///// @@ -69,87 +66,76 @@ func isNil(val interface{}) bool { // Nil asserts the given value is nil func (a Assert) Nil(actual interface{}, msg ...interface{}) { - t(a).Helper() - msg = prepMsg(msg, `Should be nil, but got %#v`, actual) - - a(isNil(actual), msg...) + a.t.Helper() + a.f(isNil(actual), msg, `Should be nil, but got %#v`, actual) } // NotNil sserts the given value is not nil func (a Assert) NotNil(actual interface{}, msg ...interface{}) { - t(a).Helper() - msg = prepMsg(msg, `Should not be nil, but it is`) - - a(!isNil(actual), msg...) + a.t.Helper() + a.f(!isNil(actual), msg, `Should not be nil, but it is`) } ///// Errors ///// // Error asserts the given error is not nil func (a Assert) Error(actual error, msg ...interface{}) { - t(a).Helper() - msg = prepMsg(msg, `Expected an error, but got nil`) - a(actual != nil, msg...) + a.t.Helper() + a.f(actual != nil, msg, `Expected an error, but got nil`) } // NoError asserts the given error is not nil func (a Assert) NoError(actual error, msg ...interface{}) { - t(a).Helper() - msg = prepMsg(msg, `Expected no error, but got %#v`, actual) - a(actual == nil, msg...) + a.t.Helper() + a.f(actual == nil, msg, `Expected no error, but got %#v`, actual) } ///// Comparisons ///// // Eq asserts the given values match func (a Assert) Eq(expected, actual interface{}, msg ...interface{}) { - t(a).Helper() + a.t.Helper() if reflect.TypeOf(expected) != reflect.TypeOf(actual) { - msg = prepMsg(msg, `Expected %T(%#v), but got %T(%#v)`, expected, expected, actual, actual) - a(false, msg...) + a.f(false, msg, `Expected %T(%#v), but got %T(%#v)`, expected, expected, actual, actual) return } - msg = prepMsg(msg, `Expected %#v, but got %#v`, expected, actual) - a(expected == actual, msg...) + a.f(expected == actual, msg, `Expected %#v, but got %#v`, expected, actual) } // Ne asserts the given values don't match func (a Assert) Ne(expected, actual interface{}, msg ...interface{}) { - t(a).Helper() - msg = prepMsg(msg, `Should not be %#v, but it is`, expected) - a(expected != actual, msg...) + a.t.Helper() + a.f(expected != actual, msg, `Should not be %#v, but it is`, expected) } ///// Lists ///// // Contains asserts the expected value is in the given list func (a Assert) Contains(expected, list interface{}, msg ...interface{}) { - t(a).Helper() + a.t.Helper() rlist := reflect.ValueOf(list) - a(rlist.Kind() == reflect.Slice || rlist.Kind() == reflect.Array, `Can only call assert.Contains on a slice or array`) + a.f(rlist.Kind() == reflect.Slice || rlist.Kind() == reflect.Array, nil, `Can only call assert.Contains on a slice or array`) for i := 0; i < rlist.Len(); i++ { if rlist.Index(i).Interface() == expected { return } } - msg = prepMsg(msg, `Expected %#v to be in %#v, but it isn't`, expected, list) - a(false, msg...) + a.f(false, msg, `Expected %#v to be in %#v, but it isn't`, expected, list) } // SameElements asserts the values have the same elements. It ignores the order of the elements func (a Assert) SameElements(expected, actual interface{}, msg ...interface{}) { - t(a).Helper() + a.t.Helper() rexpected, ractual := reflect.ValueOf(expected), reflect.ValueOf(actual) - a(rexpected.Kind() == reflect.Slice || rexpected.Kind() == reflect.Array, `Can only call assert.SameElements on a slice or array`) - a(ractual.Kind() == reflect.Slice || ractual.Kind() == reflect.Array, `Can only call assert.SameElements on a slice or array`) + a.f(rexpected.Kind() == reflect.Slice || rexpected.Kind() == reflect.Array, nil, `Can only call assert.SameElements on a slice or array`) + a.f(ractual.Kind() == reflect.Slice || ractual.Kind() == reflect.Array, nil, `Can only call assert.SameElements on a slice or array`) - msg = prepMsg(msg, `Expected elements of %#v to match %#v, but they don't`, expected, actual) if rexpected.Len() != ractual.Len() { - a(false, msg...) + a.f(false, msg, `Expected elements of %#v to match %#v, but they don't`, expected, actual) return } @@ -167,14 +153,15 @@ func (a Assert) SameElements(expected, actual interface{}, msg ...interface{}) { return } - a(false, msg...) + a.f(false, msg, ``) } func (a Assert) Cmp(expected, actual interface{}, opts ...cmp.Option) { + a.t.Helper() diff := cmp.Diff(expected, actual, opts...) if diff == `` { return } - a(false, "\n"+diff) + a.f(false, nil, "\n"+diff) } diff --git a/helper.go b/helper.go index e94190b..d8d5e63 100644 --- a/helper.go +++ b/helper.go @@ -2,8 +2,6 @@ package assert import ( "fmt" - "reflect" - "runtime" "strconv" ) @@ -14,10 +12,3 @@ func prepMsg(msg []interface{}, format string, args ...interface{}) []interface{ func shell(i int) string { return "\x1B[" + strconv.Itoa(i) + "m" } - -var ts = map[*runtime.Func]T{} - -func t(a Assert) T { - f := runtime.FuncForPC(reflect.ValueOf(a).Pointer()) - return ts[f] -}