// Copyright 2018 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 impl_test import ( "fmt" "reflect" "sync" "testing" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" "google.golang.org/protobuf/encoding/prototext" pimpl "google.golang.org/protobuf/internal/impl" "google.golang.org/protobuf/internal/pragma" "google.golang.org/protobuf/proto" pdesc "google.golang.org/protobuf/reflect/protodesc" pref "google.golang.org/protobuf/reflect/protoreflect" preg "google.golang.org/protobuf/reflect/protoregistry" piface "google.golang.org/protobuf/runtime/protoiface" proto2_20180125 "google.golang.org/protobuf/internal/testprotos/legacy/proto2.v1.0.0-20180125-92554152" "google.golang.org/protobuf/types/descriptorpb" ) type LegacyTestMessage struct { XXX_unrecognized []byte XXX_InternalExtensions map[int32]pimpl.ExtensionField } func (*LegacyTestMessage) Reset() {} func (*LegacyTestMessage) String() string { return "" } func (*LegacyTestMessage) ProtoMessage() {} func (*LegacyTestMessage) ExtensionRangeArray() []piface.ExtensionRangeV1 { return []piface.ExtensionRangeV1{{Start: 10, End: 20}, {Start: 40, End: 80}, {Start: 10000, End: 20000}} } func (*LegacyTestMessage) Descriptor() ([]byte, []int) { return legacyFD, []int{0} } var legacyFD = func() []byte { b, _ := proto.Marshal(pdesc.ToFileDescriptorProto(mustMakeFileDesc(` name: "legacy.proto" syntax: "proto2" message_type: [{ name: "LegacyTestMessage" extension_range: [{start:10 end:20}, {start:40 end:80}, {start:10000 end:20000}] }] `, nil))) return pimpl.Export{}.CompressGZIP(b) }() func init() { mt := pimpl.Export{}.MessageTypeOf((*LegacyTestMessage)(nil)) preg.GlobalFiles.Register(mt.Descriptor().ParentFile()) preg.GlobalTypes.Register(mt) } func mustMakeExtensionType(fileDesc, extDesc string, t reflect.Type, r pdesc.Resolver) pref.ExtensionType { s := fmt.Sprintf(`name:"test.proto" syntax:"proto2" %s extension:[{%s}]`, fileDesc, extDesc) xd := mustMakeFileDesc(s, r).Extensions().Get(0) xi := &pimpl.ExtensionInfo{} pimpl.InitExtensionInfo(xi, xd, t) return xi } func mustMakeFileDesc(s string, r pdesc.Resolver) pref.FileDescriptor { pb := new(descriptorpb.FileDescriptorProto) if err := prototext.Unmarshal([]byte(s), pb); err != nil { panic(err) } fd, err := pdesc.NewFile(pb, r) if err != nil { panic(err) } return fd } var ( testParentDesc = pimpl.Export{}.MessageDescriptorOf((*LegacyTestMessage)(nil)) testEnumV1Desc = pimpl.Export{}.EnumDescriptorOf(proto2_20180125.Message_ChildEnum(0)) testMessageV1Desc = pimpl.Export{}.MessageDescriptorOf((*proto2_20180125.Message_ChildMessage)(nil)) testMessageV2Desc = enumMessagesType.Desc depReg = preg.NewFiles( testParentDesc.ParentFile(), testEnumV1Desc.ParentFile(), testMessageV1Desc.ParentFile(), enumProto2Desc.ParentFile(), testMessageV2Desc.ParentFile(), ) extensionTypes = []pref.ExtensionType{ mustMakeExtensionType( `package:"fizz.buzz" dependency:"legacy.proto"`, `name:"optional_bool" number:10000 label:LABEL_OPTIONAL type:TYPE_BOOL default_value:"true" extendee:".LegacyTestMessage"`, reflect.TypeOf(false), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:"legacy.proto"`, `name:"optional_int32" number:10001 label:LABEL_OPTIONAL type:TYPE_INT32 default_value:"-12345" extendee:".LegacyTestMessage"`, reflect.TypeOf(int32(0)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:"legacy.proto"`, `name:"optional_uint32" number:10002 label:LABEL_OPTIONAL type:TYPE_UINT32 default_value:"3200" extendee:".LegacyTestMessage"`, reflect.TypeOf(uint32(0)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:"legacy.proto"`, `name:"optional_float" number:10003 label:LABEL_OPTIONAL type:TYPE_FLOAT default_value:"3.14159" extendee:".LegacyTestMessage"`, reflect.TypeOf(float32(0)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:"legacy.proto"`, `name:"optional_string" number:10004 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"hello, \"world!\"\n" extendee:".LegacyTestMessage"`, reflect.TypeOf(""), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:"legacy.proto"`, `name:"optional_bytes" number:10005 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"dead\\336\\255\\276\\357beef" extendee:".LegacyTestMessage"`, reflect.TypeOf(([]byte)(nil)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:["legacy.proto", "proto2.v1.0.0-20180125-92554152/test.proto"]`, `name:"optional_enum_v1" number:10006 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".google.golang.org.proto2_20180125.Message.ChildEnum" default_value:"ALPHA" extendee:".LegacyTestMessage"`, reflect.TypeOf(proto2_20180125.Message_ChildEnum(0)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:["legacy.proto", "proto2.v1.0.0-20180125-92554152/test.proto"]`, `name:"optional_message_v1" number:10007 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".google.golang.org.proto2_20180125.Message.ChildMessage" extendee:".LegacyTestMessage"`, reflect.TypeOf((*proto2_20180125.Message_ChildMessage)(nil)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:["legacy.proto", "enum2.proto"]`, `name:"optional_enum_v2" number:10008 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".EnumProto2" default_value:"DEAD" extendee:".LegacyTestMessage"`, reflect.TypeOf(EnumProto2(0)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:["legacy.proto", "enum-messages.proto"]`, `name:"optional_message_v2" number:10009 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".EnumMessages" extendee:".LegacyTestMessage"`, reflect.TypeOf((*EnumMessages)(nil)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:"legacy.proto"`, `name:"repeated_bool" number:10010 label:LABEL_REPEATED type:TYPE_BOOL extendee:".LegacyTestMessage"`, reflect.TypeOf([]bool(nil)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:"legacy.proto"`, `name:"repeated_int32" number:10011 label:LABEL_REPEATED type:TYPE_INT32 extendee:".LegacyTestMessage"`, reflect.TypeOf([]int32(nil)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:"legacy.proto"`, `name:"repeated_uint32" number:10012 label:LABEL_REPEATED type:TYPE_UINT32 extendee:".LegacyTestMessage"`, reflect.TypeOf([]uint32(nil)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:"legacy.proto"`, `name:"repeated_float" number:10013 label:LABEL_REPEATED type:TYPE_FLOAT extendee:".LegacyTestMessage"`, reflect.TypeOf([]float32(nil)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:"legacy.proto"`, `name:"repeated_string" number:10014 label:LABEL_REPEATED type:TYPE_STRING extendee:".LegacyTestMessage"`, reflect.TypeOf([]string(nil)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:"legacy.proto"`, `name:"repeated_bytes" number:10015 label:LABEL_REPEATED type:TYPE_BYTES extendee:".LegacyTestMessage"`, reflect.TypeOf([][]byte(nil)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:["legacy.proto", "proto2.v1.0.0-20180125-92554152/test.proto"]`, `name:"repeated_enum_v1" number:10016 label:LABEL_REPEATED type:TYPE_ENUM type_name:".google.golang.org.proto2_20180125.Message.ChildEnum" extendee:".LegacyTestMessage"`, reflect.TypeOf([]proto2_20180125.Message_ChildEnum(nil)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:["legacy.proto", "proto2.v1.0.0-20180125-92554152/test.proto"]`, `name:"repeated_message_v1" number:10017 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".google.golang.org.proto2_20180125.Message.ChildMessage" extendee:".LegacyTestMessage"`, reflect.TypeOf([]*proto2_20180125.Message_ChildMessage(nil)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:["legacy.proto", "enum2.proto"]`, `name:"repeated_enum_v2" number:10018 label:LABEL_REPEATED type:TYPE_ENUM type_name:".EnumProto2" extendee:".LegacyTestMessage"`, reflect.TypeOf([]EnumProto2(nil)), depReg, ), mustMakeExtensionType( `package:"fizz.buzz" dependency:["legacy.proto", "enum-messages.proto"]`, `name:"repeated_message_v2" number:10019 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".EnumMessages" extendee:".LegacyTestMessage"`, reflect.TypeOf([]*EnumMessages(nil)), depReg, ), } extensionDescs = []*pimpl.ExtensionInfo{{ ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: (*bool)(nil), Field: 10000, Name: "fizz.buzz.optional_bool", Tag: "varint,10000,opt,name=optional_bool,def=1", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: (*int32)(nil), Field: 10001, Name: "fizz.buzz.optional_int32", Tag: "varint,10001,opt,name=optional_int32,def=-12345", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: (*uint32)(nil), Field: 10002, Name: "fizz.buzz.optional_uint32", Tag: "varint,10002,opt,name=optional_uint32,def=3200", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: (*float32)(nil), Field: 10003, Name: "fizz.buzz.optional_float", Tag: "fixed32,10003,opt,name=optional_float,def=3.14159", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: (*string)(nil), Field: 10004, Name: "fizz.buzz.optional_string", Tag: "bytes,10004,opt,name=optional_string,def=hello, \"world!\"\n", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: ([]byte)(nil), Field: 10005, Name: "fizz.buzz.optional_bytes", Tag: "bytes,10005,opt,name=optional_bytes,def=dead\\336\\255\\276\\357beef", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: (*proto2_20180125.Message_ChildEnum)(nil), Field: 10006, Name: "fizz.buzz.optional_enum_v1", Tag: "varint,10006,opt,name=optional_enum_v1,enum=google.golang.org.proto2_20180125.Message_ChildEnum,def=0", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: (*proto2_20180125.Message_ChildMessage)(nil), Field: 10007, Name: "fizz.buzz.optional_message_v1", Tag: "bytes,10007,opt,name=optional_message_v1", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: (*EnumProto2)(nil), Field: 10008, Name: "fizz.buzz.optional_enum_v2", Tag: "varint,10008,opt,name=optional_enum_v2,enum=EnumProto2,def=57005", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: (*EnumMessages)(nil), Field: 10009, Name: "fizz.buzz.optional_message_v2", Tag: "bytes,10009,opt,name=optional_message_v2", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: ([]bool)(nil), Field: 10010, Name: "fizz.buzz.repeated_bool", Tag: "varint,10010,rep,name=repeated_bool", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: ([]int32)(nil), Field: 10011, Name: "fizz.buzz.repeated_int32", Tag: "varint,10011,rep,name=repeated_int32", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: ([]uint32)(nil), Field: 10012, Name: "fizz.buzz.repeated_uint32", Tag: "varint,10012,rep,name=repeated_uint32", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: ([]float32)(nil), Field: 10013, Name: "fizz.buzz.repeated_float", Tag: "fixed32,10013,rep,name=repeated_float", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: ([]string)(nil), Field: 10014, Name: "fizz.buzz.repeated_string", Tag: "bytes,10014,rep,name=repeated_string", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: ([][]byte)(nil), Field: 10015, Name: "fizz.buzz.repeated_bytes", Tag: "bytes,10015,rep,name=repeated_bytes", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: ([]proto2_20180125.Message_ChildEnum)(nil), Field: 10016, Name: "fizz.buzz.repeated_enum_v1", Tag: "varint,10016,rep,name=repeated_enum_v1,enum=google.golang.org.proto2_20180125.Message_ChildEnum", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: ([]*proto2_20180125.Message_ChildMessage)(nil), Field: 10017, Name: "fizz.buzz.repeated_message_v1", Tag: "bytes,10017,rep,name=repeated_message_v1", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: ([]EnumProto2)(nil), Field: 10018, Name: "fizz.buzz.repeated_enum_v2", Tag: "varint,10018,rep,name=repeated_enum_v2,enum=EnumProto2", Filename: "test.proto", }, { ExtendedType: (*LegacyTestMessage)(nil), ExtensionType: ([]*EnumMessages)(nil), Field: 10019, Name: "fizz.buzz.repeated_message_v2", Tag: "bytes,10019,rep,name=repeated_message_v2", Filename: "test.proto", }} ) func TestLegacyExtensions(t *testing.T) { opts := cmp.Options{cmp.Comparer(func(x, y *proto2_20180125.Message_ChildMessage) bool { return x == y // pointer compare messages for object identity })} m := pimpl.Export{}.MessageOf(new(LegacyTestMessage)) // Check that getting the zero value returns the default value for scalars, // nil for singular messages, and an empty list for repeated fields. defaultValues := map[int]interface{}{ 0: bool(true), 1: int32(-12345), 2: uint32(3200), 3: float32(3.14159), 4: string("hello, \"world!\"\n"), 5: []byte("dead\xde\xad\xbe\xefbeef"), 6: proto2_20180125.Message_ALPHA, 7: nil, 8: EnumProto2(0xdead), 9: nil, } for i, xt := range extensionTypes { var got interface{} xd := xt.TypeDescriptor() if !(xd.IsList() || xd.IsMap() || xd.Message() != nil) { got = xt.InterfaceOf(m.Get(xd)) } want := defaultValues[i] if diff := cmp.Diff(want, got, opts); diff != "" { t.Errorf("Message.Get(%d) mismatch (-want +got):\n%v", xd.Number(), diff) } } // All fields should be unpopulated. for _, xt := range extensionTypes { xd := xt.TypeDescriptor() if m.Has(xd) { t.Errorf("Message.Has(%d) = true, want false", xd.Number()) } } // Set some values and append to values to the lists. m1a := &proto2_20180125.Message_ChildMessage{F1: proto.String("m1a")} m1b := &proto2_20180125.Message_ChildMessage{F1: proto.String("m2b")} m2a := &EnumMessages{EnumP2: EnumProto2(0x1b).Enum()} m2b := &EnumMessages{EnumP2: EnumProto2(0x2b).Enum()} setValues := map[int]interface{}{ 0: bool(false), 1: int32(-54321), 2: uint32(6400), 3: float32(2.71828), 4: string("goodbye, \"world!\"\n"), 5: []byte("live\xde\xad\xbe\xefchicken"), 6: proto2_20180125.Message_CHARLIE, 7: m1a, 8: EnumProto2(0xbeef), 9: m2a, 10: []bool{true}, 11: []int32{-1000}, 12: []uint32{1280}, 13: []float32{1.6180}, 14: []string{"zero"}, 15: [][]byte{[]byte("zero")}, 16: []proto2_20180125.Message_ChildEnum{proto2_20180125.Message_BRAVO}, 17: []*proto2_20180125.Message_ChildMessage{m1b}, 18: []EnumProto2{0xdead}, 19: []*EnumMessages{m2b}, } for i, xt := range extensionTypes { m.Set(xt.TypeDescriptor(), xt.ValueOf(setValues[i])) } for i, xt := range extensionTypes[len(extensionTypes)/2:] { v := extensionTypes[i].ValueOf(setValues[i]) m.Get(xt.TypeDescriptor()).List().Append(v) } // Get the values and check for equality. getValues := map[int]interface{}{ 0: bool(false), 1: int32(-54321), 2: uint32(6400), 3: float32(2.71828), 4: string("goodbye, \"world!\"\n"), 5: []byte("live\xde\xad\xbe\xefchicken"), 6: proto2_20180125.Message_ChildEnum(proto2_20180125.Message_CHARLIE), 7: m1a, 8: EnumProto2(0xbeef), 9: m2a, 10: []bool{true, false}, 11: []int32{-1000, -54321}, 12: []uint32{1280, 6400}, 13: []float32{1.6180, 2.71828}, 14: []string{"zero", "goodbye, \"world!\"\n"}, 15: [][]byte{[]byte("zero"), []byte("live\xde\xad\xbe\xefchicken")}, 16: []proto2_20180125.Message_ChildEnum{proto2_20180125.Message_BRAVO, proto2_20180125.Message_CHARLIE}, 17: []*proto2_20180125.Message_ChildMessage{m1b, m1a}, 18: []EnumProto2{0xdead, 0xbeef}, 19: []*EnumMessages{m2b, m2a}, } for i, xt := range extensionTypes { xd := xt.TypeDescriptor() got := xt.InterfaceOf(m.Get(xd)) want := getValues[i] if diff := cmp.Diff(want, got, opts); diff != "" { t.Errorf("Message.Get(%d) mismatch (-want +got):\n%v", xd.Number(), diff) } } // Clear all singular fields and truncate all repeated fields. for _, xt := range extensionTypes[:len(extensionTypes)/2] { m.Clear(xt.TypeDescriptor()) } for _, xt := range extensionTypes[len(extensionTypes)/2:] { m.Get(xt.TypeDescriptor()).List().Truncate(0) } // Clear all repeated fields. for _, xt := range extensionTypes[len(extensionTypes)/2:] { m.Clear(xt.TypeDescriptor()) } } func TestLegacyExtensionConvert(t *testing.T) { for i := range extensionTypes { i := i t.Run("", func(t *testing.T) { t.Parallel() wantType := extensionTypes[i] wantDesc := extensionDescs[i] gotType := (pref.ExtensionType)(wantDesc) gotDesc := wantType.(*pimpl.ExtensionInfo) // Concurrently call accessors to trigger possible races. for _, xt := range []pref.ExtensionType{wantType, wantDesc} { xt := xt go func() { xt.New() }() go func() { xt.Zero() }() go func() { xt.TypeDescriptor() }() } // TODO: We need a test package to compare descriptors. type list interface { Len() int pragma.DoNotImplement } opts := cmp.Options{ cmp.Comparer(func(x, y reflect.Type) bool { return x == y }), cmp.Transformer("", func(x list) []interface{} { out := make([]interface{}, x.Len()) v := reflect.ValueOf(x) for i := 0; i < x.Len(); i++ { m := v.MethodByName("Get") out[i] = m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface() } return out }), cmp.Transformer("", func(x pref.Descriptor) map[string]interface{} { out := make(map[string]interface{}) v := reflect.ValueOf(x) for i := 0; i < v.NumMethod(); i++ { name := v.Type().Method(i).Name if m := v.Method(i); m.Type().NumIn() == 0 && m.Type().NumOut() == 1 { switch name { case "ParentFile", "Parent": // Ignore parents to avoid recursive cycle. case "Options": // Ignore descriptor options since protos are not cmperable. case "ContainingOneof", "ContainingMessage", "Enum", "Message": // Avoid descending into a dependency to avoid a cycle. // Just record the full name if available. // // TODO: Cycle support in cmp would be useful here. v := m.Call(nil)[0] if !v.IsNil() { out[name] = v.Interface().(pref.Descriptor).FullName() } case "Type": // Ignore ExtensionTypeDescriptor.Type method to avoid cycle. default: out[name] = m.Call(nil)[0].Interface() } } } return out }), cmp.Transformer("", func(xt pref.ExtensionType) map[string]interface{} { return map[string]interface{}{ "Descriptor": xt.TypeDescriptor(), } }), cmp.Transformer("", func(v pref.Value) interface{} { return v.Interface() }), } if diff := cmp.Diff(&wantType, &gotType, opts); diff != "" { t.Errorf("ExtensionType mismatch (-want, +got):\n%v", diff) } opts = cmp.Options{ cmpopts.IgnoreFields(pimpl.ExtensionInfo{}, "ExtensionType"), cmpopts.IgnoreUnexported(pimpl.ExtensionInfo{}), } if diff := cmp.Diff(wantDesc, gotDesc, opts); diff != "" { t.Errorf("ExtensionDesc mismatch (-want, +got):\n%v", diff) } }) } } type ( MessageA struct { A1 *MessageA `protobuf:"bytes,1,req,name=a1"` A2 *MessageB `protobuf:"bytes,2,req,name=a2"` A3 Enum `protobuf:"varint,3,opt,name=a3,enum=legacy.Enum"` } MessageB struct { B1 *MessageA `protobuf:"bytes,1,req,name=b1"` B2 *MessageB `protobuf:"bytes,2,req,name=b2"` B3 Enum `protobuf:"varint,3,opt,name=b3,enum=legacy.Enum"` } Enum int32 ) func (*MessageA) Reset() { panic("not implemented") } func (*MessageA) String() string { panic("not implemented") } func (*MessageA) ProtoMessage() { panic("not implemented") } func (*MessageA) Descriptor() ([]byte, []int) { return concurrentFD, []int{0} } func (*MessageB) Reset() { panic("not implemented") } func (*MessageB) String() string { panic("not implemented") } func (*MessageB) ProtoMessage() { panic("not implemented") } func (*MessageB) Descriptor() ([]byte, []int) { return concurrentFD, []int{1} } func (Enum) EnumDescriptor() ([]byte, []int) { return concurrentFD, []int{0} } var concurrentFD = func() []byte { b, _ := proto.Marshal(pdesc.ToFileDescriptorProto(mustMakeFileDesc(` name: "concurrent.proto" syntax: "proto2" package: "legacy" message_type: [{ name: "MessageA" field: [ {name:"a1" number:1 label:LABEL_REQUIRED type:TYPE_MESSAGE type_name:".legacy.MessageA"}, {name:"a2" number:2 label:LABEL_REQUIRED type:TYPE_MESSAGE type_name:".legacy.MessageB"}, {name:"a3" number:3 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".legacy.Enum"} ] }, { name: "MessageB" field: [ {name:"a1" number:1 label:LABEL_REQUIRED type:TYPE_MESSAGE type_name:".legacy.MessageA"}, {name:"a2" number:2 label:LABEL_REQUIRED type:TYPE_MESSAGE type_name:".legacy.MessageB"}, {name:"a3" number:3 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".legacy.Enum"} ] }] enum_type: [{ name: "Enum" value: [{name:"FOO" number:500}] }] `, nil))) return pimpl.Export{}.CompressGZIP(b) }() // TestLegacyConcurrentInit tests that concurrent wrapping of multiple legacy types // results in the exact same descriptor being created. func TestLegacyConcurrentInit(t *testing.T) { const numParallel = 5 var messageATypes [numParallel]pref.MessageType var messageBTypes [numParallel]pref.MessageType var enumDescs [numParallel]pref.EnumDescriptor // Concurrently load message and enum types. var wg sync.WaitGroup for i := 0; i < numParallel; i++ { i := i wg.Add(3) go func() { defer wg.Done() messageATypes[i] = pimpl.Export{}.MessageTypeOf((*MessageA)(nil)) }() go func() { defer wg.Done() messageBTypes[i] = pimpl.Export{}.MessageTypeOf((*MessageB)(nil)) }() go func() { defer wg.Done() enumDescs[i] = pimpl.Export{}.EnumDescriptorOf(Enum(0)) }() } wg.Wait() var ( wantMTA = messageATypes[0] wantMDA = messageATypes[0].Descriptor().Fields().ByNumber(1).Message() wantMTB = messageBTypes[0] wantMDB = messageBTypes[0].Descriptor().Fields().ByNumber(2).Message() wantED = messageATypes[0].Descriptor().Fields().ByNumber(3).Enum() ) for _, gotMT := range messageATypes[1:] { if gotMT != wantMTA { t.Error("MessageType(MessageA) mismatch") } if gotMDA := gotMT.Descriptor().Fields().ByNumber(1).Message(); gotMDA != wantMDA { t.Error("MessageDescriptor(MessageA) mismatch") } if gotMDB := gotMT.Descriptor().Fields().ByNumber(2).Message(); gotMDB != wantMDB { t.Error("MessageDescriptor(MessageB) mismatch") } if gotED := gotMT.Descriptor().Fields().ByNumber(3).Enum(); gotED != wantED { t.Error("EnumDescriptor(Enum) mismatch") } } for _, gotMT := range messageBTypes[1:] { if gotMT != wantMTB { t.Error("MessageType(MessageB) mismatch") } if gotMDA := gotMT.Descriptor().Fields().ByNumber(1).Message(); gotMDA != wantMDA { t.Error("MessageDescriptor(MessageA) mismatch") } if gotMDB := gotMT.Descriptor().Fields().ByNumber(2).Message(); gotMDB != wantMDB { t.Error("MessageDescriptor(MessageB) mismatch") } if gotED := gotMT.Descriptor().Fields().ByNumber(3).Enum(); gotED != wantED { t.Error("EnumDescriptor(Enum) mismatch") } } for _, gotED := range enumDescs[1:] { if gotED != wantED { t.Error("EnumType(Enum) mismatch") } } } type LegacyTestMessageName1 struct{} func (*LegacyTestMessageName1) Reset() { panic("not implemented") } func (*LegacyTestMessageName1) String() string { panic("not implemented") } func (*LegacyTestMessageName1) ProtoMessage() { panic("not implemented") } type LegacyTestMessageName2 struct{} func (*LegacyTestMessageName2) Reset() { panic("not implemented") } func (*LegacyTestMessageName2) String() string { panic("not implemented") } func (*LegacyTestMessageName2) ProtoMessage() { panic("not implemented") } func (*LegacyTestMessageName2) XXX_MessageName() string { return "google.golang.org.LegacyTestMessageName2" } func TestLegacyMessageName(t *testing.T) { tests := []struct { in piface.MessageV1 suggestName pref.FullName wantName pref.FullName }{ {new(LegacyTestMessageName1), "google.golang.org.LegacyTestMessageName1", "google.golang.org.LegacyTestMessageName1"}, {new(LegacyTestMessageName2), "", "google.golang.org.LegacyTestMessageName2"}, } for _, tt := range tests { mt := pimpl.Export{}.LegacyMessageTypeOf(tt.in, tt.suggestName) if got := mt.Descriptor().FullName(); got != tt.wantName { t.Errorf("type: %T, name mismatch: got %v, want %v", tt.in, got, tt.wantName) } } }