testing/protocmp/util_test.go

// 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)
				}
			})
		}
	})
}