mirror of
https://github.com/restic/restic.git
synced 2026-07-12 10:15:08 +00:00
Update dependencies, enable pruning for vendor/
So, `dep` got an nice new feature to remove tests and non-go files from `vendor/`, and this brings the size of the vendor directory from ~300MiB down to ~20MiB. We don that now.
This commit is contained in:
Alexander Neumann
-89
@@ -1,89 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
// Package cmpopts provides common options for the cmp package.
|
||||
package cmpopts
|
||||
|
||||
import (
|
||||
"math"
|
||||
"reflect"
|
||||
|
||||
"github.com/google/go-cmp/cmp"
|
||||
)
|
||||
|
||||
func equateAlways(_, _ interface{}) bool { return true }
|
||||
|
||||
// EquateEmpty returns a Comparer option that determines all maps and slices
|
||||
// with a length of zero to be equal, regardless of whether they are nil.
|
||||
//
|
||||
// EquateEmpty can be used in conjuction with SortSlices and SortMaps.
|
||||
func EquateEmpty() cmp.Option {
|
||||
return cmp.FilterValues(isEmpty, cmp.Comparer(equateAlways))
|
||||
}
|
||||
|
||||
func isEmpty(x, y interface{}) bool {
|
||||
vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
|
||||
return (x != nil && y != nil && vx.Type() == vy.Type()) &&
|
||||
(vx.Kind() == reflect.Slice || vx.Kind() == reflect.Map) &&
|
||||
(vx.Len() == 0 && vy.Len() == 0)
|
||||
}
|
||||
|
||||
// EquateApprox returns a Comparer option that determines float32 or float64
|
||||
// values to be equal if they are within a relative fraction or absolute margin.
|
||||
// This option is not used when either x or y is NaN or infinite.
|
||||
//
|
||||
// The fraction determines that the difference of two values must be within the
|
||||
// smaller fraction of the two values, while the margin determines that the two
|
||||
// values must be within some absolute margin.
|
||||
// To express only a fraction or only a margin, use 0 for the other parameter.
|
||||
// The fraction and margin must be non-negative.
|
||||
//
|
||||
// The mathematical expression used is equivalent to:
|
||||
// |x-y| ≤ max(fraction*min(|x|, |y|), margin)
|
||||
//
|
||||
// EquateApprox can be used in conjuction with EquateNaNs.
|
||||
func EquateApprox(fraction, margin float64) cmp.Option {
|
||||
if margin < 0 || fraction < 0 || math.IsNaN(margin) || math.IsNaN(fraction) {
|
||||
panic("margin or fraction must be a non-negative number")
|
||||
}
|
||||
a := approximator{fraction, margin}
|
||||
return cmp.Options{
|
||||
cmp.FilterValues(areRealF64s, cmp.Comparer(a.compareF64)),
|
||||
cmp.FilterValues(areRealF32s, cmp.Comparer(a.compareF32)),
|
||||
}
|
||||
}
|
||||
|
||||
type approximator struct{ frac, marg float64 }
|
||||
|
||||
func areRealF64s(x, y float64) bool {
|
||||
return !math.IsNaN(x) && !math.IsNaN(y) && !math.IsInf(x, 0) && !math.IsInf(y, 0)
|
||||
}
|
||||
func areRealF32s(x, y float32) bool {
|
||||
return areRealF64s(float64(x), float64(y))
|
||||
}
|
||||
func (a approximator) compareF64(x, y float64) bool {
|
||||
relMarg := a.frac * math.Min(math.Abs(x), math.Abs(y))
|
||||
return math.Abs(x-y) <= math.Max(a.marg, relMarg)
|
||||
}
|
||||
func (a approximator) compareF32(x, y float32) bool {
|
||||
return a.compareF64(float64(x), float64(y))
|
||||
}
|
||||
|
||||
// EquateNaNs returns a Comparer option that determines float32 and float64
|
||||
// NaN values to be equal.
|
||||
//
|
||||
// EquateNaNs can be used in conjuction with EquateApprox.
|
||||
func EquateNaNs() cmp.Option {
|
||||
return cmp.Options{
|
||||
cmp.FilterValues(areNaNsF64s, cmp.Comparer(equateAlways)),
|
||||
cmp.FilterValues(areNaNsF32s, cmp.Comparer(equateAlways)),
|
||||
}
|
||||
}
|
||||
|
||||
func areNaNsF64s(x, y float64) bool {
|
||||
return math.IsNaN(x) && math.IsNaN(y)
|
||||
}
|
||||
func areNaNsF32s(x, y float32) bool {
|
||||
return areNaNsF64s(float64(x), float64(y))
|
||||
}
|
||||
-148
@@ -1,148 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package cmpopts
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"unicode"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/google/go-cmp/cmp"
|
||||
)
|
||||
|
||||
// IgnoreFields returns an Option that ignores exported fields of the
|
||||
// given names on a single struct type.
|
||||
// The struct type is specified by passing in a value of that type.
|
||||
//
|
||||
// The name may be a dot-delimited string (e.g., "Foo.Bar") to ignore a
|
||||
// specific sub-field that is embedded or nested within the parent struct.
|
||||
//
|
||||
// This does not handle unexported fields; use IgnoreUnexported instead.
|
||||
func IgnoreFields(typ interface{}, names ...string) cmp.Option {
|
||||
sf := newStructFilter(typ, names...)
|
||||
return cmp.FilterPath(sf.filter, cmp.Ignore())
|
||||
}
|
||||
|
||||
// IgnoreTypes returns an Option that ignores all values assignable to
|
||||
// certain types, which are specified by passing in a value of each type.
|
||||
func IgnoreTypes(typs ...interface{}) cmp.Option {
|
||||
tf := newTypeFilter(typs...)
|
||||
return cmp.FilterPath(tf.filter, cmp.Ignore())
|
||||
}
|
||||
|
||||
type typeFilter []reflect.Type
|
||||
|
||||
func newTypeFilter(typs ...interface{}) (tf typeFilter) {
|
||||
for _, typ := range typs {
|
||||
t := reflect.TypeOf(typ)
|
||||
if t == nil {
|
||||
// This occurs if someone tries to pass in sync.Locker(nil)
|
||||
panic("cannot determine type; consider using IgnoreInterfaces")
|
||||
}
|
||||
tf = append(tf, t)
|
||||
}
|
||||
return tf
|
||||
}
|
||||
func (tf typeFilter) filter(p cmp.Path) bool {
|
||||
if len(p) < 1 {
|
||||
return false
|
||||
}
|
||||
t := p[len(p)-1].Type()
|
||||
for _, ti := range tf {
|
||||
if t.AssignableTo(ti) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// IgnoreInterfaces returns an Option that ignores all values or references of
|
||||
// values assignable to certain interface types. These interfaces are specified
|
||||
// by passing in an anonymous struct with the interface types embedded in it.
|
||||
// For example, to ignore sync.Locker, pass in struct{sync.Locker}{}.
|
||||
func IgnoreInterfaces(ifaces interface{}) cmp.Option {
|
||||
tf := newIfaceFilter(ifaces)
|
||||
return cmp.FilterPath(tf.filter, cmp.Ignore())
|
||||
}
|
||||
|
||||
type ifaceFilter []reflect.Type
|
||||
|
||||
func newIfaceFilter(ifaces interface{}) (tf ifaceFilter) {
|
||||
t := reflect.TypeOf(ifaces)
|
||||
if ifaces == nil || t.Name() != "" || t.Kind() != reflect.Struct {
|
||||
panic("input must be an anonymous struct")
|
||||
}
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
fi := t.Field(i)
|
||||
switch {
|
||||
case !fi.Anonymous:
|
||||
panic("struct cannot have named fields")
|
||||
case fi.Type.Kind() != reflect.Interface:
|
||||
panic("embedded field must be an interface type")
|
||||
case fi.Type.NumMethod() == 0:
|
||||
// This matches everything; why would you ever want this?
|
||||
panic("cannot ignore empty interface")
|
||||
default:
|
||||
tf = append(tf, fi.Type)
|
||||
}
|
||||
}
|
||||
return tf
|
||||
}
|
||||
func (tf ifaceFilter) filter(p cmp.Path) bool {
|
||||
if len(p) < 1 {
|
||||
return false
|
||||
}
|
||||
t := p[len(p)-1].Type()
|
||||
for _, ti := range tf {
|
||||
if t.AssignableTo(ti) {
|
||||
return true
|
||||
}
|
||||
if t.Kind() != reflect.Ptr && reflect.PtrTo(t).AssignableTo(ti) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// IgnoreUnexported returns an Option that only ignores the immediate unexported
|
||||
// fields of a struct, including anonymous fields of unexported types.
|
||||
// In particular, unexported fields within the struct's exported fields
|
||||
// of struct types, including anonymous fields, will not be ignored unless the
|
||||
// type of the field itself is also passed to IgnoreUnexported.
|
||||
func IgnoreUnexported(typs ...interface{}) cmp.Option {
|
||||
ux := newUnexportedFilter(typs...)
|
||||
return cmp.FilterPath(ux.filter, cmp.Ignore())
|
||||
}
|
||||
|
||||
type unexportedFilter struct{ m map[reflect.Type]bool }
|
||||
|
||||
func newUnexportedFilter(typs ...interface{}) unexportedFilter {
|
||||
ux := unexportedFilter{m: make(map[reflect.Type]bool)}
|
||||
for _, typ := range typs {
|
||||
t := reflect.TypeOf(typ)
|
||||
if t == nil || t.Kind() != reflect.Struct {
|
||||
panic(fmt.Sprintf("invalid struct type: %T", typ))
|
||||
}
|
||||
ux.m[t] = true
|
||||
}
|
||||
return ux
|
||||
}
|
||||
func (xf unexportedFilter) filter(p cmp.Path) bool {
|
||||
if len(p) < 2 {
|
||||
return false
|
||||
}
|
||||
sf, ok := p[len(p)-1].(cmp.StructField)
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
return xf.m[p[len(p)-2].Type()] && !isExported(sf.Name())
|
||||
}
|
||||
|
||||
// isExported reports whether the identifier is exported.
|
||||
func isExported(id string) bool {
|
||||
r, _ := utf8.DecodeRuneInString(id)
|
||||
return unicode.IsUpper(r)
|
||||
}
|
||||
-146
@@ -1,146 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package cmpopts
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
|
||||
"github.com/google/go-cmp/cmp"
|
||||
"github.com/google/go-cmp/cmp/internal/function"
|
||||
)
|
||||
|
||||
// SortSlices returns a Transformer option that sorts all []V.
|
||||
// The less function must be of the form "func(T, T) bool" which is used to
|
||||
// sort any slice with element type V that is assignable to T.
|
||||
//
|
||||
// The less function must be:
|
||||
// • Deterministic: less(x, y) == less(x, y)
|
||||
// • Irreflexive: !less(x, x)
|
||||
// • Transitive: if !less(x, y) and !less(y, z), then !less(x, z)
|
||||
//
|
||||
// The less function does not have to be "total". That is, if !less(x, y) and
|
||||
// !less(y, x) for two elements x and y, their relative order is maintained.
|
||||
//
|
||||
// SortSlices can be used in conjuction with EquateEmpty.
|
||||
func SortSlices(less interface{}) cmp.Option {
|
||||
vf := reflect.ValueOf(less)
|
||||
if !function.IsType(vf.Type(), function.Less) || vf.IsNil() {
|
||||
panic(fmt.Sprintf("invalid less function: %T", less))
|
||||
}
|
||||
ss := sliceSorter{vf.Type().In(0), vf}
|
||||
return cmp.FilterValues(ss.filter, cmp.Transformer("Sort", ss.sort))
|
||||
}
|
||||
|
||||
type sliceSorter struct {
|
||||
in reflect.Type // T
|
||||
fnc reflect.Value // func(T, T) bool
|
||||
}
|
||||
|
||||
func (ss sliceSorter) filter(x, y interface{}) bool {
|
||||
vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
|
||||
if !(x != nil && y != nil && vx.Type() == vy.Type()) ||
|
||||
!(vx.Kind() == reflect.Slice && vx.Type().Elem().AssignableTo(ss.in)) ||
|
||||
(vx.Len() <= 1 && vy.Len() <= 1) {
|
||||
return false
|
||||
}
|
||||
// Check whether the slices are already sorted to avoid an infinite
|
||||
// recursion cycle applying the same transform to itself.
|
||||
ok1 := sliceIsSorted(x, func(i, j int) bool { return ss.less(vx, i, j) })
|
||||
ok2 := sliceIsSorted(y, func(i, j int) bool { return ss.less(vy, i, j) })
|
||||
return !ok1 || !ok2
|
||||
}
|
||||
func (ss sliceSorter) sort(x interface{}) interface{} {
|
||||
src := reflect.ValueOf(x)
|
||||
dst := reflect.MakeSlice(src.Type(), src.Len(), src.Len())
|
||||
for i := 0; i < src.Len(); i++ {
|
||||
dst.Index(i).Set(src.Index(i))
|
||||
}
|
||||
sortSliceStable(dst.Interface(), func(i, j int) bool { return ss.less(dst, i, j) })
|
||||
ss.checkSort(dst)
|
||||
return dst.Interface()
|
||||
}
|
||||
func (ss sliceSorter) checkSort(v reflect.Value) {
|
||||
start := -1 // Start of a sequence of equal elements.
|
||||
for i := 1; i < v.Len(); i++ {
|
||||
if ss.less(v, i-1, i) {
|
||||
// Check that first and last elements in v[start:i] are equal.
|
||||
if start >= 0 && (ss.less(v, start, i-1) || ss.less(v, i-1, start)) {
|
||||
panic(fmt.Sprintf("incomparable values detected: want equal elements: %v", v.Slice(start, i)))
|
||||
}
|
||||
start = -1
|
||||
} else if start == -1 {
|
||||
start = i
|
||||
}
|
||||
}
|
||||
}
|
||||
func (ss sliceSorter) less(v reflect.Value, i, j int) bool {
|
||||
vx, vy := v.Index(i), v.Index(j)
|
||||
return ss.fnc.Call([]reflect.Value{vx, vy})[0].Bool()
|
||||
}
|
||||
|
||||
// SortMaps returns a Transformer option that flattens map[K]V types to be a
|
||||
// sorted []struct{K, V}. The less function must be of the form
|
||||
// "func(T, T) bool" which is used to sort any map with key K that is
|
||||
// assignable to T.
|
||||
//
|
||||
// Flattening the map into a slice has the property that cmp.Equal is able to
|
||||
// use Comparers on K or the K.Equal method if it exists.
|
||||
//
|
||||
// The less function must be:
|
||||
// • Deterministic: less(x, y) == less(x, y)
|
||||
// • Irreflexive: !less(x, x)
|
||||
// • Transitive: if !less(x, y) and !less(y, z), then !less(x, z)
|
||||
// • Total: if x != y, then either less(x, y) or less(y, x)
|
||||
//
|
||||
// SortMaps can be used in conjuction with EquateEmpty.
|
||||
func SortMaps(less interface{}) cmp.Option {
|
||||
vf := reflect.ValueOf(less)
|
||||
if !function.IsType(vf.Type(), function.Less) || vf.IsNil() {
|
||||
panic(fmt.Sprintf("invalid less function: %T", less))
|
||||
}
|
||||
ms := mapSorter{vf.Type().In(0), vf}
|
||||
return cmp.FilterValues(ms.filter, cmp.Transformer("Sort", ms.sort))
|
||||
}
|
||||
|
||||
type mapSorter struct {
|
||||
in reflect.Type // T
|
||||
fnc reflect.Value // func(T, T) bool
|
||||
}
|
||||
|
||||
func (ms mapSorter) filter(x, y interface{}) bool {
|
||||
vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
|
||||
return (x != nil && y != nil && vx.Type() == vy.Type()) &&
|
||||
(vx.Kind() == reflect.Map && vx.Type().Key().AssignableTo(ms.in)) &&
|
||||
(vx.Len() != 0 || vy.Len() != 0)
|
||||
}
|
||||
func (ms mapSorter) sort(x interface{}) interface{} {
|
||||
src := reflect.ValueOf(x)
|
||||
outType := mapEntryType(src.Type())
|
||||
dst := reflect.MakeSlice(reflect.SliceOf(outType), src.Len(), src.Len())
|
||||
for i, k := range src.MapKeys() {
|
||||
v := reflect.New(outType).Elem()
|
||||
v.Field(0).Set(k)
|
||||
v.Field(1).Set(src.MapIndex(k))
|
||||
dst.Index(i).Set(v)
|
||||
}
|
||||
sortSlice(dst.Interface(), func(i, j int) bool { return ms.less(dst, i, j) })
|
||||
ms.checkSort(dst)
|
||||
return dst.Interface()
|
||||
}
|
||||
func (ms mapSorter) checkSort(v reflect.Value) {
|
||||
for i := 1; i < v.Len(); i++ {
|
||||
if !ms.less(v, i-1, i) {
|
||||
panic(fmt.Sprintf("partial order detected: want %v < %v", v.Index(i-1), v.Index(i)))
|
||||
}
|
||||
}
|
||||
}
|
||||
func (ms mapSorter) less(v reflect.Value, i, j int) bool {
|
||||
vx, vy := v.Index(i).Field(0), v.Index(j).Field(0)
|
||||
if !hasReflectStructOf {
|
||||
vx, vy = vx.Elem(), vy.Elem()
|
||||
}
|
||||
return ms.fnc.Call([]reflect.Value{vx, vy})[0].Bool()
|
||||
}
|
||||
-46
@@ -1,46 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
// +build !go1.8
|
||||
|
||||
package cmpopts
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"sort"
|
||||
)
|
||||
|
||||
const hasReflectStructOf = false
|
||||
|
||||
func mapEntryType(reflect.Type) reflect.Type {
|
||||
return reflect.TypeOf(struct{ K, V interface{} }{})
|
||||
}
|
||||
|
||||
func sliceIsSorted(slice interface{}, less func(i, j int) bool) bool {
|
||||
return sort.IsSorted(reflectSliceSorter{reflect.ValueOf(slice), less})
|
||||
}
|
||||
func sortSlice(slice interface{}, less func(i, j int) bool) {
|
||||
sort.Sort(reflectSliceSorter{reflect.ValueOf(slice), less})
|
||||
}
|
||||
func sortSliceStable(slice interface{}, less func(i, j int) bool) {
|
||||
sort.Stable(reflectSliceSorter{reflect.ValueOf(slice), less})
|
||||
}
|
||||
|
||||
type reflectSliceSorter struct {
|
||||
slice reflect.Value
|
||||
less func(i, j int) bool
|
||||
}
|
||||
|
||||
func (ss reflectSliceSorter) Len() int {
|
||||
return ss.slice.Len()
|
||||
}
|
||||
func (ss reflectSliceSorter) Less(i, j int) bool {
|
||||
return ss.less(i, j)
|
||||
}
|
||||
func (ss reflectSliceSorter) Swap(i, j int) {
|
||||
vi := ss.slice.Index(i).Interface()
|
||||
vj := ss.slice.Index(j).Interface()
|
||||
ss.slice.Index(i).Set(reflect.ValueOf(vj))
|
||||
ss.slice.Index(j).Set(reflect.ValueOf(vi))
|
||||
}
|
||||
-31
@@ -1,31 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
// +build go1.8
|
||||
|
||||
package cmpopts
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"sort"
|
||||
)
|
||||
|
||||
const hasReflectStructOf = true
|
||||
|
||||
func mapEntryType(t reflect.Type) reflect.Type {
|
||||
return reflect.StructOf([]reflect.StructField{
|
||||
{Name: "K", Type: t.Key()},
|
||||
{Name: "V", Type: t.Elem()},
|
||||
})
|
||||
}
|
||||
|
||||
func sliceIsSorted(slice interface{}, less func(i, j int) bool) bool {
|
||||
return sort.SliceIsSorted(slice, less)
|
||||
}
|
||||
func sortSlice(slice interface{}, less func(i, j int) bool) {
|
||||
sort.Slice(slice, less)
|
||||
}
|
||||
func sortSliceStable(slice interface{}, less func(i, j int) bool) {
|
||||
sort.SliceStable(slice, less)
|
||||
}
|
||||
-182
@@ -1,182 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package cmpopts
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strings"
|
||||
|
||||
"github.com/google/go-cmp/cmp"
|
||||
)
|
||||
|
||||
// filterField returns a new Option where opt is only evaluated on paths that
|
||||
// include a specific exported field on a single struct type.
|
||||
// The struct type is specified by passing in a value of that type.
|
||||
//
|
||||
// The name may be a dot-delimited string (e.g., "Foo.Bar") to select a
|
||||
// specific sub-field that is embedded or nested within the parent struct.
|
||||
func filterField(typ interface{}, name string, opt cmp.Option) cmp.Option {
|
||||
// TODO: This is currently unexported over concerns of how helper filters
|
||||
// can be composed together easily.
|
||||
// TODO: Add tests for FilterField.
|
||||
|
||||
sf := newStructFilter(typ, name)
|
||||
return cmp.FilterPath(sf.filter, opt)
|
||||
}
|
||||
|
||||
type structFilter struct {
|
||||
t reflect.Type // The root struct type to match on
|
||||
ft fieldTree // Tree of fields to match on
|
||||
}
|
||||
|
||||
func newStructFilter(typ interface{}, names ...string) structFilter {
|
||||
// TODO: Perhaps allow * as a special identifier to allow ignoring any
|
||||
// number of path steps until the next field match?
|
||||
// This could be useful when a concrete struct gets transformed into
|
||||
// an anonymous struct where it is not possible to specify that by type,
|
||||
// but the transformer happens to provide guarantees about the names of
|
||||
// the transformed fields.
|
||||
|
||||
t := reflect.TypeOf(typ)
|
||||
if t == nil || t.Kind() != reflect.Struct {
|
||||
panic(fmt.Sprintf("%T must be a struct", typ))
|
||||
}
|
||||
var ft fieldTree
|
||||
for _, name := range names {
|
||||
cname, err := canonicalName(t, name)
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("%s: %v", strings.Join(cname, "."), err))
|
||||
}
|
||||
ft.insert(cname)
|
||||
}
|
||||
return structFilter{t, ft}
|
||||
}
|
||||
|
||||
func (sf structFilter) filter(p cmp.Path) bool {
|
||||
for i, ps := range p {
|
||||
if ps.Type().AssignableTo(sf.t) && sf.ft.matchPrefix(p[i+1:]) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// fieldTree represents a set of dot-separated identifiers.
|
||||
//
|
||||
// For example, inserting the following selectors:
|
||||
// Foo
|
||||
// Foo.Bar.Baz
|
||||
// Foo.Buzz
|
||||
// Nuka.Cola.Quantum
|
||||
//
|
||||
// Results in a tree of the form:
|
||||
// {sub: {
|
||||
// "Foo": {ok: true, sub: {
|
||||
// "Bar": {sub: {
|
||||
// "Baz": {ok: true},
|
||||
// }},
|
||||
// "Buzz": {ok: true},
|
||||
// }},
|
||||
// "Nuka": {sub: {
|
||||
// "Cola": {sub: {
|
||||
// "Quantum": {ok: true},
|
||||
// }},
|
||||
// }},
|
||||
// }}
|
||||
type fieldTree struct {
|
||||
ok bool // Whether this is a specified node
|
||||
sub map[string]fieldTree // The sub-tree of fields under this node
|
||||
}
|
||||
|
||||
// insert inserts a sequence of field accesses into the tree.
|
||||
func (ft *fieldTree) insert(cname []string) {
|
||||
if ft.sub == nil {
|
||||
ft.sub = make(map[string]fieldTree)
|
||||
}
|
||||
if len(cname) == 0 {
|
||||
ft.ok = true
|
||||
return
|
||||
}
|
||||
sub := ft.sub[cname[0]]
|
||||
sub.insert(cname[1:])
|
||||
ft.sub[cname[0]] = sub
|
||||
}
|
||||
|
||||
// matchPrefix reports whether any selector in the fieldTree matches
|
||||
// the start of path p.
|
||||
func (ft fieldTree) matchPrefix(p cmp.Path) bool {
|
||||
for _, ps := range p {
|
||||
switch ps := ps.(type) {
|
||||
case cmp.StructField:
|
||||
ft = ft.sub[ps.Name()]
|
||||
if ft.ok {
|
||||
return true
|
||||
}
|
||||
if len(ft.sub) == 0 {
|
||||
return false
|
||||
}
|
||||
case cmp.Indirect:
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// canonicalName returns a list of identifiers where any struct field access
|
||||
// through an embedded field is expanded to include the names of the embedded
|
||||
// types themselves.
|
||||
//
|
||||
// For example, suppose field "Foo" is not directly in the parent struct,
|
||||
// but actually from an embedded struct of type "Bar". Then, the canonical name
|
||||
// of "Foo" is actually "Bar.Foo".
|
||||
//
|
||||
// Suppose field "Foo" is not directly in the parent struct, but actually
|
||||
// a field in two different embedded structs of types "Bar" and "Baz".
|
||||
// Then the selector "Foo" causes a panic since it is ambiguous which one it
|
||||
// refers to. The user must specify either "Bar.Foo" or "Baz.Foo".
|
||||
func canonicalName(t reflect.Type, sel string) ([]string, error) {
|
||||
var name string
|
||||
sel = strings.TrimPrefix(sel, ".")
|
||||
if sel == "" {
|
||||
return nil, fmt.Errorf("name must not be empty")
|
||||
}
|
||||
if i := strings.IndexByte(sel, '.'); i < 0 {
|
||||
name, sel = sel, ""
|
||||
} else {
|
||||
name, sel = sel[:i], sel[i:]
|
||||
}
|
||||
|
||||
// Type must be a struct or pointer to struct.
|
||||
if t.Kind() == reflect.Ptr {
|
||||
t = t.Elem()
|
||||
}
|
||||
if t.Kind() != reflect.Struct {
|
||||
return nil, fmt.Errorf("%v must be a struct", t)
|
||||
}
|
||||
|
||||
// Find the canonical name for this current field name.
|
||||
// If the field exists in an embedded struct, then it will be expanded.
|
||||
if !isExported(name) {
|
||||
// Disallow unexported fields:
|
||||
// * To discourage people from actually touching unexported fields
|
||||
// * FieldByName is buggy (https://golang.org/issue/4876)
|
||||
return []string{name}, fmt.Errorf("name must be exported")
|
||||
}
|
||||
sf, ok := t.FieldByName(name)
|
||||
if !ok {
|
||||
return []string{name}, fmt.Errorf("does not exist")
|
||||
}
|
||||
var ss []string
|
||||
for i := range sf.Index {
|
||||
ss = append(ss, t.FieldByIndex(sf.Index[:i+1]).Name)
|
||||
}
|
||||
if sel == "" {
|
||||
return ss, nil
|
||||
}
|
||||
ssPost, err := canonicalName(sf.Type, sel)
|
||||
return append(ss, ssPost...), err
|
||||
}
|
||||
-996
@@ -1,996 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package cmpopts
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
"math"
|
||||
"reflect"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/google/go-cmp/cmp"
|
||||
)
|
||||
|
||||
type (
|
||||
MyInt int
|
||||
MyFloat float32
|
||||
MyTime struct{ time.Time }
|
||||
MyStruct struct {
|
||||
A, B []int
|
||||
C, D map[time.Time]string
|
||||
}
|
||||
|
||||
Foo1 struct{ Alpha, Bravo, Charlie int }
|
||||
Foo2 struct{ *Foo1 }
|
||||
Foo3 struct{ *Foo2 }
|
||||
Bar1 struct{ Foo3 }
|
||||
Bar2 struct {
|
||||
Bar1
|
||||
*Foo3
|
||||
Bravo float32
|
||||
}
|
||||
Bar3 struct {
|
||||
Bar1
|
||||
Bravo *Bar2
|
||||
Delta struct{ Echo Foo1 }
|
||||
*Foo3
|
||||
Alpha string
|
||||
}
|
||||
|
||||
privateStruct struct{ Public, private int }
|
||||
PublicStruct struct{ Public, private int }
|
||||
ParentStruct struct {
|
||||
*privateStruct
|
||||
*PublicStruct
|
||||
Public int
|
||||
private int
|
||||
}
|
||||
|
||||
Everything struct {
|
||||
MyInt
|
||||
MyFloat
|
||||
MyTime
|
||||
MyStruct
|
||||
Bar3
|
||||
ParentStruct
|
||||
}
|
||||
|
||||
EmptyInterface interface{}
|
||||
)
|
||||
|
||||
func TestOptions(t *testing.T) {
|
||||
createBar3X := func() *Bar3 {
|
||||
return &Bar3{
|
||||
Bar1: Bar1{Foo3{&Foo2{&Foo1{Bravo: 2}}}},
|
||||
Bravo: &Bar2{
|
||||
Bar1: Bar1{Foo3{&Foo2{&Foo1{Charlie: 7}}}},
|
||||
Foo3: &Foo3{&Foo2{&Foo1{Bravo: 5}}},
|
||||
Bravo: 4,
|
||||
},
|
||||
Delta: struct{ Echo Foo1 }{Foo1{Charlie: 3}},
|
||||
Foo3: &Foo3{&Foo2{&Foo1{Alpha: 1}}},
|
||||
Alpha: "alpha",
|
||||
}
|
||||
}
|
||||
createBar3Y := func() *Bar3 {
|
||||
return &Bar3{
|
||||
Bar1: Bar1{Foo3{&Foo2{&Foo1{Bravo: 3}}}},
|
||||
Bravo: &Bar2{
|
||||
Bar1: Bar1{Foo3{&Foo2{&Foo1{Charlie: 8}}}},
|
||||
Foo3: &Foo3{&Foo2{&Foo1{Bravo: 6}}},
|
||||
Bravo: 5,
|
||||
},
|
||||
Delta: struct{ Echo Foo1 }{Foo1{Charlie: 4}},
|
||||
Foo3: &Foo3{&Foo2{&Foo1{Alpha: 2}}},
|
||||
Alpha: "ALPHA",
|
||||
}
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
label string // Test name
|
||||
x, y interface{} // Input values to compare
|
||||
opts []cmp.Option // Input options
|
||||
wantEqual bool // Whether the inputs are equal
|
||||
wantPanic bool // Whether Equal should panic
|
||||
reason string // The reason for the expected outcome
|
||||
}{{
|
||||
label: "EquateEmpty",
|
||||
x: []int{},
|
||||
y: []int(nil),
|
||||
wantEqual: false,
|
||||
reason: "not equal because empty non-nil and nil slice differ",
|
||||
}, {
|
||||
label: "EquateEmpty",
|
||||
x: []int{},
|
||||
y: []int(nil),
|
||||
opts: []cmp.Option{EquateEmpty()},
|
||||
wantEqual: true,
|
||||
reason: "equal because EquateEmpty equates empty slices",
|
||||
}, {
|
||||
label: "SortSlices",
|
||||
x: []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
|
||||
y: []int{1, 0, 5, 2, 8, 9, 4, 3, 6, 7},
|
||||
wantEqual: false,
|
||||
reason: "not equal because element order differs",
|
||||
}, {
|
||||
label: "SortSlices",
|
||||
x: []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
|
||||
y: []int{1, 0, 5, 2, 8, 9, 4, 3, 6, 7},
|
||||
opts: []cmp.Option{SortSlices(func(x, y int) bool { return x < y })},
|
||||
wantEqual: true,
|
||||
reason: "equal because SortSlices sorts the slices",
|
||||
}, {
|
||||
label: "SortSlices",
|
||||
x: []MyInt{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
|
||||
y: []MyInt{1, 0, 5, 2, 8, 9, 4, 3, 6, 7},
|
||||
opts: []cmp.Option{SortSlices(func(x, y int) bool { return x < y })},
|
||||
wantEqual: false,
|
||||
reason: "not equal because MyInt is not the same type as int",
|
||||
}, {
|
||||
label: "SortSlices",
|
||||
x: []float64{0, 1, 1, 2, 2, 2},
|
||||
y: []float64{2, 0, 2, 1, 2, 1},
|
||||
opts: []cmp.Option{SortSlices(func(x, y float64) bool { return x < y })},
|
||||
wantEqual: true,
|
||||
reason: "equal even when sorted with duplicate elements",
|
||||
}, {
|
||||
label: "SortSlices",
|
||||
x: []float64{0, 1, 1, 2, 2, 2, math.NaN(), 3, 3, 3, 3, 4, 4, 4, 4},
|
||||
y: []float64{2, 0, 4, 4, 3, math.NaN(), 4, 1, 3, 2, 3, 3, 4, 1, 2},
|
||||
opts: []cmp.Option{SortSlices(func(x, y float64) bool { return x < y })},
|
||||
wantPanic: true,
|
||||
reason: "panics because SortSlices used with non-transitive less function",
|
||||
}, {
|
||||
label: "SortSlices",
|
||||
x: []float64{0, 1, 1, 2, 2, 2, math.NaN(), 3, 3, 3, 3, 4, 4, 4, 4},
|
||||
y: []float64{2, 0, 4, 4, 3, math.NaN(), 4, 1, 3, 2, 3, 3, 4, 1, 2},
|
||||
opts: []cmp.Option{SortSlices(func(x, y float64) bool {
|
||||
return (!math.IsNaN(x) && math.IsNaN(y)) || x < y
|
||||
})},
|
||||
wantEqual: false,
|
||||
reason: "no panics because SortSlices used with valid less function; not equal because NaN != NaN",
|
||||
}, {
|
||||
label: "SortSlices+EquateNaNs",
|
||||
x: []float64{0, 1, 1, 2, 2, 2, math.NaN(), 3, 3, 3, math.NaN(), 3, 4, 4, 4, 4},
|
||||
y: []float64{2, 0, 4, 4, 3, math.NaN(), 4, 1, 3, 2, 3, 3, 4, 1, math.NaN(), 2},
|
||||
opts: []cmp.Option{
|
||||
EquateNaNs(),
|
||||
SortSlices(func(x, y float64) bool {
|
||||
return (!math.IsNaN(x) && math.IsNaN(y)) || x < y
|
||||
}),
|
||||
},
|
||||
wantEqual: true,
|
||||
reason: "no panics because SortSlices used with valid less function; equal because EquateNaNs is used",
|
||||
}, {
|
||||
label: "SortMaps",
|
||||
x: map[time.Time]string{
|
||||
time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC): "0th birthday",
|
||||
time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC): "1st birthday",
|
||||
time.Date(2011, time.November, 10, 23, 0, 0, 0, time.UTC): "2nd birthday",
|
||||
},
|
||||
y: map[time.Time]string{
|
||||
time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "0th birthday",
|
||||
time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "1st birthday",
|
||||
time.Date(2011, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "2nd birthday",
|
||||
},
|
||||
wantEqual: false,
|
||||
reason: "not equal because timezones differ",
|
||||
}, {
|
||||
label: "SortMaps",
|
||||
x: map[time.Time]string{
|
||||
time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC): "0th birthday",
|
||||
time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC): "1st birthday",
|
||||
time.Date(2011, time.November, 10, 23, 0, 0, 0, time.UTC): "2nd birthday",
|
||||
},
|
||||
y: map[time.Time]string{
|
||||
time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "0th birthday",
|
||||
time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "1st birthday",
|
||||
time.Date(2011, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "2nd birthday",
|
||||
},
|
||||
opts: []cmp.Option{SortMaps(func(x, y time.Time) bool { return x.Before(y) })},
|
||||
wantEqual: true,
|
||||
reason: "equal because SortMaps flattens to a slice where Time.Equal can be used",
|
||||
}, {
|
||||
label: "SortMaps",
|
||||
x: map[MyTime]string{
|
||||
{time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)}: "0th birthday",
|
||||
{time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC)}: "1st birthday",
|
||||
{time.Date(2011, time.November, 10, 23, 0, 0, 0, time.UTC)}: "2nd birthday",
|
||||
},
|
||||
y: map[MyTime]string{
|
||||
{time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local)}: "0th birthday",
|
||||
{time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local)}: "1st birthday",
|
||||
{time.Date(2011, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local)}: "2nd birthday",
|
||||
},
|
||||
opts: []cmp.Option{SortMaps(func(x, y time.Time) bool { return x.Before(y) })},
|
||||
wantEqual: false,
|
||||
reason: "not equal because MyTime is not assignable to time.Time",
|
||||
}, {
|
||||
label: "SortMaps",
|
||||
x: map[int]string{-3: "", -2: "", -1: "", 0: "", 1: "", 2: "", 3: ""},
|
||||
// => {0, 1, 2, 3, -1, -2, -3},
|
||||
y: map[int]string{300: "", 200: "", 100: "", 0: "", 1: "", 2: "", 3: ""},
|
||||
// => {0, 1, 2, 3, 100, 200, 300},
|
||||
opts: []cmp.Option{SortMaps(func(a, b int) bool {
|
||||
if -10 < a && a <= 0 {
|
||||
a *= -100
|
||||
}
|
||||
if -10 < b && b <= 0 {
|
||||
b *= -100
|
||||
}
|
||||
return a < b
|
||||
})},
|
||||
wantEqual: false,
|
||||
reason: "not equal because values differ even though SortMap provides valid ordering",
|
||||
}, {
|
||||
label: "SortMaps",
|
||||
x: map[int]string{-3: "", -2: "", -1: "", 0: "", 1: "", 2: "", 3: ""},
|
||||
// => {0, 1, 2, 3, -1, -2, -3},
|
||||
y: map[int]string{300: "", 200: "", 100: "", 0: "", 1: "", 2: "", 3: ""},
|
||||
// => {0, 1, 2, 3, 100, 200, 300},
|
||||
opts: []cmp.Option{
|
||||
SortMaps(func(x, y int) bool {
|
||||
if -10 < x && x <= 0 {
|
||||
x *= -100
|
||||
}
|
||||
if -10 < y && y <= 0 {
|
||||
y *= -100
|
||||
}
|
||||
return x < y
|
||||
}),
|
||||
cmp.Comparer(func(x, y int) bool {
|
||||
if -10 < x && x <= 0 {
|
||||
x *= -100
|
||||
}
|
||||
if -10 < y && y <= 0 {
|
||||
y *= -100
|
||||
}
|
||||
return x == y
|
||||
}),
|
||||
},
|
||||
wantEqual: true,
|
||||
reason: "equal because Comparer used to equate differences",
|
||||
}, {
|
||||
label: "SortMaps",
|
||||
x: map[int]string{-3: "", -2: "", -1: "", 0: "", 1: "", 2: "", 3: ""},
|
||||
y: map[int]string{},
|
||||
opts: []cmp.Option{SortMaps(func(x, y int) bool {
|
||||
return x < y && x >= 0 && y >= 0
|
||||
})},
|
||||
wantPanic: true,
|
||||
reason: "panics because SortMaps used with non-transitive less function",
|
||||
}, {
|
||||
label: "SortMaps",
|
||||
x: map[int]string{-3: "", -2: "", -1: "", 0: "", 1: "", 2: "", 3: ""},
|
||||
y: map[int]string{},
|
||||
opts: []cmp.Option{SortMaps(func(x, y int) bool {
|
||||
return math.Abs(float64(x)) < math.Abs(float64(y))
|
||||
})},
|
||||
wantPanic: true,
|
||||
reason: "panics because SortMaps used with partial less function",
|
||||
}, {
|
||||
label: "EquateEmpty+SortSlices+SortMaps",
|
||||
x: MyStruct{
|
||||
A: []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
|
||||
C: map[time.Time]string{
|
||||
time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC): "0th birthday",
|
||||
time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC): "1st birthday",
|
||||
},
|
||||
D: map[time.Time]string{},
|
||||
},
|
||||
y: MyStruct{
|
||||
A: []int{1, 0, 5, 2, 8, 9, 4, 3, 6, 7},
|
||||
B: []int{},
|
||||
C: map[time.Time]string{
|
||||
time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "0th birthday",
|
||||
time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC).In(time.Local): "1st birthday",
|
||||
},
|
||||
},
|
||||
opts: []cmp.Option{
|
||||
EquateEmpty(),
|
||||
SortSlices(func(x, y int) bool { return x < y }),
|
||||
SortMaps(func(x, y time.Time) bool { return x.Before(y) }),
|
||||
},
|
||||
wantEqual: true,
|
||||
reason: "no panics because EquateEmpty should compose with the sort options",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: 3.09,
|
||||
y: 3.10,
|
||||
wantEqual: false,
|
||||
reason: "not equal because floats do not exactly matches",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: 3.09,
|
||||
y: 3.10,
|
||||
opts: []cmp.Option{EquateApprox(0, 0)},
|
||||
wantEqual: false,
|
||||
reason: "not equal because EquateApprox(0 ,0) is equivalent to using ==",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: 3.09,
|
||||
y: 3.10,
|
||||
opts: []cmp.Option{EquateApprox(0.003, 0.009)},
|
||||
wantEqual: false,
|
||||
reason: "not equal because EquateApprox is too strict",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: 3.09,
|
||||
y: 3.10,
|
||||
opts: []cmp.Option{EquateApprox(0, 0.011)},
|
||||
wantEqual: true,
|
||||
reason: "equal because margin is loose enough to match",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: 3.09,
|
||||
y: 3.10,
|
||||
opts: []cmp.Option{EquateApprox(0.004, 0)},
|
||||
wantEqual: true,
|
||||
reason: "equal because fraction is loose enough to match",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: 3.09,
|
||||
y: 3.10,
|
||||
opts: []cmp.Option{EquateApprox(0.004, 0.011)},
|
||||
wantEqual: true,
|
||||
reason: "equal because both the margin and fraction are loose enough to match",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: float32(3.09),
|
||||
y: float64(3.10),
|
||||
opts: []cmp.Option{EquateApprox(0.004, 0)},
|
||||
wantEqual: false,
|
||||
reason: "not equal because the types differ",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: float32(3.09),
|
||||
y: float32(3.10),
|
||||
opts: []cmp.Option{EquateApprox(0.004, 0)},
|
||||
wantEqual: true,
|
||||
reason: "equal because EquateApprox also applies on float32s",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: []float64{math.Inf(+1), math.Inf(-1)},
|
||||
y: []float64{math.Inf(+1), math.Inf(-1)},
|
||||
opts: []cmp.Option{EquateApprox(0, 1)},
|
||||
wantEqual: true,
|
||||
reason: "equal because we fall back on == which matches Inf (EquateApprox does not apply on Inf) ",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: []float64{math.Inf(+1), -1e100},
|
||||
y: []float64{+1e100, math.Inf(-1)},
|
||||
opts: []cmp.Option{EquateApprox(0, 1)},
|
||||
wantEqual: false,
|
||||
reason: "not equal because we fall back on == where Inf != 1e100 (EquateApprox does not apply on Inf)",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: float64(+1e100),
|
||||
y: float64(-1e100),
|
||||
opts: []cmp.Option{EquateApprox(math.Inf(+1), 0)},
|
||||
wantEqual: true,
|
||||
reason: "equal because infinite fraction matches everything",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: float64(+1e100),
|
||||
y: float64(-1e100),
|
||||
opts: []cmp.Option{EquateApprox(0, math.Inf(+1))},
|
||||
wantEqual: true,
|
||||
reason: "equal because infinite margin matches everything",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: math.Pi,
|
||||
y: math.Pi,
|
||||
opts: []cmp.Option{EquateApprox(0, 0)},
|
||||
wantEqual: true,
|
||||
reason: "equal because EquateApprox(0, 0) is equivalent to ==",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
x: math.Pi,
|
||||
y: math.Nextafter(math.Pi, math.Inf(+1)),
|
||||
opts: []cmp.Option{EquateApprox(0, 0)},
|
||||
wantEqual: false,
|
||||
reason: "not equal because EquateApprox(0, 0) is equivalent to ==",
|
||||
}, {
|
||||
label: "EquateNaNs",
|
||||
x: []float64{1.0, math.NaN(), math.E, -0.0, +0.0, math.Inf(+1), math.Inf(-1)},
|
||||
y: []float64{1.0, math.NaN(), math.E, -0.0, +0.0, math.Inf(+1), math.Inf(-1)},
|
||||
wantEqual: false,
|
||||
reason: "not equal because NaN != NaN",
|
||||
}, {
|
||||
label: "EquateNaNs",
|
||||
x: []float64{1.0, math.NaN(), math.E, -0.0, +0.0, math.Inf(+1), math.Inf(-1)},
|
||||
y: []float64{1.0, math.NaN(), math.E, -0.0, +0.0, math.Inf(+1), math.Inf(-1)},
|
||||
opts: []cmp.Option{EquateNaNs()},
|
||||
wantEqual: true,
|
||||
reason: "equal because EquateNaNs allows NaN == NaN",
|
||||
}, {
|
||||
label: "EquateNaNs",
|
||||
x: []float32{1.0, float32(math.NaN()), math.E, -0.0, +0.0},
|
||||
y: []float32{1.0, float32(math.NaN()), math.E, -0.0, +0.0},
|
||||
opts: []cmp.Option{EquateNaNs()},
|
||||
wantEqual: true,
|
||||
reason: "equal because EquateNaNs operates on float32",
|
||||
}, {
|
||||
label: "EquateApprox+EquateNaNs",
|
||||
x: []float64{1.0, math.NaN(), math.E, -0.0, +0.0, math.Inf(+1), math.Inf(-1), 1.01, 5001},
|
||||
y: []float64{1.0, math.NaN(), math.E, -0.0, +0.0, math.Inf(+1), math.Inf(-1), 1.02, 5002},
|
||||
opts: []cmp.Option{
|
||||
EquateNaNs(),
|
||||
EquateApprox(0.01, 0),
|
||||
},
|
||||
wantEqual: true,
|
||||
reason: "equal because EquateNaNs and EquateApprox compose together",
|
||||
}, {
|
||||
label: "EquateApprox+EquateNaNs",
|
||||
x: []MyFloat{1.0, MyFloat(math.NaN()), MyFloat(math.E), -0.0, +0.0, MyFloat(math.Inf(+1)), MyFloat(math.Inf(-1)), 1.01, 5001},
|
||||
y: []MyFloat{1.0, MyFloat(math.NaN()), MyFloat(math.E), -0.0, +0.0, MyFloat(math.Inf(+1)), MyFloat(math.Inf(-1)), 1.02, 5002},
|
||||
opts: []cmp.Option{
|
||||
EquateNaNs(),
|
||||
EquateApprox(0.01, 0),
|
||||
},
|
||||
wantEqual: false,
|
||||
reason: "not equal because EquateApprox and EquateNaNs do not apply on a named type",
|
||||
}, {
|
||||
label: "EquateApprox+EquateNaNs+Transform",
|
||||
x: []MyFloat{1.0, MyFloat(math.NaN()), MyFloat(math.E), -0.0, +0.0, MyFloat(math.Inf(+1)), MyFloat(math.Inf(-1)), 1.01, 5001},
|
||||
y: []MyFloat{1.0, MyFloat(math.NaN()), MyFloat(math.E), -0.0, +0.0, MyFloat(math.Inf(+1)), MyFloat(math.Inf(-1)), 1.02, 5002},
|
||||
opts: []cmp.Option{
|
||||
cmp.Transformer("", func(x MyFloat) float64 { return float64(x) }),
|
||||
EquateNaNs(),
|
||||
EquateApprox(0.01, 0),
|
||||
},
|
||||
wantEqual: true,
|
||||
reason: "equal because named type is transformed to float64",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
x: Bar1{Foo3{&Foo2{&Foo1{Alpha: 5}}}},
|
||||
y: Bar1{Foo3{&Foo2{&Foo1{Alpha: 6}}}},
|
||||
wantEqual: false,
|
||||
reason: "not equal because values do not match in deeply embedded field",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
x: Bar1{Foo3{&Foo2{&Foo1{Alpha: 5}}}},
|
||||
y: Bar1{Foo3{&Foo2{&Foo1{Alpha: 6}}}},
|
||||
opts: []cmp.Option{IgnoreFields(Bar1{}, "Alpha")},
|
||||
wantEqual: true,
|
||||
reason: "equal because IgnoreField ignores deeply embedded field: Alpha",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
x: Bar1{Foo3{&Foo2{&Foo1{Alpha: 5}}}},
|
||||
y: Bar1{Foo3{&Foo2{&Foo1{Alpha: 6}}}},
|
||||
opts: []cmp.Option{IgnoreFields(Bar1{}, "Foo1.Alpha")},
|
||||
wantEqual: true,
|
||||
reason: "equal because IgnoreField ignores deeply embedded field: Foo1.Alpha",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
x: Bar1{Foo3{&Foo2{&Foo1{Alpha: 5}}}},
|
||||
y: Bar1{Foo3{&Foo2{&Foo1{Alpha: 6}}}},
|
||||
opts: []cmp.Option{IgnoreFields(Bar1{}, "Foo2.Alpha")},
|
||||
wantEqual: true,
|
||||
reason: "equal because IgnoreField ignores deeply embedded field: Foo2.Alpha",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
x: Bar1{Foo3{&Foo2{&Foo1{Alpha: 5}}}},
|
||||
y: Bar1{Foo3{&Foo2{&Foo1{Alpha: 6}}}},
|
||||
opts: []cmp.Option{IgnoreFields(Bar1{}, "Foo3.Alpha")},
|
||||
wantEqual: true,
|
||||
reason: "equal because IgnoreField ignores deeply embedded field: Foo3.Alpha",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
x: Bar1{Foo3{&Foo2{&Foo1{Alpha: 5}}}},
|
||||
y: Bar1{Foo3{&Foo2{&Foo1{Alpha: 6}}}},
|
||||
opts: []cmp.Option{IgnoreFields(Bar1{}, "Foo3.Foo2.Alpha")},
|
||||
wantEqual: true,
|
||||
reason: "equal because IgnoreField ignores deeply embedded field: Foo3.Foo2.Alpha",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
x: createBar3X(),
|
||||
y: createBar3Y(),
|
||||
wantEqual: false,
|
||||
reason: "not equal because many deeply nested or embedded fields differ",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
x: createBar3X(),
|
||||
y: createBar3Y(),
|
||||
opts: []cmp.Option{IgnoreFields(Bar3{}, "Bar1", "Bravo", "Delta", "Foo3", "Alpha")},
|
||||
wantEqual: true,
|
||||
reason: "equal because IgnoreFields ignores fields at the highest levels",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
x: createBar3X(),
|
||||
y: createBar3Y(),
|
||||
opts: []cmp.Option{
|
||||
IgnoreFields(Bar3{},
|
||||
"Bar1.Foo3.Bravo",
|
||||
"Bravo.Bar1.Foo3.Foo2.Foo1.Charlie",
|
||||
"Bravo.Foo3.Foo2.Foo1.Bravo",
|
||||
"Bravo.Bravo",
|
||||
"Delta.Echo.Charlie",
|
||||
"Foo3.Foo2.Foo1.Alpha",
|
||||
"Alpha",
|
||||
),
|
||||
},
|
||||
wantEqual: true,
|
||||
reason: "equal because IgnoreFields ignores fields using fully-qualified field",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
x: createBar3X(),
|
||||
y: createBar3Y(),
|
||||
opts: []cmp.Option{
|
||||
IgnoreFields(Bar3{},
|
||||
"Bar1.Foo3.Bravo",
|
||||
"Bravo.Foo3.Foo2.Foo1.Bravo",
|
||||
"Bravo.Bravo",
|
||||
"Delta.Echo.Charlie",
|
||||
"Foo3.Foo2.Foo1.Alpha",
|
||||
"Alpha",
|
||||
),
|
||||
},
|
||||
wantEqual: false,
|
||||
reason: "not equal because one fully-qualified field is not ignored: Bravo.Bar1.Foo3.Foo2.Foo1.Charlie",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
x: createBar3X(),
|
||||
y: createBar3Y(),
|
||||
opts: []cmp.Option{IgnoreFields(Bar3{}, "Bar1", "Bravo", "Delta", "Alpha")},
|
||||
wantEqual: false,
|
||||
reason: "not equal because highest-level field is not ignored: Foo3",
|
||||
}, {
|
||||
label: "IgnoreTypes",
|
||||
x: []interface{}{5, "same"},
|
||||
y: []interface{}{6, "same"},
|
||||
wantEqual: false,
|
||||
reason: "not equal because 5 != 6",
|
||||
}, {
|
||||
label: "IgnoreTypes",
|
||||
x: []interface{}{5, "same"},
|
||||
y: []interface{}{6, "same"},
|
||||
opts: []cmp.Option{IgnoreTypes(0)},
|
||||
wantEqual: true,
|
||||
reason: "equal because ints are ignored",
|
||||
}, {
|
||||
label: "IgnoreTypes+IgnoreInterfaces",
|
||||
x: []interface{}{5, "same", new(bytes.Buffer)},
|
||||
y: []interface{}{6, "same", new(bytes.Buffer)},
|
||||
opts: []cmp.Option{IgnoreTypes(0)},
|
||||
wantPanic: true,
|
||||
reason: "panics because bytes.Buffer has unexported fields",
|
||||
}, {
|
||||
label: "IgnoreTypes+IgnoreInterfaces",
|
||||
x: []interface{}{5, "same", new(bytes.Buffer)},
|
||||
y: []interface{}{6, "diff", new(bytes.Buffer)},
|
||||
opts: []cmp.Option{
|
||||
IgnoreTypes(0, ""),
|
||||
IgnoreInterfaces(struct{ io.Reader }{}),
|
||||
},
|
||||
wantEqual: true,
|
||||
reason: "equal because bytes.Buffer is ignored by match on interface type",
|
||||
}, {
|
||||
label: "IgnoreTypes+IgnoreInterfaces",
|
||||
x: []interface{}{5, "same", new(bytes.Buffer)},
|
||||
y: []interface{}{6, "same", new(bytes.Buffer)},
|
||||
opts: []cmp.Option{
|
||||
IgnoreTypes(0, ""),
|
||||
IgnoreInterfaces(struct {
|
||||
io.Reader
|
||||
io.Writer
|
||||
fmt.Stringer
|
||||
}{}),
|
||||
},
|
||||
wantEqual: true,
|
||||
reason: "equal because bytes.Buffer is ignored by match on multiple interface types",
|
||||
}, {
|
||||
label: "IgnoreInterfaces",
|
||||
x: struct{ mu sync.Mutex }{},
|
||||
y: struct{ mu sync.Mutex }{},
|
||||
wantPanic: true,
|
||||
reason: "panics because sync.Mutex has unexported fields",
|
||||
}, {
|
||||
label: "IgnoreInterfaces",
|
||||
x: struct{ mu sync.Mutex }{},
|
||||
y: struct{ mu sync.Mutex }{},
|
||||
opts: []cmp.Option{IgnoreInterfaces(struct{ sync.Locker }{})},
|
||||
wantEqual: true,
|
||||
reason: "equal because IgnoreInterfaces applies on values (with pointer receiver)",
|
||||
}, {
|
||||
label: "IgnoreInterfaces",
|
||||
x: struct{ mu *sync.Mutex }{},
|
||||
y: struct{ mu *sync.Mutex }{},
|
||||
opts: []cmp.Option{IgnoreInterfaces(struct{ sync.Locker }{})},
|
||||
wantEqual: true,
|
||||
reason: "equal because IgnoreInterfaces applies on pointers",
|
||||
}, {
|
||||
label: "IgnoreUnexported",
|
||||
x: ParentStruct{Public: 1, private: 2},
|
||||
y: ParentStruct{Public: 1, private: -2},
|
||||
opts: []cmp.Option{cmp.AllowUnexported(ParentStruct{})},
|
||||
wantEqual: false,
|
||||
reason: "not equal because ParentStruct.private differs with AllowUnexported",
|
||||
}, {
|
||||
label: "IgnoreUnexported",
|
||||
x: ParentStruct{Public: 1, private: 2},
|
||||
y: ParentStruct{Public: 1, private: -2},
|
||||
opts: []cmp.Option{IgnoreUnexported(ParentStruct{})},
|
||||
wantEqual: true,
|
||||
reason: "equal because IgnoreUnexported ignored ParentStruct.private",
|
||||
}, {
|
||||
label: "IgnoreUnexported",
|
||||
x: ParentStruct{Public: 1, private: 2, PublicStruct: &PublicStruct{Public: 3, private: 4}},
|
||||
y: ParentStruct{Public: 1, private: -2, PublicStruct: &PublicStruct{Public: 3, private: 4}},
|
||||
opts: []cmp.Option{
|
||||
cmp.AllowUnexported(PublicStruct{}),
|
||||
IgnoreUnexported(ParentStruct{}),
|
||||
},
|
||||
wantEqual: true,
|
||||
reason: "equal because ParentStruct.private is ignored",
|
||||
}, {
|
||||
label: "IgnoreUnexported",
|
||||
x: ParentStruct{Public: 1, private: 2, PublicStruct: &PublicStruct{Public: 3, private: 4}},
|
||||
y: ParentStruct{Public: 1, private: -2, PublicStruct: &PublicStruct{Public: 3, private: -4}},
|
||||
opts: []cmp.Option{
|
||||
cmp.AllowUnexported(PublicStruct{}),
|
||||
IgnoreUnexported(ParentStruct{}),
|
||||
},
|
||||
wantEqual: false,
|
||||
reason: "not equal because ParentStruct.PublicStruct.private differs and not ignored by IgnoreUnexported(ParentStruct{})",
|
||||
}, {
|
||||
label: "IgnoreUnexported",
|
||||
x: ParentStruct{Public: 1, private: 2, PublicStruct: &PublicStruct{Public: 3, private: 4}},
|
||||
y: ParentStruct{Public: 1, private: -2, PublicStruct: &PublicStruct{Public: 3, private: -4}},
|
||||
opts: []cmp.Option{
|
||||
IgnoreUnexported(ParentStruct{}, PublicStruct{}),
|
||||
},
|
||||
wantEqual: true,
|
||||
reason: "equal because both ParentStruct.PublicStruct and ParentStruct.PublicStruct.private are ignored",
|
||||
}, {
|
||||
label: "IgnoreUnexported",
|
||||
x: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: 3, private: 4}},
|
||||
y: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: -3, private: -4}},
|
||||
opts: []cmp.Option{
|
||||
cmp.AllowUnexported(privateStruct{}, PublicStruct{}, ParentStruct{}),
|
||||
},
|
||||
wantEqual: false,
|
||||
reason: "not equal since ParentStruct.privateStruct differs",
|
||||
}, {
|
||||
label: "IgnoreUnexported",
|
||||
x: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: 3, private: 4}},
|
||||
y: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: -3, private: -4}},
|
||||
opts: []cmp.Option{
|
||||
cmp.AllowUnexported(privateStruct{}, PublicStruct{}),
|
||||
IgnoreUnexported(ParentStruct{}),
|
||||
},
|
||||
wantEqual: true,
|
||||
reason: "equal because ParentStruct.privateStruct ignored by IgnoreUnexported(ParentStruct{})",
|
||||
}, {
|
||||
label: "IgnoreUnexported",
|
||||
x: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: 3, private: 4}},
|
||||
y: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: 3, private: -4}},
|
||||
opts: []cmp.Option{
|
||||
cmp.AllowUnexported(PublicStruct{}, ParentStruct{}),
|
||||
IgnoreUnexported(privateStruct{}),
|
||||
},
|
||||
wantEqual: true,
|
||||
reason: "equal because privateStruct.private ignored by IgnoreUnexported(privateStruct{})",
|
||||
}, {
|
||||
label: "IgnoreUnexported",
|
||||
x: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: 3, private: 4}},
|
||||
y: ParentStruct{Public: 1, private: 2, privateStruct: &privateStruct{Public: -3, private: -4}},
|
||||
opts: []cmp.Option{
|
||||
cmp.AllowUnexported(PublicStruct{}, ParentStruct{}),
|
||||
IgnoreUnexported(privateStruct{}),
|
||||
},
|
||||
wantEqual: false,
|
||||
reason: "not equal because privateStruct.Public differs and not ignored by IgnoreUnexported(privateStruct{})",
|
||||
}, {
|
||||
label: "IgnoreFields+IgnoreTypes+IgnoreUnexported",
|
||||
x: &Everything{
|
||||
MyInt: 5,
|
||||
MyFloat: 3.3,
|
||||
MyTime: MyTime{time.Now()},
|
||||
Bar3: *createBar3X(),
|
||||
ParentStruct: ParentStruct{
|
||||
Public: 1, private: 2, PublicStruct: &PublicStruct{Public: 3, private: 4},
|
||||
},
|
||||
},
|
||||
y: &Everything{
|
||||
MyInt: -5,
|
||||
MyFloat: 3.3,
|
||||
MyTime: MyTime{time.Now()},
|
||||
Bar3: *createBar3Y(),
|
||||
ParentStruct: ParentStruct{
|
||||
Public: 1, private: -2, PublicStruct: &PublicStruct{Public: -3, private: -4},
|
||||
},
|
||||
},
|
||||
opts: []cmp.Option{
|
||||
IgnoreFields(Everything{}, "MyTime", "Bar3.Foo3"),
|
||||
IgnoreFields(Bar3{}, "Bar1", "Bravo", "Delta", "Alpha"),
|
||||
IgnoreTypes(MyInt(0), PublicStruct{}),
|
||||
IgnoreUnexported(ParentStruct{}),
|
||||
},
|
||||
wantEqual: true,
|
||||
reason: "equal because all Ignore options can be composed together",
|
||||
}}
|
||||
|
||||
for _, tt := range tests {
|
||||
tRun(t, tt.label, func(t *testing.T) {
|
||||
var gotEqual bool
|
||||
var gotPanic string
|
||||
func() {
|
||||
defer func() {
|
||||
if ex := recover(); ex != nil {
|
||||
gotPanic = fmt.Sprint(ex)
|
||||
}
|
||||
}()
|
||||
gotEqual = cmp.Equal(tt.x, tt.y, tt.opts...)
|
||||
}()
|
||||
switch {
|
||||
case gotPanic == "" && tt.wantPanic:
|
||||
t.Errorf("expected Equal panic\nreason: %s", tt.reason)
|
||||
case gotPanic != "" && !tt.wantPanic:
|
||||
t.Errorf("unexpected Equal panic: got %v\nreason: %v", gotPanic, tt.reason)
|
||||
case gotEqual != tt.wantEqual:
|
||||
t.Errorf("Equal = %v, want %v\nreason: %v", gotEqual, tt.wantEqual, tt.reason)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestPanic(t *testing.T) {
|
||||
args := func(x ...interface{}) []interface{} { return x }
|
||||
tests := []struct {
|
||||
label string // Test name
|
||||
fnc interface{} // Option function to call
|
||||
args []interface{} // Arguments to pass in
|
||||
wantPanic string // Expected panic message
|
||||
reason string // The reason for the expected outcome
|
||||
}{{
|
||||
label: "EquateApprox",
|
||||
fnc: EquateApprox,
|
||||
args: args(0.0, 0.0),
|
||||
reason: "zero margin and fraction is equivalent to exact equality",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
fnc: EquateApprox,
|
||||
args: args(-0.1, 0.0),
|
||||
wantPanic: "margin or fraction must be a non-negative number",
|
||||
reason: "negative inputs are invalid",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
fnc: EquateApprox,
|
||||
args: args(0.0, -0.1),
|
||||
wantPanic: "margin or fraction must be a non-negative number",
|
||||
reason: "negative inputs are invalid",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
fnc: EquateApprox,
|
||||
args: args(math.NaN(), 0.0),
|
||||
wantPanic: "margin or fraction must be a non-negative number",
|
||||
reason: "NaN inputs are invalid",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
fnc: EquateApprox,
|
||||
args: args(1.0, 0.0),
|
||||
reason: "fraction of 1.0 or greater is valid",
|
||||
}, {
|
||||
label: "EquateApprox",
|
||||
fnc: EquateApprox,
|
||||
args: args(0.0, math.Inf(+1)),
|
||||
reason: "margin of infinity is valid",
|
||||
}, {
|
||||
label: "SortSlices",
|
||||
fnc: SortSlices,
|
||||
args: args(strings.Compare),
|
||||
wantPanic: "invalid less function",
|
||||
reason: "func(x, y string) int is wrong signature for less",
|
||||
}, {
|
||||
label: "SortSlices",
|
||||
fnc: SortSlices,
|
||||
args: args((func(_, _ int) bool)(nil)),
|
||||
wantPanic: "invalid less function",
|
||||
reason: "nil value is not valid",
|
||||
}, {
|
||||
label: "SortMaps",
|
||||
fnc: SortMaps,
|
||||
args: args(strings.Compare),
|
||||
wantPanic: "invalid less function",
|
||||
reason: "func(x, y string) int is wrong signature for less",
|
||||
}, {
|
||||
label: "SortMaps",
|
||||
fnc: SortMaps,
|
||||
args: args((func(_, _ int) bool)(nil)),
|
||||
wantPanic: "invalid less function",
|
||||
reason: "nil value is not valid",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
fnc: IgnoreFields,
|
||||
args: args(Foo1{}, ""),
|
||||
wantPanic: "name must not be empty",
|
||||
reason: "empty selector is invalid",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
fnc: IgnoreFields,
|
||||
args: args(Foo1{}, "."),
|
||||
wantPanic: "name must not be empty",
|
||||
reason: "single dot selector is invalid",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
fnc: IgnoreFields,
|
||||
args: args(Foo1{}, ".Alpha"),
|
||||
reason: "dot-prefix is okay since Foo1.Alpha reads naturally",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
fnc: IgnoreFields,
|
||||
args: args(Foo1{}, "Alpha."),
|
||||
wantPanic: "name must not be empty",
|
||||
reason: "dot-suffix is invalid",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
fnc: IgnoreFields,
|
||||
args: args(Foo1{}, "Alpha "),
|
||||
wantPanic: "does not exist",
|
||||
reason: "identifiers must not have spaces",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
fnc: IgnoreFields,
|
||||
args: args(Foo1{}, "Zulu"),
|
||||
wantPanic: "does not exist",
|
||||
reason: "name of non-existent field is invalid",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
fnc: IgnoreFields,
|
||||
args: args(Foo1{}, "Alpha.NoExist"),
|
||||
wantPanic: "must be a struct",
|
||||
reason: "cannot select into a non-struct",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
fnc: IgnoreFields,
|
||||
args: args(&Foo1{}, "Alpha"),
|
||||
wantPanic: "must be a struct",
|
||||
reason: "the type must be a struct (not pointer to a struct)",
|
||||
}, {
|
||||
label: "IgnoreFields",
|
||||
fnc: IgnoreFields,
|
||||
args: args(Foo1{}, "unexported"),
|
||||
wantPanic: "name must be exported",
|
||||
reason: "unexported fields must not be specified",
|
||||
}, {
|
||||
label: "IgnoreTypes",
|
||||
fnc: IgnoreTypes,
|
||||
reason: "empty input is valid",
|
||||
}, {
|
||||
label: "IgnoreTypes",
|
||||
fnc: IgnoreTypes,
|
||||
args: args(nil),
|
||||
wantPanic: "cannot determine type",
|
||||
reason: "input must not be nil value",
|
||||
}, {
|
||||
label: "IgnoreTypes",
|
||||
fnc: IgnoreTypes,
|
||||
args: args(0, 0, 0),
|
||||
reason: "duplicate inputs of the same type is valid",
|
||||
}, {
|
||||
label: "IgnoreInterfaces",
|
||||
fnc: IgnoreInterfaces,
|
||||
args: args(nil),
|
||||
wantPanic: "input must be an anonymous struct",
|
||||
reason: "input must not be nil value",
|
||||
}, {
|
||||
label: "IgnoreInterfaces",
|
||||
fnc: IgnoreInterfaces,
|
||||
args: args(Foo1{}),
|
||||
wantPanic: "input must be an anonymous struct",
|
||||
reason: "input must not be a named struct type",
|
||||
}, {
|
||||
label: "IgnoreInterfaces",
|
||||
fnc: IgnoreInterfaces,
|
||||
args: args(struct{ _ io.Reader }{}),
|
||||
wantPanic: "struct cannot have named fields",
|
||||
reason: "input must not have named fields",
|
||||
}, {
|
||||
label: "IgnoreInterfaces",
|
||||
fnc: IgnoreInterfaces,
|
||||
args: args(struct{ Foo1 }{}),
|
||||
wantPanic: "embedded field must be an interface type",
|
||||
reason: "field types must be interfaces",
|
||||
}, {
|
||||
label: "IgnoreInterfaces",
|
||||
fnc: IgnoreInterfaces,
|
||||
args: args(struct{ EmptyInterface }{}),
|
||||
wantPanic: "cannot ignore empty interface",
|
||||
reason: "field types must not be the empty interface",
|
||||
}, {
|
||||
label: "IgnoreInterfaces",
|
||||
fnc: IgnoreInterfaces,
|
||||
args: args(struct {
|
||||
io.Reader
|
||||
io.Writer
|
||||
io.Closer
|
||||
io.ReadWriteCloser
|
||||
}{}),
|
||||
reason: "multiple interfaces may be specified, even if they overlap",
|
||||
}, {
|
||||
label: "IgnoreUnexported",
|
||||
fnc: IgnoreUnexported,
|
||||
reason: "empty input is valid",
|
||||
}, {
|
||||
label: "IgnoreUnexported",
|
||||
fnc: IgnoreUnexported,
|
||||
args: args(nil),
|
||||
wantPanic: "invalid struct type",
|
||||
reason: "input must not be nil value",
|
||||
}, {
|
||||
label: "IgnoreUnexported",
|
||||
fnc: IgnoreUnexported,
|
||||
args: args(&Foo1{}),
|
||||
wantPanic: "invalid struct type",
|
||||
reason: "input must be a struct type (not a pointer to a struct)",
|
||||
}, {
|
||||
label: "IgnoreUnexported",
|
||||
fnc: IgnoreUnexported,
|
||||
args: args(Foo1{}, struct{ x, X int }{}),
|
||||
reason: "input may be named or unnamed structs",
|
||||
}}
|
||||
|
||||
for _, tt := range tests {
|
||||
tRun(t, tt.label, func(t *testing.T) {
|
||||
// Prepare function arguments.
|
||||
vf := reflect.ValueOf(tt.fnc)
|
||||
var vargs []reflect.Value
|
||||
for i, arg := range tt.args {
|
||||
if arg == nil {
|
||||
tf := vf.Type()
|
||||
if i == tf.NumIn()-1 && tf.IsVariadic() {
|
||||
vargs = append(vargs, reflect.Zero(tf.In(i).Elem()))
|
||||
} else {
|
||||
vargs = append(vargs, reflect.Zero(tf.In(i)))
|
||||
}
|
||||
} else {
|
||||
vargs = append(vargs, reflect.ValueOf(arg))
|
||||
}
|
||||
}
|
||||
|
||||
// Call the function and capture any panics.
|
||||
var gotPanic string
|
||||
func() {
|
||||
defer func() {
|
||||
if ex := recover(); ex != nil {
|
||||
if s, ok := ex.(string); ok {
|
||||
gotPanic = s
|
||||
} else {
|
||||
panic(ex)
|
||||
}
|
||||
}
|
||||
}()
|
||||
vf.Call(vargs)
|
||||
}()
|
||||
|
||||
switch {
|
||||
case tt.wantPanic == "" && gotPanic != "":
|
||||
t.Errorf("unexpected panic message: %s\nreason: %s", gotPanic, tt.reason)
|
||||
case tt.wantPanic != "" && !strings.Contains(gotPanic, tt.wantPanic):
|
||||
t.Errorf("panic message:\ngot: %s\nwant: %s\nreason: %s", gotPanic, tt.wantPanic, tt.reason)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Delete this hack when we drop Go1.6 support.
|
||||
func tRun(t *testing.T, name string, f func(t *testing.T)) {
|
||||
type runner interface {
|
||||
Run(string, func(t *testing.T)) bool
|
||||
}
|
||||
var ti interface{} = t
|
||||
if r, ok := ti.(runner); ok {
|
||||
r.Run(name, f)
|
||||
} else {
|
||||
t.Logf("Test: %s", name)
|
||||
f(t)
|
||||
}
|
||||
}
|
||||
+33
-9
@@ -22,7 +22,7 @@
|
||||
// equality is determined by recursively comparing the primitive kinds on both
|
||||
// values, much like reflect.DeepEqual. Unlike reflect.DeepEqual, unexported
|
||||
// fields are not compared by default; they result in panics unless suppressed
|
||||
// by using an Ignore option (see cmpopts.IgnoreUnexported) or explictly compared
|
||||
// by using an Ignore option (see cmpopts.IgnoreUnexported) or explicitly compared
|
||||
// using the AllowUnexported option.
|
||||
package cmp
|
||||
|
||||
@@ -35,7 +35,7 @@ import (
|
||||
"github.com/google/go-cmp/cmp/internal/value"
|
||||
)
|
||||
|
||||
// BUG: Maps with keys containing NaN values cannot be properly compared due to
|
||||
// BUG(dsnet): Maps with keys containing NaN values cannot be properly compared due to
|
||||
// the reflection package's inability to retrieve such entries. Equal will panic
|
||||
// anytime it comes across a NaN key, but this behavior may change.
|
||||
//
|
||||
@@ -61,8 +61,8 @@ var nothing = reflect.Value{}
|
||||
//
|
||||
// • If the values have an Equal method of the form "(T) Equal(T) bool" or
|
||||
// "(T) Equal(I) bool" where T is assignable to I, then use the result of
|
||||
// x.Equal(y). Otherwise, no such method exists and evaluation proceeds to
|
||||
// the next rule.
|
||||
// x.Equal(y) even if x or y is nil.
|
||||
// Otherwise, no such method exists and evaluation proceeds to the next rule.
|
||||
//
|
||||
// • Lastly, try to compare x and y based on their basic kinds.
|
||||
// Simple kinds like booleans, integers, floats, complex numbers, strings, and
|
||||
@@ -304,7 +304,8 @@ func (s *state) tryOptions(vx, vy reflect.Value, t reflect.Type) bool {
|
||||
|
||||
// Evaluate all filters and apply the remaining options.
|
||||
if opt := opts.filter(s, vx, vy, t); opt != nil {
|
||||
return opt.apply(s, vx, vy)
|
||||
opt.apply(s, vx, vy)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -322,6 +323,7 @@ func (s *state) tryMethod(vx, vy reflect.Value, t reflect.Type) bool {
|
||||
}
|
||||
|
||||
func (s *state) callTRFunc(f, v reflect.Value) reflect.Value {
|
||||
v = sanitizeValue(v, f.Type().In(0))
|
||||
if !s.dynChecker.Next() {
|
||||
return f.Call([]reflect.Value{v})[0]
|
||||
}
|
||||
@@ -345,6 +347,8 @@ func (s *state) callTRFunc(f, v reflect.Value) reflect.Value {
|
||||
}
|
||||
|
||||
func (s *state) callTTBFunc(f, x, y reflect.Value) bool {
|
||||
x = sanitizeValue(x, f.Type().In(0))
|
||||
y = sanitizeValue(y, f.Type().In(1))
|
||||
if !s.dynChecker.Next() {
|
||||
return f.Call([]reflect.Value{x, y})[0].Bool()
|
||||
}
|
||||
@@ -372,20 +376,40 @@ func detectRaces(c chan<- reflect.Value, f reflect.Value, vs ...reflect.Value) {
|
||||
ret = f.Call(vs)[0]
|
||||
}
|
||||
|
||||
// sanitizeValue converts nil interfaces of type T to those of type R,
|
||||
// assuming that T is assignable to R.
|
||||
// Otherwise, it returns the input value as is.
|
||||
func sanitizeValue(v reflect.Value, t reflect.Type) reflect.Value {
|
||||
// TODO(dsnet): Remove this hacky workaround.
|
||||
// See https://golang.org/issue/22143
|
||||
if v.Kind() == reflect.Interface && v.IsNil() && v.Type() != t {
|
||||
return reflect.New(t).Elem()
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
func (s *state) compareArray(vx, vy reflect.Value, t reflect.Type) {
|
||||
step := &sliceIndex{pathStep{t.Elem()}, 0, 0}
|
||||
s.curPath.push(step)
|
||||
|
||||
// Compute an edit-script for slices vx and vy.
|
||||
eq, es := diff.Difference(vx.Len(), vy.Len(), func(ix, iy int) diff.Result {
|
||||
es := diff.Difference(vx.Len(), vy.Len(), func(ix, iy int) diff.Result {
|
||||
step.xkey, step.ykey = ix, iy
|
||||
return s.statelessCompare(vx.Index(ix), vy.Index(iy))
|
||||
})
|
||||
|
||||
// Equal or no edit-script, so report entire slices as is.
|
||||
if eq || es == nil {
|
||||
// Report the entire slice as is if the arrays are of primitive kind,
|
||||
// and the arrays are different enough.
|
||||
isPrimitive := false
|
||||
switch t.Elem().Kind() {
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
|
||||
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
|
||||
reflect.Bool, reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128:
|
||||
isPrimitive = true
|
||||
}
|
||||
if isPrimitive && es.Dist() > (vx.Len()+vy.Len())/4 {
|
||||
s.curPath.pop() // Pop first since we are reporting the whole slice
|
||||
s.report(eq, vx, vy)
|
||||
s.report(false, vx, vy)
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
-1795
File diff suppressed because it is too large
Load Diff
-374
@@ -1,374 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package cmp_test
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"reflect"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"github.com/google/go-cmp/cmp"
|
||||
)
|
||||
|
||||
// TODO: Re-write these examples in terms of how you actually use the
|
||||
// fundamental options and filters and not in terms of what cool things you can
|
||||
// do with them since that overlaps with cmp/cmpopts.
|
||||
|
||||
// Use Diff for printing out human-readable errors for test cases comparing
|
||||
// nested or structured data.
|
||||
func ExampleDiff_testing() {
|
||||
// Code under test:
|
||||
type ShipManifest struct {
|
||||
Name string
|
||||
Crew map[string]string
|
||||
Androids int
|
||||
Stolen bool
|
||||
}
|
||||
|
||||
// AddCrew tries to add the given crewmember to the manifest.
|
||||
AddCrew := func(m *ShipManifest, name, title string) {
|
||||
if m.Crew == nil {
|
||||
m.Crew = make(map[string]string)
|
||||
}
|
||||
m.Crew[title] = name
|
||||
}
|
||||
|
||||
// Test function:
|
||||
tests := []struct {
|
||||
desc string
|
||||
before *ShipManifest
|
||||
name, title string
|
||||
after *ShipManifest
|
||||
}{
|
||||
{
|
||||
desc: "add to empty",
|
||||
before: &ShipManifest{},
|
||||
name: "Zaphod Beeblebrox",
|
||||
title: "Galactic President",
|
||||
after: &ShipManifest{
|
||||
Crew: map[string]string{
|
||||
"Zaphod Beeblebrox": "Galactic President",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "add another",
|
||||
before: &ShipManifest{
|
||||
Crew: map[string]string{
|
||||
"Zaphod Beeblebrox": "Galactic President",
|
||||
},
|
||||
},
|
||||
name: "Trillian",
|
||||
title: "Human",
|
||||
after: &ShipManifest{
|
||||
Crew: map[string]string{
|
||||
"Zaphod Beeblebrox": "Galactic President",
|
||||
"Trillian": "Human",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "overwrite",
|
||||
before: &ShipManifest{
|
||||
Crew: map[string]string{
|
||||
"Zaphod Beeblebrox": "Galactic President",
|
||||
},
|
||||
},
|
||||
name: "Zaphod Beeblebrox",
|
||||
title: "Just this guy, you know?",
|
||||
after: &ShipManifest{
|
||||
Crew: map[string]string{
|
||||
"Zaphod Beeblebrox": "Just this guy, you know?",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
var t fakeT
|
||||
for _, test := range tests {
|
||||
AddCrew(test.before, test.name, test.title)
|
||||
if diff := cmp.Diff(test.before, test.after); diff != "" {
|
||||
t.Errorf("%s: after AddCrew, manifest differs: (-got +want)\n%s", test.desc, diff)
|
||||
}
|
||||
}
|
||||
|
||||
// Output:
|
||||
// add to empty: after AddCrew, manifest differs: (-got +want)
|
||||
// {*cmp_test.ShipManifest}.Crew["Galactic President"]:
|
||||
// -: "Zaphod Beeblebrox"
|
||||
// +: <non-existent>
|
||||
// {*cmp_test.ShipManifest}.Crew["Zaphod Beeblebrox"]:
|
||||
// -: <non-existent>
|
||||
// +: "Galactic President"
|
||||
//
|
||||
// add another: after AddCrew, manifest differs: (-got +want)
|
||||
// {*cmp_test.ShipManifest}.Crew["Human"]:
|
||||
// -: "Trillian"
|
||||
// +: <non-existent>
|
||||
// {*cmp_test.ShipManifest}.Crew["Trillian"]:
|
||||
// -: <non-existent>
|
||||
// +: "Human"
|
||||
//
|
||||
// overwrite: after AddCrew, manifest differs: (-got +want)
|
||||
// {*cmp_test.ShipManifest}.Crew["Just this guy, you know?"]:
|
||||
// -: "Zaphod Beeblebrox"
|
||||
// +: <non-existent>
|
||||
// {*cmp_test.ShipManifest}.Crew["Zaphod Beeblebrox"]:
|
||||
// -: "Galactic President"
|
||||
// +: "Just this guy, you know?"
|
||||
}
|
||||
|
||||
// Approximate equality for floats can be handled by defining a custom
|
||||
// comparer on floats that determines two values to be equal if they are within
|
||||
// some range of each other.
|
||||
//
|
||||
// This example is for demonstrative purposes; use cmpopts.EquateApprox instead.
|
||||
func ExampleOption_approximateFloats() {
|
||||
// This Comparer only operates on float64.
|
||||
// To handle float32s, either define a similar function for that type
|
||||
// or use a Transformer to convert float32s into float64s.
|
||||
opt := cmp.Comparer(func(x, y float64) bool {
|
||||
delta := math.Abs(x - y)
|
||||
mean := math.Abs(x+y) / 2.0
|
||||
return delta/mean < 0.00001
|
||||
})
|
||||
|
||||
x := []float64{1.0, 1.1, 1.2, math.Pi}
|
||||
y := []float64{1.0, 1.1, 1.2, 3.14159265359} // Accurate enough to Pi
|
||||
z := []float64{1.0, 1.1, 1.2, 3.1415} // Diverges too far from Pi
|
||||
|
||||
fmt.Println(cmp.Equal(x, y, opt))
|
||||
fmt.Println(cmp.Equal(y, z, opt))
|
||||
fmt.Println(cmp.Equal(z, x, opt))
|
||||
|
||||
// Output:
|
||||
// true
|
||||
// false
|
||||
// false
|
||||
}
|
||||
|
||||
// Normal floating-point arithmetic defines == to be false when comparing
|
||||
// NaN with itself. In certain cases, this is not the desired property.
|
||||
//
|
||||
// This example is for demonstrative purposes; use cmpopts.EquateNaNs instead.
|
||||
func ExampleOption_equalNaNs() {
|
||||
// This Comparer only operates on float64.
|
||||
// To handle float32s, either define a similar function for that type
|
||||
// or use a Transformer to convert float32s into float64s.
|
||||
opt := cmp.Comparer(func(x, y float64) bool {
|
||||
return (math.IsNaN(x) && math.IsNaN(y)) || x == y
|
||||
})
|
||||
|
||||
x := []float64{1.0, math.NaN(), math.E, -0.0, +0.0}
|
||||
y := []float64{1.0, math.NaN(), math.E, -0.0, +0.0}
|
||||
z := []float64{1.0, math.NaN(), math.Pi, -0.0, +0.0} // Pi constant instead of E
|
||||
|
||||
fmt.Println(cmp.Equal(x, y, opt))
|
||||
fmt.Println(cmp.Equal(y, z, opt))
|
||||
fmt.Println(cmp.Equal(z, x, opt))
|
||||
|
||||
// Output:
|
||||
// true
|
||||
// false
|
||||
// false
|
||||
}
|
||||
|
||||
// To have floating-point comparisons combine both properties of NaN being
|
||||
// equal to itself and also approximate equality of values, filters are needed
|
||||
// to restrict the scope of the comparison so that they are composable.
|
||||
//
|
||||
// This example is for demonstrative purposes;
|
||||
// use cmpopts.EquateNaNs and cmpopts.EquateApprox instead.
|
||||
func ExampleOption_equalNaNsAndApproximateFloats() {
|
||||
alwaysEqual := cmp.Comparer(func(_, _ interface{}) bool { return true })
|
||||
|
||||
opts := cmp.Options{
|
||||
// This option declares that a float64 comparison is equal only if
|
||||
// both inputs are NaN.
|
||||
cmp.FilterValues(func(x, y float64) bool {
|
||||
return math.IsNaN(x) && math.IsNaN(y)
|
||||
}, alwaysEqual),
|
||||
|
||||
// This option declares approximate equality on float64s only if
|
||||
// both inputs are not NaN.
|
||||
cmp.FilterValues(func(x, y float64) bool {
|
||||
return !math.IsNaN(x) && !math.IsNaN(y)
|
||||
}, cmp.Comparer(func(x, y float64) bool {
|
||||
delta := math.Abs(x - y)
|
||||
mean := math.Abs(x+y) / 2.0
|
||||
return delta/mean < 0.00001
|
||||
})),
|
||||
}
|
||||
|
||||
x := []float64{math.NaN(), 1.0, 1.1, 1.2, math.Pi}
|
||||
y := []float64{math.NaN(), 1.0, 1.1, 1.2, 3.14159265359} // Accurate enough to Pi
|
||||
z := []float64{math.NaN(), 1.0, 1.1, 1.2, 3.1415} // Diverges too far from Pi
|
||||
|
||||
fmt.Println(cmp.Equal(x, y, opts))
|
||||
fmt.Println(cmp.Equal(y, z, opts))
|
||||
fmt.Println(cmp.Equal(z, x, opts))
|
||||
|
||||
// Output:
|
||||
// true
|
||||
// false
|
||||
// false
|
||||
}
|
||||
|
||||
// Sometimes, an empty map or slice is considered equal to an allocated one
|
||||
// of zero length.
|
||||
//
|
||||
// This example is for demonstrative purposes; use cmpopts.EquateEmpty instead.
|
||||
func ExampleOption_equalEmpty() {
|
||||
alwaysEqual := cmp.Comparer(func(_, _ interface{}) bool { return true })
|
||||
|
||||
// This option handles slices and maps of any type.
|
||||
opt := cmp.FilterValues(func(x, y interface{}) bool {
|
||||
vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
|
||||
return (vx.IsValid() && vy.IsValid() && vx.Type() == vy.Type()) &&
|
||||
(vx.Kind() == reflect.Slice || vx.Kind() == reflect.Map) &&
|
||||
(vx.Len() == 0 && vy.Len() == 0)
|
||||
}, alwaysEqual)
|
||||
|
||||
type S struct {
|
||||
A []int
|
||||
B map[string]bool
|
||||
}
|
||||
x := S{nil, make(map[string]bool, 100)}
|
||||
y := S{make([]int, 0, 200), nil}
|
||||
z := S{[]int{0}, nil} // []int has a single element (i.e., not empty)
|
||||
|
||||
fmt.Println(cmp.Equal(x, y, opt))
|
||||
fmt.Println(cmp.Equal(y, z, opt))
|
||||
fmt.Println(cmp.Equal(z, x, opt))
|
||||
|
||||
// Output:
|
||||
// true
|
||||
// false
|
||||
// false
|
||||
}
|
||||
|
||||
// Two slices may be considered equal if they have the same elements,
|
||||
// regardless of the order that they appear in. Transformations can be used
|
||||
// to sort the slice.
|
||||
//
|
||||
// This example is for demonstrative purposes; use cmpopts.SortSlices instead.
|
||||
func ExampleOption_sortedSlice() {
|
||||
// This Transformer sorts a []int.
|
||||
// Since the transformer transforms []int into []int, there is problem where
|
||||
// this is recursively applied forever. To prevent this, use a FilterValues
|
||||
// to first check for the condition upon which the transformer ought to apply.
|
||||
trans := cmp.FilterValues(func(x, y []int) bool {
|
||||
return !sort.IntsAreSorted(x) || !sort.IntsAreSorted(y)
|
||||
}, cmp.Transformer("Sort", func(in []int) []int {
|
||||
out := append([]int(nil), in...) // Copy input to avoid mutating it
|
||||
sort.Ints(out)
|
||||
return out
|
||||
}))
|
||||
|
||||
x := struct{ Ints []int }{[]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}}
|
||||
y := struct{ Ints []int }{[]int{2, 8, 0, 9, 6, 1, 4, 7, 3, 5}}
|
||||
z := struct{ Ints []int }{[]int{0, 0, 1, 2, 3, 4, 5, 6, 7, 8}}
|
||||
|
||||
fmt.Println(cmp.Equal(x, y, trans))
|
||||
fmt.Println(cmp.Equal(y, z, trans))
|
||||
fmt.Println(cmp.Equal(z, x, trans))
|
||||
|
||||
// Output:
|
||||
// true
|
||||
// false
|
||||
// false
|
||||
}
|
||||
|
||||
type otherString string
|
||||
|
||||
func (x otherString) Equal(y otherString) bool {
|
||||
return strings.ToLower(string(x)) == strings.ToLower(string(y))
|
||||
}
|
||||
|
||||
// If the Equal method defined on a type is not suitable, the type can be be
|
||||
// dynamically transformed to be stripped of the Equal method (or any method
|
||||
// for that matter).
|
||||
func ExampleOption_avoidEqualMethod() {
|
||||
// Suppose otherString.Equal performs a case-insensitive equality,
|
||||
// which is too loose for our needs.
|
||||
// We can avoid the methods of otherString by declaring a new type.
|
||||
type myString otherString
|
||||
|
||||
// This transformer converts otherString to myString, allowing Equal to use
|
||||
// other Options to determine equality.
|
||||
trans := cmp.Transformer("", func(in otherString) myString {
|
||||
return myString(in)
|
||||
})
|
||||
|
||||
x := []otherString{"foo", "bar", "baz"}
|
||||
y := []otherString{"fOO", "bAr", "Baz"} // Same as before, but with different case
|
||||
|
||||
fmt.Println(cmp.Equal(x, y)) // Equal because of case-insensitivity
|
||||
fmt.Println(cmp.Equal(x, y, trans)) // Not equal because of more exact equality
|
||||
|
||||
// Output:
|
||||
// true
|
||||
// false
|
||||
}
|
||||
|
||||
func roundF64(z float64) float64 {
|
||||
if z < 0 {
|
||||
return math.Ceil(z - 0.5)
|
||||
}
|
||||
return math.Floor(z + 0.5)
|
||||
}
|
||||
|
||||
// The complex numbers complex64 and complex128 can really just be decomposed
|
||||
// into a pair of float32 or float64 values. It would be convenient to be able
|
||||
// define only a single comparator on float64 and have float32, complex64, and
|
||||
// complex128 all be able to use that comparator. Transformations can be used
|
||||
// to handle this.
|
||||
func ExampleOption_transformComplex() {
|
||||
opts := []cmp.Option{
|
||||
// This transformer decomposes complex128 into a pair of float64s.
|
||||
cmp.Transformer("T1", func(in complex128) (out struct{ Real, Imag float64 }) {
|
||||
out.Real, out.Imag = real(in), imag(in)
|
||||
return out
|
||||
}),
|
||||
// This transformer converts complex64 to complex128 to allow the
|
||||
// above transform to take effect.
|
||||
cmp.Transformer("T2", func(in complex64) complex128 {
|
||||
return complex128(in)
|
||||
}),
|
||||
// This transformer converts float32 to float64.
|
||||
cmp.Transformer("T3", func(in float32) float64 {
|
||||
return float64(in)
|
||||
}),
|
||||
// This equality function compares float64s as rounded integers.
|
||||
cmp.Comparer(func(x, y float64) bool {
|
||||
return roundF64(x) == roundF64(y)
|
||||
}),
|
||||
}
|
||||
|
||||
x := []interface{}{
|
||||
complex128(3.0), complex64(5.1 + 2.9i), float32(-1.2), float64(12.3),
|
||||
}
|
||||
y := []interface{}{
|
||||
complex128(3.1), complex64(4.9 + 3.1i), float32(-1.3), float64(11.7),
|
||||
}
|
||||
z := []interface{}{
|
||||
complex128(3.8), complex64(4.9 + 3.1i), float32(-1.3), float64(11.7),
|
||||
}
|
||||
|
||||
fmt.Println(cmp.Equal(x, y, opts...))
|
||||
fmt.Println(cmp.Equal(y, z, opts...))
|
||||
fmt.Println(cmp.Equal(z, x, opts...))
|
||||
|
||||
// Output:
|
||||
// true
|
||||
// false
|
||||
// false
|
||||
}
|
||||
|
||||
type fakeT struct{}
|
||||
|
||||
func (t fakeT) Errorf(format string, args ...interface{}) { fmt.Printf(format+"\n", args...) }
|
||||
+1
-1
@@ -50,7 +50,7 @@ import (
|
||||
//
|
||||
// The series of '.', 'X', 'Y', and 'M' characters at the bottom represents
|
||||
// the currently established path from the forward and reverse searches,
|
||||
// seperated by a '|' character.
|
||||
// separated by a '|' character.
|
||||
|
||||
const (
|
||||
updateDelay = 100 * time.Millisecond
|
||||
|
||||
+4
-14
@@ -106,9 +106,9 @@ func (r Result) Similar() bool {
|
||||
// Difference reports whether two lists of lengths nx and ny are equal
|
||||
// given the definition of equality provided as f.
|
||||
//
|
||||
// This function may return a edit-script, which is a sequence of operations
|
||||
// needed to convert one list into the other. If non-nil, the following
|
||||
// invariants for the edit-script are maintained:
|
||||
// This function returns an edit-script, which is a sequence of operations
|
||||
// needed to convert one list into the other. The following invariants for
|
||||
// the edit-script are maintained:
|
||||
// • eq == (es.Dist()==0)
|
||||
// • nx == es.LenX()
|
||||
// • ny == es.LenY()
|
||||
@@ -117,17 +117,7 @@ func (r Result) Similar() bool {
|
||||
// produces an edit-script with a minimal Levenshtein distance). This algorithm
|
||||
// favors performance over optimality. The exact output is not guaranteed to
|
||||
// be stable and may change over time.
|
||||
func Difference(nx, ny int, f EqualFunc) (eq bool, es EditScript) {
|
||||
es = searchGraph(nx, ny, f)
|
||||
st := es.stats()
|
||||
eq = len(es) == st.NI
|
||||
if !eq && st.NI < (nx+ny)/4 {
|
||||
return eq, nil // Edit-script more distracting than helpful
|
||||
}
|
||||
return eq, es
|
||||
}
|
||||
|
||||
func searchGraph(nx, ny int, f EqualFunc) EditScript {
|
||||
func Difference(nx, ny int, f EqualFunc) (es EditScript) {
|
||||
// This algorithm is based on traversing what is known as an "edit-graph".
|
||||
// See Figure 1 from "An O(ND) Difference Algorithm and Its Variations"
|
||||
// by Eugene W. Myers. Since D can be as large as N itself, this is
|
||||
|
||||
-467
@@ -1,467 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package diff
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math/rand"
|
||||
"strings"
|
||||
"testing"
|
||||
"unicode"
|
||||
)
|
||||
|
||||
func TestDifference(t *testing.T) {
|
||||
tests := []struct {
|
||||
// Before passing x and y to Difference, we strip all spaces so that
|
||||
// they can be used by the test author to indicate a missing symbol
|
||||
// in one of the lists.
|
||||
x, y string
|
||||
want string
|
||||
}{{
|
||||
x: "",
|
||||
y: "",
|
||||
want: "",
|
||||
}, {
|
||||
x: "#",
|
||||
y: "#",
|
||||
want: ".",
|
||||
}, {
|
||||
x: "##",
|
||||
y: "# ",
|
||||
want: ".X",
|
||||
}, {
|
||||
x: "a#",
|
||||
y: "A ",
|
||||
want: "MX",
|
||||
}, {
|
||||
x: "#a",
|
||||
y: " A",
|
||||
want: "XM",
|
||||
}, {
|
||||
x: "# ",
|
||||
y: "##",
|
||||
want: ".Y",
|
||||
}, {
|
||||
x: " #",
|
||||
y: "@#",
|
||||
want: "Y.",
|
||||
}, {
|
||||
x: "@#",
|
||||
y: " #",
|
||||
want: "X.",
|
||||
}, {
|
||||
x: "##########0123456789",
|
||||
y: " 0123456789",
|
||||
want: "XXXXXXXXXX..........",
|
||||
}, {
|
||||
x: " 0123456789",
|
||||
y: "##########0123456789",
|
||||
want: "YYYYYYYYYY..........",
|
||||
}, {
|
||||
x: "#####0123456789#####",
|
||||
y: " 0123456789 ",
|
||||
want: "XXXXX..........XXXXX",
|
||||
}, {
|
||||
x: " 0123456789 ",
|
||||
y: "#####0123456789#####",
|
||||
want: "YYYYY..........YYYYY",
|
||||
}, {
|
||||
x: "01234##########56789",
|
||||
y: "01234 56789",
|
||||
want: ".....XXXXXXXXXX.....",
|
||||
}, {
|
||||
x: "01234 56789",
|
||||
y: "01234##########56789",
|
||||
want: ".....YYYYYYYYYY.....",
|
||||
}, {
|
||||
x: "0123456789##########",
|
||||
y: "0123456789 ",
|
||||
want: "..........XXXXXXXXXX",
|
||||
}, {
|
||||
x: "0123456789 ",
|
||||
y: "0123456789##########",
|
||||
want: "..........YYYYYYYYYY",
|
||||
}, {
|
||||
x: "abcdefghij0123456789",
|
||||
y: "ABCDEFGHIJ0123456789",
|
||||
want: "MMMMMMMMMM..........",
|
||||
}, {
|
||||
x: "ABCDEFGHIJ0123456789",
|
||||
y: "abcdefghij0123456789",
|
||||
want: "MMMMMMMMMM..........",
|
||||
}, {
|
||||
x: "01234abcdefghij56789",
|
||||
y: "01234ABCDEFGHIJ56789",
|
||||
want: ".....MMMMMMMMMM.....",
|
||||
}, {
|
||||
x: "01234ABCDEFGHIJ56789",
|
||||
y: "01234abcdefghij56789",
|
||||
want: ".....MMMMMMMMMM.....",
|
||||
}, {
|
||||
x: "0123456789abcdefghij",
|
||||
y: "0123456789ABCDEFGHIJ",
|
||||
want: "..........MMMMMMMMMM",
|
||||
}, {
|
||||
x: "0123456789ABCDEFGHIJ",
|
||||
y: "0123456789abcdefghij",
|
||||
want: "..........MMMMMMMMMM",
|
||||
}, {
|
||||
x: "ABCDEFGHIJ0123456789 ",
|
||||
y: " 0123456789abcdefghij",
|
||||
want: "XXXXXXXXXX..........YYYYYYYYYY",
|
||||
}, {
|
||||
x: " 0123456789abcdefghij",
|
||||
y: "ABCDEFGHIJ0123456789 ",
|
||||
want: "YYYYYYYYYY..........XXXXXXXXXX",
|
||||
}, {
|
||||
x: "ABCDE0123456789 FGHIJ",
|
||||
y: " 0123456789abcdefghij",
|
||||
want: "XXXXX..........YYYYYMMMMM",
|
||||
}, {
|
||||
x: " 0123456789abcdefghij",
|
||||
y: "ABCDE0123456789 FGHIJ",
|
||||
want: "YYYYY..........XXXXXMMMMM",
|
||||
}, {
|
||||
x: "ABCDE01234F G H I J 56789 ",
|
||||
y: " 01234 a b c d e56789fghij",
|
||||
want: "XXXXX.....XYXYXYXYXY.....YYYYY",
|
||||
}, {
|
||||
x: " 01234a b c d e 56789fghij",
|
||||
y: "ABCDE01234 F G H I J56789 ",
|
||||
want: "YYYYY.....XYXYXYXYXY.....XXXXX",
|
||||
}, {
|
||||
x: "FGHIJ01234ABCDE56789 ",
|
||||
y: " 01234abcde56789fghij",
|
||||
want: "XXXXX.....MMMMM.....YYYYY",
|
||||
}, {
|
||||
x: " 01234abcde56789fghij",
|
||||
y: "FGHIJ01234ABCDE56789 ",
|
||||
want: "YYYYY.....MMMMM.....XXXXX",
|
||||
}, {
|
||||
x: "ABCAB BA ",
|
||||
y: " C BABAC",
|
||||
want: "XX.X.Y..Y",
|
||||
}, {
|
||||
x: "# #### ###",
|
||||
y: "#y####yy###",
|
||||
want: ".Y....YY...",
|
||||
}, {
|
||||
x: "# #### # ##x#x",
|
||||
y: "#y####y y## # ",
|
||||
want: ".Y....YXY..X.X",
|
||||
}, {
|
||||
x: "###z#z###### x #",
|
||||
y: "#y##Z#Z###### yy#",
|
||||
want: ".Y..M.M......XYY.",
|
||||
}, {
|
||||
x: "0 12z3x 456789 x x 0",
|
||||
y: "0y12Z3 y456789y y y0",
|
||||
want: ".Y..M.XY......YXYXY.",
|
||||
}, {
|
||||
x: "0 2 4 6 8 ..................abXXcdEXF.ghXi",
|
||||
y: " 1 3 5 7 9..................AB CDE F.GH I",
|
||||
want: "XYXYXYXYXY..................MMXXMM.X..MMXM",
|
||||
}, {
|
||||
x: "I HG.F EDC BA..................9 7 5 3 1 ",
|
||||
y: "iXhg.FXEdcXXba.................. 8 6 4 2 0",
|
||||
want: "MYMM..Y.MMYYMM..................XYXYXYXYXY",
|
||||
}, {
|
||||
x: "x1234",
|
||||
y: " 1234",
|
||||
want: "X....",
|
||||
}, {
|
||||
x: "x123x4",
|
||||
y: " 123 4",
|
||||
want: "X...X.",
|
||||
}, {
|
||||
x: "x1234x56",
|
||||
y: " 1234 ",
|
||||
want: "X....XXX",
|
||||
}, {
|
||||
x: "x1234xxx56",
|
||||
y: " 1234 56",
|
||||
want: "X....XXX..",
|
||||
}, {
|
||||
x: ".1234...ab",
|
||||
y: " 1234 AB",
|
||||
want: "X....XXXMM",
|
||||
}, {
|
||||
x: "x1234xxab.",
|
||||
y: " 1234 AB ",
|
||||
want: "X....XXMMX",
|
||||
}, {
|
||||
x: " 0123456789",
|
||||
y: "9012345678 ",
|
||||
want: "Y.........X",
|
||||
}, {
|
||||
x: " 0123456789",
|
||||
y: "8901234567 ",
|
||||
want: "YY........XX",
|
||||
}, {
|
||||
x: " 0123456789",
|
||||
y: "7890123456 ",
|
||||
want: "YYY.......XXX",
|
||||
}, {
|
||||
x: " 0123456789",
|
||||
y: "6789012345 ",
|
||||
want: "YYYY......XXXX",
|
||||
}, {
|
||||
x: "0123456789 ",
|
||||
y: " 5678901234",
|
||||
want: "XXXXX.....YYYYY",
|
||||
}, {
|
||||
x: "0123456789 ",
|
||||
y: " 4567890123",
|
||||
want: "XXXX......YYYY",
|
||||
}, {
|
||||
x: "0123456789 ",
|
||||
y: " 3456789012",
|
||||
want: "XXX.......YYY",
|
||||
}, {
|
||||
x: "0123456789 ",
|
||||
y: " 2345678901",
|
||||
want: "XX........YY",
|
||||
}, {
|
||||
x: "0123456789 ",
|
||||
y: " 1234567890",
|
||||
want: "X.........Y",
|
||||
}, {
|
||||
x: "0123456789",
|
||||
y: "9876543210",
|
||||
}, {
|
||||
x: "0123456789",
|
||||
y: "6725819034",
|
||||
}, {
|
||||
x: "FBQMOIGTLN72X90E4SP651HKRJUDA83CVZW",
|
||||
y: "5WHXO10R9IVKZLCTAJ8P3NSEQM472G6UBDF",
|
||||
}}
|
||||
|
||||
for _, tt := range tests {
|
||||
tRun(t, "", func(t *testing.T) {
|
||||
x := strings.Replace(tt.x, " ", "", -1)
|
||||
y := strings.Replace(tt.y, " ", "", -1)
|
||||
es := testStrings(t, x, y)
|
||||
if got := es.String(); got != tt.want {
|
||||
t.Errorf("Difference(%s, %s):\ngot %s\nwant %s", x, y, got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestDifferenceFuzz(t *testing.T) {
|
||||
tests := []struct{ px, py, pm float32 }{
|
||||
{px: 0.0, py: 0.0, pm: 0.1},
|
||||
{px: 0.0, py: 0.1, pm: 0.0},
|
||||
{px: 0.1, py: 0.0, pm: 0.0},
|
||||
{px: 0.0, py: 0.1, pm: 0.1},
|
||||
{px: 0.1, py: 0.0, pm: 0.1},
|
||||
{px: 0.2, py: 0.2, pm: 0.2},
|
||||
{px: 0.3, py: 0.1, pm: 0.2},
|
||||
{px: 0.1, py: 0.3, pm: 0.2},
|
||||
{px: 0.2, py: 0.2, pm: 0.2},
|
||||
{px: 0.3, py: 0.3, pm: 0.3},
|
||||
{px: 0.1, py: 0.1, pm: 0.5},
|
||||
{px: 0.4, py: 0.1, pm: 0.5},
|
||||
{px: 0.3, py: 0.2, pm: 0.5},
|
||||
{px: 0.2, py: 0.3, pm: 0.5},
|
||||
{px: 0.1, py: 0.4, pm: 0.5},
|
||||
}
|
||||
|
||||
for i, tt := range tests {
|
||||
tRun(t, fmt.Sprintf("P%d", i), func(t *testing.T) {
|
||||
// Sweep from 1B to 1KiB.
|
||||
for n := 1; n <= 1024; n <<= 1 {
|
||||
tRun(t, fmt.Sprintf("N%d", n), func(t *testing.T) {
|
||||
for j := 0; j < 10; j++ {
|
||||
x, y := generateStrings(n, tt.px, tt.py, tt.pm, int64(j))
|
||||
testStrings(t, x, y)
|
||||
}
|
||||
})
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkDifference(b *testing.B, n int) {
|
||||
// TODO: Use testing.B.Run when we drop Go1.6 support.
|
||||
x, y := generateStrings(n, 0.05, 0.05, 0.10, 0)
|
||||
b.ReportAllocs()
|
||||
b.SetBytes(int64(len(x) + len(y)))
|
||||
for i := 0; i < b.N; i++ {
|
||||
Difference(len(x), len(y), func(ix, iy int) Result {
|
||||
return compareByte(x[ix], y[iy])
|
||||
})
|
||||
}
|
||||
}
|
||||
func BenchmarkDifference1K(b *testing.B) { benchmarkDifference(b, 1<<10) }
|
||||
func BenchmarkDifference4K(b *testing.B) { benchmarkDifference(b, 1<<12) }
|
||||
func BenchmarkDifference16K(b *testing.B) { benchmarkDifference(b, 1<<14) }
|
||||
func BenchmarkDifference64K(b *testing.B) { benchmarkDifference(b, 1<<16) }
|
||||
func BenchmarkDifference256K(b *testing.B) { benchmarkDifference(b, 1<<18) }
|
||||
func BenchmarkDifference1M(b *testing.B) { benchmarkDifference(b, 1<<20) }
|
||||
|
||||
func generateStrings(n int, px, py, pm float32, seed int64) (string, string) {
|
||||
if px+py+pm > 1.0 {
|
||||
panic("invalid probabilities")
|
||||
}
|
||||
py += px
|
||||
pm += py
|
||||
|
||||
b := make([]byte, n)
|
||||
r := rand.New(rand.NewSource(seed))
|
||||
r.Read(b)
|
||||
|
||||
var x, y []byte
|
||||
for len(b) > 0 {
|
||||
switch p := r.Float32(); {
|
||||
case p < px: // UniqueX
|
||||
x = append(x, b[0])
|
||||
case p < py: // UniqueY
|
||||
y = append(y, b[0])
|
||||
case p < pm: // Modified
|
||||
x = append(x, 'A'+(b[0]%26))
|
||||
y = append(y, 'a'+(b[0]%26))
|
||||
default: // Identity
|
||||
x = append(x, b[0])
|
||||
y = append(y, b[0])
|
||||
}
|
||||
b = b[1:]
|
||||
}
|
||||
return string(x), string(y)
|
||||
}
|
||||
|
||||
func testStrings(t *testing.T, x, y string) EditScript {
|
||||
wantEq := x == y
|
||||
eq, es := Difference(len(x), len(y), func(ix, iy int) Result {
|
||||
return compareByte(x[ix], y[iy])
|
||||
})
|
||||
if eq != wantEq {
|
||||
t.Errorf("equality mismatch: got %v, want %v", eq, wantEq)
|
||||
}
|
||||
if es != nil {
|
||||
if es.LenX() != len(x) {
|
||||
t.Errorf("es.LenX = %d, want %d", es.LenX(), len(x))
|
||||
}
|
||||
if es.LenY() != len(y) {
|
||||
t.Errorf("es.LenY = %d, want %d", es.LenY(), len(y))
|
||||
}
|
||||
if got := (es.Dist() == 0); got != wantEq {
|
||||
t.Errorf("violation of equality invariant: got %v, want %v", got, wantEq)
|
||||
}
|
||||
if !validateScript(x, y, es) {
|
||||
t.Errorf("invalid edit script: %v", es)
|
||||
}
|
||||
}
|
||||
return es
|
||||
}
|
||||
|
||||
func validateScript(x, y string, es EditScript) bool {
|
||||
var bx, by []byte
|
||||
for _, e := range es {
|
||||
switch e {
|
||||
case Identity:
|
||||
if !compareByte(x[len(bx)], y[len(by)]).Equal() {
|
||||
return false
|
||||
}
|
||||
bx = append(bx, x[len(bx)])
|
||||
by = append(by, y[len(by)])
|
||||
case UniqueX:
|
||||
bx = append(bx, x[len(bx)])
|
||||
case UniqueY:
|
||||
by = append(by, y[len(by)])
|
||||
case Modified:
|
||||
if !compareByte(x[len(bx)], y[len(by)]).Similar() {
|
||||
return false
|
||||
}
|
||||
bx = append(bx, x[len(bx)])
|
||||
by = append(by, y[len(by)])
|
||||
}
|
||||
}
|
||||
return string(bx) == x && string(by) == y
|
||||
}
|
||||
|
||||
// compareByte returns a Result where the result is Equal if x == y,
|
||||
// similar if x and y differ only in casing, and different otherwise.
|
||||
func compareByte(x, y byte) (r Result) {
|
||||
switch {
|
||||
case x == y:
|
||||
return equalResult // Identity
|
||||
case unicode.ToUpper(rune(x)) == unicode.ToUpper(rune(y)):
|
||||
return similarResult // Modified
|
||||
default:
|
||||
return differentResult // UniqueX or UniqueY
|
||||
}
|
||||
}
|
||||
|
||||
var (
|
||||
equalResult = Result{NDiff: 0}
|
||||
similarResult = Result{NDiff: 1}
|
||||
differentResult = Result{NDiff: 2}
|
||||
)
|
||||
|
||||
func TestResult(t *testing.T) {
|
||||
tests := []struct {
|
||||
result Result
|
||||
wantEqual bool
|
||||
wantSimilar bool
|
||||
}{
|
||||
// equalResult is equal since NDiff == 0, by definition of Equal method.
|
||||
{equalResult, true, true},
|
||||
// similarResult is similar since it is a binary result where only one
|
||||
// element was compared (i.e., Either NSame==1 or NDiff==1).
|
||||
{similarResult, false, true},
|
||||
// differentResult is different since there are enough differences that
|
||||
// it isn't even considered similar.
|
||||
{differentResult, false, false},
|
||||
|
||||
// Zero value is always equal.
|
||||
{Result{NSame: 0, NDiff: 0}, true, true},
|
||||
|
||||
// Binary comparisons (where NSame+NDiff == 1) are always similar.
|
||||
{Result{NSame: 1, NDiff: 0}, true, true},
|
||||
{Result{NSame: 0, NDiff: 1}, false, true},
|
||||
|
||||
// More complex ratios. The exact ratio for similarity may change,
|
||||
// and may require updates to these test cases.
|
||||
{Result{NSame: 1, NDiff: 1}, false, true},
|
||||
{Result{NSame: 1, NDiff: 2}, false, true},
|
||||
{Result{NSame: 1, NDiff: 3}, false, false},
|
||||
{Result{NSame: 2, NDiff: 1}, false, true},
|
||||
{Result{NSame: 2, NDiff: 2}, false, true},
|
||||
{Result{NSame: 2, NDiff: 3}, false, true},
|
||||
{Result{NSame: 3, NDiff: 1}, false, true},
|
||||
{Result{NSame: 3, NDiff: 2}, false, true},
|
||||
{Result{NSame: 3, NDiff: 3}, false, true},
|
||||
{Result{NSame: 1000, NDiff: 0}, true, true},
|
||||
{Result{NSame: 1000, NDiff: 1}, false, true},
|
||||
{Result{NSame: 1000, NDiff: 2}, false, true},
|
||||
{Result{NSame: 0, NDiff: 1000}, false, false},
|
||||
{Result{NSame: 1, NDiff: 1000}, false, false},
|
||||
{Result{NSame: 2, NDiff: 1000}, false, false},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
if got := tt.result.Equal(); got != tt.wantEqual {
|
||||
t.Errorf("%#v.Equal() = %v, want %v", tt.result, got, tt.wantEqual)
|
||||
}
|
||||
if got := tt.result.Similar(); got != tt.wantSimilar {
|
||||
t.Errorf("%#v.Similar() = %v, want %v", tt.result, got, tt.wantSimilar)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Delete this hack when we drop Go1.6 support.
|
||||
func tRun(t *testing.T, name string, f func(t *testing.T)) {
|
||||
type runner interface {
|
||||
Run(string, func(t *testing.T)) bool
|
||||
}
|
||||
var ti interface{} = t
|
||||
if r, ok := ti.(runner); ok {
|
||||
r.Run(name, f)
|
||||
} else {
|
||||
t.Logf("Test: %s", name)
|
||||
f(t)
|
||||
}
|
||||
}
|
||||
-116
@@ -1,116 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package testprotos
|
||||
|
||||
func Equal(x, y Message) bool {
|
||||
if x == nil || y == nil {
|
||||
return x == nil && y == nil
|
||||
}
|
||||
return x.String() == y.String()
|
||||
}
|
||||
|
||||
type Message interface {
|
||||
Proto()
|
||||
String() string
|
||||
}
|
||||
|
||||
type proto interface {
|
||||
Proto()
|
||||
}
|
||||
|
||||
type notComparable struct {
|
||||
unexportedField func()
|
||||
}
|
||||
|
||||
type Stringer struct{ X string }
|
||||
|
||||
func (s *Stringer) String() string { return s.X }
|
||||
|
||||
// Project1 protocol buffers
|
||||
type (
|
||||
Eagle_States int
|
||||
Eagle_MissingCalls int
|
||||
Dreamer_States int
|
||||
Dreamer_MissingCalls int
|
||||
Slap_States int
|
||||
Goat_States int
|
||||
Donkey_States int
|
||||
SummerType int
|
||||
|
||||
Eagle struct {
|
||||
proto
|
||||
notComparable
|
||||
Stringer
|
||||
}
|
||||
Dreamer struct {
|
||||
proto
|
||||
notComparable
|
||||
Stringer
|
||||
}
|
||||
Slap struct {
|
||||
proto
|
||||
notComparable
|
||||
Stringer
|
||||
}
|
||||
Goat struct {
|
||||
proto
|
||||
notComparable
|
||||
Stringer
|
||||
}
|
||||
Donkey struct {
|
||||
proto
|
||||
notComparable
|
||||
Stringer
|
||||
}
|
||||
)
|
||||
|
||||
// Project2 protocol buffers
|
||||
type (
|
||||
Germ struct {
|
||||
proto
|
||||
notComparable
|
||||
Stringer
|
||||
}
|
||||
Dish struct {
|
||||
proto
|
||||
notComparable
|
||||
Stringer
|
||||
}
|
||||
)
|
||||
|
||||
// Project3 protocol buffers
|
||||
type (
|
||||
Dirt struct {
|
||||
proto
|
||||
notComparable
|
||||
Stringer
|
||||
}
|
||||
Wizard struct {
|
||||
proto
|
||||
notComparable
|
||||
Stringer
|
||||
}
|
||||
Sadistic struct {
|
||||
proto
|
||||
notComparable
|
||||
Stringer
|
||||
}
|
||||
)
|
||||
|
||||
// Project4 protocol buffers
|
||||
type (
|
||||
HoneyStatus int
|
||||
PoisonType int
|
||||
MetaData struct {
|
||||
proto
|
||||
notComparable
|
||||
Stringer
|
||||
}
|
||||
Restrictions struct {
|
||||
proto
|
||||
notComparable
|
||||
Stringer
|
||||
}
|
||||
)
|
||||
-267
@@ -1,267 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package teststructs
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
pb "github.com/google/go-cmp/cmp/internal/testprotos"
|
||||
)
|
||||
|
||||
// This is an sanitized example of equality from a real use-case.
|
||||
// The original equality function was as follows:
|
||||
/*
|
||||
func equalEagle(x, y Eagle) bool {
|
||||
if x.Name != y.Name &&
|
||||
!reflect.DeepEqual(x.Hounds, y.Hounds) &&
|
||||
x.Desc != y.Desc &&
|
||||
x.DescLong != y.DescLong &&
|
||||
x.Prong != y.Prong &&
|
||||
x.StateGoverner != y.StateGoverner &&
|
||||
x.PrankRating != y.PrankRating &&
|
||||
x.FunnyPrank != y.FunnyPrank &&
|
||||
!pb.Equal(x.Immutable.Proto(), y.Immutable.Proto()) {
|
||||
return false
|
||||
}
|
||||
|
||||
if len(x.Dreamers) != len(y.Dreamers) {
|
||||
return false
|
||||
}
|
||||
for i := range x.Dreamers {
|
||||
if !equalDreamer(x.Dreamers[i], y.Dreamers[i]) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
if len(x.Slaps) != len(y.Slaps) {
|
||||
return false
|
||||
}
|
||||
for i := range x.Slaps {
|
||||
if !equalSlap(x.Slaps[i], y.Slaps[i]) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
func equalDreamer(x, y Dreamer) bool {
|
||||
if x.Name != y.Name ||
|
||||
x.Desc != y.Desc ||
|
||||
x.DescLong != y.DescLong ||
|
||||
x.ContSlapsInterval != y.ContSlapsInterval ||
|
||||
x.Ornamental != y.Ornamental ||
|
||||
x.Amoeba != y.Amoeba ||
|
||||
x.Heroes != y.Heroes ||
|
||||
x.FloppyDisk != y.FloppyDisk ||
|
||||
x.MightiestDuck != y.MightiestDuck ||
|
||||
x.FunnyPrank != y.FunnyPrank ||
|
||||
!pb.Equal(x.Immutable.Proto(), y.Immutable.Proto()) {
|
||||
|
||||
return false
|
||||
}
|
||||
if len(x.Animal) != len(y.Animal) {
|
||||
return false
|
||||
}
|
||||
for i := range x.Animal {
|
||||
vx := x.Animal[i]
|
||||
vy := y.Animal[i]
|
||||
if reflect.TypeOf(x.Animal) != reflect.TypeOf(y.Animal) {
|
||||
return false
|
||||
}
|
||||
switch vx.(type) {
|
||||
case Goat:
|
||||
if !equalGoat(vx.(Goat), vy.(Goat)) {
|
||||
return false
|
||||
}
|
||||
case Donkey:
|
||||
if !equalDonkey(vx.(Donkey), vy.(Donkey)) {
|
||||
return false
|
||||
}
|
||||
default:
|
||||
panic(fmt.Sprintf("unknown type: %T", vx))
|
||||
}
|
||||
}
|
||||
if len(x.PreSlaps) != len(y.PreSlaps) {
|
||||
return false
|
||||
}
|
||||
for i := range x.PreSlaps {
|
||||
if !equalSlap(x.PreSlaps[i], y.PreSlaps[i]) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
if len(x.ContSlaps) != len(y.ContSlaps) {
|
||||
return false
|
||||
}
|
||||
for i := range x.ContSlaps {
|
||||
if !equalSlap(x.ContSlaps[i], y.ContSlaps[i]) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
func equalSlap(x, y Slap) bool {
|
||||
return x.Name == y.Name &&
|
||||
x.Desc == y.Desc &&
|
||||
x.DescLong == y.DescLong &&
|
||||
pb.Equal(x.Args, y.Args) &&
|
||||
x.Tense == y.Tense &&
|
||||
x.Interval == y.Interval &&
|
||||
x.Homeland == y.Homeland &&
|
||||
x.FunnyPrank == y.FunnyPrank &&
|
||||
pb.Equal(x.Immutable.Proto(), y.Immutable.Proto())
|
||||
}
|
||||
func equalGoat(x, y Goat) bool {
|
||||
if x.Target != y.Target ||
|
||||
x.FunnyPrank != y.FunnyPrank ||
|
||||
!pb.Equal(x.Immutable.Proto(), y.Immutable.Proto()) {
|
||||
return false
|
||||
}
|
||||
if len(x.Slaps) != len(y.Slaps) {
|
||||
return false
|
||||
}
|
||||
for i := range x.Slaps {
|
||||
if !equalSlap(x.Slaps[i], y.Slaps[i]) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
func equalDonkey(x, y Donkey) bool {
|
||||
return x.Pause == y.Pause &&
|
||||
x.Sleep == y.Sleep &&
|
||||
x.FunnyPrank == y.FunnyPrank &&
|
||||
pb.Equal(x.Immutable.Proto(), y.Immutable.Proto())
|
||||
}
|
||||
*/
|
||||
|
||||
type Eagle struct {
|
||||
Name string
|
||||
Hounds []string
|
||||
Desc string
|
||||
DescLong string
|
||||
Dreamers []Dreamer
|
||||
Prong int64
|
||||
Slaps []Slap
|
||||
StateGoverner string
|
||||
PrankRating string
|
||||
FunnyPrank string
|
||||
Immutable *EagleImmutable
|
||||
}
|
||||
|
||||
type EagleImmutable struct {
|
||||
ID string
|
||||
State *pb.Eagle_States
|
||||
MissingCall *pb.Eagle_MissingCalls
|
||||
Birthday time.Time
|
||||
Death time.Time
|
||||
Started time.Time
|
||||
LastUpdate time.Time
|
||||
Creator string
|
||||
empty bool
|
||||
}
|
||||
|
||||
type Dreamer struct {
|
||||
Name string
|
||||
Desc string
|
||||
DescLong string
|
||||
PreSlaps []Slap
|
||||
ContSlaps []Slap
|
||||
ContSlapsInterval int32
|
||||
Animal []interface{} // Could be either Goat or Donkey
|
||||
Ornamental bool
|
||||
Amoeba int64
|
||||
Heroes int32
|
||||
FloppyDisk int32
|
||||
MightiestDuck bool
|
||||
FunnyPrank string
|
||||
Immutable *DreamerImmutable
|
||||
}
|
||||
|
||||
type DreamerImmutable struct {
|
||||
ID string
|
||||
State *pb.Dreamer_States
|
||||
MissingCall *pb.Dreamer_MissingCalls
|
||||
Calls int32
|
||||
Started time.Time
|
||||
Stopped time.Time
|
||||
LastUpdate time.Time
|
||||
empty bool
|
||||
}
|
||||
|
||||
type Slap struct {
|
||||
Name string
|
||||
Desc string
|
||||
DescLong string
|
||||
Args pb.Message
|
||||
Tense int32
|
||||
Interval int32
|
||||
Homeland uint32
|
||||
FunnyPrank string
|
||||
Immutable *SlapImmutable
|
||||
}
|
||||
|
||||
type SlapImmutable struct {
|
||||
ID string
|
||||
Out pb.Message
|
||||
MildSlap bool
|
||||
PrettyPrint string
|
||||
State *pb.Slap_States
|
||||
Started time.Time
|
||||
Stopped time.Time
|
||||
LastUpdate time.Time
|
||||
LoveRadius *LoveRadius
|
||||
empty bool
|
||||
}
|
||||
|
||||
type Goat struct {
|
||||
Target string
|
||||
Slaps []Slap
|
||||
FunnyPrank string
|
||||
Immutable *GoatImmutable
|
||||
}
|
||||
|
||||
type GoatImmutable struct {
|
||||
ID string
|
||||
State *pb.Goat_States
|
||||
Started time.Time
|
||||
Stopped time.Time
|
||||
LastUpdate time.Time
|
||||
empty bool
|
||||
}
|
||||
type Donkey struct {
|
||||
Pause bool
|
||||
Sleep int32
|
||||
FunnyPrank string
|
||||
Immutable *DonkeyImmutable
|
||||
}
|
||||
|
||||
type DonkeyImmutable struct {
|
||||
ID string
|
||||
State *pb.Donkey_States
|
||||
Started time.Time
|
||||
Stopped time.Time
|
||||
LastUpdate time.Time
|
||||
empty bool
|
||||
}
|
||||
|
||||
type LoveRadius struct {
|
||||
Summer *SummerLove
|
||||
empty bool
|
||||
}
|
||||
|
||||
type SummerLove struct {
|
||||
Summary *SummerLoveSummary
|
||||
empty bool
|
||||
}
|
||||
|
||||
type SummerLoveSummary struct {
|
||||
Devices []string
|
||||
ChangeType []pb.SummerType
|
||||
empty bool
|
||||
}
|
||||
|
||||
func (EagleImmutable) Proto() *pb.Eagle { return nil }
|
||||
func (DreamerImmutable) Proto() *pb.Dreamer { return nil }
|
||||
func (SlapImmutable) Proto() *pb.Slap { return nil }
|
||||
func (GoatImmutable) Proto() *pb.Goat { return nil }
|
||||
func (DonkeyImmutable) Proto() *pb.Donkey { return nil }
|
||||
-74
@@ -1,74 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package teststructs
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
pb "github.com/google/go-cmp/cmp/internal/testprotos"
|
||||
)
|
||||
|
||||
// This is an sanitized example of equality from a real use-case.
|
||||
// The original equality function was as follows:
|
||||
/*
|
||||
func equalBatch(b1, b2 *GermBatch) bool {
|
||||
for _, b := range []*GermBatch{b1, b2} {
|
||||
for _, l := range b.DirtyGerms {
|
||||
sort.Slice(l, func(i, j int) bool { return l[i].String() < l[j].String() })
|
||||
}
|
||||
for _, l := range b.CleanGerms {
|
||||
sort.Slice(l, func(i, j int) bool { return l[i].String() < l[j].String() })
|
||||
}
|
||||
}
|
||||
if !pb.DeepEqual(b1.DirtyGerms, b2.DirtyGerms) ||
|
||||
!pb.DeepEqual(b1.CleanGerms, b2.CleanGerms) ||
|
||||
!pb.DeepEqual(b1.GermMap, b2.GermMap) {
|
||||
return false
|
||||
}
|
||||
if len(b1.DishMap) != len(b2.DishMap) {
|
||||
return false
|
||||
}
|
||||
for id := range b1.DishMap {
|
||||
kpb1, err1 := b1.DishMap[id].Proto()
|
||||
kpb2, err2 := b2.DishMap[id].Proto()
|
||||
if !pb.Equal(kpb1, kpb2) || !reflect.DeepEqual(err1, err2) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return b1.HasPreviousResult == b2.HasPreviousResult &&
|
||||
b1.DirtyID == b2.DirtyID &&
|
||||
b1.CleanID == b2.CleanID &&
|
||||
b1.GermStrain == b2.GermStrain &&
|
||||
b1.TotalDirtyGerms == b2.TotalDirtyGerms &&
|
||||
b1.InfectedAt.Equal(b2.InfectedAt)
|
||||
}
|
||||
*/
|
||||
|
||||
type GermBatch struct {
|
||||
DirtyGerms, CleanGerms map[int32][]*pb.Germ
|
||||
GermMap map[int32]*pb.Germ
|
||||
DishMap map[int32]*Dish
|
||||
HasPreviousResult bool
|
||||
DirtyID, CleanID int32
|
||||
GermStrain int32
|
||||
TotalDirtyGerms int
|
||||
InfectedAt time.Time
|
||||
}
|
||||
|
||||
type Dish struct {
|
||||
pb *pb.Dish
|
||||
err error
|
||||
}
|
||||
|
||||
func CreateDish(m *pb.Dish, err error) *Dish {
|
||||
return &Dish{pb: m, err: err}
|
||||
}
|
||||
|
||||
func (d *Dish) Proto() (*pb.Dish, error) {
|
||||
if d.err != nil {
|
||||
return nil, d.err
|
||||
}
|
||||
return d.pb, nil
|
||||
}
|
||||
-77
@@ -1,77 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package teststructs
|
||||
|
||||
import (
|
||||
"sync"
|
||||
|
||||
pb "github.com/google/go-cmp/cmp/internal/testprotos"
|
||||
)
|
||||
|
||||
// This is an sanitized example of equality from a real use-case.
|
||||
// The original equality function was as follows:
|
||||
/*
|
||||
func equalDirt(x, y *Dirt) bool {
|
||||
if !reflect.DeepEqual(x.table, y.table) ||
|
||||
!reflect.DeepEqual(x.ts, y.ts) ||
|
||||
x.Discord != y.Discord ||
|
||||
!pb.Equal(&x.Proto, &y.Proto) ||
|
||||
len(x.wizard) != len(y.wizard) ||
|
||||
len(x.sadistic) != len(y.sadistic) ||
|
||||
x.lastTime != y.lastTime {
|
||||
return false
|
||||
}
|
||||
for k, vx := range x.wizard {
|
||||
vy, ok := y.wizard[k]
|
||||
if !ok || !pb.Equal(vx, vy) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
for k, vx := range x.sadistic {
|
||||
vy, ok := y.sadistic[k]
|
||||
if !ok || !pb.Equal(vx, vy) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
*/
|
||||
|
||||
type Dirt struct {
|
||||
table Table // Always concrete type of MockTable
|
||||
ts Timestamp
|
||||
Discord DiscordState
|
||||
Proto pb.Dirt
|
||||
wizard map[string]*pb.Wizard
|
||||
sadistic map[string]*pb.Sadistic
|
||||
lastTime int64
|
||||
mu sync.Mutex
|
||||
}
|
||||
|
||||
type DiscordState int
|
||||
|
||||
type Timestamp int64
|
||||
|
||||
func (d *Dirt) SetTable(t Table) { d.table = t }
|
||||
func (d *Dirt) SetTimestamp(t Timestamp) { d.ts = t }
|
||||
func (d *Dirt) SetWizard(m map[string]*pb.Wizard) { d.wizard = m }
|
||||
func (d *Dirt) SetSadistic(m map[string]*pb.Sadistic) { d.sadistic = m }
|
||||
func (d *Dirt) SetLastTime(t int64) { d.lastTime = t }
|
||||
|
||||
type Table interface {
|
||||
Operation1() error
|
||||
Operation2() error
|
||||
Operation3() error
|
||||
}
|
||||
|
||||
type MockTable struct {
|
||||
state []string
|
||||
}
|
||||
|
||||
func CreateMockTable(s []string) *MockTable { return &MockTable{s} }
|
||||
func (mt *MockTable) Operation1() error { return nil }
|
||||
func (mt *MockTable) Operation2() error { return nil }
|
||||
func (mt *MockTable) Operation3() error { return nil }
|
||||
func (mt *MockTable) State() []string { return mt.state }
|
||||
-142
@@ -1,142 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package teststructs
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
pb "github.com/google/go-cmp/cmp/internal/testprotos"
|
||||
)
|
||||
|
||||
// This is an sanitized example of equality from a real use-case.
|
||||
// The original equality function was as follows:
|
||||
/*
|
||||
func equalCartel(x, y Cartel) bool {
|
||||
if !(equalHeadquarter(x.Headquarter, y.Headquarter) &&
|
||||
x.Source() == y.Source() &&
|
||||
x.CreationDate().Equal(y.CreationDate()) &&
|
||||
x.Boss() == y.Boss() &&
|
||||
x.LastCrimeDate().Equal(y.LastCrimeDate())) {
|
||||
return false
|
||||
}
|
||||
if len(x.Poisons()) != len(y.Poisons()) {
|
||||
return false
|
||||
}
|
||||
for i := range x.Poisons() {
|
||||
if !equalPoison(*x.Poisons()[i], *y.Poisons()[i]) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
func equalHeadquarter(x, y Headquarter) bool {
|
||||
xr, yr := x.Restrictions(), y.Restrictions()
|
||||
return x.ID() == y.ID() &&
|
||||
x.Location() == y.Location() &&
|
||||
reflect.DeepEqual(x.SubDivisions(), y.SubDivisions()) &&
|
||||
x.IncorporatedDate().Equal(y.IncorporatedDate()) &&
|
||||
pb.Equal(x.MetaData(), y.MetaData()) &&
|
||||
bytes.Equal(x.PrivateMessage(), y.PrivateMessage()) &&
|
||||
bytes.Equal(x.PublicMessage(), y.PublicMessage()) &&
|
||||
x.HorseBack() == y.HorseBack() &&
|
||||
x.Rattle() == y.Rattle() &&
|
||||
x.Convulsion() == y.Convulsion() &&
|
||||
x.Expansion() == y.Expansion() &&
|
||||
x.Status() == y.Status() &&
|
||||
pb.Equal(&xr, &yr) &&
|
||||
x.CreationTime().Equal(y.CreationTime())
|
||||
}
|
||||
func equalPoison(x, y Poison) bool {
|
||||
return x.PoisonType() == y.PoisonType() &&
|
||||
x.Expiration().Equal(y.Expiration()) &&
|
||||
x.Manufactuer() == y.Manufactuer() &&
|
||||
x.Potency() == y.Potency()
|
||||
}
|
||||
*/
|
||||
|
||||
type Cartel struct {
|
||||
Headquarter
|
||||
source string
|
||||
creationDate time.Time
|
||||
boss string
|
||||
lastCrimeDate time.Time
|
||||
poisons []*Poison
|
||||
}
|
||||
|
||||
func (p Cartel) Source() string { return p.source }
|
||||
func (p Cartel) CreationDate() time.Time { return p.creationDate }
|
||||
func (p Cartel) Boss() string { return p.boss }
|
||||
func (p Cartel) LastCrimeDate() time.Time { return p.lastCrimeDate }
|
||||
func (p Cartel) Poisons() []*Poison { return p.poisons }
|
||||
|
||||
func (p *Cartel) SetSource(x string) { p.source = x }
|
||||
func (p *Cartel) SetCreationDate(x time.Time) { p.creationDate = x }
|
||||
func (p *Cartel) SetBoss(x string) { p.boss = x }
|
||||
func (p *Cartel) SetLastCrimeDate(x time.Time) { p.lastCrimeDate = x }
|
||||
func (p *Cartel) SetPoisons(x []*Poison) { p.poisons = x }
|
||||
|
||||
type Headquarter struct {
|
||||
id uint64
|
||||
location string
|
||||
subDivisions []string
|
||||
incorporatedDate time.Time
|
||||
metaData *pb.MetaData
|
||||
privateMessage []byte
|
||||
publicMessage []byte
|
||||
horseBack string
|
||||
rattle string
|
||||
convulsion bool
|
||||
expansion uint64
|
||||
status pb.HoneyStatus
|
||||
restrictions pb.Restrictions
|
||||
creationTime time.Time
|
||||
}
|
||||
|
||||
func (hq Headquarter) ID() uint64 { return hq.id }
|
||||
func (hq Headquarter) Location() string { return hq.location }
|
||||
func (hq Headquarter) SubDivisions() []string { return hq.subDivisions }
|
||||
func (hq Headquarter) IncorporatedDate() time.Time { return hq.incorporatedDate }
|
||||
func (hq Headquarter) MetaData() *pb.MetaData { return hq.metaData }
|
||||
func (hq Headquarter) PrivateMessage() []byte { return hq.privateMessage }
|
||||
func (hq Headquarter) PublicMessage() []byte { return hq.publicMessage }
|
||||
func (hq Headquarter) HorseBack() string { return hq.horseBack }
|
||||
func (hq Headquarter) Rattle() string { return hq.rattle }
|
||||
func (hq Headquarter) Convulsion() bool { return hq.convulsion }
|
||||
func (hq Headquarter) Expansion() uint64 { return hq.expansion }
|
||||
func (hq Headquarter) Status() pb.HoneyStatus { return hq.status }
|
||||
func (hq Headquarter) Restrictions() pb.Restrictions { return hq.restrictions }
|
||||
func (hq Headquarter) CreationTime() time.Time { return hq.creationTime }
|
||||
|
||||
func (hq *Headquarter) SetID(x uint64) { hq.id = x }
|
||||
func (hq *Headquarter) SetLocation(x string) { hq.location = x }
|
||||
func (hq *Headquarter) SetSubDivisions(x []string) { hq.subDivisions = x }
|
||||
func (hq *Headquarter) SetIncorporatedDate(x time.Time) { hq.incorporatedDate = x }
|
||||
func (hq *Headquarter) SetMetaData(x *pb.MetaData) { hq.metaData = x }
|
||||
func (hq *Headquarter) SetPrivateMessage(x []byte) { hq.privateMessage = x }
|
||||
func (hq *Headquarter) SetPublicMessage(x []byte) { hq.publicMessage = x }
|
||||
func (hq *Headquarter) SetHorseBack(x string) { hq.horseBack = x }
|
||||
func (hq *Headquarter) SetRattle(x string) { hq.rattle = x }
|
||||
func (hq *Headquarter) SetConvulsion(x bool) { hq.convulsion = x }
|
||||
func (hq *Headquarter) SetExpansion(x uint64) { hq.expansion = x }
|
||||
func (hq *Headquarter) SetStatus(x pb.HoneyStatus) { hq.status = x }
|
||||
func (hq *Headquarter) SetRestrictions(x pb.Restrictions) { hq.restrictions = x }
|
||||
func (hq *Headquarter) SetCreationTime(x time.Time) { hq.creationTime = x }
|
||||
|
||||
type Poison struct {
|
||||
poisonType pb.PoisonType
|
||||
expiration time.Time
|
||||
manufactuer string
|
||||
potency int
|
||||
}
|
||||
|
||||
func (p Poison) PoisonType() pb.PoisonType { return p.poisonType }
|
||||
func (p Poison) Expiration() time.Time { return p.expiration }
|
||||
func (p Poison) Manufactuer() string { return p.manufactuer }
|
||||
func (p Poison) Potency() int { return p.potency }
|
||||
|
||||
func (p *Poison) SetPoisonType(x pb.PoisonType) { p.poisonType = x }
|
||||
func (p *Poison) SetExpiration(x time.Time) { p.expiration = x }
|
||||
func (p *Poison) SetManufactuer(x string) { p.manufactuer = x }
|
||||
func (p *Poison) SetPotency(x int) { p.potency = x }
|
||||
-197
@@ -1,197 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package teststructs
|
||||
|
||||
type InterfaceA interface {
|
||||
InterfaceA()
|
||||
}
|
||||
|
||||
type (
|
||||
StructA struct{ X string } // Equal method on value receiver
|
||||
StructB struct{ X string } // Equal method on pointer receiver
|
||||
StructC struct{ X string } // Equal method (with interface argument) on value receiver
|
||||
StructD struct{ X string } // Equal method (with interface argument) on pointer receiver
|
||||
StructE struct{ X string } // Equal method (with interface argument on value receiver) on pointer receiver
|
||||
StructF struct{ X string } // Equal method (with interface argument on pointer receiver) on value receiver
|
||||
|
||||
// These embed the above types as a value.
|
||||
StructA1 struct {
|
||||
StructA
|
||||
X string
|
||||
}
|
||||
StructB1 struct {
|
||||
StructB
|
||||
X string
|
||||
}
|
||||
StructC1 struct {
|
||||
StructC
|
||||
X string
|
||||
}
|
||||
StructD1 struct {
|
||||
StructD
|
||||
X string
|
||||
}
|
||||
StructE1 struct {
|
||||
StructE
|
||||
X string
|
||||
}
|
||||
StructF1 struct {
|
||||
StructF
|
||||
X string
|
||||
}
|
||||
|
||||
// These embed the above types as a pointer.
|
||||
StructA2 struct {
|
||||
*StructA
|
||||
X string
|
||||
}
|
||||
StructB2 struct {
|
||||
*StructB
|
||||
X string
|
||||
}
|
||||
StructC2 struct {
|
||||
*StructC
|
||||
X string
|
||||
}
|
||||
StructD2 struct {
|
||||
*StructD
|
||||
X string
|
||||
}
|
||||
StructE2 struct {
|
||||
*StructE
|
||||
X string
|
||||
}
|
||||
StructF2 struct {
|
||||
*StructF
|
||||
X string
|
||||
}
|
||||
|
||||
StructNo struct{ X string } // Equal method (with interface argument) on non-satisfying receiver
|
||||
|
||||
AssignA func() int
|
||||
AssignB struct{ A int }
|
||||
AssignC chan bool
|
||||
AssignD <-chan bool
|
||||
)
|
||||
|
||||
func (x StructA) Equal(y StructA) bool { return true }
|
||||
func (x *StructB) Equal(y *StructB) bool { return true }
|
||||
func (x StructC) Equal(y InterfaceA) bool { return true }
|
||||
func (x StructC) InterfaceA() {}
|
||||
func (x *StructD) Equal(y InterfaceA) bool { return true }
|
||||
func (x *StructD) InterfaceA() {}
|
||||
func (x *StructE) Equal(y InterfaceA) bool { return true }
|
||||
func (x StructE) InterfaceA() {}
|
||||
func (x StructF) Equal(y InterfaceA) bool { return true }
|
||||
func (x *StructF) InterfaceA() {}
|
||||
func (x StructNo) Equal(y InterfaceA) bool { return true }
|
||||
|
||||
func (x AssignA) Equal(y func() int) bool { return true }
|
||||
func (x AssignB) Equal(y struct{ A int }) bool { return true }
|
||||
func (x AssignC) Equal(y chan bool) bool { return true }
|
||||
func (x AssignD) Equal(y <-chan bool) bool { return true }
|
||||
|
||||
var _ = func(
|
||||
a StructA, b StructB, c StructC, d StructD, e StructE, f StructF,
|
||||
ap *StructA, bp *StructB, cp *StructC, dp *StructD, ep *StructE, fp *StructF,
|
||||
a1 StructA1, b1 StructB1, c1 StructC1, d1 StructD1, e1 StructE1, f1 StructF1,
|
||||
a2 StructA2, b2 StructB2, c2 StructC2, d2 StructD2, e2 StructE2, f2 StructF1,
|
||||
) {
|
||||
a.Equal(a)
|
||||
b.Equal(&b)
|
||||
c.Equal(c)
|
||||
d.Equal(&d)
|
||||
e.Equal(e)
|
||||
f.Equal(&f)
|
||||
|
||||
ap.Equal(*ap)
|
||||
bp.Equal(bp)
|
||||
cp.Equal(*cp)
|
||||
dp.Equal(dp)
|
||||
ep.Equal(*ep)
|
||||
fp.Equal(fp)
|
||||
|
||||
a1.Equal(a1.StructA)
|
||||
b1.Equal(&b1.StructB)
|
||||
c1.Equal(c1)
|
||||
d1.Equal(&d1)
|
||||
e1.Equal(e1)
|
||||
f1.Equal(&f1)
|
||||
|
||||
a2.Equal(*a2.StructA)
|
||||
b2.Equal(b2.StructB)
|
||||
c2.Equal(c2)
|
||||
d2.Equal(&d2)
|
||||
e2.Equal(e2)
|
||||
f2.Equal(&f2)
|
||||
}
|
||||
|
||||
type (
|
||||
privateStruct struct{ Public, private int }
|
||||
PublicStruct struct{ Public, private int }
|
||||
ParentStructA struct{ privateStruct }
|
||||
ParentStructB struct{ PublicStruct }
|
||||
ParentStructC struct {
|
||||
privateStruct
|
||||
Public, private int
|
||||
}
|
||||
ParentStructD struct {
|
||||
PublicStruct
|
||||
Public, private int
|
||||
}
|
||||
ParentStructE struct {
|
||||
privateStruct
|
||||
PublicStruct
|
||||
}
|
||||
ParentStructF struct {
|
||||
privateStruct
|
||||
PublicStruct
|
||||
Public, private int
|
||||
}
|
||||
ParentStructG struct {
|
||||
*privateStruct
|
||||
}
|
||||
ParentStructH struct {
|
||||
*PublicStruct
|
||||
}
|
||||
ParentStructI struct {
|
||||
*privateStruct
|
||||
*PublicStruct
|
||||
}
|
||||
ParentStructJ struct {
|
||||
*privateStruct
|
||||
*PublicStruct
|
||||
Public PublicStruct
|
||||
private privateStruct
|
||||
}
|
||||
)
|
||||
|
||||
func NewParentStructG() *ParentStructG {
|
||||
return &ParentStructG{new(privateStruct)}
|
||||
}
|
||||
func NewParentStructH() *ParentStructH {
|
||||
return &ParentStructH{new(PublicStruct)}
|
||||
}
|
||||
func NewParentStructI() *ParentStructI {
|
||||
return &ParentStructI{new(privateStruct), new(PublicStruct)}
|
||||
}
|
||||
func NewParentStructJ() *ParentStructJ {
|
||||
return &ParentStructJ{
|
||||
privateStruct: new(privateStruct), PublicStruct: new(PublicStruct),
|
||||
}
|
||||
}
|
||||
func (s *privateStruct) SetPrivate(i int) { s.private = i }
|
||||
func (s *PublicStruct) SetPrivate(i int) { s.private = i }
|
||||
func (s *ParentStructC) SetPrivate(i int) { s.private = i }
|
||||
func (s *ParentStructD) SetPrivate(i int) { s.private = i }
|
||||
func (s *ParentStructF) SetPrivate(i int) { s.private = i }
|
||||
func (s *ParentStructA) PrivateStruct() *privateStruct { return &s.privateStruct }
|
||||
func (s *ParentStructC) PrivateStruct() *privateStruct { return &s.privateStruct }
|
||||
func (s *ParentStructE) PrivateStruct() *privateStruct { return &s.privateStruct }
|
||||
func (s *ParentStructF) PrivateStruct() *privateStruct { return &s.privateStruct }
|
||||
func (s *ParentStructG) PrivateStruct() *privateStruct { return s.privateStruct }
|
||||
func (s *ParentStructI) PrivateStruct() *privateStruct { return s.privateStruct }
|
||||
func (s *ParentStructJ) PrivateStruct() *privateStruct { return s.privateStruct }
|
||||
func (s *ParentStructJ) Private() *privateStruct { return &s.private }
|
||||
+48
-30
@@ -8,15 +8,11 @@ package value
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
"unicode"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
// formatFakePointers controls whether to substitute pointer addresses with nil.
|
||||
// This is used for deterministic testing.
|
||||
var formatFakePointers = false
|
||||
|
||||
var stringerIface = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
|
||||
|
||||
// Format formats the value v as a string.
|
||||
@@ -26,28 +22,35 @@ var stringerIface = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
|
||||
// * Avoids printing struct fields that are zero
|
||||
// * Prints a nil-slice as being nil, not empty
|
||||
// * Prints map entries in deterministic order
|
||||
func Format(v reflect.Value, useStringer bool) string {
|
||||
return formatAny(v, formatConfig{useStringer, true, true, !formatFakePointers}, nil)
|
||||
func Format(v reflect.Value, conf FormatConfig) string {
|
||||
conf.printType = true
|
||||
conf.followPointers = true
|
||||
conf.realPointers = true
|
||||
return formatAny(v, conf, nil)
|
||||
}
|
||||
|
||||
type formatConfig struct {
|
||||
useStringer bool // Should the String method be used if available?
|
||||
printType bool // Should we print the type before the value?
|
||||
followPointers bool // Should we recursively follow pointers?
|
||||
realPointers bool // Should we print the real address of pointers?
|
||||
type FormatConfig struct {
|
||||
UseStringer bool // Should the String method be used if available?
|
||||
printType bool // Should we print the type before the value?
|
||||
PrintPrimitiveType bool // Should we print the type of primitives?
|
||||
followPointers bool // Should we recursively follow pointers?
|
||||
realPointers bool // Should we print the real address of pointers?
|
||||
}
|
||||
|
||||
func formatAny(v reflect.Value, conf formatConfig, visited map[uintptr]bool) string {
|
||||
func formatAny(v reflect.Value, conf FormatConfig, visited map[uintptr]bool) string {
|
||||
// TODO: Should this be a multi-line printout in certain situations?
|
||||
|
||||
if !v.IsValid() {
|
||||
return "<non-existent>"
|
||||
}
|
||||
if conf.useStringer && v.Type().Implements(stringerIface) && v.CanInterface() {
|
||||
if conf.UseStringer && v.Type().Implements(stringerIface) && v.CanInterface() {
|
||||
if (v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface) && v.IsNil() {
|
||||
return "<nil>"
|
||||
}
|
||||
return fmt.Sprintf("%q", v.Interface().(fmt.Stringer).String())
|
||||
|
||||
const stringerPrefix = "s" // Indicates that the String method was used
|
||||
s := v.Interface().(fmt.Stringer).String()
|
||||
return stringerPrefix + formatString(s)
|
||||
}
|
||||
|
||||
switch v.Kind() {
|
||||
@@ -66,7 +69,7 @@ func formatAny(v reflect.Value, conf formatConfig, visited map[uintptr]bool) str
|
||||
case reflect.Complex64, reflect.Complex128:
|
||||
return formatPrimitive(v.Type(), v.Complex(), conf)
|
||||
case reflect.String:
|
||||
return formatPrimitive(v.Type(), fmt.Sprintf("%q", v), conf)
|
||||
return formatPrimitive(v.Type(), formatString(v.String()), conf)
|
||||
case reflect.UnsafePointer, reflect.Chan, reflect.Func:
|
||||
return formatPointer(v, conf)
|
||||
case reflect.Ptr:
|
||||
@@ -127,11 +130,13 @@ func formatAny(v reflect.Value, conf formatConfig, visited map[uintptr]bool) str
|
||||
visited = insertPointer(visited, v.Pointer())
|
||||
|
||||
var ss []string
|
||||
subConf := conf
|
||||
subConf.printType = v.Type().Elem().Kind() == reflect.Interface
|
||||
keyConf, valConf := conf, conf
|
||||
keyConf.printType = v.Type().Key().Kind() == reflect.Interface
|
||||
keyConf.followPointers = false
|
||||
valConf.printType = v.Type().Elem().Kind() == reflect.Interface
|
||||
for _, k := range SortKeys(v.MapKeys()) {
|
||||
sk := formatAny(k, formatConfig{realPointers: conf.realPointers}, visited)
|
||||
sv := formatAny(v.MapIndex(k), subConf, visited)
|
||||
sk := formatAny(k, keyConf, visited)
|
||||
sv := formatAny(v.MapIndex(k), valConf, visited)
|
||||
ss = append(ss, fmt.Sprintf("%s: %s", sk, sv))
|
||||
}
|
||||
s := fmt.Sprintf("{%s}", strings.Join(ss, ", "))
|
||||
@@ -149,7 +154,7 @@ func formatAny(v reflect.Value, conf formatConfig, visited map[uintptr]bool) str
|
||||
continue // Elide zero value fields
|
||||
}
|
||||
name := v.Type().Field(i).Name
|
||||
subConf.useStringer = conf.useStringer && isExported(name)
|
||||
subConf.UseStringer = conf.UseStringer
|
||||
s := formatAny(vv, subConf, visited)
|
||||
ss = append(ss, fmt.Sprintf("%s: %s", name, s))
|
||||
}
|
||||
@@ -163,14 +168,33 @@ func formatAny(v reflect.Value, conf formatConfig, visited map[uintptr]bool) str
|
||||
}
|
||||
}
|
||||
|
||||
func formatPrimitive(t reflect.Type, v interface{}, conf formatConfig) string {
|
||||
if conf.printType && t.PkgPath() != "" {
|
||||
func formatString(s string) string {
|
||||
// Use quoted string if it the same length as a raw string literal.
|
||||
// Otherwise, attempt to use the raw string form.
|
||||
qs := strconv.Quote(s)
|
||||
if len(qs) == 1+len(s)+1 {
|
||||
return qs
|
||||
}
|
||||
|
||||
// Disallow newlines to ensure output is a single line.
|
||||
// Only allow printable runes for readability purposes.
|
||||
rawInvalid := func(r rune) bool {
|
||||
return r == '`' || r == '\n' || !unicode.IsPrint(r)
|
||||
}
|
||||
if strings.IndexFunc(s, rawInvalid) < 0 {
|
||||
return "`" + s + "`"
|
||||
}
|
||||
return qs
|
||||
}
|
||||
|
||||
func formatPrimitive(t reflect.Type, v interface{}, conf FormatConfig) string {
|
||||
if conf.printType && (conf.PrintPrimitiveType || t.PkgPath() != "") {
|
||||
return fmt.Sprintf("%v(%v)", t, v)
|
||||
}
|
||||
return fmt.Sprintf("%v", v)
|
||||
}
|
||||
|
||||
func formatPointer(v reflect.Value, conf formatConfig) string {
|
||||
func formatPointer(v reflect.Value, conf FormatConfig) string {
|
||||
p := v.Pointer()
|
||||
if !conf.realPointers {
|
||||
p = 0 // For deterministic printing purposes
|
||||
@@ -251,9 +275,3 @@ func isZero(v reflect.Value) bool {
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// isExported reports whether the identifier is exported.
|
||||
func isExported(id string) bool {
|
||||
r, _ := utf8.DecodeRuneInString(id)
|
||||
return unicode.IsUpper(r)
|
||||
}
|
||||
|
||||
-91
@@ -1,91 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package value
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"io"
|
||||
"reflect"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestFormat(t *testing.T) {
|
||||
type key struct {
|
||||
a int
|
||||
b string
|
||||
c chan bool
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
in interface{}
|
||||
want string
|
||||
}{{
|
||||
in: []int{},
|
||||
want: "[]int{}",
|
||||
}, {
|
||||
in: []int(nil),
|
||||
want: "[]int(nil)",
|
||||
}, {
|
||||
in: []int{1, 2, 3, 4, 5},
|
||||
want: "[]int{1, 2, 3, 4, 5}",
|
||||
}, {
|
||||
in: []interface{}{1, true, "hello", struct{ A, B int }{1, 2}},
|
||||
want: "[]interface {}{1, true, \"hello\", struct { A int; B int }{A: 1, B: 2}}",
|
||||
}, {
|
||||
in: []struct{ A, B int }{{1, 2}, {0, 4}, {}},
|
||||
want: "[]struct { A int; B int }{{A: 1, B: 2}, {B: 4}, {}}",
|
||||
}, {
|
||||
in: map[*int]string{new(int): "hello"},
|
||||
want: "map[*int]string{0x00: \"hello\"}",
|
||||
}, {
|
||||
in: map[key]string{{}: "hello"},
|
||||
want: "map[value.key]string{{}: \"hello\"}",
|
||||
}, {
|
||||
in: map[key]string{{a: 5, b: "key", c: make(chan bool)}: "hello"},
|
||||
want: "map[value.key]string{{a: 5, b: \"key\", c: (chan bool)(0x00)}: \"hello\"}",
|
||||
}, {
|
||||
in: map[io.Reader]string{new(bytes.Reader): "hello"},
|
||||
want: "map[io.Reader]string{0x00: \"hello\"}",
|
||||
}, {
|
||||
in: func() interface{} {
|
||||
var a = []interface{}{nil}
|
||||
a[0] = a
|
||||
return a
|
||||
}(),
|
||||
want: "[]interface {}{([]interface {})(0x00)}",
|
||||
}, {
|
||||
in: func() interface{} {
|
||||
type A *A
|
||||
var a A
|
||||
a = &a
|
||||
return a
|
||||
}(),
|
||||
want: "&(value.A)(0x00)",
|
||||
}, {
|
||||
in: func() interface{} {
|
||||
type A map[*A]A
|
||||
a := make(A)
|
||||
a[&a] = a
|
||||
return a
|
||||
}(),
|
||||
want: "value.A{0x00: 0x00}",
|
||||
}, {
|
||||
in: func() interface{} {
|
||||
var a [2]interface{}
|
||||
a[0] = &a
|
||||
return a
|
||||
}(),
|
||||
want: "[2]interface {}{&[2]interface {}{(*[2]interface {})(0x00), interface {}(nil)}, interface {}(nil)}",
|
||||
}}
|
||||
|
||||
formatFakePointers = true
|
||||
defer func() { formatFakePointers = false }()
|
||||
for i, tt := range tests {
|
||||
got := Format(reflect.ValueOf(tt.in), true)
|
||||
if got != tt.want {
|
||||
t.Errorf("test %d, Format():\ngot %q\nwant %q", i, got, tt.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
+1
-1
@@ -24,7 +24,7 @@ func SortKeys(vs []reflect.Value) []reflect.Value {
|
||||
// Deduplicate keys (fails for NaNs).
|
||||
vs2 := vs[:1]
|
||||
for _, v := range vs[1:] {
|
||||
if v.Interface() != vs2[len(vs2)-1].Interface() {
|
||||
if isLess(vs2[len(vs2)-1], v) {
|
||||
vs2 = append(vs2, v)
|
||||
}
|
||||
}
|
||||
|
||||
-152
@@ -1,152 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package value_test
|
||||
|
||||
import (
|
||||
"math"
|
||||
"reflect"
|
||||
"testing"
|
||||
|
||||
"github.com/google/go-cmp/cmp"
|
||||
"github.com/google/go-cmp/cmp/internal/value"
|
||||
)
|
||||
|
||||
func TestSortKeys(t *testing.T) {
|
||||
type (
|
||||
MyString string
|
||||
MyArray [2]int
|
||||
MyStruct struct {
|
||||
A MyString
|
||||
B MyArray
|
||||
C chan float64
|
||||
}
|
||||
EmptyStruct struct{}
|
||||
)
|
||||
|
||||
opts := []cmp.Option{
|
||||
cmp.Comparer(func(x, y float64) bool {
|
||||
if math.IsNaN(x) && math.IsNaN(y) {
|
||||
return true
|
||||
}
|
||||
return x == y
|
||||
}),
|
||||
cmp.Comparer(func(x, y complex128) bool {
|
||||
rx, ix, ry, iy := real(x), imag(x), real(y), imag(y)
|
||||
if math.IsNaN(rx) && math.IsNaN(ry) {
|
||||
rx, ry = 0, 0
|
||||
}
|
||||
if math.IsNaN(ix) && math.IsNaN(iy) {
|
||||
ix, iy = 0, 0
|
||||
}
|
||||
return rx == ry && ix == iy
|
||||
}),
|
||||
cmp.Comparer(func(x, y chan bool) bool { return true }),
|
||||
cmp.Comparer(func(x, y chan int) bool { return true }),
|
||||
cmp.Comparer(func(x, y chan float64) bool { return true }),
|
||||
cmp.Comparer(func(x, y chan interface{}) bool { return true }),
|
||||
cmp.Comparer(func(x, y *int) bool { return true }),
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
in map[interface{}]bool // Set of keys to sort
|
||||
want []interface{}
|
||||
}{{
|
||||
in: map[interface{}]bool{1: true, 2: true, 3: true},
|
||||
want: []interface{}{1, 2, 3},
|
||||
}, {
|
||||
in: map[interface{}]bool{
|
||||
nil: true,
|
||||
true: true,
|
||||
false: true,
|
||||
-5: true,
|
||||
-55: true,
|
||||
-555: true,
|
||||
uint(1): true,
|
||||
uint(11): true,
|
||||
uint(111): true,
|
||||
"abc": true,
|
||||
"abcd": true,
|
||||
"abcde": true,
|
||||
"foo": true,
|
||||
"bar": true,
|
||||
MyString("abc"): true,
|
||||
MyString("abcd"): true,
|
||||
MyString("abcde"): true,
|
||||
new(int): true,
|
||||
new(int): true,
|
||||
make(chan bool): true,
|
||||
make(chan bool): true,
|
||||
make(chan int): true,
|
||||
make(chan interface{}): true,
|
||||
math.Inf(+1): true,
|
||||
math.Inf(-1): true,
|
||||
1.2345: true,
|
||||
12.345: true,
|
||||
123.45: true,
|
||||
1234.5: true,
|
||||
0 + 0i: true,
|
||||
1 + 0i: true,
|
||||
2 + 0i: true,
|
||||
0 + 1i: true,
|
||||
0 + 2i: true,
|
||||
0 + 3i: true,
|
||||
[2]int{2, 3}: true,
|
||||
[2]int{4, 0}: true,
|
||||
[2]int{2, 4}: true,
|
||||
MyArray([2]int{2, 4}): true,
|
||||
EmptyStruct{}: true,
|
||||
MyStruct{
|
||||
"bravo", [2]int{2, 3}, make(chan float64),
|
||||
}: true,
|
||||
MyStruct{
|
||||
"alpha", [2]int{3, 3}, make(chan float64),
|
||||
}: true,
|
||||
},
|
||||
want: []interface{}{
|
||||
nil, false, true,
|
||||
-555, -55, -5, uint(1), uint(11), uint(111),
|
||||
math.Inf(-1), 1.2345, 12.345, 123.45, 1234.5, math.Inf(+1),
|
||||
(0 + 0i), (0 + 1i), (0 + 2i), (0 + 3i), (1 + 0i), (2 + 0i),
|
||||
[2]int{2, 3}, [2]int{2, 4}, [2]int{4, 0}, MyArray([2]int{2, 4}),
|
||||
make(chan bool), make(chan bool), make(chan int), make(chan interface{}),
|
||||
new(int), new(int),
|
||||
"abc", "abcd", "abcde", "bar", "foo",
|
||||
MyString("abc"), MyString("abcd"), MyString("abcde"),
|
||||
EmptyStruct{},
|
||||
MyStruct{"alpha", [2]int{3, 3}, make(chan float64)},
|
||||
MyStruct{"bravo", [2]int{2, 3}, make(chan float64)},
|
||||
},
|
||||
}, {
|
||||
// NaN values cannot be properly deduplicated.
|
||||
// This is okay since map entries with NaN in the keys cannot be
|
||||
// retrieved anyways.
|
||||
in: map[interface{}]bool{
|
||||
math.NaN(): true,
|
||||
math.NaN(): true,
|
||||
complex(0, math.NaN()): true,
|
||||
complex(0, math.NaN()): true,
|
||||
complex(math.NaN(), 0): true,
|
||||
complex(math.NaN(), 0): true,
|
||||
complex(math.NaN(), math.NaN()): true,
|
||||
},
|
||||
want: []interface{}{
|
||||
math.NaN(), math.NaN(), math.NaN(), math.NaN(),
|
||||
complex(math.NaN(), math.NaN()), complex(math.NaN(), math.NaN()),
|
||||
complex(math.NaN(), 0), complex(math.NaN(), 0), complex(math.NaN(), 0), complex(math.NaN(), 0),
|
||||
complex(0, math.NaN()), complex(0, math.NaN()), complex(0, math.NaN()), complex(0, math.NaN()),
|
||||
},
|
||||
}}
|
||||
|
||||
for i, tt := range tests {
|
||||
keys := append(reflect.ValueOf(tt.in).MapKeys(), reflect.ValueOf(tt.in).MapKeys()...)
|
||||
var got []interface{}
|
||||
for _, k := range value.SortKeys(keys) {
|
||||
got = append(got, k.Interface())
|
||||
}
|
||||
if d := cmp.Diff(got, tt.want, opts...); d != "" {
|
||||
t.Errorf("test %d, Sort() mismatch (-got +want):\n%s", i, d)
|
||||
}
|
||||
}
|
||||
}
|
||||
+22
-15
@@ -38,9 +38,8 @@ type Option interface {
|
||||
type applicableOption interface {
|
||||
Option
|
||||
|
||||
// apply executes the option and reports whether the option was applied.
|
||||
// Each option may mutate s.
|
||||
apply(s *state, vx, vy reflect.Value) bool
|
||||
// apply executes the option, which may mutate s or panic.
|
||||
apply(s *state, vx, vy reflect.Value)
|
||||
}
|
||||
|
||||
// coreOption represents the following types:
|
||||
@@ -85,7 +84,7 @@ func (opts Options) filter(s *state, vx, vy reflect.Value, t reflect.Type) (out
|
||||
return out
|
||||
}
|
||||
|
||||
func (opts Options) apply(s *state, _, _ reflect.Value) bool {
|
||||
func (opts Options) apply(s *state, _, _ reflect.Value) {
|
||||
const warning = "ambiguous set of applicable options"
|
||||
const help = "consider using filters to ensure at most one Comparer or Transformer may apply"
|
||||
var ss []string
|
||||
@@ -196,7 +195,7 @@ type ignore struct{ core }
|
||||
|
||||
func (ignore) isFiltered() bool { return false }
|
||||
func (ignore) filter(_ *state, _, _ reflect.Value, _ reflect.Type) applicableOption { return ignore{} }
|
||||
func (ignore) apply(_ *state, _, _ reflect.Value) bool { return true }
|
||||
func (ignore) apply(_ *state, _, _ reflect.Value) { return }
|
||||
func (ignore) String() string { return "Ignore()" }
|
||||
|
||||
// invalid is a sentinel Option type to indicate that some options could not
|
||||
@@ -204,7 +203,7 @@ func (ignore) String() string
|
||||
type invalid struct{ core }
|
||||
|
||||
func (invalid) filter(_ *state, _, _ reflect.Value, _ reflect.Type) applicableOption { return invalid{} }
|
||||
func (invalid) apply(s *state, _, _ reflect.Value) bool {
|
||||
func (invalid) apply(s *state, _, _ reflect.Value) {
|
||||
const help = "consider using AllowUnexported or cmpopts.IgnoreUnexported"
|
||||
panic(fmt.Sprintf("cannot handle unexported field: %#v\n%s", s.curPath, help))
|
||||
}
|
||||
@@ -215,9 +214,12 @@ func (invalid) apply(s *state, _, _ reflect.Value) bool {
|
||||
// The transformer f must be a function "func(T) R" that converts values of
|
||||
// type T to those of type R and is implicitly filtered to input values
|
||||
// assignable to T. The transformer must not mutate T in any way.
|
||||
// If T and R are the same type, an additional filter must be applied to
|
||||
// act as the base case to prevent an infinite recursion applying the same
|
||||
// transform to itself (see the SortedSlice example).
|
||||
//
|
||||
// To help prevent some cases of infinite recursive cycles applying the
|
||||
// same transform to the output of itself (e.g., in the case where the
|
||||
// input and output types are the same), an implicit filter is added such that
|
||||
// a transformer is applicable only if that exact transformer is not already
|
||||
// in the tail of the Path since the last non-Transform step.
|
||||
//
|
||||
// The name is a user provided label that is used as the Transform.Name in the
|
||||
// transformation PathStep. If empty, an arbitrary name is used.
|
||||
@@ -248,14 +250,21 @@ type transformer struct {
|
||||
|
||||
func (tr *transformer) isFiltered() bool { return tr.typ != nil }
|
||||
|
||||
func (tr *transformer) filter(_ *state, _, _ reflect.Value, t reflect.Type) applicableOption {
|
||||
func (tr *transformer) filter(s *state, _, _ reflect.Value, t reflect.Type) applicableOption {
|
||||
for i := len(s.curPath) - 1; i >= 0; i-- {
|
||||
if t, ok := s.curPath[i].(*transform); !ok {
|
||||
break // Hit most recent non-Transform step
|
||||
} else if tr == t.trans {
|
||||
return nil // Cannot directly use same Transform
|
||||
}
|
||||
}
|
||||
if tr.typ == nil || t.AssignableTo(tr.typ) {
|
||||
return tr
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (tr *transformer) apply(s *state, vx, vy reflect.Value) bool {
|
||||
func (tr *transformer) apply(s *state, vx, vy reflect.Value) {
|
||||
// Update path before calling the Transformer so that dynamic checks
|
||||
// will use the updated path.
|
||||
s.curPath.push(&transform{pathStep{tr.fnc.Type().Out(0)}, tr})
|
||||
@@ -264,7 +273,6 @@ func (tr *transformer) apply(s *state, vx, vy reflect.Value) bool {
|
||||
vx = s.callTRFunc(tr.fnc, vx)
|
||||
vy = s.callTRFunc(tr.fnc, vy)
|
||||
s.compareAny(vx, vy)
|
||||
return true
|
||||
}
|
||||
|
||||
func (tr transformer) String() string {
|
||||
@@ -310,10 +318,9 @@ func (cm *comparer) filter(_ *state, _, _ reflect.Value, t reflect.Type) applica
|
||||
return nil
|
||||
}
|
||||
|
||||
func (cm *comparer) apply(s *state, vx, vy reflect.Value) bool {
|
||||
func (cm *comparer) apply(s *state, vx, vy reflect.Value) {
|
||||
eq := s.callTTBFunc(cm.fnc, vx, vy)
|
||||
s.report(eq, vx, vy)
|
||||
return true
|
||||
}
|
||||
|
||||
func (cm comparer) String() string {
|
||||
@@ -348,7 +355,7 @@ func (cm comparer) String() string {
|
||||
// all unexported fields on specified struct types.
|
||||
func AllowUnexported(types ...interface{}) Option {
|
||||
if !supportAllowUnexported {
|
||||
panic("AllowUnexported is not supported on App Engine Classic or GopherJS")
|
||||
panic("AllowUnexported is not supported on purego builds, Google App Engine Standard, or GopherJS")
|
||||
}
|
||||
m := make(map[reflect.Type]bool)
|
||||
for _, typ := range types {
|
||||
|
||||
-231
@@ -1,231 +0,0 @@
|
||||
// Copyright 2017, The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
package cmp
|
||||
|
||||
import (
|
||||
"io"
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
ts "github.com/google/go-cmp/cmp/internal/teststructs"
|
||||
)
|
||||
|
||||
// Test that the creation of Option values with non-sensible inputs produces
|
||||
// a run-time panic with a decent error message
|
||||
func TestOptionPanic(t *testing.T) {
|
||||
type myBool bool
|
||||
tests := []struct {
|
||||
label string // Test description
|
||||
fnc interface{} // Option function to call
|
||||
args []interface{} // Arguments to pass in
|
||||
wantPanic string // Expected panic message
|
||||
}{{
|
||||
label: "AllowUnexported",
|
||||
fnc: AllowUnexported,
|
||||
args: []interface{}{},
|
||||
}, {
|
||||
label: "AllowUnexported",
|
||||
fnc: AllowUnexported,
|
||||
args: []interface{}{1},
|
||||
wantPanic: "invalid struct type",
|
||||
}, {
|
||||
label: "AllowUnexported",
|
||||
fnc: AllowUnexported,
|
||||
args: []interface{}{ts.StructA{}},
|
||||
}, {
|
||||
label: "AllowUnexported",
|
||||
fnc: AllowUnexported,
|
||||
args: []interface{}{ts.StructA{}, ts.StructB{}, ts.StructA{}},
|
||||
}, {
|
||||
label: "AllowUnexported",
|
||||
fnc: AllowUnexported,
|
||||
args: []interface{}{ts.StructA{}, &ts.StructB{}, ts.StructA{}},
|
||||
wantPanic: "invalid struct type",
|
||||
}, {
|
||||
label: "Comparer",
|
||||
fnc: Comparer,
|
||||
args: []interface{}{5},
|
||||
wantPanic: "invalid comparer function",
|
||||
}, {
|
||||
label: "Comparer",
|
||||
fnc: Comparer,
|
||||
args: []interface{}{func(x, y interface{}) bool { return true }},
|
||||
}, {
|
||||
label: "Comparer",
|
||||
fnc: Comparer,
|
||||
args: []interface{}{func(x, y io.Reader) bool { return true }},
|
||||
}, {
|
||||
label: "Comparer",
|
||||
fnc: Comparer,
|
||||
args: []interface{}{func(x, y io.Reader) myBool { return true }},
|
||||
wantPanic: "invalid comparer function",
|
||||
}, {
|
||||
label: "Comparer",
|
||||
fnc: Comparer,
|
||||
args: []interface{}{func(x string, y interface{}) bool { return true }},
|
||||
wantPanic: "invalid comparer function",
|
||||
}, {
|
||||
label: "Comparer",
|
||||
fnc: Comparer,
|
||||
args: []interface{}{(func(int, int) bool)(nil)},
|
||||
wantPanic: "invalid comparer function",
|
||||
}, {
|
||||
label: "Transformer",
|
||||
fnc: Transformer,
|
||||
args: []interface{}{"", 0},
|
||||
wantPanic: "invalid transformer function",
|
||||
}, {
|
||||
label: "Transformer",
|
||||
fnc: Transformer,
|
||||
args: []interface{}{"", func(int) int { return 0 }},
|
||||
}, {
|
||||
label: "Transformer",
|
||||
fnc: Transformer,
|
||||
args: []interface{}{"", func(bool) bool { return true }},
|
||||
}, {
|
||||
label: "Transformer",
|
||||
fnc: Transformer,
|
||||
args: []interface{}{"", func(int) bool { return true }},
|
||||
}, {
|
||||
label: "Transformer",
|
||||
fnc: Transformer,
|
||||
args: []interface{}{"", func(int, int) bool { return true }},
|
||||
wantPanic: "invalid transformer function",
|
||||
}, {
|
||||
label: "Transformer",
|
||||
fnc: Transformer,
|
||||
args: []interface{}{"", (func(int) uint)(nil)},
|
||||
wantPanic: "invalid transformer function",
|
||||
}, {
|
||||
label: "Transformer",
|
||||
fnc: Transformer,
|
||||
args: []interface{}{"Func", func(Path) Path { return nil }},
|
||||
}, {
|
||||
label: "Transformer",
|
||||
fnc: Transformer,
|
||||
args: []interface{}{"世界", func(int) bool { return true }},
|
||||
}, {
|
||||
label: "Transformer",
|
||||
fnc: Transformer,
|
||||
args: []interface{}{"/*", func(int) bool { return true }},
|
||||
wantPanic: "invalid name",
|
||||
}, {
|
||||
label: "Transformer",
|
||||
fnc: Transformer,
|
||||
args: []interface{}{"_", func(int) bool { return true }},
|
||||
wantPanic: "invalid name",
|
||||
}, {
|
||||
label: "FilterPath",
|
||||
fnc: FilterPath,
|
||||
args: []interface{}{(func(Path) bool)(nil), Ignore()},
|
||||
wantPanic: "invalid path filter function",
|
||||
}, {
|
||||
label: "FilterPath",
|
||||
fnc: FilterPath,
|
||||
args: []interface{}{func(Path) bool { return true }, Ignore()},
|
||||
}, {
|
||||
label: "FilterPath",
|
||||
fnc: FilterPath,
|
||||
args: []interface{}{func(Path) bool { return true }, &defaultReporter{}},
|
||||
wantPanic: "invalid option type",
|
||||
}, {
|
||||
label: "FilterPath",
|
||||
fnc: FilterPath,
|
||||
args: []interface{}{func(Path) bool { return true }, Options{Ignore(), Ignore()}},
|
||||
}, {
|
||||
label: "FilterPath",
|
||||
fnc: FilterPath,
|
||||
args: []interface{}{func(Path) bool { return true }, Options{Ignore(), &defaultReporter{}}},
|
||||
wantPanic: "invalid option type",
|
||||
}, {
|
||||
label: "FilterValues",
|
||||
fnc: FilterValues,
|
||||
args: []interface{}{0, Ignore()},
|
||||
wantPanic: "invalid values filter function",
|
||||
}, {
|
||||
label: "FilterValues",
|
||||
fnc: FilterValues,
|
||||
args: []interface{}{func(x, y int) bool { return true }, Ignore()},
|
||||
}, {
|
||||
label: "FilterValues",
|
||||
fnc: FilterValues,
|
||||
args: []interface{}{func(x, y interface{}) bool { return true }, Ignore()},
|
||||
}, {
|
||||
label: "FilterValues",
|
||||
fnc: FilterValues,
|
||||
args: []interface{}{func(x, y interface{}) myBool { return true }, Ignore()},
|
||||
wantPanic: "invalid values filter function",
|
||||
}, {
|
||||
label: "FilterValues",
|
||||
fnc: FilterValues,
|
||||
args: []interface{}{func(x io.Reader, y interface{}) bool { return true }, Ignore()},
|
||||
wantPanic: "invalid values filter function",
|
||||
}, {
|
||||
label: "FilterValues",
|
||||
fnc: FilterValues,
|
||||
args: []interface{}{(func(int, int) bool)(nil), Ignore()},
|
||||
wantPanic: "invalid values filter function",
|
||||
}, {
|
||||
label: "FilterValues",
|
||||
fnc: FilterValues,
|
||||
args: []interface{}{func(int, int) bool { return true }, &defaultReporter{}},
|
||||
wantPanic: "invalid option type",
|
||||
}, {
|
||||
label: "FilterValues",
|
||||
fnc: FilterValues,
|
||||
args: []interface{}{func(int, int) bool { return true }, Options{Ignore(), Ignore()}},
|
||||
}, {
|
||||
label: "FilterValues",
|
||||
fnc: FilterValues,
|
||||
args: []interface{}{func(int, int) bool { return true }, Options{Ignore(), &defaultReporter{}}},
|
||||
wantPanic: "invalid option type",
|
||||
}}
|
||||
|
||||
for _, tt := range tests {
|
||||
tRun(t, tt.label, func(t *testing.T) {
|
||||
var gotPanic string
|
||||
func() {
|
||||
defer func() {
|
||||
if ex := recover(); ex != nil {
|
||||
if s, ok := ex.(string); ok {
|
||||
gotPanic = s
|
||||
} else {
|
||||
panic(ex)
|
||||
}
|
||||
}
|
||||
}()
|
||||
var vargs []reflect.Value
|
||||
for _, arg := range tt.args {
|
||||
vargs = append(vargs, reflect.ValueOf(arg))
|
||||
}
|
||||
reflect.ValueOf(tt.fnc).Call(vargs)
|
||||
}()
|
||||
if tt.wantPanic == "" {
|
||||
if gotPanic != "" {
|
||||
t.Fatalf("unexpected panic message: %s", gotPanic)
|
||||
}
|
||||
} else {
|
||||
if !strings.Contains(gotPanic, tt.wantPanic) {
|
||||
t.Fatalf("panic message:\ngot: %s\nwant: %s", gotPanic, tt.wantPanic)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Delete this hack when we drop Go1.6 support.
|
||||
func tRun(t *testing.T, name string, f func(t *testing.T)) {
|
||||
type runner interface {
|
||||
Run(string, func(t *testing.T)) bool
|
||||
}
|
||||
var ti interface{} = t
|
||||
if r, ok := ti.(runner); ok {
|
||||
r.Run(name, f)
|
||||
} else {
|
||||
t.Logf("Test: %s", name)
|
||||
f(t)
|
||||
}
|
||||
}
|
||||
+26
-10
@@ -79,6 +79,11 @@ type (
|
||||
PathStep
|
||||
Name() string
|
||||
Func() reflect.Value
|
||||
|
||||
// Option returns the originally constructed Transformer option.
|
||||
// The == operator can be used to detect the exact option used.
|
||||
Option() Option
|
||||
|
||||
isTransform()
|
||||
}
|
||||
)
|
||||
@@ -94,10 +99,21 @@ func (pa *Path) pop() {
|
||||
// Last returns the last PathStep in the Path.
|
||||
// If the path is empty, this returns a non-nil PathStep that reports a nil Type.
|
||||
func (pa Path) Last() PathStep {
|
||||
if len(pa) > 0 {
|
||||
return pa[len(pa)-1]
|
||||
return pa.Index(-1)
|
||||
}
|
||||
|
||||
// Index returns the ith step in the Path and supports negative indexing.
|
||||
// A negative index starts counting from the tail of the Path such that -1
|
||||
// refers to the last step, -2 refers to the second-to-last step, and so on.
|
||||
// If index is invalid, this returns a non-nil PathStep that reports a nil Type.
|
||||
func (pa Path) Index(i int) PathStep {
|
||||
if i < 0 {
|
||||
i = len(pa) + i
|
||||
}
|
||||
return pathStep{}
|
||||
if i < 0 || i >= len(pa) {
|
||||
return pathStep{}
|
||||
}
|
||||
return pa[i]
|
||||
}
|
||||
|
||||
// String returns the simplified path to a node.
|
||||
@@ -150,13 +166,12 @@ func (pa Path) GoString() string {
|
||||
ssPost = append(ssPost, ")")
|
||||
continue
|
||||
case *typeAssertion:
|
||||
// Elide type assertions immediately following a transform to
|
||||
// prevent overly verbose path printouts.
|
||||
// Some transforms return interface{} because of Go's lack of
|
||||
// generics, but typically take in and return the exact same
|
||||
// concrete type. Other times, the transform creates an anonymous
|
||||
// struct, which will be very verbose to print.
|
||||
if _, ok := nextStep.(*transform); ok {
|
||||
// As a special-case, elide type assertions on anonymous types
|
||||
// since they are typically generated dynamically and can be very
|
||||
// verbose. For example, some transforms return interface{} because
|
||||
// of Go's lack of generics, but typically take in and return the
|
||||
// exact same concrete type.
|
||||
if s.Type().PkgPath() == "" {
|
||||
continue
|
||||
}
|
||||
}
|
||||
@@ -250,6 +265,7 @@ func (sf structField) Name() string { return sf.name }
|
||||
func (sf structField) Index() int { return sf.idx }
|
||||
func (tf transform) Name() string { return tf.trans.name }
|
||||
func (tf transform) Func() reflect.Value { return tf.trans.fnc }
|
||||
func (tf transform) Option() Option { return tf.trans }
|
||||
|
||||
func (pathStep) isPathStep() {}
|
||||
func (sliceIndex) isSliceIndex() {}
|
||||
|
||||
+6
-6
@@ -30,12 +30,12 @@ func (r *defaultReporter) Report(x, y reflect.Value, eq bool, p Path) {
|
||||
const maxLines = 256
|
||||
r.ndiffs++
|
||||
if r.nbytes < maxBytes && r.nlines < maxLines {
|
||||
sx := value.Format(x, true)
|
||||
sy := value.Format(y, true)
|
||||
sx := value.Format(x, value.FormatConfig{UseStringer: true})
|
||||
sy := value.Format(y, value.FormatConfig{UseStringer: true})
|
||||
if sx == sy {
|
||||
// Stringer is not helpful, so rely on more exact formatting.
|
||||
sx = value.Format(x, false)
|
||||
sy = value.Format(y, false)
|
||||
// Unhelpful output, so use more exact formatting.
|
||||
sx = value.Format(x, value.FormatConfig{PrintPrimitiveType: true})
|
||||
sy = value.Format(y, value.FormatConfig{PrintPrimitiveType: true})
|
||||
}
|
||||
s := fmt.Sprintf("%#v:\n\t-: %s\n\t+: %s\n", p, sx, sy)
|
||||
r.diffs = append(r.diffs, s)
|
||||
@@ -49,5 +49,5 @@ func (r *defaultReporter) String() string {
|
||||
if r.ndiffs == len(r.diffs) {
|
||||
return s
|
||||
}
|
||||
return fmt.Sprintf("%s... %d more differences ...", s, len(r.diffs)-r.ndiffs)
|
||||
return fmt.Sprintf("%s... %d more differences ...", s, r.ndiffs-len(r.diffs))
|
||||
}
|
||||
|
||||
+1
-1
@@ -2,7 +2,7 @@
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
// +build appengine js
|
||||
// +build purego appengine js
|
||||
|
||||
package cmp
|
||||
|
||||
|
||||
+1
-1
@@ -2,7 +2,7 @@
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE.md file.
|
||||
|
||||
// +build !appengine,!js
|
||||
// +build !purego,!appengine,!js
|
||||
|
||||
package cmp
|
||||
|
||||
|
||||
Reference in New Issue
Block a user