From c45c728df0ae2283938f5e7a603e65726f0f39ed Mon Sep 17 00:00:00 2001 From: Brady Catherman Date: Mon, 11 Aug 2014 23:37:02 -0600 Subject: [PATCH] Fix some bug to make the module work agian --- .travis.yml | 2 +- equal.go | 2 + equal_test.go | 200 +++++++++++++++++++++++++------------------------- test.go | 70 +++++++++++++++--- testlib.go | 25 ++++++- 5 files changed, 183 insertions(+), 116 deletions(-) diff --git a/.travis.yml b/.travis.yml index 37a7bd4..6030d2d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -14,7 +14,7 @@ before_script: - go get github.com/mattn/goveralls script: - - go fmt . + - test -z "$(gofmt -l . | tee /dev/stderr)" - go vet . - go test -v -race . - go test -covermode=count -coverprofile=/tmp/coverage.out diff --git a/equal.go b/equal.go index 1c59b5a..d062b26 100644 --- a/equal.go +++ b/equal.go @@ -14,6 +14,8 @@ package testlib + + import ( "fmt" "reflect" diff --git a/equal_test.go b/equal_test.go index 03d8155..27c1b51 100644 --- a/equal_test.go +++ b/equal_test.go @@ -46,59 +46,59 @@ func TestTestLibEqual(t *testing.T) { var i3 interface{} // These tests should all succeed. - m.Pass(t, func() { T.Equal(nil, nil) }) - m.Pass(t, func() { T.Equal(true, true) }) - m.Pass(t, func() { T.Equal(int(1), int(1)) }) - m.Pass(t, func() { T.Equal(int8(1), int8(1)) }) - m.Pass(t, func() { T.Equal(int16(1), int16(1)) }) - m.Pass(t, func() { T.Equal(int32(1), int32(1)) }) - m.Pass(t, func() { T.Equal(int64(1), int64(1)) }) - m.Pass(t, func() { T.Equal(uint(1), uint(1)) }) - m.Pass(t, func() { T.Equal(uint8(1), uint8(1)) }) - m.Pass(t, func() { T.Equal(uint16(1), uint16(1)) }) - m.Pass(t, func() { T.Equal(uint32(1), uint32(1)) }) - m.Pass(t, func() { T.Equal(uint64(1), uint64(1)) }) - m.Pass(t, func() { T.Equal(uintptr(1), uintptr(1)) }) - m.Pass(t, func() { T.Equal(float32(1), float32(1)) }) - m.Pass(t, func() { T.Equal(float64(1), float64(1)) }) - m.Pass(t, func() { T.Equal("1", "1") }) - m.Pass(t, func() { T.Equal(nilPtr, nil) }) - m.Pass(t, func() { T.Equal(strSlice1, strSlice2) }) - m.Pass(t, func() { T.Equal(strMap1, strMap2) }) - m.Pass(t, func() { T.Equal(myStr1, myStr2) }) - m.Pass(t, func() { T.Equal(m, m) }) - m.Pass(t, func() { T.Equal(mSlice1, mSlice2) }) - m.Pass(t, func() { T.Equal(mArray1, mArray2) }) - m.Pass(t, func() { T.Equal(f1, f1) }) - m.Pass(t, func() { T.Equal(&i1, &i2) }) + m.CheckPass(t, func() { T.Equal(nil, nil) }) + m.CheckPass(t, func() { T.Equal(true, true) }) + m.CheckPass(t, func() { T.Equal(int(1), int(1)) }) + m.CheckPass(t, func() { T.Equal(int8(1), int8(1)) }) + m.CheckPass(t, func() { T.Equal(int16(1), int16(1)) }) + m.CheckPass(t, func() { T.Equal(int32(1), int32(1)) }) + m.CheckPass(t, func() { T.Equal(int64(1), int64(1)) }) + m.CheckPass(t, func() { T.Equal(uint(1), uint(1)) }) + m.CheckPass(t, func() { T.Equal(uint8(1), uint8(1)) }) + m.CheckPass(t, func() { T.Equal(uint16(1), uint16(1)) }) + m.CheckPass(t, func() { T.Equal(uint32(1), uint32(1)) }) + m.CheckPass(t, func() { T.Equal(uint64(1), uint64(1)) }) + m.CheckPass(t, func() { T.Equal(uintptr(1), uintptr(1)) }) + m.CheckPass(t, func() { T.Equal(float32(1), float32(1)) }) + m.CheckPass(t, func() { T.Equal(float64(1), float64(1)) }) + m.CheckPass(t, func() { T.Equal("1", "1") }) + m.CheckPass(t, func() { T.Equal(nilPtr, nil) }) + m.CheckPass(t, func() { T.Equal(strSlice1, strSlice2) }) + m.CheckPass(t, func() { T.Equal(strMap1, strMap2) }) + m.CheckPass(t, func() { T.Equal(myStr1, myStr2) }) + m.CheckPass(t, func() { T.Equal(m, m) }) + m.CheckPass(t, func() { T.Equal(mSlice1, mSlice2) }) + m.CheckPass(t, func() { T.Equal(mArray1, mArray2) }) + m.CheckPass(t, func() { T.Equal(f1, f1) }) + m.CheckPass(t, func() { T.Equal(&i1, &i2) }) // Expected failure conditions. - m.Fail(t, func() { T.Equal(&MockT{}, "A") }) - m.Fail(t, func() { T.Equal(&MockT{}, nil) }) - m.Fail(t, func() { T.Equal(nil, &MockT{}) }) - m.Fail(t, func() { T.Equal(false, true) }) - m.Fail(t, func() { T.Equal(int(2), int(1)) }) - m.Fail(t, func() { T.Equal(int8(2), int8(1)) }) - m.Fail(t, func() { T.Equal(int16(2), int16(1)) }) - m.Fail(t, func() { T.Equal(int32(2), int32(1)) }) - m.Fail(t, func() { T.Equal(int64(2), int64(1)) }) - m.Fail(t, func() { T.Equal(uint(2), uint(1)) }) - m.Fail(t, func() { T.Equal(uint8(2), uint8(1)) }) - m.Fail(t, func() { T.Equal(uint16(2), uint16(1)) }) - m.Fail(t, func() { T.Equal(uint32(2), uint32(1)) }) - m.Fail(t, func() { T.Equal(uint64(2), uint64(1)) }) - m.Fail(t, func() { T.Equal(uintptr(2), uintptr(1)) }) - m.Fail(t, func() { T.Equal(float32(2), float32(1)) }) - m.Fail(t, func() { T.Equal(float64(2), float64(1)) }) - m.Fail(t, func() { T.Equal("2", "1") }) - m.Fail(t, func() { T.Equal("22", "1") }) - m.Fail(t, func() { T.Equal(mSlice1, mSlice3) }) - m.Fail(t, func() { T.Equal(mArray1, mArray3) }) - m.Fail(t, func() { T.Equal(f1, f2) }) - m.Fail(t, func() { T.Equal(&i1, &i3) }) + m.CheckFail(t, func() { T.Equal(&MockT{}, "A") }) + m.CheckFail(t, func() { T.Equal(&MockT{}, nil) }) + m.CheckFail(t, func() { T.Equal(nil, &MockT{}) }) + m.CheckFail(t, func() { T.Equal(false, true) }) + m.CheckFail(t, func() { T.Equal(int(2), int(1)) }) + m.CheckFail(t, func() { T.Equal(int8(2), int8(1)) }) + m.CheckFail(t, func() { T.Equal(int16(2), int16(1)) }) + m.CheckFail(t, func() { T.Equal(int32(2), int32(1)) }) + m.CheckFail(t, func() { T.Equal(int64(2), int64(1)) }) + m.CheckFail(t, func() { T.Equal(uint(2), uint(1)) }) + m.CheckFail(t, func() { T.Equal(uint8(2), uint8(1)) }) + m.CheckFail(t, func() { T.Equal(uint16(2), uint16(1)) }) + m.CheckFail(t, func() { T.Equal(uint32(2), uint32(1)) }) + m.CheckFail(t, func() { T.Equal(uint64(2), uint64(1)) }) + m.CheckFail(t, func() { T.Equal(uintptr(2), uintptr(1)) }) + m.CheckFail(t, func() { T.Equal(float32(2), float32(1)) }) + m.CheckFail(t, func() { T.Equal(float64(2), float64(1)) }) + m.CheckFail(t, func() { T.Equal("2", "1") }) + m.CheckFail(t, func() { T.Equal("22", "1") }) + m.CheckFail(t, func() { T.Equal(mSlice1, mSlice3) }) + m.CheckFail(t, func() { T.Equal(mArray1, mArray3) }) + m.CheckFail(t, func() { T.Equal(f1, f2) }) + m.CheckFail(t, func() { T.Equal(&i1, &i3) }) - m.Fail(t, func() { T.Equal(strSlice1, strSlice3) }) - m.Fail(t, func() { T.Equal(strMap1, strMap3) }) + m.CheckFail(t, func() { T.Equal(strSlice1, strSlice3) }) + m.CheckFail(t, func() { T.Equal(strMap1, strMap3) }) } func TestTestLibNotEqual(t *testing.T) { @@ -125,56 +125,56 @@ func TestTestLibNotEqual(t *testing.T) { var i2 interface{} = mSlice2 var i3 interface{} - // Failure cases. - m.Fail(t, func() { T.NotEqual(nil, nil) }) - m.Fail(t, func() { T.NotEqual(true, true) }) - m.Fail(t, func() { T.NotEqual(int(1), int(1)) }) - m.Fail(t, func() { T.NotEqual(int8(1), int8(1)) }) - m.Fail(t, func() { T.NotEqual(int16(1), int16(1)) }) - m.Fail(t, func() { T.NotEqual(int32(1), int32(1)) }) - m.Fail(t, func() { T.NotEqual(int64(1), int64(1)) }) - m.Fail(t, func() { T.NotEqual(uint(1), uint(1)) }) - m.Fail(t, func() { T.NotEqual(uint8(1), uint8(1)) }) - m.Fail(t, func() { T.NotEqual(uint16(1), uint16(1)) }) - m.Fail(t, func() { T.NotEqual(uint32(1), uint32(1)) }) - m.Fail(t, func() { T.NotEqual(uint64(1), uint64(1)) }) - m.Fail(t, func() { T.NotEqual(uintptr(1), uintptr(1)) }) - m.Fail(t, func() { T.NotEqual(float32(1), float32(1)) }) - m.Fail(t, func() { T.NotEqual(float64(1), float64(1)) }) - m.Fail(t, func() { T.NotEqual("1", "1") }) - m.Fail(t, func() { T.NotEqual(nilPtr, nil) }) - m.Fail(t, func() { T.NotEqual(strSlice1, strSlice2) }) - m.Fail(t, func() { T.NotEqual(strMap1, strMap2) }) - m.Fail(t, func() { T.NotEqual(m, m) }) - m.Fail(t, func() { T.NotEqual(mSlice1, mSlice2) }) - m.Fail(t, func() { T.NotEqual(mArray1, mArray2) }) - m.Fail(t, func() { T.NotEqual(f1, f1) }) - m.Fail(t, func() { T.NotEqual(&i1, &i2) }) + // CheckFailure cases. + m.CheckFail(t, func() { T.NotEqual(nil, nil) }) + m.CheckFail(t, func() { T.NotEqual(true, true) }) + m.CheckFail(t, func() { T.NotEqual(int(1), int(1)) }) + m.CheckFail(t, func() { T.NotEqual(int8(1), int8(1)) }) + m.CheckFail(t, func() { T.NotEqual(int16(1), int16(1)) }) + m.CheckFail(t, func() { T.NotEqual(int32(1), int32(1)) }) + m.CheckFail(t, func() { T.NotEqual(int64(1), int64(1)) }) + m.CheckFail(t, func() { T.NotEqual(uint(1), uint(1)) }) + m.CheckFail(t, func() { T.NotEqual(uint8(1), uint8(1)) }) + m.CheckFail(t, func() { T.NotEqual(uint16(1), uint16(1)) }) + m.CheckFail(t, func() { T.NotEqual(uint32(1), uint32(1)) }) + m.CheckFail(t, func() { T.NotEqual(uint64(1), uint64(1)) }) + m.CheckFail(t, func() { T.NotEqual(uintptr(1), uintptr(1)) }) + m.CheckFail(t, func() { T.NotEqual(float32(1), float32(1)) }) + m.CheckFail(t, func() { T.NotEqual(float64(1), float64(1)) }) + m.CheckFail(t, func() { T.NotEqual("1", "1") }) + m.CheckFail(t, func() { T.NotEqual(nilPtr, nil) }) + m.CheckFail(t, func() { T.NotEqual(strSlice1, strSlice2) }) + m.CheckFail(t, func() { T.NotEqual(strMap1, strMap2) }) + m.CheckFail(t, func() { T.NotEqual(m, m) }) + m.CheckFail(t, func() { T.NotEqual(mSlice1, mSlice2) }) + m.CheckFail(t, func() { T.NotEqual(mArray1, mArray2) }) + m.CheckFail(t, func() { T.NotEqual(f1, f1) }) + m.CheckFail(t, func() { T.NotEqual(&i1, &i2) }) // Non failure cases. - m.Pass(t, func() { T.NotEqual(&MockT{}, "A") }) - m.Pass(t, func() { T.NotEqual(&MockT{}, nil) }) - m.Pass(t, func() { T.NotEqual(nil, &MockT{}) }) - m.Pass(t, func() { T.NotEqual(false, true) }) - m.Pass(t, func() { T.NotEqual(int(2), int(1)) }) - m.Pass(t, func() { T.NotEqual(int8(2), int8(1)) }) - m.Pass(t, func() { T.NotEqual(int16(2), int16(1)) }) - m.Pass(t, func() { T.NotEqual(int32(2), int32(1)) }) - m.Pass(t, func() { T.NotEqual(int64(2), int64(1)) }) - m.Pass(t, func() { T.NotEqual(uint(2), uint(1)) }) - m.Pass(t, func() { T.NotEqual(uint8(2), uint8(1)) }) - m.Pass(t, func() { T.NotEqual(uint16(2), uint16(1)) }) - m.Pass(t, func() { T.NotEqual(uint32(2), uint32(1)) }) - m.Pass(t, func() { T.NotEqual(uint64(2), uint64(1)) }) - m.Pass(t, func() { T.NotEqual(uintptr(2), uintptr(1)) }) - m.Pass(t, func() { T.NotEqual(float32(2), float32(1)) }) - m.Pass(t, func() { T.NotEqual(float64(2), float64(1)) }) - m.Pass(t, func() { T.NotEqual("2", "1") }) - m.Pass(t, func() { T.NotEqual("22", "1") }) - m.Pass(t, func() { T.NotEqual(mSlice1, mSlice3) }) - m.Pass(t, func() { T.NotEqual(mArray1, mArray3) }) - m.Pass(t, func() { T.NotEqual(f1, f2) }) - m.Pass(t, func() { T.NotEqual(&i1, &i3) }) - m.Pass(t, func() { T.NotEqual(strSlice1, strSlice3) }) - m.Pass(t, func() { T.NotEqual(strMap1, strMap3) }) + m.CheckPass(t, func() { T.NotEqual(&MockT{}, "A") }) + m.CheckPass(t, func() { T.NotEqual(&MockT{}, nil) }) + m.CheckPass(t, func() { T.NotEqual(nil, &MockT{}) }) + m.CheckPass(t, func() { T.NotEqual(false, true) }) + m.CheckPass(t, func() { T.NotEqual(int(2), int(1)) }) + m.CheckPass(t, func() { T.NotEqual(int8(2), int8(1)) }) + m.CheckPass(t, func() { T.NotEqual(int16(2), int16(1)) }) + m.CheckPass(t, func() { T.NotEqual(int32(2), int32(1)) }) + m.CheckPass(t, func() { T.NotEqual(int64(2), int64(1)) }) + m.CheckPass(t, func() { T.NotEqual(uint(2), uint(1)) }) + m.CheckPass(t, func() { T.NotEqual(uint8(2), uint8(1)) }) + m.CheckPass(t, func() { T.NotEqual(uint16(2), uint16(1)) }) + m.CheckPass(t, func() { T.NotEqual(uint32(2), uint32(1)) }) + m.CheckPass(t, func() { T.NotEqual(uint64(2), uint64(1)) }) + m.CheckPass(t, func() { T.NotEqual(uintptr(2), uintptr(1)) }) + m.CheckPass(t, func() { T.NotEqual(float32(2), float32(1)) }) + m.CheckPass(t, func() { T.NotEqual(float64(2), float64(1)) }) + m.CheckPass(t, func() { T.NotEqual("2", "1") }) + m.CheckPass(t, func() { T.NotEqual("22", "1") }) + m.CheckPass(t, func() { T.NotEqual(mSlice1, mSlice3) }) + m.CheckPass(t, func() { T.NotEqual(mArray1, mArray3) }) + m.CheckPass(t, func() { T.NotEqual(f1, f2) }) + m.CheckPass(t, func() { T.NotEqual(&i1, &i3) }) + m.CheckPass(t, func() { T.NotEqual(strSlice1, strSlice3) }) + m.CheckPass(t, func() { T.NotEqual(strMap1, strMap3) }) } diff --git a/test.go b/test.go index b9a9647..6ab84ef 100644 --- a/test.go +++ b/test.go @@ -28,13 +28,19 @@ type MockT struct { skipped bool // These functions will be called if set to non nil. - funcError func(args ...interface{}) - funcErrorf func(format string, args ...interface{}) - funcFailed func() bool - funcFatal func(args ...interface{}) - funcFatalf func(format string, args ...interface{}) - funcSkip func(args ...interface{}) - funcSkipf func(format string, args ...interface{}) + funcErrorf func(format string, args ...interface{}) + funcError func(args ...interface{}) + funcFailed func() bool + funcFail func() + funcFailNow func() + funcFatalf func(format string, args ...interface{}) + funcFatal func(args ...interface{}) + funcLogf func(format string, args ...interface{}) + funcLog func(args ...interface{}) + funcSkipf func(format string, args ...interface{}) + funcSkip func(args ...interface{}) + funcSkipNow func() + funcSkipped func() bool } func (m *MockT) runTest(t *testing.T, fails bool, f func()) { @@ -58,14 +64,16 @@ func (m *MockT) runTest(t *testing.T, fails bool, f func()) { } } -func (m *MockT) Pass(t *testing.T, f func()) { +func (m *MockT) CheckPass(t *testing.T, f func()) { m.runTest(t, false, f) } -func (m *MockT) Fail(t *testing.T, f func()) { +func (m *MockT) CheckFail(t *testing.T, f func()) { m.runTest(t, true, f) } +// testing.TB compatibility functions. + func (m *MockT) Error(args ...interface{}) { m.failed = true if m.funcError != nil { @@ -87,6 +95,15 @@ func (m *MockT) Failed() bool { return m.failed } +func (m *MockT) Fail() { + m.failed = true +} + +func (m *MockT) FailNow() { + m.failed = true + runtime.Goexit() +} + func (m *MockT) Fatal(args ...interface{}) { m.failed = true if m.funcFatal != nil { @@ -103,6 +120,26 @@ func (m *MockT) Fatalf(format string, args ...interface{}) { runtime.Goexit() } +func (m *MockT) Log(args ...interface{}) { + if m.funcLog != nil { + m.funcLog(args...) + } +} + +func (m *MockT) Logf(format string, args ...interface{}) { + if m.funcLogf != nil { + m.funcLogf(format, args...) + } +} + +func (m *MockT) Skipf(format string, args ...interface{}) { + m.skipped = true + if m.funcSkipf != nil { + m.funcSkipf(format, args...) + } + runtime.Goexit() +} + func (m *MockT) Skip(args ...interface{}) { m.skipped = true if m.funcSkip != nil { @@ -111,10 +148,19 @@ func (m *MockT) Skip(args ...interface{}) { runtime.Goexit() } -func (m *MockT) Skipf(format string, args ...interface{}) { +func (m *MockT) SkipNow() { m.skipped = true - if m.funcSkipf != nil { - m.funcSkipf(format, args...) + if m.funcSkipNow != nil { + m.funcSkipNow() } runtime.Goexit() } + +func (m *MockT) Skipped() bool { + if m.funcSkipped != nil { + return m.funcSkipped() + } + return m.skipped +} + +func (m *MockT) private() {} diff --git a/testlib.go b/testlib.go index f833595..8a98a83 100644 --- a/testlib.go +++ b/testlib.go @@ -19,16 +19,35 @@ import ( "path" "runtime" "strings" - "testing" ) +// This is a mirror of testing.TB except that it does not include the private +// function. This allows us to use a mocked testing library, which for some +// reason the Go devs appear to think is a really bad thing however ends up +// being necessary to test libraries designed to work with testing.. =/ +type testingTB interface { + Error(args ...interface{}) + Errorf(format string, args ...interface{}) + Fail() + FailNow() + Failed() bool + Fatal(args ...interface{}) + Fatalf(format string, args ...interface{}) + Log(args ...interface{}) + Logf(format string, args ...interface{}) + Skip(args ...interface{}) + SkipNow() + Skipf(format string, args ...interface{}) + Skipped() bool +} + // This is the tracking object used to store various variables and bits needed // for tracking the test. Each test should create this object and then destroy // it when the test finishes by using a defer() call. type TestLib struct { // This stores a reference to the testing.T or testing.B object used to // create the initial test. - t testing.TB + t testingTB // This is the name of the test (function name) that created this TestLib // instance. @@ -43,7 +62,7 @@ type TestLib struct { // This should be called when the test is started. It will initialize a // TestLib instance for the specific test. -func NewTestLib(t testing.TB) *TestLib { +func NewTestLib(t testingTB) *TestLib { return &TestLib{t: t} }