You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1804 lines
46 KiB
1804 lines
46 KiB
package assert
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"math"
|
|
"os"
|
|
"reflect"
|
|
"regexp"
|
|
"runtime"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
var (
|
|
i interface{}
|
|
zeros = []interface{}{
|
|
false,
|
|
byte(0),
|
|
complex64(0),
|
|
complex128(0),
|
|
float32(0),
|
|
float64(0),
|
|
int(0),
|
|
int8(0),
|
|
int16(0),
|
|
int32(0),
|
|
int64(0),
|
|
rune(0),
|
|
uint(0),
|
|
uint8(0),
|
|
uint16(0),
|
|
uint32(0),
|
|
uint64(0),
|
|
uintptr(0),
|
|
"",
|
|
[0]interface{}{},
|
|
[]interface{}(nil),
|
|
struct{ x int }{},
|
|
(*interface{})(nil),
|
|
(func())(nil),
|
|
nil,
|
|
interface{}(nil),
|
|
map[interface{}]interface{}(nil),
|
|
(chan interface{})(nil),
|
|
(<-chan interface{})(nil),
|
|
(chan<- interface{})(nil),
|
|
}
|
|
nonZeros = []interface{}{
|
|
true,
|
|
byte(1),
|
|
complex64(1),
|
|
complex128(1),
|
|
float32(1),
|
|
float64(1),
|
|
int(1),
|
|
int8(1),
|
|
int16(1),
|
|
int32(1),
|
|
int64(1),
|
|
rune(1),
|
|
uint(1),
|
|
uint8(1),
|
|
uint16(1),
|
|
uint32(1),
|
|
uint64(1),
|
|
uintptr(1),
|
|
"s",
|
|
[1]interface{}{1},
|
|
[]interface{}{},
|
|
struct{ x int }{1},
|
|
(*interface{})(&i),
|
|
(func())(func() {}),
|
|
interface{}(1),
|
|
map[interface{}]interface{}{},
|
|
(chan interface{})(make(chan interface{})),
|
|
(<-chan interface{})(make(chan interface{})),
|
|
(chan<- interface{})(make(chan interface{})),
|
|
}
|
|
)
|
|
|
|
// AssertionTesterInterface defines an interface to be used for testing assertion methods
|
|
type AssertionTesterInterface interface {
|
|
TestMethod()
|
|
}
|
|
|
|
// AssertionTesterConformingObject is an object that conforms to the AssertionTesterInterface interface
|
|
type AssertionTesterConformingObject struct {
|
|
}
|
|
|
|
func (a *AssertionTesterConformingObject) TestMethod() {
|
|
}
|
|
|
|
// AssertionTesterNonConformingObject is an object that does not conform to the AssertionTesterInterface interface
|
|
type AssertionTesterNonConformingObject struct {
|
|
}
|
|
|
|
func TestObjectsAreEqual(t *testing.T) {
|
|
|
|
if !ObjectsAreEqual("Hello World", "Hello World") {
|
|
t.Error("objectsAreEqual should return true")
|
|
}
|
|
if !ObjectsAreEqual(123, 123) {
|
|
t.Error("objectsAreEqual should return true")
|
|
}
|
|
if !ObjectsAreEqual(123.5, 123.5) {
|
|
t.Error("objectsAreEqual should return true")
|
|
}
|
|
if !ObjectsAreEqual([]byte("Hello World"), []byte("Hello World")) {
|
|
t.Error("objectsAreEqual should return true")
|
|
}
|
|
if !ObjectsAreEqual(nil, nil) {
|
|
t.Error("objectsAreEqual should return true")
|
|
}
|
|
if ObjectsAreEqual(map[int]int{5: 10}, map[int]int{10: 20}) {
|
|
t.Error("objectsAreEqual should return false")
|
|
}
|
|
if ObjectsAreEqual('x', "x") {
|
|
t.Error("objectsAreEqual should return false")
|
|
}
|
|
if ObjectsAreEqual("x", 'x') {
|
|
t.Error("objectsAreEqual should return false")
|
|
}
|
|
if ObjectsAreEqual(0, 0.1) {
|
|
t.Error("objectsAreEqual should return false")
|
|
}
|
|
if ObjectsAreEqual(0.1, 0) {
|
|
t.Error("objectsAreEqual should return false")
|
|
}
|
|
if ObjectsAreEqual(uint32(10), int32(10)) {
|
|
t.Error("objectsAreEqual should return false")
|
|
}
|
|
if !ObjectsAreEqualValues(uint32(10), int32(10)) {
|
|
t.Error("ObjectsAreEqualValues should return true")
|
|
}
|
|
if ObjectsAreEqualValues(0, nil) {
|
|
t.Fail()
|
|
}
|
|
if ObjectsAreEqualValues(nil, 0) {
|
|
t.Fail()
|
|
}
|
|
|
|
}
|
|
|
|
func TestImplements(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
if !Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) {
|
|
t.Error("Implements method should return true: AssertionTesterConformingObject implements AssertionTesterInterface")
|
|
}
|
|
if Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) {
|
|
t.Error("Implements method should return false: AssertionTesterNonConformingObject does not implements AssertionTesterInterface")
|
|
}
|
|
if Implements(mockT, (*AssertionTesterInterface)(nil), nil) {
|
|
t.Error("Implements method should return false: nil does not implement AssertionTesterInterface")
|
|
}
|
|
|
|
}
|
|
|
|
func TestIsType(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
if !IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) {
|
|
t.Error("IsType should return true: AssertionTesterConformingObject is the same type as AssertionTesterConformingObject")
|
|
}
|
|
if IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) {
|
|
t.Error("IsType should return false: AssertionTesterConformingObject is not the same type as AssertionTesterNonConformingObject")
|
|
}
|
|
|
|
}
|
|
|
|
type myType string
|
|
|
|
func TestEqual(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
if !Equal(mockT, "Hello World", "Hello World") {
|
|
t.Error("Equal should return true")
|
|
}
|
|
if !Equal(mockT, 123, 123) {
|
|
t.Error("Equal should return true")
|
|
}
|
|
if !Equal(mockT, 123.5, 123.5) {
|
|
t.Error("Equal should return true")
|
|
}
|
|
if !Equal(mockT, []byte("Hello World"), []byte("Hello World")) {
|
|
t.Error("Equal should return true")
|
|
}
|
|
if !Equal(mockT, nil, nil) {
|
|
t.Error("Equal should return true")
|
|
}
|
|
if !Equal(mockT, int32(123), int32(123)) {
|
|
t.Error("Equal should return true")
|
|
}
|
|
if !Equal(mockT, uint64(123), uint64(123)) {
|
|
t.Error("Equal should return true")
|
|
}
|
|
if !Equal(mockT, myType("1"), myType("1")) {
|
|
t.Error("Equal should return true")
|
|
}
|
|
if !Equal(mockT, &struct{}{}, &struct{}{}) {
|
|
t.Error("Equal should return true (pointer equality is based on equality of underlying value)")
|
|
}
|
|
var m map[string]interface{}
|
|
if Equal(mockT, m["bar"], "something") {
|
|
t.Error("Equal should return false")
|
|
}
|
|
if Equal(mockT, myType("1"), myType("2")) {
|
|
t.Error("Equal should return false")
|
|
}
|
|
}
|
|
|
|
// bufferT implements TestingT. Its implementation of Errorf writes the output that would be produced by
|
|
// testing.T.Errorf to an internal bytes.Buffer.
|
|
type bufferT struct {
|
|
buf bytes.Buffer
|
|
}
|
|
|
|
func (t *bufferT) Errorf(format string, args ...interface{}) {
|
|
// implementation of decorate is copied from testing.T
|
|
decorate := func(s string) string {
|
|
_, file, line, ok := runtime.Caller(3) // decorate + log + public function.
|
|
if ok {
|
|
// Truncate file name at last file name separator.
|
|
if index := strings.LastIndex(file, "/"); index >= 0 {
|
|
file = file[index+1:]
|
|
} else if index = strings.LastIndex(file, "\\"); index >= 0 {
|
|
file = file[index+1:]
|
|
}
|
|
} else {
|
|
file = "???"
|
|
line = 1
|
|
}
|
|
buf := new(bytes.Buffer)
|
|
// Every line is indented at least one tab.
|
|
buf.WriteByte('\t')
|
|
fmt.Fprintf(buf, "%s:%d: ", file, line)
|
|
lines := strings.Split(s, "\n")
|
|
if l := len(lines); l > 1 && lines[l-1] == "" {
|
|
lines = lines[:l-1]
|
|
}
|
|
for i, line := range lines {
|
|
if i > 0 {
|
|
// Second and subsequent lines are indented an extra tab.
|
|
buf.WriteString("\n\t\t")
|
|
}
|
|
buf.WriteString(line)
|
|
}
|
|
buf.WriteByte('\n')
|
|
return buf.String()
|
|
}
|
|
t.buf.WriteString(decorate(fmt.Sprintf(format, args...)))
|
|
}
|
|
|
|
func TestStringEqual(t *testing.T) {
|
|
for i, currCase := range []struct {
|
|
equalWant string
|
|
equalGot string
|
|
msgAndArgs []interface{}
|
|
want string
|
|
}{
|
|
{equalWant: "hi, \nmy name is", equalGot: "what,\nmy name is", want: "\tassertions.go:\\d+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"hi, \\\\nmy name is\"\n\\s+actual\\s+: \"what,\\\\nmy name is\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1,2 \\+1,2 @@\n\\s+-hi, \n\\s+\\+what,\n\\s+my name is"},
|
|
} {
|
|
mockT := &bufferT{}
|
|
Equal(mockT, currCase.equalWant, currCase.equalGot, currCase.msgAndArgs...)
|
|
Regexp(t, regexp.MustCompile(currCase.want), mockT.buf.String(), "Case %d", i)
|
|
}
|
|
}
|
|
|
|
func TestEqualFormatting(t *testing.T) {
|
|
for i, currCase := range []struct {
|
|
equalWant string
|
|
equalGot string
|
|
msgAndArgs []interface{}
|
|
want string
|
|
}{
|
|
{equalWant: "want", equalGot: "got", want: "\tassertions.go:\\d+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n"},
|
|
{equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{"hello, %v!", "world"}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+hello, world!\n"},
|
|
{equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{123}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+123\n"},
|
|
{equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{struct{ a string }{"hello"}}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+{a:hello}\n"},
|
|
} {
|
|
mockT := &bufferT{}
|
|
Equal(mockT, currCase.equalWant, currCase.equalGot, currCase.msgAndArgs...)
|
|
Regexp(t, regexp.MustCompile(currCase.want), mockT.buf.String(), "Case %d", i)
|
|
}
|
|
}
|
|
|
|
func TestFormatUnequalValues(t *testing.T) {
|
|
expected, actual := formatUnequalValues("foo", "bar")
|
|
Equal(t, `"foo"`, expected, "value should not include type")
|
|
Equal(t, `"bar"`, actual, "value should not include type")
|
|
|
|
expected, actual = formatUnequalValues(123, 123)
|
|
Equal(t, `123`, expected, "value should not include type")
|
|
Equal(t, `123`, actual, "value should not include type")
|
|
|
|
expected, actual = formatUnequalValues(int64(123), int32(123))
|
|
Equal(t, `int64(123)`, expected, "value should include type")
|
|
Equal(t, `int32(123)`, actual, "value should include type")
|
|
|
|
expected, actual = formatUnequalValues(int64(123), nil)
|
|
Equal(t, `int64(123)`, expected, "value should include type")
|
|
Equal(t, `<nil>(<nil>)`, actual, "value should include type")
|
|
|
|
type testStructType struct {
|
|
Val string
|
|
}
|
|
|
|
expected, actual = formatUnequalValues(&testStructType{Val: "test"}, &testStructType{Val: "test"})
|
|
Equal(t, `&assert.testStructType{Val:"test"}`, expected, "value should not include type annotation")
|
|
Equal(t, `&assert.testStructType{Val:"test"}`, actual, "value should not include type annotation")
|
|
}
|
|
|
|
func TestNotNil(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
if !NotNil(mockT, new(AssertionTesterConformingObject)) {
|
|
t.Error("NotNil should return true: object is not nil")
|
|
}
|
|
if NotNil(mockT, nil) {
|
|
t.Error("NotNil should return false: object is nil")
|
|
}
|
|
if NotNil(mockT, (*struct{})(nil)) {
|
|
t.Error("NotNil should return false: object is (*struct{})(nil)")
|
|
}
|
|
|
|
}
|
|
|
|
func TestNil(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
if !Nil(mockT, nil) {
|
|
t.Error("Nil should return true: object is nil")
|
|
}
|
|
if !Nil(mockT, (*struct{})(nil)) {
|
|
t.Error("Nil should return true: object is (*struct{})(nil)")
|
|
}
|
|
if Nil(mockT, new(AssertionTesterConformingObject)) {
|
|
t.Error("Nil should return false: object is not nil")
|
|
}
|
|
|
|
}
|
|
|
|
func TestTrue(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
if !True(mockT, true) {
|
|
t.Error("True should return true")
|
|
}
|
|
if True(mockT, false) {
|
|
t.Error("True should return false")
|
|
}
|
|
|
|
}
|
|
|
|
func TestFalse(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
if !False(mockT, false) {
|
|
t.Error("False should return true")
|
|
}
|
|
if False(mockT, true) {
|
|
t.Error("False should return false")
|
|
}
|
|
|
|
}
|
|
|
|
func TestExactly(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
a := float32(1)
|
|
b := float64(1)
|
|
c := float32(1)
|
|
d := float32(2)
|
|
|
|
if Exactly(mockT, a, b) {
|
|
t.Error("Exactly should return false")
|
|
}
|
|
if Exactly(mockT, a, d) {
|
|
t.Error("Exactly should return false")
|
|
}
|
|
if !Exactly(mockT, a, c) {
|
|
t.Error("Exactly should return true")
|
|
}
|
|
|
|
if Exactly(mockT, nil, a) {
|
|
t.Error("Exactly should return false")
|
|
}
|
|
if Exactly(mockT, a, nil) {
|
|
t.Error("Exactly should return false")
|
|
}
|
|
|
|
}
|
|
|
|
func TestNotEqual(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
if !NotEqual(mockT, "Hello World", "Hello World!") {
|
|
t.Error("NotEqual should return true")
|
|
}
|
|
if !NotEqual(mockT, 123, 1234) {
|
|
t.Error("NotEqual should return true")
|
|
}
|
|
if !NotEqual(mockT, 123.5, 123.55) {
|
|
t.Error("NotEqual should return true")
|
|
}
|
|
if !NotEqual(mockT, []byte("Hello World"), []byte("Hello World!")) {
|
|
t.Error("NotEqual should return true")
|
|
}
|
|
if !NotEqual(mockT, nil, new(AssertionTesterConformingObject)) {
|
|
t.Error("NotEqual should return true")
|
|
}
|
|
funcA := func() int { return 23 }
|
|
funcB := func() int { return 42 }
|
|
if NotEqual(mockT, funcA, funcB) {
|
|
t.Error("NotEqual should return false")
|
|
}
|
|
|
|
if NotEqual(mockT, "Hello World", "Hello World") {
|
|
t.Error("NotEqual should return false")
|
|
}
|
|
if NotEqual(mockT, 123, 123) {
|
|
t.Error("NotEqual should return false")
|
|
}
|
|
if NotEqual(mockT, 123.5, 123.5) {
|
|
t.Error("NotEqual should return false")
|
|
}
|
|
if NotEqual(mockT, []byte("Hello World"), []byte("Hello World")) {
|
|
t.Error("NotEqual should return false")
|
|
}
|
|
if NotEqual(mockT, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) {
|
|
t.Error("NotEqual should return false")
|
|
}
|
|
if NotEqual(mockT, &struct{}{}, &struct{}{}) {
|
|
t.Error("NotEqual should return false")
|
|
}
|
|
}
|
|
|
|
type A struct {
|
|
Name, Value string
|
|
}
|
|
|
|
func TestContains(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
list := []string{"Foo", "Bar"}
|
|
complexList := []*A{
|
|
{"b", "c"},
|
|
{"d", "e"},
|
|
{"g", "h"},
|
|
{"j", "k"},
|
|
}
|
|
simpleMap := map[interface{}]interface{}{"Foo": "Bar"}
|
|
|
|
if !Contains(mockT, "Hello World", "Hello") {
|
|
t.Error("Contains should return true: \"Hello World\" contains \"Hello\"")
|
|
}
|
|
if Contains(mockT, "Hello World", "Salut") {
|
|
t.Error("Contains should return false: \"Hello World\" does not contain \"Salut\"")
|
|
}
|
|
|
|
if !Contains(mockT, list, "Bar") {
|
|
t.Error("Contains should return true: \"[\"Foo\", \"Bar\"]\" contains \"Bar\"")
|
|
}
|
|
if Contains(mockT, list, "Salut") {
|
|
t.Error("Contains should return false: \"[\"Foo\", \"Bar\"]\" does not contain \"Salut\"")
|
|
}
|
|
if !Contains(mockT, complexList, &A{"g", "h"}) {
|
|
t.Error("Contains should return true: complexList contains {\"g\", \"h\"}")
|
|
}
|
|
if Contains(mockT, complexList, &A{"g", "e"}) {
|
|
t.Error("Contains should return false: complexList contains {\"g\", \"e\"}")
|
|
}
|
|
if Contains(mockT, complexList, &A{"g", "e"}) {
|
|
t.Error("Contains should return false: complexList contains {\"g\", \"e\"}")
|
|
}
|
|
if !Contains(mockT, simpleMap, "Foo") {
|
|
t.Error("Contains should return true: \"{\"Foo\": \"Bar\"}\" contains \"Foo\"")
|
|
}
|
|
if Contains(mockT, simpleMap, "Bar") {
|
|
t.Error("Contains should return false: \"{\"Foo\": \"Bar\"}\" does not contains \"Bar\"")
|
|
}
|
|
}
|
|
|
|
func TestNotContains(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
list := []string{"Foo", "Bar"}
|
|
simpleMap := map[interface{}]interface{}{"Foo": "Bar"}
|
|
|
|
if !NotContains(mockT, "Hello World", "Hello!") {
|
|
t.Error("NotContains should return true: \"Hello World\" does not contain \"Hello!\"")
|
|
}
|
|
if NotContains(mockT, "Hello World", "Hello") {
|
|
t.Error("NotContains should return false: \"Hello World\" contains \"Hello\"")
|
|
}
|
|
|
|
if !NotContains(mockT, list, "Foo!") {
|
|
t.Error("NotContains should return true: \"[\"Foo\", \"Bar\"]\" does not contain \"Foo!\"")
|
|
}
|
|
if NotContains(mockT, list, "Foo") {
|
|
t.Error("NotContains should return false: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"")
|
|
}
|
|
if NotContains(mockT, simpleMap, "Foo") {
|
|
t.Error("Contains should return true: \"{\"Foo\": \"Bar\"}\" contains \"Foo\"")
|
|
}
|
|
if !NotContains(mockT, simpleMap, "Bar") {
|
|
t.Error("Contains should return false: \"{\"Foo\": \"Bar\"}\" does not contains \"Bar\"")
|
|
}
|
|
}
|
|
|
|
func TestSubset(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
if !Subset(mockT, []int{1, 2, 3}, nil) {
|
|
t.Error("Subset should return true: given subset is nil")
|
|
}
|
|
if !Subset(mockT, []int{1, 2, 3}, []int{}) {
|
|
t.Error("Subset should return true: any set contains the nil set")
|
|
}
|
|
if !Subset(mockT, []int{1, 2, 3}, []int{1, 2}) {
|
|
t.Error("Subset should return true: [1, 2, 3] contains [1, 2]")
|
|
}
|
|
if !Subset(mockT, []int{1, 2, 3}, []int{1, 2, 3}) {
|
|
t.Error("Subset should return true: [1, 2, 3] contains [1, 2, 3]")
|
|
}
|
|
if !Subset(mockT, []string{"hello", "world"}, []string{"hello"}) {
|
|
t.Error("Subset should return true: [\"hello\", \"world\"] contains [\"hello\"]")
|
|
}
|
|
|
|
if Subset(mockT, []string{"hello", "world"}, []string{"hello", "testify"}) {
|
|
t.Error("Subset should return false: [\"hello\", \"world\"] does not contain [\"hello\", \"testify\"]")
|
|
}
|
|
if Subset(mockT, []int{1, 2, 3}, []int{4, 5}) {
|
|
t.Error("Subset should return false: [1, 2, 3] does not contain [4, 5]")
|
|
}
|
|
if Subset(mockT, []int{1, 2, 3}, []int{1, 5}) {
|
|
t.Error("Subset should return false: [1, 2, 3] does not contain [1, 5]")
|
|
}
|
|
}
|
|
|
|
func TestNotSubset(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
if NotSubset(mockT, []int{1, 2, 3}, nil) {
|
|
t.Error("NotSubset should return false: given subset is nil")
|
|
}
|
|
if NotSubset(mockT, []int{1, 2, 3}, []int{}) {
|
|
t.Error("NotSubset should return false: any set contains the nil set")
|
|
}
|
|
if NotSubset(mockT, []int{1, 2, 3}, []int{1, 2}) {
|
|
t.Error("NotSubset should return false: [1, 2, 3] contains [1, 2]")
|
|
}
|
|
if NotSubset(mockT, []int{1, 2, 3}, []int{1, 2, 3}) {
|
|
t.Error("NotSubset should return false: [1, 2, 3] contains [1, 2, 3]")
|
|
}
|
|
if NotSubset(mockT, []string{"hello", "world"}, []string{"hello"}) {
|
|
t.Error("NotSubset should return false: [\"hello\", \"world\"] contains [\"hello\"]")
|
|
}
|
|
|
|
if !NotSubset(mockT, []string{"hello", "world"}, []string{"hello", "testify"}) {
|
|
t.Error("NotSubset should return true: [\"hello\", \"world\"] does not contain [\"hello\", \"testify\"]")
|
|
}
|
|
if !NotSubset(mockT, []int{1, 2, 3}, []int{4, 5}) {
|
|
t.Error("NotSubset should return true: [1, 2, 3] does not contain [4, 5]")
|
|
}
|
|
if !NotSubset(mockT, []int{1, 2, 3}, []int{1, 5}) {
|
|
t.Error("NotSubset should return true: [1, 2, 3] does not contain [1, 5]")
|
|
}
|
|
}
|
|
|
|
func TestNotSubsetNil(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
NotSubset(mockT, []string{"foo"}, nil)
|
|
if !mockT.Failed() {
|
|
t.Error("NotSubset on nil set should have failed the test")
|
|
}
|
|
}
|
|
|
|
func Test_includeElement(t *testing.T) {
|
|
|
|
list1 := []string{"Foo", "Bar"}
|
|
list2 := []int{1, 2}
|
|
simpleMap := map[interface{}]interface{}{"Foo": "Bar"}
|
|
|
|
ok, found := includeElement("Hello World", "World")
|
|
True(t, ok)
|
|
True(t, found)
|
|
|
|
ok, found = includeElement(list1, "Foo")
|
|
True(t, ok)
|
|
True(t, found)
|
|
|
|
ok, found = includeElement(list1, "Bar")
|
|
True(t, ok)
|
|
True(t, found)
|
|
|
|
ok, found = includeElement(list2, 1)
|
|
True(t, ok)
|
|
True(t, found)
|
|
|
|
ok, found = includeElement(list2, 2)
|
|
True(t, ok)
|
|
True(t, found)
|
|
|
|
ok, found = includeElement(list1, "Foo!")
|
|
True(t, ok)
|
|
False(t, found)
|
|
|
|
ok, found = includeElement(list2, 3)
|
|
True(t, ok)
|
|
False(t, found)
|
|
|
|
ok, found = includeElement(list2, "1")
|
|
True(t, ok)
|
|
False(t, found)
|
|
|
|
ok, found = includeElement(simpleMap, "Foo")
|
|
True(t, ok)
|
|
True(t, found)
|
|
|
|
ok, found = includeElement(simpleMap, "Bar")
|
|
True(t, ok)
|
|
False(t, found)
|
|
|
|
ok, found = includeElement(1433, "1")
|
|
False(t, ok)
|
|
False(t, found)
|
|
}
|
|
|
|
func TestElementsMatch(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
if !ElementsMatch(mockT, nil, nil) {
|
|
t.Error("ElementsMatch should return true")
|
|
}
|
|
if !ElementsMatch(mockT, []int{}, []int{}) {
|
|
t.Error("ElementsMatch should return true")
|
|
}
|
|
if !ElementsMatch(mockT, []int{1}, []int{1}) {
|
|
t.Error("ElementsMatch should return true")
|
|
}
|
|
if !ElementsMatch(mockT, []int{1, 1}, []int{1, 1}) {
|
|
t.Error("ElementsMatch should return true")
|
|
}
|
|
if !ElementsMatch(mockT, []int{1, 2}, []int{1, 2}) {
|
|
t.Error("ElementsMatch should return true")
|
|
}
|
|
if !ElementsMatch(mockT, []int{1, 2}, []int{2, 1}) {
|
|
t.Error("ElementsMatch should return true")
|
|
}
|
|
if !ElementsMatch(mockT, [2]int{1, 2}, [2]int{2, 1}) {
|
|
t.Error("ElementsMatch should return true")
|
|
}
|
|
if !ElementsMatch(mockT, []string{"hello", "world"}, []string{"world", "hello"}) {
|
|
t.Error("ElementsMatch should return true")
|
|
}
|
|
if !ElementsMatch(mockT, []string{"hello", "hello"}, []string{"hello", "hello"}) {
|
|
t.Error("ElementsMatch should return true")
|
|
}
|
|
if !ElementsMatch(mockT, []string{"hello", "hello", "world"}, []string{"hello", "world", "hello"}) {
|
|
t.Error("ElementsMatch should return true")
|
|
}
|
|
if !ElementsMatch(mockT, [3]string{"hello", "hello", "world"}, [3]string{"hello", "world", "hello"}) {
|
|
t.Error("ElementsMatch should return true")
|
|
}
|
|
if !ElementsMatch(mockT, []int{}, nil) {
|
|
t.Error("ElementsMatch should return true")
|
|
}
|
|
|
|
if ElementsMatch(mockT, []int{1}, []int{1, 1}) {
|
|
t.Error("ElementsMatch should return false")
|
|
}
|
|
if ElementsMatch(mockT, []int{1, 2}, []int{2, 2}) {
|
|
t.Error("ElementsMatch should return false")
|
|
}
|
|
if ElementsMatch(mockT, []string{"hello", "hello"}, []string{"hello"}) {
|
|
t.Error("ElementsMatch should return false")
|
|
}
|
|
}
|
|
|
|
func TestCondition(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
if !Condition(mockT, func() bool { return true }, "Truth") {
|
|
t.Error("Condition should return true")
|
|
}
|
|
|
|
if Condition(mockT, func() bool { return false }, "Lie") {
|
|
t.Error("Condition should return false")
|
|
}
|
|
|
|
}
|
|
|
|
func TestDidPanic(t *testing.T) {
|
|
|
|
if funcDidPanic, _ := didPanic(func() {
|
|
panic("Panic!")
|
|
}); !funcDidPanic {
|
|
t.Error("didPanic should return true")
|
|
}
|
|
|
|
if funcDidPanic, _ := didPanic(func() {
|
|
}); funcDidPanic {
|
|
t.Error("didPanic should return false")
|
|
}
|
|
|
|
}
|
|
|
|
func TestPanics(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
if !Panics(mockT, func() {
|
|
panic("Panic!")
|
|
}) {
|
|
t.Error("Panics should return true")
|
|
}
|
|
|
|
if Panics(mockT, func() {
|
|
}) {
|
|
t.Error("Panics should return false")
|
|
}
|
|
|
|
}
|
|
|
|
func TestPanicsWithValue(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
if !PanicsWithValue(mockT, "Panic!", func() {
|
|
panic("Panic!")
|
|
}) {
|
|
t.Error("PanicsWithValue should return true")
|
|
}
|
|
|
|
if PanicsWithValue(mockT, "Panic!", func() {
|
|
}) {
|
|
t.Error("PanicsWithValue should return false")
|
|
}
|
|
|
|
if PanicsWithValue(mockT, "at the disco", func() {
|
|
panic("Panic!")
|
|
}) {
|
|
t.Error("PanicsWithValue should return false")
|
|
}
|
|
}
|
|
|
|
func TestNotPanics(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
if !NotPanics(mockT, func() {
|
|
}) {
|
|
t.Error("NotPanics should return true")
|
|
}
|
|
|
|
if NotPanics(mockT, func() {
|
|
panic("Panic!")
|
|
}) {
|
|
t.Error("NotPanics should return false")
|
|
}
|
|
|
|
}
|
|
|
|
func TestNoError(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
// start with a nil error
|
|
var err error
|
|
|
|
True(t, NoError(mockT, err), "NoError should return True for nil arg")
|
|
|
|
// now set an error
|
|
err = errors.New("some error")
|
|
|
|
False(t, NoError(mockT, err), "NoError with error should return False")
|
|
|
|
// returning an empty error interface
|
|
err = func() error {
|
|
var err *customError
|
|
if err != nil {
|
|
t.Fatal("err should be nil here")
|
|
}
|
|
return err
|
|
}()
|
|
|
|
if err == nil { // err is not nil here!
|
|
t.Errorf("Error should be nil due to empty interface: %s", err)
|
|
}
|
|
|
|
False(t, NoError(mockT, err), "NoError should fail with empty error interface")
|
|
}
|
|
|
|
type customError struct{}
|
|
|
|
func (*customError) Error() string { return "fail" }
|
|
|
|
func TestError(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
|
|
// start with a nil error
|
|
var err error
|
|
|
|
False(t, Error(mockT, err), "Error should return False for nil arg")
|
|
|
|
// now set an error
|
|
err = errors.New("some error")
|
|
|
|
True(t, Error(mockT, err), "Error with error should return True")
|
|
|
|
// go vet check
|
|
True(t, Errorf(mockT, err, "example with %s", "formatted message"), "Errorf with error should rturn True")
|
|
|
|
// returning an empty error interface
|
|
err = func() error {
|
|
var err *customError
|
|
if err != nil {
|
|
t.Fatal("err should be nil here")
|
|
}
|
|
return err
|
|
}()
|
|
|
|
if err == nil { // err is not nil here!
|
|
t.Errorf("Error should be nil due to empty interface: %s", err)
|
|
}
|
|
|
|
True(t, Error(mockT, err), "Error should pass with empty error interface")
|
|
}
|
|
|
|
func TestEqualError(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
// start with a nil error
|
|
var err error
|
|
False(t, EqualError(mockT, err, ""),
|
|
"EqualError should return false for nil arg")
|
|
|
|
// now set an error
|
|
err = errors.New("some error")
|
|
False(t, EqualError(mockT, err, "Not some error"),
|
|
"EqualError should return false for different error string")
|
|
True(t, EqualError(mockT, err, "some error"),
|
|
"EqualError should return true")
|
|
}
|
|
|
|
func Test_isEmpty(t *testing.T) {
|
|
|
|
chWithValue := make(chan struct{}, 1)
|
|
chWithValue <- struct{}{}
|
|
|
|
True(t, isEmpty(""))
|
|
True(t, isEmpty(nil))
|
|
True(t, isEmpty([]string{}))
|
|
True(t, isEmpty(0))
|
|
True(t, isEmpty(int32(0)))
|
|
True(t, isEmpty(int64(0)))
|
|
True(t, isEmpty(false))
|
|
True(t, isEmpty(map[string]string{}))
|
|
True(t, isEmpty(new(time.Time)))
|
|
True(t, isEmpty(time.Time{}))
|
|
True(t, isEmpty(make(chan struct{})))
|
|
False(t, isEmpty("something"))
|
|
False(t, isEmpty(errors.New("something")))
|
|
False(t, isEmpty([]string{"something"}))
|
|
False(t, isEmpty(1))
|
|
False(t, isEmpty(true))
|
|
False(t, isEmpty(map[string]string{"Hello": "World"}))
|
|
False(t, isEmpty(chWithValue))
|
|
|
|
}
|
|
|
|
func TestEmpty(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
chWithValue := make(chan struct{}, 1)
|
|
chWithValue <- struct{}{}
|
|
var tiP *time.Time
|
|
var tiNP time.Time
|
|
var s *string
|
|
var f *os.File
|
|
sP := &s
|
|
x := 1
|
|
xP := &x
|
|
|
|
type TString string
|
|
type TStruct struct {
|
|
x int
|
|
s []int
|
|
}
|
|
|
|
True(t, Empty(mockT, ""), "Empty string is empty")
|
|
True(t, Empty(mockT, nil), "Nil is empty")
|
|
True(t, Empty(mockT, []string{}), "Empty string array is empty")
|
|
True(t, Empty(mockT, 0), "Zero int value is empty")
|
|
True(t, Empty(mockT, false), "False value is empty")
|
|
True(t, Empty(mockT, make(chan struct{})), "Channel without values is empty")
|
|
True(t, Empty(mockT, s), "Nil string pointer is empty")
|
|
True(t, Empty(mockT, f), "Nil os.File pointer is empty")
|
|
True(t, Empty(mockT, tiP), "Nil time.Time pointer is empty")
|
|
True(t, Empty(mockT, tiNP), "time.Time is empty")
|
|
True(t, Empty(mockT, TStruct{}), "struct with zero values is empty")
|
|
True(t, Empty(mockT, TString("")), "empty aliased string is empty")
|
|
True(t, Empty(mockT, sP), "ptr to nil value is empty")
|
|
|
|
False(t, Empty(mockT, "something"), "Non Empty string is not empty")
|
|
False(t, Empty(mockT, errors.New("something")), "Non nil object is not empty")
|
|
False(t, Empty(mockT, []string{"something"}), "Non empty string array is not empty")
|
|
False(t, Empty(mockT, 1), "Non-zero int value is not empty")
|
|
False(t, Empty(mockT, true), "True value is not empty")
|
|
False(t, Empty(mockT, chWithValue), "Channel with values is not empty")
|
|
False(t, Empty(mockT, TStruct{x: 1}), "struct with initialized values is empty")
|
|
False(t, Empty(mockT, TString("abc")), "non-empty aliased string is empty")
|
|
False(t, Empty(mockT, xP), "ptr to non-nil value is not empty")
|
|
}
|
|
|
|
func TestNotEmpty(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
chWithValue := make(chan struct{}, 1)
|
|
chWithValue <- struct{}{}
|
|
|
|
False(t, NotEmpty(mockT, ""), "Empty string is empty")
|
|
False(t, NotEmpty(mockT, nil), "Nil is empty")
|
|
False(t, NotEmpty(mockT, []string{}), "Empty string array is empty")
|
|
False(t, NotEmpty(mockT, 0), "Zero int value is empty")
|
|
False(t, NotEmpty(mockT, false), "False value is empty")
|
|
False(t, NotEmpty(mockT, make(chan struct{})), "Channel without values is empty")
|
|
|
|
True(t, NotEmpty(mockT, "something"), "Non Empty string is not empty")
|
|
True(t, NotEmpty(mockT, errors.New("something")), "Non nil object is not empty")
|
|
True(t, NotEmpty(mockT, []string{"something"}), "Non empty string array is not empty")
|
|
True(t, NotEmpty(mockT, 1), "Non-zero int value is not empty")
|
|
True(t, NotEmpty(mockT, true), "True value is not empty")
|
|
True(t, NotEmpty(mockT, chWithValue), "Channel with values is not empty")
|
|
}
|
|
|
|
func Test_getLen(t *testing.T) {
|
|
falseCases := []interface{}{
|
|
nil,
|
|
0,
|
|
true,
|
|
false,
|
|
'A',
|
|
struct{}{},
|
|
}
|
|
for _, v := range falseCases {
|
|
ok, l := getLen(v)
|
|
False(t, ok, "Expected getLen fail to get length of %#v", v)
|
|
Equal(t, 0, l, "getLen should return 0 for %#v", v)
|
|
}
|
|
|
|
ch := make(chan int, 5)
|
|
ch <- 1
|
|
ch <- 2
|
|
ch <- 3
|
|
trueCases := []struct {
|
|
v interface{}
|
|
l int
|
|
}{
|
|
{[]int{1, 2, 3}, 3},
|
|
{[...]int{1, 2, 3}, 3},
|
|
{"ABC", 3},
|
|
{map[int]int{1: 2, 2: 4, 3: 6}, 3},
|
|
{ch, 3},
|
|
|
|
{[]int{}, 0},
|
|
{map[int]int{}, 0},
|
|
{make(chan int), 0},
|
|
|
|
{[]int(nil), 0},
|
|
{map[int]int(nil), 0},
|
|
{(chan int)(nil), 0},
|
|
}
|
|
|
|
for _, c := range trueCases {
|
|
ok, l := getLen(c.v)
|
|
True(t, ok, "Expected getLen success to get length of %#v", c.v)
|
|
Equal(t, c.l, l)
|
|
}
|
|
}
|
|
|
|
func TestLen(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
False(t, Len(mockT, nil, 0), "nil does not have length")
|
|
False(t, Len(mockT, 0, 0), "int does not have length")
|
|
False(t, Len(mockT, true, 0), "true does not have length")
|
|
False(t, Len(mockT, false, 0), "false does not have length")
|
|
False(t, Len(mockT, 'A', 0), "Rune does not have length")
|
|
False(t, Len(mockT, struct{}{}, 0), "Struct does not have length")
|
|
|
|
ch := make(chan int, 5)
|
|
ch <- 1
|
|
ch <- 2
|
|
ch <- 3
|
|
|
|
cases := []struct {
|
|
v interface{}
|
|
l int
|
|
}{
|
|
{[]int{1, 2, 3}, 3},
|
|
{[...]int{1, 2, 3}, 3},
|
|
{"ABC", 3},
|
|
{map[int]int{1: 2, 2: 4, 3: 6}, 3},
|
|
{ch, 3},
|
|
|
|
{[]int{}, 0},
|
|
{map[int]int{}, 0},
|
|
{make(chan int), 0},
|
|
|
|
{[]int(nil), 0},
|
|
{map[int]int(nil), 0},
|
|
{(chan int)(nil), 0},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
True(t, Len(mockT, c.v, c.l), "%#v have %d items", c.v, c.l)
|
|
}
|
|
|
|
cases = []struct {
|
|
v interface{}
|
|
l int
|
|
}{
|
|
{[]int{1, 2, 3}, 4},
|
|
{[...]int{1, 2, 3}, 2},
|
|
{"ABC", 2},
|
|
{map[int]int{1: 2, 2: 4, 3: 6}, 4},
|
|
{ch, 2},
|
|
|
|
{[]int{}, 1},
|
|
{map[int]int{}, 1},
|
|
{make(chan int), 1},
|
|
|
|
{[]int(nil), 1},
|
|
{map[int]int(nil), 1},
|
|
{(chan int)(nil), 1},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
False(t, Len(mockT, c.v, c.l), "%#v have %d items", c.v, c.l)
|
|
}
|
|
}
|
|
|
|
func TestWithinDuration(t *testing.T) {
|
|
|
|
mockT := new(testing.T)
|
|
a := time.Now()
|
|
b := a.Add(10 * time.Second)
|
|
|
|
True(t, WithinDuration(mockT, a, b, 10*time.Second), "A 10s difference is within a 10s time difference")
|
|
True(t, WithinDuration(mockT, b, a, 10*time.Second), "A 10s difference is within a 10s time difference")
|
|
|
|
False(t, WithinDuration(mockT, a, b, 9*time.Second), "A 10s difference is not within a 9s time difference")
|
|
False(t, WithinDuration(mockT, b, a, 9*time.Second), "A 10s difference is not within a 9s time difference")
|
|
|
|
False(t, WithinDuration(mockT, a, b, -9*time.Second), "A 10s difference is not within a 9s time difference")
|
|
False(t, WithinDuration(mockT, b, a, -9*time.Second), "A 10s difference is not within a 9s time difference")
|
|
|
|
False(t, WithinDuration(mockT, a, b, -11*time.Second), "A 10s difference is not within a 9s time difference")
|
|
False(t, WithinDuration(mockT, b, a, -11*time.Second), "A 10s difference is not within a 9s time difference")
|
|
}
|
|
|
|
func TestInDelta(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
True(t, InDelta(mockT, 1.001, 1, 0.01), "|1.001 - 1| <= 0.01")
|
|
True(t, InDelta(mockT, 1, 1.001, 0.01), "|1 - 1.001| <= 0.01")
|
|
True(t, InDelta(mockT, 1, 2, 1), "|1 - 2| <= 1")
|
|
False(t, InDelta(mockT, 1, 2, 0.5), "Expected |1 - 2| <= 0.5 to fail")
|
|
False(t, InDelta(mockT, 2, 1, 0.5), "Expected |2 - 1| <= 0.5 to fail")
|
|
False(t, InDelta(mockT, "", nil, 1), "Expected non numerals to fail")
|
|
False(t, InDelta(mockT, 42, math.NaN(), 0.01), "Expected NaN for actual to fail")
|
|
False(t, InDelta(mockT, math.NaN(), 42, 0.01), "Expected NaN for expected to fail")
|
|
|
|
cases := []struct {
|
|
a, b interface{}
|
|
delta float64
|
|
}{
|
|
{uint8(2), uint8(1), 1},
|
|
{uint16(2), uint16(1), 1},
|
|
{uint32(2), uint32(1), 1},
|
|
{uint64(2), uint64(1), 1},
|
|
|
|
{int(2), int(1), 1},
|
|
{int8(2), int8(1), 1},
|
|
{int16(2), int16(1), 1},
|
|
{int32(2), int32(1), 1},
|
|
{int64(2), int64(1), 1},
|
|
|
|
{float32(2), float32(1), 1},
|
|
{float64(2), float64(1), 1},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
True(t, InDelta(mockT, tc.a, tc.b, tc.delta), "Expected |%V - %V| <= %v", tc.a, tc.b, tc.delta)
|
|
}
|
|
}
|
|
|
|
func TestInDeltaSlice(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
True(t, InDeltaSlice(mockT,
|
|
[]float64{1.001, 0.999},
|
|
[]float64{1, 1},
|
|
0.1), "{1.001, 0.009} is element-wise close to {1, 1} in delta=0.1")
|
|
|
|
True(t, InDeltaSlice(mockT,
|
|
[]float64{1, 2},
|
|
[]float64{0, 3},
|
|
1), "{1, 2} is element-wise close to {0, 3} in delta=1")
|
|
|
|
False(t, InDeltaSlice(mockT,
|
|
[]float64{1, 2},
|
|
[]float64{0, 3},
|
|
0.1), "{1, 2} is not element-wise close to {0, 3} in delta=0.1")
|
|
|
|
False(t, InDeltaSlice(mockT, "", nil, 1), "Expected non numeral slices to fail")
|
|
}
|
|
|
|
func TestInDeltaMapValues(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
for _, tc := range []struct {
|
|
title string
|
|
expect interface{}
|
|
actual interface{}
|
|
f func(TestingT, bool, ...interface{}) bool
|
|
delta float64
|
|
}{
|
|
{
|
|
title: "Within delta",
|
|
expect: map[string]float64{
|
|
"foo": 1.0,
|
|
"bar": 2.0,
|
|
},
|
|
actual: map[string]float64{
|
|
"foo": 1.01,
|
|
"bar": 1.99,
|
|
},
|
|
delta: 0.1,
|
|
f: True,
|
|
},
|
|
{
|
|
title: "Within delta",
|
|
expect: map[int]float64{
|
|
1: 1.0,
|
|
2: 2.0,
|
|
},
|
|
actual: map[int]float64{
|
|
1: 1.0,
|
|
2: 1.99,
|
|
},
|
|
delta: 0.1,
|
|
f: True,
|
|
},
|
|
{
|
|
title: "Different number of keys",
|
|
expect: map[int]float64{
|
|
1: 1.0,
|
|
2: 2.0,
|
|
},
|
|
actual: map[int]float64{
|
|
1: 1.0,
|
|
},
|
|
delta: 0.1,
|
|
f: False,
|
|
},
|
|
{
|
|
title: "Within delta with zero value",
|
|
expect: map[string]float64{
|
|
"zero": 0.0,
|
|
},
|
|
actual: map[string]float64{
|
|
"zero": 0.0,
|
|
},
|
|
delta: 0.1,
|
|
f: True,
|
|
},
|
|
{
|
|
title: "With missing key with zero value",
|
|
expect: map[string]float64{
|
|
"zero": 0.0,
|
|
"foo": 0.0,
|
|
},
|
|
actual: map[string]float64{
|
|
"zero": 0.0,
|
|
"bar": 0.0,
|
|
},
|
|
f: False,
|
|
},
|
|
} {
|
|
tc.f(t, InDeltaMapValues(mockT, tc.expect, tc.actual, tc.delta), tc.title+"\n"+diff(tc.expect, tc.actual))
|
|
}
|
|
}
|
|
|
|
func TestInEpsilon(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
cases := []struct {
|
|
a, b interface{}
|
|
epsilon float64
|
|
}{
|
|
{uint8(2), uint16(2), .001},
|
|
{2.1, 2.2, 0.1},
|
|
{2.2, 2.1, 0.1},
|
|
{-2.1, -2.2, 0.1},
|
|
{-2.2, -2.1, 0.1},
|
|
{uint64(100), uint8(101), 0.01},
|
|
{0.1, -0.1, 2},
|
|
{0.1, 0, 2},
|
|
{time.Second, time.Second + time.Millisecond, 0.002},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
True(t, InEpsilon(t, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon), "test: %q", tc)
|
|
}
|
|
|
|
cases = []struct {
|
|
a, b interface{}
|
|
epsilon float64
|
|
}{
|
|
{uint8(2), int16(-2), .001},
|
|
{uint64(100), uint8(102), 0.01},
|
|
{2.1, 2.2, 0.001},
|
|
{2.2, 2.1, 0.001},
|
|
{2.1, -2.2, 1},
|
|
{2.1, "bla-bla", 0},
|
|
{0.1, -0.1, 1.99},
|
|
{0, 0.1, 2}, // expected must be different to zero
|
|
{time.Second, time.Second + 10*time.Millisecond, 0.002},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
False(t, InEpsilon(mockT, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
|
|
}
|
|
|
|
}
|
|
|
|
func TestInEpsilonSlice(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
True(t, InEpsilonSlice(mockT,
|
|
[]float64{2.2, 2.0},
|
|
[]float64{2.1, 2.1},
|
|
0.06), "{2.2, 2.0} is element-wise close to {2.1, 2.1} in espilon=0.06")
|
|
|
|
False(t, InEpsilonSlice(mockT,
|
|
[]float64{2.2, 2.0},
|
|
[]float64{2.1, 2.1},
|
|
0.04), "{2.2, 2.0} is not element-wise close to {2.1, 2.1} in espilon=0.04")
|
|
|
|
False(t, InEpsilonSlice(mockT, "", nil, 1), "Expected non numeral slices to fail")
|
|
}
|
|
|
|
func TestRegexp(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
cases := []struct {
|
|
rx, str string
|
|
}{
|
|
{"^start", "start of the line"},
|
|
{"end$", "in the end"},
|
|
{"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
True(t, Regexp(mockT, tc.rx, tc.str))
|
|
True(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str))
|
|
False(t, NotRegexp(mockT, tc.rx, tc.str))
|
|
False(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str))
|
|
}
|
|
|
|
cases = []struct {
|
|
rx, str string
|
|
}{
|
|
{"^asdfastart", "Not the start of the line"},
|
|
{"end$", "in the end."},
|
|
{"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12a.34"},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
False(t, Regexp(mockT, tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str)
|
|
False(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str))
|
|
True(t, NotRegexp(mockT, tc.rx, tc.str))
|
|
True(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str))
|
|
}
|
|
}
|
|
|
|
func testAutogeneratedFunction() {
|
|
defer func() {
|
|
if err := recover(); err == nil {
|
|
panic("did not panic")
|
|
}
|
|
CallerInfo()
|
|
}()
|
|
t := struct {
|
|
io.Closer
|
|
}{}
|
|
var c io.Closer
|
|
c = t
|
|
c.Close()
|
|
}
|
|
|
|
func TestCallerInfoWithAutogeneratedFunctions(t *testing.T) {
|
|
NotPanics(t, func() {
|
|
testAutogeneratedFunction()
|
|
})
|
|
}
|
|
|
|
func TestZero(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
for _, test := range zeros {
|
|
True(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
|
|
}
|
|
|
|
for _, test := range nonZeros {
|
|
False(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
|
|
}
|
|
}
|
|
|
|
func TestNotZero(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
|
|
for _, test := range zeros {
|
|
False(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
|
|
}
|
|
|
|
for _, test := range nonZeros {
|
|
True(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
|
|
}
|
|
}
|
|
|
|
func TestFileExists(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
True(t, FileExists(mockT, "assertions.go"))
|
|
|
|
mockT = new(testing.T)
|
|
False(t, FileExists(mockT, "random_file"))
|
|
|
|
mockT = new(testing.T)
|
|
False(t, FileExists(mockT, "../_codegen"))
|
|
}
|
|
|
|
func TestDirExists(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
False(t, DirExists(mockT, "assertions.go"))
|
|
|
|
mockT = new(testing.T)
|
|
False(t, DirExists(mockT, "random_dir"))
|
|
|
|
mockT = new(testing.T)
|
|
True(t, DirExists(mockT, "../_codegen"))
|
|
}
|
|
|
|
func TestJSONEq_EqualSONString(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
True(t, JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`))
|
|
}
|
|
|
|
func TestJSONEq_EquivalentButNotEqual(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
True(t, JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`))
|
|
}
|
|
|
|
func TestJSONEq_HashOfArraysAndHashes(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
True(t, JSONEq(mockT, "{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
|
|
"{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}"))
|
|
}
|
|
|
|
func TestJSONEq_Array(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
True(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`))
|
|
}
|
|
|
|
func TestJSONEq_HashAndArrayNotEquivalent(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
False(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`))
|
|
}
|
|
|
|
func TestJSONEq_HashesNotEquivalent(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
False(t, JSONEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`))
|
|
}
|
|
|
|
func TestJSONEq_ActualIsNotJSON(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
False(t, JSONEq(mockT, `{"foo": "bar"}`, "Not JSON"))
|
|
}
|
|
|
|
func TestJSONEq_ExpectedIsNotJSON(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
False(t, JSONEq(mockT, "Not JSON", `{"foo": "bar", "hello": "world"}`))
|
|
}
|
|
|
|
func TestJSONEq_ExpectedAndActualNotJSON(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
False(t, JSONEq(mockT, "Not JSON", "Not JSON"))
|
|
}
|
|
|
|
func TestJSONEq_ArraysOfDifferentOrder(t *testing.T) {
|
|
mockT := new(testing.T)
|
|
False(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`))
|
|
}
|
|
|
|
func TestDiff(t *testing.T) {
|
|
expected := `
|
|
|
|
Diff:
|
|
--- Expected
|
|
+++ Actual
|
|
@@ -1,3 +1,3 @@
|
|
(struct { foo string }) {
|
|
- foo: (string) (len=5) "hello"
|
|
+ foo: (string) (len=3) "bar"
|
|
}
|
|
`
|
|
actual := diff(
|
|
struct{ foo string }{"hello"},
|
|
struct{ foo string }{"bar"},
|
|
)
|
|
Equal(t, expected, actual)
|
|
|
|
expected = `
|
|
|
|
Diff:
|
|
--- Expected
|
|
+++ Actual
|
|
@@ -2,5 +2,5 @@
|
|
(int) 1,
|
|
- (int) 2,
|
|
(int) 3,
|
|
- (int) 4
|
|
+ (int) 5,
|
|
+ (int) 7
|
|
}
|
|
`
|
|
actual = diff(
|
|
[]int{1, 2, 3, 4},
|
|
[]int{1, 3, 5, 7},
|
|
)
|
|
Equal(t, expected, actual)
|
|
|
|
expected = `
|
|
|
|
Diff:
|
|
--- Expected
|
|
+++ Actual
|
|
@@ -2,4 +2,4 @@
|
|
(int) 1,
|
|
- (int) 2,
|
|
- (int) 3
|
|
+ (int) 3,
|
|
+ (int) 5
|
|
}
|
|
`
|
|
actual = diff(
|
|
[]int{1, 2, 3, 4}[0:3],
|
|
[]int{1, 3, 5, 7}[0:3],
|
|
)
|
|
Equal(t, expected, actual)
|
|
|
|
expected = `
|
|
|
|
Diff:
|
|
--- Expected
|
|
+++ Actual
|
|
@@ -1,6 +1,6 @@
|
|
(map[string]int) (len=4) {
|
|
- (string) (len=4) "four": (int) 4,
|
|
+ (string) (len=4) "five": (int) 5,
|
|
(string) (len=3) "one": (int) 1,
|
|
- (string) (len=5) "three": (int) 3,
|
|
- (string) (len=3) "two": (int) 2
|
|
+ (string) (len=5) "seven": (int) 7,
|
|
+ (string) (len=5) "three": (int) 3
|
|
}
|
|
`
|
|
|
|
actual = diff(
|
|
map[string]int{"one": 1, "two": 2, "three": 3, "four": 4},
|
|
map[string]int{"one": 1, "three": 3, "five": 5, "seven": 7},
|
|
)
|
|
Equal(t, expected, actual)
|
|
}
|
|
|
|
func TestDiffEmptyCases(t *testing.T) {
|
|
Equal(t, "", diff(nil, nil))
|
|
Equal(t, "", diff(struct{ foo string }{}, nil))
|
|
Equal(t, "", diff(nil, struct{ foo string }{}))
|
|
Equal(t, "", diff(1, 2))
|
|
Equal(t, "", diff(1, 2))
|
|
Equal(t, "", diff([]int{1}, []bool{true}))
|
|
}
|
|
|
|
// Ensure there are no data races
|
|
func TestDiffRace(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
expected := map[string]string{
|
|
"a": "A",
|
|
"b": "B",
|
|
"c": "C",
|
|
}
|
|
|
|
actual := map[string]string{
|
|
"d": "D",
|
|
"e": "E",
|
|
"f": "F",
|
|
}
|
|
|
|
// run diffs in parallel simulating tests with t.Parallel()
|
|
numRoutines := 10
|
|
rChans := make([]chan string, numRoutines)
|
|
for idx := range rChans {
|
|
rChans[idx] = make(chan string)
|
|
go func(ch chan string) {
|
|
defer close(ch)
|
|
ch <- diff(expected, actual)
|
|
}(rChans[idx])
|
|
}
|
|
|
|
for _, ch := range rChans {
|
|
for msg := range ch {
|
|
NotZero(t, msg) // dummy assert
|
|
}
|
|
}
|
|
}
|
|
|
|
type mockTestingT struct {
|
|
}
|
|
|
|
func (m *mockTestingT) Errorf(format string, args ...interface{}) {}
|
|
|
|
func TestFailNowWithPlainTestingT(t *testing.T) {
|
|
mockT := &mockTestingT{}
|
|
|
|
Panics(t, func() {
|
|
FailNow(mockT, "failed")
|
|
}, "should panic since mockT is missing FailNow()")
|
|
}
|
|
|
|
type mockFailNowTestingT struct {
|
|
}
|
|
|
|
func (m *mockFailNowTestingT) Errorf(format string, args ...interface{}) {}
|
|
|
|
func (m *mockFailNowTestingT) FailNow() {}
|
|
|
|
func TestFailNowWithFullTestingT(t *testing.T) {
|
|
mockT := &mockFailNowTestingT{}
|
|
|
|
NotPanics(t, func() {
|
|
FailNow(mockT, "failed")
|
|
}, "should call mockT.FailNow() rather than panicking")
|
|
}
|
|
|
|
func TestBytesEqual(t *testing.T) {
|
|
var cases = []struct {
|
|
a, b []byte
|
|
}{
|
|
{make([]byte, 2), make([]byte, 2)},
|
|
{make([]byte, 2), make([]byte, 2, 3)},
|
|
{nil, make([]byte, 0)},
|
|
}
|
|
for i, c := range cases {
|
|
Equal(t, reflect.DeepEqual(c.a, c.b), ObjectsAreEqual(c.a, c.b), "case %d failed", i+1)
|
|
}
|
|
}
|
|
|
|
func BenchmarkBytesEqual(b *testing.B) {
|
|
const size = 1024 * 8
|
|
s := make([]byte, size)
|
|
for i := range s {
|
|
s[i] = byte(i % 255)
|
|
}
|
|
s2 := make([]byte, size)
|
|
copy(s2, s)
|
|
|
|
mockT := &mockFailNowTestingT{}
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
Equal(mockT, s, s2)
|
|
}
|
|
}
|
|
|
|
func TestEqualArgsValidation(t *testing.T) {
|
|
err := validateEqualArgs(time.Now, time.Now)
|
|
EqualError(t, err, "cannot take func type as argument")
|
|
}
|
|
|
|
func ExampleComparisonAssertionFunc() {
|
|
t := &testing.T{} // provided by test
|
|
|
|
adder := func(x, y int) int {
|
|
return x + y
|
|
}
|
|
|
|
type args struct {
|
|
x int
|
|
y int
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
expect int
|
|
assertion ComparisonAssertionFunc
|
|
}{
|
|
{"2+2=4", args{2, 2}, 4, Equal},
|
|
{"2+2!=5", args{2, 2}, 5, NotEqual},
|
|
{"2+3==5", args{2, 3}, 5, Exactly},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tt.assertion(t, tt.expect, adder(tt.args.x, tt.args.y))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestComparisonAssertionFunc(t *testing.T) {
|
|
type iface interface {
|
|
Name() string
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
expect interface{}
|
|
got interface{}
|
|
assertion ComparisonAssertionFunc
|
|
}{
|
|
{"implements", (*iface)(nil), t, Implements},
|
|
{"isType", (*testing.T)(nil), t, IsType},
|
|
{"equal", t, t, Equal},
|
|
{"equalValues", t, t, EqualValues},
|
|
{"exactly", t, t, Exactly},
|
|
{"notEqual", t, nil, NotEqual},
|
|
{"notContains", []int{1, 2, 3}, 4, NotContains},
|
|
{"subset", []int{1, 2, 3, 4}, []int{2, 3}, Subset},
|
|
{"notSubset", []int{1, 2, 3, 4}, []int{0, 3}, NotSubset},
|
|
{"elementsMatch", []byte("abc"), []byte("bac"), ElementsMatch},
|
|
{"regexp", "^t.*y$", "testify", Regexp},
|
|
{"notRegexp", "^t.*y$", "Testify", NotRegexp},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tt.assertion(t, tt.expect, tt.got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func ExampleValueAssertionFunc() {
|
|
t := &testing.T{} // provided by test
|
|
|
|
dumbParse := func(input string) interface{} {
|
|
var x interface{}
|
|
json.Unmarshal([]byte(input), &x)
|
|
return x
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
arg string
|
|
assertion ValueAssertionFunc
|
|
}{
|
|
{"true is not nil", "true", NotNil},
|
|
{"empty string is nil", "", Nil},
|
|
{"zero is not nil", "0", NotNil},
|
|
{"zero is zero", "0", Zero},
|
|
{"false is zero", "false", Zero},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tt.assertion(t, dumbParse(tt.arg))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValueAssertionFunc(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
value interface{}
|
|
assertion ValueAssertionFunc
|
|
}{
|
|
{"notNil", true, NotNil},
|
|
{"nil", nil, Nil},
|
|
{"empty", []int{}, Empty},
|
|
{"notEmpty", []int{1}, NotEmpty},
|
|
{"zero", false, Zero},
|
|
{"notZero", 42, NotZero},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tt.assertion(t, tt.value)
|
|
})
|
|
}
|
|
}
|
|
|
|
func ExampleBoolAssertionFunc() {
|
|
t := &testing.T{} // provided by test
|
|
|
|
isOkay := func(x int) bool {
|
|
return x >= 42
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
arg int
|
|
assertion BoolAssertionFunc
|
|
}{
|
|
{"-1 is bad", -1, False},
|
|
{"42 is good", 42, True},
|
|
{"41 is bad", 41, False},
|
|
{"45 is cool", 45, True},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tt.assertion(t, isOkay(tt.arg))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBoolAssertionFunc(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
value bool
|
|
assertion BoolAssertionFunc
|
|
}{
|
|
{"true", true, True},
|
|
{"false", false, False},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tt.assertion(t, tt.value)
|
|
})
|
|
}
|
|
}
|
|
|
|
func ExampleErrorAssertionFunc() {
|
|
t := &testing.T{} // provided by test
|
|
|
|
dumbParseNum := func(input string, v interface{}) error {
|
|
return json.Unmarshal([]byte(input), v)
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
arg string
|
|
assertion ErrorAssertionFunc
|
|
}{
|
|
{"1.2 is number", "1.2", NoError},
|
|
{"1.2.3 not number", "1.2.3", Error},
|
|
{"true is not number", "true", Error},
|
|
{"3 is number", "3", NoError},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
var x float64
|
|
tt.assertion(t, dumbParseNum(tt.arg, &x))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestErrorAssertionFunc(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
err error
|
|
assertion ErrorAssertionFunc
|
|
}{
|
|
{"noError", nil, NoError},
|
|
{"error", errors.New("whoops"), Error},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tt.assertion(t, tt.err)
|
|
})
|
|
}
|
|
}
|