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__ = 'robinson@google.com (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 222 223def SetAllExtensions(message): 224 """Sets every extension in the message to a unique value. 225 226 Args: 227 message: A unittest_pb2.TestAllExtensions instance. 228 """ 229 230 extensions = message.Extensions 231 pb2 = unittest_pb2 232 import_pb2 = unittest_import_pb2 233 234 # 235 # Optional fields. 236 # 237 238 extensions[pb2.optional_int32_extension] = 101 239 extensions[pb2.optional_int64_extension] = 102 240 extensions[pb2.optional_uint32_extension] = 103 241 extensions[pb2.optional_uint64_extension] = 104 242 extensions[pb2.optional_sint32_extension] = 105 243 extensions[pb2.optional_sint64_extension] = 106 244 extensions[pb2.optional_fixed32_extension] = 107 245 extensions[pb2.optional_fixed64_extension] = 108 246 extensions[pb2.optional_sfixed32_extension] = 109 247 extensions[pb2.optional_sfixed64_extension] = 110 248 extensions[pb2.optional_float_extension] = 111 249 extensions[pb2.optional_double_extension] = 112 250 extensions[pb2.optional_bool_extension] = True 251 extensions[pb2.optional_string_extension] = u'115' 252 extensions[pb2.optional_bytes_extension] = b'116' 253 254 extensions[pb2.optionalgroup_extension].a = 117 255 extensions[pb2.optional_nested_message_extension].bb = 118 256 extensions[pb2.optional_foreign_message_extension].c = 119 257 extensions[pb2.optional_import_message_extension].d = 120 258 extensions[pb2.optional_public_import_message_extension].e = 126 259 extensions[pb2.optional_lazy_message_extension].bb = 127 260 261 extensions[pb2.optional_nested_enum_extension] = pb2.TestAllTypes.BAZ 262 extensions[pb2.optional_nested_enum_extension] = pb2.TestAllTypes.BAZ 263 extensions[pb2.optional_foreign_enum_extension] = pb2.FOREIGN_BAZ 264 extensions[pb2.optional_import_enum_extension] = import_pb2.IMPORT_BAZ 265 266 extensions[pb2.optional_string_piece_extension] = u'124' 267 extensions[pb2.optional_cord_extension] = u'125' 268 269 # 270 # Repeated fields. 271 # 272 273 extensions[pb2.repeated_int32_extension].append(201) 274 extensions[pb2.repeated_int64_extension].append(202) 275 extensions[pb2.repeated_uint32_extension].append(203) 276 extensions[pb2.repeated_uint64_extension].append(204) 277 extensions[pb2.repeated_sint32_extension].append(205) 278 extensions[pb2.repeated_sint64_extension].append(206) 279 extensions[pb2.repeated_fixed32_extension].append(207) 280 extensions[pb2.repeated_fixed64_extension].append(208) 281 extensions[pb2.repeated_sfixed32_extension].append(209) 282 extensions[pb2.repeated_sfixed64_extension].append(210) 283 extensions[pb2.repeated_float_extension].append(211) 284 extensions[pb2.repeated_double_extension].append(212) 285 extensions[pb2.repeated_bool_extension].append(True) 286 extensions[pb2.repeated_string_extension].append(u'215') 287 extensions[pb2.repeated_bytes_extension].append(b'216') 288 289 extensions[pb2.repeatedgroup_extension].add().a = 217 290 extensions[pb2.repeated_nested_message_extension].add().bb = 218 291 extensions[pb2.repeated_foreign_message_extension].add().c = 219 292 extensions[pb2.repeated_import_message_extension].add().d = 220 293 extensions[pb2.repeated_lazy_message_extension].add().bb = 227 294 295 extensions[pb2.repeated_nested_enum_extension].append(pb2.TestAllTypes.BAR) 296 extensions[pb2.repeated_foreign_enum_extension].append(pb2.FOREIGN_BAR) 297 extensions[pb2.repeated_import_enum_extension].append(import_pb2.IMPORT_BAR) 298 299 extensions[pb2.repeated_string_piece_extension].append(u'224') 300 extensions[pb2.repeated_cord_extension].append(u'225') 301 302 # Append a second one of each field. 303 extensions[pb2.repeated_int32_extension].append(301) 304 extensions[pb2.repeated_int64_extension].append(302) 305 extensions[pb2.repeated_uint32_extension].append(303) 306 extensions[pb2.repeated_uint64_extension].append(304) 307 extensions[pb2.repeated_sint32_extension].append(305) 308 extensions[pb2.repeated_sint64_extension].append(306) 309 extensions[pb2.repeated_fixed32_extension].append(307) 310 extensions[pb2.repeated_fixed64_extension].append(308) 311 extensions[pb2.repeated_sfixed32_extension].append(309) 312 extensions[pb2.repeated_sfixed64_extension].append(310) 313 extensions[pb2.repeated_float_extension].append(311) 314 extensions[pb2.repeated_double_extension].append(312) 315 extensions[pb2.repeated_bool_extension].append(False) 316 extensions[pb2.repeated_string_extension].append(u'315') 317 extensions[pb2.repeated_bytes_extension].append(b'316') 318 319 extensions[pb2.repeatedgroup_extension].add().a = 317 320 extensions[pb2.repeated_nested_message_extension].add().bb = 318 321 extensions[pb2.repeated_foreign_message_extension].add().c = 319 322 extensions[pb2.repeated_import_message_extension].add().d = 320 323 extensions[pb2.repeated_lazy_message_extension].add().bb = 327 324 325 extensions[pb2.repeated_nested_enum_extension].append(pb2.TestAllTypes.BAZ) 326 extensions[pb2.repeated_foreign_enum_extension].append(pb2.FOREIGN_BAZ) 327 extensions[pb2.repeated_import_enum_extension].append(import_pb2.IMPORT_BAZ) 328 329 extensions[pb2.repeated_string_piece_extension].append(u'324') 330 extensions[pb2.repeated_cord_extension].append(u'325') 331 332 # 333 # Fields with defaults. 334 # 335 336 extensions[pb2.default_int32_extension] = 401 337 extensions[pb2.default_int64_extension] = 402 338 extensions[pb2.default_uint32_extension] = 403 339 extensions[pb2.default_uint64_extension] = 404 340 extensions[pb2.default_sint32_extension] = 405 341 extensions[pb2.default_sint64_extension] = 406 342 extensions[pb2.default_fixed32_extension] = 407 343 extensions[pb2.default_fixed64_extension] = 408 344 extensions[pb2.default_sfixed32_extension] = 409 345 extensions[pb2.default_sfixed64_extension] = 410 346 extensions[pb2.default_float_extension] = 411 347 extensions[pb2.default_double_extension] = 412 348 extensions[pb2.default_bool_extension] = False 349 extensions[pb2.default_string_extension] = u'415' 350 extensions[pb2.default_bytes_extension] = b'416' 351 352 extensions[pb2.default_nested_enum_extension] = pb2.TestAllTypes.FOO 353 extensions[pb2.default_foreign_enum_extension] = pb2.FOREIGN_FOO 354 extensions[pb2.default_import_enum_extension] = import_pb2.IMPORT_FOO 355 356 extensions[pb2.default_string_piece_extension] = u'424' 357 extensions[pb2.default_cord_extension] = '425' 358 359 extensions[pb2.oneof_uint32_extension] = 601 360 extensions[pb2.oneof_nested_message_extension].bb = 602 361 extensions[pb2.oneof_string_extension] = u'603' 362 extensions[pb2.oneof_bytes_extension] = b'604' 363 364 365def SetAllFieldsAndExtensions(message): 366 """Sets every field and extension in the message to a unique value. 367 368 Args: 369 message: A unittest_pb2.TestAllExtensions message. 370 """ 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' 376 377 378def ExpectAllFieldsAndExtensionsInOrder(serialized): 379 """Ensures that serialized is the serialization we expect for a message 380 filled with SetAllFieldsAndExtensions(). (Specifically, ensures that the 381 serialization is in canonical, tag-number order). 382 """ 383 my_extension_int = unittest_pb2.my_extension_int 384 my_extension_string = unittest_pb2.my_extension_string 385 expected_strings = [] 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() 402 expected = b''.join(expected_strings) 403 404 if expected != serialized: 405 raise ValueError('Expected %r, found %r' % (expected, serialized)) 406 407 408def ExpectAllFieldsSet(test_case, message): 409 """Check all fields for correct values have after Set*Fields() is called.""" 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')) 425 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')) 431 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')) 436 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')) 441 442 test_case.assertTrue(message.HasField('optional_string_piece')) 443 test_case.assertTrue(message.HasField('optional_cord')) 444 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) 460 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) 468 469 test_case.assertEqual(unittest_pb2.TestAllTypes.BAZ, 470 message.optional_nested_enum) 471 test_case.assertEqual(unittest_pb2.FOREIGN_BAZ, 472 message.optional_foreign_enum) 473 if IsProto2(message): 474 test_case.assertEqual(unittest_import_pb2.IMPORT_BAZ, 475 message.optional_import_enum) 476 477 # ----------------------------------------------------------------- 478 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)) 494 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)) 504 505 test_case.assertEqual(2, len(message.repeated_string_piece)) 506 test_case.assertEqual(2, len(message.repeated_cord)) 507 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]) 523 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) 530 531 test_case.assertEqual(unittest_pb2.TestAllTypes.BAR, 532 message.repeated_nested_enum[0]) 533 test_case.assertEqual(unittest_pb2.FOREIGN_BAR, 534 message.repeated_foreign_enum[0]) 535 if IsProto2(message): 536 test_case.assertEqual(unittest_import_pb2.IMPORT_BAR, 537 message.repeated_import_enum[0]) 538 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]) 554 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) 561 562 test_case.assertEqual(unittest_pb2.TestAllTypes.BAZ, 563 message.repeated_nested_enum[1]) 564 test_case.assertEqual(unittest_pb2.FOREIGN_BAZ, 565 message.repeated_foreign_enum[1]) 566 if IsProto2(message): 567 test_case.assertEqual(unittest_import_pb2.IMPORT_BAZ, 568 message.repeated_import_enum[1]) 569 570 # ----------------------------------------------------------------- 571 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')) 588 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')) 592 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) 608 609 test_case.assertEqual(unittest_pb2.TestAllTypes.FOO, 610 message.default_nested_enum) 611 test_case.assertEqual(unittest_pb2.FOREIGN_FOO, 612 message.default_foreign_enum) 613 test_case.assertEqual(unittest_import_pb2.IMPORT_FOO, 614 message.default_import_enum) 615 616 617def GoldenFile(filename): 618 """Finds the given golden file and returns a file object representing it.""" 619 620 # Search up the directory tree looking for the C++ protobuf source code. 621 path = '.' 622 while os.path.exists(path): 623 if os.path.exists(os.path.join(path, 'src/google/protobuf')): 624 # Found it. Load the golden file from the testdata directory. 625 full_path = os.path.join(path, 'src/google/protobuf/testdata', filename) 626 return open(full_path, 'rb') 627 path = os.path.join(path, '..') 628 629 # Search internally. 630 path = '.' 631 full_path = os.path.join(path, 'third_party/py/google/protobuf/testdata', 632 filename) 633 if os.path.exists(full_path): 634 # Found it. Load the golden file from the testdata directory. 635 return open(full_path, 'rb') 636 637 raise RuntimeError( 638 'Could not find golden files. This test must be run from within the ' 639 'protobuf source package so that it can read test data files from the ' 640 'C++ source tree.') 641 642 643def GoldenFileData(filename): 644 """Finds the given golden file and returns its contents.""" 645 with GoldenFile(filename) as f: 646 return f.read() 647 648 649def SetAllPackedFields(message): 650 """Sets every field in the message to a unique value. 651 652 Args: 653 message: A TestPackedTypes instance. 654 """ 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, 669 unittest_pb2.FOREIGN_BAZ]) 670 671 672def SetAllPackedExtensions(message): 673 """Sets every extension in the message to a unique value. 674 675 Args: 676 message: A unittest_pb2.TestPackedExtensions instance. 677 """ 678 extensions = message.Extensions 679 pb2 = unittest_pb2 680 681 extensions[pb2.packed_int32_extension].extend([601, 701]) 682 extensions[pb2.packed_int64_extension].extend([602, 702]) 683 extensions[pb2.packed_uint32_extension].extend([603, 703]) 684 extensions[pb2.packed_uint64_extension].extend([604, 704]) 685 extensions[pb2.packed_sint32_extension].extend([605, 705]) 686 extensions[pb2.packed_sint64_extension].extend([606, 706]) 687 extensions[pb2.packed_fixed32_extension].extend([607, 707]) 688 extensions[pb2.packed_fixed64_extension].extend([608, 708]) 689 extensions[pb2.packed_sfixed32_extension].extend([609, 709]) 690 extensions[pb2.packed_sfixed64_extension].extend([610, 710]) 691 extensions[pb2.packed_float_extension].extend([611.0, 711.0]) 692 extensions[pb2.packed_double_extension].extend([612.0, 712.0]) 693 extensions[pb2.packed_bool_extension].extend([True, False]) 694 extensions[pb2.packed_enum_extension].extend([unittest_pb2.FOREIGN_BAR, 695 unittest_pb2.FOREIGN_BAZ]) 696 697 698def SetAllUnpackedFields(message): 699 """Sets every field in the message to a unique value. 700 701 Args: 702 message: A unittest_pb2.TestUnpackedTypes instance. 703 """ 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, 718 unittest_pb2.FOREIGN_BAZ]) 719 720 721class NonStandardInteger(numbers.Integral): 722 """An integer object that does not subclass int. 723 724 This is used to verify that both C++ and regular proto systems can handle 725 integer others than int and long and that they handle them in predictable 726 ways. 727 728 NonStandardInteger is the minimal legal specification for a custom Integral. 729 As such, it does not support 0 < x < 5 and it is not hashable. 730 731 Note: This is added here instead of relying on numpy or a similar library 732 with custom integers to limit dependencies. 733 """ 734 735 def __init__(self, val, error_string_on_conversion=None): 736 assert isinstance(val, numbers.Integral) 737 if isinstance(val, NonStandardInteger): 738 val = val.val 739 self.val = val 740 self.error_string_on_conversion = error_string_on_conversion 741 742 def __long__(self): 743 if self.error_string_on_conversion: 744 raise RuntimeError(self.error_string_on_conversion) 745 return long(self.val) 746 747 def __abs__(self): 748 return NonStandardInteger(operator.abs(self.val)) 749 750 def __add__(self, y): 751 return NonStandardInteger(operator.add(self.val, y)) 752 753 def __div__(self, y): 754 return NonStandardInteger(operator.div(self.val, y)) 755 756 def __eq__(self, y): 757 return operator.eq(self.val, y) 758 759 def __floordiv__(self, y): 760 return NonStandardInteger(operator.floordiv(self.val, y)) 761 762 def __truediv__(self, y): 763 return NonStandardInteger(operator.truediv(self.val, y)) 764 765 def __invert__(self): 766 return NonStandardInteger(operator.invert(self.val)) 767 768 def __mod__(self, y): 769 return NonStandardInteger(operator.mod(self.val, y)) 770 771 def __mul__(self, y): 772 return NonStandardInteger(operator.mul(self.val, y)) 773 774 def __neg__(self): 775 return NonStandardInteger(operator.neg(self.val)) 776 777 def __pos__(self): 778 return NonStandardInteger(operator.pos(self.val)) 779 780 def __pow__(self, y): 781 return NonStandardInteger(operator.pow(self.val, y)) 782 783 def __trunc__(self): 784 return int(self.val) 785 786 def __radd__(self, y): 787 return NonStandardInteger(operator.add(y, self.val)) 788 789 def __rdiv__(self, y): 790 return NonStandardInteger(operator.div(y, self.val)) 791 792 def __rmod__(self, y): 793 return NonStandardInteger(operator.mod(y, self.val)) 794 795 def __rmul__(self, y): 796 return NonStandardInteger(operator.mul(y, self.val)) 797 798 def __rpow__(self, y): 799 return NonStandardInteger(operator.pow(y, self.val)) 800 801 def __rfloordiv__(self, y): 802 return NonStandardInteger(operator.floordiv(y, self.val)) 803 804 def __rtruediv__(self, y): 805 return NonStandardInteger(operator.truediv(y, self.val)) 806 807 def __lshift__(self, y): 808 return NonStandardInteger(operator.lshift(self.val, y)) 809 810 def __rshift__(self, y): 811 return NonStandardInteger(operator.rshift(self.val, y)) 812 813 def __rlshift__(self, y): 814 return NonStandardInteger(operator.lshift(y, self.val)) 815 816 def __rrshift__(self, y): 817 return NonStandardInteger(operator.rshift(y, self.val)) 818 819 def __le__(self, y): 820 if isinstance(y, NonStandardInteger): 821 y = y.val 822 return operator.le(self.val, y) 823 824 def __lt__(self, y): 825 if isinstance(y, NonStandardInteger): 826 y = y.val 827 return operator.lt(self.val, y) 828 829 def __and__(self, y): 830 return NonStandardInteger(operator.and_(self.val, y)) 831 832 def __or__(self, y): 833 return NonStandardInteger(operator.or_(self.val, y)) 834 835 def __xor__(self, y): 836 return NonStandardInteger(operator.xor(self.val, y)) 837 838 def __rand__(self, y): 839 return NonStandardInteger(operator.and_(y, self.val)) 840 841 def __ror__(self, y): 842 return NonStandardInteger(operator.or_(y, self.val)) 843 844 def __rxor__(self, y): 845 return NonStandardInteger(operator.xor(y, self.val)) 846 847 def __bool__(self): 848 return self.val 849 850 def __nonzero__(self): 851 return self.val 852 853 def __ceil__(self): 854 return self 855 856 def __floor__(self): 857 return self 858 859 def __int__(self): 860 if self.error_string_on_conversion: 861 raise RuntimeError(self.error_string_on_conversion) 862 return int(self.val) 863 864 def __round__(self): 865 return self 866 867 def __repr__(self): 868 return 'NonStandardInteger(%s)' % self.val 869