1# Protocol Buffers - Google's data interchange format 2# Copyright 2008 Google Inc. All rights reserved. 3# 4# Use of this source code is governed by a BSD-style 5# license that can be found in the LICENSE file or at 6# https://developers.google.com/open-source/licenses/bsd 7 8"""Utilities for Python proto2 tests. 9 10This is intentionally modeled on C++ code in 11//google/protobuf/test_util.*. 12""" 13 14__author__ = 'robinson@google.com (Will Robinson)' 15 16import importlib.resources 17import numbers 18import operator 19import os.path 20 21from google.protobuf import testdata 22from google.protobuf import unittest_import_pb2 23from google.protobuf import unittest_pb2 24 25try: 26 long # Python 2 27except NameError: 28 long = int # Python 3 29 30 31# Tests whether the given TestAllTypes message is 32# protobuf_unittest.TestAllTypes or not. 33# This is used to gate several fields/features that only exist 34# for the protobuf_unittest version of the message. 35def IsProto2(message): 36 return message.DESCRIPTOR.full_name == 'protobuf_unittest.TestAllTypes' 37 38 39def SetAllNonLazyFields(message): 40 """Sets every non-lazy field in the message to a unique value. 41 42 Args: 43 message: A TestAllTypes instance. 44 """ 45 46 # 47 # Optional fields. 48 # 49 50 message.optional_int32 = 101 51 message.optional_int64 = 102 52 message.optional_uint32 = 103 53 message.optional_uint64 = 104 54 message.optional_sint32 = 105 55 message.optional_sint64 = 106 56 message.optional_fixed32 = 107 57 message.optional_fixed64 = 108 58 message.optional_sfixed32 = 109 59 message.optional_sfixed64 = 110 60 message.optional_float = 111 61 message.optional_double = 112 62 message.optional_bool = True 63 message.optional_string = u'115' 64 message.optional_bytes = b'116' 65 66 if IsProto2(message): 67 message.optionalgroup.a = 117 68 message.optional_nested_message.bb = 118 69 message.optional_foreign_message.c = 119 70 message.optional_import_message.d = 120 71 message.optional_public_import_message.e = 126 72 73 message.optional_nested_enum = unittest_pb2.TestAllTypes.BAZ 74 message.optional_foreign_enum = unittest_pb2.FOREIGN_BAZ 75 if IsProto2(message): 76 message.optional_import_enum = unittest_import_pb2.IMPORT_BAZ 77 78 message.optional_string_piece = u'124' 79 message.optional_cord = u'125' 80 message.optional_bytes_cord = b'optional bytes cord' 81 82 # 83 # Repeated fields. 84 # 85 86 message.repeated_int32.append(201) 87 message.repeated_int64.append(202) 88 message.repeated_uint32.append(203) 89 message.repeated_uint64.append(204) 90 message.repeated_sint32.append(205) 91 message.repeated_sint64.append(206) 92 message.repeated_fixed32.append(207) 93 message.repeated_fixed64.append(208) 94 message.repeated_sfixed32.append(209) 95 message.repeated_sfixed64.append(210) 96 message.repeated_float.append(211) 97 message.repeated_double.append(212) 98 message.repeated_bool.append(True) 99 message.repeated_string.append(u'215') 100 message.repeated_bytes.append(b'216') 101 102 if IsProto2(message): 103 message.repeatedgroup.add().a = 217 104 message.repeated_nested_message.add().bb = 218 105 message.repeated_foreign_message.add().c = 219 106 message.repeated_import_message.add().d = 220 107 message.repeated_lazy_message.add().bb = 227 108 109 message.repeated_nested_enum.append(unittest_pb2.TestAllTypes.BAR) 110 message.repeated_foreign_enum.append(unittest_pb2.FOREIGN_BAR) 111 if IsProto2(message): 112 message.repeated_import_enum.append(unittest_import_pb2.IMPORT_BAR) 113 114 message.repeated_string_piece.append(u'224') 115 message.repeated_cord.append(u'225') 116 117 # Add a second one of each field and set value by index. 118 message.repeated_int32.append(0) 119 message.repeated_int64.append(0) 120 message.repeated_uint32.append(0) 121 message.repeated_uint64.append(0) 122 message.repeated_sint32.append(0) 123 message.repeated_sint64.append(0) 124 message.repeated_fixed32.append(0) 125 message.repeated_fixed64.append(0) 126 message.repeated_sfixed32.append(0) 127 message.repeated_sfixed64.append(0) 128 message.repeated_float.append(0) 129 message.repeated_double.append(0) 130 message.repeated_bool.append(True) 131 message.repeated_string.append(u'0') 132 message.repeated_bytes.append(b'0') 133 message.repeated_int32[1] = 301 134 message.repeated_int64[1] = 302 135 message.repeated_uint32[1] = 303 136 message.repeated_uint64[1] = 304 137 message.repeated_sint32[1] = 305 138 message.repeated_sint64[1] = 306 139 message.repeated_fixed32[1] = 307 140 message.repeated_fixed64[1] = 308 141 message.repeated_sfixed32[1] = 309 142 message.repeated_sfixed64[1] = 310 143 message.repeated_float[1] = 311 144 message.repeated_double[1] = 312 145 message.repeated_bool[1] = False 146 message.repeated_string[1] = u'315' 147 message.repeated_bytes[1] = b'316' 148 149 if IsProto2(message): 150 message.repeatedgroup.add().a = 317 151 message.repeated_nested_message.add().bb = 318 152 message.repeated_foreign_message.add().c = 319 153 message.repeated_import_message.add().d = 320 154 message.repeated_lazy_message.add().bb = 327 155 156 message.repeated_nested_enum.append(unittest_pb2.TestAllTypes.BAR) 157 message.repeated_nested_enum[1] = unittest_pb2.TestAllTypes.BAZ 158 message.repeated_foreign_enum.append(unittest_pb2.FOREIGN_BAZ) 159 if IsProto2(message): 160 message.repeated_import_enum.append(unittest_import_pb2.IMPORT_BAZ) 161 162 message.repeated_string_piece.append(u'324') 163 message.repeated_cord.append(u'325') 164 165 # 166 # Fields that have defaults. 167 # 168 169 if IsProto2(message): 170 message.default_int32 = 401 171 message.default_int64 = 402 172 message.default_uint32 = 403 173 message.default_uint64 = 404 174 message.default_sint32 = 405 175 message.default_sint64 = 406 176 message.default_fixed32 = 407 177 message.default_fixed64 = 408 178 message.default_sfixed32 = 409 179 message.default_sfixed64 = 410 180 message.default_float = 411 181 message.default_double = 412 182 message.default_bool = False 183 message.default_string = '415' 184 message.default_bytes = b'416' 185 186 message.default_nested_enum = unittest_pb2.TestAllTypes.FOO 187 message.default_foreign_enum = unittest_pb2.FOREIGN_FOO 188 message.default_import_enum = unittest_import_pb2.IMPORT_FOO 189 190 message.default_string_piece = '424' 191 message.default_cord = '425' 192 193 message.oneof_uint32 = 601 194 message.oneof_nested_message.bb = 602 195 message.oneof_string = '603' 196 message.oneof_bytes = b'604' 197 198 199def SetAllFields(message): 200 SetAllNonLazyFields(message) 201 message.optional_lazy_message.bb = 127 202 message.optional_unverified_lazy_message.bb = 128 203 204 205def SetAllExtensions(message): 206 """Sets every extension in the message to a unique value. 207 208 Args: 209 message: A unittest_pb2.TestAllExtensions instance. 210 """ 211 212 extensions = message.Extensions 213 pb2 = unittest_pb2 214 import_pb2 = unittest_import_pb2 215 216 # 217 # Optional fields. 218 # 219 220 extensions[pb2.optional_int32_extension] = 101 221 extensions[pb2.optional_int64_extension] = 102 222 extensions[pb2.optional_uint32_extension] = 103 223 extensions[pb2.optional_uint64_extension] = 104 224 extensions[pb2.optional_sint32_extension] = 105 225 extensions[pb2.optional_sint64_extension] = 106 226 extensions[pb2.optional_fixed32_extension] = 107 227 extensions[pb2.optional_fixed64_extension] = 108 228 extensions[pb2.optional_sfixed32_extension] = 109 229 extensions[pb2.optional_sfixed64_extension] = 110 230 extensions[pb2.optional_float_extension] = 111 231 extensions[pb2.optional_double_extension] = 112 232 extensions[pb2.optional_bool_extension] = True 233 extensions[pb2.optional_string_extension] = u'115' 234 extensions[pb2.optional_bytes_extension] = b'116' 235 236 extensions[pb2.optionalgroup_extension].a = 117 237 extensions[pb2.optional_nested_message_extension].bb = 118 238 extensions[pb2.optional_foreign_message_extension].c = 119 239 extensions[pb2.optional_import_message_extension].d = 120 240 extensions[pb2.optional_public_import_message_extension].e = 126 241 extensions[pb2.optional_lazy_message_extension].bb = 127 242 extensions[pb2.optional_unverified_lazy_message_extension].bb = 128 243 244 extensions[pb2.optional_nested_enum_extension] = pb2.TestAllTypes.BAZ 245 extensions[pb2.optional_nested_enum_extension] = pb2.TestAllTypes.BAZ 246 extensions[pb2.optional_foreign_enum_extension] = pb2.FOREIGN_BAZ 247 extensions[pb2.optional_import_enum_extension] = import_pb2.IMPORT_BAZ 248 249 extensions[pb2.optional_string_piece_extension] = u'124' 250 extensions[pb2.optional_cord_extension] = u'125' 251 extensions[pb2.optional_bytes_cord_extension] = b'optional bytes cord' 252 253 # 254 # Repeated fields. 255 # 256 257 extensions[pb2.repeated_int32_extension].append(201) 258 extensions[pb2.repeated_int64_extension].append(202) 259 extensions[pb2.repeated_uint32_extension].append(203) 260 extensions[pb2.repeated_uint64_extension].append(204) 261 extensions[pb2.repeated_sint32_extension].append(205) 262 extensions[pb2.repeated_sint64_extension].append(206) 263 extensions[pb2.repeated_fixed32_extension].append(207) 264 extensions[pb2.repeated_fixed64_extension].append(208) 265 extensions[pb2.repeated_sfixed32_extension].append(209) 266 extensions[pb2.repeated_sfixed64_extension].append(210) 267 extensions[pb2.repeated_float_extension].append(211) 268 extensions[pb2.repeated_double_extension].append(212) 269 extensions[pb2.repeated_bool_extension].append(True) 270 extensions[pb2.repeated_string_extension].append(u'215') 271 extensions[pb2.repeated_bytes_extension].append(b'216') 272 273 extensions[pb2.repeatedgroup_extension].add().a = 217 274 extensions[pb2.repeated_nested_message_extension].add().bb = 218 275 extensions[pb2.repeated_foreign_message_extension].add().c = 219 276 extensions[pb2.repeated_import_message_extension].add().d = 220 277 extensions[pb2.repeated_lazy_message_extension].add().bb = 227 278 279 extensions[pb2.repeated_nested_enum_extension].append(pb2.TestAllTypes.BAR) 280 extensions[pb2.repeated_foreign_enum_extension].append(pb2.FOREIGN_BAR) 281 extensions[pb2.repeated_import_enum_extension].append(import_pb2.IMPORT_BAR) 282 283 extensions[pb2.repeated_string_piece_extension].append(u'224') 284 extensions[pb2.repeated_cord_extension].append(u'225') 285 286 # Append a second one of each field. 287 extensions[pb2.repeated_int32_extension].append(301) 288 extensions[pb2.repeated_int64_extension].append(302) 289 extensions[pb2.repeated_uint32_extension].append(303) 290 extensions[pb2.repeated_uint64_extension].append(304) 291 extensions[pb2.repeated_sint32_extension].append(305) 292 extensions[pb2.repeated_sint64_extension].append(306) 293 extensions[pb2.repeated_fixed32_extension].append(307) 294 extensions[pb2.repeated_fixed64_extension].append(308) 295 extensions[pb2.repeated_sfixed32_extension].append(309) 296 extensions[pb2.repeated_sfixed64_extension].append(310) 297 extensions[pb2.repeated_float_extension].append(311) 298 extensions[pb2.repeated_double_extension].append(312) 299 extensions[pb2.repeated_bool_extension].append(False) 300 extensions[pb2.repeated_string_extension].append(u'315') 301 extensions[pb2.repeated_bytes_extension].append(b'316') 302 303 extensions[pb2.repeatedgroup_extension].add().a = 317 304 extensions[pb2.repeated_nested_message_extension].add().bb = 318 305 extensions[pb2.repeated_foreign_message_extension].add().c = 319 306 extensions[pb2.repeated_import_message_extension].add().d = 320 307 extensions[pb2.repeated_lazy_message_extension].add().bb = 327 308 309 extensions[pb2.repeated_nested_enum_extension].append(pb2.TestAllTypes.BAZ) 310 extensions[pb2.repeated_foreign_enum_extension].append(pb2.FOREIGN_BAZ) 311 extensions[pb2.repeated_import_enum_extension].append(import_pb2.IMPORT_BAZ) 312 313 extensions[pb2.repeated_string_piece_extension].append(u'324') 314 extensions[pb2.repeated_cord_extension].append(u'325') 315 316 # 317 # Fields with defaults. 318 # 319 320 extensions[pb2.default_int32_extension] = 401 321 extensions[pb2.default_int64_extension] = 402 322 extensions[pb2.default_uint32_extension] = 403 323 extensions[pb2.default_uint64_extension] = 404 324 extensions[pb2.default_sint32_extension] = 405 325 extensions[pb2.default_sint64_extension] = 406 326 extensions[pb2.default_fixed32_extension] = 407 327 extensions[pb2.default_fixed64_extension] = 408 328 extensions[pb2.default_sfixed32_extension] = 409 329 extensions[pb2.default_sfixed64_extension] = 410 330 extensions[pb2.default_float_extension] = 411 331 extensions[pb2.default_double_extension] = 412 332 extensions[pb2.default_bool_extension] = False 333 extensions[pb2.default_string_extension] = u'415' 334 extensions[pb2.default_bytes_extension] = b'416' 335 336 extensions[pb2.default_nested_enum_extension] = pb2.TestAllTypes.FOO 337 extensions[pb2.default_foreign_enum_extension] = pb2.FOREIGN_FOO 338 extensions[pb2.default_import_enum_extension] = import_pb2.IMPORT_FOO 339 340 extensions[pb2.default_string_piece_extension] = u'424' 341 extensions[pb2.default_cord_extension] = '425' 342 343 extensions[pb2.oneof_uint32_extension] = 601 344 extensions[pb2.oneof_nested_message_extension].bb = 602 345 extensions[pb2.oneof_string_extension] = u'603' 346 extensions[pb2.oneof_bytes_extension] = b'604' 347 348 349def SetAllFieldsAndExtensions(message): 350 """Sets every field and extension in the message to a unique value. 351 352 Args: 353 message: A unittest_pb2.TestAllExtensions message. 354 """ 355 message.my_int = 1 356 message.my_string = 'foo' 357 message.my_float = 1.0 358 message.Extensions[unittest_pb2.my_extension_int] = 23 359 message.Extensions[unittest_pb2.my_extension_string] = 'bar' 360 361 362def ExpectAllFieldsAndExtensionsInOrder(serialized): 363 """Ensures that serialized is the serialization we expect for a message 364 filled with SetAllFieldsAndExtensions(). (Specifically, ensures that the 365 serialization is in canonical, tag-number order). 366 """ 367 my_extension_int = unittest_pb2.my_extension_int 368 my_extension_string = unittest_pb2.my_extension_string 369 expected_strings = [] 370 message = unittest_pb2.TestFieldOrderings() 371 message.my_int = 1 # Field 1. 372 expected_strings.append(message.SerializeToString()) 373 message.Clear() 374 message.Extensions[my_extension_int] = 23 # Field 5. 375 expected_strings.append(message.SerializeToString()) 376 message.Clear() 377 message.my_string = 'foo' # Field 11. 378 expected_strings.append(message.SerializeToString()) 379 message.Clear() 380 message.Extensions[my_extension_string] = 'bar' # Field 50. 381 expected_strings.append(message.SerializeToString()) 382 message.Clear() 383 message.my_float = 1.0 384 expected_strings.append(message.SerializeToString()) 385 message.Clear() 386 expected = b''.join(expected_strings) 387 388 if expected != serialized: 389 raise ValueError('Expected %r, found %r' % (expected, serialized)) 390 391 392def ExpectAllFieldsSet(test_case, message): 393 """Check all fields for correct values have after Set*Fields() is called.""" 394 test_case.assertTrue(message.HasField('optional_int32')) 395 test_case.assertTrue(message.HasField('optional_int64')) 396 test_case.assertTrue(message.HasField('optional_uint32')) 397 test_case.assertTrue(message.HasField('optional_uint64')) 398 test_case.assertTrue(message.HasField('optional_sint32')) 399 test_case.assertTrue(message.HasField('optional_sint64')) 400 test_case.assertTrue(message.HasField('optional_fixed32')) 401 test_case.assertTrue(message.HasField('optional_fixed64')) 402 test_case.assertTrue(message.HasField('optional_sfixed32')) 403 test_case.assertTrue(message.HasField('optional_sfixed64')) 404 test_case.assertTrue(message.HasField('optional_float')) 405 test_case.assertTrue(message.HasField('optional_double')) 406 test_case.assertTrue(message.HasField('optional_bool')) 407 test_case.assertTrue(message.HasField('optional_string')) 408 test_case.assertTrue(message.HasField('optional_bytes')) 409 410 if IsProto2(message): 411 test_case.assertTrue(message.HasField('optionalgroup')) 412 test_case.assertTrue(message.HasField('optional_nested_message')) 413 test_case.assertTrue(message.HasField('optional_foreign_message')) 414 test_case.assertTrue(message.HasField('optional_import_message')) 415 416 test_case.assertTrue(message.optionalgroup.HasField('a')) 417 test_case.assertTrue(message.optional_nested_message.HasField('bb')) 418 test_case.assertTrue(message.optional_foreign_message.HasField('c')) 419 test_case.assertTrue(message.optional_import_message.HasField('d')) 420 421 test_case.assertTrue(message.HasField('optional_nested_enum')) 422 test_case.assertTrue(message.HasField('optional_foreign_enum')) 423 if IsProto2(message): 424 test_case.assertTrue(message.HasField('optional_import_enum')) 425 426 test_case.assertTrue(message.HasField('optional_string_piece')) 427 test_case.assertTrue(message.HasField('optional_cord')) 428 test_case.assertTrue(message.HasField('optional_bytes_cord')) 429 430 test_case.assertEqual(101, message.optional_int32) 431 test_case.assertEqual(102, message.optional_int64) 432 test_case.assertEqual(103, message.optional_uint32) 433 test_case.assertEqual(104, message.optional_uint64) 434 test_case.assertEqual(105, message.optional_sint32) 435 test_case.assertEqual(106, message.optional_sint64) 436 test_case.assertEqual(107, message.optional_fixed32) 437 test_case.assertEqual(108, message.optional_fixed64) 438 test_case.assertEqual(109, message.optional_sfixed32) 439 test_case.assertEqual(110, message.optional_sfixed64) 440 test_case.assertEqual(111, message.optional_float) 441 test_case.assertEqual(112, message.optional_double) 442 test_case.assertEqual(True, message.optional_bool) 443 test_case.assertEqual('115', message.optional_string) 444 test_case.assertEqual(b'116', message.optional_bytes) 445 446 if IsProto2(message): 447 test_case.assertEqual(117, message.optionalgroup.a) 448 test_case.assertEqual(118, message.optional_nested_message.bb) 449 test_case.assertEqual(119, message.optional_foreign_message.c) 450 test_case.assertEqual(120, message.optional_import_message.d) 451 test_case.assertEqual(126, message.optional_public_import_message.e) 452 test_case.assertEqual(127, message.optional_lazy_message.bb) 453 test_case.assertEqual(128, message.optional_unverified_lazy_message.bb) 454 455 test_case.assertEqual(unittest_pb2.TestAllTypes.BAZ, 456 message.optional_nested_enum) 457 test_case.assertEqual(unittest_pb2.FOREIGN_BAZ, 458 message.optional_foreign_enum) 459 if IsProto2(message): 460 test_case.assertEqual(unittest_import_pb2.IMPORT_BAZ, 461 message.optional_import_enum) 462 463 # ----------------------------------------------------------------- 464 465 test_case.assertEqual(2, len(message.repeated_int32)) 466 test_case.assertEqual(2, len(message.repeated_int64)) 467 test_case.assertEqual(2, len(message.repeated_uint32)) 468 test_case.assertEqual(2, len(message.repeated_uint64)) 469 test_case.assertEqual(2, len(message.repeated_sint32)) 470 test_case.assertEqual(2, len(message.repeated_sint64)) 471 test_case.assertEqual(2, len(message.repeated_fixed32)) 472 test_case.assertEqual(2, len(message.repeated_fixed64)) 473 test_case.assertEqual(2, len(message.repeated_sfixed32)) 474 test_case.assertEqual(2, len(message.repeated_sfixed64)) 475 test_case.assertEqual(2, len(message.repeated_float)) 476 test_case.assertEqual(2, len(message.repeated_double)) 477 test_case.assertEqual(2, len(message.repeated_bool)) 478 test_case.assertEqual(2, len(message.repeated_string)) 479 test_case.assertEqual(2, len(message.repeated_bytes)) 480 481 if IsProto2(message): 482 test_case.assertEqual(2, len(message.repeatedgroup)) 483 test_case.assertEqual(2, len(message.repeated_nested_message)) 484 test_case.assertEqual(2, len(message.repeated_foreign_message)) 485 test_case.assertEqual(2, len(message.repeated_import_message)) 486 test_case.assertEqual(2, len(message.repeated_nested_enum)) 487 test_case.assertEqual(2, len(message.repeated_foreign_enum)) 488 if IsProto2(message): 489 test_case.assertEqual(2, len(message.repeated_import_enum)) 490 491 test_case.assertEqual(2, len(message.repeated_string_piece)) 492 test_case.assertEqual(2, len(message.repeated_cord)) 493 494 test_case.assertEqual(201, message.repeated_int32[0]) 495 test_case.assertEqual(202, message.repeated_int64[0]) 496 test_case.assertEqual(203, message.repeated_uint32[0]) 497 test_case.assertEqual(204, message.repeated_uint64[0]) 498 test_case.assertEqual(205, message.repeated_sint32[0]) 499 test_case.assertEqual(206, message.repeated_sint64[0]) 500 test_case.assertEqual(207, message.repeated_fixed32[0]) 501 test_case.assertEqual(208, message.repeated_fixed64[0]) 502 test_case.assertEqual(209, message.repeated_sfixed32[0]) 503 test_case.assertEqual(210, message.repeated_sfixed64[0]) 504 test_case.assertEqual(211, message.repeated_float[0]) 505 test_case.assertEqual(212, message.repeated_double[0]) 506 test_case.assertEqual(True, message.repeated_bool[0]) 507 test_case.assertEqual('215', message.repeated_string[0]) 508 test_case.assertEqual(b'216', message.repeated_bytes[0]) 509 510 if IsProto2(message): 511 test_case.assertEqual(217, message.repeatedgroup[0].a) 512 test_case.assertEqual(218, message.repeated_nested_message[0].bb) 513 test_case.assertEqual(219, message.repeated_foreign_message[0].c) 514 test_case.assertEqual(220, message.repeated_import_message[0].d) 515 test_case.assertEqual(227, message.repeated_lazy_message[0].bb) 516 517 test_case.assertEqual(unittest_pb2.TestAllTypes.BAR, 518 message.repeated_nested_enum[0]) 519 test_case.assertEqual(unittest_pb2.FOREIGN_BAR, 520 message.repeated_foreign_enum[0]) 521 if IsProto2(message): 522 test_case.assertEqual(unittest_import_pb2.IMPORT_BAR, 523 message.repeated_import_enum[0]) 524 525 test_case.assertEqual(301, message.repeated_int32[1]) 526 test_case.assertEqual(302, message.repeated_int64[1]) 527 test_case.assertEqual(303, message.repeated_uint32[1]) 528 test_case.assertEqual(304, message.repeated_uint64[1]) 529 test_case.assertEqual(305, message.repeated_sint32[1]) 530 test_case.assertEqual(306, message.repeated_sint64[1]) 531 test_case.assertEqual(307, message.repeated_fixed32[1]) 532 test_case.assertEqual(308, message.repeated_fixed64[1]) 533 test_case.assertEqual(309, message.repeated_sfixed32[1]) 534 test_case.assertEqual(310, message.repeated_sfixed64[1]) 535 test_case.assertEqual(311, message.repeated_float[1]) 536 test_case.assertEqual(312, message.repeated_double[1]) 537 test_case.assertEqual(False, message.repeated_bool[1]) 538 test_case.assertEqual('315', message.repeated_string[1]) 539 test_case.assertEqual(b'316', message.repeated_bytes[1]) 540 541 if IsProto2(message): 542 test_case.assertEqual(317, message.repeatedgroup[1].a) 543 test_case.assertEqual(318, message.repeated_nested_message[1].bb) 544 test_case.assertEqual(319, message.repeated_foreign_message[1].c) 545 test_case.assertEqual(320, message.repeated_import_message[1].d) 546 test_case.assertEqual(327, message.repeated_lazy_message[1].bb) 547 548 test_case.assertEqual(unittest_pb2.TestAllTypes.BAZ, 549 message.repeated_nested_enum[1]) 550 test_case.assertEqual(unittest_pb2.FOREIGN_BAZ, 551 message.repeated_foreign_enum[1]) 552 if IsProto2(message): 553 test_case.assertEqual(unittest_import_pb2.IMPORT_BAZ, 554 message.repeated_import_enum[1]) 555 556 # ----------------------------------------------------------------- 557 558 if IsProto2(message): 559 test_case.assertTrue(message.HasField('default_int32')) 560 test_case.assertTrue(message.HasField('default_int64')) 561 test_case.assertTrue(message.HasField('default_uint32')) 562 test_case.assertTrue(message.HasField('default_uint64')) 563 test_case.assertTrue(message.HasField('default_sint32')) 564 test_case.assertTrue(message.HasField('default_sint64')) 565 test_case.assertTrue(message.HasField('default_fixed32')) 566 test_case.assertTrue(message.HasField('default_fixed64')) 567 test_case.assertTrue(message.HasField('default_sfixed32')) 568 test_case.assertTrue(message.HasField('default_sfixed64')) 569 test_case.assertTrue(message.HasField('default_float')) 570 test_case.assertTrue(message.HasField('default_double')) 571 test_case.assertTrue(message.HasField('default_bool')) 572 test_case.assertTrue(message.HasField('default_string')) 573 test_case.assertTrue(message.HasField('default_bytes')) 574 575 test_case.assertTrue(message.HasField('default_nested_enum')) 576 test_case.assertTrue(message.HasField('default_foreign_enum')) 577 test_case.assertTrue(message.HasField('default_import_enum')) 578 579 test_case.assertEqual(401, message.default_int32) 580 test_case.assertEqual(402, message.default_int64) 581 test_case.assertEqual(403, message.default_uint32) 582 test_case.assertEqual(404, message.default_uint64) 583 test_case.assertEqual(405, message.default_sint32) 584 test_case.assertEqual(406, message.default_sint64) 585 test_case.assertEqual(407, message.default_fixed32) 586 test_case.assertEqual(408, message.default_fixed64) 587 test_case.assertEqual(409, message.default_sfixed32) 588 test_case.assertEqual(410, message.default_sfixed64) 589 test_case.assertEqual(411, message.default_float) 590 test_case.assertEqual(412, message.default_double) 591 test_case.assertEqual(False, message.default_bool) 592 test_case.assertEqual('415', message.default_string) 593 test_case.assertEqual(b'416', message.default_bytes) 594 595 test_case.assertEqual(unittest_pb2.TestAllTypes.FOO, 596 message.default_nested_enum) 597 test_case.assertEqual(unittest_pb2.FOREIGN_FOO, 598 message.default_foreign_enum) 599 test_case.assertEqual(unittest_import_pb2.IMPORT_FOO, 600 message.default_import_enum) 601 602 603def GoldenFile(filename): 604 """Finds the given golden file and returns a file object representing it.""" 605 606 # Search up the directory tree looking for the C++ protobuf source code. 607 path = '.' 608 while os.path.exists(path): 609 if os.path.exists(os.path.join(path, 'src/google/protobuf')): 610 # Found it. Load the golden file from the testdata directory. 611 full_path = os.path.join(path, 'src/google/protobuf/testdata', filename) 612 return open(full_path, 'rb') 613 path = os.path.join(path, '..') 614 615 # Search for cross-repo path. 616 full_path = os.path.join( 617 'external/com_google_protobuf/src/google/protobuf/testdata', filename 618 ) 619 if os.path.exists(full_path): 620 # Found it. Load the golden file from the testdata directory. 621 return open(full_path, 'rb') 622 623 try: 624 full_path = importlib.resources.files(testdata) / filename 625 if os.path.exists(full_path): 626 return open(full_path, 'rb') 627 except AttributeError: 628 # Fallback for Python < 3.9 629 return importlib.resources.open_binary(testdata, filename) 630 631 raise RuntimeError( 632 'Could not find golden files. This test must be run from within the ' 633 'protobuf source package so that it can read test data files from the ' 634 'C++ source tree.') 635 636 637def GoldenFileData(filename): 638 """Finds the given golden file and returns its contents.""" 639 with GoldenFile(filename) as f: 640 return f.read() 641 642 643def SetAllPackedFields(message): 644 """Sets every field in the message to a unique value. 645 646 Args: 647 message: A TestPackedTypes instance. 648 """ 649 message.packed_int32.extend([601, 701]) 650 message.packed_int64.extend([602, 702]) 651 message.packed_uint32.extend([603, 703]) 652 message.packed_uint64.extend([604, 704]) 653 message.packed_sint32.extend([605, 705]) 654 message.packed_sint64.extend([606, 706]) 655 message.packed_fixed32.extend([607, 707]) 656 message.packed_fixed64.extend([608, 708]) 657 message.packed_sfixed32.extend([609, 709]) 658 message.packed_sfixed64.extend([610, 710]) 659 message.packed_float.extend([611.0, 711.0]) 660 message.packed_double.extend([612.0, 712.0]) 661 message.packed_bool.extend([True, False]) 662 message.packed_enum.extend([unittest_pb2.FOREIGN_BAR, 663 unittest_pb2.FOREIGN_BAZ]) 664 665 666def SetAllPackedExtensions(message): 667 """Sets every extension in the message to a unique value. 668 669 Args: 670 message: A unittest_pb2.TestPackedExtensions instance. 671 """ 672 extensions = message.Extensions 673 pb2 = unittest_pb2 674 675 extensions[pb2.packed_int32_extension].extend([601, 701]) 676 extensions[pb2.packed_int64_extension].extend([602, 702]) 677 extensions[pb2.packed_uint32_extension].extend([603, 703]) 678 extensions[pb2.packed_uint64_extension].extend([604, 704]) 679 extensions[pb2.packed_sint32_extension].extend([605, 705]) 680 extensions[pb2.packed_sint64_extension].extend([606, 706]) 681 extensions[pb2.packed_fixed32_extension].extend([607, 707]) 682 extensions[pb2.packed_fixed64_extension].extend([608, 708]) 683 extensions[pb2.packed_sfixed32_extension].extend([609, 709]) 684 extensions[pb2.packed_sfixed64_extension].extend([610, 710]) 685 extensions[pb2.packed_float_extension].extend([611.0, 711.0]) 686 extensions[pb2.packed_double_extension].extend([612.0, 712.0]) 687 extensions[pb2.packed_bool_extension].extend([True, False]) 688 extensions[pb2.packed_enum_extension].extend([unittest_pb2.FOREIGN_BAR, 689 unittest_pb2.FOREIGN_BAZ]) 690 691 692def SetAllUnpackedFields(message): 693 """Sets every field in the message to a unique value. 694 695 Args: 696 message: A unittest_pb2.TestUnpackedTypes instance. 697 """ 698 message.unpacked_int32.extend([601, 701]) 699 message.unpacked_int64.extend([602, 702]) 700 message.unpacked_uint32.extend([603, 703]) 701 message.unpacked_uint64.extend([604, 704]) 702 message.unpacked_sint32.extend([605, 705]) 703 message.unpacked_sint64.extend([606, 706]) 704 message.unpacked_fixed32.extend([607, 707]) 705 message.unpacked_fixed64.extend([608, 708]) 706 message.unpacked_sfixed32.extend([609, 709]) 707 message.unpacked_sfixed64.extend([610, 710]) 708 message.unpacked_float.extend([611.0, 711.0]) 709 message.unpacked_double.extend([612.0, 712.0]) 710 message.unpacked_bool.extend([True, False]) 711 message.unpacked_enum.extend([unittest_pb2.FOREIGN_BAR, 712 unittest_pb2.FOREIGN_BAZ]) 713 714 715class NonStandardInteger(numbers.Integral): 716 """An integer object that does not subclass int. 717 718 This is used to verify that both C++ and regular proto systems can handle 719 integer others than int and long and that they handle them in predictable 720 ways. 721 722 NonStandardInteger is the minimal legal specification for a custom Integral. 723 As such, it does not support 0 < x < 5 and it is not hashable. 724 725 Note: This is added here instead of relying on numpy or a similar library 726 with custom integers to limit dependencies. 727 """ 728 729 def __init__(self, val, error_string_on_conversion=None): 730 assert isinstance(val, numbers.Integral) 731 if isinstance(val, NonStandardInteger): 732 val = val.val 733 self.val = val 734 self.error_string_on_conversion = error_string_on_conversion 735 736 def __long__(self): 737 if self.error_string_on_conversion: 738 raise RuntimeError(self.error_string_on_conversion) 739 return long(self.val) 740 741 def __abs__(self): 742 return NonStandardInteger(operator.abs(self.val)) 743 744 def __add__(self, y): 745 return NonStandardInteger(operator.add(self.val, y)) 746 747 def __div__(self, y): 748 return NonStandardInteger(operator.div(self.val, y)) 749 750 def __eq__(self, y): 751 return operator.eq(self.val, y) 752 753 def __floordiv__(self, y): 754 return NonStandardInteger(operator.floordiv(self.val, y)) 755 756 def __truediv__(self, y): 757 return NonStandardInteger(operator.truediv(self.val, y)) 758 759 def __invert__(self): 760 return NonStandardInteger(operator.invert(self.val)) 761 762 def __mod__(self, y): 763 return NonStandardInteger(operator.mod(self.val, y)) 764 765 def __mul__(self, y): 766 return NonStandardInteger(operator.mul(self.val, y)) 767 768 def __neg__(self): 769 return NonStandardInteger(operator.neg(self.val)) 770 771 def __pos__(self): 772 return NonStandardInteger(operator.pos(self.val)) 773 774 def __pow__(self, y): 775 return NonStandardInteger(operator.pow(self.val, y)) 776 777 def __trunc__(self): 778 return int(self.val) 779 780 def __radd__(self, y): 781 return NonStandardInteger(operator.add(y, self.val)) 782 783 def __rdiv__(self, y): 784 return NonStandardInteger(operator.div(y, self.val)) 785 786 def __rmod__(self, y): 787 return NonStandardInteger(operator.mod(y, self.val)) 788 789 def __rmul__(self, y): 790 return NonStandardInteger(operator.mul(y, self.val)) 791 792 def __rpow__(self, y): 793 return NonStandardInteger(operator.pow(y, self.val)) 794 795 def __rfloordiv__(self, y): 796 return NonStandardInteger(operator.floordiv(y, self.val)) 797 798 def __rtruediv__(self, y): 799 return NonStandardInteger(operator.truediv(y, self.val)) 800 801 def __lshift__(self, y): 802 return NonStandardInteger(operator.lshift(self.val, y)) 803 804 def __rshift__(self, y): 805 return NonStandardInteger(operator.rshift(self.val, y)) 806 807 def __rlshift__(self, y): 808 return NonStandardInteger(operator.lshift(y, self.val)) 809 810 def __rrshift__(self, y): 811 return NonStandardInteger(operator.rshift(y, self.val)) 812 813 def __le__(self, y): 814 if isinstance(y, NonStandardInteger): 815 y = y.val 816 return operator.le(self.val, y) 817 818 def __lt__(self, y): 819 if isinstance(y, NonStandardInteger): 820 y = y.val 821 return operator.lt(self.val, y) 822 823 def __and__(self, y): 824 return NonStandardInteger(operator.and_(self.val, y)) 825 826 def __or__(self, y): 827 return NonStandardInteger(operator.or_(self.val, y)) 828 829 def __xor__(self, y): 830 return NonStandardInteger(operator.xor(self.val, y)) 831 832 def __rand__(self, y): 833 return NonStandardInteger(operator.and_(y, self.val)) 834 835 def __ror__(self, y): 836 return NonStandardInteger(operator.or_(y, self.val)) 837 838 def __rxor__(self, y): 839 return NonStandardInteger(operator.xor(y, self.val)) 840 841 def __bool__(self): 842 return self.val 843 844 def __nonzero__(self): 845 return self.val 846 847 def __ceil__(self): 848 return self 849 850 def __floor__(self): 851 return self 852 853 def __int__(self): 854 if self.error_string_on_conversion: 855 raise RuntimeError(self.error_string_on_conversion) 856 return int(self.val) 857 858 def __round__(self): 859 return self 860 861 def __repr__(self): 862 return 'NonStandardInteger(%s)' % self.val 863