From ac1463f956a00565e6df4d71facece9d5660e314 Mon Sep 17 00:00:00 2001 From: Ivo van der Wijk Date: Fri, 22 May 2020 16:54:16 +0200 Subject: [PATCH] Implement NotEqualValues --- assert/assertions.go | 15 +++++++ assert/assertions_test.go | 69 +++++++++++++++++++++++++++++++ assert/forward_assertions_test.go | 24 +++++++++++ require/requirements_test.go | 1 + 4 files changed, 109 insertions(+) diff --git a/assert/assertions.go b/assert/assertions.go index 7af9ad236..914a10d83 100644 --- a/assert/assertions.go +++ b/assert/assertions.go @@ -699,6 +699,21 @@ func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{ } +// NotEqualValues asserts that two objects are not equal even when converted to the same type +// +// assert.NotEqualValues(t, obj1, obj2) +func NotEqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + if ObjectsAreEqualValues(expected, actual) { + return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...) + } + + return true +} + // containsElement try loop over the list check if the list includes the element. // return (false, false) if impossible. // return (true, false) if element was not found. diff --git a/assert/assertions_test.go b/assert/assertions_test.go index 4f0f41c86..7046bc021 100644 --- a/assert/assertions_test.go +++ b/assert/assertions_test.go @@ -222,6 +222,10 @@ func TestEqual(t *testing.T) { if Equal(mockT, myType("1"), myType("2")) { t.Error("Equal should return false") } + // A case that might be confusing, especially with numeric literals + if Equal(mockT, 10, uint(10)) { + t.Error("Equal should return false") + } } func ptr(i int) *int { @@ -544,6 +548,70 @@ func TestNotEqual(t *testing.T) { if NotEqual(mockT, &struct{}{}, &struct{}{}) { t.Error("NotEqual should return false") } + + // A case that might be confusing, especially with numeric literals + if !NotEqual(mockT, 10, uint(10)) { + t.Error("NotEqual should return false") + } +} + +func TestNotEqualValues(t *testing.T) { + + mockT := new(testing.T) + + // Same tests as NotEqual since they behave the same when types are irrelevant + if !NotEqualValues(mockT, "Hello World", "Hello World!") { + t.Error("NotEqualValues should return true") + } + if !NotEqualValues(mockT, 123, 1234) { + t.Error("NotEqualValues should return true") + } + if !NotEqualValues(mockT, 123.5, 123.55) { + t.Error("NotEqualValues should return true") + } + if !NotEqualValues(mockT, []byte("Hello World"), []byte("Hello World!")) { + t.Error("NotEqualValues should return true") + } + if !NotEqualValues(mockT, nil, new(AssertionTesterConformingObject)) { + t.Error("NotEqualValues should return true") + } + if NotEqualValues(mockT, nil, nil) { + t.Error("NotEqualValues should return false") + } + if NotEqualValues(mockT, "Hello World", "Hello World") { + t.Error("NotEqualValues should return false") + } + if NotEqualValues(mockT, 123, 123) { + t.Error("NotEqualValues should return false") + } + if NotEqualValues(mockT, 123.5, 123.5) { + t.Error("NotEqualValues should return false") + } + if NotEqualValues(mockT, []byte("Hello World"), []byte("Hello World")) { + t.Error("NotEqualValues should return false") + } + if NotEqualValues(mockT, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) { + t.Error("NotEqualValues should return false") + } + if NotEqualValues(mockT, &struct{}{}, &struct{}{}) { + t.Error("NotEqualValues should return false") + } + + // Special cases where NotEqualValues behaves differently + funcA := func() int { return 23 } + funcB := func() int { return 42 } + if !NotEqualValues(mockT, funcA, funcB) { + t.Error("NotEqualValues should return true") + } + if !NotEqualValues(mockT, int(10), int(11)) { + t.Error("NotEqualValues should return true") + } + if NotEqualValues(mockT, int(10), uint(10)) { + t.Error("NotEqualValues should return false") + } + if NotEqualValues(mockT, struct{}{}, struct{}{}) { + t.Error("NotEqualValues should return false") + } } type A struct { @@ -2139,6 +2207,7 @@ func TestComparisonAssertionFunc(t *testing.T) { {"isType", (*testing.T)(nil), t, IsType}, {"equal", t, t, Equal}, {"equalValues", t, t, EqualValues}, + {"notEqualValues", t, nil, NotEqualValues}, {"exactly", t, t, Exactly}, {"notEqual", t, nil, NotEqual}, {"notContains", []int{1, 2, 3}, 4, NotContains}, diff --git a/assert/forward_assertions_test.go b/assert/forward_assertions_test.go index 60e5e3023..a8240d79d 100644 --- a/assert/forward_assertions_test.go +++ b/assert/forward_assertions_test.go @@ -154,6 +154,30 @@ func TestNotEqualWrapper(t *testing.T) { } } +func TestNotEqualValuesWrapper(t *testing.T) { + + assert := New(new(testing.T)) + + if !assert.NotEqualValues("Hello World", "Hello World!") { + t.Error("NotEqualValues should return true") + } + if !assert.NotEqualValues(123, 1234) { + t.Error("NotEqualValues should return true") + } + if !assert.NotEqualValues(123.5, 123.55) { + t.Error("NotEqualValues should return true") + } + if !assert.NotEqualValues([]byte("Hello World"), []byte("Hello World!")) { + t.Error("NotEqualValues should return true") + } + if !assert.NotEqualValues(nil, new(AssertionTesterConformingObject)) { + t.Error("NotEqualValues should return true") + } + if assert.NotEqualValues(10, uint(10)) { + t.Error("NotEqualValues should return false") + } +} + func TestContainsWrapper(t *testing.T) { assert := New(new(testing.T)) diff --git a/require/requirements_test.go b/require/requirements_test.go index c4d0afa17..c43e9895a 100644 --- a/require/requirements_test.go +++ b/require/requirements_test.go @@ -521,6 +521,7 @@ func TestComparisonAssertionFunc(t *testing.T) { {"equalValues", t, t, EqualValues}, {"exactly", t, t, Exactly}, {"notEqual", t, nil, NotEqual}, + {"NotEqualValues", t, nil, NotEqualValues}, {"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},