Import Emilien Puget version as-is from

stretchr/objx#159

Co-Authored-by: Emilien Puget <emilien-puget@users.noreply.github.com>

Author: ccoVeille

internal/testifail.go

@@ -0,0 +1,247 @@
+package internal
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+type (
+	nonfatal struct{}
+	fatal    struct{}
+)
+
+var (
+	assert  nonfatal
+	require fatal
+)
+
+func (nonfatal) fail(t *testing.T, msg string, msgAndArgs ...any) bool {
+	t.Helper()
+	if len(msgAndArgs) > 0 {
+		msg = fmt.Sprintf(msg, msgAndArgs...)
+	}
+	t.Error(msg)
+	return false
+}
+
+func (fatal) fail(t *testing.T, msg string, msgAndArgs ...any) {
+	t.Helper()
+	if len(msgAndArgs) > 0 {
+		msg = fmt.Sprintf(msg, msgAndArgs...)
+	}
+	t.Fatal(msg)
+}
+
+func (a nonfatal) Equal(t *testing.T, expected, actual any, msgAndArgs ...any) bool {
+	t.Helper()
+	if !reflect.DeepEqual(expected, actual) {
+		return a.fail(t, "not equal:\nexpected: %#v\nactual:   %#v", expected, actual)
+	}
+	return true
+}
+
+func (a fatal) Equal(t *testing.T, expected, actual any, msgAndArgs ...any) {
+	t.Helper()
+	if !reflect.DeepEqual(expected, actual) {
+		a.fail(t, "not equal:\nexpected: %#v\nactual:   %#v", expected, actual)
+	}
+}
+
+func (a nonfatal) NotEqual(t *testing.T, expected, actual any, msgAndArgs ...any) bool {
+	t.Helper()
+	if reflect.DeepEqual(expected, actual) {
+		return a.fail(t, "should not be equal: %#v", actual)
+	}
+	return true
+}
+
+func (a fatal) NotEqual(t *testing.T, expected, actual any, msgAndArgs ...any) {
+	t.Helper()
+	if reflect.DeepEqual(expected, actual) {
+		a.fail(t, "should not be equal: %#v", actual)
+	}
+}
+
+func isNil(i any) bool {
+	if i == nil {
+		return true
+	}
+	v := reflect.ValueOf(i)
+	switch v.Kind() {
+	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		return v.IsNil()
+	}
+	return false
+}
+
+func (a nonfatal) Nil(t *testing.T, object any, msgAndArgs ...any) bool {
+	t.Helper()
+	if !isNil(object) {
+		return a.fail(t, "expected nil, got: %#v", object)
+	}
+	return true
+}
+
+func (a fatal) Nil(t *testing.T, object any, msgAndArgs ...any) {
+	t.Helper()
+	if !isNil(object) {
+		a.fail(t, "expected nil, got: %#v", object)
+	}
+}
+
+func (a nonfatal) NotNil(t *testing.T, object any, msgAndArgs ...any) bool {
+	t.Helper()
+	if isNil(object) {
+		return a.fail(t, "expected not nil")
+	}
+	return true
+}
+
+func (a fatal) NotNil(t *testing.T, object any, msgAndArgs ...any) {
+	t.Helper()
+	if isNil(object) {
+		a.fail(t, "expected not nil")
+	}
+}
+
+func (a nonfatal) True(t *testing.T, value bool, msgAndArgs ...any) bool {
+	t.Helper()
+	if !value {
+		return a.fail(t, "expected true, got false")
+	}
+	return true
+}
+
+func (a fatal) True(t *testing.T, value bool, msgAndArgs ...any) {
+	t.Helper()
+	if !value {
+		a.fail(t, "expected true, got false")
+	}
+}
+
+func (a nonfatal) False(t *testing.T, value bool, msgAndArgs ...any) bool {
+	t.Helper()
+	if value {
+		return a.fail(t, "expected false, got true")
+	}
+	return true
+}
+
+func (a fatal) False(t *testing.T, value bool, msgAndArgs ...any) {
+	t.Helper()
+	if value {
+		a.fail(t, "expected false, got true")
+	}
+}
+
+func (a nonfatal) NoError(t *testing.T, err error, msgAndArgs ...any) bool {
+	t.Helper()
+	if err != nil {
+		return a.fail(t, "expected no error, got: %v", err)
+	}
+	return true
+}
+
+func (a fatal) NoError(t *testing.T, err error, msgAndArgs ...any) {
+	t.Helper()
+	if err != nil {
+		a.fail(t, "expected no error, got: %v", err)
+	}
+}
+
+func (a nonfatal) Error(t *testing.T, err error, msgAndArgs ...any) bool {
+	t.Helper()
+	if err == nil {
+		return a.fail(t, "expected error, got nil")
+	}
+	return true
+}
+
+func (a fatal) Error(t *testing.T, err error, msgAndArgs ...any) {
+	t.Helper()
+	if err == nil {
+		a.fail(t, "expected error, got nil")
+	}
+}
+
+func (a nonfatal) Panics(t *testing.T, f func(), msgAndArgs ...any) bool {
+	t.Helper()
+	defer func() {
+		if r := recover(); r == nil {
+			_ = a.fail(t, "expected panic, but function did not panic")
+		}
+	}()
+	f()
+	return true
+}
+
+func (a fatal) Panics(t *testing.T, f func(), msgAndArgs ...any) {
+	t.Helper()
+	defer func() {
+		if r := recover(); r == nil {
+			a.fail(t, "expected panic, but function did not panic")
+		}
+	}()
+	f()
+}
+
+func (a nonfatal) Empty(t *testing.T, object any, msgAndArgs ...any) bool {
+	t.Helper()
+	if !isEmpty(object) {
+		return a.fail(t, "expected empty, got: %#v", object)
+	}
+	return true
+}
+
+func (a fatal) Empty(t *testing.T, object any, msgAndArgs ...any) {
+	t.Helper()
+	if !isEmpty(object) {
+		a.fail(t, "expected empty, got: %#v", object)
+	}
+}
+
+func isEmpty(object any) bool {
+	if object == nil {
+		return true
+	}
+	v := reflect.ValueOf(object)
+	switch v.Kind() {
+	case reflect.Array, reflect.Slice, reflect.Map, reflect.Chan, reflect.String:
+		return v.Len() == 0
+	case reflect.Ptr, reflect.Interface:
+		if v.IsNil() {
+			return true
+		}
+		return isEmpty(v.Elem().Interface())
+	}
+	// numbers and structs are never considered empty here
+	return false
+}
+
+func (a nonfatal) Len(t *testing.T, object any, length int, msgAndArgs ...any) bool {
+	t.Helper()
+	v := reflect.ValueOf(object)
+	switch v.Kind() {
+	case reflect.Array, reflect.Slice, reflect.Map, reflect.Chan, reflect.String:
+		if v.Len() != length {
+			return a.fail(t, "unexpected length, expected %d got %d", length, v.Len())
+		}
+		return true
+	default:
+		return a.fail(t, "Len not supported for kind %s", v.Kind())
+	}
+}
+
+func (a fatal) Len(t *testing.T, object any, length int, msgAndArgs ...any) {
+	t.Helper()
+	v := reflect.ValueOf(object)
+	switch v.Kind() {
+	case reflect.Array, reflect.Slice, reflect.Map, reflect.Chan, reflect.String:
+		if v.Len() != length {
+			a.fail(t, "unexpected length, expected %d got %d", length, v.Len())
+		}
+	default:
+		a.fail(t, "Len not supported for kind %s", v.Kind())
+	}
+}