improved nil check

Author: yazgazan

diff/diff.go

@@ -46,7 +46,7 @@ func diff(c config, lhs, rhs interface{}, visited *visited) (Differ, error) {
 	lhsVal, lhs := indirectValueOf(lhs)
 	rhsVal, rhs := indirectValueOf(rhs)
 
-	if d, ok := nilCheck(lhs, rhs); ok {
+	if d, ok := nilCheck(lhsVal, rhsVal, lhs, rhs); ok {
 		return d, nil
 	}
 
@@ -115,12 +115,15 @@ func valueIsScalar(v reflect.Value) bool {
 	}
 }
 
-func nilCheck(lhs, rhs interface{}) (Differ, bool) {
-	if lhs == nil && rhs == nil {
-		return scalar{lhs, rhs}, true
+func nilCheck(lhsVal, rhsVal reflect.Value, lhs, rhs interface{}) (Differ, bool) {
+	lhsNil := lhs == nil || (lhsVal.Kind() == reflect.Ptr && lhsVal.IsNil())
+	rhsNil := rhs == nil || (rhsVal.Kind() == reflect.Ptr && rhsVal.IsNil())
+
+	if lhsNil && rhsNil {
+		return scalar{lhsVal, rhsVal}, true
 	}
-	if lhs == nil || rhs == nil {
-		return types{lhs, rhs}, true
+	if lhsNil || rhsNil {
+		return types{lhsVal, rhsVal}, true
 	}
 
 	return nil, false

diff/diff_test.go

@@ -7,6 +7,7 @@ import (
 	"reflect"
 	"strings"
 	"testing"
+	"time"
 )
 
 type mockedStream struct {
@@ -36,6 +37,8 @@ func (s erroringMockedStream) NextValue() (interface{}, error) {
 }
 
 func TestDiff(t *testing.T) {
+	type CustomType int
+
 	for _, test := range []struct {
 		LHS   interface{}
 		RHS   interface{}
@@ -111,6 +114,98 @@ func TestDiff(t *testing.T) {
 			RHS:  mockStream(4, 5, 6),
 			Want: ContentDiffer,
 		},
+		{
+			LHS:  CustomType(1),
+			RHS:  CustomType(1),
+			Want: Identical,
+		},
+		{
+			LHS:  CustomType(1),
+			RHS:  CustomType(2),
+			Want: ContentDiffer,
+		},
+		{
+			LHS:  CustomType(1),
+			RHS:  2,
+			Want: ContentDiffer,
+		},
+		{
+			LHS:  new(CustomType),
+			RHS:  new(CustomType),
+			Want: Identical,
+		},
+		{
+			LHS:  time.Time{},
+			RHS:  time.Time{},
+			Want: Identical,
+		},
+		{
+			LHS:  new(time.Time),
+			RHS:  new(time.Time),
+			Want: Identical,
+		},
+		{
+			LHS: struct {
+				Foo *int
+			}{},
+			RHS: struct {
+				Foo *int
+			}{},
+			Want: Identical,
+		},
+		{
+			LHS: struct {
+				Foo *int
+			}{
+				Foo: new(int),
+			},
+			RHS: struct {
+				Foo *int
+			}{},
+			Want: ContentDiffer,
+		},
+		{
+			LHS: struct {
+				Foo *int
+			}{
+				Foo: func() *int {
+					i := 42
+
+					return &i
+				}(),
+			},
+			RHS: struct {
+				Foo *int
+			}{
+				Foo: func() *int {
+					i := 42
+
+					return &i
+				}(),
+			},
+			Want: Identical,
+		},
+		{
+			LHS: struct {
+				Foo *int
+			}{
+				Foo: func() *int {
+					i := 42
+
+					return &i
+				}(),
+			},
+			RHS: struct {
+				Foo *int
+			}{
+				Foo: func() *int {
+					i := 84
+
+					return &i
+				}(),
+			},
+			Want: ContentDiffer,
+		},
 	} {
 		diff, err := Diff(test.LHS, test.RHS)