Adding upstream version 2.1.2.

Signed-off-by: Daniel Baumann <daniel@debian.org>

testutil/helpers.go

@@ -0,0 +1,216 @@
+package testutil
+
+import (
+	"math"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// AssertNil asserts an argument is nil.
+func AssertNil(t *testing.T, actual interface{}) {
+	t.Helper()
+	if !isNil(actual) {
+		t.Errorf("assertion failed; expected actual to be nil")
+		t.FailNow()
+	}
+}
+
+// AssertNotNil asserts an argument is not nil.
+func AssertNotNil(t *testing.T, actual interface{}, message ...interface{}) {
+	t.Helper()
+	if isNil(actual) {
+		t.Error("assertion failed; expected actual to not be nil")
+		if len(message) > 0 {
+			t.Error(message...)
+		}
+		t.FailNow()
+	}
+}
+
+// AssertEqual asserts two arguments are equal.
+func AssertEqual(t *testing.T, expected, actual interface{}, message ...interface{}) {
+	t.Helper()
+	if !equal(expected, actual) {
+		t.Errorf("assertion failed; expected %v to equal %v", actual, expected)
+		if len(message) > 0 {
+			t.Error(message...)
+		}
+		t.FailNow()
+	}
+}
+
+// AssertNotEqual asserts two arguments are not equal.
+func AssertNotEqual(t *testing.T, expected, actual interface{}, message ...interface{}) {
+	t.Helper()
+	if equal(expected, actual) {
+		t.Errorf("assertion failed; expected %v to not equal %v", actual, expected)
+		if len(message) > 0 {
+			t.Error(message...)
+		}
+		t.FailNow()
+	}
+}
+
+// AssertZero asserts an argument is zero.
+func AssertZero(t *testing.T, actual interface{}, message ...interface{}) {
+	t.Helper()
+	AssertEqual(t, 0, actual)
+}
+
+// AssertNotZero asserts an argument is not zero.
+func AssertNotZero(t *testing.T, actual interface{}, message ...interface{}) {
+	t.Helper()
+	AssertNotEqual(t, 0, actual)
+}
+
+// AssertTrue asserts an argument is true.
+func AssertTrue(t *testing.T, arg bool, message ...interface{}) {
+	t.Helper()
+	if !arg {
+		t.Errorf("assertion failed; expected actual to be true")
+		if len(message) > 0 {
+			t.Error(message...)
+		}
+		t.FailNow()
+	}
+}
+
+// AssertFalse asserts an argument is false.
+func AssertFalse(t *testing.T, arg bool, message ...interface{}) {
+	t.Helper()
+	if arg {
+		t.Errorf("assertion failed; expected actual to be false")
+		if len(message) > 0 {
+			t.Error(message...)
+		}
+		t.FailNow()
+	}
+}
+
+// AssertInDelta asserts a two arguments are within a delta of eachother.
+//
+// This delta will be determined absolute, and the delta should always be positive.
+func AssertInDelta(t *testing.T, from, to, delta float64, message ...interface{}) {
+	t.Helper()
+	if diff := math.Abs(from - to); diff > delta {
+		t.Errorf("assertion failed; expected absolute difference of %f and %f to be %f", from, to, delta)
+		if len(message) > 0 {
+			t.Error(message...)
+		}
+		t.FailNow()
+	}
+}
+
+// AssertEmpty asserts an argument is empty.
+func AssertEmpty(t *testing.T, arg interface{}, message ...interface{}) {
+	t.Helper()
+	if getLength(arg) != 0 {
+		t.Errorf("assertion failed; expected actual to be empty")
+		if len(message) > 0 {
+			t.Error(message...)
+		}
+		t.FailNow()
+	}
+}
+
+// AssertNotEmpty asserts an argument is not empty.
+func AssertNotEmpty(t *testing.T, arg interface{}, message ...interface{}) {
+	t.Helper()
+	if getLength(arg) == 0 {
+		t.Errorf("assertion failed; expected actual to not be empty")
+		if len(message) > 0 {
+			t.Error(message...)
+		}
+		t.FailNow()
+	}
+}
+
+// AssertLen asserts an argument has a given length.
+func AssertLen(t *testing.T, arg interface{}, length int, message ...interface{}) {
+	t.Helper()
+	if getLength(arg) != length {
+		t.Errorf("assertion failed; expected actual to have length %d", length)
+		if len(message) > 0 {
+			t.Error(message...)
+		}
+		t.FailNow()
+	}
+}
+
+// AssertContains asserts an argument contains a given substring.
+func AssertContains(t *testing.T, s, substr string, message ...interface{}) {
+	t.Helper()
+	if !strings.Contains(s, substr) {
+		t.Errorf("assertion failed; expected actual to contain %q", substr)
+		if len(message) > 0 {
+			t.Error(message...)
+		}
+		t.FailNow()
+	}
+}
+
+// AssertNotContains asserts an argument does not contain a given substring.
+func AssertNotContains(t *testing.T, s, substr string, message ...interface{}) {
+	t.Helper()
+	if strings.Contains(s, substr) {
+		t.Errorf("assertion failed; expected actual to not contain %q", substr)
+		if len(message) > 0 {
+			t.Error(message...)
+		}
+		t.FailNow()
+	}
+}
+
+func equal(expected, actual interface{}) bool {
+	if expected == nil && actual == nil {
+		return true
+	}
+	if (expected == nil && actual != nil) || (expected != nil && actual == nil) {
+		return false
+	}
+
+	actualType := reflect.TypeOf(actual)
+	if actualType == nil {
+		return false
+	}
+	expectedValue := reflect.ValueOf(expected)
+	if expectedValue.IsValid() && expectedValue.Type().ConvertibleTo(actualType) {
+		return reflect.DeepEqual(expectedValue.Convert(actualType).Interface(), actual)
+	}
+
+	return reflect.DeepEqual(expected, actual)
+}
+
+func isNil(object interface{}) bool {
+	if object == nil {
+		return true
+	}
+
+	value := reflect.ValueOf(object)
+	kind := value.Kind()
+	if kind >= reflect.Chan && kind <= reflect.Slice && value.IsNil() {
+		return true
+	}
+	return false
+}
+
+func getLength(object interface{}) int {
+	if object == nil {
+		return 0
+	} else if object == "" {
+		return 0
+	}
+
+	objValue := reflect.ValueOf(object)
+
+	switch objValue.Kind() {
+	case reflect.Map:
+		fallthrough
+	case reflect.Slice, reflect.Chan, reflect.String:
+		{
+			return objValue.Len()
+		}
+	}
+	return 0
+}