1# Protocol Buffers - Google's data interchange format 2# Copyright 2008 Google Inc. All rights reserved. 3# http://code.google.com/p/protobuf/ 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 os.path 40 41from google.protobuf import unittest_import_pb2 42from google.protobuf import unittest_pb2 43 44 45def SetAllNonLazyFields(message): 46 """Sets every non-lazy field in the message to a unique value. 47 48 Args: 49 message: A unittest_pb2.TestAllTypes instance. 50 """ 51 52 # 53 # Optional fields. 54 # 55 56 message.optional_int32 = 101 57 message.optional_int64 = 102 58 message.optional_uint32 = 103 59 message.optional_uint64 = 104 60 message.optional_sint32 = 105 61 message.optional_sint64 = 106 62 message.optional_fixed32 = 107 63 message.optional_fixed64 = 108 64 message.optional_sfixed32 = 109 65 message.optional_sfixed64 = 110 66 message.optional_float = 111 67 message.optional_double = 112 68 message.optional_bool = True 69 # TODO(robinson): Firmly spec out and test how 70 # protos interact with unicode. One specific example: 71 # what happens if we change the literal below to 72 # u'115'? What *should* happen? Still some discussion 73 # to finish with Kenton about bytes vs. strings 74 # and forcing everything to be utf8. :-/ 75 message.optional_string = '115' 76 message.optional_bytes = '116' 77 78 message.optionalgroup.a = 117 79 message.optional_nested_message.bb = 118 80 message.optional_foreign_message.c = 119 81 message.optional_import_message.d = 120 82 message.optional_public_import_message.e = 126 83 84 message.optional_nested_enum = unittest_pb2.TestAllTypes.BAZ 85 message.optional_foreign_enum = unittest_pb2.FOREIGN_BAZ 86 message.optional_import_enum = unittest_import_pb2.IMPORT_BAZ 87 88 message.optional_string_piece = '124' 89 message.optional_cord = '125' 90 91 # 92 # Repeated fields. 93 # 94 95 message.repeated_int32.append(201) 96 message.repeated_int64.append(202) 97 message.repeated_uint32.append(203) 98 message.repeated_uint64.append(204) 99 message.repeated_sint32.append(205) 100 message.repeated_sint64.append(206) 101 message.repeated_fixed32.append(207) 102 message.repeated_fixed64.append(208) 103 message.repeated_sfixed32.append(209) 104 message.repeated_sfixed64.append(210) 105 message.repeated_float.append(211) 106 message.repeated_double.append(212) 107 message.repeated_bool.append(True) 108 message.repeated_string.append('215') 109 message.repeated_bytes.append('216') 110 111 message.repeatedgroup.add().a = 217 112 message.repeated_nested_message.add().bb = 218 113 message.repeated_foreign_message.add().c = 219 114 message.repeated_import_message.add().d = 220 115 message.repeated_lazy_message.add().bb = 227 116 117 message.repeated_nested_enum.append(unittest_pb2.TestAllTypes.BAR) 118 message.repeated_foreign_enum.append(unittest_pb2.FOREIGN_BAR) 119 message.repeated_import_enum.append(unittest_import_pb2.IMPORT_BAR) 120 121 message.repeated_string_piece.append('224') 122 message.repeated_cord.append('225') 123 124 # Add a second one of each field. 125 message.repeated_int32.append(301) 126 message.repeated_int64.append(302) 127 message.repeated_uint32.append(303) 128 message.repeated_uint64.append(304) 129 message.repeated_sint32.append(305) 130 message.repeated_sint64.append(306) 131 message.repeated_fixed32.append(307) 132 message.repeated_fixed64.append(308) 133 message.repeated_sfixed32.append(309) 134 message.repeated_sfixed64.append(310) 135 message.repeated_float.append(311) 136 message.repeated_double.append(312) 137 message.repeated_bool.append(False) 138 message.repeated_string.append('315') 139 message.repeated_bytes.append('316') 140 141 message.repeatedgroup.add().a = 317 142 message.repeated_nested_message.add().bb = 318 143 message.repeated_foreign_message.add().c = 319 144 message.repeated_import_message.add().d = 320 145 message.repeated_lazy_message.add().bb = 327 146 147 message.repeated_nested_enum.append(unittest_pb2.TestAllTypes.BAZ) 148 message.repeated_foreign_enum.append(unittest_pb2.FOREIGN_BAZ) 149 message.repeated_import_enum.append(unittest_import_pb2.IMPORT_BAZ) 150 151 message.repeated_string_piece.append('324') 152 message.repeated_cord.append('325') 153 154 # 155 # Fields that have defaults. 156 # 157 158 message.default_int32 = 401 159 message.default_int64 = 402 160 message.default_uint32 = 403 161 message.default_uint64 = 404 162 message.default_sint32 = 405 163 message.default_sint64 = 406 164 message.default_fixed32 = 407 165 message.default_fixed64 = 408 166 message.default_sfixed32 = 409 167 message.default_sfixed64 = 410 168 message.default_float = 411 169 message.default_double = 412 170 message.default_bool = False 171 message.default_string = '415' 172 message.default_bytes = '416' 173 174 message.default_nested_enum = unittest_pb2.TestAllTypes.FOO 175 message.default_foreign_enum = unittest_pb2.FOREIGN_FOO 176 message.default_import_enum = unittest_import_pb2.IMPORT_FOO 177 178 message.default_string_piece = '424' 179 message.default_cord = '425' 180 181 182def SetAllFields(message): 183 SetAllNonLazyFields(message) 184 message.optional_lazy_message.bb = 127 185 186 187def SetAllExtensions(message): 188 """Sets every extension in the message to a unique value. 189 190 Args: 191 message: A unittest_pb2.TestAllExtensions instance. 192 """ 193 194 extensions = message.Extensions 195 pb2 = unittest_pb2 196 import_pb2 = unittest_import_pb2 197 198 # 199 # Optional fields. 200 # 201 202 extensions[pb2.optional_int32_extension] = 101 203 extensions[pb2.optional_int64_extension] = 102 204 extensions[pb2.optional_uint32_extension] = 103 205 extensions[pb2.optional_uint64_extension] = 104 206 extensions[pb2.optional_sint32_extension] = 105 207 extensions[pb2.optional_sint64_extension] = 106 208 extensions[pb2.optional_fixed32_extension] = 107 209 extensions[pb2.optional_fixed64_extension] = 108 210 extensions[pb2.optional_sfixed32_extension] = 109 211 extensions[pb2.optional_sfixed64_extension] = 110 212 extensions[pb2.optional_float_extension] = 111 213 extensions[pb2.optional_double_extension] = 112 214 extensions[pb2.optional_bool_extension] = True 215 extensions[pb2.optional_string_extension] = '115' 216 extensions[pb2.optional_bytes_extension] = '116' 217 218 extensions[pb2.optionalgroup_extension].a = 117 219 extensions[pb2.optional_nested_message_extension].bb = 118 220 extensions[pb2.optional_foreign_message_extension].c = 119 221 extensions[pb2.optional_import_message_extension].d = 120 222 extensions[pb2.optional_public_import_message_extension].e = 126 223 extensions[pb2.optional_lazy_message_extension].bb = 127 224 225 extensions[pb2.optional_nested_enum_extension] = pb2.TestAllTypes.BAZ 226 extensions[pb2.optional_nested_enum_extension] = pb2.TestAllTypes.BAZ 227 extensions[pb2.optional_foreign_enum_extension] = pb2.FOREIGN_BAZ 228 extensions[pb2.optional_import_enum_extension] = import_pb2.IMPORT_BAZ 229 230 extensions[pb2.optional_string_piece_extension] = '124' 231 extensions[pb2.optional_cord_extension] = '125' 232 233 # 234 # Repeated fields. 235 # 236 237 extensions[pb2.repeated_int32_extension].append(201) 238 extensions[pb2.repeated_int64_extension].append(202) 239 extensions[pb2.repeated_uint32_extension].append(203) 240 extensions[pb2.repeated_uint64_extension].append(204) 241 extensions[pb2.repeated_sint32_extension].append(205) 242 extensions[pb2.repeated_sint64_extension].append(206) 243 extensions[pb2.repeated_fixed32_extension].append(207) 244 extensions[pb2.repeated_fixed64_extension].append(208) 245 extensions[pb2.repeated_sfixed32_extension].append(209) 246 extensions[pb2.repeated_sfixed64_extension].append(210) 247 extensions[pb2.repeated_float_extension].append(211) 248 extensions[pb2.repeated_double_extension].append(212) 249 extensions[pb2.repeated_bool_extension].append(True) 250 extensions[pb2.repeated_string_extension].append('215') 251 extensions[pb2.repeated_bytes_extension].append('216') 252 253 extensions[pb2.repeatedgroup_extension].add().a = 217 254 extensions[pb2.repeated_nested_message_extension].add().bb = 218 255 extensions[pb2.repeated_foreign_message_extension].add().c = 219 256 extensions[pb2.repeated_import_message_extension].add().d = 220 257 extensions[pb2.repeated_lazy_message_extension].add().bb = 227 258 259 extensions[pb2.repeated_nested_enum_extension].append(pb2.TestAllTypes.BAR) 260 extensions[pb2.repeated_foreign_enum_extension].append(pb2.FOREIGN_BAR) 261 extensions[pb2.repeated_import_enum_extension].append(import_pb2.IMPORT_BAR) 262 263 extensions[pb2.repeated_string_piece_extension].append('224') 264 extensions[pb2.repeated_cord_extension].append('225') 265 266 # Append a second one of each field. 267 extensions[pb2.repeated_int32_extension].append(301) 268 extensions[pb2.repeated_int64_extension].append(302) 269 extensions[pb2.repeated_uint32_extension].append(303) 270 extensions[pb2.repeated_uint64_extension].append(304) 271 extensions[pb2.repeated_sint32_extension].append(305) 272 extensions[pb2.repeated_sint64_extension].append(306) 273 extensions[pb2.repeated_fixed32_extension].append(307) 274 extensions[pb2.repeated_fixed64_extension].append(308) 275 extensions[pb2.repeated_sfixed32_extension].append(309) 276 extensions[pb2.repeated_sfixed64_extension].append(310) 277 extensions[pb2.repeated_float_extension].append(311) 278 extensions[pb2.repeated_double_extension].append(312) 279 extensions[pb2.repeated_bool_extension].append(False) 280 extensions[pb2.repeated_string_extension].append('315') 281 extensions[pb2.repeated_bytes_extension].append('316') 282 283 extensions[pb2.repeatedgroup_extension].add().a = 317 284 extensions[pb2.repeated_nested_message_extension].add().bb = 318 285 extensions[pb2.repeated_foreign_message_extension].add().c = 319 286 extensions[pb2.repeated_import_message_extension].add().d = 320 287 extensions[pb2.repeated_lazy_message_extension].add().bb = 327 288 289 extensions[pb2.repeated_nested_enum_extension].append(pb2.TestAllTypes.BAZ) 290 extensions[pb2.repeated_foreign_enum_extension].append(pb2.FOREIGN_BAZ) 291 extensions[pb2.repeated_import_enum_extension].append(import_pb2.IMPORT_BAZ) 292 293 extensions[pb2.repeated_string_piece_extension].append('324') 294 extensions[pb2.repeated_cord_extension].append('325') 295 296 # 297 # Fields with defaults. 298 # 299 300 extensions[pb2.default_int32_extension] = 401 301 extensions[pb2.default_int64_extension] = 402 302 extensions[pb2.default_uint32_extension] = 403 303 extensions[pb2.default_uint64_extension] = 404 304 extensions[pb2.default_sint32_extension] = 405 305 extensions[pb2.default_sint64_extension] = 406 306 extensions[pb2.default_fixed32_extension] = 407 307 extensions[pb2.default_fixed64_extension] = 408 308 extensions[pb2.default_sfixed32_extension] = 409 309 extensions[pb2.default_sfixed64_extension] = 410 310 extensions[pb2.default_float_extension] = 411 311 extensions[pb2.default_double_extension] = 412 312 extensions[pb2.default_bool_extension] = False 313 extensions[pb2.default_string_extension] = '415' 314 extensions[pb2.default_bytes_extension] = '416' 315 316 extensions[pb2.default_nested_enum_extension] = pb2.TestAllTypes.FOO 317 extensions[pb2.default_foreign_enum_extension] = pb2.FOREIGN_FOO 318 extensions[pb2.default_import_enum_extension] = import_pb2.IMPORT_FOO 319 320 extensions[pb2.default_string_piece_extension] = '424' 321 extensions[pb2.default_cord_extension] = '425' 322 323 324def SetAllFieldsAndExtensions(message): 325 """Sets every field and extension in the message to a unique value. 326 327 Args: 328 message: A unittest_pb2.TestAllExtensions message. 329 """ 330 message.my_int = 1 331 message.my_string = 'foo' 332 message.my_float = 1.0 333 message.Extensions[unittest_pb2.my_extension_int] = 23 334 message.Extensions[unittest_pb2.my_extension_string] = 'bar' 335 336 337def ExpectAllFieldsAndExtensionsInOrder(serialized): 338 """Ensures that serialized is the serialization we expect for a message 339 filled with SetAllFieldsAndExtensions(). (Specifically, ensures that the 340 serialization is in canonical, tag-number order). 341 """ 342 my_extension_int = unittest_pb2.my_extension_int 343 my_extension_string = unittest_pb2.my_extension_string 344 expected_strings = [] 345 message = unittest_pb2.TestFieldOrderings() 346 message.my_int = 1 # Field 1. 347 expected_strings.append(message.SerializeToString()) 348 message.Clear() 349 message.Extensions[my_extension_int] = 23 # Field 5. 350 expected_strings.append(message.SerializeToString()) 351 message.Clear() 352 message.my_string = 'foo' # Field 11. 353 expected_strings.append(message.SerializeToString()) 354 message.Clear() 355 message.Extensions[my_extension_string] = 'bar' # Field 50. 356 expected_strings.append(message.SerializeToString()) 357 message.Clear() 358 message.my_float = 1.0 359 expected_strings.append(message.SerializeToString()) 360 message.Clear() 361 expected = ''.join(expected_strings) 362 363 if expected != serialized: 364 raise ValueError('Expected %r, found %r' % (expected, serialized)) 365 366 367def ExpectAllFieldsSet(test_case, message): 368 """Check all fields for correct values have after Set*Fields() is called.""" 369 test_case.assertTrue(message.HasField('optional_int32')) 370 test_case.assertTrue(message.HasField('optional_int64')) 371 test_case.assertTrue(message.HasField('optional_uint32')) 372 test_case.assertTrue(message.HasField('optional_uint64')) 373 test_case.assertTrue(message.HasField('optional_sint32')) 374 test_case.assertTrue(message.HasField('optional_sint64')) 375 test_case.assertTrue(message.HasField('optional_fixed32')) 376 test_case.assertTrue(message.HasField('optional_fixed64')) 377 test_case.assertTrue(message.HasField('optional_sfixed32')) 378 test_case.assertTrue(message.HasField('optional_sfixed64')) 379 test_case.assertTrue(message.HasField('optional_float')) 380 test_case.assertTrue(message.HasField('optional_double')) 381 test_case.assertTrue(message.HasField('optional_bool')) 382 test_case.assertTrue(message.HasField('optional_string')) 383 test_case.assertTrue(message.HasField('optional_bytes')) 384 385 test_case.assertTrue(message.HasField('optionalgroup')) 386 test_case.assertTrue(message.HasField('optional_nested_message')) 387 test_case.assertTrue(message.HasField('optional_foreign_message')) 388 test_case.assertTrue(message.HasField('optional_import_message')) 389 390 test_case.assertTrue(message.optionalgroup.HasField('a')) 391 test_case.assertTrue(message.optional_nested_message.HasField('bb')) 392 test_case.assertTrue(message.optional_foreign_message.HasField('c')) 393 test_case.assertTrue(message.optional_import_message.HasField('d')) 394 395 test_case.assertTrue(message.HasField('optional_nested_enum')) 396 test_case.assertTrue(message.HasField('optional_foreign_enum')) 397 test_case.assertTrue(message.HasField('optional_import_enum')) 398 399 test_case.assertTrue(message.HasField('optional_string_piece')) 400 test_case.assertTrue(message.HasField('optional_cord')) 401 402 test_case.assertEqual(101, message.optional_int32) 403 test_case.assertEqual(102, message.optional_int64) 404 test_case.assertEqual(103, message.optional_uint32) 405 test_case.assertEqual(104, message.optional_uint64) 406 test_case.assertEqual(105, message.optional_sint32) 407 test_case.assertEqual(106, message.optional_sint64) 408 test_case.assertEqual(107, message.optional_fixed32) 409 test_case.assertEqual(108, message.optional_fixed64) 410 test_case.assertEqual(109, message.optional_sfixed32) 411 test_case.assertEqual(110, message.optional_sfixed64) 412 test_case.assertEqual(111, message.optional_float) 413 test_case.assertEqual(112, message.optional_double) 414 test_case.assertEqual(True, message.optional_bool) 415 test_case.assertEqual('115', message.optional_string) 416 test_case.assertEqual('116', message.optional_bytes) 417 418 test_case.assertEqual(117, message.optionalgroup.a) 419 test_case.assertEqual(118, message.optional_nested_message.bb) 420 test_case.assertEqual(119, message.optional_foreign_message.c) 421 test_case.assertEqual(120, message.optional_import_message.d) 422 test_case.assertEqual(126, message.optional_public_import_message.e) 423 test_case.assertEqual(127, message.optional_lazy_message.bb) 424 425 test_case.assertEqual(unittest_pb2.TestAllTypes.BAZ, 426 message.optional_nested_enum) 427 test_case.assertEqual(unittest_pb2.FOREIGN_BAZ, 428 message.optional_foreign_enum) 429 test_case.assertEqual(unittest_import_pb2.IMPORT_BAZ, 430 message.optional_import_enum) 431 432 # ----------------------------------------------------------------- 433 434 test_case.assertEqual(2, len(message.repeated_int32)) 435 test_case.assertEqual(2, len(message.repeated_int64)) 436 test_case.assertEqual(2, len(message.repeated_uint32)) 437 test_case.assertEqual(2, len(message.repeated_uint64)) 438 test_case.assertEqual(2, len(message.repeated_sint32)) 439 test_case.assertEqual(2, len(message.repeated_sint64)) 440 test_case.assertEqual(2, len(message.repeated_fixed32)) 441 test_case.assertEqual(2, len(message.repeated_fixed64)) 442 test_case.assertEqual(2, len(message.repeated_sfixed32)) 443 test_case.assertEqual(2, len(message.repeated_sfixed64)) 444 test_case.assertEqual(2, len(message.repeated_float)) 445 test_case.assertEqual(2, len(message.repeated_double)) 446 test_case.assertEqual(2, len(message.repeated_bool)) 447 test_case.assertEqual(2, len(message.repeated_string)) 448 test_case.assertEqual(2, len(message.repeated_bytes)) 449 450 test_case.assertEqual(2, len(message.repeatedgroup)) 451 test_case.assertEqual(2, len(message.repeated_nested_message)) 452 test_case.assertEqual(2, len(message.repeated_foreign_message)) 453 test_case.assertEqual(2, len(message.repeated_import_message)) 454 test_case.assertEqual(2, len(message.repeated_nested_enum)) 455 test_case.assertEqual(2, len(message.repeated_foreign_enum)) 456 test_case.assertEqual(2, len(message.repeated_import_enum)) 457 458 test_case.assertEqual(2, len(message.repeated_string_piece)) 459 test_case.assertEqual(2, len(message.repeated_cord)) 460 461 test_case.assertEqual(201, message.repeated_int32[0]) 462 test_case.assertEqual(202, message.repeated_int64[0]) 463 test_case.assertEqual(203, message.repeated_uint32[0]) 464 test_case.assertEqual(204, message.repeated_uint64[0]) 465 test_case.assertEqual(205, message.repeated_sint32[0]) 466 test_case.assertEqual(206, message.repeated_sint64[0]) 467 test_case.assertEqual(207, message.repeated_fixed32[0]) 468 test_case.assertEqual(208, message.repeated_fixed64[0]) 469 test_case.assertEqual(209, message.repeated_sfixed32[0]) 470 test_case.assertEqual(210, message.repeated_sfixed64[0]) 471 test_case.assertEqual(211, message.repeated_float[0]) 472 test_case.assertEqual(212, message.repeated_double[0]) 473 test_case.assertEqual(True, message.repeated_bool[0]) 474 test_case.assertEqual('215', message.repeated_string[0]) 475 test_case.assertEqual('216', message.repeated_bytes[0]) 476 477 test_case.assertEqual(217, message.repeatedgroup[0].a) 478 test_case.assertEqual(218, message.repeated_nested_message[0].bb) 479 test_case.assertEqual(219, message.repeated_foreign_message[0].c) 480 test_case.assertEqual(220, message.repeated_import_message[0].d) 481 test_case.assertEqual(227, message.repeated_lazy_message[0].bb) 482 483 test_case.assertEqual(unittest_pb2.TestAllTypes.BAR, 484 message.repeated_nested_enum[0]) 485 test_case.assertEqual(unittest_pb2.FOREIGN_BAR, 486 message.repeated_foreign_enum[0]) 487 test_case.assertEqual(unittest_import_pb2.IMPORT_BAR, 488 message.repeated_import_enum[0]) 489 490 test_case.assertEqual(301, message.repeated_int32[1]) 491 test_case.assertEqual(302, message.repeated_int64[1]) 492 test_case.assertEqual(303, message.repeated_uint32[1]) 493 test_case.assertEqual(304, message.repeated_uint64[1]) 494 test_case.assertEqual(305, message.repeated_sint32[1]) 495 test_case.assertEqual(306, message.repeated_sint64[1]) 496 test_case.assertEqual(307, message.repeated_fixed32[1]) 497 test_case.assertEqual(308, message.repeated_fixed64[1]) 498 test_case.assertEqual(309, message.repeated_sfixed32[1]) 499 test_case.assertEqual(310, message.repeated_sfixed64[1]) 500 test_case.assertEqual(311, message.repeated_float[1]) 501 test_case.assertEqual(312, message.repeated_double[1]) 502 test_case.assertEqual(False, message.repeated_bool[1]) 503 test_case.assertEqual('315', message.repeated_string[1]) 504 test_case.assertEqual('316', message.repeated_bytes[1]) 505 506 test_case.assertEqual(317, message.repeatedgroup[1].a) 507 test_case.assertEqual(318, message.repeated_nested_message[1].bb) 508 test_case.assertEqual(319, message.repeated_foreign_message[1].c) 509 test_case.assertEqual(320, message.repeated_import_message[1].d) 510 test_case.assertEqual(327, message.repeated_lazy_message[1].bb) 511 512 test_case.assertEqual(unittest_pb2.TestAllTypes.BAZ, 513 message.repeated_nested_enum[1]) 514 test_case.assertEqual(unittest_pb2.FOREIGN_BAZ, 515 message.repeated_foreign_enum[1]) 516 test_case.assertEqual(unittest_import_pb2.IMPORT_BAZ, 517 message.repeated_import_enum[1]) 518 519 # ----------------------------------------------------------------- 520 521 test_case.assertTrue(message.HasField('default_int32')) 522 test_case.assertTrue(message.HasField('default_int64')) 523 test_case.assertTrue(message.HasField('default_uint32')) 524 test_case.assertTrue(message.HasField('default_uint64')) 525 test_case.assertTrue(message.HasField('default_sint32')) 526 test_case.assertTrue(message.HasField('default_sint64')) 527 test_case.assertTrue(message.HasField('default_fixed32')) 528 test_case.assertTrue(message.HasField('default_fixed64')) 529 test_case.assertTrue(message.HasField('default_sfixed32')) 530 test_case.assertTrue(message.HasField('default_sfixed64')) 531 test_case.assertTrue(message.HasField('default_float')) 532 test_case.assertTrue(message.HasField('default_double')) 533 test_case.assertTrue(message.HasField('default_bool')) 534 test_case.assertTrue(message.HasField('default_string')) 535 test_case.assertTrue(message.HasField('default_bytes')) 536 537 test_case.assertTrue(message.HasField('default_nested_enum')) 538 test_case.assertTrue(message.HasField('default_foreign_enum')) 539 test_case.assertTrue(message.HasField('default_import_enum')) 540 541 test_case.assertEqual(401, message.default_int32) 542 test_case.assertEqual(402, message.default_int64) 543 test_case.assertEqual(403, message.default_uint32) 544 test_case.assertEqual(404, message.default_uint64) 545 test_case.assertEqual(405, message.default_sint32) 546 test_case.assertEqual(406, message.default_sint64) 547 test_case.assertEqual(407, message.default_fixed32) 548 test_case.assertEqual(408, message.default_fixed64) 549 test_case.assertEqual(409, message.default_sfixed32) 550 test_case.assertEqual(410, message.default_sfixed64) 551 test_case.assertEqual(411, message.default_float) 552 test_case.assertEqual(412, message.default_double) 553 test_case.assertEqual(False, message.default_bool) 554 test_case.assertEqual('415', message.default_string) 555 test_case.assertEqual('416', message.default_bytes) 556 557 test_case.assertEqual(unittest_pb2.TestAllTypes.FOO, 558 message.default_nested_enum) 559 test_case.assertEqual(unittest_pb2.FOREIGN_FOO, 560 message.default_foreign_enum) 561 test_case.assertEqual(unittest_import_pb2.IMPORT_FOO, 562 message.default_import_enum) 563 564def GoldenFile(filename): 565 """Finds the given golden file and returns a file object representing it.""" 566 567 # Search up the directory tree looking for the C++ protobuf source code. 568 path = '.' 569 while os.path.exists(path): 570 if os.path.exists(os.path.join(path, 'tests/google/protobuf/internal')): 571 # Found it. Load the golden file from the testdata directory. 572 full_path = os.path.join(path, 'tests/google/protobuf/internal', filename) 573 return open(full_path, 'rb') 574 path = os.path.join(path, '..') 575 576 raise RuntimeError( 577 'Could not find golden files. This test must be run from within the ' 578 'protobuf source package so that it can read test data files from the ' 579 'C++ source tree.') 580 581 582def SetAllPackedFields(message): 583 """Sets every field in the message to a unique value. 584 585 Args: 586 message: A unittest_pb2.TestPackedTypes instance. 587 """ 588 message.packed_int32.extend([601, 701]) 589 message.packed_int64.extend([602, 702]) 590 message.packed_uint32.extend([603, 703]) 591 message.packed_uint64.extend([604, 704]) 592 message.packed_sint32.extend([605, 705]) 593 message.packed_sint64.extend([606, 706]) 594 message.packed_fixed32.extend([607, 707]) 595 message.packed_fixed64.extend([608, 708]) 596 message.packed_sfixed32.extend([609, 709]) 597 message.packed_sfixed64.extend([610, 710]) 598 message.packed_float.extend([611.0, 711.0]) 599 message.packed_double.extend([612.0, 712.0]) 600 message.packed_bool.extend([True, False]) 601 message.packed_enum.extend([unittest_pb2.FOREIGN_BAR, 602 unittest_pb2.FOREIGN_BAZ]) 603 604 605def SetAllPackedExtensions(message): 606 """Sets every extension in the message to a unique value. 607 608 Args: 609 message: A unittest_pb2.TestPackedExtensions instance. 610 """ 611 extensions = message.Extensions 612 pb2 = unittest_pb2 613 614 extensions[pb2.packed_int32_extension].extend([601, 701]) 615 extensions[pb2.packed_int64_extension].extend([602, 702]) 616 extensions[pb2.packed_uint32_extension].extend([603, 703]) 617 extensions[pb2.packed_uint64_extension].extend([604, 704]) 618 extensions[pb2.packed_sint32_extension].extend([605, 705]) 619 extensions[pb2.packed_sint64_extension].extend([606, 706]) 620 extensions[pb2.packed_fixed32_extension].extend([607, 707]) 621 extensions[pb2.packed_fixed64_extension].extend([608, 708]) 622 extensions[pb2.packed_sfixed32_extension].extend([609, 709]) 623 extensions[pb2.packed_sfixed64_extension].extend([610, 710]) 624 extensions[pb2.packed_float_extension].extend([611.0, 711.0]) 625 extensions[pb2.packed_double_extension].extend([612.0, 712.0]) 626 extensions[pb2.packed_bool_extension].extend([True, False]) 627 extensions[pb2.packed_enum_extension].extend([unittest_pb2.FOREIGN_BAR, 628 unittest_pb2.FOREIGN_BAZ]) 629 630 631def SetAllUnpackedFields(message): 632 """Sets every field in the message to a unique value. 633 634 Args: 635 message: A unittest_pb2.TestUnpackedTypes instance. 636 """ 637 message.unpacked_int32.extend([601, 701]) 638 message.unpacked_int64.extend([602, 702]) 639 message.unpacked_uint32.extend([603, 703]) 640 message.unpacked_uint64.extend([604, 704]) 641 message.unpacked_sint32.extend([605, 705]) 642 message.unpacked_sint64.extend([606, 706]) 643 message.unpacked_fixed32.extend([607, 707]) 644 message.unpacked_fixed64.extend([608, 708]) 645 message.unpacked_sfixed32.extend([609, 709]) 646 message.unpacked_sfixed64.extend([610, 710]) 647 message.unpacked_float.extend([611.0, 711.0]) 648 message.unpacked_double.extend([612.0, 712.0]) 649 message.unpacked_bool.extend([True, False]) 650 message.unpacked_enum.extend([unittest_pb2.FOREIGN_BAR, 651 unittest_pb2.FOREIGN_BAZ]) 652