mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-01-31 06:32:40 +00:00
16163b4f67
Remove the remaining uses of the prototype package.
The most significant change is to impl.MessageInfo, which now directly
implements the MessageType interface. This involves two notable changes
to exported fields of MessageInfo:
- PBType is now Desc.
- GoType is now GoReflectType. (Name changed to avoid a conflict with
the GoType method of the MessageType interface.)
Fixes golang/protobuf#911
Change-Id: Ie2aa4766d6887ceaa9cf06b1f109aa6e6e2a208f
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/189340
Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
656 lines
24 KiB
Go
656 lines
24 KiB
Go
// 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)
|
|
return pimpl.LegacyExtensionTypeOf(xd, t)
|
|
}
|
|
|
|
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 = []*piface.ExtensionDescV1{{
|
|
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.Descriptor()
|
|
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.Descriptor()
|
|
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.Descriptor(), xt.ValueOf(setValues[i]))
|
|
}
|
|
for i, xt := range extensionTypes[len(extensionTypes)/2:] {
|
|
v := extensionTypes[i].ValueOf(setValues[i])
|
|
m.Get(xt.Descriptor()).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.Descriptor()
|
|
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.Descriptor())
|
|
}
|
|
for _, xt := range extensionTypes[len(extensionTypes)/2:] {
|
|
m.Get(xt.Descriptor()).List().Truncate(0)
|
|
}
|
|
|
|
// Clear all repeated fields.
|
|
for _, xt := range extensionTypes[len(extensionTypes)/2:] {
|
|
m.Clear(xt.Descriptor())
|
|
}
|
|
}
|
|
|
|
func TestExtensionConvert(t *testing.T) {
|
|
for i := range extensionTypes {
|
|
i := i
|
|
t.Run("", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
wantType := extensionTypes[i]
|
|
wantDesc := extensionDescs[i]
|
|
gotType := pimpl.Export{}.ExtensionTypeFromDesc(wantDesc)
|
|
gotDesc := pimpl.Export{}.ExtensionDescFromType(wantType)
|
|
|
|
// 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.Descriptor(),
|
|
"GoType": xt.GoType(),
|
|
}
|
|
}),
|
|
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(piface.ExtensionDescV1{}, "Type"),
|
|
}
|
|
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) Descriptor() ([]byte, []int) { return concurrentFD, []int{0} }
|
|
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)
|
|
}()
|
|
|
|
// TestConcurrentInit tests that concurrent wrapping of multiple legacy types
|
|
// results in the exact same descriptor being created.
|
|
func TestConcurrentInit(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")
|
|
}
|
|
}
|
|
}
|