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