Lines Matching full:message
52 # Tests whether the given TestAllTypes message is proto2 or not.
54 # for the proto2 version of the message.
55 def IsProto2(message): argument
56 return message.DESCRIPTOR.syntax == "proto2"
59 def SetAllNonLazyFields(message): argument
60 """Sets every non-lazy field in the message to a unique value.
63 message: A TestAllTypes instance.
70 message.optional_int32 = 101
71 message.optional_int64 = 102
72 message.optional_uint32 = 103
73 message.optional_uint64 = 104
74 message.optional_sint32 = 105
75 message.optional_sint64 = 106
76 message.optional_fixed32 = 107
77 message.optional_fixed64 = 108
78 message.optional_sfixed32 = 109
79 message.optional_sfixed64 = 110
80 message.optional_float = 111
81 message.optional_double = 112
82 message.optional_bool = True
83 message.optional_string = u'115'
84 message.optional_bytes = b'116'
86 if IsProto2(message):
87 message.optionalgroup.a = 117
88 message.optional_nested_message.bb = 118
89 message.optional_foreign_message.c = 119
90 message.optional_import_message.d = 120
91 message.optional_public_import_message.e = 126
93 message.optional_nested_enum = unittest_pb2.TestAllTypes.BAZ
94 message.optional_foreign_enum = unittest_pb2.FOREIGN_BAZ
95 if IsProto2(message):
96 message.optional_import_enum = unittest_import_pb2.IMPORT_BAZ
98 message.optional_string_piece = u'124'
99 message.optional_cord = u'125'
105 message.repeated_int32.append(201)
106 message.repeated_int64.append(202)
107 message.repeated_uint32.append(203)
108 message.repeated_uint64.append(204)
109 message.repeated_sint32.append(205)
110 message.repeated_sint64.append(206)
111 message.repeated_fixed32.append(207)
112 message.repeated_fixed64.append(208)
113 message.repeated_sfixed32.append(209)
114 message.repeated_sfixed64.append(210)
115 message.repeated_float.append(211)
116 message.repeated_double.append(212)
117 message.repeated_bool.append(True)
118 message.repeated_string.append(u'215')
119 message.repeated_bytes.append(b'216')
121 if IsProto2(message):
122 message.repeatedgroup.add().a = 217
123 message.repeated_nested_message.add().bb = 218
124 message.repeated_foreign_message.add().c = 219
125 message.repeated_import_message.add().d = 220
126 message.repeated_lazy_message.add().bb = 227
128 message.repeated_nested_enum.append(unittest_pb2.TestAllTypes.BAR)
129 message.repeated_foreign_enum.append(unittest_pb2.FOREIGN_BAR)
130 if IsProto2(message):
131 message.repeated_import_enum.append(unittest_import_pb2.IMPORT_BAR)
133 message.repeated_string_piece.append(u'224')
134 message.repeated_cord.append(u'225')
137 message.repeated_int32.append(0)
138 message.repeated_int64.append(0)
139 message.repeated_uint32.append(0)
140 message.repeated_uint64.append(0)
141 message.repeated_sint32.append(0)
142 message.repeated_sint64.append(0)
143 message.repeated_fixed32.append(0)
144 message.repeated_fixed64.append(0)
145 message.repeated_sfixed32.append(0)
146 message.repeated_sfixed64.append(0)
147 message.repeated_float.append(0)
148 message.repeated_double.append(0)
149 message.repeated_bool.append(True)
150 message.repeated_string.append(u'0')
151 message.repeated_bytes.append(b'0')
152 message.repeated_int32[1] = 301
153 message.repeated_int64[1] = 302
154 message.repeated_uint32[1] = 303
155 message.repeated_uint64[1] = 304
156 message.repeated_sint32[1] = 305
157 message.repeated_sint64[1] = 306
158 message.repeated_fixed32[1] = 307
159 message.repeated_fixed64[1] = 308
160 message.repeated_sfixed32[1] = 309
161 message.repeated_sfixed64[1] = 310
162 message.repeated_float[1] = 311
163 message.repeated_double[1] = 312
164 message.repeated_bool[1] = False
165 message.repeated_string[1] = u'315'
166 message.repeated_bytes[1] = b'316'
168 if IsProto2(message):
169 message.repeatedgroup.add().a = 317
170 message.repeated_nested_message.add().bb = 318
171 message.repeated_foreign_message.add().c = 319
172 message.repeated_import_message.add().d = 320
173 message.repeated_lazy_message.add().bb = 327
175 message.repeated_nested_enum.append(unittest_pb2.TestAllTypes.BAR)
176 message.repeated_nested_enum[1] = unittest_pb2.TestAllTypes.BAZ
177 message.repeated_foreign_enum.append(unittest_pb2.FOREIGN_BAZ)
178 if IsProto2(message):
179 message.repeated_import_enum.append(unittest_import_pb2.IMPORT_BAZ)
181 message.repeated_string_piece.append(u'324')
182 message.repeated_cord.append(u'325')
188 if IsProto2(message):
189 message.default_int32 = 401
190 message.default_int64 = 402
191 message.default_uint32 = 403
192 message.default_uint64 = 404
193 message.default_sint32 = 405
194 message.default_sint64 = 406
195 message.default_fixed32 = 407
196 message.default_fixed64 = 408
197 message.default_sfixed32 = 409
198 message.default_sfixed64 = 410
199 message.default_float = 411
200 message.default_double = 412
201 message.default_bool = False
202 message.default_string = '415'
203 message.default_bytes = b'416'
205 message.default_nested_enum = unittest_pb2.TestAllTypes.FOO
206 message.default_foreign_enum = unittest_pb2.FOREIGN_FOO
207 message.default_import_enum = unittest_import_pb2.IMPORT_FOO
209 message.default_string_piece = '424'
210 message.default_cord = '425'
212 message.oneof_uint32 = 601
213 message.oneof_nested_message.bb = 602
214 message.oneof_string = '603'
215 message.oneof_bytes = b'604'
218 def SetAllFields(message): argument
219 SetAllNonLazyFields(message)
220 message.optional_lazy_message.bb = 127
223 def SetAllExtensions(message): argument
224 """Sets every extension in the message to a unique value.
227 message: A unittest_pb2.TestAllExtensions instance.
230 extensions = message.Extensions
365 def SetAllFieldsAndExtensions(message): argument
366 """Sets every field and extension in the message to a unique value.
369 message: A unittest_pb2.TestAllExtensions message.
371 message.my_int = 1
372 message.my_string = 'foo'
373 message.my_float = 1.0
374 message.Extensions[unittest_pb2.my_extension_int] = 23
375 message.Extensions[unittest_pb2.my_extension_string] = 'bar'
379 """Ensures that serialized is the serialization we expect for a message
386 message = unittest_pb2.TestFieldOrderings()
387 message.my_int = 1 # Field 1.
388 expected_strings.append(message.SerializeToString())
389 message.Clear()
390 message.Extensions[my_extension_int] = 23 # Field 5.
391 expected_strings.append(message.SerializeToString())
392 message.Clear()
393 message.my_string = 'foo' # Field 11.
394 expected_strings.append(message.SerializeToString())
395 message.Clear()
396 message.Extensions[my_extension_string] = 'bar' # Field 50.
397 expected_strings.append(message.SerializeToString())
398 message.Clear()
399 message.my_float = 1.0
400 expected_strings.append(message.SerializeToString())
401 message.Clear()
408 def ExpectAllFieldsSet(test_case, message): argument
410 test_case.assertTrue(message.HasField('optional_int32'))
411 test_case.assertTrue(message.HasField('optional_int64'))
412 test_case.assertTrue(message.HasField('optional_uint32'))
413 test_case.assertTrue(message.HasField('optional_uint64'))
414 test_case.assertTrue(message.HasField('optional_sint32'))
415 test_case.assertTrue(message.HasField('optional_sint64'))
416 test_case.assertTrue(message.HasField('optional_fixed32'))
417 test_case.assertTrue(message.HasField('optional_fixed64'))
418 test_case.assertTrue(message.HasField('optional_sfixed32'))
419 test_case.assertTrue(message.HasField('optional_sfixed64'))
420 test_case.assertTrue(message.HasField('optional_float'))
421 test_case.assertTrue(message.HasField('optional_double'))
422 test_case.assertTrue(message.HasField('optional_bool'))
423 test_case.assertTrue(message.HasField('optional_string'))
424 test_case.assertTrue(message.HasField('optional_bytes'))
426 if IsProto2(message):
427 test_case.assertTrue(message.HasField('optionalgroup'))
428 test_case.assertTrue(message.HasField('optional_nested_message'))
429 test_case.assertTrue(message.HasField('optional_foreign_message'))
430 test_case.assertTrue(message.HasField('optional_import_message'))
432 test_case.assertTrue(message.optionalgroup.HasField('a'))
433 test_case.assertTrue(message.optional_nested_message.HasField('bb'))
434 test_case.assertTrue(message.optional_foreign_message.HasField('c'))
435 test_case.assertTrue(message.optional_import_message.HasField('d'))
437 test_case.assertTrue(message.HasField('optional_nested_enum'))
438 test_case.assertTrue(message.HasField('optional_foreign_enum'))
439 if IsProto2(message):
440 test_case.assertTrue(message.HasField('optional_import_enum'))
442 test_case.assertTrue(message.HasField('optional_string_piece'))
443 test_case.assertTrue(message.HasField('optional_cord'))
445 test_case.assertEqual(101, message.optional_int32)
446 test_case.assertEqual(102, message.optional_int64)
447 test_case.assertEqual(103, message.optional_uint32)
448 test_case.assertEqual(104, message.optional_uint64)
449 test_case.assertEqual(105, message.optional_sint32)
450 test_case.assertEqual(106, message.optional_sint64)
451 test_case.assertEqual(107, message.optional_fixed32)
452 test_case.assertEqual(108, message.optional_fixed64)
453 test_case.assertEqual(109, message.optional_sfixed32)
454 test_case.assertEqual(110, message.optional_sfixed64)
455 test_case.assertEqual(111, message.optional_float)
456 test_case.assertEqual(112, message.optional_double)
457 test_case.assertEqual(True, message.optional_bool)
458 test_case.assertEqual('115', message.optional_string)
459 test_case.assertEqual(b'116', message.optional_bytes)
461 if IsProto2(message):
462 test_case.assertEqual(117, message.optionalgroup.a)
463 test_case.assertEqual(118, message.optional_nested_message.bb)
464 test_case.assertEqual(119, message.optional_foreign_message.c)
465 test_case.assertEqual(120, message.optional_import_message.d)
466 test_case.assertEqual(126, message.optional_public_import_message.e)
467 test_case.assertEqual(127, message.optional_lazy_message.bb)
470 message.optional_nested_enum)
472 message.optional_foreign_enum)
473 if IsProto2(message):
475 message.optional_import_enum)
479 test_case.assertEqual(2, len(message.repeated_int32))
480 test_case.assertEqual(2, len(message.repeated_int64))
481 test_case.assertEqual(2, len(message.repeated_uint32))
482 test_case.assertEqual(2, len(message.repeated_uint64))
483 test_case.assertEqual(2, len(message.repeated_sint32))
484 test_case.assertEqual(2, len(message.repeated_sint64))
485 test_case.assertEqual(2, len(message.repeated_fixed32))
486 test_case.assertEqual(2, len(message.repeated_fixed64))
487 test_case.assertEqual(2, len(message.repeated_sfixed32))
488 test_case.assertEqual(2, len(message.repeated_sfixed64))
489 test_case.assertEqual(2, len(message.repeated_float))
490 test_case.assertEqual(2, len(message.repeated_double))
491 test_case.assertEqual(2, len(message.repeated_bool))
492 test_case.assertEqual(2, len(message.repeated_string))
493 test_case.assertEqual(2, len(message.repeated_bytes))
495 if IsProto2(message):
496 test_case.assertEqual(2, len(message.repeatedgroup))
497 test_case.assertEqual(2, len(message.repeated_nested_message))
498 test_case.assertEqual(2, len(message.repeated_foreign_message))
499 test_case.assertEqual(2, len(message.repeated_import_message))
500 test_case.assertEqual(2, len(message.repeated_nested_enum))
501 test_case.assertEqual(2, len(message.repeated_foreign_enum))
502 if IsProto2(message):
503 test_case.assertEqual(2, len(message.repeated_import_enum))
505 test_case.assertEqual(2, len(message.repeated_string_piece))
506 test_case.assertEqual(2, len(message.repeated_cord))
508 test_case.assertEqual(201, message.repeated_int32[0])
509 test_case.assertEqual(202, message.repeated_int64[0])
510 test_case.assertEqual(203, message.repeated_uint32[0])
511 test_case.assertEqual(204, message.repeated_uint64[0])
512 test_case.assertEqual(205, message.repeated_sint32[0])
513 test_case.assertEqual(206, message.repeated_sint64[0])
514 test_case.assertEqual(207, message.repeated_fixed32[0])
515 test_case.assertEqual(208, message.repeated_fixed64[0])
516 test_case.assertEqual(209, message.repeated_sfixed32[0])
517 test_case.assertEqual(210, message.repeated_sfixed64[0])
518 test_case.assertEqual(211, message.repeated_float[0])
519 test_case.assertEqual(212, message.repeated_double[0])
520 test_case.assertEqual(True, message.repeated_bool[0])
521 test_case.assertEqual('215', message.repeated_string[0])
522 test_case.assertEqual(b'216', message.repeated_bytes[0])
524 if IsProto2(message):
525 test_case.assertEqual(217, message.repeatedgroup[0].a)
526 test_case.assertEqual(218, message.repeated_nested_message[0].bb)
527 test_case.assertEqual(219, message.repeated_foreign_message[0].c)
528 test_case.assertEqual(220, message.repeated_import_message[0].d)
529 test_case.assertEqual(227, message.repeated_lazy_message[0].bb)
532 message.repeated_nested_enum[0])
534 message.repeated_foreign_enum[0])
535 if IsProto2(message):
537 message.repeated_import_enum[0])
539 test_case.assertEqual(301, message.repeated_int32[1])
540 test_case.assertEqual(302, message.repeated_int64[1])
541 test_case.assertEqual(303, message.repeated_uint32[1])
542 test_case.assertEqual(304, message.repeated_uint64[1])
543 test_case.assertEqual(305, message.repeated_sint32[1])
544 test_case.assertEqual(306, message.repeated_sint64[1])
545 test_case.assertEqual(307, message.repeated_fixed32[1])
546 test_case.assertEqual(308, message.repeated_fixed64[1])
547 test_case.assertEqual(309, message.repeated_sfixed32[1])
548 test_case.assertEqual(310, message.repeated_sfixed64[1])
549 test_case.assertEqual(311, message.repeated_float[1])
550 test_case.assertEqual(312, message.repeated_double[1])
551 test_case.assertEqual(False, message.repeated_bool[1])
552 test_case.assertEqual('315', message.repeated_string[1])
553 test_case.assertEqual(b'316', message.repeated_bytes[1])
555 if IsProto2(message):
556 test_case.assertEqual(317, message.repeatedgroup[1].a)
557 test_case.assertEqual(318, message.repeated_nested_message[1].bb)
558 test_case.assertEqual(319, message.repeated_foreign_message[1].c)
559 test_case.assertEqual(320, message.repeated_import_message[1].d)
560 test_case.assertEqual(327, message.repeated_lazy_message[1].bb)
563 message.repeated_nested_enum[1])
565 message.repeated_foreign_enum[1])
566 if IsProto2(message):
568 message.repeated_import_enum[1])
572 if IsProto2(message):
573 test_case.assertTrue(message.HasField('default_int32'))
574 test_case.assertTrue(message.HasField('default_int64'))
575 test_case.assertTrue(message.HasField('default_uint32'))
576 test_case.assertTrue(message.HasField('default_uint64'))
577 test_case.assertTrue(message.HasField('default_sint32'))
578 test_case.assertTrue(message.HasField('default_sint64'))
579 test_case.assertTrue(message.HasField('default_fixed32'))
580 test_case.assertTrue(message.HasField('default_fixed64'))
581 test_case.assertTrue(message.HasField('default_sfixed32'))
582 test_case.assertTrue(message.HasField('default_sfixed64'))
583 test_case.assertTrue(message.HasField('default_float'))
584 test_case.assertTrue(message.HasField('default_double'))
585 test_case.assertTrue(message.HasField('default_bool'))
586 test_case.assertTrue(message.HasField('default_string'))
587 test_case.assertTrue(message.HasField('default_bytes'))
589 test_case.assertTrue(message.HasField('default_nested_enum'))
590 test_case.assertTrue(message.HasField('default_foreign_enum'))
591 test_case.assertTrue(message.HasField('default_import_enum'))
593 test_case.assertEqual(401, message.default_int32)
594 test_case.assertEqual(402, message.default_int64)
595 test_case.assertEqual(403, message.default_uint32)
596 test_case.assertEqual(404, message.default_uint64)
597 test_case.assertEqual(405, message.default_sint32)
598 test_case.assertEqual(406, message.default_sint64)
599 test_case.assertEqual(407, message.default_fixed32)
600 test_case.assertEqual(408, message.default_fixed64)
601 test_case.assertEqual(409, message.default_sfixed32)
602 test_case.assertEqual(410, message.default_sfixed64)
603 test_case.assertEqual(411, message.default_float)
604 test_case.assertEqual(412, message.default_double)
605 test_case.assertEqual(False, message.default_bool)
606 test_case.assertEqual('415', message.default_string)
607 test_case.assertEqual(b'416', message.default_bytes)
610 message.default_nested_enum)
612 message.default_foreign_enum)
614 message.default_import_enum)
649 def SetAllPackedFields(message): argument
650 """Sets every field in the message to a unique value.
653 message: A TestPackedTypes instance.
655 message.packed_int32.extend([601, 701])
656 message.packed_int64.extend([602, 702])
657 message.packed_uint32.extend([603, 703])
658 message.packed_uint64.extend([604, 704])
659 message.packed_sint32.extend([605, 705])
660 message.packed_sint64.extend([606, 706])
661 message.packed_fixed32.extend([607, 707])
662 message.packed_fixed64.extend([608, 708])
663 message.packed_sfixed32.extend([609, 709])
664 message.packed_sfixed64.extend([610, 710])
665 message.packed_float.extend([611.0, 711.0])
666 message.packed_double.extend([612.0, 712.0])
667 message.packed_bool.extend([True, False])
668 message.packed_enum.extend([unittest_pb2.FOREIGN_BAR,
672 def SetAllPackedExtensions(message): argument
673 """Sets every extension in the message to a unique value.
676 message: A unittest_pb2.TestPackedExtensions instance.
678 extensions = message.Extensions
698 def SetAllUnpackedFields(message): argument
699 """Sets every field in the message to a unique value.
702 message: A unittest_pb2.TestUnpackedTypes instance.
704 message.unpacked_int32.extend([601, 701])
705 message.unpacked_int64.extend([602, 702])
706 message.unpacked_uint32.extend([603, 703])
707 message.unpacked_uint64.extend([604, 704])
708 message.unpacked_sint32.extend([605, 705])
709 message.unpacked_sint64.extend([606, 706])
710 message.unpacked_fixed32.extend([607, 707])
711 message.unpacked_fixed64.extend([608, 708])
712 message.unpacked_sfixed32.extend([609, 709])
713 message.unpacked_sfixed64.extend([610, 710])
714 message.unpacked_float.extend([611.0, 711.0])
715 message.unpacked_double.extend([612.0, 712.0])
716 message.unpacked_bool.extend([True, False])
717 message.unpacked_enum.extend([unittest_pb2.FOREIGN_BAR,