assert.Empty: comprehensive doc of "Empty"-ness rules

[dolmen]

Summary

Document the assert.Empty rules more comprehensively. This exposes our quirks to the user to avoid wrong expectations.

Add many many many more test cases that document edges cases and will allow to catch breaking changes and avoid regressions.

Changes

• improve doc of assert.Empty, assert.NotEmpty (and their generated childs in package require)
• add many test cases for the internal isEmpty. They are added in the current style for now, but I have plans for a future refactoring (using table tests).

Motivation

assert.Empty has quirks which desserve to be documented for our users, and for contributors.

The extensive test suite will help to ease future refactorings of Testify internals by catch breaking changes.

Related issues

[dolmen]

Cc: @PeterEFinch could you review this?

[ccoVeille]

I learned things BTW

[PeterEFinch]

This comment is definitely an improvement and aligns with what is I see is implemented.

I was also wondering if the current implementation:

testify/assert/assertions.go

Lines 770 to 773 in 3c1541a

	default:
	zero := reflect.Zero(objValue.Type())
	return reflect.DeepEqual(object, zero.Interface())
	}

is in any way different to

default:
	return objValue.IsZero()
}

if so that might be worthwhile highlighting (I doubt there is any difference though).

[dolmen]

reflect.Value.IsZero() did not exist when assert.Empty has been added.

It is a good idea for a future refactoring. That's why we first need a strong test suite.

[PeterEFinch]

I think your list is pretty extensive.

You could test some interfaces with nil values but have a types associated with them but that might be a bit overkill. For example, you can have err being nil according to the assertions but is not equal to nil

type MyError struct{}

func (e *MyError) Error() string {
	return "my error"
}

func TestMyError_isNil(t *testing.T) {
	var e *MyError
	err := error(e)
	assert.False(t, err == nil)
	assert.Empty(t, err)
	assert.Nil(t, err)
	assert.Zero(t, err)
}

[brackendawson]

Because testify works at runtime it does not have visibility of your code's interface types, they get always converted into interface{}, eg:

var e *MyError // type: *MyError, value: nil
assert.Empty(t, e)
...
func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
	object // type: interface{}, value: (*MyError)(nil)
...
err := error(e) // type: error, value: (*MyError)(nil)
assert.Empty(t, err)
...
func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
	object // type: interface{}, value: (*MyError)(nil)

Put simply, testify cannot tell that you passed an interface.

[brackendawson]

Malformed Zero values link and missing line break between Zero values and Arrays:

[dolmen]

Fixed.

I had to swich all mentions of "Empty" to "empty" because codegen replaces them ("Empty" becomes "Emptyf" in the doc of Emptyf).

[brackendawson]

LGTM and renders nice in pkgsite.