diff --git a/testing/protocmp/util.go b/testing/protocmp/util.go
index 7455591..668bb2e 100644
--- a/testing/protocmp/util.go
+++ b/testing/protocmp/util.go
@@ -12,6 +12,7 @@
 	"strings"
 
 	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
 
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/reflect/protoreflect"
@@ -501,3 +502,178 @@
 		return strings.Trim(mi.Key().String(), "0123456789") == ""
 	}, cmp.Ignore())
 }
+
+// SortRepeated sorts repeated fields of the specified element type.
+// The less function must be of the form "func(T, T) bool" where T is the
+// Go element type for the repeated field kind.
+//
+// The element type T can be one of the following:
+//	• Go type for a protobuf scalar kind except for an enum
+//	  (i.e., bool, int32, int64, uint32, uint64, float32, float64, string, and []byte)
+//	• E where E is a concrete enum type that implements protoreflect.Enum
+//	• M where M is a concrete message type that implement proto.Message
+//
+// This option only applies to repeated fields within a protobuf message.
+// It does not operate on higher-order Go types that seem like a repeated field.
+// For example, a []T outside the context of a protobuf message will not be
+// handled by this option. To sort Go slices that are not repeated fields,
+// consider using "github.com/google/go-cmp/cmp/cmpopts".SortSlices instead.
+//
+// This must be used in conjunction with Transform.
+func SortRepeated(lessFunc interface{}) cmp.Option {
+	t, ok := checkTTBFunc(lessFunc)
+	if !ok {
+		panic(fmt.Sprintf("invalid less function: %T", lessFunc))
+	}
+
+	var opt cmp.Option
+	var sliceType reflect.Type
+	switch vf := reflect.ValueOf(lessFunc); {
+	case t.Implements(enumV2Type):
+		et := reflect.Zero(t).Interface().(protoreflect.Enum).Type()
+		lessFunc = func(x, y Enum) bool {
+			vx := reflect.ValueOf(et.New(x.Number()))
+			vy := reflect.ValueOf(et.New(y.Number()))
+			return vf.Call([]reflect.Value{vx, vy})[0].Bool()
+		}
+		opt = FilterDescriptor(et.Descriptor(), cmpopts.SortSlices(lessFunc))
+		sliceType = reflect.SliceOf(enumReflectType)
+	case t.Implements(messageV2Type):
+		mt := reflect.Zero(t).Interface().(protoreflect.ProtoMessage).ProtoReflect().Type()
+		lessFunc = func(x, y Message) bool {
+			mx := mt.New().Interface()
+			my := mt.New().Interface()
+			proto.Merge(mx, x)
+			proto.Merge(my, y)
+			vx := reflect.ValueOf(mx)
+			vy := reflect.ValueOf(my)
+			return vf.Call([]reflect.Value{vx, vy})[0].Bool()
+		}
+		opt = FilterDescriptor(mt.Descriptor(), cmpopts.SortSlices(lessFunc))
+		sliceType = reflect.SliceOf(messageReflectType)
+	default:
+		switch t {
+		case reflect.TypeOf(bool(false)):
+		case reflect.TypeOf(int32(0)):
+		case reflect.TypeOf(int64(0)):
+		case reflect.TypeOf(uint32(0)):
+		case reflect.TypeOf(uint64(0)):
+		case reflect.TypeOf(float32(0)):
+		case reflect.TypeOf(float64(0)):
+		case reflect.TypeOf(string("")):
+		case reflect.TypeOf([]byte(nil)):
+		default:
+			panic(fmt.Sprintf("invalid element type: %v", t))
+		}
+		opt = cmpopts.SortSlices(lessFunc)
+		sliceType = reflect.SliceOf(t)
+	}
+
+	return cmp.FilterPath(func(p cmp.Path) bool {
+		// Filter to only apply to repeated fields within a message.
+		if t := p.Index(-1).Type(); t == nil || t != sliceType {
+			return false
+		}
+		if t := p.Index(-2).Type(); t == nil || t.Kind() != reflect.Interface {
+			return false
+		}
+		if t := p.Index(-3).Type(); t == nil || t != messageReflectType {
+			return false
+		}
+		return true
+	}, opt)
+}
+
+func checkTTBFunc(lessFunc interface{}) (reflect.Type, bool) {
+	switch t := reflect.TypeOf(lessFunc); {
+	case t == nil:
+		return nil, false
+	case t.NumIn() != 2 || t.In(0) != t.In(1) || t.IsVariadic():
+		return nil, false
+	case t.NumOut() != 1 || t.Out(0) != reflect.TypeOf(false):
+		return nil, false
+	default:
+		return t.In(0), true
+	}
+}
+
+// SortRepeatedFields sorts the specified repeated fields.
+// Sorting a repeated field is useful for treating the list as a multiset
+// (i.e., a set where each value can appear multiple times).
+// It panics if the field does not exist or is not a repeated field.
+//
+// The sort ordering is as follows:
+//	• Booleans are sorted where false is sorted before true.
+//	• Integers are sorted in ascending order.
+//	• Floating-point numbers are sorted in ascending order according to
+//	  the total ordering defined by IEEE-754 (section 5.10).
+//	• Strings and bytes are sorted lexicographically in ascending order.
+//	• Enums are sorted in ascending order based on its numeric value.
+//	• Messages are sorted according to some arbitrary ordering
+//	  which is undefined and may change in future implementations.
+//
+// The ordering chosen for repeated messages is unlikely to be aesthetically
+// preferred by humans. Consider using a custom sort function:
+//
+//	FilterField(m, "foo_field", SortRepeated(func(x, y *foopb.MyMessage) bool {
+//	    ... // user-provided definition for less
+//	}))
+//
+// This must be used in conjunction with Transform.
+func SortRepeatedFields(message proto.Message, names ...protoreflect.Name) cmp.Option {
+	var opts cmp.Options
+	md := message.ProtoReflect().Descriptor()
+	for _, name := range names {
+		fd := mustFindFieldDescriptor(md, name)
+		if !fd.IsList() {
+			panic(fmt.Sprintf("message field %q is not repeated", fd.FullName()))
+		}
+
+		var lessFunc interface{}
+		switch fd.Kind() {
+		case protoreflect.BoolKind:
+			lessFunc = func(x, y bool) bool { return !x && y }
+		case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
+			lessFunc = func(x, y int32) bool { return x < y }
+		case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
+			lessFunc = func(x, y int64) bool { return x < y }
+		case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
+			lessFunc = func(x, y uint32) bool { return x < y }
+		case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
+			lessFunc = func(x, y uint64) bool { return x < y }
+		case protoreflect.FloatKind:
+			lessFunc = lessF32
+		case protoreflect.DoubleKind:
+			lessFunc = lessF64
+		case protoreflect.StringKind:
+			lessFunc = func(x, y string) bool { return x < y }
+		case protoreflect.BytesKind:
+			lessFunc = func(x, y []byte) bool { return bytes.Compare(x, y) < 0 }
+		case protoreflect.EnumKind:
+			lessFunc = func(x, y Enum) bool { return x.Number() < y.Number() }
+		case protoreflect.MessageKind, protoreflect.GroupKind:
+			lessFunc = func(x, y Message) bool { return x.String() < y.String() }
+		default:
+			panic(fmt.Sprintf("invalid kind: %v", fd.Kind()))
+		}
+		opts = append(opts, FilterDescriptor(fd, cmpopts.SortSlices(lessFunc)))
+	}
+	return opts
+}
+
+func lessF32(x, y float32) bool {
+	// Bit-wise implementation of IEEE-754, section 5.10.
+	xi := int32(math.Float32bits(x))
+	yi := int32(math.Float32bits(y))
+	xi ^= int32(uint32(xi>>31) >> 1)
+	yi ^= int32(uint32(yi>>31) >> 1)
+	return xi < yi
+}
+func lessF64(x, y float64) bool {
+	// Bit-wise implementation of IEEE-754, section 5.10.
+	xi := int64(math.Float64bits(x))
+	yi := int64(math.Float64bits(y))
+	xi ^= int64(uint64(xi>>63) >> 1)
+	yi ^= int64(uint64(yi>>63) >> 1)
+	return xi < yi
+}
diff --git a/testing/protocmp/util_test.go b/testing/protocmp/util_test.go
index 6f41ba4..728dcc7 100644
--- a/testing/protocmp/util_test.go
+++ b/testing/protocmp/util_test.go
@@ -5,6 +5,9 @@
 package protocmp
 
 import (
+	"math"
+	"math/rand"
+	"sort"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
@@ -1023,6 +1026,263 @@
 		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)
@@ -1066,3 +1326,74 @@
 	}
 	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)
+				}
+			})
+		}
+	})
+}
diff --git a/testing/protocmp/xform.go b/testing/protocmp/xform.go
index 3b2f9f3..8f26aa7 100644
--- a/testing/protocmp/xform.go
+++ b/testing/protocmp/xform.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package protocmp provides protobuf specific options for the cmp package.
+// Package protocmp provides protobuf specific options for the
+// "github.com/google/go-cmp/cmp" package.
 //
 // The primary feature is the Transform option, which transform proto.Message
 // types into a Message map that is suitable for cmp to introspect upon.
@@ -24,6 +25,7 @@
 )
 
 var (
+	enumV2Type    = reflect.TypeOf((*protoreflect.Enum)(nil)).Elem()
 	messageV1Type = reflect.TypeOf((*protoiface.MessageV1)(nil)).Elem()
 	messageV2Type = reflect.TypeOf((*proto.Message)(nil)).Elem()
 )