1// Copyright 2018 The Go Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style 3// license that can be found in the LICENSE file. 4 5package impl_test 6 7import ( 8 "fmt" 9 "math" 10 "reflect" 11 "runtime" 12 "strings" 13 "sync" 14 "testing" 15 16 cmp "github.com/google/go-cmp/cmp" 17 cmpopts "github.com/google/go-cmp/cmp/cmpopts" 18 19 "google.golang.org/protobuf/encoding/prototext" 20 pimpl "google.golang.org/protobuf/internal/impl" 21 "google.golang.org/protobuf/proto" 22 pdesc "google.golang.org/protobuf/reflect/protodesc" 23 pref "google.golang.org/protobuf/reflect/protoreflect" 24 "google.golang.org/protobuf/reflect/protoregistry" 25 "google.golang.org/protobuf/testing/protopack" 26 27 proto2_20180125 "google.golang.org/protobuf/internal/testprotos/legacy/proto2_20180125_92554152" 28 testpb "google.golang.org/protobuf/internal/testprotos/test" 29 "google.golang.org/protobuf/types/descriptorpb" 30) 31 32// List of test operations to perform on messages, lists, or maps. 33type ( 34 messageOp interface{ isMessageOp() } 35 messageOps []messageOp 36 37 listOp interface{ isListOp() } 38 listOps []listOp 39 40 mapOp interface{ isMapOp() } 41 mapOps []mapOp 42) 43 44// Test operations performed on a message. 45type ( 46 // check that the message contents match 47 equalMessage struct{ pref.Message } 48 // check presence for specific fields in the message 49 hasFields map[pref.FieldNumber]bool 50 // check that specific message fields match 51 getFields map[pref.FieldNumber]pref.Value 52 // set specific message fields 53 setFields map[pref.FieldNumber]pref.Value 54 // clear specific fields in the message 55 clearFields []pref.FieldNumber 56 // check for the presence of specific oneof member fields. 57 whichOneofs map[pref.Name]pref.FieldNumber 58 // apply messageOps on each specified message field 59 messageFields map[pref.FieldNumber]messageOps 60 messageFieldsMutable map[pref.FieldNumber]messageOps 61 // apply listOps on each specified list field 62 listFields map[pref.FieldNumber]listOps 63 listFieldsMutable map[pref.FieldNumber]listOps 64 // apply mapOps on each specified map fields 65 mapFields map[pref.FieldNumber]mapOps 66 mapFieldsMutable map[pref.FieldNumber]mapOps 67 // range through all fields and check that they match 68 rangeFields map[pref.FieldNumber]pref.Value 69) 70 71func (equalMessage) isMessageOp() {} 72func (hasFields) isMessageOp() {} 73func (getFields) isMessageOp() {} 74func (setFields) isMessageOp() {} 75func (clearFields) isMessageOp() {} 76func (whichOneofs) isMessageOp() {} 77func (messageFields) isMessageOp() {} 78func (messageFieldsMutable) isMessageOp() {} 79func (listFields) isMessageOp() {} 80func (listFieldsMutable) isMessageOp() {} 81func (mapFields) isMessageOp() {} 82func (mapFieldsMutable) isMessageOp() {} 83func (rangeFields) isMessageOp() {} 84 85// Test operations performed on a list. 86type ( 87 // check that the list contents match 88 equalList struct{ pref.List } 89 // check that list length matches 90 lenList int 91 // check that specific list entries match 92 getList map[int]pref.Value 93 // set specific list entries 94 setList map[int]pref.Value 95 // append entries to the list 96 appendList []pref.Value 97 // apply messageOps on a newly appended message 98 appendMessageList messageOps 99 // truncate the list to the specified length 100 truncList int 101) 102 103func (equalList) isListOp() {} 104func (lenList) isListOp() {} 105func (getList) isListOp() {} 106func (setList) isListOp() {} 107func (appendList) isListOp() {} 108func (appendMessageList) isListOp() {} 109func (truncList) isListOp() {} 110 111// Test operations performed on a map. 112type ( 113 // check that the map contents match 114 equalMap struct{ pref.Map } 115 // check that map length matches 116 lenMap int 117 // check presence for specific entries in the map 118 hasMap map[interface{}]bool 119 // check that specific map entries match 120 getMap map[interface{}]pref.Value 121 // set specific map entries 122 setMap map[interface{}]pref.Value 123 // clear specific entries in the map 124 clearMap []interface{} 125 // apply messageOps on each specified message entry 126 messageMap map[interface{}]messageOps 127 // range through all entries and check that they match 128 rangeMap map[interface{}]pref.Value 129) 130 131func (equalMap) isMapOp() {} 132func (lenMap) isMapOp() {} 133func (hasMap) isMapOp() {} 134func (getMap) isMapOp() {} 135func (setMap) isMapOp() {} 136func (clearMap) isMapOp() {} 137func (messageMap) isMapOp() {} 138func (rangeMap) isMapOp() {} 139 140type ScalarProto2 struct { 141 Bool *bool `protobuf:"1"` 142 Int32 *int32 `protobuf:"2"` 143 Int64 *int64 `protobuf:"3"` 144 Uint32 *uint32 `protobuf:"4"` 145 Uint64 *uint64 `protobuf:"5"` 146 Float32 *float32 `protobuf:"6"` 147 Float64 *float64 `protobuf:"7"` 148 String *string `protobuf:"8"` 149 StringA []byte `protobuf:"9"` 150 Bytes []byte `protobuf:"10"` 151 BytesA *string `protobuf:"11"` 152 153 MyBool *MyBool `protobuf:"12"` 154 MyInt32 *MyInt32 `protobuf:"13"` 155 MyInt64 *MyInt64 `protobuf:"14"` 156 MyUint32 *MyUint32 `protobuf:"15"` 157 MyUint64 *MyUint64 `protobuf:"16"` 158 MyFloat32 *MyFloat32 `protobuf:"17"` 159 MyFloat64 *MyFloat64 `protobuf:"18"` 160 MyString *MyString `protobuf:"19"` 161 MyStringA MyBytes `protobuf:"20"` 162 MyBytes MyBytes `protobuf:"21"` 163 MyBytesA *MyString `protobuf:"22"` 164} 165 166func mustMakeEnumDesc(path string, syntax pref.Syntax, enumDesc string) pref.EnumDescriptor { 167 s := fmt.Sprintf(`name:%q syntax:%q enum_type:[{%s}]`, path, syntax, enumDesc) 168 pb := new(descriptorpb.FileDescriptorProto) 169 if err := prototext.Unmarshal([]byte(s), pb); err != nil { 170 panic(err) 171 } 172 fd, err := pdesc.NewFile(pb, nil) 173 if err != nil { 174 panic(err) 175 } 176 return fd.Enums().Get(0) 177} 178 179func mustMakeMessageDesc(path string, syntax pref.Syntax, fileDesc, msgDesc string, r pdesc.Resolver) pref.MessageDescriptor { 180 s := fmt.Sprintf(`name:%q syntax:%q %s message_type:[{%s}]`, path, syntax, fileDesc, msgDesc) 181 pb := new(descriptorpb.FileDescriptorProto) 182 if err := prototext.Unmarshal([]byte(s), pb); err != nil { 183 panic(err) 184 } 185 fd, err := pdesc.NewFile(pb, r) 186 if err != nil { 187 panic(err) 188 } 189 return fd.Messages().Get(0) 190} 191 192var V = pref.ValueOf 193var VE = func(n pref.EnumNumber) pref.Value { return V(n) } 194 195type ( 196 MyBool bool 197 MyInt32 int32 198 MyInt64 int64 199 MyUint32 uint32 200 MyUint64 uint64 201 MyFloat32 float32 202 MyFloat64 float64 203 MyString string 204 MyBytes []byte 205 206 ListStrings []MyString 207 ListBytes []MyBytes 208 209 MapStrings map[MyString]MyString 210 MapBytes map[MyString]MyBytes 211) 212 213var scalarProto2Type = pimpl.MessageInfo{GoReflectType: reflect.TypeOf(new(ScalarProto2)), Desc: mustMakeMessageDesc("scalar2.proto", pref.Proto2, "", ` 214 name: "ScalarProto2" 215 field: [ 216 {name:"f1" number:1 label:LABEL_OPTIONAL type:TYPE_BOOL default_value:"true"}, 217 {name:"f2" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 default_value:"2"}, 218 {name:"f3" number:3 label:LABEL_OPTIONAL type:TYPE_INT64 default_value:"3"}, 219 {name:"f4" number:4 label:LABEL_OPTIONAL type:TYPE_UINT32 default_value:"4"}, 220 {name:"f5" number:5 label:LABEL_OPTIONAL type:TYPE_UINT64 default_value:"5"}, 221 {name:"f6" number:6 label:LABEL_OPTIONAL type:TYPE_FLOAT default_value:"6"}, 222 {name:"f7" number:7 label:LABEL_OPTIONAL type:TYPE_DOUBLE default_value:"7"}, 223 {name:"f8" number:8 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"8"}, 224 {name:"f9" number:9 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"9"}, 225 {name:"f10" number:10 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"10"}, 226 {name:"f11" number:11 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"11"}, 227 228 {name:"f12" number:12 label:LABEL_OPTIONAL type:TYPE_BOOL default_value:"true"}, 229 {name:"f13" number:13 label:LABEL_OPTIONAL type:TYPE_INT32 default_value:"13"}, 230 {name:"f14" number:14 label:LABEL_OPTIONAL type:TYPE_INT64 default_value:"14"}, 231 {name:"f15" number:15 label:LABEL_OPTIONAL type:TYPE_UINT32 default_value:"15"}, 232 {name:"f16" number:16 label:LABEL_OPTIONAL type:TYPE_UINT64 default_value:"16"}, 233 {name:"f17" number:17 label:LABEL_OPTIONAL type:TYPE_FLOAT default_value:"17"}, 234 {name:"f18" number:18 label:LABEL_OPTIONAL type:TYPE_DOUBLE default_value:"18"}, 235 {name:"f19" number:19 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"19"}, 236 {name:"f20" number:20 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"20"}, 237 {name:"f21" number:21 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"21"}, 238 {name:"f22" number:22 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"22"} 239 ] 240 `, nil), 241} 242 243func (m *ScalarProto2) ProtoReflect() pref.Message { return scalarProto2Type.MessageOf(m) } 244 245func TestScalarProto2(t *testing.T) { 246 testMessage(t, nil, new(ScalarProto2).ProtoReflect(), messageOps{ 247 hasFields{ 248 1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 249 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false, 250 }, 251 getFields{ 252 1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V([]byte("10")), 11: V([]byte("11")), 253 12: V(bool(true)), 13: V(int32(13)), 14: V(int64(14)), 15: V(uint32(15)), 16: V(uint64(16)), 17: V(float32(17)), 18: V(float64(18)), 19: V(string("19")), 20: V(string("20")), 21: V([]byte("21")), 22: V([]byte("22")), 254 }, 255 setFields{ 256 1: V(bool(false)), 2: V(int32(0)), 3: V(int64(0)), 4: V(uint32(0)), 5: V(uint64(0)), 6: V(float32(0)), 7: V(float64(0)), 8: V(string("")), 9: V(string("")), 10: V([]byte(nil)), 11: V([]byte(nil)), 257 12: V(bool(false)), 13: V(int32(0)), 14: V(int64(0)), 15: V(uint32(0)), 16: V(uint64(0)), 17: V(float32(0)), 18: V(float64(0)), 19: V(string("")), 20: V(string("")), 21: V([]byte(nil)), 22: V([]byte(nil)), 258 }, 259 hasFields{ 260 1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true, 261 12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true, 20: true, 21: true, 22: true, 262 }, 263 equalMessage{(&ScalarProto2{ 264 new(bool), new(int32), new(int64), new(uint32), new(uint64), new(float32), new(float64), new(string), []byte{}, []byte{}, new(string), 265 new(MyBool), new(MyInt32), new(MyInt64), new(MyUint32), new(MyUint64), new(MyFloat32), new(MyFloat64), new(MyString), MyBytes{}, MyBytes{}, new(MyString), 266 }).ProtoReflect()}, 267 clearFields{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22}, 268 equalMessage{new(ScalarProto2).ProtoReflect()}, 269 270 // Setting a bytes field nil empty bytes should preserve presence. 271 setFields{10: V([]byte(nil)), 11: V([]byte(nil)), 21: V([]byte(nil)), 22: V([]byte(nil))}, 272 getFields{10: V([]byte{}), 11: V([]byte(nil)), 21: V([]byte{}), 22: V([]byte(nil))}, 273 hasFields{10: true, 11: true, 21: true, 22: true}, 274 }) 275 276 // Test read-only operations on nil message. 277 testMessage(t, nil, (*ScalarProto2)(nil).ProtoReflect(), messageOps{ 278 hasFields{ 279 1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 280 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false, 281 }, 282 getFields{ 283 1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V([]byte("10")), 11: V([]byte("11")), 284 12: V(bool(true)), 13: V(int32(13)), 14: V(int64(14)), 15: V(uint32(15)), 16: V(uint64(16)), 17: V(float32(17)), 18: V(float64(18)), 19: V(string("19")), 20: V(string("20")), 21: V([]byte("21")), 22: V([]byte("22")), 285 }, 286 }) 287} 288 289type ScalarProto3 struct { 290 Bool bool `protobuf:"1"` 291 Int32 int32 `protobuf:"2"` 292 Int64 int64 `protobuf:"3"` 293 Uint32 uint32 `protobuf:"4"` 294 Uint64 uint64 `protobuf:"5"` 295 Float32 float32 `protobuf:"6"` 296 Float64 float64 `protobuf:"7"` 297 String string `protobuf:"8"` 298 StringA []byte `protobuf:"9"` 299 Bytes []byte `protobuf:"10"` 300 BytesA string `protobuf:"11"` 301 302 MyBool MyBool `protobuf:"12"` 303 MyInt32 MyInt32 `protobuf:"13"` 304 MyInt64 MyInt64 `protobuf:"14"` 305 MyUint32 MyUint32 `protobuf:"15"` 306 MyUint64 MyUint64 `protobuf:"16"` 307 MyFloat32 MyFloat32 `protobuf:"17"` 308 MyFloat64 MyFloat64 `protobuf:"18"` 309 MyString MyString `protobuf:"19"` 310 MyStringA MyBytes `protobuf:"20"` 311 MyBytes MyBytes `protobuf:"21"` 312 MyBytesA MyString `protobuf:"22"` 313} 314 315var scalarProto3Type = pimpl.MessageInfo{GoReflectType: reflect.TypeOf(new(ScalarProto3)), Desc: mustMakeMessageDesc("scalar3.proto", pref.Proto3, "", ` 316 name: "ScalarProto3" 317 field: [ 318 {name:"f1" number:1 label:LABEL_OPTIONAL type:TYPE_BOOL}, 319 {name:"f2" number:2 label:LABEL_OPTIONAL type:TYPE_INT32}, 320 {name:"f3" number:3 label:LABEL_OPTIONAL type:TYPE_INT64}, 321 {name:"f4" number:4 label:LABEL_OPTIONAL type:TYPE_UINT32}, 322 {name:"f5" number:5 label:LABEL_OPTIONAL type:TYPE_UINT64}, 323 {name:"f6" number:6 label:LABEL_OPTIONAL type:TYPE_FLOAT}, 324 {name:"f7" number:7 label:LABEL_OPTIONAL type:TYPE_DOUBLE}, 325 {name:"f8" number:8 label:LABEL_OPTIONAL type:TYPE_STRING}, 326 {name:"f9" number:9 label:LABEL_OPTIONAL type:TYPE_STRING}, 327 {name:"f10" number:10 label:LABEL_OPTIONAL type:TYPE_BYTES}, 328 {name:"f11" number:11 label:LABEL_OPTIONAL type:TYPE_BYTES}, 329 330 {name:"f12" number:12 label:LABEL_OPTIONAL type:TYPE_BOOL}, 331 {name:"f13" number:13 label:LABEL_OPTIONAL type:TYPE_INT32}, 332 {name:"f14" number:14 label:LABEL_OPTIONAL type:TYPE_INT64}, 333 {name:"f15" number:15 label:LABEL_OPTIONAL type:TYPE_UINT32}, 334 {name:"f16" number:16 label:LABEL_OPTIONAL type:TYPE_UINT64}, 335 {name:"f17" number:17 label:LABEL_OPTIONAL type:TYPE_FLOAT}, 336 {name:"f18" number:18 label:LABEL_OPTIONAL type:TYPE_DOUBLE}, 337 {name:"f19" number:19 label:LABEL_OPTIONAL type:TYPE_STRING}, 338 {name:"f20" number:20 label:LABEL_OPTIONAL type:TYPE_STRING}, 339 {name:"f21" number:21 label:LABEL_OPTIONAL type:TYPE_BYTES}, 340 {name:"f22" number:22 label:LABEL_OPTIONAL type:TYPE_BYTES} 341 ] 342 `, nil), 343} 344 345func (m *ScalarProto3) ProtoReflect() pref.Message { return scalarProto3Type.MessageOf(m) } 346 347func TestScalarProto3(t *testing.T) { 348 testMessage(t, nil, new(ScalarProto3).ProtoReflect(), messageOps{ 349 hasFields{ 350 1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 351 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false, 352 }, 353 getFields{ 354 1: V(bool(false)), 2: V(int32(0)), 3: V(int64(0)), 4: V(uint32(0)), 5: V(uint64(0)), 6: V(float32(0)), 7: V(float64(0)), 8: V(string("")), 9: V(string("")), 10: V([]byte(nil)), 11: V([]byte(nil)), 355 12: V(bool(false)), 13: V(int32(0)), 14: V(int64(0)), 15: V(uint32(0)), 16: V(uint64(0)), 17: V(float32(0)), 18: V(float64(0)), 19: V(string("")), 20: V(string("")), 21: V([]byte(nil)), 22: V([]byte(nil)), 356 }, 357 setFields{ 358 1: V(bool(false)), 2: V(int32(0)), 3: V(int64(0)), 4: V(uint32(0)), 5: V(uint64(0)), 6: V(float32(0)), 7: V(float64(0)), 8: V(string("")), 9: V(string("")), 10: V([]byte(nil)), 11: V([]byte(nil)), 359 12: V(bool(false)), 13: V(int32(0)), 14: V(int64(0)), 15: V(uint32(0)), 16: V(uint64(0)), 17: V(float32(0)), 18: V(float64(0)), 19: V(string("")), 20: V(string("")), 21: V([]byte(nil)), 22: V([]byte(nil)), 360 }, 361 hasFields{ 362 1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 363 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false, 364 }, 365 equalMessage{new(ScalarProto3).ProtoReflect()}, 366 setFields{ 367 1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V([]byte("10")), 11: V([]byte("11")), 368 12: V(bool(true)), 13: V(int32(13)), 14: V(int64(14)), 15: V(uint32(15)), 16: V(uint64(16)), 17: V(float32(17)), 18: V(float64(18)), 19: V(string("19")), 20: V(string("20")), 21: V([]byte("21")), 22: V([]byte("22")), 369 }, 370 hasFields{ 371 1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true, 372 12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true, 20: true, 21: true, 22: true, 373 }, 374 equalMessage{(&ScalarProto3{ 375 true, 2, 3, 4, 5, 6, 7, "8", []byte("9"), []byte("10"), "11", 376 true, 13, 14, 15, 16, 17, 18, "19", []byte("20"), []byte("21"), "22", 377 }).ProtoReflect()}, 378 setFields{ 379 2: V(int32(-2)), 3: V(int64(-3)), 6: V(float32(math.Inf(-1))), 7: V(float64(math.NaN())), 380 }, 381 hasFields{ 382 2: true, 3: true, 6: true, 7: true, 383 }, 384 clearFields{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22}, 385 equalMessage{new(ScalarProto3).ProtoReflect()}, 386 387 // Verify that -0 triggers proper Has behavior. 388 hasFields{6: false, 7: false}, 389 setFields{6: V(float32(math.Copysign(0, -1))), 7: V(float64(math.Copysign(0, -1)))}, 390 hasFields{6: true, 7: true}, 391 392 // Setting a bytes field to non-nil empty bytes should not preserve presence. 393 setFields{10: V([]byte{}), 11: V([]byte{}), 21: V([]byte{}), 22: V([]byte{})}, 394 getFields{10: V([]byte(nil)), 11: V([]byte(nil)), 21: V([]byte(nil)), 22: V([]byte(nil))}, 395 hasFields{10: false, 11: false, 21: false, 22: false}, 396 }) 397 398 // Test read-only operations on nil message. 399 testMessage(t, nil, (*ScalarProto3)(nil).ProtoReflect(), messageOps{ 400 hasFields{ 401 1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 402 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false, 403 }, 404 getFields{ 405 1: V(bool(false)), 2: V(int32(0)), 3: V(int64(0)), 4: V(uint32(0)), 5: V(uint64(0)), 6: V(float32(0)), 7: V(float64(0)), 8: V(string("")), 9: V(string("")), 10: V([]byte(nil)), 11: V([]byte(nil)), 406 12: V(bool(false)), 13: V(int32(0)), 14: V(int64(0)), 15: V(uint32(0)), 16: V(uint64(0)), 17: V(float32(0)), 18: V(float64(0)), 19: V(string("")), 20: V(string("")), 21: V([]byte(nil)), 22: V([]byte(nil)), 407 }, 408 }) 409} 410 411type ListScalars struct { 412 Bools []bool `protobuf:"1"` 413 Int32s []int32 `protobuf:"2"` 414 Int64s []int64 `protobuf:"3"` 415 Uint32s []uint32 `protobuf:"4"` 416 Uint64s []uint64 `protobuf:"5"` 417 Float32s []float32 `protobuf:"6"` 418 Float64s []float64 `protobuf:"7"` 419 Strings []string `protobuf:"8"` 420 StringsA [][]byte `protobuf:"9"` 421 Bytes [][]byte `protobuf:"10"` 422 BytesA []string `protobuf:"11"` 423 424 MyStrings1 []MyString `protobuf:"12"` 425 MyStrings2 []MyBytes `protobuf:"13"` 426 MyBytes1 []MyBytes `protobuf:"14"` 427 MyBytes2 []MyString `protobuf:"15"` 428 429 MyStrings3 ListStrings `protobuf:"16"` 430 MyStrings4 ListBytes `protobuf:"17"` 431 MyBytes3 ListBytes `protobuf:"18"` 432 MyBytes4 ListStrings `protobuf:"19"` 433} 434 435var listScalarsType = pimpl.MessageInfo{GoReflectType: reflect.TypeOf(new(ListScalars)), Desc: mustMakeMessageDesc("list-scalars.proto", pref.Proto2, "", ` 436 name: "ListScalars" 437 field: [ 438 {name:"f1" number:1 label:LABEL_REPEATED type:TYPE_BOOL}, 439 {name:"f2" number:2 label:LABEL_REPEATED type:TYPE_INT32}, 440 {name:"f3" number:3 label:LABEL_REPEATED type:TYPE_INT64}, 441 {name:"f4" number:4 label:LABEL_REPEATED type:TYPE_UINT32}, 442 {name:"f5" number:5 label:LABEL_REPEATED type:TYPE_UINT64}, 443 {name:"f6" number:6 label:LABEL_REPEATED type:TYPE_FLOAT}, 444 {name:"f7" number:7 label:LABEL_REPEATED type:TYPE_DOUBLE}, 445 {name:"f8" number:8 label:LABEL_REPEATED type:TYPE_STRING}, 446 {name:"f9" number:9 label:LABEL_REPEATED type:TYPE_STRING}, 447 {name:"f10" number:10 label:LABEL_REPEATED type:TYPE_BYTES}, 448 {name:"f11" number:11 label:LABEL_REPEATED type:TYPE_BYTES}, 449 450 {name:"f12" number:12 label:LABEL_REPEATED type:TYPE_STRING}, 451 {name:"f13" number:13 label:LABEL_REPEATED type:TYPE_STRING}, 452 {name:"f14" number:14 label:LABEL_REPEATED type:TYPE_BYTES}, 453 {name:"f15" number:15 label:LABEL_REPEATED type:TYPE_BYTES}, 454 455 {name:"f16" number:16 label:LABEL_REPEATED type:TYPE_STRING}, 456 {name:"f17" number:17 label:LABEL_REPEATED type:TYPE_STRING}, 457 {name:"f18" number:18 label:LABEL_REPEATED type:TYPE_BYTES}, 458 {name:"f19" number:19 label:LABEL_REPEATED type:TYPE_BYTES} 459 ] 460 `, nil), 461} 462 463func (m *ListScalars) ProtoReflect() pref.Message { return listScalarsType.MessageOf(m) } 464 465func TestListScalars(t *testing.T) { 466 empty := new(ListScalars).ProtoReflect() 467 want := (&ListScalars{ 468 Bools: []bool{true, false, true}, 469 Int32s: []int32{2, math.MinInt32, math.MaxInt32}, 470 Int64s: []int64{3, math.MinInt64, math.MaxInt64}, 471 Uint32s: []uint32{4, math.MaxUint32 / 2, math.MaxUint32}, 472 Uint64s: []uint64{5, math.MaxUint64 / 2, math.MaxUint64}, 473 Float32s: []float32{6, math.SmallestNonzeroFloat32, float32(math.NaN()), math.MaxFloat32}, 474 Float64s: []float64{7, math.SmallestNonzeroFloat64, float64(math.NaN()), math.MaxFloat64}, 475 Strings: []string{"8", "", "eight"}, 476 StringsA: [][]byte{[]byte("9"), nil, []byte("nine")}, 477 Bytes: [][]byte{[]byte("10"), nil, []byte("ten")}, 478 BytesA: []string{"11", "", "eleven"}, 479 480 MyStrings1: []MyString{"12", "", "twelve"}, 481 MyStrings2: []MyBytes{[]byte("13"), nil, []byte("thirteen")}, 482 MyBytes1: []MyBytes{[]byte("14"), nil, []byte("fourteen")}, 483 MyBytes2: []MyString{"15", "", "fifteen"}, 484 485 MyStrings3: ListStrings{"16", "", "sixteen"}, 486 MyStrings4: ListBytes{[]byte("17"), nil, []byte("seventeen")}, 487 MyBytes3: ListBytes{[]byte("18"), nil, []byte("eighteen")}, 488 MyBytes4: ListStrings{"19", "", "nineteen"}, 489 }).ProtoReflect() 490 491 testMessage(t, nil, new(ListScalars).ProtoReflect(), messageOps{ 492 hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false}, 493 getFields{1: getField(empty, 1), 3: getField(empty, 3), 5: getField(empty, 5), 7: getField(empty, 7), 9: getField(empty, 9), 11: getField(empty, 11), 13: getField(empty, 13), 15: getField(empty, 15), 17: getField(empty, 17), 19: getField(empty, 19)}, 494 setFields{1: getField(want, 1), 3: getField(want, 3), 5: getField(want, 5), 7: getField(want, 7), 9: getField(want, 9), 11: getField(want, 11), 13: getField(want, 13), 15: getField(want, 15), 17: getField(want, 17), 19: getField(want, 19)}, 495 listFieldsMutable{ 496 2: { 497 lenList(0), 498 appendList{V(int32(2)), V(int32(math.MinInt32)), V(int32(math.MaxInt32))}, 499 getList{0: V(int32(2)), 1: V(int32(math.MinInt32)), 2: V(int32(math.MaxInt32))}, 500 equalList{getField(want, 2).List()}, 501 }, 502 4: { 503 appendList{V(uint32(0)), V(uint32(0)), V(uint32(0))}, 504 setList{0: V(uint32(4)), 1: V(uint32(math.MaxUint32 / 2)), 2: V(uint32(math.MaxUint32))}, 505 lenList(3), 506 }, 507 6: { 508 appendList{V(float32(6)), V(float32(math.SmallestNonzeroFloat32)), V(float32(math.NaN())), V(float32(math.MaxFloat32))}, 509 equalList{getField(want, 6).List()}, 510 }, 511 8: { 512 appendList{V(""), V(""), V(""), V(""), V(""), V("")}, 513 lenList(6), 514 setList{0: V("8"), 2: V("eight")}, 515 truncList(3), 516 equalList{getField(want, 8).List()}, 517 }, 518 10: { 519 appendList{V([]byte(nil)), V([]byte(nil))}, 520 setList{0: V([]byte("10"))}, 521 appendList{V([]byte("wrong"))}, 522 setList{2: V([]byte("ten"))}, 523 equalList{getField(want, 10).List()}, 524 }, 525 12: { 526 appendList{V("12"), V("wrong"), V("twelve")}, 527 setList{1: V("")}, 528 equalList{getField(want, 12).List()}, 529 }, 530 14: { 531 appendList{V([]byte("14")), V([]byte(nil)), V([]byte("fourteen"))}, 532 equalList{getField(want, 14).List()}, 533 }, 534 16: { 535 appendList{V("16"), V(""), V("sixteen"), V("extra")}, 536 truncList(3), 537 equalList{getField(want, 16).List()}, 538 }, 539 18: { 540 appendList{V([]byte("18")), V([]byte(nil)), V([]byte("eighteen"))}, 541 equalList{getField(want, 18).List()}, 542 }, 543 }, 544 hasFields{1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true, 12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true}, 545 equalMessage{want}, 546 clearFields{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}, 547 equalMessage{empty}, 548 }) 549 550 // Test read-only operations on nil message. 551 testMessage(t, nil, (*ListScalars)(nil).ProtoReflect(), messageOps{ 552 hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false}, 553 listFields{2: {lenList(0)}, 4: {lenList(0)}, 6: {lenList(0)}, 8: {lenList(0)}, 10: {lenList(0)}, 12: {lenList(0)}, 14: {lenList(0)}, 16: {lenList(0)}, 18: {lenList(0)}}, 554 }) 555} 556 557type MapScalars struct { 558 KeyBools map[bool]string `protobuf:"1"` 559 KeyInt32s map[int32]string `protobuf:"2"` 560 KeyInt64s map[int64]string `protobuf:"3"` 561 KeyUint32s map[uint32]string `protobuf:"4"` 562 KeyUint64s map[uint64]string `protobuf:"5"` 563 KeyStrings map[string]string `protobuf:"6"` 564 565 ValBools map[string]bool `protobuf:"7"` 566 ValInt32s map[string]int32 `protobuf:"8"` 567 ValInt64s map[string]int64 `protobuf:"9"` 568 ValUint32s map[string]uint32 `protobuf:"10"` 569 ValUint64s map[string]uint64 `protobuf:"11"` 570 ValFloat32s map[string]float32 `protobuf:"12"` 571 ValFloat64s map[string]float64 `protobuf:"13"` 572 ValStrings map[string]string `protobuf:"14"` 573 ValStringsA map[string][]byte `protobuf:"15"` 574 ValBytes map[string][]byte `protobuf:"16"` 575 ValBytesA map[string]string `protobuf:"17"` 576 577 MyStrings1 map[MyString]MyString `protobuf:"18"` 578 MyStrings2 map[MyString]MyBytes `protobuf:"19"` 579 MyBytes1 map[MyString]MyBytes `protobuf:"20"` 580 MyBytes2 map[MyString]MyString `protobuf:"21"` 581 582 MyStrings3 MapStrings `protobuf:"22"` 583 MyStrings4 MapBytes `protobuf:"23"` 584 MyBytes3 MapBytes `protobuf:"24"` 585 MyBytes4 MapStrings `protobuf:"25"` 586} 587 588var mapScalarsType = pimpl.MessageInfo{GoReflectType: reflect.TypeOf(new(MapScalars)), Desc: mustMakeMessageDesc("map-scalars.proto", pref.Proto2, "", ` 589 name: "MapScalars" 590 field: [ 591 {name:"f1" number:1 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F1Entry"}, 592 {name:"f2" number:2 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F2Entry"}, 593 {name:"f3" number:3 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F3Entry"}, 594 {name:"f4" number:4 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F4Entry"}, 595 {name:"f5" number:5 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F5Entry"}, 596 {name:"f6" number:6 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F6Entry"}, 597 598 {name:"f7" number:7 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F7Entry"}, 599 {name:"f8" number:8 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F8Entry"}, 600 {name:"f9" number:9 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F9Entry"}, 601 {name:"f10" number:10 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F10Entry"}, 602 {name:"f11" number:11 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F11Entry"}, 603 {name:"f12" number:12 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F12Entry"}, 604 {name:"f13" number:13 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F13Entry"}, 605 {name:"f14" number:14 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F14Entry"}, 606 {name:"f15" number:15 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F15Entry"}, 607 {name:"f16" number:16 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F16Entry"}, 608 {name:"f17" number:17 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F17Entry"}, 609 610 {name:"f18" number:18 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F18Entry"}, 611 {name:"f19" number:19 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F19Entry"}, 612 {name:"f20" number:20 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F20Entry"}, 613 {name:"f21" number:21 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F21Entry"}, 614 615 {name:"f22" number:22 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F22Entry"}, 616 {name:"f23" number:23 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F23Entry"}, 617 {name:"f24" number:24 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F24Entry"}, 618 {name:"f25" number:25 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F25Entry"} 619 ] 620 nested_type: [ 621 {name:"F1Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_BOOL}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}}, 622 {name:"F2Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_INT32}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}}, 623 {name:"F3Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_INT64}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}}, 624 {name:"F4Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_UINT32}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}}, 625 {name:"F5Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_UINT64}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}}, 626 {name:"F6Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}}, 627 628 {name:"F7Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BOOL}] options:{map_entry:true}}, 629 {name:"F8Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_INT32}] options:{map_entry:true}}, 630 {name:"F9Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_INT64}] options:{map_entry:true}}, 631 {name:"F10Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_UINT32}] options:{map_entry:true}}, 632 {name:"F11Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_UINT64}] options:{map_entry:true}}, 633 {name:"F12Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_FLOAT}] options:{map_entry:true}}, 634 {name:"F13Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_DOUBLE}] options:{map_entry:true}}, 635 {name:"F14Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}}, 636 {name:"F15Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}}, 637 {name:"F16Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}] options:{map_entry:true}}, 638 {name:"F17Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}] options:{map_entry:true}}, 639 640 {name:"F18Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}}, 641 {name:"F19Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}}, 642 {name:"F20Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}] options:{map_entry:true}}, 643 {name:"F21Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}] options:{map_entry:true}}, 644 645 {name:"F22Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}}, 646 {name:"F23Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}}, 647 {name:"F24Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}] options:{map_entry:true}}, 648 {name:"F25Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}] options:{map_entry:true}} 649 ] 650 `, nil), 651} 652 653func (m *MapScalars) ProtoReflect() pref.Message { return mapScalarsType.MessageOf(m) } 654 655func TestMapScalars(t *testing.T) { 656 empty := new(MapScalars).ProtoReflect() 657 want := (&MapScalars{ 658 KeyBools: map[bool]string{true: "true", false: "false"}, 659 KeyInt32s: map[int32]string{0: "zero", -1: "one", 2: "two"}, 660 KeyInt64s: map[int64]string{0: "zero", -10: "ten", 20: "twenty"}, 661 KeyUint32s: map[uint32]string{0: "zero", 1: "one", 2: "two"}, 662 KeyUint64s: map[uint64]string{0: "zero", 10: "ten", 20: "twenty"}, 663 KeyStrings: map[string]string{"": "", "foo": "bar"}, 664 665 ValBools: map[string]bool{"true": true, "false": false}, 666 ValInt32s: map[string]int32{"one": 1, "two": 2, "three": 3}, 667 ValInt64s: map[string]int64{"ten": 10, "twenty": -20, "thirty": 30}, 668 ValUint32s: map[string]uint32{"0x00": 0x00, "0xff": 0xff, "0xdead": 0xdead}, 669 ValUint64s: map[string]uint64{"0x00": 0x00, "0xff": 0xff, "0xdead": 0xdead}, 670 ValFloat32s: map[string]float32{"nan": float32(math.NaN()), "pi": float32(math.Pi)}, 671 ValFloat64s: map[string]float64{"nan": float64(math.NaN()), "pi": float64(math.Pi)}, 672 ValStrings: map[string]string{"s1": "s1", "s2": "s2"}, 673 ValStringsA: map[string][]byte{"s1": []byte("s1"), "s2": []byte("s2")}, 674 ValBytes: map[string][]byte{"s1": []byte("s1"), "s2": []byte("s2")}, 675 ValBytesA: map[string]string{"s1": "s1", "s2": "s2"}, 676 677 MyStrings1: map[MyString]MyString{"s1": "s1", "s2": "s2"}, 678 MyStrings2: map[MyString]MyBytes{"s1": []byte("s1"), "s2": []byte("s2")}, 679 MyBytes1: map[MyString]MyBytes{"s1": []byte("s1"), "s2": []byte("s2")}, 680 MyBytes2: map[MyString]MyString{"s1": "s1", "s2": "s2"}, 681 682 MyStrings3: MapStrings{"s1": "s1", "s2": "s2"}, 683 MyStrings4: MapBytes{"s1": []byte("s1"), "s2": []byte("s2")}, 684 MyBytes3: MapBytes{"s1": []byte("s1"), "s2": []byte("s2")}, 685 MyBytes4: MapStrings{"s1": "s1", "s2": "s2"}, 686 }).ProtoReflect() 687 688 testMessage(t, nil, new(MapScalars).ProtoReflect(), messageOps{ 689 hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false, 23: false, 24: false, 25: false}, 690 getFields{1: getField(empty, 1), 3: getField(empty, 3), 5: getField(empty, 5), 7: getField(empty, 7), 9: getField(empty, 9), 11: getField(empty, 11), 13: getField(empty, 13), 15: getField(empty, 15), 17: getField(empty, 17), 19: getField(empty, 19), 21: getField(empty, 21), 23: getField(empty, 23), 25: getField(empty, 25)}, 691 setFields{1: getField(want, 1), 3: getField(want, 3), 5: getField(want, 5), 7: getField(want, 7), 9: getField(want, 9), 11: getField(want, 11), 13: getField(want, 13), 15: getField(want, 15), 17: getField(want, 17), 19: getField(want, 19), 21: getField(want, 21), 23: getField(want, 23), 25: getField(want, 25)}, 692 mapFieldsMutable{ 693 2: { 694 lenMap(0), 695 hasMap{int32(0): false, int32(-1): false, int32(2): false}, 696 setMap{int32(0): V("zero")}, 697 lenMap(1), 698 hasMap{int32(0): true, int32(-1): false, int32(2): false}, 699 setMap{int32(-1): V("one")}, 700 lenMap(2), 701 hasMap{int32(0): true, int32(-1): true, int32(2): false}, 702 setMap{int32(2): V("two")}, 703 lenMap(3), 704 hasMap{int32(0): true, int32(-1): true, int32(2): true}, 705 }, 706 4: { 707 setMap{uint32(0): V("zero"), uint32(1): V("one"), uint32(2): V("two")}, 708 equalMap{getField(want, 4).Map()}, 709 }, 710 6: { 711 clearMap{"noexist"}, 712 setMap{"foo": V("bar")}, 713 setMap{"": V("empty")}, 714 getMap{"": V("empty"), "foo": V("bar"), "noexist": V(nil)}, 715 setMap{"": V(""), "extra": V("extra")}, 716 clearMap{"extra", "noexist"}, 717 }, 718 8: { 719 equalMap{getField(empty, 8).Map()}, 720 setMap{"one": V(int32(1)), "two": V(int32(2)), "three": V(int32(3))}, 721 }, 722 10: { 723 setMap{"0x00": V(uint32(0x00)), "0xff": V(uint32(0xff)), "0xdead": V(uint32(0xdead))}, 724 lenMap(3), 725 equalMap{getField(want, 10).Map()}, 726 getMap{"0x00": V(uint32(0x00)), "0xff": V(uint32(0xff)), "0xdead": V(uint32(0xdead)), "0xdeadbeef": V(nil)}, 727 }, 728 12: { 729 setMap{"nan": V(float32(math.NaN())), "pi": V(float32(math.Pi)), "e": V(float32(math.E))}, 730 clearMap{"e", "phi"}, 731 rangeMap{"nan": V(float32(math.NaN())), "pi": V(float32(math.Pi))}, 732 }, 733 14: { 734 equalMap{getField(empty, 14).Map()}, 735 setMap{"s1": V("s1"), "s2": V("s2")}, 736 }, 737 16: { 738 setMap{"s1": V([]byte("s1")), "s2": V([]byte("s2"))}, 739 equalMap{getField(want, 16).Map()}, 740 }, 741 18: { 742 hasMap{"s1": false, "s2": false, "s3": false}, 743 setMap{"s1": V("s1"), "s2": V("s2")}, 744 hasMap{"s1": true, "s2": true, "s3": false}, 745 }, 746 20: { 747 equalMap{getField(empty, 20).Map()}, 748 setMap{"s1": V([]byte("s1")), "s2": V([]byte("s2"))}, 749 }, 750 22: { 751 rangeMap{}, 752 setMap{"s1": V("s1"), "s2": V("s2")}, 753 rangeMap{"s1": V("s1"), "s2": V("s2")}, 754 lenMap(2), 755 }, 756 24: { 757 setMap{"s1": V([]byte("s1")), "s2": V([]byte("s2"))}, 758 equalMap{getField(want, 24).Map()}, 759 }, 760 }, 761 hasFields{1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true, 12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true, 20: true, 21: true, 22: true, 23: true, 24: true, 25: true}, 762 equalMessage{want}, 763 clearFields{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25}, 764 equalMessage{empty}, 765 }) 766 767 // Test read-only operations on nil message. 768 testMessage(t, nil, (*MapScalars)(nil).ProtoReflect(), messageOps{ 769 hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false, 20: false, 21: false, 22: false, 23: false, 24: false, 25: false}, 770 mapFields{2: {lenMap(0)}, 4: {lenMap(0)}, 6: {lenMap(0)}, 8: {lenMap(0)}, 10: {lenMap(0)}, 12: {lenMap(0)}, 14: {lenMap(0)}, 16: {lenMap(0)}, 18: {lenMap(0)}, 20: {lenMap(0)}, 22: {lenMap(0)}, 24: {lenMap(0)}}, 771 }) 772} 773 774type OneofScalars struct { 775 Union isOneofScalars_Union `protobuf_oneof:"union"` 776} 777 778var oneofScalarsType = pimpl.MessageInfo{GoReflectType: reflect.TypeOf(new(OneofScalars)), Desc: mustMakeMessageDesc("oneof-scalars.proto", pref.Proto2, "", ` 779 name: "OneofScalars" 780 field: [ 781 {name:"f1" number:1 label:LABEL_OPTIONAL type:TYPE_BOOL default_value:"true" oneof_index:0}, 782 {name:"f2" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 default_value:"2" oneof_index:0}, 783 {name:"f3" number:3 label:LABEL_OPTIONAL type:TYPE_INT64 default_value:"3" oneof_index:0}, 784 {name:"f4" number:4 label:LABEL_OPTIONAL type:TYPE_UINT32 default_value:"4" oneof_index:0}, 785 {name:"f5" number:5 label:LABEL_OPTIONAL type:TYPE_UINT64 default_value:"5" oneof_index:0}, 786 {name:"f6" number:6 label:LABEL_OPTIONAL type:TYPE_FLOAT default_value:"6" oneof_index:0}, 787 {name:"f7" number:7 label:LABEL_OPTIONAL type:TYPE_DOUBLE default_value:"7" oneof_index:0}, 788 {name:"f8" number:8 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"8" oneof_index:0}, 789 {name:"f9" number:9 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"9" oneof_index:0}, 790 {name:"f10" number:10 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"10" oneof_index:0}, 791 {name:"f11" number:11 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"11" oneof_index:0}, 792 {name:"f12" number:12 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"12" oneof_index:0}, 793 {name:"f13" number:13 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"13" oneof_index:0} 794 ] 795 oneof_decl: [{name:"union"}] 796 `, nil), 797} 798 799func (m *OneofScalars) ProtoReflect() pref.Message { return oneofScalarsType.MessageOf(m) } 800 801func (*OneofScalars) XXX_OneofWrappers() []interface{} { 802 return []interface{}{ 803 (*OneofScalars_Bool)(nil), 804 (*OneofScalars_Int32)(nil), 805 (*OneofScalars_Int64)(nil), 806 (*OneofScalars_Uint32)(nil), 807 (*OneofScalars_Uint64)(nil), 808 (*OneofScalars_Float32)(nil), 809 (*OneofScalars_Float64)(nil), 810 (*OneofScalars_String)(nil), 811 (*OneofScalars_StringA)(nil), 812 (*OneofScalars_StringB)(nil), 813 (*OneofScalars_Bytes)(nil), 814 (*OneofScalars_BytesA)(nil), 815 (*OneofScalars_BytesB)(nil), 816 } 817} 818 819type ( 820 isOneofScalars_Union interface { 821 isOneofScalars_Union() 822 } 823 OneofScalars_Bool struct { 824 Bool bool `protobuf:"1"` 825 } 826 OneofScalars_Int32 struct { 827 Int32 MyInt32 `protobuf:"2"` 828 } 829 OneofScalars_Int64 struct { 830 Int64 int64 `protobuf:"3"` 831 } 832 OneofScalars_Uint32 struct { 833 Uint32 MyUint32 `protobuf:"4"` 834 } 835 OneofScalars_Uint64 struct { 836 Uint64 uint64 `protobuf:"5"` 837 } 838 OneofScalars_Float32 struct { 839 Float32 MyFloat32 `protobuf:"6"` 840 } 841 OneofScalars_Float64 struct { 842 Float64 float64 `protobuf:"7"` 843 } 844 OneofScalars_String struct { 845 String string `protobuf:"8"` 846 } 847 OneofScalars_StringA struct { 848 StringA []byte `protobuf:"9"` 849 } 850 OneofScalars_StringB struct { 851 StringB MyString `protobuf:"10"` 852 } 853 OneofScalars_Bytes struct { 854 Bytes []byte `protobuf:"11"` 855 } 856 OneofScalars_BytesA struct { 857 BytesA string `protobuf:"12"` 858 } 859 OneofScalars_BytesB struct { 860 BytesB MyBytes `protobuf:"13"` 861 } 862) 863 864func (*OneofScalars_Bool) isOneofScalars_Union() {} 865func (*OneofScalars_Int32) isOneofScalars_Union() {} 866func (*OneofScalars_Int64) isOneofScalars_Union() {} 867func (*OneofScalars_Uint32) isOneofScalars_Union() {} 868func (*OneofScalars_Uint64) isOneofScalars_Union() {} 869func (*OneofScalars_Float32) isOneofScalars_Union() {} 870func (*OneofScalars_Float64) isOneofScalars_Union() {} 871func (*OneofScalars_String) isOneofScalars_Union() {} 872func (*OneofScalars_StringA) isOneofScalars_Union() {} 873func (*OneofScalars_StringB) isOneofScalars_Union() {} 874func (*OneofScalars_Bytes) isOneofScalars_Union() {} 875func (*OneofScalars_BytesA) isOneofScalars_Union() {} 876func (*OneofScalars_BytesB) isOneofScalars_Union() {} 877 878func TestOneofs(t *testing.T) { 879 empty := &OneofScalars{} 880 want1 := &OneofScalars{Union: &OneofScalars_Bool{true}} 881 want2 := &OneofScalars{Union: &OneofScalars_Int32{20}} 882 want3 := &OneofScalars{Union: &OneofScalars_Int64{30}} 883 want4 := &OneofScalars{Union: &OneofScalars_Uint32{40}} 884 want5 := &OneofScalars{Union: &OneofScalars_Uint64{50}} 885 want6 := &OneofScalars{Union: &OneofScalars_Float32{60}} 886 want7 := &OneofScalars{Union: &OneofScalars_Float64{70}} 887 want8 := &OneofScalars{Union: &OneofScalars_String{string("80")}} 888 want9 := &OneofScalars{Union: &OneofScalars_StringA{[]byte("90")}} 889 want10 := &OneofScalars{Union: &OneofScalars_StringB{MyString("100")}} 890 want11 := &OneofScalars{Union: &OneofScalars_Bytes{[]byte("110")}} 891 want12 := &OneofScalars{Union: &OneofScalars_BytesA{string("120")}} 892 want13 := &OneofScalars{Union: &OneofScalars_BytesB{MyBytes("130")}} 893 894 testMessage(t, nil, new(OneofScalars).ProtoReflect(), messageOps{ 895 hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false}, 896 getFields{1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V(string("10")), 11: V([]byte("11")), 12: V([]byte("12")), 13: V([]byte("13"))}, 897 whichOneofs{"union": 0}, 898 899 setFields{1: V(bool(true))}, hasFields{1: true}, equalMessage{want1.ProtoReflect()}, 900 setFields{2: V(int32(20))}, hasFields{2: true}, equalMessage{want2.ProtoReflect()}, 901 setFields{3: V(int64(30))}, hasFields{3: true}, equalMessage{want3.ProtoReflect()}, 902 setFields{4: V(uint32(40))}, hasFields{4: true}, equalMessage{want4.ProtoReflect()}, 903 setFields{5: V(uint64(50))}, hasFields{5: true}, equalMessage{want5.ProtoReflect()}, 904 setFields{6: V(float32(60))}, hasFields{6: true}, equalMessage{want6.ProtoReflect()}, 905 setFields{7: V(float64(70))}, hasFields{7: true}, equalMessage{want7.ProtoReflect()}, 906 907 hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: true, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false}, 908 whichOneofs{"union": 7}, 909 910 setFields{8: V(string("80"))}, hasFields{8: true}, equalMessage{want8.ProtoReflect()}, 911 setFields{9: V(string("90"))}, hasFields{9: true}, equalMessage{want9.ProtoReflect()}, 912 setFields{10: V(string("100"))}, hasFields{10: true}, equalMessage{want10.ProtoReflect()}, 913 setFields{11: V([]byte("110"))}, hasFields{11: true}, equalMessage{want11.ProtoReflect()}, 914 setFields{12: V([]byte("120"))}, hasFields{12: true}, equalMessage{want12.ProtoReflect()}, 915 setFields{13: V([]byte("130"))}, hasFields{13: true}, equalMessage{want13.ProtoReflect()}, 916 917 hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: true}, 918 getFields{1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V(string("10")), 11: V([]byte("11")), 12: V([]byte("12")), 13: V([]byte("130"))}, 919 clearFields{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}, 920 whichOneofs{"union": 13}, 921 equalMessage{want13.ProtoReflect()}, 922 clearFields{13}, 923 whichOneofs{"union": 0}, 924 equalMessage{empty.ProtoReflect()}, 925 }) 926 927 // Test read-only operations on nil message. 928 testMessage(t, nil, (*OneofScalars)(nil).ProtoReflect(), messageOps{ 929 hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false}, 930 getFields{1: V(bool(true)), 2: V(int32(2)), 3: V(int64(3)), 4: V(uint32(4)), 5: V(uint64(5)), 6: V(float32(6)), 7: V(float64(7)), 8: V(string("8")), 9: V(string("9")), 10: V(string("10")), 11: V([]byte("11")), 12: V([]byte("12")), 13: V([]byte("13"))}, 931 }) 932} 933 934type EnumProto2 int32 935 936var enumProto2Desc = mustMakeEnumDesc("enum2.proto", pref.Proto2, ` 937 name: "EnumProto2" 938 value: [{name:"DEAD" number:0xdead}, {name:"BEEF" number:0xbeef}] 939`) 940 941func (e EnumProto2) Descriptor() pref.EnumDescriptor { return enumProto2Desc } 942func (e EnumProto2) Type() pref.EnumType { return e } 943func (e EnumProto2) Enum() *EnumProto2 { return &e } 944func (e EnumProto2) Number() pref.EnumNumber { return pref.EnumNumber(e) } 945func (t EnumProto2) New(n pref.EnumNumber) pref.Enum { return EnumProto2(n) } 946 947type EnumProto3 int32 948 949var enumProto3Desc = mustMakeEnumDesc("enum3.proto", pref.Proto3, ` 950 name: "EnumProto3", 951 value: [{name:"ALPHA" number:0}, {name:"BRAVO" number:1}] 952`) 953 954func (e EnumProto3) Descriptor() pref.EnumDescriptor { return enumProto3Desc } 955func (e EnumProto3) Type() pref.EnumType { return e } 956func (e EnumProto3) Enum() *EnumProto3 { return &e } 957func (e EnumProto3) Number() pref.EnumNumber { return pref.EnumNumber(e) } 958func (t EnumProto3) New(n pref.EnumNumber) pref.Enum { return EnumProto3(n) } 959 960type EnumMessages struct { 961 EnumP2 *EnumProto2 `protobuf:"1"` 962 EnumP3 *EnumProto3 `protobuf:"2"` 963 MessageLegacy *proto2_20180125.Message `protobuf:"3"` 964 MessageCycle *EnumMessages `protobuf:"4"` 965 EnumList []EnumProto2 `protobuf:"5"` 966 MessageList []*ScalarProto2 `protobuf:"6"` 967 EnumMap map[string]EnumProto3 `protobuf:"7"` 968 MessageMap map[string]*ScalarProto3 `protobuf:"8"` 969 Union isEnumMessages_Union `protobuf_oneof:"union"` 970} 971 972var enumMessagesType = pimpl.MessageInfo{GoReflectType: reflect.TypeOf(new(EnumMessages)), Desc: mustMakeMessageDesc("enum-messages.proto", pref.Proto2, ` 973 dependency: ["enum2.proto", "enum3.proto", "scalar2.proto", "scalar3.proto", "proto2_20180125_92554152/test.proto"] 974 `, ` 975 name: "EnumMessages" 976 field: [ 977 {name:"f1" number:1 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".EnumProto2" default_value:"BEEF"}, 978 {name:"f2" number:2 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".EnumProto3" default_value:"BRAVO"}, 979 {name:"f3" number:3 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".google.golang.org.proto2_20180125.Message"}, 980 {name:"f4" number:4 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".EnumMessages"}, 981 {name:"f5" number:5 label:LABEL_REPEATED type:TYPE_ENUM type_name:".EnumProto2"}, 982 {name:"f6" number:6 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".ScalarProto2"}, 983 {name:"f7" number:7 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".EnumMessages.F7Entry"}, 984 {name:"f8" number:8 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".EnumMessages.F8Entry"}, 985 {name:"f9" number:9 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".EnumProto2" oneof_index:0 default_value:"BEEF"}, 986 {name:"f10" number:10 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".EnumProto3" oneof_index:0 default_value:"BRAVO"}, 987 {name:"f11" number:11 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".ScalarProto2" oneof_index:0}, 988 {name:"f12" number:12 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".ScalarProto3" oneof_index:0} 989 ] 990 oneof_decl: [{name:"union"}] 991 nested_type: [ 992 {name:"F7Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".EnumProto3"}] options:{map_entry:true}}, 993 {name:"F8Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".ScalarProto3"}] options:{map_entry:true}} 994 ] 995 `, newFileRegistry( 996 EnumProto2(0).Descriptor().ParentFile(), 997 EnumProto3(0).Descriptor().ParentFile(), 998 ((*ScalarProto2)(nil)).ProtoReflect().Descriptor().ParentFile(), 999 ((*ScalarProto3)(nil)).ProtoReflect().Descriptor().ParentFile(), 1000 pimpl.Export{}.MessageDescriptorOf((*proto2_20180125.Message)(nil)).ParentFile(), 1001)), 1002} 1003 1004func newFileRegistry(files ...pref.FileDescriptor) *protoregistry.Files { 1005 r := new(protoregistry.Files) 1006 for _, file := range files { 1007 r.RegisterFile(file) 1008 } 1009 return r 1010} 1011 1012func (m *EnumMessages) ProtoReflect() pref.Message { return enumMessagesType.MessageOf(m) } 1013 1014func (*EnumMessages) XXX_OneofWrappers() []interface{} { 1015 return []interface{}{ 1016 (*EnumMessages_OneofE2)(nil), 1017 (*EnumMessages_OneofE3)(nil), 1018 (*EnumMessages_OneofM2)(nil), 1019 (*EnumMessages_OneofM3)(nil), 1020 } 1021} 1022 1023type ( 1024 isEnumMessages_Union interface { 1025 isEnumMessages_Union() 1026 } 1027 EnumMessages_OneofE2 struct { 1028 OneofE2 EnumProto2 `protobuf:"9"` 1029 } 1030 EnumMessages_OneofE3 struct { 1031 OneofE3 EnumProto3 `protobuf:"10"` 1032 } 1033 EnumMessages_OneofM2 struct { 1034 OneofM2 *ScalarProto2 `protobuf:"11"` 1035 } 1036 EnumMessages_OneofM3 struct { 1037 OneofM3 *ScalarProto3 `protobuf:"12"` 1038 } 1039) 1040 1041func (*EnumMessages_OneofE2) isEnumMessages_Union() {} 1042func (*EnumMessages_OneofE3) isEnumMessages_Union() {} 1043func (*EnumMessages_OneofM2) isEnumMessages_Union() {} 1044func (*EnumMessages_OneofM3) isEnumMessages_Union() {} 1045 1046func TestEnumMessages(t *testing.T) { 1047 emptyL := pimpl.Export{}.MessageOf(new(proto2_20180125.Message)) 1048 emptyM := new(EnumMessages).ProtoReflect() 1049 emptyM2 := new(ScalarProto2).ProtoReflect() 1050 emptyM3 := new(ScalarProto3).ProtoReflect() 1051 1052 wantL := pimpl.Export{}.MessageOf(&proto2_20180125.Message{OptionalFloat: proto.Float32(math.E)}) 1053 wantM := (&EnumMessages{EnumP2: EnumProto2(1234).Enum()}).ProtoReflect() 1054 wantM2a := &ScalarProto2{Float32: proto.Float32(math.Pi)} 1055 wantM2b := &ScalarProto2{Float32: proto.Float32(math.Phi)} 1056 wantM3a := &ScalarProto3{Float32: math.Pi} 1057 wantM3b := &ScalarProto3{Float32: math.Ln2} 1058 1059 wantList5 := getField((&EnumMessages{EnumList: []EnumProto2{333, 222}}).ProtoReflect(), 5) 1060 wantList6 := getField((&EnumMessages{MessageList: []*ScalarProto2{wantM2a, wantM2b}}).ProtoReflect(), 6) 1061 1062 wantMap7 := getField((&EnumMessages{EnumMap: map[string]EnumProto3{"one": 1, "two": 2}}).ProtoReflect(), 7) 1063 wantMap8 := getField((&EnumMessages{MessageMap: map[string]*ScalarProto3{"pi": wantM3a, "ln2": wantM3b}}).ProtoReflect(), 8) 1064 1065 testMessage(t, nil, new(EnumMessages).ProtoReflect(), messageOps{ 1066 hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false}, 1067 getFields{1: VE(0xbeef), 2: VE(1), 3: V(emptyL), 4: V(emptyM), 9: VE(0xbeef), 10: VE(1)}, 1068 1069 // Test singular enums. 1070 setFields{1: VE(0xdead), 2: VE(0)}, 1071 getFields{1: VE(0xdead), 2: VE(0)}, 1072 hasFields{1: true, 2: true}, 1073 1074 // Test singular messages. 1075 messageFieldsMutable{3: messageOps{setFields{109: V(float32(math.E))}}}, 1076 messageFieldsMutable{4: messageOps{setFields{1: VE(1234)}}}, 1077 getFields{3: V(wantL), 4: V(wantM)}, 1078 clearFields{3, 4}, 1079 hasFields{3: false, 4: false}, 1080 setFields{3: V(wantL), 4: V(wantM)}, 1081 hasFields{3: true, 4: true}, 1082 1083 // Test list of enums and messages. 1084 listFieldsMutable{ 1085 5: listOps{ 1086 appendList{VE(111), VE(222)}, 1087 setList{0: VE(333)}, 1088 getList{0: VE(333), 1: VE(222)}, 1089 lenList(2), 1090 }, 1091 6: listOps{ 1092 appendMessageList{setFields{4: V(uint32(1e6))}}, 1093 appendMessageList{setFields{6: V(float32(math.Phi))}}, 1094 setList{0: V(wantM2a.ProtoReflect())}, 1095 getList{0: V(wantM2a.ProtoReflect()), 1: V(wantM2b.ProtoReflect())}, 1096 }, 1097 }, 1098 getFields{5: wantList5, 6: wantList6}, 1099 hasFields{5: true, 6: true}, 1100 listFields{5: listOps{truncList(0)}}, 1101 hasFields{5: false, 6: true}, 1102 1103 // Test maps of enums and messages. 1104 mapFieldsMutable{ 1105 7: mapOps{ 1106 setMap{"one": VE(1), "two": VE(2)}, 1107 hasMap{"one": true, "two": true, "three": false}, 1108 lenMap(2), 1109 }, 1110 8: mapOps{ 1111 messageMap{"pi": messageOps{setFields{6: V(float32(math.Pi))}}}, 1112 setMap{"ln2": V(wantM3b.ProtoReflect())}, 1113 getMap{"pi": V(wantM3a.ProtoReflect()), "ln2": V(wantM3b.ProtoReflect()), "none": V(nil)}, 1114 lenMap(2), 1115 }, 1116 }, 1117 getFields{7: wantMap7, 8: wantMap8}, 1118 hasFields{7: true, 8: true}, 1119 mapFields{8: mapOps{clearMap{"pi", "ln2", "none"}}}, 1120 hasFields{7: true, 8: false}, 1121 1122 // Test oneofs of enums and messages. 1123 setFields{9: VE(0xdead)}, 1124 hasFields{1: true, 2: true, 9: true, 10: false, 11: false, 12: false}, 1125 setFields{10: VE(0)}, 1126 hasFields{1: true, 2: true, 9: false, 10: true, 11: false, 12: false}, 1127 messageFieldsMutable{11: messageOps{setFields{6: V(float32(math.Pi))}}}, 1128 getFields{11: V(wantM2a.ProtoReflect())}, 1129 hasFields{1: true, 2: true, 9: false, 10: false, 11: true, 12: false}, 1130 messageFieldsMutable{12: messageOps{setFields{6: V(float32(math.Pi))}}}, 1131 getFields{12: V(wantM3a.ProtoReflect())}, 1132 hasFields{1: true, 2: true, 9: false, 10: false, 11: false, 12: true}, 1133 1134 // Check entire message. 1135 rangeFields{1: VE(0xdead), 2: VE(0), 3: V(wantL), 4: V(wantM), 6: wantList6, 7: wantMap7, 12: V(wantM3a.ProtoReflect())}, 1136 equalMessage{(&EnumMessages{ 1137 EnumP2: EnumProto2(0xdead).Enum(), 1138 EnumP3: EnumProto3(0).Enum(), 1139 MessageLegacy: &proto2_20180125.Message{OptionalFloat: proto.Float32(math.E)}, 1140 MessageCycle: wantM.Interface().(*EnumMessages), 1141 MessageList: []*ScalarProto2{wantM2a, wantM2b}, 1142 EnumMap: map[string]EnumProto3{"one": 1, "two": 2}, 1143 Union: &EnumMessages_OneofM3{wantM3a}, 1144 }).ProtoReflect()}, 1145 clearFields{1, 2, 3, 4, 6, 7, 12}, 1146 equalMessage{new(EnumMessages).ProtoReflect()}, 1147 }) 1148 1149 // Test read-only operations on nil message. 1150 testMessage(t, nil, (*EnumMessages)(nil).ProtoReflect(), messageOps{ 1151 hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false}, 1152 getFields{1: VE(0xbeef), 2: VE(1), 3: V(emptyL), 4: V(emptyM), 9: VE(0xbeef), 10: VE(1), 11: V(emptyM2), 12: V(emptyM3)}, 1153 listFields{5: {lenList(0)}, 6: {lenList(0)}}, 1154 mapFields{7: {lenMap(0)}, 8: {lenMap(0)}}, 1155 }) 1156} 1157 1158var cmpOpts = cmp.Options{ 1159 cmp.Comparer(func(x, y *proto2_20180125.Message) bool { 1160 mx := pimpl.Export{}.MessageOf(x).Interface() 1161 my := pimpl.Export{}.MessageOf(y).Interface() 1162 return proto.Equal(mx, my) 1163 }), 1164 cmp.Transformer("UnwrapValue", func(pv pref.Value) interface{} { 1165 switch v := pv.Interface().(type) { 1166 case pref.Message: 1167 out := make(map[pref.FieldNumber]pref.Value) 1168 v.Range(func(fd pref.FieldDescriptor, v pref.Value) bool { 1169 out[fd.Number()] = v 1170 return true 1171 }) 1172 return out 1173 case pref.List: 1174 var out []pref.Value 1175 for i := 0; i < v.Len(); i++ { 1176 out = append(out, v.Get(i)) 1177 } 1178 return out 1179 case pref.Map: 1180 out := make(map[interface{}]pref.Value) 1181 v.Range(func(k pref.MapKey, v pref.Value) bool { 1182 out[k.Interface()] = v 1183 return true 1184 }) 1185 return out 1186 default: 1187 return v 1188 } 1189 }), 1190 cmpopts.EquateNaNs(), 1191} 1192 1193func testMessage(t *testing.T, p path, m pref.Message, tt messageOps) { 1194 fieldDescs := m.Descriptor().Fields() 1195 oneofDescs := m.Descriptor().Oneofs() 1196 for i, op := range tt { 1197 p.Push(i) 1198 switch op := op.(type) { 1199 case equalMessage: 1200 if diff := cmp.Diff(V(op.Message), V(m), cmpOpts); diff != "" { 1201 t.Errorf("operation %v, message mismatch (-want, +got):\n%s", p, diff) 1202 } 1203 case hasFields: 1204 got := map[pref.FieldNumber]bool{} 1205 want := map[pref.FieldNumber]bool(op) 1206 for n := range want { 1207 fd := fieldDescs.ByNumber(n) 1208 got[n] = m.Has(fd) 1209 } 1210 if diff := cmp.Diff(want, got); diff != "" { 1211 t.Errorf("operation %v, Message.Has mismatch (-want, +got):\n%s", p, diff) 1212 } 1213 case getFields: 1214 got := map[pref.FieldNumber]pref.Value{} 1215 want := map[pref.FieldNumber]pref.Value(op) 1216 for n := range want { 1217 fd := fieldDescs.ByNumber(n) 1218 got[n] = m.Get(fd) 1219 } 1220 if diff := cmp.Diff(want, got, cmpOpts); diff != "" { 1221 t.Errorf("operation %v, Message.Get mismatch (-want, +got):\n%s", p, diff) 1222 } 1223 case setFields: 1224 for n, v := range op { 1225 fd := fieldDescs.ByNumber(n) 1226 m.Set(fd, v) 1227 } 1228 case clearFields: 1229 for _, n := range op { 1230 fd := fieldDescs.ByNumber(n) 1231 m.Clear(fd) 1232 } 1233 case whichOneofs: 1234 got := map[pref.Name]pref.FieldNumber{} 1235 want := map[pref.Name]pref.FieldNumber(op) 1236 for s := range want { 1237 od := oneofDescs.ByName(s) 1238 fd := m.WhichOneof(od) 1239 if fd == nil { 1240 got[s] = 0 1241 } else { 1242 got[s] = fd.Number() 1243 } 1244 } 1245 if diff := cmp.Diff(want, got); diff != "" { 1246 t.Errorf("operation %v, Message.WhichOneof mismatch (-want, +got):\n%s", p, diff) 1247 } 1248 case messageFields: 1249 for n, tt := range op { 1250 p.Push(int(n)) 1251 fd := fieldDescs.ByNumber(n) 1252 testMessage(t, p, m.Get(fd).Message(), tt) 1253 p.Pop() 1254 } 1255 case messageFieldsMutable: 1256 for n, tt := range op { 1257 p.Push(int(n)) 1258 fd := fieldDescs.ByNumber(n) 1259 testMessage(t, p, m.Mutable(fd).Message(), tt) 1260 p.Pop() 1261 } 1262 case listFields: 1263 for n, tt := range op { 1264 p.Push(int(n)) 1265 fd := fieldDescs.ByNumber(n) 1266 testLists(t, p, m.Get(fd).List(), tt) 1267 p.Pop() 1268 } 1269 case listFieldsMutable: 1270 for n, tt := range op { 1271 p.Push(int(n)) 1272 fd := fieldDescs.ByNumber(n) 1273 testLists(t, p, m.Mutable(fd).List(), tt) 1274 p.Pop() 1275 } 1276 case mapFields: 1277 for n, tt := range op { 1278 p.Push(int(n)) 1279 fd := fieldDescs.ByNumber(n) 1280 testMaps(t, p, m.Get(fd).Map(), tt) 1281 p.Pop() 1282 } 1283 case mapFieldsMutable: 1284 for n, tt := range op { 1285 p.Push(int(n)) 1286 fd := fieldDescs.ByNumber(n) 1287 testMaps(t, p, m.Mutable(fd).Map(), tt) 1288 p.Pop() 1289 } 1290 case rangeFields: 1291 got := map[pref.FieldNumber]pref.Value{} 1292 want := map[pref.FieldNumber]pref.Value(op) 1293 m.Range(func(fd pref.FieldDescriptor, v pref.Value) bool { 1294 got[fd.Number()] = v 1295 return true 1296 }) 1297 if diff := cmp.Diff(want, got, cmpOpts); diff != "" { 1298 t.Errorf("operation %v, Message.Range mismatch (-want, +got):\n%s", p, diff) 1299 } 1300 default: 1301 t.Fatalf("operation %v, invalid operation: %T", p, op) 1302 } 1303 p.Pop() 1304 } 1305} 1306 1307func testLists(t *testing.T, p path, v pref.List, tt listOps) { 1308 for i, op := range tt { 1309 p.Push(i) 1310 switch op := op.(type) { 1311 case equalList: 1312 if diff := cmp.Diff(V(op.List), V(v), cmpOpts); diff != "" { 1313 t.Errorf("operation %v, list mismatch (-want, +got):\n%s", p, diff) 1314 } 1315 case lenList: 1316 if got, want := v.Len(), int(op); got != want { 1317 t.Errorf("operation %v, List.Len = %d, want %d", p, got, want) 1318 } 1319 case getList: 1320 got := map[int]pref.Value{} 1321 want := map[int]pref.Value(op) 1322 for n := range want { 1323 got[n] = v.Get(n) 1324 } 1325 if diff := cmp.Diff(want, got, cmpOpts); diff != "" { 1326 t.Errorf("operation %v, List.Get mismatch (-want, +got):\n%s", p, diff) 1327 } 1328 case setList: 1329 for n, e := range op { 1330 v.Set(n, e) 1331 } 1332 case appendList: 1333 for _, e := range op { 1334 v.Append(e) 1335 } 1336 case appendMessageList: 1337 e := v.NewElement() 1338 v.Append(e) 1339 testMessage(t, p, e.Message(), messageOps(op)) 1340 case truncList: 1341 v.Truncate(int(op)) 1342 default: 1343 t.Fatalf("operation %v, invalid operation: %T", p, op) 1344 } 1345 p.Pop() 1346 } 1347} 1348 1349func testMaps(t *testing.T, p path, m pref.Map, tt mapOps) { 1350 for i, op := range tt { 1351 p.Push(i) 1352 switch op := op.(type) { 1353 case equalMap: 1354 if diff := cmp.Diff(V(op.Map), V(m), cmpOpts); diff != "" { 1355 t.Errorf("operation %v, map mismatch (-want, +got):\n%s", p, diff) 1356 } 1357 case lenMap: 1358 if got, want := m.Len(), int(op); got != want { 1359 t.Errorf("operation %v, Map.Len = %d, want %d", p, got, want) 1360 } 1361 case hasMap: 1362 got := map[interface{}]bool{} 1363 want := map[interface{}]bool(op) 1364 for k := range want { 1365 got[k] = m.Has(V(k).MapKey()) 1366 } 1367 if diff := cmp.Diff(want, got, cmpOpts); diff != "" { 1368 t.Errorf("operation %v, Map.Has mismatch (-want, +got):\n%s", p, diff) 1369 } 1370 case getMap: 1371 got := map[interface{}]pref.Value{} 1372 want := map[interface{}]pref.Value(op) 1373 for k := range want { 1374 got[k] = m.Get(V(k).MapKey()) 1375 } 1376 if diff := cmp.Diff(want, got, cmpOpts); diff != "" { 1377 t.Errorf("operation %v, Map.Get mismatch (-want, +got):\n%s", p, diff) 1378 } 1379 case setMap: 1380 for k, v := range op { 1381 m.Set(V(k).MapKey(), v) 1382 } 1383 case clearMap: 1384 for _, k := range op { 1385 m.Clear(V(k).MapKey()) 1386 } 1387 case messageMap: 1388 for k, tt := range op { 1389 mk := V(k).MapKey() 1390 if !m.Has(mk) { 1391 m.Set(mk, m.NewValue()) 1392 } 1393 testMessage(t, p, m.Get(mk).Message(), tt) 1394 } 1395 case rangeMap: 1396 got := map[interface{}]pref.Value{} 1397 want := map[interface{}]pref.Value(op) 1398 m.Range(func(k pref.MapKey, v pref.Value) bool { 1399 got[k.Interface()] = v 1400 return true 1401 }) 1402 if diff := cmp.Diff(want, got, cmpOpts); diff != "" { 1403 t.Errorf("operation %v, Map.Range mismatch (-want, +got):\n%s", p, diff) 1404 } 1405 default: 1406 t.Fatalf("operation %v, invalid operation: %T", p, op) 1407 } 1408 p.Pop() 1409 } 1410} 1411 1412func getField(m pref.Message, n pref.FieldNumber) pref.Value { 1413 fd := m.Descriptor().Fields().ByNumber(n) 1414 return m.Get(fd) 1415} 1416 1417type path []int 1418 1419func (p *path) Push(i int) { *p = append(*p, i) } 1420func (p *path) Pop() { *p = (*p)[:len(*p)-1] } 1421func (p path) String() string { 1422 var ss []string 1423 for _, i := range p { 1424 ss = append(ss, fmt.Sprint(i)) 1425 } 1426 return strings.Join(ss, ".") 1427} 1428 1429type UnknownFieldsA struct { 1430 XXX_unrecognized []byte 1431} 1432 1433var unknownFieldsAType = pimpl.MessageInfo{ 1434 GoReflectType: reflect.TypeOf(new(UnknownFieldsA)), 1435 Desc: mustMakeMessageDesc("unknown.proto", pref.Proto2, "", `name: "UnknownFieldsA"`, nil), 1436} 1437 1438func (m *UnknownFieldsA) ProtoReflect() pref.Message { return unknownFieldsAType.MessageOf(m) } 1439 1440type UnknownFieldsB struct { 1441 XXX_unrecognized *[]byte 1442} 1443 1444var unknownFieldsBType = pimpl.MessageInfo{ 1445 GoReflectType: reflect.TypeOf(new(UnknownFieldsB)), 1446 Desc: mustMakeMessageDesc("unknown.proto", pref.Proto2, "", `name: "UnknownFieldsB"`, nil), 1447} 1448 1449func (m *UnknownFieldsB) ProtoReflect() pref.Message { return unknownFieldsBType.MessageOf(m) } 1450 1451func TestUnknownFields(t *testing.T) { 1452 for _, m := range []proto.Message{new(UnknownFieldsA), new(UnknownFieldsB)} { 1453 t.Run(reflect.TypeOf(m).Elem().Name(), func(t *testing.T) { 1454 want := protopack.Message{ 1455 protopack.Tag{1, protopack.BytesType}, protopack.String("Hello, world!"), 1456 }.Marshal() 1457 m.ProtoReflect().SetUnknown(want) 1458 got := []byte(m.ProtoReflect().GetUnknown()) 1459 if diff := cmp.Diff(want, got); diff != "" { 1460 t.Errorf("UnknownFields mismatch (-want +got):\n%s", diff) 1461 } 1462 }) 1463 } 1464} 1465 1466func TestReset(t *testing.T) { 1467 mi := new(testpb.TestAllTypes) 1468 1469 // ProtoReflect is implemented using a messageState cache. 1470 m := mi.ProtoReflect() 1471 1472 // Reset must not clear the messageState cache. 1473 mi.Reset() 1474 1475 // If Reset accidentally cleared the messageState cache, this panics. 1476 m.Descriptor() 1477} 1478 1479func TestIsValid(t *testing.T) { 1480 var m *testpb.TestAllTypes 1481 if got, want := m.ProtoReflect().IsValid(), false; got != want { 1482 t.Errorf("((*M)(nil)).ProtoReflect().IsValid() = %v, want %v", got, want) 1483 } 1484 m = &testpb.TestAllTypes{} 1485 if got, want := m.ProtoReflect().IsValid(), true; got != want { 1486 t.Errorf("(&M{}).ProtoReflect().IsValid() = %v, want %v", got, want) 1487 } 1488} 1489 1490// The MessageState implementation makes the assumption that when a 1491// concrete message is unsafe casted as a *MessageState, the Go GC does 1492// not reclaim the memory for the remainder of the concrete message. 1493func TestUnsafeAssumptions(t *testing.T) { 1494 if !pimpl.UnsafeEnabled { 1495 t.Skip() 1496 } 1497 1498 var wg sync.WaitGroup 1499 for i := 0; i < 10; i++ { 1500 wg.Add(1) 1501 go func() { 1502 var ms [10]pref.Message 1503 1504 // Store the message only in its reflective form. 1505 // Trigger the GC after each iteration. 1506 for j := 0; j < 10; j++ { 1507 ms[j] = (&testpb.TestAllTypes{ 1508 OptionalInt32: proto.Int32(int32(j)), 1509 OptionalFloat: proto.Float32(float32(j)), 1510 RepeatedInt32: []int32{int32(j)}, 1511 RepeatedFloat: []float32{float32(j)}, 1512 DefaultInt32: proto.Int32(int32(j)), 1513 DefaultFloat: proto.Float32(float32(j)), 1514 }).ProtoReflect() 1515 runtime.GC() 1516 } 1517 1518 // Convert the reflective form back into a concrete form. 1519 // Verify that the values written previously are still the same. 1520 for j := 0; j < 10; j++ { 1521 switch m := ms[j].Interface().(*testpb.TestAllTypes); { 1522 case m.GetOptionalInt32() != int32(j): 1523 case m.GetOptionalFloat() != float32(j): 1524 case m.GetRepeatedInt32()[0] != int32(j): 1525 case m.GetRepeatedFloat()[0] != float32(j): 1526 case m.GetDefaultInt32() != int32(j): 1527 case m.GetDefaultFloat() != float32(j): 1528 default: 1529 continue 1530 } 1531 t.Error("memory corrupted detected") 1532 } 1533 defer wg.Done() 1534 }() 1535 } 1536 wg.Wait() 1537} 1538 1539func BenchmarkName(b *testing.B) { 1540 var sink pref.FullName 1541 b.Run("Value", func(b *testing.B) { 1542 b.ReportAllocs() 1543 m := new(descriptorpb.FileDescriptorProto) 1544 for i := 0; i < b.N; i++ { 1545 sink = m.ProtoReflect().Descriptor().FullName() 1546 } 1547 }) 1548 b.Run("Nil", func(b *testing.B) { 1549 b.ReportAllocs() 1550 m := (*descriptorpb.FileDescriptorProto)(nil) 1551 for i := 0; i < b.N; i++ { 1552 sink = m.ProtoReflect().Descriptor().FullName() 1553 } 1554 }) 1555 runtime.KeepAlive(sink) 1556} 1557 1558func BenchmarkReflect(b *testing.B) { 1559 m := new(testpb.TestAllTypes).ProtoReflect() 1560 fds := m.Descriptor().Fields() 1561 vs := make([]pref.Value, fds.Len()) 1562 for i := range vs { 1563 vs[i] = m.NewField(fds.Get(i)) 1564 } 1565 1566 b.Run("Has", func(b *testing.B) { 1567 b.ReportAllocs() 1568 for i := 0; i < b.N; i++ { 1569 for j := 0; j < fds.Len(); j++ { 1570 m.Has(fds.Get(j)) 1571 } 1572 } 1573 }) 1574 b.Run("Get", func(b *testing.B) { 1575 b.ReportAllocs() 1576 for i := 0; i < b.N; i++ { 1577 for j := 0; j < fds.Len(); j++ { 1578 m.Get(fds.Get(j)) 1579 } 1580 } 1581 }) 1582 b.Run("Set", func(b *testing.B) { 1583 b.ReportAllocs() 1584 for i := 0; i < b.N; i++ { 1585 for j := 0; j < fds.Len(); j++ { 1586 m.Set(fds.Get(j), vs[j]) 1587 } 1588 } 1589 }) 1590 b.Run("Clear", func(b *testing.B) { 1591 b.ReportAllocs() 1592 for i := 0; i < b.N; i++ { 1593 for j := 0; j < fds.Len(); j++ { 1594 m.Clear(fds.Get(j)) 1595 } 1596 } 1597 }) 1598 b.Run("Range", func(b *testing.B) { 1599 b.ReportAllocs() 1600 for i := 0; i < b.N; i++ { 1601 m.Range(func(pref.FieldDescriptor, pref.Value) bool { 1602 return true 1603 }) 1604 } 1605 }) 1606} 1607