assert: add Kind and NotKind

assert/assertions.go

@@ -487,6 +487,36 @@ func IsNotType(t TestingT, theType, object interface{}, msgAndArgs ...interface{
 	return Fail(t, fmt.Sprintf("Object type expected to be different than %T", theType), msgAndArgs...)
 }
 
+// Kind asserts that the given object's kind matches the expected kind.
+//
+//	assert.Kind(t, reflect.String, "Hello World")
+func Kind(t TestingT, expectedKind reflect.Kind, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	objectKind := reflect.TypeOf(object).Kind()
+	if objectKind == expectedKind {
+		return true
+	}
+	return Fail(t, fmt.Sprintf("Object expected to be of kind %v, but was %v", expectedKind, objectKind), msgAndArgs...)
+}
+
+// NotKind asserts that the given object's kind does not match the unexpected kind.
+//
+//	assert.NotKind(t, reflect.Int, "Hello World")
+func NotKind(t TestingT, unexpectedKind reflect.Kind, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+
+	objectKind := reflect.TypeOf(object).Kind()
+	if objectKind != unexpectedKind {
+		return true
+	}
+	return Fail(t, fmt.Sprintf("Object expected NOT to be of kind %v, but was %v", unexpectedKind, objectKind), msgAndArgs...)
+}
+
 // Equal asserts that two objects are equal.
 //
 //	assert.Equal(t, 123, 123)

assert/assertions_test.go

@@ -585,6 +585,71 @@ func TestNotIsType(t *testing.T) {
 	}
 }
 
+func TestKind(t *testing.T) {
+	mockT := new(testing.T)
+
+	cases := []struct {
+		expected reflect.Kind
+		object   interface{}
+		result   bool
+		remark   string
+	}{
+		{reflect.String, "Hello World", true, "is string"},
+		{reflect.Int, 123, true, "is int"},
+		{reflect.Array, [6]int{2, 3, 5, 7, 11, 13}, true, "is array"},
+		{reflect.Func, Kind, true, "is func"},
+		{reflect.Float64, 0.0345, true, "is float64"},
+		{reflect.Map, make(map[string]int), true, "is map"},
+		{reflect.Bool, true, true, "is bool"},
+		{reflect.Ptr, new(int), true, "is pointer"},
+
+		// Not expected to be equal
+		{reflect.String, 13, false, "not string"},
+		{reflect.Int, [6]int{2, 3, 5, 7, 11, 13}, false, "not int"},
+		{reflect.Float64, 12, false, "not float64"},
+		{reflect.Bool, make(map[string]int), false, "not bool"},
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("Kind(%#v, %#v)", c.expected, c.object), func(t *testing.T) {
+			res := Kind(mockT, c.expected, c.object)
+
+			if res != c.result {
+				t.Errorf("Kind(%#v, %#v) should return %#v: %s", c.expected, c.object, c.result, c.remark)
+			}
+		})
+	}
+}
+
+func TestNotKind(t *testing.T) {
+	mockT := new(testing.T)
+
+	cases := []struct {
+		unexpected reflect.Kind
+		object     interface{}
+		result     bool
+		remark     string
+	}{
+		{reflect.String, 123, true, "not string"},
+		{reflect.Int, "hi", true, "not int"},
+		{reflect.Map, []int{1, 2}, true, "not map"},
+		{reflect.Ptr, 99, true, "not pointer"},
+
+		// Should fail when kinds match
+		{reflect.Func, func() {}, false, "is func"},
+		{reflect.Bool, false, false, "is bool"},
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("NotKind(%#v, %#v)", c.unexpected, c.object), func(t *testing.T) {
+			res := NotKind(mockT, c.unexpected, c.object)
+			if res != c.result {
+				t.Errorf("NotKind(%#v, %#v) should return %#v: %s", c.unexpected, c.object, c.result, c.remark)
+			}
+		})
+	}
+}
+
 func TestEqual(t *testing.T) {
 	t.Parallel()