settable time precision for small differences

deep.go

@@ -9,13 +9,17 @@ import (
 	"log"
 	"reflect"
 	"strings"
+	"time"
 )
 
 var (
 	// FloatPrecision is the number of decimal places to round float values
 	// to when comparing.
 	FloatPrecision = 10
 
+	// TimePrecision is a precision used for time.Time.Truncate(), if it is non-zero.
+	TimePrecision time.Duration
+
 	// MaxDiff specifies the maximum number of differences to return.
 	MaxDiff = 10
 
@@ -79,7 +83,11 @@ type cmp struct {
 	flag        map[byte]bool
 }
 
-var errorType = reflect.TypeOf((*error)(nil)).Elem()
+var (
+	errorType    = reflect.TypeOf((*error)(nil)).Elem()
+	timeType     = reflect.TypeOf(time.Time{})
+	durationType = reflect.TypeOf(time.Nanosecond)
+)
 
 // Equal compares variables a and b, recursing into their structure up to
 // MaxDepth levels deep (if greater than zero), and returns a list of differences,
@@ -203,6 +211,23 @@ func (c *cmp) equals(a, b reflect.Value, level int) {
 		return
 	}
 
+	fixTimePrecision := func() {
+		if TimePrecision > 0 {
+			switch aType {
+			case timeType, durationType:
+				aFunc := a.MethodByName("Truncate")
+				bFunc := a.MethodByName("Truncate")
+
+				if aFunc.CanInterface() && bFunc.CanInterface() {
+					precision := reflect.ValueOf(TimePrecision)
+
+					a = aFunc.Call([]reflect.Value{precision})[0]
+					b = bFunc.Call([]reflect.Value{precision})[0]
+				}
+			}
+		}
+	}
+
 	switch aKind {
 
 	/////////////////////////////////////////////////////////////////////
@@ -221,6 +246,8 @@ func (c *cmp) equals(a, b reflect.Value, level int) {
 			Iterate through the fields (FirstName, LastName), recurse into their values.
 		*/
 
+		fixTimePrecision()
+
 		// Types with an Equal() method, like time.Time, only if struct field
 		// is exported (CanInterface)
 		if eqFunc := a.MethodByName("Equal"); eqFunc.IsValid() && eqFunc.CanInterface() {
@@ -439,6 +466,7 @@ func (c *cmp) equals(a, b reflect.Value, level int) {
 			c.saveDiff(a.Bool(), b.Bool())
 		}
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		fixTimePrecision()
 		if a.Int() != b.Int() {
 			c.saveDiff(a.Int(), b.Int())
 		}