From f5cea76cb7b102b167e698e28e85a55a7e46850b Mon Sep 17 00:00:00 2001 From: Brian Picciano Date: Sun, 10 Mar 2019 19:23:37 -0400 Subject: [PATCH] mtest/massert: rename a bunch of functions --- env.test | 5 ++ m/m_test.go | 6 +- mcfg/source_test.go | 10 +-- mctx/annotate_test.go | 24 +++---- mctx/ctx_test.go | 48 ++++++------- mdb/mbigtable/bigtable_test.go | 6 +- mdb/mdatastore/datastore_test.go | 2 +- merr/merr_test.go | 28 ++++---- merr/stack_test.go | 10 +-- mhttp/mhttp_test.go | 8 +-- mlog/mlog_test.go | 18 ++--- mnet/mnet_test.go | 6 +- mrun/hook_test.go | 8 +-- mtest/massert/massert.go | 62 +++++++---------- mtest/massert/massert_test.go | 114 +++++++++++++++---------------- 15 files changed, 174 insertions(+), 181 deletions(-) diff --git a/env.test b/env.test index b639da3..ad66e16 100644 --- a/env.test +++ b/env.test @@ -17,3 +17,8 @@ if [ "$(ps aux | grep '[b]igtable-emulator')" = "" ]; then yes | gcloud beta emulators bigtable start --host-port 127.0.0.1:8086 >/dev/null 2>&1 & fi $(gcloud beta emulators bigtable env-init) + +if ! (sudo systemctl status mysqld 1>/dev/null); then + echo "starting mysqld" + sudo systemctl start mysqld +fi diff --git a/m/m_test.go b/m/m_test.go index 47eb4b9..0756cb4 100644 --- a/m/m_test.go +++ b/m/m_test.go @@ -39,14 +39,14 @@ func TestServiceCtx(t *T) { mlog.From(ctxA).Info("foo", ctxA) mlog.From(ctxA).Debug("bar", ctxA) - massert.Fatal(t, massert.All( - massert.Len(msgs, 2), + massert.Require(t, + massert.Length(msgs, 2), massert.Equal(msgs[0].Level.String(), "INFO"), massert.Equal(msgs[0].Description, "foo"), massert.Equal(msgs[0].Contexts, []context.Context{ctxA}), massert.Equal(msgs[1].Level.String(), "DEBUG"), massert.Equal(msgs[1].Description, "bar"), massert.Equal(msgs[1].Contexts, []context.Context{ctxA}), - )) + ) }) } diff --git a/mcfg/source_test.go b/mcfg/source_test.go index db31e07..00e959d 100644 --- a/mcfg/source_test.go +++ b/mcfg/source_test.go @@ -148,7 +148,7 @@ func (scs srcCommonState) assert(s Source) error { return err } return massert.All( - massert.Len(gotPVs, len(scs.expPVs)), + massert.Length(gotPVs, len(scs.expPVs)), massert.Subset(scs.expPVs, gotPVs), ).Assert() } @@ -163,12 +163,12 @@ func TestSources(t *T) { SourceCLI{Args: []string{"--a=1", "--b=666"}}, SourceEnv{Env: []string{"B=2", "C=3"}}, }) - massert.Fatal(t, massert.All( + massert.Require(t, massert.Nil(err), massert.Equal(1, *a), massert.Equal(2, *b), massert.Equal(3, *c), - )) + ) } func TestSourceParamValues(t *T) { @@ -184,10 +184,10 @@ func TestSourceParamValues(t *T) { {Path: []string{"foo"}, Name: "b", Value: json.RawMessage(`"bbb"`)}, {Path: []string{"foo"}, Name: "c", Value: json.RawMessage("true")}, }) - massert.Fatal(t, massert.All( + massert.Require(t, massert.Nil(err), massert.Equal(4, *a), massert.Equal("bbb", *b), massert.Equal(true, *c), - )) + ) } diff --git a/mctx/annotate_test.go b/mctx/annotate_test.go index acff519..248cbe9 100644 --- a/mctx/annotate_test.go +++ b/mctx/annotate_test.go @@ -20,19 +20,19 @@ func TestAnnotate(t *T) { parentAnnotations := Annotations(parent) childAnnotations := Annotations(child) - massert.Fatal(t, massert.All( - massert.Len(parentAnnotations, 2), - massert.Has(parentAnnotations, Annotation{Key: "a", Value: "foo"}), - massert.Has(parentAnnotations, Annotation{Key: "b", Value: "bar"}), + massert.Require(t, + massert.Length(parentAnnotations, 2), + massert.HasValue(parentAnnotations, Annotation{Key: "a", Value: "foo"}), + massert.HasValue(parentAnnotations, Annotation{Key: "b", Value: "bar"}), - massert.Len(childAnnotations, 4), - massert.Has(childAnnotations, Annotation{Key: "a", Value: "foo"}), - massert.Has(childAnnotations, Annotation{Key: "b", Value: "bar"}), - massert.Has(childAnnotations, + massert.Length(childAnnotations, 4), + massert.HasValue(childAnnotations, Annotation{Key: "a", Value: "foo"}), + massert.HasValue(childAnnotations, Annotation{Key: "b", Value: "bar"}), + massert.HasValue(childAnnotations, Annotation{Key: "a", Path: []string{"child"}, Value: "FOO"}), - massert.Has(childAnnotations, + massert.HasValue(childAnnotations, Annotation{Key: "c", Path: []string{"child"}, Value: "BAZ"}), - )) + ) } func TestAnnotationsStringMap(t *T) { @@ -46,7 +46,7 @@ func TestAnnotationsStringMap(t *T) { {Key: B(2), Path: []string{"foo"}, Value: "TWO"}, } - massert.Fatal(t, massert.All( + massert.Require(t, massert.Equal(map[string]string{ "0": "zero", "1(/)": "one", @@ -65,7 +65,7 @@ func TestAnnotationsStringMap(t *T) { "2(mctx.B)": "TWO", }, }, aa.StringMapByPath()), - )) + ) } func TestMergeAnnotations(t *T) { diff --git a/mctx/ctx_test.go b/mctx/ctx_test.go index 5772299..53a5724 100644 --- a/mctx/ctx_test.go +++ b/mctx/ctx_test.go @@ -18,19 +18,19 @@ func TestInheritance(t *T) { ctx = WithChild(ctx, ctx1) ctx = WithChild(ctx, ctx2) - massert.Fatal(t, massert.All( - massert.Len(Path(ctx), 0), + massert.Require(t, + massert.Length(Path(ctx), 0), massert.Equal(Path(ctx1), []string{"1"}), massert.Equal(Path(ctx1a), []string{"1", "a"}), massert.Equal(Path(ctx1b), []string{"1", "b"}), massert.Equal(Path(ctx2), []string{"2"}), - )) + ) - massert.Fatal(t, massert.All( + massert.Require(t, massert.Equal([]context.Context{ctx1, ctx2}, Children(ctx)), massert.Equal([]context.Context{ctx1a, ctx1b}, Children(ctx1)), - massert.Len(Children(ctx2), 0), - )) + massert.Length(Children(ctx2), 0), + ) } func TestBreadFirstVisit(t *T) { @@ -50,7 +50,7 @@ func TestBreadFirstVisit(t *T) { got = append(got, ctx) return true }) - massert.Fatal(t, + massert.Require(t, massert.Equal([]context.Context{ctx, ctx1, ctx2, ctx1a, ctx1b}, got), ) } @@ -64,7 +64,7 @@ func TestBreadFirstVisit(t *T) { got = append(got, ctx) return true }) - massert.Fatal(t, + massert.Require(t, massert.Equal([]context.Context{ctx, ctx1, ctx2}, got), ) } @@ -74,44 +74,44 @@ func TestLocalValues(t *T) { // test with no value set ctx := context.Background() - massert.Fatal(t, massert.All( + massert.Require(t, massert.Nil(LocalValue(ctx, "foo")), - massert.Len(LocalValues(ctx), 0), - )) + massert.Length(LocalValues(ctx), 0), + ) // test basic value retrieval ctx = WithLocalValue(ctx, "foo", "bar") - massert.Fatal(t, massert.All( + massert.Require(t, massert.Equal("bar", LocalValue(ctx, "foo")), massert.Equal( map[interface{}]interface{}{"foo": "bar"}, LocalValues(ctx), ), - )) + ) // test that doesn't conflict with WithValue ctx = context.WithValue(ctx, "foo", "WithValue bar") - massert.Fatal(t, massert.All( + massert.Require(t, massert.Equal("bar", LocalValue(ctx, "foo")), massert.Equal("WithValue bar", ctx.Value("foo")), massert.Equal( map[interface{}]interface{}{"foo": "bar"}, LocalValues(ctx), ), - )) + ) // test that child doesn't get values child := NewChild(ctx, "child") - massert.Fatal(t, massert.All( + massert.Require(t, massert.Equal("bar", LocalValue(ctx, "foo")), massert.Nil(LocalValue(child, "foo")), - massert.Len(LocalValues(child), 0), - )) + massert.Length(LocalValues(child), 0), + ) // test that values on child don't affect parent values child = WithLocalValue(child, "foo", "child bar") ctx = WithChild(ctx, child) - massert.Fatal(t, massert.All( + massert.Require(t, massert.Equal("bar", LocalValue(ctx, "foo")), massert.Equal("child bar", LocalValue(child, "foo")), massert.Equal( @@ -122,12 +122,12 @@ func TestLocalValues(t *T) { map[interface{}]interface{}{"foo": "child bar"}, LocalValues(child), ), - )) + ) // test that two With calls on the same context generate distinct contexts childA := WithLocalValue(child, "foo2", "baz") childB := WithLocalValue(child, "foo2", "buz") - massert.Fatal(t, massert.All( + massert.Require(t, massert.Equal("bar", LocalValue(ctx, "foo")), massert.Equal("child bar", LocalValue(child, "foo")), massert.Nil(LocalValue(child, "foo2")), @@ -141,16 +141,16 @@ func TestLocalValues(t *T) { map[interface{}]interface{}{"foo": "child bar", "foo2": "buz"}, LocalValues(childB), ), - )) + ) // if a value overwrites a previous one the newer one should show in // LocalValues ctx = WithLocalValue(ctx, "foo", "barbar") - massert.Fatal(t, massert.All( + massert.Require(t, massert.Equal("barbar", LocalValue(ctx, "foo")), massert.Equal( map[interface{}]interface{}{"foo": "barbar"}, LocalValues(ctx), ), - )) + ) } diff --git a/mdb/mbigtable/bigtable_test.go b/mdb/mbigtable/bigtable_test.go index 36c4417..c43f015 100644 --- a/mdb/mbigtable/bigtable_test.go +++ b/mdb/mbigtable/bigtable_test.go @@ -35,10 +35,10 @@ func TestBasic(t *T) { t.Fatal(err) } readColFam := readRow[colFam] - massert.Fatal(t, massert.All( - massert.Len(readColFam, 1), + massert.Require(t, + massert.Length(readColFam, 1), massert.Equal(colFam+":col", readColFam[0].Column), massert.Equal([]byte("bar"), readColFam[0].Value), - )) + ) }) } diff --git a/mdb/mdatastore/datastore_test.go b/mdb/mdatastore/datastore_test.go index 759b0b1..99d92a5 100644 --- a/mdb/mdatastore/datastore_test.go +++ b/mdb/mdatastore/datastore_test.go @@ -35,6 +35,6 @@ func TestBasic(t *T) { t.Fatal(err) } - massert.Fatal(t, massert.Equal(val, val2)) + massert.Require(t, massert.Equal(val, val2)) }) } diff --git a/merr/merr_test.go b/merr/merr_test.go index b64d315..9ae6eed 100644 --- a/merr/merr_test.go +++ b/merr/merr_test.go @@ -10,7 +10,7 @@ import ( ) func TestError(t *T) { - massert.Fatal(t, massert.Nil(Wrap(nil))) + massert.Require(t, massert.Nil(Wrap(nil))) ctx := mctx.Annotate(context.Background(), "a", "aaa aaa\n", @@ -25,8 +25,8 @@ func TestError(t *T) { ccc ccc * d: weird key but ok - * errLoc: merr/merr_test.go:19` - massert.Fatal(t, massert.Equal(exp, e.Error())) + * errLoc: merr/merr_test.go:21` + massert.Require(t, massert.Equal(exp, e.Error())) } { @@ -37,15 +37,15 @@ func TestError(t *T) { ccc ccc * d: weird key but ok - * errLoc: merr/merr_test.go:31` - massert.Fatal(t, massert.Equal(exp, e.Error())) + * errLoc: merr/merr_test.go:33` + massert.Require(t, massert.Equal(exp, e.Error())) } } func TestBase(t *T) { errFoo, errBar := errors.New("foo"), errors.New("bar") erFoo := Wrap(errFoo) - massert.Fatal(t, massert.All( + massert.Require(t, massert.Nil(Base(nil)), massert.Equal(errFoo, Base(erFoo)), massert.Equal(errBar, Base(errBar)), @@ -53,29 +53,29 @@ func TestBase(t *T) { massert.Not(massert.Equal(errBar, Base(erFoo))), massert.Equal(true, Equal(errFoo, erFoo)), massert.Equal(false, Equal(errBar, erFoo)), - )) + ) } func TestValue(t *T) { - massert.Fatal(t, massert.All( + massert.Require(t, massert.Nil(WithValue(nil, "foo", "bar")), massert.Nil(Value(nil, "foo")), - )) + ) e1 := New("foo") e1 = WithValue(e1, "a", "A") e2 := WithValue(errors.New("bar"), "a", "A") - massert.Fatal(t, massert.All( + massert.Require(t, massert.Equal("A", Value(e1, "a")), massert.Equal("A", Value(e2, "a")), - )) + ) e3 := WithValue(e2, "a", "AAA") - massert.Fatal(t, massert.All( + massert.Require(t, massert.Equal("A", Value(e1, "a")), massert.Equal("A", Value(e2, "a")), massert.Equal("AAA", Value(e3, "a")), - )) + ) } func mkErr(ctx context.Context, err error) error { @@ -96,7 +96,7 @@ func TestCtx(t *T) { "1": "ONE", "2": "TWO", "err": "hello", - "errLoc": "merr/merr_test.go:80", + "errLoc": "merr/merr_test.go:82", }, mctx.Annotations(Context(e)).StringMap()).Assert() if err != nil { t.Fatal(err) diff --git a/merr/stack_test.go b/merr/stack_test.go index e17ac03..ef45785 100644 --- a/merr/stack_test.go +++ b/merr/stack_test.go @@ -10,17 +10,17 @@ import ( func TestStack(t *T) { foo := New("test") fooStack, ok := Stack(foo) - massert.Fatal(t, massert.Equal(true, ok)) + massert.Require(t, massert.Equal(true, ok)) // test Frame frame := fooStack.Frame() - massert.Fatal(t, massert.All( + massert.Require(t, massert.Equal(true, strings.Contains(frame.File, "stack_test.go")), massert.Equal(true, strings.Contains(frame.Function, "TestStack")), - )) + ) frames := fooStack.Frames() - massert.Fatal(t, massert.Comment( + massert.Require(t, massert.Comment( massert.All( massert.Equal(true, len(frames) >= 2), massert.Equal(true, strings.Contains(frames[0].File, "stack_test.go")), @@ -34,7 +34,7 @@ func TestStack(t *T) { bar := WithStack(foo, 1) barStack, _ := Stack(bar) frames := barStack.Frames() - massert.Fatal(t, massert.Comment( + massert.Require(t, massert.Comment( massert.All( massert.Equal(true, len(frames) >= 2), massert.Equal(true, strings.Contains(frames[0].File, "stack_test.go")), diff --git a/mhttp/mhttp_test.go b/mhttp/mhttp_test.go index 5db0aad..a9c0194 100644 --- a/mhttp/mhttp_test.go +++ b/mhttp/mhttp_test.go @@ -45,17 +45,17 @@ func TestAddXForwardedFor(t *T) { AddXForwardedFor(r, ipStr) var a massert.Assertion if expected == "" { - a = massert.Len(r.Header["X-Forwarded-For"], 0) + a = massert.Length(r.Header["X-Forwarded-For"], 0) } else { a = massert.All( - massert.Len(r.Header["X-Forwarded-For"], 1), + massert.Length(r.Header["X-Forwarded-For"], 1), massert.Equal(expected, r.Header["X-Forwarded-For"][0]), ) } return massert.Comment(a, "prev:%#v ipStr:%q", prev, ipStr) } - massert.Fatal(t, massert.All( + massert.Require(t, assertXFF(nil, "invalid", ""), assertXFF(nil, "::1", ""), assertXFF([]string{"8.0.0.0"}, "invalid", "8.0.0.0"), @@ -66,5 +66,5 @@ func TestAddXForwardedFor(t *T) { assertXFF([]string{"8.0.0.0, 8.0.0.1"}, "8.0.0.2", "8.0.0.0, 8.0.0.1, 8.0.0.2"), assertXFF([]string{"8.0.0.0, 8.0.0.1", "8.0.0.2"}, "8.0.0.3", "8.0.0.0, 8.0.0.1, 8.0.0.2, 8.0.0.3"), - )) + ) } diff --git a/mlog/mlog_test.go b/mlog/mlog_test.go index 427bc6d..86aa8bd 100644 --- a/mlog/mlog_test.go +++ b/mlog/mlog_test.go @@ -12,11 +12,11 @@ import ( ) func TestTruncate(t *T) { - massert.Fatal(t, massert.All( + massert.Require(t, massert.Equal("abc", Truncate("abc", 4)), massert.Equal("abc", Truncate("abc", 3)), massert.Equal("ab...", Truncate("abc", 2)), - )) + ) } func TestLogger(t *T) { @@ -31,7 +31,7 @@ func TestLogger(t *T) { select { case <-l.testMsgWrittenCh: case <-time.After(1 * time.Second): - return massert.Errf("waited too long for msg to write") + return massert.Errorf("waited too long for msg to write") } out, err := buf.ReadString('\n') return massert.All( @@ -45,11 +45,11 @@ func TestLogger(t *T) { l.Info("bar") l.Warn("baz") l.Error("buz") - massert.Fatal(t, massert.All( + massert.Require(t, assertOut(`{"level":"INFO","descr":"bar"}`), assertOut(`{"level":"WARN","descr":"baz"}`), assertOut(`{"level":"ERROR","descr":"buz"}`), - )) + ) ctx := context.Background() @@ -58,10 +58,10 @@ func TestLogger(t *T) { l.Info("bar") l.Warn("baz") l.Error("buz", mctx.Annotate(ctx, "a", "b", "c", "d")) - massert.Fatal(t, massert.All( + massert.Require(t, assertOut(`{"level":"WARN","descr":"baz"}`), assertOut(`{"level":"ERROR","descr":"buz","annotations":{"/":{"a":"b","c":"d"}}}`), - )) + ) l2 := l.Clone() l2.SetMaxLevel(InfoLevel) @@ -72,9 +72,9 @@ func TestLogger(t *T) { l2.Info("bar") l2.Warn("baz") l.Error("buz") - massert.Fatal(t, massert.All( + massert.Require(t, assertOut(`{"level":"INFO","descr":"BAR"}`), assertOut(`{"level":"WARN","descr":"BAZ"}`), assertOut(`{"level":"ERROR","descr":"buz"}`), - )) + ) } diff --git a/mnet/mnet_test.go b/mnet/mnet_test.go index e49aa0f..92024f4 100644 --- a/mnet/mnet_test.go +++ b/mnet/mnet_test.go @@ -20,15 +20,15 @@ func TestIsReservedIP(t *T) { "ip:%q", ipStr) } - massert.Fatal(t, massert.All( + massert.Require(t, assertReserved("127.0.0.1"), assertReserved("::ffff:127.0.0.1"), assertReserved("192.168.40.50"), assertReserved("::1"), assertReserved("100::1"), - )) + ) - massert.Fatal(t, massert.None( + massert.Require(t, massert.None( assertReserved("8.8.8.8"), assertReserved("::ffff:8.8.8.8"), assertReserved("2600:1700:7580:6e80:21c:25ff:fe97:44df"), diff --git a/mrun/hook_test.go b/mrun/hook_test.go index b4c5b09..d660fe5 100644 --- a/mrun/hook_test.go +++ b/mrun/hook_test.go @@ -37,14 +37,14 @@ func TestHooks(t *T) { ctx = WithHook(ctx, 0, mkHook(7)) - massert.Fatal(t, massert.All( + massert.Require(t, massert.Nil(TriggerHooks(ctx, 0)), massert.Equal([]int{1, 2, 3, 4, 5, 6, 7}, out), - )) + ) out = nil - massert.Fatal(t, massert.All( + massert.Require(t, massert.Nil(TriggerHooksReverse(ctx, 0)), massert.Equal([]int{7, 6, 5, 4, 3, 2, 1}, out), - )) + ) } diff --git a/mtest/massert/massert.go b/mtest/massert/massert.go index 0ac9584..9d4ee74 100644 --- a/mtest/massert/massert.go +++ b/mtest/massert/massert.go @@ -151,23 +151,23 @@ func (a *assertion) Stack() []runtime.Frame { //////////////////////////////////////////////////////////////////////////////// -// Fatal is a convenience function which performs the Assertion and calls Fatal -// on the testing.T instance if the assertion fails. -// -// TODO rename to Require -func Fatal(t *testing.T, a Assertion) { - if err := a.Assert(); err != nil { - t.Fatal(err) +// Require is a convenience function which performs the Assertions and calls +// Fatal on the testing.T instance for the first Assertion which fails. +func Require(t *testing.T, aa ...Assertion) { + for _, a := range aa { + if err := a.Assert(); err != nil { + t.Fatal(err) + } } } -// Error is a convenience function which performs the Assertion and calls Error -// on the testing.T instance if the assertion fails. -// -// TODO rename to Assert -func Error(t *testing.T, a Assertion) { - if err := a.Assert(); err != nil { - t.Error(err) +// Assert is a convenience function which performs the Assertion and calls Error +// on the testing.T instance for the first Assertion which fails. +func Assert(t *testing.T, aa ...Assertion) { + for _, a := range aa { + if err := a.Assert(); err != nil { + t.Error(err) + } } } @@ -291,18 +291,14 @@ func None(aa ...Assertion) Assertion { return newAssertion(fn, fmtMultiDescr("None", aa...), 0) } -// Err returns an Assertion which always fails with the given error. -// -// TODO rename to Error -func Err(err error) Assertion { +// Error returns an Assertion which always fails with the given error. +func Error(err error) Assertion { return newAssertion(func() error { return err }, "", 0) } -// Errf is like Err but allows for a formatted string. -// -// TODO rename to Errorf -func Errf(str string, args ...interface{}) Assertion { - return Err(fmt.Errorf(str, args...)) +// Errorf is like Err but allows for a formatted string. +func Errorf(str string, args ...interface{}) Assertion { + return Error(fmt.Errorf(str, args...)) } //////////////////////////////////////////////////////////////////////////////// @@ -313,10 +309,6 @@ func toStr(i interface{}) string { // Equal asserts that the two values are exactly equal, and uses the // reflect.DeepEqual function to determine if they are. -// -// TODO this does not currently handle the case of creating the Assertion using -// a reference type (like a map), changing one of the map's keys, and then -// calling Assert. func Equal(a, b interface{}) Assertion { return newAssertion(func() error { if !reflect.DeepEqual(a, b) { @@ -409,12 +401,10 @@ func Subset(set, subset interface{}) Assertion { }, toStr(set)+" has subset "+toStr(subset), 0) } -// Has asserts that the given set has the given element as a value in it. The -// set may be an array, a slice, or a map, and if it's a map then the elem will -// need to be a value in it. -// -// TODO rename to HasValue -func Has(set, elem interface{}) Assertion { +// HasValue asserts that the given set has the given element as a value in it. +// The set may be an array, a slice, or a map, and if it's a map then the elem +// will need to be a value in it. +func HasValue(set, elem interface{}) Assertion { setVV, err := toSet(set, false) if err != nil { panic(err) @@ -450,12 +440,10 @@ func HasKey(set, elem interface{}) Assertion { }, toStr(set)+" has key "+toStr(elem), 0) } -// Len asserts that the given set has the given number of elements in it. The +// Length asserts that the given set has the given number of elements in it. The // set may be an array, a slice, or a map. A nil value'd set is considered to be // a length of zero. -// -// TODO rename to Length -func Len(set interface{}, length int) Assertion { +func Length(set interface{}, length int) Assertion { setVV, err := toSet(set, false) if err != nil { panic(err) diff --git a/mtest/massert/massert_test.go b/mtest/massert/massert_test.go index ce5d840..125417b 100644 --- a/mtest/massert/massert_test.go +++ b/mtest/massert/massert_test.go @@ -96,12 +96,12 @@ func TestNone(t *T) { } func TestEqual(t *T) { - Fatal(t, All( + Require(t, Equal(1, 1), Equal("foo", "foo"), - )) + ) - Fatal(t, None( + Require(t, None( Equal(1, 2), Equal(1, int64(1)), Equal(1, uint64(1)), @@ -116,20 +116,20 @@ func TestEqual(t *T) { aa = append(aa, Equal(1, m["foo"])) m["foo"] = 2 aa = append(aa, Equal(2, m["foo"])) - Fatal(t, All(aa...)) + Require(t, aa...) } func TestNil(t *T) { - Fatal(t, All( + Require(t, Nil(nil), Nil([]byte(nil)), Nil(map[int]int(nil)), Nil((*struct{})(nil)), Nil(interface{}(nil)), Nil(error(nil)), - )) + ) - Fatal(t, None( + Require(t, None( Nil(1), Nil([]byte("foo")), Nil(map[int]int{1: 1}), @@ -140,7 +140,7 @@ func TestNil(t *T) { } func TestSubset(t *T) { - Fatal(t, All( + Require(t, Subset([]int{1, 2, 3}, []int{}), Subset([]int{1, 2, 3}, []int{1}), Subset([]int{1, 2, 3}, []int{2}), @@ -152,9 +152,9 @@ func TestSubset(t *T) { Subset(map[int]int{1: 1, 2: 2}, map[int]int{}), Subset(map[int]int{1: 1, 2: 2}, map[int]int{1: 1}), Subset(map[int]int{1: 1, 2: 2}, map[int]int{1: 1, 2: 2}), - )) + ) - Fatal(t, None( + Require(t, None( Subset([]int{}, []int{1, 2, 3}), Subset([]int{1, 2, 3}, []int{4}), Subset([]int{1, 2, 3}, []int{1, 3, 2, 4}), @@ -167,45 +167,45 @@ func TestSubset(t *T) { m := map[int]int{1: 1, 2: 2} a := Subset(m, map[int]int{1: 1}) m[1] = 2 - Fatal(t, a) + Require(t, a) } -func TestHas(t *T) { - Fatal(t, All( - Has([]int{1}, 1), - Has([]int{1, 2}, 1), - Has([]int{2, 1}, 1), - Has(map[int]int{1: 1}, 1), - Has(map[int]int{1: 2}, 2), - Has(map[int]int{1: 2, 2: 1}, 1), - Has(map[int]int{1: 2, 2: 2}, 2), - )) +func TestHasValue(t *T) { + Require(t, + HasValue([]int{1}, 1), + HasValue([]int{1, 2}, 1), + HasValue([]int{2, 1}, 1), + HasValue(map[int]int{1: 1}, 1), + HasValue(map[int]int{1: 2}, 2), + HasValue(map[int]int{1: 2, 2: 1}, 1), + HasValue(map[int]int{1: 2, 2: 2}, 2), + ) - Fatal(t, None( - Has([]int{}, 1), - Has([]int{1}, 2), - Has([]int{2, 1}, 3), - Has(map[int]int{}, 1), - Has(map[int]int{1: 1}, 2), - Has(map[int]int{1: 2}, 1), - Has(map[int]int{1: 2, 2: 1}, 3), + Require(t, None( + HasValue([]int{}, 1), + HasValue([]int{1}, 2), + HasValue([]int{2, 1}, 3), + HasValue(map[int]int{}, 1), + HasValue(map[int]int{1: 1}, 2), + HasValue(map[int]int{1: 2}, 1), + HasValue(map[int]int{1: 2, 2: 1}, 3), )) // make sure changes don't retroactively fail the assertion m := map[int]int{1: 1} - a := Has(m, 1) + a := HasValue(m, 1) m[1] = 2 - Fatal(t, a) + Require(t, a) } func TestHasKey(t *T) { - Fatal(t, All( + Require(t, HasKey(map[int]int{1: 1}, 1), HasKey(map[int]int{1: 1, 2: 2}, 1), HasKey(map[int]int{1: 1, 2: 2}, 2), - )) + ) - Fatal(t, None( + Require(t, None( HasKey(map[int]int{}, 1), HasKey(map[int]int{2: 2}, 1), )) @@ -214,36 +214,36 @@ func TestHasKey(t *T) { m := map[int]int{1: 1} a := HasKey(m, 1) delete(m, 1) - Fatal(t, a) + Require(t, a) } -func TestLen(t *T) { - Fatal(t, All( - Len([]int(nil), 0), - Len([]int{}, 0), - Len([]int{1}, 1), - Len([]int{1, 2}, 2), - Len(map[int]int(nil), 0), - Len(map[int]int{}, 0), - Len(map[int]int{1: 1}, 1), - Len(map[int]int{1: 1, 2: 2}, 2), - )) +func TestLength(t *T) { + Require(t, + Length([]int(nil), 0), + Length([]int{}, 0), + Length([]int{1}, 1), + Length([]int{1, 2}, 2), + Length(map[int]int(nil), 0), + Length(map[int]int{}, 0), + Length(map[int]int{1: 1}, 1), + Length(map[int]int{1: 1, 2: 2}, 2), + ) - Fatal(t, None( - Len([]int(nil), 1), - Len([]int{}, 1), - Len([]int{1}, 0), - Len([]int{1}, 2), - Len([]int{1, 2}, 1), - Len([]int{1, 2}, 3), - Len(map[int]int(nil), 1), - Len(map[int]int{}, 1), + Require(t, None( + Length([]int(nil), 1), + Length([]int{}, 1), + Length([]int{1}, 0), + Length([]int{1}, 2), + Length([]int{1, 2}, 1), + Length([]int{1, 2}, 3), + Length(map[int]int(nil), 1), + Length(map[int]int{}, 1), )) // make sure changes don't retroactively fail the assertion m := map[int]int{1: 1} - a := Len(m, 1) + a := Length(m, 1) m[2] = 2 - Fatal(t, a) + Require(t, a) }