136 lines
2.7 KiB
Go
136 lines
2.7 KiB
Go
package massert
|
|
|
|
import (
|
|
"errors"
|
|
. "testing"
|
|
)
|
|
|
|
func succeed() Assertion {
|
|
return newAssertion(func() error { return nil }, "Succeed", 0)
|
|
}
|
|
|
|
func fail() Assertion {
|
|
return newAssertion(func() error { return errors.New("failure") }, "Fail", 0)
|
|
}
|
|
|
|
func TestNot(t *T) {
|
|
if err := Not(succeed()).Assert(); err == nil {
|
|
t.Fatal("Not(succeed()) should have failed")
|
|
}
|
|
|
|
if err := Not(fail()).Assert(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestAny(t *T) {
|
|
if err := Any().Assert(); err == nil {
|
|
t.Fatal("empty Any should fail")
|
|
}
|
|
|
|
if err := Any(succeed(), succeed()).Assert(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if err := Any(succeed(), fail()).Assert(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if err := Any(fail(), fail()).Assert(); err == nil {
|
|
t.Fatal("Any should have failed with all inner fail Assertions")
|
|
}
|
|
}
|
|
|
|
func TestAnyOne(t *T) {
|
|
if err := AnyOne().Assert(); err == nil {
|
|
t.Fatal("empty AnyOne should fail")
|
|
}
|
|
|
|
if err := AnyOne(succeed(), succeed()).Assert(); err == nil {
|
|
t.Fatal("AnyOne with two succeeds should fail")
|
|
}
|
|
|
|
if err := AnyOne(succeed(), fail()).Assert(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if err := AnyOne(fail(), fail()).Assert(); err == nil {
|
|
t.Fatal("AnyOne should have failed with all inner fail Assertions")
|
|
}
|
|
}
|
|
|
|
func TestAll(t *T) {
|
|
if err := All().Assert(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if err := All(succeed(), succeed()).Assert(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if err := All(succeed(), fail()).Assert(); err == nil {
|
|
t.Fatal("All should have failed with one inner fail Assertion")
|
|
}
|
|
|
|
if err := All(fail(), fail()).Assert(); err == nil {
|
|
t.Fatal("All should have failed with all inner fail Assertions")
|
|
}
|
|
}
|
|
|
|
func TestNone(t *T) {
|
|
if err := None().Assert(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if err := None(succeed(), succeed()).Assert(); err == nil {
|
|
t.Fatal("None should have failed with all inner succeed Assertions")
|
|
}
|
|
|
|
if err := None(succeed(), fail()).Assert(); err == nil {
|
|
t.Fatal("None should have failed with one inner succeed Assertion")
|
|
}
|
|
|
|
if err := None(fail(), fail()).Assert(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// TODO pointers, structs, slices, maps, nils
|
|
func TestEqual(t *T) {
|
|
if err := All(
|
|
Equal(1, 1),
|
|
Equal(1, int64(1)),
|
|
Equal(1, uint64(1)),
|
|
Equal("foo", "foo"),
|
|
).Assert(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if err := None(
|
|
Equal(1, 2),
|
|
Equal(1, int64(2)),
|
|
Equal(1, uint64(2)),
|
|
Equal("foo", "bar"),
|
|
).Assert(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestExactly(t *T) {
|
|
if err := All(
|
|
Exactly(1, 1),
|
|
Exactly("foo", "foo"),
|
|
).Assert(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if err := None(
|
|
Exactly(1, 2),
|
|
Exactly(1, int64(1)),
|
|
Exactly(1, uint64(1)),
|
|
Exactly("foo", "bar"),
|
|
).Assert(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|