mirror/protobuf-go
1
0
Fork 0
mirror of https://github.com/protocolbuffers/protobuf-go.git synced 2025-01-28 06:35:29 +00:00
Code Issues Packages Projects Releases Wiki Activity
protobuf-go/testing/protocmp/util_test.go
Michael Stapelberg cbc3dd69c1 all: replace interface{} by any now that we are on Go 1.21 
I generated this change using:

  % sed -i 's,interface{},any,g' **/*.go
  % git checkout -- **/*.pb.go
  % $EDITOR cmd/protoc-gen-go/internal_gengo/well_known_types.go
  % ./regenerate.bash

Change-Id: I728f4b69c87ffc8f3b19bf807bf9bf1479bdbab4
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/585735
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Lasse Folger <lassefolger@google.com>
2024-05-15 12:42:15 +00:00

1400 lines
57 KiB
Go
Raw Blame History

// Copyright 2019 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 file.
package protocmp
import (
"math"
"math/rand"
"sort"
"testing"
"github.com/google/go-cmp/cmp"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/testing/protopack"
"google.golang.org/protobuf/types/dynamicpb"
testpb "google.golang.org/protobuf/internal/testprotos/test"
)
func TestEqual(t *testing.T) {
type test struct {
x, y any
opts cmp.Options
want bool
}
var tests []test
allTypesDesc := (*testpb.TestAllTypes)(nil).ProtoReflect().Descriptor()
// Test nil and empty messages of differing types.
tests = append(tests, []test{{
x: (*testpb.TestAllTypes)(nil),
y: (*testpb.TestAllTypes)(nil),
opts: cmp.Options{Transform()},
want: true,
}, {
x: (*testpb.TestAllTypes)(nil),
y: (*testpb.TestAllExtensions)(nil),
opts: cmp.Options{Transform()},
want: false,
}, {
x: (*testpb.TestAllTypes)(nil),
y: new(testpb.TestAllTypes),
opts: cmp.Options{Transform()},
want: false,
}, {
x: (*testpb.TestAllTypes)(nil),
y: dynamicpb.NewMessage(allTypesDesc),
opts: cmp.Options{Transform()},
want: false,
}, {
x: (*testpb.TestAllTypes)(nil),
y: new(testpb.TestAllTypes),
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: true,
}, {
x: (*testpb.TestAllTypes)(nil),
y: dynamicpb.NewMessage(allTypesDesc),
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: true,
}, {
x: new(testpb.TestAllTypes),
y: new(testpb.TestAllTypes),
opts: cmp.Options{Transform()},
want: true,
}, {
x: new(testpb.TestAllTypes),
y: dynamicpb.NewMessage(allTypesDesc),
opts: cmp.Options{Transform()},
want: true,
}, {
x: new(testpb.TestAllTypes),
y: new(testpb.TestAllExtensions),
opts: cmp.Options{Transform()},
want: false,
}, {
x: struct{ I any }{(*testpb.TestAllTypes)(nil)},
y: struct{ I any }{(*testpb.TestAllTypes)(nil)},
opts: cmp.Options{Transform()},
want: true,
}, {
x: struct{ I any }{(*testpb.TestAllTypes)(nil)},
y: struct{ I any }{new(testpb.TestAllTypes)},
opts: cmp.Options{Transform()},
want: false,
}, {
x: struct{ I any }{(*testpb.TestAllTypes)(nil)},
y: struct{ I any }{dynamicpb.NewMessage(allTypesDesc)},
opts: cmp.Options{Transform()},
want: false,
}, {
x: struct{ I any }{(*testpb.TestAllTypes)(nil)},
y: struct{ I any }{new(testpb.TestAllTypes)},
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: true,
}, {
x: struct{ I any }{(*testpb.TestAllTypes)(nil)},
y: struct{ I any }{dynamicpb.NewMessage(allTypesDesc)},
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: true,
}, {
x: struct{ I any }{new(testpb.TestAllTypes)},
y: struct{ I any }{new(testpb.TestAllTypes)},
opts: cmp.Options{Transform()},
want: true,
}, {
x: struct{ I any }{new(testpb.TestAllTypes)},
y: struct{ I any }{dynamicpb.NewMessage(allTypesDesc)},
opts: cmp.Options{Transform()},
want: true,
}, {
x: struct{ M proto.Message }{(*testpb.TestAllTypes)(nil)},
y: struct{ M proto.Message }{(*testpb.TestAllTypes)(nil)},
opts: cmp.Options{Transform()},
want: true,
}, {
x: struct{ M proto.Message }{(*testpb.TestAllTypes)(nil)},
y: struct{ M proto.Message }{new(testpb.TestAllTypes)},
opts: cmp.Options{Transform()},
want: false,
}, {
x: struct{ M proto.Message }{(*testpb.TestAllTypes)(nil)},
y: struct{ M proto.Message }{dynamicpb.NewMessage(allTypesDesc)},
opts: cmp.Options{Transform()},
want: false,
}, {
x: struct{ M proto.Message }{(*testpb.TestAllTypes)(nil)},
y: struct{ M proto.Message }{new(testpb.TestAllTypes)},
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: true,
}, {
x: struct{ M proto.Message }{(*testpb.TestAllTypes)(nil)},
y: struct{ M proto.Message }{dynamicpb.NewMessage(allTypesDesc)},
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: true,
}, {
x: struct{ M proto.Message }{new(testpb.TestAllTypes)},
y: struct{ M proto.Message }{new(testpb.TestAllTypes)},
opts: cmp.Options{Transform()},
want: true,
}, {
x: struct{ M proto.Message }{new(testpb.TestAllTypes)},
y: struct{ M proto.Message }{dynamicpb.NewMessage(allTypesDesc)},
opts: cmp.Options{Transform()},
want: true,
}}...)
// Test message values.
tests = append(tests, []test{{
x: testpb.TestAllTypes{OptionalSint64: proto.Int64(1)},
y: testpb.TestAllTypes{OptionalSint64: proto.Int64(1)},
opts: cmp.Options{Transform()},
want: true,
}, {
x: testpb.TestAllTypes{OptionalSint64: proto.Int64(1)},
y: testpb.TestAllTypes{OptionalSint64: proto.Int64(2)},
opts: cmp.Options{Transform()},
want: false,
}, {
x: struct{ M testpb.TestAllTypes }{M: testpb.TestAllTypes{OptionalSint64: proto.Int64(1)}},
y: struct{ M testpb.TestAllTypes }{M: testpb.TestAllTypes{OptionalSint64: proto.Int64(1)}},
opts: cmp.Options{Transform()},
want: true,
}, {
x: struct{ M testpb.TestAllTypes }{M: testpb.TestAllTypes{OptionalSint64: proto.Int64(1)}},
y: struct{ M testpb.TestAllTypes }{M: testpb.TestAllTypes{OptionalSint64: proto.Int64(2)}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: struct{ M []testpb.TestAllTypes }{M: []testpb.TestAllTypes{{OptionalSint64: proto.Int64(1)}}},
y: struct{ M []testpb.TestAllTypes }{M: []testpb.TestAllTypes{{OptionalSint64: proto.Int64(1)}}},
opts: cmp.Options{Transform()},
want: true,
}, {
x: struct{ M []testpb.TestAllTypes }{M: []testpb.TestAllTypes{{OptionalSint64: proto.Int64(1)}}},
y: struct{ M []testpb.TestAllTypes }{M: []testpb.TestAllTypes{{OptionalSint64: proto.Int64(2)}}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: struct {
M map[string]testpb.TestAllTypes
}{
M: map[string]testpb.TestAllTypes{"k": {OptionalSint64: proto.Int64(1)}},
},
y: struct {
M map[string]testpb.TestAllTypes
}{
M: map[string]testpb.TestAllTypes{"k": {OptionalSint64: proto.Int64(1)}},
},
opts: cmp.Options{Transform()},
want: true,
}, {
x: struct {
M map[string]testpb.TestAllTypes
}{
M: map[string]testpb.TestAllTypes{"k": {OptionalSint64: proto.Int64(1)}},
},
y: struct {
M map[string]testpb.TestAllTypes
}{
M: map[string]testpb.TestAllTypes{"k": {OptionalSint64: proto.Int64(2)}},
},
opts: cmp.Options{Transform()},
want: false,
}}...)
// Test IgnoreUnknown.
raw := protopack.Message{
protopack.Tag{1, protopack.BytesType}, protopack.String("Hello, goodbye!"),
}.Marshal()
tests = append(tests, []test{{
x: apply(&testpb.TestAllTypes{OptionalSint64: proto.Int64(5)}, setUnknown{raw}),
y: &testpb.TestAllTypes{OptionalSint64: proto.Int64(5)},
opts: cmp.Options{Transform()},
want: false,
}, {
x: apply(&testpb.TestAllTypes{OptionalSint64: proto.Int64(5)}, setUnknown{raw}),
y: &testpb.TestAllTypes{OptionalSint64: proto.Int64(5)},
opts: cmp.Options{Transform(), IgnoreUnknown()},
want: true,
}, {
x: apply(&testpb.TestAllTypes{OptionalSint64: proto.Int64(5)}, setUnknown{raw}),
y: &testpb.TestAllTypes{OptionalSint64: proto.Int64(6)},
opts: cmp.Options{Transform(), IgnoreUnknown()},
want: false,
}, {
x: apply(&testpb.TestAllTypes{OptionalSint64: proto.Int64(5)}, setUnknown{raw}),
y: apply(dynamicpb.NewMessage(allTypesDesc), setField{6, int64(5)}),
opts: cmp.Options{Transform()},
want: false,
}, {
x: apply(&testpb.TestAllTypes{OptionalSint64: proto.Int64(5)}, setUnknown{raw}),
y: apply(dynamicpb.NewMessage(allTypesDesc), setField{6, int64(5)}),
opts: cmp.Options{Transform(), IgnoreUnknown()},
want: true,
}}...)
// Test IgnoreDefaultScalars.
tests = append(tests, []test{{
x: &testpb.TestAllTypes{
DefaultInt32: proto.Int32(81),
DefaultUint32: proto.Uint32(83),
DefaultFloat: proto.Float32(91.5),
DefaultBool: proto.Bool(true),
DefaultBytes: []byte("world"),
},
y: &testpb.TestAllTypes{
DefaultInt64: proto.Int64(82),
DefaultUint64: proto.Uint64(84),
DefaultDouble: proto.Float64(92e3),
DefaultString: proto.String("hello"),
DefaultForeignEnum: testpb.ForeignEnum_FOREIGN_BAR.Enum(),
},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{
DefaultInt32: proto.Int32(81),
DefaultUint32: proto.Uint32(83),
DefaultFloat: proto.Float32(91.5),
DefaultBool: proto.Bool(true),
DefaultBytes: []byte("world"),
},
y: &testpb.TestAllTypes{
DefaultInt64: proto.Int64(82),
DefaultUint64: proto.Uint64(84),
DefaultDouble: proto.Float64(92e3),
DefaultString: proto.String("hello"),
DefaultForeignEnum: testpb.ForeignEnum_FOREIGN_BAR.Enum(),
},
opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
want: true,
}, {
x: &testpb.TestAllTypes{
OptionalInt32: proto.Int32(81),
OptionalUint32: proto.Uint32(83),
OptionalFloat: proto.Float32(91.5),
OptionalBool: proto.Bool(true),
OptionalBytes: []byte("world"),
},
y: &testpb.TestAllTypes{
OptionalInt64: proto.Int64(82),
OptionalUint64: proto.Uint64(84),
OptionalDouble: proto.Float64(92e3),
OptionalString: proto.String("hello"),
OptionalForeignEnum: testpb.ForeignEnum_FOREIGN_BAR.Enum(),
},
opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
want: false,
}, {
x: &testpb.TestAllTypes{
OptionalInt32: proto.Int32(0),
OptionalUint32: proto.Uint32(0),
OptionalFloat: proto.Float32(0),
OptionalBool: proto.Bool(false),
OptionalBytes: []byte(""),
},
y: &testpb.TestAllTypes{
OptionalInt64: proto.Int64(0),
OptionalUint64: proto.Uint64(0),
OptionalDouble: proto.Float64(0),
OptionalString: proto.String(""),
OptionalForeignEnum: testpb.ForeignEnum_FOREIGN_FOO.Enum(),
},
opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
want: true,
}, {
x: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_DefaultInt32, int32(81)},
setExtension{testpb.E_DefaultUint32, uint32(83)},
setExtension{testpb.E_DefaultFloat, float32(91.5)},
setExtension{testpb.E_DefaultBool, bool(true)},
setExtension{testpb.E_DefaultBytes, []byte("world")}),
y: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_DefaultInt64, int64(82)},
setExtension{testpb.E_DefaultUint64, uint64(84)},
setExtension{testpb.E_DefaultDouble, float64(92e3)},
setExtension{testpb.E_DefaultString, string("hello")}),
opts: cmp.Options{Transform()},
want: false,
}, {
x: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_DefaultInt32, int32(81)},
setExtension{testpb.E_DefaultUint32, uint32(83)},
setExtension{testpb.E_DefaultFloat, float32(91.5)},
setExtension{testpb.E_DefaultBool, bool(true)},
setExtension{testpb.E_DefaultBytes, []byte("world")}),
y: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_DefaultInt64, int64(82)},
setExtension{testpb.E_DefaultUint64, uint64(84)},
setExtension{testpb.E_DefaultDouble, float64(92e3)},
setExtension{testpb.E_DefaultString, string("hello")}),
opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
want: true,
}, {
x: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_OptionalInt32, int32(0)},
setExtension{testpb.E_OptionalUint32, uint32(0)},
setExtension{testpb.E_OptionalFloat, float32(0)},
setExtension{testpb.E_OptionalBool, bool(false)},
setExtension{testpb.E_OptionalBytes, []byte("")}),
y: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_OptionalInt64, int64(0)},
setExtension{testpb.E_OptionalUint64, uint64(0)},
setExtension{testpb.E_OptionalDouble, float64(0)},
setExtension{testpb.E_OptionalString, string("")}),
opts: cmp.Options{Transform()},
want: false,
}, {
x: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_OptionalInt32, int32(0)},
setExtension{testpb.E_OptionalUint32, uint32(0)},
setExtension{testpb.E_OptionalFloat, float32(0)},
setExtension{testpb.E_OptionalBool, bool(false)},
setExtension{testpb.E_OptionalBytes, []byte("")}),
y: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_OptionalInt64, int64(0)},
setExtension{testpb.E_OptionalUint64, uint64(0)},
setExtension{testpb.E_OptionalDouble, float64(0)},
setExtension{testpb.E_OptionalString, string("")}),
opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
want: true,
}, {
x: &testpb.TestAllTypes{
DefaultFloat: proto.Float32(91.6),
},
y: &testpb.TestAllTypes{},
opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
want: false,
}, {
x: &testpb.TestAllTypes{
OptionalForeignMessage: &testpb.ForeignMessage{},
},
y: &testpb.TestAllTypes{},
opts: cmp.Options{Transform(), IgnoreDefaultScalars()},
want: false,
}}...)
// Test IgnoreEmptyMessages.
tests = append(tests, []test{{
x: []*testpb.TestAllTypes{nil, {}, {OptionalInt32: proto.Int32(5)}},
y: []*testpb.TestAllTypes{nil, {}, {OptionalInt32: proto.Int32(5)}},
opts: cmp.Options{Transform()},
want: true,
}, {
x: []*testpb.TestAllTypes{nil, {}, {OptionalInt32: proto.Int32(5)}},
y: []*testpb.TestAllTypes{{OptionalInt32: proto.Int32(5)}},
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: false,
}, {
x: &testpb.TestAllTypes{OptionalForeignMessage: &testpb.ForeignMessage{}},
y: &testpb.TestAllTypes{OptionalForeignMessage: nil},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{OptionalForeignMessage: &testpb.ForeignMessage{}},
y: &testpb.TestAllTypes{OptionalForeignMessage: nil},
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: true,
}, {
x: &testpb.TestAllTypes{OptionalForeignMessage: &testpb.ForeignMessage{C: proto.Int32(5)}},
y: &testpb.TestAllTypes{OptionalForeignMessage: nil},
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: false,
}, {
x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{}},
y: &testpb.TestAllTypes{RepeatedForeignMessage: nil},
opts: cmp.Options{Transform()},
want: true,
}, {
x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {}}},
y: &testpb.TestAllTypes{RepeatedForeignMessage: nil},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {}}},
y: &testpb.TestAllTypes{RepeatedForeignMessage: nil},
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: true,
}, {
x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(5)}, {}}},
y: &testpb.TestAllTypes{RepeatedForeignMessage: nil},
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: false,
}, {
x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(5)}, {}}},
y: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {}, nil, {}, {C: proto.Int32(5)}, {}}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(5)}, {}}},
y: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {}, nil, {}, {C: proto.Int32(5)}, {}}},
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: true,
}, {
x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{}},
y: &testpb.TestAllTypes{MapStringNestedMessage: nil},
opts: cmp.Options{Transform()},
want: true,
}, {
x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": nil, "2": {}}},
y: &testpb.TestAllTypes{MapStringNestedMessage: nil},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": nil, "2": {}}},
y: &testpb.TestAllTypes{MapStringNestedMessage: nil},
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: true,
}, {
x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": nil, "2": {A: proto.Int32(5)}, "3": {}}},
y: &testpb.TestAllTypes{MapStringNestedMessage: nil},
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: false,
}, {
x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": nil, "2": {A: proto.Int32(5)}, "3": {}}},
y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": {}, "1a": {}, "1b": nil, "2": {A: proto.Int32(5)}, "4": {}}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": nil, "2": {A: proto.Int32(5)}, "3": {}}},
y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"1": {}, "1a": {}, "1b": nil, "2": {A: proto.Int32(5)}, "4": {}}},
opts: cmp.Options{Transform(), IgnoreEmptyMessages()},
want: true,
}}...)
// Test IgnoreEnums and IgnoreMessages.
tests = append(tests, []test{{
x: &testpb.TestAllTypes{
OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)},
RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}},
MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"3": {A: proto.Int32(3)}},
},
y: &testpb.TestAllTypes{},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{
OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)},
RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}},
MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"3": {A: proto.Int32(3)}},
},
y: &testpb.TestAllTypes{},
opts: cmp.Options{Transform(), IgnoreMessages(&testpb.TestAllTypes{})},
want: true,
}, {
x: &testpb.TestAllTypes{
OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum(),
RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR},
MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"baz": testpb.TestAllTypes_BAZ},
},
y: &testpb.TestAllTypes{},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{
OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum(),
RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR},
MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"baz": testpb.TestAllTypes_BAZ},
},
y: &testpb.TestAllTypes{},
opts: cmp.Options{Transform(), IgnoreEnums(testpb.TestAllTypes_NestedEnum(0))},
want: true,
}, {
x: &testpb.TestAllTypes{
OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum(),
RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR},
MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"baz": testpb.TestAllTypes_BAZ},
OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)},
RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}},
MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"3": {A: proto.Int32(3)}},
},
y: &testpb.TestAllTypes{},
opts: cmp.Options{Transform(),
IgnoreMessages(&testpb.TestAllExtensions{}),
IgnoreEnums(testpb.ForeignEnum(0)),
},
want: false,
}}...)
// Test IgnoreFields and IgnoreOneofs.
tests = append(tests, []test{{
x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(5)},
y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(6)},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(5)},
y: &testpb.TestAllTypes{},
opts: cmp.Options{Transform(),
IgnoreFields(&testpb.TestAllTypes{}, "optional_int32")},
want: true,
}, {
x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(5)},
y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(6)},
opts: cmp.Options{Transform(),
IgnoreFields(&testpb.TestAllTypes{}, "optional_int32")},
want: true,
}, {
x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(5)},
y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(6)},
opts: cmp.Options{Transform(),
IgnoreFields(&testpb.TestAllTypes{}, "optional_int64")},
want: false,
}, {
x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{5}},
y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofString{"5"}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{5}},
y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofString{"5"}},
opts: cmp.Options{Transform(),
IgnoreFields(&testpb.TestAllTypes{}, "oneof_uint32"),
IgnoreFields(&testpb.TestAllTypes{}, "oneof_string")},
want: true,
}, {
x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{5}},
y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofString{"5"}},
opts: cmp.Options{Transform(),
IgnoreOneofs(&testpb.TestAllTypes{}, "oneof_field")},
want: true,
}, {
x: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_OptionalString, "hello"}),
y: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_OptionalString, "goodbye"}),
opts: cmp.Options{Transform()},
want: false,
}, {
x: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_OptionalString, "hello"}),
y: new(testpb.TestAllExtensions),
opts: cmp.Options{Transform(),
IgnoreDescriptors(testpb.E_OptionalString.TypeDescriptor())},
want: true,
}, {
x: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_OptionalString, "hello"}),
y: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_OptionalString, "goodbye"}),
opts: cmp.Options{Transform(),
IgnoreDescriptors(testpb.E_OptionalString.TypeDescriptor())},
want: true,
}, {
x: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_OptionalString, "hello"}),
y: apply(new(testpb.TestAllExtensions),
setExtension{testpb.E_OptionalString, "goodbye"}),
opts: cmp.Options{Transform(),
IgnoreDescriptors(testpb.E_OptionalInt32.TypeDescriptor())},
want: false,
}}...)
// Test FilterEnum.
tests = append(tests, []test{{
x: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
y: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum()},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
y: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum()},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.ForeignEnum(0), cmp.Comparer(func(x, y any) bool { return true })),
},
want: false, // mismatching filter type
}, {
x: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
y: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum()},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y int) bool { return true })),
},
want: false, // matching filter type, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
y: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum()},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y testpb.TestAllTypes_NestedEnum) bool { return true })),
},
want: false, // matching filter type, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
y: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum()},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y any) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_FOO.Enum()},
y: &testpb.TestAllTypes{OptionalNestedEnum: testpb.TestAllTypes_BAR.Enum()},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y Enum) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO}},
y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO}},
y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR}},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.ForeignEnum(0), cmp.Comparer(func(x, y any) bool { return true })),
},
want: false, // mismatching filter type
}, {
x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO}},
y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR}},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y int) bool { return true })),
},
want: false, // matching filter type, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO}},
y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR}},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y []testpb.TestAllTypes_NestedEnum) bool { return true })),
},
want: false, // matching filter type, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO}},
y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR}},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y any) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO}},
y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR}},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y []Enum) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_FOO}},
y: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_BAR}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_FOO}},
y: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_BAR}},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.ForeignEnum(0), cmp.Comparer(func(x, y any) bool { return true })),
},
want: false, // mismatching filter type
}, {
x: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_FOO}},
y: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_BAR}},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y int) bool { return true })),
},
want: false, // matching filter type, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_FOO}},
y: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_BAR}},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y map[string]testpb.TestAllTypes_NestedEnum) bool { return true })),
},
want: false, // matching filter type, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_FOO}},
y: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_BAR}},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y any) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_FOO}},
y: &testpb.TestAllTypes{MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{"k": testpb.TestAllTypes_BAR}},
opts: cmp.Options{
Transform(),
FilterEnum(testpb.TestAllTypes_NestedEnum(0), cmp.Comparer(func(x, y map[string]Enum) bool { return true })),
},
want: true,
}}...)
// Test FilterMessage.
tests = append(tests, []test{{
x: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)}},
y: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(2)}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)}},
y: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(2)}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllExtensions), cmp.Comparer(func(x, y any) bool { return true })),
},
want: false, // mismatching filter type
}, {
x: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)}},
y: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(2)}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y int) bool { return true })),
},
want: false, // matching filter type, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)}},
y: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(2)}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y *testpb.TestAllTypes_NestedMessage) bool { return true })),
},
want: false, // matching filter type, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)}},
y: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(2)}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y any) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(1)}},
y: &testpb.TestAllTypes{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(2)}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y Message) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(1)}}},
y: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(1)}}},
y: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllExtensions), cmp.Comparer(func(x, y any) bool { return true })),
},
want: false, // mismatching filter type
}, {
x: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(1)}}},
y: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y int) bool { return true })),
},
want: false, // matching filter type, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(1)}}},
y: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y []*testpb.TestAllTypes_NestedMessage) bool { return true })),
},
want: false, // matching filter type, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(1)}}},
y: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y any) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(1)}}},
y: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{{A: proto.Int32(2)}}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y []Message) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(1)}}},
y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(2)}}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(1)}}},
y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(2)}}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllExtensions), cmp.Comparer(func(x, y any) bool { return true })),
},
want: false, // mismatching filter type
}, {
x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(1)}}},
y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(2)}}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y int) bool { return true })),
},
want: false, // matching filter type, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(1)}}},
y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(2)}}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y map[string]*testpb.TestAllTypes_NestedMessage) bool { return true })),
},
want: false, // matching filter type, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(1)}}},
y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(2)}}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y any) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(1)}}},
y: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": {A: proto.Int32(2)}}},
opts: cmp.Options{
Transform(),
FilterMessage(new(testpb.TestAllTypes_NestedMessage), cmp.Comparer(func(x, y map[string]Message) bool { return true })),
},
want: true,
}}...)
// Test FilterField.
tests = append(tests, []test{{
x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(1)},
y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(2)},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(1)},
y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(2)},
opts: cmp.Options{
Transform(),
FilterField(new(testpb.TestAllTypes), "optional_int64", cmp.Comparer(func(x, y any) bool { return true })),
},
want: false, // mismatching filter name
}, {
x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(1)},
y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(2)},
opts: cmp.Options{
Transform(),
FilterField(new(testpb.TestAllTypes), "optional_int32", cmp.Comparer(func(x, y int64) bool { return true })),
},
want: false, // matching filter name, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(1)},
y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(2)},
opts: cmp.Options{
Transform(),
FilterField(new(testpb.TestAllTypes), "optional_int32", cmp.Comparer(func(x, y any) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{OptionalInt32: proto.Int32(1)},
y: &testpb.TestAllTypes{OptionalInt32: proto.Int32(2)},
opts: cmp.Options{
Transform(),
FilterField(new(testpb.TestAllTypes), "optional_int32", cmp.Comparer(func(x, y int32) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{RepeatedInt32: []int32{1}},
y: &testpb.TestAllTypes{RepeatedInt32: []int32{2}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{RepeatedInt32: []int32{1}},
y: &testpb.TestAllTypes{RepeatedInt32: []int32{2}},
opts: cmp.Options{
Transform(),
FilterField(new(testpb.TestAllTypes), "repeated_int64", cmp.Comparer(func(x, y any) bool { return true })),
},
want: false, // mismatching filter name
}, {
x: &testpb.TestAllTypes{RepeatedInt32: []int32{1}},
y: &testpb.TestAllTypes{RepeatedInt32: []int32{2}},
opts: cmp.Options{
Transform(),
FilterField(new(testpb.TestAllTypes), "repeated_int32", cmp.Comparer(func(x, y []int64) bool { return true })),
},
want: false, // matching filter name, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{RepeatedInt32: []int32{1}},
y: &testpb.TestAllTypes{RepeatedInt32: []int32{2}},
opts: cmp.Options{
Transform(),
FilterField(new(testpb.TestAllTypes), "repeated_int32", cmp.Comparer(func(x, y any) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{RepeatedInt32: []int32{1}},
y: &testpb.TestAllTypes{RepeatedInt32: []int32{2}},
opts: cmp.Options{
Transform(),
FilterField(new(testpb.TestAllTypes), "repeated_int32", cmp.Comparer(func(x, y []int32) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 1}},
y: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{2: 2}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 1}},
y: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{2: 2}},
opts: cmp.Options{
Transform(),
FilterField(new(testpb.TestAllTypes), "map_int64_int64", cmp.Comparer(func(x, y any) bool { return true })),
},
want: false, // mismatching filter name
}, {
x: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 1}},
y: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{2: 2}},
opts: cmp.Options{
Transform(),
FilterField(new(testpb.TestAllTypes), "map_int32_int32", cmp.Comparer(func(x, y map[int64]int64) bool { return true })),
},
want: false, // matching filter name, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 1}},
y: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{2: 2}},
opts: cmp.Options{
Transform(),
FilterField(new(testpb.TestAllTypes), "map_int32_int32", cmp.Comparer(func(x, y any) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{1: 1}},
y: &testpb.TestAllTypes{MapInt32Int32: map[int32]int32{2: 2}},
opts: cmp.Options{
Transform(),
FilterField(new(testpb.TestAllTypes), "map_int32_int32", cmp.Comparer(func(x, y map[int32]int32) bool { return true })),
},
want: true,
}}...)
// Test FilterOneof
tests = append(tests, []test{{
x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{1}},
y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{2}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{1}},
y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{2}},
opts: cmp.Options{
Transform(),
FilterOneof(new(testpb.TestAllTypes), "oneof_optional", cmp.Comparer(func(x, y any) bool { return true })),
},
want: false, // mismatching filter name
}, {
x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{1}},
y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{2}},
opts: cmp.Options{
Transform(),
FilterOneof(new(testpb.TestAllTypes), "oneof_field", cmp.Comparer(func(x, y string) bool { return true })),
},
want: false, // matching filter name, but mismatching comparer type
}, {
x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{1}},
y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{2}},
opts: cmp.Options{
Transform(),
FilterOneof(new(testpb.TestAllTypes), "oneof_field", cmp.Comparer(func(x, y uint32) bool { return true })),
},
want: true,
}, {
x: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{1}},
y: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofUint32{2}},
opts: cmp.Options{
Transform(),
FilterOneof(new(testpb.TestAllTypes), "oneof_field", cmp.Comparer(func(x, y any) bool { return true })),
},
want: true,
}}...)
// Test SortRepeated.
type higherOrderType struct {
M *testpb.TestAllTypes
I32s []int32
Es []testpb.TestAllTypes_NestedEnum
Ms []*testpb.ForeignMessage
}
tests = append(tests, []test{{
x: &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
y: &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
y: &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
opts: cmp.Options{
Transform(),
SortRepeated(func(x, y int32) bool { return x < y }),
},
want: true,
}, {
x: higherOrderType{
M: &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
I32s: []int32{3, 2, 1, 2, 3, 3},
},
y: higherOrderType{
M: &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
I32s: []int32{2, 3, 3, 2, 1, 3},
},
opts: cmp.Options{
Transform(),
SortRepeated(func(x, y int32) bool { return x < y }),
},
want: false, // sort does not apply to []int32 outside of a message
}, {
x: &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
y: &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
opts: cmp.Options{
Transform(),
SortRepeated(func(x, y int64) bool { return x < y }),
},
want: false, // wrong sort type: int32 != int64
}, {
x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
opts: cmp.Options{
Transform(),
SortRepeated(func(x, y testpb.TestAllTypes_NestedEnum) bool { return x < y }),
},
want: true,
}, {
x: higherOrderType{
M: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
Es: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ},
},
y: higherOrderType{
M: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
Es: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ},
},
opts: cmp.Options{
Transform(),
SortRepeated(func(x, y testpb.TestAllTypes_NestedEnum) bool { return x < y }),
},
want: false, // sort does not apply to []testpb.TestAllTypes_NestedEnum outside of a message
}, {
x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
opts: cmp.Options{
Transform(),
SortRepeated(func(x, y testpb.ForeignEnum) bool { return x < y }),
},
want: false, // wrong sort type: testpb.TestAllTypes_NestedEnum != testpb.ForeignEnum
}, {
x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
y: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
y: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
opts: cmp.Options{
Transform(),
SortRepeated(func(x, y *testpb.ForeignMessage) bool { return x.GetC() < y.GetC() }),
},
want: true,
}, {
x: higherOrderType{
M: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
Ms: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}},
},
y: higherOrderType{
M: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
Ms: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}},
},
opts: cmp.Options{
Transform(),
SortRepeated(func(x, y *testpb.ForeignMessage) bool { return x.GetC() < y.GetC() }),
},
want: false, // sort does not apply to []*testpb.ForeignMessage outside of a message
}, {
x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
y: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
opts: cmp.Options{
Transform(),
SortRepeated(func(x, y *testpb.TestAllTypes_NestedMessage) bool { return x.GetA() < y.GetA() }),
},
want: false, // wrong sort type: *testpb.ForeignMessage != *testpb.TestAllTypes_NestedMessage
}, {
x: &testpb.TestAllTypes{
RepeatedInt32: []int32{-32, +32},
RepeatedSint32: []int32{-32, +32},
RepeatedSfixed32: []int32{-32, +32},
RepeatedInt64: []int64{-64, +64},
RepeatedSint64: []int64{-64, +64},
RepeatedSfixed64: []int64{-64, +64},
RepeatedUint32: []uint32{0, 32},
RepeatedFixed32: []uint32{0, 32},
RepeatedUint64: []uint64{0, 64},
RepeatedFixed64: []uint64{0, 64},
},
y: &testpb.TestAllTypes{
RepeatedInt32: []int32{+32, -32},
RepeatedSint32: []int32{+32, -32},
RepeatedSfixed32: []int32{+32, -32},
RepeatedInt64: []int64{+64, -64},
RepeatedSint64: []int64{+64, -64},
RepeatedSfixed64: []int64{+64, -64},
RepeatedUint32: []uint32{32, 0},
RepeatedFixed32: []uint32{32, 0},
RepeatedUint64: []uint64{64, 0},
RepeatedFixed64: []uint64{64, 0},
},
opts: cmp.Options{
Transform(),
SortRepeated(func(x, y int32) bool { return x < y }),
SortRepeated(func(x, y int64) bool { return x < y }),
SortRepeated(func(x, y uint32) bool { return x < y }),
SortRepeated(func(x, y uint64) bool { return x < y }),
},
want: true,
}}...)
// Test SortRepeatedFields.
tests = append(tests, []test{{
x: &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
y: &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
y: &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
opts: cmp.Options{
Transform(),
SortRepeatedFields(new(testpb.TestAllTypes), "repeated_int32"),
},
want: true,
}, {
x: &testpb.TestAllTypes{RepeatedInt32: []int32{3, 2, 1, 2, 3, 3}},
y: &testpb.TestAllTypes{RepeatedInt32: []int32{2, 3, 3, 2, 1, 3}},
opts: cmp.Options{
Transform(),
SortRepeatedFields(new(testpb.TestAllTypes), "repeated_int64"),
},
want: false, // wrong field: repeated_int32 != repeated_int64
}, {
x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
opts: cmp.Options{
Transform(),
SortRepeatedFields(new(testpb.TestAllTypes), "repeated_nested_enum"),
},
want: true,
}, {
x: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAR, testpb.TestAllTypes_BAZ}},
y: &testpb.TestAllTypes{RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{testpb.TestAllTypes_BAR, testpb.TestAllTypes_FOO, testpb.TestAllTypes_BAZ}},
opts: cmp.Options{
Transform(),
SortRepeatedFields(new(testpb.TestAllTypes), "repeated_foreign_enum"),
},
want: false, // wrong field: repeated_nested_enum != repeated_foreign_enum
}, {
x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
y: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
opts: cmp.Options{Transform()},
want: false,
}, {
x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
y: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
opts: cmp.Options{
Transform(),
SortRepeatedFields(new(testpb.TestAllTypes), "repeated_foreign_message"),
},
want: true,
}, {
x: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{{}, {C: proto.Int32(3)}, nil, {C: proto.Int32(3)}, {C: proto.Int32(5)}, {C: proto.Int32(4)}}},
y: &testpb.TestAllTypes{RepeatedForeignMessage: []*testpb.ForeignMessage{nil, {C: proto.Int32(3)}, {}, {C: proto.Int32(4)}, {C: proto.Int32(3)}, {C: proto.Int32(5)}}},
opts: cmp.Options{
Transform(),
SortRepeatedFields(new(testpb.TestAllTypes), "repeated_nested_message"),
},
want: false, // wrong field: repeated_foreign_message != repeated_nested_message
}, {
x: &testpb.TestAllTypes{
RepeatedBool: []bool{false, true},
RepeatedInt32: []int32{-32, +32},
RepeatedInt64: []int64{-64, +64},
RepeatedUint32: []uint32{0, 32},
RepeatedUint64: []uint64{0, 64},
RepeatedFloat: []float32{-32.32, +32.32},
RepeatedDouble: []float64{-64.64, +64.64},
RepeatedString: []string{"hello", "world"},
RepeatedBytes: [][]byte{[]byte("hello"), []byte("world")},
RepeatedForeignEnum: []testpb.ForeignEnum{testpb.ForeignEnum_FOREIGN_FOO, testpb.ForeignEnum_FOREIGN_BAR},
RepeatedForeignMessage: []*testpb.ForeignMessage{{C: proto.Int32(-1)}, {C: proto.Int32(+1)}},
},
y: &testpb.TestAllTypes{
RepeatedBool: []bool{true, false},
RepeatedInt32: []int32{+32, -32},
RepeatedInt64: []int64{+64, -64},
RepeatedUint32: []uint32{32, 0},
RepeatedUint64: []uint64{64, 0},
RepeatedFloat: []float32{+32.32, -32.32},
RepeatedDouble: []float64{+64.64, -64.64},
RepeatedString: []string{"world", "hello"},
RepeatedBytes: [][]byte{[]byte("world"), []byte("hello")},
RepeatedForeignEnum: []testpb.ForeignEnum{testpb.ForeignEnum_FOREIGN_BAR, testpb.ForeignEnum_FOREIGN_FOO},
RepeatedForeignMessage: []*testpb.ForeignMessage{{C: proto.Int32(+1)}, {C: proto.Int32(-1)}},
},
opts: cmp.Options{
Transform(),
SortRepeatedFields(new(testpb.TestAllTypes),
"repeated_bool",
"repeated_int32",
"repeated_int64",
"repeated_uint32",
"repeated_uint64",
"repeated_float",
"repeated_double",
"repeated_string",
"repeated_bytes",
"repeated_foreign_enum",
"repeated_foreign_message",
),
},
want: true,
}}...)
for _, tt := range tests {
t.Run("", func(t *testing.T) {
got := cmp.Equal(tt.x, tt.y, tt.opts)
if got != tt.want {
if !got {
t.Errorf("cmp.Equal = false, want true; diff:\n%v", cmp.Diff(tt.x, tt.y, tt.opts))
} else {
t.Errorf("cmp.Equal = true, want false")
}
}
})
}
}
type setField struct {
num protoreflect.FieldNumber
val any
}
type setUnknown struct {
raw protoreflect.RawFields
}
type setExtension struct {
typ protoreflect.ExtensionType
val any
}
// apply applies a sequence of mutating operations to m.
func apply(m proto.Message, ops ...any) proto.Message {
mr := m.ProtoReflect()
md := mr.Descriptor()
for _, op := range ops {
switch op := op.(type) {
case setField:
fd := md.Fields().ByNumber(op.num)
mr.Set(fd, protoreflect.ValueOf(op.val))
case setUnknown:
mr.SetUnknown(op.raw)
case setExtension:
mr.Set(op.typ.TypeDescriptor(), protoreflect.ValueOf(op.val))
}
}
return m
}
func TestSort(t *testing.T) {
t.Run("F32", func(t *testing.T) {
want := []float32{
float32(math.Float32frombits(0xffc00000)), // -NaN
float32(math.Inf(-1)),
float32(-math.MaxFloat32),
float32(-123.456),
float32(-math.SmallestNonzeroFloat32),
float32(math.Copysign(0, -1)),
float32(math.Copysign(0, +1)),
float32(+math.SmallestNonzeroFloat32),
float32(+123.456),
float32(+math.MaxFloat32),
float32(math.Inf(+1)),
float32(math.Float32frombits(0x7fc00000)), // +NaN
}
for i := 0; i < 10; i++ {
t.Run("", func(t *testing.T) {
got := append([]float32(nil), want...)
rn := rand.New(rand.NewSource(int64(i)))
for i, j := range rn.Perm(len(got)) {
got[i], got[j] = got[j], got[i]
}
sort.Slice(got, func(i, j int) bool {
return lessF32(got[i], got[j])
})
cmpF32s := cmp.Comparer(func(x, y float32) bool {
return math.Float32bits(x) == math.Float32bits(y)
})
if diff := cmp.Diff(want, got, cmpF32s); diff != "" {
t.Errorf("Sort mismatch (-want +got):\n%s", diff)
}
})
}
})
t.Run("F64", func(t *testing.T) {
want := []float64{
float64(math.Float64frombits(0xfff8000000000001)), // -NaN
float64(math.Inf(-1)),
float64(-math.MaxFloat64),
float64(-123.456),
float64(-math.SmallestNonzeroFloat64),
float64(math.Copysign(0, -1)),
float64(math.Copysign(0, +1)),
float64(+math.SmallestNonzeroFloat64),
float64(+123.456),
float64(+math.MaxFloat64),
float64(math.Inf(+1)),
float64(math.Float64frombits(0x7ff8000000000001)), // +NaN
}
for i := 0; i < 10; i++ {
t.Run("", func(t *testing.T) {
got := append([]float64(nil), want...)
rn := rand.New(rand.NewSource(int64(i)))
for i, j := range rn.Perm(len(got)) {
got[i], got[j] = got[j], got[i]
}
sort.Slice(got, func(i, j int) bool {
return lessF64(got[i], got[j])
})
cmpF64s := cmp.Comparer(func(x, y float64) bool {
return math.Float64bits(x) == math.Float64bits(y)
})
if diff := cmp.Diff(want, got, cmpF64s); diff != "" {
t.Errorf("Sort mismatch (-want +got):\n%s", diff)
}
})
}
})
}
Reference in New Issue View Git Blame Copy Permalink