Skip to content

Commit

Permalink
Fix some bug to make the module work agian
Browse files Browse the repository at this point in the history
  • Loading branch information
Brady Catherman committed Aug 12, 2014
1 parent 308548b commit c45c728
Show file tree
Hide file tree
Showing 5 changed files with 183 additions and 116 deletions.
2 changes: 1 addition & 1 deletion .travis.yml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
2 changes: 2 additions & 0 deletions equal.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,6 +14,8 @@

package testlib



import (
"fmt"
"reflect"
Expand Down
200 changes: 100 additions & 100 deletions equal_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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) {
Expand All @@ -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) })
}
70 changes: 58 additions & 12 deletions test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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()) {
Expand All @@ -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 {
Expand All @@ -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 {
Expand All @@ -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 {
Expand All @@ -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() {}
25 changes: 22 additions & 3 deletions testlib.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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.
Expand All @@ -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}
}

Expand Down

0 comments on commit c45c728

Please sign in to comment.