Package deep

Constants

const (
    // FLAG_NONE is a placeholder for default Equal behavior. You don't have to
    // pass it to Equal; if you do, it does nothing.
    FLAG_NONE byte = iota

    // FLAG_IGNORE_SLICE_ORDER causes Equal to ignore slice order so that
    // []int{1, 2} and []int{2, 1} are equal. Only slices of primitive scalars
    // like numbers and strings are supported. Slices of complex types,
    // like []T where T is a struct, are undefined because Equal does not
    // recurse into the slice value when this flag is enabled.
    FLAG_IGNORE_SLICE_ORDER
)

Variables

var (
    // FloatPrecision is the number of decimal places to round float values
    // to when comparing.
    FloatPrecision = 10

    // MaxDiff specifies the maximum number of differences to return.
    MaxDiff = 10

    // MaxDepth specifies the maximum levels of a struct to recurse into,
    // if greater than zero. If zero, there is no limit.
    MaxDepth = 0

    // LogErrors causes errors to be logged to STDERR when true.
    LogErrors = false

    // CompareUnexportedFields causes unexported struct fields, like s in
    // T{s int}, to be compared when true. This does not work for comparing
    // error or Time types on unexported fields because methods on unexported
    // fields cannot be called.
    CompareUnexportedFields = false

    // CompareFunctions compares functions the same as reflect.DeepEqual:
    // only two nil functions are equal. Every other combination is not equal.
    // This is disabled by default because previous versions of this package
    // ignored functions. Enabling it can possibly report new diffs.
    CompareFunctions = false

    // NilSlicesAreEmpty causes a nil slice to be equal to an empty slice.
    NilSlicesAreEmpty = false

    // NilMapsAreEmpty causes a nil map to be equal to an empty map.
    NilMapsAreEmpty = false
)

var (
    // ErrMaxRecursion is logged when MaxDepth is reached.
    ErrMaxRecursion = errors.New("recursed to MaxDepth")

    // ErrTypeMismatch is logged when Equal passed two different types of values.
    ErrTypeMismatch = errors.New("variables are different reflect.Type")

    // ErrNotHandled is logged when a primitive Go kind is not handled.
    ErrNotHandled = errors.New("cannot compare the reflect.Kind")
)

func Equal ¶

func Equal(a, b interface{}, flags ...interface{}) []string

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, or nil if there are none. Some differences may not be found if an error is also returned.

If a type has an Equal method, like time.Equal, it is called to check for equality.

When comparing a struct, if a field has the tag `deep:"-"` then it will be ignored.

Subdirectories