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 // Author: kenton (at) google.com (Kenton Varda) 32 // Based on original Protocol Buffers design by 33 // Sanjay Ghemawat, Jeff Dean, and others. 34 35 #ifdef _WIN32 36 // Verify that #including windows.h does not break anything (e.g. because 37 // windows.h #defines GetMessage() as a macro). 38 #include <windows.h> 39 #endif 40 41 #include <google/protobuf/test_util.h> 42 #include <google/protobuf/descriptor.h> 43 #include <google/protobuf/message.h> 44 45 #include <google/protobuf/stubs/logging.h> 46 #include <google/protobuf/stubs/common.h> 47 #include <google/protobuf/testing/googletest.h> 48 #include <gtest/gtest.h> 49 50 namespace google { 51 namespace protobuf { 52 53 void TestUtil::SetAllFields(unittest::TestAllTypes* message) { 54 SetOptionalFields(message); 55 AddRepeatedFields1(message); 56 AddRepeatedFields2(message); 57 SetDefaultFields(message); 58 SetOneofFields(message); 59 } 60 61 void TestUtil::SetOptionalFields(unittest::TestAllTypes* message) { 62 message->set_optional_int32 (101); 63 message->set_optional_int64 (102); 64 message->set_optional_uint32 (103); 65 message->set_optional_uint64 (104); 66 message->set_optional_sint32 (105); 67 message->set_optional_sint64 (106); 68 message->set_optional_fixed32 (107); 69 message->set_optional_fixed64 (108); 70 message->set_optional_sfixed32(109); 71 message->set_optional_sfixed64(110); 72 message->set_optional_float (111); 73 message->set_optional_double (112); 74 message->set_optional_bool (true); 75 message->set_optional_string ("115"); 76 message->set_optional_bytes ("116"); 77 78 message->mutable_optionalgroup ()->set_a(117); 79 message->mutable_optional_nested_message ()->set_bb(118); 80 message->mutable_optional_foreign_message ()->set_c(119); 81 message->mutable_optional_import_message ()->set_d(120); 82 message->mutable_optional_public_import_message()->set_e(126); 83 message->mutable_optional_lazy_message ()->set_bb(127); 84 85 message->set_optional_nested_enum (unittest::TestAllTypes::BAZ); 86 message->set_optional_foreign_enum(unittest::FOREIGN_BAZ ); 87 message->set_optional_import_enum (unittest_import::IMPORT_BAZ); 88 89 // StringPiece and Cord fields are only accessible via reflection in the 90 // open source release; see comments in compiler/cpp/string_field.cc. 91 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 92 message->GetReflection()->SetString( 93 message, 94 message->GetDescriptor()->FindFieldByName("optional_string_piece"), 95 "124"); 96 message->GetReflection()->SetString( 97 message, 98 message->GetDescriptor()->FindFieldByName("optional_cord"), 99 "125"); 100 #endif // !PROTOBUF_TEST_NO_DESCRIPTORS 101 } 102 103 // ------------------------------------------------------------------- 104 105 void TestUtil::AddRepeatedFields1(unittest::TestAllTypes* message) { 106 message->add_repeated_int32 (201); 107 message->add_repeated_int64 (202); 108 message->add_repeated_uint32 (203); 109 message->add_repeated_uint64 (204); 110 message->add_repeated_sint32 (205); 111 message->add_repeated_sint64 (206); 112 message->add_repeated_fixed32 (207); 113 message->add_repeated_fixed64 (208); 114 message->add_repeated_sfixed32(209); 115 message->add_repeated_sfixed64(210); 116 message->add_repeated_float (211); 117 message->add_repeated_double (212); 118 message->add_repeated_bool (true); 119 message->add_repeated_string ("215"); 120 message->add_repeated_bytes ("216"); 121 122 message->add_repeatedgroup ()->set_a(217); 123 message->add_repeated_nested_message ()->set_bb(218); 124 message->add_repeated_foreign_message()->set_c(219); 125 message->add_repeated_import_message ()->set_d(220); 126 message->add_repeated_lazy_message ()->set_bb(227); 127 128 message->add_repeated_nested_enum (unittest::TestAllTypes::BAR); 129 message->add_repeated_foreign_enum(unittest::FOREIGN_BAR ); 130 message->add_repeated_import_enum (unittest_import::IMPORT_BAR); 131 132 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 133 message->GetReflection()->AddString( 134 message, 135 message->GetDescriptor()->FindFieldByName("repeated_string_piece"), 136 "224"); 137 message->GetReflection()->AddString( 138 message, 139 message->GetDescriptor()->FindFieldByName("repeated_cord"), 140 "225"); 141 #endif // !PROTOBUF_TEST_NO_DESCRIPTORS 142 } 143 144 void TestUtil::AddRepeatedFields2(unittest::TestAllTypes* message) { 145 // Add a second one of each field. 146 message->add_repeated_int32 (301); 147 message->add_repeated_int64 (302); 148 message->add_repeated_uint32 (303); 149 message->add_repeated_uint64 (304); 150 message->add_repeated_sint32 (305); 151 message->add_repeated_sint64 (306); 152 message->add_repeated_fixed32 (307); 153 message->add_repeated_fixed64 (308); 154 message->add_repeated_sfixed32(309); 155 message->add_repeated_sfixed64(310); 156 message->add_repeated_float (311); 157 message->add_repeated_double (312); 158 message->add_repeated_bool (false); 159 message->add_repeated_string ("315"); 160 message->add_repeated_bytes ("316"); 161 162 message->add_repeatedgroup ()->set_a(317); 163 message->add_repeated_nested_message ()->set_bb(318); 164 message->add_repeated_foreign_message()->set_c(319); 165 message->add_repeated_import_message ()->set_d(320); 166 message->add_repeated_lazy_message ()->set_bb(327); 167 168 message->add_repeated_nested_enum (unittest::TestAllTypes::BAZ); 169 message->add_repeated_foreign_enum(unittest::FOREIGN_BAZ ); 170 message->add_repeated_import_enum (unittest_import::IMPORT_BAZ); 171 172 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 173 message->GetReflection()->AddString( 174 message, 175 message->GetDescriptor()->FindFieldByName("repeated_string_piece"), 176 "324"); 177 message->GetReflection()->AddString( 178 message, 179 message->GetDescriptor()->FindFieldByName("repeated_cord"), 180 "325"); 181 #endif // !PROTOBUF_TEST_NO_DESCRIPTORS 182 } 183 184 // ------------------------------------------------------------------- 185 186 void TestUtil::SetDefaultFields(unittest::TestAllTypes* message) { 187 message->set_default_int32 (401); 188 message->set_default_int64 (402); 189 message->set_default_uint32 (403); 190 message->set_default_uint64 (404); 191 message->set_default_sint32 (405); 192 message->set_default_sint64 (406); 193 message->set_default_fixed32 (407); 194 message->set_default_fixed64 (408); 195 message->set_default_sfixed32(409); 196 message->set_default_sfixed64(410); 197 message->set_default_float (411); 198 message->set_default_double (412); 199 message->set_default_bool (false); 200 message->set_default_string ("415"); 201 message->set_default_bytes ("416"); 202 203 message->set_default_nested_enum (unittest::TestAllTypes::FOO); 204 message->set_default_foreign_enum(unittest::FOREIGN_FOO ); 205 message->set_default_import_enum (unittest_import::IMPORT_FOO); 206 207 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 208 message->GetReflection()->SetString( 209 message, 210 message->GetDescriptor()->FindFieldByName("default_string_piece"), 211 "424"); 212 message->GetReflection()->SetString( 213 message, 214 message->GetDescriptor()->FindFieldByName("default_cord"), 215 "425"); 216 #endif // !PROTOBUF_TEST_NO_DESCRIPTORS 217 } 218 219 // ------------------------------------------------------------------- 220 221 void TestUtil::ModifyRepeatedFields(unittest::TestAllTypes* message) { 222 message->set_repeated_int32 (1, 501); 223 message->set_repeated_int64 (1, 502); 224 message->set_repeated_uint32 (1, 503); 225 message->set_repeated_uint64 (1, 504); 226 message->set_repeated_sint32 (1, 505); 227 message->set_repeated_sint64 (1, 506); 228 message->set_repeated_fixed32 (1, 507); 229 message->set_repeated_fixed64 (1, 508); 230 message->set_repeated_sfixed32(1, 509); 231 message->set_repeated_sfixed64(1, 510); 232 message->set_repeated_float (1, 511); 233 message->set_repeated_double (1, 512); 234 message->set_repeated_bool (1, true); 235 message->set_repeated_string (1, "515"); 236 message->set_repeated_bytes (1, "516"); 237 238 message->mutable_repeatedgroup (1)->set_a(517); 239 message->mutable_repeated_nested_message (1)->set_bb(518); 240 message->mutable_repeated_foreign_message(1)->set_c(519); 241 message->mutable_repeated_import_message (1)->set_d(520); 242 message->mutable_repeated_lazy_message (1)->set_bb(527); 243 244 message->set_repeated_nested_enum (1, unittest::TestAllTypes::FOO); 245 message->set_repeated_foreign_enum(1, unittest::FOREIGN_FOO ); 246 message->set_repeated_import_enum (1, unittest_import::IMPORT_FOO); 247 248 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 249 message->GetReflection()->SetRepeatedString( 250 message, 251 message->GetDescriptor()->FindFieldByName("repeated_string_piece"), 252 1, "524"); 253 message->GetReflection()->SetRepeatedString( 254 message, 255 message->GetDescriptor()->FindFieldByName("repeated_cord"), 256 1, "525"); 257 #endif // !PROTOBUF_TEST_NO_DESCRIPTORS 258 } 259 260 // ------------------------------------------------------------------ 261 void TestUtil::SetOneofFields(unittest::TestAllTypes* message) { 262 message->set_oneof_uint32(601); 263 message->mutable_oneof_nested_message()->set_bb(602); 264 message->set_oneof_string("603"); 265 message->set_oneof_bytes("604"); 266 } 267 268 // ------------------------------------------------------------------- 269 270 void TestUtil::ExpectAllFieldsSet(const unittest::TestAllTypes& message) { 271 EXPECT_TRUE(message.has_optional_int32 ()); 272 EXPECT_TRUE(message.has_optional_int64 ()); 273 EXPECT_TRUE(message.has_optional_uint32 ()); 274 EXPECT_TRUE(message.has_optional_uint64 ()); 275 EXPECT_TRUE(message.has_optional_sint32 ()); 276 EXPECT_TRUE(message.has_optional_sint64 ()); 277 EXPECT_TRUE(message.has_optional_fixed32 ()); 278 EXPECT_TRUE(message.has_optional_fixed64 ()); 279 EXPECT_TRUE(message.has_optional_sfixed32()); 280 EXPECT_TRUE(message.has_optional_sfixed64()); 281 EXPECT_TRUE(message.has_optional_float ()); 282 EXPECT_TRUE(message.has_optional_double ()); 283 EXPECT_TRUE(message.has_optional_bool ()); 284 EXPECT_TRUE(message.has_optional_string ()); 285 EXPECT_TRUE(message.has_optional_bytes ()); 286 287 EXPECT_TRUE(message.has_optionalgroup ()); 288 EXPECT_TRUE(message.has_optional_nested_message ()); 289 EXPECT_TRUE(message.has_optional_foreign_message ()); 290 EXPECT_TRUE(message.has_optional_import_message ()); 291 EXPECT_TRUE(message.has_optional_public_import_message()); 292 EXPECT_TRUE(message.has_optional_lazy_message ()); 293 294 EXPECT_TRUE(message.optionalgroup ().has_a()); 295 EXPECT_TRUE(message.optional_nested_message ().has_bb()); 296 EXPECT_TRUE(message.optional_foreign_message ().has_c()); 297 EXPECT_TRUE(message.optional_import_message ().has_d()); 298 EXPECT_TRUE(message.optional_public_import_message().has_e()); 299 EXPECT_TRUE(message.optional_lazy_message ().has_bb()); 300 301 EXPECT_TRUE(message.has_optional_nested_enum ()); 302 EXPECT_TRUE(message.has_optional_foreign_enum()); 303 EXPECT_TRUE(message.has_optional_import_enum ()); 304 305 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 306 EXPECT_TRUE(message.has_optional_string_piece()); 307 EXPECT_TRUE(message.has_optional_cord()); 308 #endif 309 310 EXPECT_EQ(101 , message.optional_int32 ()); 311 EXPECT_EQ(102 , message.optional_int64 ()); 312 EXPECT_EQ(103 , message.optional_uint32 ()); 313 EXPECT_EQ(104 , message.optional_uint64 ()); 314 EXPECT_EQ(105 , message.optional_sint32 ()); 315 EXPECT_EQ(106 , message.optional_sint64 ()); 316 EXPECT_EQ(107 , message.optional_fixed32 ()); 317 EXPECT_EQ(108 , message.optional_fixed64 ()); 318 EXPECT_EQ(109 , message.optional_sfixed32()); 319 EXPECT_EQ(110 , message.optional_sfixed64()); 320 EXPECT_EQ(111 , message.optional_float ()); 321 EXPECT_EQ(112 , message.optional_double ()); 322 EXPECT_TRUE( message.optional_bool ()); 323 EXPECT_EQ("115", message.optional_string ()); 324 EXPECT_EQ("116", message.optional_bytes ()); 325 326 EXPECT_EQ(117, message.optionalgroup ().a()); 327 EXPECT_EQ(118, message.optional_nested_message ().bb()); 328 EXPECT_EQ(119, message.optional_foreign_message ().c()); 329 EXPECT_EQ(120, message.optional_import_message ().d()); 330 EXPECT_EQ(126, message.optional_public_import_message ().e()); 331 EXPECT_EQ(127, message.optional_lazy_message ().bb()); 332 333 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.optional_nested_enum ()); 334 EXPECT_EQ(unittest::FOREIGN_BAZ , message.optional_foreign_enum()); 335 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.optional_import_enum ()); 336 337 338 // ----------------------------------------------------------------- 339 340 ASSERT_EQ(2, message.repeated_int32_size ()); 341 ASSERT_EQ(2, message.repeated_int64_size ()); 342 ASSERT_EQ(2, message.repeated_uint32_size ()); 343 ASSERT_EQ(2, message.repeated_uint64_size ()); 344 ASSERT_EQ(2, message.repeated_sint32_size ()); 345 ASSERT_EQ(2, message.repeated_sint64_size ()); 346 ASSERT_EQ(2, message.repeated_fixed32_size ()); 347 ASSERT_EQ(2, message.repeated_fixed64_size ()); 348 ASSERT_EQ(2, message.repeated_sfixed32_size()); 349 ASSERT_EQ(2, message.repeated_sfixed64_size()); 350 ASSERT_EQ(2, message.repeated_float_size ()); 351 ASSERT_EQ(2, message.repeated_double_size ()); 352 ASSERT_EQ(2, message.repeated_bool_size ()); 353 ASSERT_EQ(2, message.repeated_string_size ()); 354 ASSERT_EQ(2, message.repeated_bytes_size ()); 355 356 ASSERT_EQ(2, message.repeatedgroup_size ()); 357 ASSERT_EQ(2, message.repeated_nested_message_size ()); 358 ASSERT_EQ(2, message.repeated_foreign_message_size()); 359 ASSERT_EQ(2, message.repeated_import_message_size ()); 360 ASSERT_EQ(2, message.repeated_lazy_message_size ()); 361 ASSERT_EQ(2, message.repeated_nested_enum_size ()); 362 ASSERT_EQ(2, message.repeated_foreign_enum_size ()); 363 ASSERT_EQ(2, message.repeated_import_enum_size ()); 364 365 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 366 ASSERT_EQ(2, message.repeated_string_piece_size()); 367 ASSERT_EQ(2, message.repeated_cord_size()); 368 #endif 369 370 EXPECT_EQ(201 , message.repeated_int32 (0)); 371 EXPECT_EQ(202 , message.repeated_int64 (0)); 372 EXPECT_EQ(203 , message.repeated_uint32 (0)); 373 EXPECT_EQ(204 , message.repeated_uint64 (0)); 374 EXPECT_EQ(205 , message.repeated_sint32 (0)); 375 EXPECT_EQ(206 , message.repeated_sint64 (0)); 376 EXPECT_EQ(207 , message.repeated_fixed32 (0)); 377 EXPECT_EQ(208 , message.repeated_fixed64 (0)); 378 EXPECT_EQ(209 , message.repeated_sfixed32(0)); 379 EXPECT_EQ(210 , message.repeated_sfixed64(0)); 380 EXPECT_EQ(211 , message.repeated_float (0)); 381 EXPECT_EQ(212 , message.repeated_double (0)); 382 EXPECT_TRUE( message.repeated_bool (0)); 383 EXPECT_EQ("215", message.repeated_string (0)); 384 EXPECT_EQ("216", message.repeated_bytes (0)); 385 386 EXPECT_EQ(217, message.repeatedgroup (0).a()); 387 EXPECT_EQ(218, message.repeated_nested_message (0).bb()); 388 EXPECT_EQ(219, message.repeated_foreign_message(0).c()); 389 EXPECT_EQ(220, message.repeated_import_message (0).d()); 390 EXPECT_EQ(227, message.repeated_lazy_message (0).bb()); 391 392 393 EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (0)); 394 EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(0)); 395 EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (0)); 396 397 EXPECT_EQ(301 , message.repeated_int32 (1)); 398 EXPECT_EQ(302 , message.repeated_int64 (1)); 399 EXPECT_EQ(303 , message.repeated_uint32 (1)); 400 EXPECT_EQ(304 , message.repeated_uint64 (1)); 401 EXPECT_EQ(305 , message.repeated_sint32 (1)); 402 EXPECT_EQ(306 , message.repeated_sint64 (1)); 403 EXPECT_EQ(307 , message.repeated_fixed32 (1)); 404 EXPECT_EQ(308 , message.repeated_fixed64 (1)); 405 EXPECT_EQ(309 , message.repeated_sfixed32(1)); 406 EXPECT_EQ(310 , message.repeated_sfixed64(1)); 407 EXPECT_EQ(311 , message.repeated_float (1)); 408 EXPECT_EQ(312 , message.repeated_double (1)); 409 EXPECT_FALSE( message.repeated_bool (1)); 410 EXPECT_EQ("315", message.repeated_string (1)); 411 EXPECT_EQ("316", message.repeated_bytes (1)); 412 413 EXPECT_EQ(317, message.repeatedgroup (1).a()); 414 EXPECT_EQ(318, message.repeated_nested_message (1).bb()); 415 EXPECT_EQ(319, message.repeated_foreign_message(1).c()); 416 EXPECT_EQ(320, message.repeated_import_message (1).d()); 417 EXPECT_EQ(327, message.repeated_lazy_message (1).bb()); 418 419 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.repeated_nested_enum (1)); 420 EXPECT_EQ(unittest::FOREIGN_BAZ , message.repeated_foreign_enum(1)); 421 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.repeated_import_enum (1)); 422 423 424 // ----------------------------------------------------------------- 425 426 EXPECT_TRUE(message.has_default_int32 ()); 427 EXPECT_TRUE(message.has_default_int64 ()); 428 EXPECT_TRUE(message.has_default_uint32 ()); 429 EXPECT_TRUE(message.has_default_uint64 ()); 430 EXPECT_TRUE(message.has_default_sint32 ()); 431 EXPECT_TRUE(message.has_default_sint64 ()); 432 EXPECT_TRUE(message.has_default_fixed32 ()); 433 EXPECT_TRUE(message.has_default_fixed64 ()); 434 EXPECT_TRUE(message.has_default_sfixed32()); 435 EXPECT_TRUE(message.has_default_sfixed64()); 436 EXPECT_TRUE(message.has_default_float ()); 437 EXPECT_TRUE(message.has_default_double ()); 438 EXPECT_TRUE(message.has_default_bool ()); 439 EXPECT_TRUE(message.has_default_string ()); 440 EXPECT_TRUE(message.has_default_bytes ()); 441 442 EXPECT_TRUE(message.has_default_nested_enum ()); 443 EXPECT_TRUE(message.has_default_foreign_enum()); 444 EXPECT_TRUE(message.has_default_import_enum ()); 445 446 447 EXPECT_EQ(401 , message.default_int32 ()); 448 EXPECT_EQ(402 , message.default_int64 ()); 449 EXPECT_EQ(403 , message.default_uint32 ()); 450 EXPECT_EQ(404 , message.default_uint64 ()); 451 EXPECT_EQ(405 , message.default_sint32 ()); 452 EXPECT_EQ(406 , message.default_sint64 ()); 453 EXPECT_EQ(407 , message.default_fixed32 ()); 454 EXPECT_EQ(408 , message.default_fixed64 ()); 455 EXPECT_EQ(409 , message.default_sfixed32()); 456 EXPECT_EQ(410 , message.default_sfixed64()); 457 EXPECT_EQ(411 , message.default_float ()); 458 EXPECT_EQ(412 , message.default_double ()); 459 EXPECT_FALSE( message.default_bool ()); 460 EXPECT_EQ("415", message.default_string ()); 461 EXPECT_EQ("416", message.default_bytes ()); 462 463 EXPECT_EQ(unittest::TestAllTypes::FOO, message.default_nested_enum ()); 464 EXPECT_EQ(unittest::FOREIGN_FOO , message.default_foreign_enum()); 465 EXPECT_EQ(unittest_import::IMPORT_FOO, message.default_import_enum ()); 466 467 468 EXPECT_FALSE(message.has_oneof_uint32 ()); 469 EXPECT_FALSE(message.has_oneof_nested_message()); 470 EXPECT_FALSE(message.has_oneof_string ()); 471 EXPECT_TRUE(message.has_oneof_bytes ()); 472 473 EXPECT_EQ("604", message.oneof_bytes()); 474 } 475 476 // ------------------------------------------------------------------- 477 478 void TestUtil::ExpectClear(const unittest::TestAllTypes& message) { 479 // has_blah() should initially be false for all optional fields. 480 EXPECT_FALSE(message.has_optional_int32 ()); 481 EXPECT_FALSE(message.has_optional_int64 ()); 482 EXPECT_FALSE(message.has_optional_uint32 ()); 483 EXPECT_FALSE(message.has_optional_uint64 ()); 484 EXPECT_FALSE(message.has_optional_sint32 ()); 485 EXPECT_FALSE(message.has_optional_sint64 ()); 486 EXPECT_FALSE(message.has_optional_fixed32 ()); 487 EXPECT_FALSE(message.has_optional_fixed64 ()); 488 EXPECT_FALSE(message.has_optional_sfixed32()); 489 EXPECT_FALSE(message.has_optional_sfixed64()); 490 EXPECT_FALSE(message.has_optional_float ()); 491 EXPECT_FALSE(message.has_optional_double ()); 492 EXPECT_FALSE(message.has_optional_bool ()); 493 EXPECT_FALSE(message.has_optional_string ()); 494 EXPECT_FALSE(message.has_optional_bytes ()); 495 496 EXPECT_FALSE(message.has_optionalgroup ()); 497 EXPECT_FALSE(message.has_optional_nested_message ()); 498 EXPECT_FALSE(message.has_optional_foreign_message ()); 499 EXPECT_FALSE(message.has_optional_import_message ()); 500 EXPECT_FALSE(message.has_optional_public_import_message()); 501 EXPECT_FALSE(message.has_optional_lazy_message ()); 502 503 EXPECT_FALSE(message.has_optional_nested_enum ()); 504 EXPECT_FALSE(message.has_optional_foreign_enum()); 505 EXPECT_FALSE(message.has_optional_import_enum ()); 506 507 EXPECT_FALSE(message.has_optional_string_piece()); 508 EXPECT_FALSE(message.has_optional_cord()); 509 510 // Optional fields without defaults are set to zero or something like it. 511 EXPECT_EQ(0 , message.optional_int32 ()); 512 EXPECT_EQ(0 , message.optional_int64 ()); 513 EXPECT_EQ(0 , message.optional_uint32 ()); 514 EXPECT_EQ(0 , message.optional_uint64 ()); 515 EXPECT_EQ(0 , message.optional_sint32 ()); 516 EXPECT_EQ(0 , message.optional_sint64 ()); 517 EXPECT_EQ(0 , message.optional_fixed32 ()); 518 EXPECT_EQ(0 , message.optional_fixed64 ()); 519 EXPECT_EQ(0 , message.optional_sfixed32()); 520 EXPECT_EQ(0 , message.optional_sfixed64()); 521 EXPECT_EQ(0 , message.optional_float ()); 522 EXPECT_EQ(0 , message.optional_double ()); 523 EXPECT_FALSE( message.optional_bool ()); 524 EXPECT_EQ("" , message.optional_string ()); 525 EXPECT_EQ("" , message.optional_bytes ()); 526 527 // Embedded messages should also be clear. 528 EXPECT_FALSE(message.optionalgroup ().has_a()); 529 EXPECT_FALSE(message.optional_nested_message ().has_bb()); 530 EXPECT_FALSE(message.optional_foreign_message ().has_c()); 531 EXPECT_FALSE(message.optional_import_message ().has_d()); 532 EXPECT_FALSE(message.optional_public_import_message().has_e()); 533 EXPECT_FALSE(message.optional_lazy_message ().has_bb()); 534 535 EXPECT_EQ(0, message.optionalgroup ().a()); 536 EXPECT_EQ(0, message.optional_nested_message ().bb()); 537 EXPECT_EQ(0, message.optional_foreign_message ().c()); 538 EXPECT_EQ(0, message.optional_import_message ().d()); 539 EXPECT_EQ(0, message.optional_public_import_message().e()); 540 EXPECT_EQ(0, message.optional_lazy_message ().bb()); 541 542 // Enums without defaults are set to the first value in the enum. 543 EXPECT_EQ(unittest::TestAllTypes::FOO, message.optional_nested_enum ()); 544 EXPECT_EQ(unittest::FOREIGN_FOO , message.optional_foreign_enum()); 545 EXPECT_EQ(unittest_import::IMPORT_FOO, message.optional_import_enum ()); 546 547 548 // Repeated fields are empty. 549 EXPECT_EQ(0, message.repeated_int32_size ()); 550 EXPECT_EQ(0, message.repeated_int64_size ()); 551 EXPECT_EQ(0, message.repeated_uint32_size ()); 552 EXPECT_EQ(0, message.repeated_uint64_size ()); 553 EXPECT_EQ(0, message.repeated_sint32_size ()); 554 EXPECT_EQ(0, message.repeated_sint64_size ()); 555 EXPECT_EQ(0, message.repeated_fixed32_size ()); 556 EXPECT_EQ(0, message.repeated_fixed64_size ()); 557 EXPECT_EQ(0, message.repeated_sfixed32_size()); 558 EXPECT_EQ(0, message.repeated_sfixed64_size()); 559 EXPECT_EQ(0, message.repeated_float_size ()); 560 EXPECT_EQ(0, message.repeated_double_size ()); 561 EXPECT_EQ(0, message.repeated_bool_size ()); 562 EXPECT_EQ(0, message.repeated_string_size ()); 563 EXPECT_EQ(0, message.repeated_bytes_size ()); 564 565 EXPECT_EQ(0, message.repeatedgroup_size ()); 566 EXPECT_EQ(0, message.repeated_nested_message_size ()); 567 EXPECT_EQ(0, message.repeated_foreign_message_size()); 568 EXPECT_EQ(0, message.repeated_import_message_size ()); 569 EXPECT_EQ(0, message.repeated_lazy_message_size ()); 570 EXPECT_EQ(0, message.repeated_nested_enum_size ()); 571 EXPECT_EQ(0, message.repeated_foreign_enum_size ()); 572 EXPECT_EQ(0, message.repeated_import_enum_size ()); 573 574 EXPECT_EQ(0, message.repeated_string_piece_size()); 575 EXPECT_EQ(0, message.repeated_cord_size()); 576 577 // has_blah() should also be false for all default fields. 578 EXPECT_FALSE(message.has_default_int32 ()); 579 EXPECT_FALSE(message.has_default_int64 ()); 580 EXPECT_FALSE(message.has_default_uint32 ()); 581 EXPECT_FALSE(message.has_default_uint64 ()); 582 EXPECT_FALSE(message.has_default_sint32 ()); 583 EXPECT_FALSE(message.has_default_sint64 ()); 584 EXPECT_FALSE(message.has_default_fixed32 ()); 585 EXPECT_FALSE(message.has_default_fixed64 ()); 586 EXPECT_FALSE(message.has_default_sfixed32()); 587 EXPECT_FALSE(message.has_default_sfixed64()); 588 EXPECT_FALSE(message.has_default_float ()); 589 EXPECT_FALSE(message.has_default_double ()); 590 EXPECT_FALSE(message.has_default_bool ()); 591 EXPECT_FALSE(message.has_default_string ()); 592 EXPECT_FALSE(message.has_default_bytes ()); 593 594 EXPECT_FALSE(message.has_default_nested_enum ()); 595 EXPECT_FALSE(message.has_default_foreign_enum()); 596 EXPECT_FALSE(message.has_default_import_enum ()); 597 598 599 // Fields with defaults have their default values (duh). 600 EXPECT_EQ( 41 , message.default_int32 ()); 601 EXPECT_EQ( 42 , message.default_int64 ()); 602 EXPECT_EQ( 43 , message.default_uint32 ()); 603 EXPECT_EQ( 44 , message.default_uint64 ()); 604 EXPECT_EQ(-45 , message.default_sint32 ()); 605 EXPECT_EQ( 46 , message.default_sint64 ()); 606 EXPECT_EQ( 47 , message.default_fixed32 ()); 607 EXPECT_EQ( 48 , message.default_fixed64 ()); 608 EXPECT_EQ( 49 , message.default_sfixed32()); 609 EXPECT_EQ(-50 , message.default_sfixed64()); 610 EXPECT_EQ( 51.5 , message.default_float ()); 611 EXPECT_EQ( 52e3 , message.default_double ()); 612 EXPECT_TRUE( message.default_bool ()); 613 EXPECT_EQ("hello", message.default_string ()); 614 EXPECT_EQ("world", message.default_bytes ()); 615 616 EXPECT_EQ(unittest::TestAllTypes::BAR, message.default_nested_enum ()); 617 EXPECT_EQ(unittest::FOREIGN_BAR , message.default_foreign_enum()); 618 EXPECT_EQ(unittest_import::IMPORT_BAR, message.default_import_enum ()); 619 620 621 EXPECT_FALSE(message.has_oneof_uint32 ()); 622 EXPECT_FALSE(message.has_oneof_nested_message()); 623 EXPECT_FALSE(message.has_oneof_string ()); 624 EXPECT_FALSE(message.has_oneof_bytes ()); 625 } 626 627 // ------------------------------------------------------------------- 628 629 void TestUtil::ExpectRepeatedFieldsModified( 630 const unittest::TestAllTypes& message) { 631 // ModifyRepeatedFields only sets the second repeated element of each 632 // field. In addition to verifying this, we also verify that the first 633 // element and size were *not* modified. 634 ASSERT_EQ(2, message.repeated_int32_size ()); 635 ASSERT_EQ(2, message.repeated_int64_size ()); 636 ASSERT_EQ(2, message.repeated_uint32_size ()); 637 ASSERT_EQ(2, message.repeated_uint64_size ()); 638 ASSERT_EQ(2, message.repeated_sint32_size ()); 639 ASSERT_EQ(2, message.repeated_sint64_size ()); 640 ASSERT_EQ(2, message.repeated_fixed32_size ()); 641 ASSERT_EQ(2, message.repeated_fixed64_size ()); 642 ASSERT_EQ(2, message.repeated_sfixed32_size()); 643 ASSERT_EQ(2, message.repeated_sfixed64_size()); 644 ASSERT_EQ(2, message.repeated_float_size ()); 645 ASSERT_EQ(2, message.repeated_double_size ()); 646 ASSERT_EQ(2, message.repeated_bool_size ()); 647 ASSERT_EQ(2, message.repeated_string_size ()); 648 ASSERT_EQ(2, message.repeated_bytes_size ()); 649 650 ASSERT_EQ(2, message.repeatedgroup_size ()); 651 ASSERT_EQ(2, message.repeated_nested_message_size ()); 652 ASSERT_EQ(2, message.repeated_foreign_message_size()); 653 ASSERT_EQ(2, message.repeated_import_message_size ()); 654 ASSERT_EQ(2, message.repeated_lazy_message_size ()); 655 ASSERT_EQ(2, message.repeated_nested_enum_size ()); 656 ASSERT_EQ(2, message.repeated_foreign_enum_size ()); 657 ASSERT_EQ(2, message.repeated_import_enum_size ()); 658 659 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 660 ASSERT_EQ(2, message.repeated_string_piece_size()); 661 ASSERT_EQ(2, message.repeated_cord_size()); 662 #endif 663 664 EXPECT_EQ(201 , message.repeated_int32 (0)); 665 EXPECT_EQ(202 , message.repeated_int64 (0)); 666 EXPECT_EQ(203 , message.repeated_uint32 (0)); 667 EXPECT_EQ(204 , message.repeated_uint64 (0)); 668 EXPECT_EQ(205 , message.repeated_sint32 (0)); 669 EXPECT_EQ(206 , message.repeated_sint64 (0)); 670 EXPECT_EQ(207 , message.repeated_fixed32 (0)); 671 EXPECT_EQ(208 , message.repeated_fixed64 (0)); 672 EXPECT_EQ(209 , message.repeated_sfixed32(0)); 673 EXPECT_EQ(210 , message.repeated_sfixed64(0)); 674 EXPECT_EQ(211 , message.repeated_float (0)); 675 EXPECT_EQ(212 , message.repeated_double (0)); 676 EXPECT_TRUE( message.repeated_bool (0)); 677 EXPECT_EQ("215", message.repeated_string (0)); 678 EXPECT_EQ("216", message.repeated_bytes (0)); 679 680 EXPECT_EQ(217, message.repeatedgroup (0).a()); 681 EXPECT_EQ(218, message.repeated_nested_message (0).bb()); 682 EXPECT_EQ(219, message.repeated_foreign_message(0).c()); 683 EXPECT_EQ(220, message.repeated_import_message (0).d()); 684 EXPECT_EQ(227, message.repeated_lazy_message (0).bb()); 685 686 EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (0)); 687 EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(0)); 688 EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (0)); 689 690 691 // Actually verify the second (modified) elements now. 692 EXPECT_EQ(501 , message.repeated_int32 (1)); 693 EXPECT_EQ(502 , message.repeated_int64 (1)); 694 EXPECT_EQ(503 , message.repeated_uint32 (1)); 695 EXPECT_EQ(504 , message.repeated_uint64 (1)); 696 EXPECT_EQ(505 , message.repeated_sint32 (1)); 697 EXPECT_EQ(506 , message.repeated_sint64 (1)); 698 EXPECT_EQ(507 , message.repeated_fixed32 (1)); 699 EXPECT_EQ(508 , message.repeated_fixed64 (1)); 700 EXPECT_EQ(509 , message.repeated_sfixed32(1)); 701 EXPECT_EQ(510 , message.repeated_sfixed64(1)); 702 EXPECT_EQ(511 , message.repeated_float (1)); 703 EXPECT_EQ(512 , message.repeated_double (1)); 704 EXPECT_TRUE( message.repeated_bool (1)); 705 EXPECT_EQ("515", message.repeated_string (1)); 706 EXPECT_EQ("516", message.repeated_bytes (1)); 707 708 EXPECT_EQ(517, message.repeatedgroup (1).a()); 709 EXPECT_EQ(518, message.repeated_nested_message (1).bb()); 710 EXPECT_EQ(519, message.repeated_foreign_message(1).c()); 711 EXPECT_EQ(520, message.repeated_import_message (1).d()); 712 EXPECT_EQ(527, message.repeated_lazy_message (1).bb()); 713 714 EXPECT_EQ(unittest::TestAllTypes::FOO, message.repeated_nested_enum (1)); 715 EXPECT_EQ(unittest::FOREIGN_FOO , message.repeated_foreign_enum(1)); 716 EXPECT_EQ(unittest_import::IMPORT_FOO, message.repeated_import_enum (1)); 717 718 } 719 720 // ------------------------------------------------------------------- 721 722 void TestUtil::SetPackedFields(unittest::TestPackedTypes* message) { 723 message->add_packed_int32 (601); 724 message->add_packed_int64 (602); 725 message->add_packed_uint32 (603); 726 message->add_packed_uint64 (604); 727 message->add_packed_sint32 (605); 728 message->add_packed_sint64 (606); 729 message->add_packed_fixed32 (607); 730 message->add_packed_fixed64 (608); 731 message->add_packed_sfixed32(609); 732 message->add_packed_sfixed64(610); 733 message->add_packed_float (611); 734 message->add_packed_double (612); 735 message->add_packed_bool (true); 736 message->add_packed_enum (unittest::FOREIGN_BAR); 737 // add a second one of each field 738 message->add_packed_int32 (701); 739 message->add_packed_int64 (702); 740 message->add_packed_uint32 (703); 741 message->add_packed_uint64 (704); 742 message->add_packed_sint32 (705); 743 message->add_packed_sint64 (706); 744 message->add_packed_fixed32 (707); 745 message->add_packed_fixed64 (708); 746 message->add_packed_sfixed32(709); 747 message->add_packed_sfixed64(710); 748 message->add_packed_float (711); 749 message->add_packed_double (712); 750 message->add_packed_bool (false); 751 message->add_packed_enum (unittest::FOREIGN_BAZ); 752 } 753 754 void TestUtil::SetUnpackedFields(unittest::TestUnpackedTypes* message) { 755 // The values applied here must match those of SetPackedFields. 756 757 message->add_unpacked_int32 (601); 758 message->add_unpacked_int64 (602); 759 message->add_unpacked_uint32 (603); 760 message->add_unpacked_uint64 (604); 761 message->add_unpacked_sint32 (605); 762 message->add_unpacked_sint64 (606); 763 message->add_unpacked_fixed32 (607); 764 message->add_unpacked_fixed64 (608); 765 message->add_unpacked_sfixed32(609); 766 message->add_unpacked_sfixed64(610); 767 message->add_unpacked_float (611); 768 message->add_unpacked_double (612); 769 message->add_unpacked_bool (true); 770 message->add_unpacked_enum (unittest::FOREIGN_BAR); 771 // add a second one of each field 772 message->add_unpacked_int32 (701); 773 message->add_unpacked_int64 (702); 774 message->add_unpacked_uint32 (703); 775 message->add_unpacked_uint64 (704); 776 message->add_unpacked_sint32 (705); 777 message->add_unpacked_sint64 (706); 778 message->add_unpacked_fixed32 (707); 779 message->add_unpacked_fixed64 (708); 780 message->add_unpacked_sfixed32(709); 781 message->add_unpacked_sfixed64(710); 782 message->add_unpacked_float (711); 783 message->add_unpacked_double (712); 784 message->add_unpacked_bool (false); 785 message->add_unpacked_enum (unittest::FOREIGN_BAZ); 786 } 787 788 // ------------------------------------------------------------------- 789 790 void TestUtil::ModifyPackedFields(unittest::TestPackedTypes* message) { 791 message->set_packed_int32 (1, 801); 792 message->set_packed_int64 (1, 802); 793 message->set_packed_uint32 (1, 803); 794 message->set_packed_uint64 (1, 804); 795 message->set_packed_sint32 (1, 805); 796 message->set_packed_sint64 (1, 806); 797 message->set_packed_fixed32 (1, 807); 798 message->set_packed_fixed64 (1, 808); 799 message->set_packed_sfixed32(1, 809); 800 message->set_packed_sfixed64(1, 810); 801 message->set_packed_float (1, 811); 802 message->set_packed_double (1, 812); 803 message->set_packed_bool (1, true); 804 message->set_packed_enum (1, unittest::FOREIGN_FOO); 805 } 806 807 // ------------------------------------------------------------------- 808 809 void TestUtil::ExpectPackedFieldsSet(const unittest::TestPackedTypes& message) { 810 ASSERT_EQ(2, message.packed_int32_size ()); 811 ASSERT_EQ(2, message.packed_int64_size ()); 812 ASSERT_EQ(2, message.packed_uint32_size ()); 813 ASSERT_EQ(2, message.packed_uint64_size ()); 814 ASSERT_EQ(2, message.packed_sint32_size ()); 815 ASSERT_EQ(2, message.packed_sint64_size ()); 816 ASSERT_EQ(2, message.packed_fixed32_size ()); 817 ASSERT_EQ(2, message.packed_fixed64_size ()); 818 ASSERT_EQ(2, message.packed_sfixed32_size()); 819 ASSERT_EQ(2, message.packed_sfixed64_size()); 820 ASSERT_EQ(2, message.packed_float_size ()); 821 ASSERT_EQ(2, message.packed_double_size ()); 822 ASSERT_EQ(2, message.packed_bool_size ()); 823 ASSERT_EQ(2, message.packed_enum_size ()); 824 825 EXPECT_EQ(601 , message.packed_int32 (0)); 826 EXPECT_EQ(602 , message.packed_int64 (0)); 827 EXPECT_EQ(603 , message.packed_uint32 (0)); 828 EXPECT_EQ(604 , message.packed_uint64 (0)); 829 EXPECT_EQ(605 , message.packed_sint32 (0)); 830 EXPECT_EQ(606 , message.packed_sint64 (0)); 831 EXPECT_EQ(607 , message.packed_fixed32 (0)); 832 EXPECT_EQ(608 , message.packed_fixed64 (0)); 833 EXPECT_EQ(609 , message.packed_sfixed32(0)); 834 EXPECT_EQ(610 , message.packed_sfixed64(0)); 835 EXPECT_EQ(611 , message.packed_float (0)); 836 EXPECT_EQ(612 , message.packed_double (0)); 837 EXPECT_TRUE( message.packed_bool (0)); 838 EXPECT_EQ(unittest::FOREIGN_BAR, message.packed_enum(0)); 839 840 EXPECT_EQ(701 , message.packed_int32 (1)); 841 EXPECT_EQ(702 , message.packed_int64 (1)); 842 EXPECT_EQ(703 , message.packed_uint32 (1)); 843 EXPECT_EQ(704 , message.packed_uint64 (1)); 844 EXPECT_EQ(705 , message.packed_sint32 (1)); 845 EXPECT_EQ(706 , message.packed_sint64 (1)); 846 EXPECT_EQ(707 , message.packed_fixed32 (1)); 847 EXPECT_EQ(708 , message.packed_fixed64 (1)); 848 EXPECT_EQ(709 , message.packed_sfixed32(1)); 849 EXPECT_EQ(710 , message.packed_sfixed64(1)); 850 EXPECT_EQ(711 , message.packed_float (1)); 851 EXPECT_EQ(712 , message.packed_double (1)); 852 EXPECT_FALSE( message.packed_bool (1)); 853 EXPECT_EQ(unittest::FOREIGN_BAZ, message.packed_enum(1)); 854 } 855 856 void TestUtil::ExpectUnpackedFieldsSet( 857 const unittest::TestUnpackedTypes& message) { 858 // The values expected here must match those of ExpectPackedFieldsSet. 859 860 ASSERT_EQ(2, message.unpacked_int32_size ()); 861 ASSERT_EQ(2, message.unpacked_int64_size ()); 862 ASSERT_EQ(2, message.unpacked_uint32_size ()); 863 ASSERT_EQ(2, message.unpacked_uint64_size ()); 864 ASSERT_EQ(2, message.unpacked_sint32_size ()); 865 ASSERT_EQ(2, message.unpacked_sint64_size ()); 866 ASSERT_EQ(2, message.unpacked_fixed32_size ()); 867 ASSERT_EQ(2, message.unpacked_fixed64_size ()); 868 ASSERT_EQ(2, message.unpacked_sfixed32_size()); 869 ASSERT_EQ(2, message.unpacked_sfixed64_size()); 870 ASSERT_EQ(2, message.unpacked_float_size ()); 871 ASSERT_EQ(2, message.unpacked_double_size ()); 872 ASSERT_EQ(2, message.unpacked_bool_size ()); 873 ASSERT_EQ(2, message.unpacked_enum_size ()); 874 875 EXPECT_EQ(601 , message.unpacked_int32 (0)); 876 EXPECT_EQ(602 , message.unpacked_int64 (0)); 877 EXPECT_EQ(603 , message.unpacked_uint32 (0)); 878 EXPECT_EQ(604 , message.unpacked_uint64 (0)); 879 EXPECT_EQ(605 , message.unpacked_sint32 (0)); 880 EXPECT_EQ(606 , message.unpacked_sint64 (0)); 881 EXPECT_EQ(607 , message.unpacked_fixed32 (0)); 882 EXPECT_EQ(608 , message.unpacked_fixed64 (0)); 883 EXPECT_EQ(609 , message.unpacked_sfixed32(0)); 884 EXPECT_EQ(610 , message.unpacked_sfixed64(0)); 885 EXPECT_EQ(611 , message.unpacked_float (0)); 886 EXPECT_EQ(612 , message.unpacked_double (0)); 887 EXPECT_TRUE( message.unpacked_bool (0)); 888 EXPECT_EQ(unittest::FOREIGN_BAR, message.unpacked_enum(0)); 889 890 EXPECT_EQ(701 , message.unpacked_int32 (1)); 891 EXPECT_EQ(702 , message.unpacked_int64 (1)); 892 EXPECT_EQ(703 , message.unpacked_uint32 (1)); 893 EXPECT_EQ(704 , message.unpacked_uint64 (1)); 894 EXPECT_EQ(705 , message.unpacked_sint32 (1)); 895 EXPECT_EQ(706 , message.unpacked_sint64 (1)); 896 EXPECT_EQ(707 , message.unpacked_fixed32 (1)); 897 EXPECT_EQ(708 , message.unpacked_fixed64 (1)); 898 EXPECT_EQ(709 , message.unpacked_sfixed32(1)); 899 EXPECT_EQ(710 , message.unpacked_sfixed64(1)); 900 EXPECT_EQ(711 , message.unpacked_float (1)); 901 EXPECT_EQ(712 , message.unpacked_double (1)); 902 EXPECT_FALSE( message.unpacked_bool (1)); 903 EXPECT_EQ(unittest::FOREIGN_BAZ, message.unpacked_enum(1)); 904 } 905 906 // ------------------------------------------------------------------- 907 908 void TestUtil::ExpectPackedClear( 909 const unittest::TestPackedTypes& message) { 910 // Packed repeated fields are empty. 911 EXPECT_EQ(0, message.packed_int32_size ()); 912 EXPECT_EQ(0, message.packed_int64_size ()); 913 EXPECT_EQ(0, message.packed_uint32_size ()); 914 EXPECT_EQ(0, message.packed_uint64_size ()); 915 EXPECT_EQ(0, message.packed_sint32_size ()); 916 EXPECT_EQ(0, message.packed_sint64_size ()); 917 EXPECT_EQ(0, message.packed_fixed32_size ()); 918 EXPECT_EQ(0, message.packed_fixed64_size ()); 919 EXPECT_EQ(0, message.packed_sfixed32_size()); 920 EXPECT_EQ(0, message.packed_sfixed64_size()); 921 EXPECT_EQ(0, message.packed_float_size ()); 922 EXPECT_EQ(0, message.packed_double_size ()); 923 EXPECT_EQ(0, message.packed_bool_size ()); 924 EXPECT_EQ(0, message.packed_enum_size ()); 925 } 926 927 // ------------------------------------------------------------------- 928 929 void TestUtil::ExpectPackedFieldsModified( 930 const unittest::TestPackedTypes& message) { 931 // Do the same for packed repeated fields. 932 ASSERT_EQ(2, message.packed_int32_size ()); 933 ASSERT_EQ(2, message.packed_int64_size ()); 934 ASSERT_EQ(2, message.packed_uint32_size ()); 935 ASSERT_EQ(2, message.packed_uint64_size ()); 936 ASSERT_EQ(2, message.packed_sint32_size ()); 937 ASSERT_EQ(2, message.packed_sint64_size ()); 938 ASSERT_EQ(2, message.packed_fixed32_size ()); 939 ASSERT_EQ(2, message.packed_fixed64_size ()); 940 ASSERT_EQ(2, message.packed_sfixed32_size()); 941 ASSERT_EQ(2, message.packed_sfixed64_size()); 942 ASSERT_EQ(2, message.packed_float_size ()); 943 ASSERT_EQ(2, message.packed_double_size ()); 944 ASSERT_EQ(2, message.packed_bool_size ()); 945 ASSERT_EQ(2, message.packed_enum_size ()); 946 947 EXPECT_EQ(601 , message.packed_int32 (0)); 948 EXPECT_EQ(602 , message.packed_int64 (0)); 949 EXPECT_EQ(603 , message.packed_uint32 (0)); 950 EXPECT_EQ(604 , message.packed_uint64 (0)); 951 EXPECT_EQ(605 , message.packed_sint32 (0)); 952 EXPECT_EQ(606 , message.packed_sint64 (0)); 953 EXPECT_EQ(607 , message.packed_fixed32 (0)); 954 EXPECT_EQ(608 , message.packed_fixed64 (0)); 955 EXPECT_EQ(609 , message.packed_sfixed32(0)); 956 EXPECT_EQ(610 , message.packed_sfixed64(0)); 957 EXPECT_EQ(611 , message.packed_float (0)); 958 EXPECT_EQ(612 , message.packed_double (0)); 959 EXPECT_TRUE( message.packed_bool (0)); 960 EXPECT_EQ(unittest::FOREIGN_BAR, message.packed_enum(0)); 961 // Actually verify the second (modified) elements now. 962 EXPECT_EQ(801 , message.packed_int32 (1)); 963 EXPECT_EQ(802 , message.packed_int64 (1)); 964 EXPECT_EQ(803 , message.packed_uint32 (1)); 965 EXPECT_EQ(804 , message.packed_uint64 (1)); 966 EXPECT_EQ(805 , message.packed_sint32 (1)); 967 EXPECT_EQ(806 , message.packed_sint64 (1)); 968 EXPECT_EQ(807 , message.packed_fixed32 (1)); 969 EXPECT_EQ(808 , message.packed_fixed64 (1)); 970 EXPECT_EQ(809 , message.packed_sfixed32(1)); 971 EXPECT_EQ(810 , message.packed_sfixed64(1)); 972 EXPECT_EQ(811 , message.packed_float (1)); 973 EXPECT_EQ(812 , message.packed_double (1)); 974 EXPECT_TRUE( message.packed_bool (1)); 975 EXPECT_EQ(unittest::FOREIGN_FOO, message.packed_enum(1)); 976 } 977 978 // =================================================================== 979 // Extensions 980 // 981 // All this code is exactly equivalent to the above code except that it's 982 // manipulating extension fields instead of normal ones. 983 // 984 // I gave up on the 80-char limit here. Sorry. 985 986 void TestUtil::SetAllExtensions(unittest::TestAllExtensions* message) { 987 message->SetExtension(unittest::optional_int32_extension , 101); 988 message->SetExtension(unittest::optional_int64_extension , 102); 989 message->SetExtension(unittest::optional_uint32_extension , 103); 990 message->SetExtension(unittest::optional_uint64_extension , 104); 991 message->SetExtension(unittest::optional_sint32_extension , 105); 992 message->SetExtension(unittest::optional_sint64_extension , 106); 993 message->SetExtension(unittest::optional_fixed32_extension , 107); 994 message->SetExtension(unittest::optional_fixed64_extension , 108); 995 message->SetExtension(unittest::optional_sfixed32_extension, 109); 996 message->SetExtension(unittest::optional_sfixed64_extension, 110); 997 message->SetExtension(unittest::optional_float_extension , 111); 998 message->SetExtension(unittest::optional_double_extension , 112); 999 message->SetExtension(unittest::optional_bool_extension , true); 1000 message->SetExtension(unittest::optional_string_extension , "115"); 1001 message->SetExtension(unittest::optional_bytes_extension , "116"); 1002 1003 message->MutableExtension(unittest::optionalgroup_extension )->set_a(117); 1004 message->MutableExtension(unittest::optional_nested_message_extension )->set_bb(118); 1005 message->MutableExtension(unittest::optional_foreign_message_extension)->set_c(119); 1006 message->MutableExtension(unittest::optional_import_message_extension )->set_d(120); 1007 1008 message->SetExtension(unittest::optional_nested_enum_extension , unittest::TestAllTypes::BAZ); 1009 message->SetExtension(unittest::optional_foreign_enum_extension, unittest::FOREIGN_BAZ ); 1010 message->SetExtension(unittest::optional_import_enum_extension , unittest_import::IMPORT_BAZ); 1011 1012 message->SetExtension(unittest::optional_string_piece_extension, "124"); 1013 message->SetExtension(unittest::optional_cord_extension, "125"); 1014 1015 message->MutableExtension(unittest::optional_public_import_message_extension)->set_e(126); 1016 message->MutableExtension(unittest::optional_lazy_message_extension)->set_bb(127); 1017 1018 // ----------------------------------------------------------------- 1019 1020 message->AddExtension(unittest::repeated_int32_extension , 201); 1021 message->AddExtension(unittest::repeated_int64_extension , 202); 1022 message->AddExtension(unittest::repeated_uint32_extension , 203); 1023 message->AddExtension(unittest::repeated_uint64_extension , 204); 1024 message->AddExtension(unittest::repeated_sint32_extension , 205); 1025 message->AddExtension(unittest::repeated_sint64_extension , 206); 1026 message->AddExtension(unittest::repeated_fixed32_extension , 207); 1027 message->AddExtension(unittest::repeated_fixed64_extension , 208); 1028 message->AddExtension(unittest::repeated_sfixed32_extension, 209); 1029 message->AddExtension(unittest::repeated_sfixed64_extension, 210); 1030 message->AddExtension(unittest::repeated_float_extension , 211); 1031 message->AddExtension(unittest::repeated_double_extension , 212); 1032 message->AddExtension(unittest::repeated_bool_extension , true); 1033 message->AddExtension(unittest::repeated_string_extension , "215"); 1034 message->AddExtension(unittest::repeated_bytes_extension , "216"); 1035 1036 message->AddExtension(unittest::repeatedgroup_extension )->set_a(217); 1037 message->AddExtension(unittest::repeated_nested_message_extension )->set_bb(218); 1038 message->AddExtension(unittest::repeated_foreign_message_extension)->set_c(219); 1039 message->AddExtension(unittest::repeated_import_message_extension )->set_d(220); 1040 message->AddExtension(unittest::repeated_lazy_message_extension )->set_bb(227); 1041 1042 message->AddExtension(unittest::repeated_nested_enum_extension , unittest::TestAllTypes::BAR); 1043 message->AddExtension(unittest::repeated_foreign_enum_extension, unittest::FOREIGN_BAR ); 1044 message->AddExtension(unittest::repeated_import_enum_extension , unittest_import::IMPORT_BAR); 1045 1046 message->AddExtension(unittest::repeated_string_piece_extension, "224"); 1047 message->AddExtension(unittest::repeated_cord_extension, "225"); 1048 1049 // Add a second one of each field. 1050 message->AddExtension(unittest::repeated_int32_extension , 301); 1051 message->AddExtension(unittest::repeated_int64_extension , 302); 1052 message->AddExtension(unittest::repeated_uint32_extension , 303); 1053 message->AddExtension(unittest::repeated_uint64_extension , 304); 1054 message->AddExtension(unittest::repeated_sint32_extension , 305); 1055 message->AddExtension(unittest::repeated_sint64_extension , 306); 1056 message->AddExtension(unittest::repeated_fixed32_extension , 307); 1057 message->AddExtension(unittest::repeated_fixed64_extension , 308); 1058 message->AddExtension(unittest::repeated_sfixed32_extension, 309); 1059 message->AddExtension(unittest::repeated_sfixed64_extension, 310); 1060 message->AddExtension(unittest::repeated_float_extension , 311); 1061 message->AddExtension(unittest::repeated_double_extension , 312); 1062 message->AddExtension(unittest::repeated_bool_extension , false); 1063 message->AddExtension(unittest::repeated_string_extension , "315"); 1064 message->AddExtension(unittest::repeated_bytes_extension , "316"); 1065 1066 message->AddExtension(unittest::repeatedgroup_extension )->set_a(317); 1067 message->AddExtension(unittest::repeated_nested_message_extension )->set_bb(318); 1068 message->AddExtension(unittest::repeated_foreign_message_extension)->set_c(319); 1069 message->AddExtension(unittest::repeated_import_message_extension )->set_d(320); 1070 message->AddExtension(unittest::repeated_lazy_message_extension )->set_bb(327); 1071 1072 message->AddExtension(unittest::repeated_nested_enum_extension , unittest::TestAllTypes::BAZ); 1073 message->AddExtension(unittest::repeated_foreign_enum_extension, unittest::FOREIGN_BAZ ); 1074 message->AddExtension(unittest::repeated_import_enum_extension , unittest_import::IMPORT_BAZ); 1075 1076 message->AddExtension(unittest::repeated_string_piece_extension, "324"); 1077 message->AddExtension(unittest::repeated_cord_extension, "325"); 1078 1079 // ----------------------------------------------------------------- 1080 1081 message->SetExtension(unittest::default_int32_extension , 401); 1082 message->SetExtension(unittest::default_int64_extension , 402); 1083 message->SetExtension(unittest::default_uint32_extension , 403); 1084 message->SetExtension(unittest::default_uint64_extension , 404); 1085 message->SetExtension(unittest::default_sint32_extension , 405); 1086 message->SetExtension(unittest::default_sint64_extension , 406); 1087 message->SetExtension(unittest::default_fixed32_extension , 407); 1088 message->SetExtension(unittest::default_fixed64_extension , 408); 1089 message->SetExtension(unittest::default_sfixed32_extension, 409); 1090 message->SetExtension(unittest::default_sfixed64_extension, 410); 1091 message->SetExtension(unittest::default_float_extension , 411); 1092 message->SetExtension(unittest::default_double_extension , 412); 1093 message->SetExtension(unittest::default_bool_extension , false); 1094 message->SetExtension(unittest::default_string_extension , "415"); 1095 message->SetExtension(unittest::default_bytes_extension , "416"); 1096 1097 message->SetExtension(unittest::default_nested_enum_extension , unittest::TestAllTypes::FOO); 1098 message->SetExtension(unittest::default_foreign_enum_extension, unittest::FOREIGN_FOO ); 1099 message->SetExtension(unittest::default_import_enum_extension , unittest_import::IMPORT_FOO); 1100 1101 message->SetExtension(unittest::default_string_piece_extension, "424"); 1102 message->SetExtension(unittest::default_cord_extension, "425"); 1103 1104 SetOneofFields(message); 1105 } 1106 1107 void TestUtil::SetOneofFields(unittest::TestAllExtensions* message) { 1108 message->SetExtension(unittest::oneof_uint32_extension, 601); 1109 message->MutableExtension(unittest::oneof_nested_message_extension)->set_bb(602); 1110 message->SetExtension(unittest::oneof_string_extension, "603"); 1111 message->SetExtension(unittest::oneof_bytes_extension, "604"); 1112 } 1113 1114 // ------------------------------------------------------------------- 1115 1116 void TestUtil::SetAllFieldsAndExtensions( 1117 unittest::TestFieldOrderings* message) { 1118 GOOGLE_CHECK(message); 1119 message->set_my_int(1); 1120 message->set_my_string("foo"); 1121 message->set_my_float(1.0); 1122 message->SetExtension(unittest::my_extension_int, 23); 1123 message->SetExtension(unittest::my_extension_string, "bar"); 1124 } 1125 1126 // ------------------------------------------------------------------- 1127 1128 void TestUtil::ModifyRepeatedExtensions(unittest::TestAllExtensions* message) { 1129 message->SetExtension(unittest::repeated_int32_extension , 1, 501); 1130 message->SetExtension(unittest::repeated_int64_extension , 1, 502); 1131 message->SetExtension(unittest::repeated_uint32_extension , 1, 503); 1132 message->SetExtension(unittest::repeated_uint64_extension , 1, 504); 1133 message->SetExtension(unittest::repeated_sint32_extension , 1, 505); 1134 message->SetExtension(unittest::repeated_sint64_extension , 1, 506); 1135 message->SetExtension(unittest::repeated_fixed32_extension , 1, 507); 1136 message->SetExtension(unittest::repeated_fixed64_extension , 1, 508); 1137 message->SetExtension(unittest::repeated_sfixed32_extension, 1, 509); 1138 message->SetExtension(unittest::repeated_sfixed64_extension, 1, 510); 1139 message->SetExtension(unittest::repeated_float_extension , 1, 511); 1140 message->SetExtension(unittest::repeated_double_extension , 1, 512); 1141 message->SetExtension(unittest::repeated_bool_extension , 1, true); 1142 message->SetExtension(unittest::repeated_string_extension , 1, "515"); 1143 message->SetExtension(unittest::repeated_bytes_extension , 1, "516"); 1144 1145 message->MutableExtension(unittest::repeatedgroup_extension , 1)->set_a(517); 1146 message->MutableExtension(unittest::repeated_nested_message_extension , 1)->set_bb(518); 1147 message->MutableExtension(unittest::repeated_foreign_message_extension, 1)->set_c(519); 1148 message->MutableExtension(unittest::repeated_import_message_extension , 1)->set_d(520); 1149 message->MutableExtension(unittest::repeated_lazy_message_extension , 1)->set_bb(527); 1150 1151 message->SetExtension(unittest::repeated_nested_enum_extension , 1, unittest::TestAllTypes::FOO); 1152 message->SetExtension(unittest::repeated_foreign_enum_extension, 1, unittest::FOREIGN_FOO ); 1153 message->SetExtension(unittest::repeated_import_enum_extension , 1, unittest_import::IMPORT_FOO); 1154 1155 message->SetExtension(unittest::repeated_string_piece_extension, 1, "524"); 1156 message->SetExtension(unittest::repeated_cord_extension, 1, "525"); 1157 } 1158 1159 // ------------------------------------------------------------------- 1160 1161 void TestUtil::ExpectAllExtensionsSet( 1162 const unittest::TestAllExtensions& message) { 1163 EXPECT_TRUE(message.HasExtension(unittest::optional_int32_extension )); 1164 EXPECT_TRUE(message.HasExtension(unittest::optional_int64_extension )); 1165 EXPECT_TRUE(message.HasExtension(unittest::optional_uint32_extension )); 1166 EXPECT_TRUE(message.HasExtension(unittest::optional_uint64_extension )); 1167 EXPECT_TRUE(message.HasExtension(unittest::optional_sint32_extension )); 1168 EXPECT_TRUE(message.HasExtension(unittest::optional_sint64_extension )); 1169 EXPECT_TRUE(message.HasExtension(unittest::optional_fixed32_extension )); 1170 EXPECT_TRUE(message.HasExtension(unittest::optional_fixed64_extension )); 1171 EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed32_extension)); 1172 EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed64_extension)); 1173 EXPECT_TRUE(message.HasExtension(unittest::optional_float_extension )); 1174 EXPECT_TRUE(message.HasExtension(unittest::optional_double_extension )); 1175 EXPECT_TRUE(message.HasExtension(unittest::optional_bool_extension )); 1176 EXPECT_TRUE(message.HasExtension(unittest::optional_string_extension )); 1177 EXPECT_TRUE(message.HasExtension(unittest::optional_bytes_extension )); 1178 1179 EXPECT_TRUE(message.HasExtension(unittest::optionalgroup_extension )); 1180 EXPECT_TRUE(message.HasExtension(unittest::optional_nested_message_extension )); 1181 EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_message_extension )); 1182 EXPECT_TRUE(message.HasExtension(unittest::optional_import_message_extension )); 1183 EXPECT_TRUE(message.HasExtension(unittest::optional_public_import_message_extension)); 1184 EXPECT_TRUE(message.HasExtension(unittest::optional_lazy_message_extension )); 1185 1186 EXPECT_TRUE(message.GetExtension(unittest::optionalgroup_extension ).has_a()); 1187 EXPECT_TRUE(message.GetExtension(unittest::optional_nested_message_extension ).has_bb()); 1188 EXPECT_TRUE(message.GetExtension(unittest::optional_foreign_message_extension ).has_c()); 1189 EXPECT_TRUE(message.GetExtension(unittest::optional_import_message_extension ).has_d()); 1190 EXPECT_TRUE(message.GetExtension(unittest::optional_public_import_message_extension).has_e()); 1191 EXPECT_TRUE(message.GetExtension(unittest::optional_lazy_message_extension ).has_bb()); 1192 1193 EXPECT_TRUE(message.HasExtension(unittest::optional_nested_enum_extension )); 1194 EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_enum_extension)); 1195 EXPECT_TRUE(message.HasExtension(unittest::optional_import_enum_extension )); 1196 1197 EXPECT_TRUE(message.HasExtension(unittest::optional_string_piece_extension)); 1198 EXPECT_TRUE(message.HasExtension(unittest::optional_cord_extension)); 1199 1200 EXPECT_EQ(101 , message.GetExtension(unittest::optional_int32_extension )); 1201 EXPECT_EQ(102 , message.GetExtension(unittest::optional_int64_extension )); 1202 EXPECT_EQ(103 , message.GetExtension(unittest::optional_uint32_extension )); 1203 EXPECT_EQ(104 , message.GetExtension(unittest::optional_uint64_extension )); 1204 EXPECT_EQ(105 , message.GetExtension(unittest::optional_sint32_extension )); 1205 EXPECT_EQ(106 , message.GetExtension(unittest::optional_sint64_extension )); 1206 EXPECT_EQ(107 , message.GetExtension(unittest::optional_fixed32_extension )); 1207 EXPECT_EQ(108 , message.GetExtension(unittest::optional_fixed64_extension )); 1208 EXPECT_EQ(109 , message.GetExtension(unittest::optional_sfixed32_extension)); 1209 EXPECT_EQ(110 , message.GetExtension(unittest::optional_sfixed64_extension)); 1210 EXPECT_EQ(111 , message.GetExtension(unittest::optional_float_extension )); 1211 EXPECT_EQ(112 , message.GetExtension(unittest::optional_double_extension )); 1212 EXPECT_TRUE( message.GetExtension(unittest::optional_bool_extension )); 1213 EXPECT_EQ("115", message.GetExtension(unittest::optional_string_extension )); 1214 EXPECT_EQ("116", message.GetExtension(unittest::optional_bytes_extension )); 1215 1216 EXPECT_EQ(117, message.GetExtension(unittest::optionalgroup_extension ).a()); 1217 EXPECT_EQ(118, message.GetExtension(unittest::optional_nested_message_extension ).bb()); 1218 EXPECT_EQ(119, message.GetExtension(unittest::optional_foreign_message_extension).c()); 1219 EXPECT_EQ(120, message.GetExtension(unittest::optional_import_message_extension ).d()); 1220 1221 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.GetExtension(unittest::optional_nested_enum_extension )); 1222 EXPECT_EQ(unittest::FOREIGN_BAZ , message.GetExtension(unittest::optional_foreign_enum_extension)); 1223 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.GetExtension(unittest::optional_import_enum_extension )); 1224 1225 EXPECT_EQ("124", message.GetExtension(unittest::optional_string_piece_extension)); 1226 EXPECT_EQ("125", message.GetExtension(unittest::optional_cord_extension)); 1227 EXPECT_EQ(126, message.GetExtension(unittest::optional_public_import_message_extension ).e()); 1228 EXPECT_EQ(127, message.GetExtension(unittest::optional_lazy_message_extension).bb()); 1229 1230 // ----------------------------------------------------------------- 1231 1232 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension )); 1233 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension )); 1234 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension )); 1235 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension )); 1236 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension )); 1237 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension )); 1238 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension )); 1239 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension )); 1240 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension)); 1241 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension)); 1242 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension )); 1243 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension )); 1244 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension )); 1245 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension )); 1246 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension )); 1247 1248 ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension )); 1249 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension )); 1250 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension)); 1251 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension )); 1252 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension )); 1253 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension )); 1254 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); 1255 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension )); 1256 1257 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_piece_extension)); 1258 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_cord_extension)); 1259 1260 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension , 0)); 1261 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension , 0)); 1262 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension , 0)); 1263 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension , 0)); 1264 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension , 0)); 1265 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension , 0)); 1266 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension , 0)); 1267 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension , 0)); 1268 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension, 0)); 1269 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 0)); 1270 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 0)); 1271 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 0)); 1272 EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 0)); 1273 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 0)); 1274 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 0)); 1275 1276 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 0).a()); 1277 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); 1278 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); 1279 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); 1280 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb()); 1281 1282 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 0)); 1283 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 0)); 1284 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 0)); 1285 1286 EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 0)); 1287 EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 0)); 1288 1289 EXPECT_EQ(301 , message.GetExtension(unittest::repeated_int32_extension , 1)); 1290 EXPECT_EQ(302 , message.GetExtension(unittest::repeated_int64_extension , 1)); 1291 EXPECT_EQ(303 , message.GetExtension(unittest::repeated_uint32_extension , 1)); 1292 EXPECT_EQ(304 , message.GetExtension(unittest::repeated_uint64_extension , 1)); 1293 EXPECT_EQ(305 , message.GetExtension(unittest::repeated_sint32_extension , 1)); 1294 EXPECT_EQ(306 , message.GetExtension(unittest::repeated_sint64_extension , 1)); 1295 EXPECT_EQ(307 , message.GetExtension(unittest::repeated_fixed32_extension , 1)); 1296 EXPECT_EQ(308 , message.GetExtension(unittest::repeated_fixed64_extension , 1)); 1297 EXPECT_EQ(309 , message.GetExtension(unittest::repeated_sfixed32_extension, 1)); 1298 EXPECT_EQ(310 , message.GetExtension(unittest::repeated_sfixed64_extension, 1)); 1299 EXPECT_EQ(311 , message.GetExtension(unittest::repeated_float_extension , 1)); 1300 EXPECT_EQ(312 , message.GetExtension(unittest::repeated_double_extension , 1)); 1301 EXPECT_FALSE( message.GetExtension(unittest::repeated_bool_extension , 1)); 1302 EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension , 1)); 1303 EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension , 1)); 1304 1305 EXPECT_EQ(317, message.GetExtension(unittest::repeatedgroup_extension , 1).a()); 1306 EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension , 1).bb()); 1307 EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension, 1).c()); 1308 EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension , 1).d()); 1309 EXPECT_EQ(327, message.GetExtension(unittest::repeated_lazy_message_extension , 1).bb()); 1310 1311 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.GetExtension(unittest::repeated_nested_enum_extension , 1)); 1312 EXPECT_EQ(unittest::FOREIGN_BAZ , message.GetExtension(unittest::repeated_foreign_enum_extension, 1)); 1313 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.GetExtension(unittest::repeated_import_enum_extension , 1)); 1314 1315 EXPECT_EQ("324", message.GetExtension(unittest::repeated_string_piece_extension, 1)); 1316 EXPECT_EQ("325", message.GetExtension(unittest::repeated_cord_extension, 1)); 1317 1318 // ----------------------------------------------------------------- 1319 1320 EXPECT_TRUE(message.HasExtension(unittest::default_int32_extension )); 1321 EXPECT_TRUE(message.HasExtension(unittest::default_int64_extension )); 1322 EXPECT_TRUE(message.HasExtension(unittest::default_uint32_extension )); 1323 EXPECT_TRUE(message.HasExtension(unittest::default_uint64_extension )); 1324 EXPECT_TRUE(message.HasExtension(unittest::default_sint32_extension )); 1325 EXPECT_TRUE(message.HasExtension(unittest::default_sint64_extension )); 1326 EXPECT_TRUE(message.HasExtension(unittest::default_fixed32_extension )); 1327 EXPECT_TRUE(message.HasExtension(unittest::default_fixed64_extension )); 1328 EXPECT_TRUE(message.HasExtension(unittest::default_sfixed32_extension)); 1329 EXPECT_TRUE(message.HasExtension(unittest::default_sfixed64_extension)); 1330 EXPECT_TRUE(message.HasExtension(unittest::default_float_extension )); 1331 EXPECT_TRUE(message.HasExtension(unittest::default_double_extension )); 1332 EXPECT_TRUE(message.HasExtension(unittest::default_bool_extension )); 1333 EXPECT_TRUE(message.HasExtension(unittest::default_string_extension )); 1334 EXPECT_TRUE(message.HasExtension(unittest::default_bytes_extension )); 1335 1336 EXPECT_TRUE(message.HasExtension(unittest::default_nested_enum_extension )); 1337 EXPECT_TRUE(message.HasExtension(unittest::default_foreign_enum_extension)); 1338 EXPECT_TRUE(message.HasExtension(unittest::default_import_enum_extension )); 1339 1340 EXPECT_TRUE(message.HasExtension(unittest::default_string_piece_extension)); 1341 EXPECT_TRUE(message.HasExtension(unittest::default_cord_extension)); 1342 1343 EXPECT_EQ(401 , message.GetExtension(unittest::default_int32_extension )); 1344 EXPECT_EQ(402 , message.GetExtension(unittest::default_int64_extension )); 1345 EXPECT_EQ(403 , message.GetExtension(unittest::default_uint32_extension )); 1346 EXPECT_EQ(404 , message.GetExtension(unittest::default_uint64_extension )); 1347 EXPECT_EQ(405 , message.GetExtension(unittest::default_sint32_extension )); 1348 EXPECT_EQ(406 , message.GetExtension(unittest::default_sint64_extension )); 1349 EXPECT_EQ(407 , message.GetExtension(unittest::default_fixed32_extension )); 1350 EXPECT_EQ(408 , message.GetExtension(unittest::default_fixed64_extension )); 1351 EXPECT_EQ(409 , message.GetExtension(unittest::default_sfixed32_extension)); 1352 EXPECT_EQ(410 , message.GetExtension(unittest::default_sfixed64_extension)); 1353 EXPECT_EQ(411 , message.GetExtension(unittest::default_float_extension )); 1354 EXPECT_EQ(412 , message.GetExtension(unittest::default_double_extension )); 1355 EXPECT_FALSE( message.GetExtension(unittest::default_bool_extension )); 1356 EXPECT_EQ("415", message.GetExtension(unittest::default_string_extension )); 1357 EXPECT_EQ("416", message.GetExtension(unittest::default_bytes_extension )); 1358 1359 EXPECT_EQ(unittest::TestAllTypes::FOO, message.GetExtension(unittest::default_nested_enum_extension )); 1360 EXPECT_EQ(unittest::FOREIGN_FOO , message.GetExtension(unittest::default_foreign_enum_extension)); 1361 EXPECT_EQ(unittest_import::IMPORT_FOO, message.GetExtension(unittest::default_import_enum_extension )); 1362 1363 EXPECT_EQ("424", message.GetExtension(unittest::default_string_piece_extension)); 1364 EXPECT_EQ("425", message.GetExtension(unittest::default_cord_extension)); 1365 1366 EXPECT_TRUE(message.HasExtension(unittest::oneof_uint32_extension)); 1367 EXPECT_TRUE(message.GetExtension(unittest::oneof_nested_message_extension).has_bb()); 1368 EXPECT_TRUE(message.HasExtension(unittest::oneof_string_extension)); 1369 EXPECT_TRUE(message.HasExtension(unittest::oneof_bytes_extension)); 1370 1371 EXPECT_EQ(601, message.GetExtension(unittest::oneof_uint32_extension)); 1372 EXPECT_EQ(602, message.GetExtension(unittest::oneof_nested_message_extension).bb()); 1373 EXPECT_EQ("603", message.GetExtension(unittest::oneof_string_extension)); 1374 EXPECT_EQ("604", message.GetExtension(unittest::oneof_bytes_extension)); 1375 } 1376 1377 // ------------------------------------------------------------------- 1378 1379 void TestUtil::ExpectExtensionsClear( 1380 const unittest::TestAllExtensions& message) { 1381 string serialized; 1382 ASSERT_TRUE(message.SerializeToString(&serialized)); 1383 EXPECT_EQ("", serialized); 1384 EXPECT_EQ(0, message.ByteSize()); 1385 1386 // has_blah() should initially be false for all optional fields. 1387 EXPECT_FALSE(message.HasExtension(unittest::optional_int32_extension )); 1388 EXPECT_FALSE(message.HasExtension(unittest::optional_int64_extension )); 1389 EXPECT_FALSE(message.HasExtension(unittest::optional_uint32_extension )); 1390 EXPECT_FALSE(message.HasExtension(unittest::optional_uint64_extension )); 1391 EXPECT_FALSE(message.HasExtension(unittest::optional_sint32_extension )); 1392 EXPECT_FALSE(message.HasExtension(unittest::optional_sint64_extension )); 1393 EXPECT_FALSE(message.HasExtension(unittest::optional_fixed32_extension )); 1394 EXPECT_FALSE(message.HasExtension(unittest::optional_fixed64_extension )); 1395 EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed32_extension)); 1396 EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed64_extension)); 1397 EXPECT_FALSE(message.HasExtension(unittest::optional_float_extension )); 1398 EXPECT_FALSE(message.HasExtension(unittest::optional_double_extension )); 1399 EXPECT_FALSE(message.HasExtension(unittest::optional_bool_extension )); 1400 EXPECT_FALSE(message.HasExtension(unittest::optional_string_extension )); 1401 EXPECT_FALSE(message.HasExtension(unittest::optional_bytes_extension )); 1402 1403 EXPECT_FALSE(message.HasExtension(unittest::optionalgroup_extension )); 1404 EXPECT_FALSE(message.HasExtension(unittest::optional_nested_message_extension )); 1405 EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_message_extension )); 1406 EXPECT_FALSE(message.HasExtension(unittest::optional_import_message_extension )); 1407 EXPECT_FALSE(message.HasExtension(unittest::optional_public_import_message_extension)); 1408 EXPECT_FALSE(message.HasExtension(unittest::optional_lazy_message_extension )); 1409 1410 EXPECT_FALSE(message.HasExtension(unittest::optional_nested_enum_extension )); 1411 EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_enum_extension)); 1412 EXPECT_FALSE(message.HasExtension(unittest::optional_import_enum_extension )); 1413 1414 EXPECT_FALSE(message.HasExtension(unittest::optional_string_piece_extension)); 1415 EXPECT_FALSE(message.HasExtension(unittest::optional_cord_extension)); 1416 1417 // Optional fields without defaults are set to zero or something like it. 1418 EXPECT_EQ(0 , message.GetExtension(unittest::optional_int32_extension )); 1419 EXPECT_EQ(0 , message.GetExtension(unittest::optional_int64_extension )); 1420 EXPECT_EQ(0 , message.GetExtension(unittest::optional_uint32_extension )); 1421 EXPECT_EQ(0 , message.GetExtension(unittest::optional_uint64_extension )); 1422 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sint32_extension )); 1423 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sint64_extension )); 1424 EXPECT_EQ(0 , message.GetExtension(unittest::optional_fixed32_extension )); 1425 EXPECT_EQ(0 , message.GetExtension(unittest::optional_fixed64_extension )); 1426 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sfixed32_extension)); 1427 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sfixed64_extension)); 1428 EXPECT_EQ(0 , message.GetExtension(unittest::optional_float_extension )); 1429 EXPECT_EQ(0 , message.GetExtension(unittest::optional_double_extension )); 1430 EXPECT_FALSE( message.GetExtension(unittest::optional_bool_extension )); 1431 EXPECT_EQ("" , message.GetExtension(unittest::optional_string_extension )); 1432 EXPECT_EQ("" , message.GetExtension(unittest::optional_bytes_extension )); 1433 1434 // Embedded messages should also be clear. 1435 EXPECT_FALSE(message.GetExtension(unittest::optionalgroup_extension ).has_a()); 1436 EXPECT_FALSE(message.GetExtension(unittest::optional_nested_message_extension ).has_bb()); 1437 EXPECT_FALSE(message.GetExtension(unittest::optional_foreign_message_extension ).has_c()); 1438 EXPECT_FALSE(message.GetExtension(unittest::optional_import_message_extension ).has_d()); 1439 EXPECT_FALSE(message.GetExtension(unittest::optional_public_import_message_extension).has_e()); 1440 EXPECT_FALSE(message.GetExtension(unittest::optional_lazy_message_extension ).has_bb()); 1441 1442 EXPECT_EQ(0, message.GetExtension(unittest::optionalgroup_extension ).a()); 1443 EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension ).bb()); 1444 EXPECT_EQ(0, message.GetExtension(unittest::optional_foreign_message_extension ).c()); 1445 EXPECT_EQ(0, message.GetExtension(unittest::optional_import_message_extension ).d()); 1446 EXPECT_EQ(0, message.GetExtension(unittest::optional_public_import_message_extension).e()); 1447 EXPECT_EQ(0, message.GetExtension(unittest::optional_lazy_message_extension ).bb()); 1448 1449 // Enums without defaults are set to the first value in the enum. 1450 EXPECT_EQ(unittest::TestAllTypes::FOO, message.GetExtension(unittest::optional_nested_enum_extension )); 1451 EXPECT_EQ(unittest::FOREIGN_FOO , message.GetExtension(unittest::optional_foreign_enum_extension)); 1452 EXPECT_EQ(unittest_import::IMPORT_FOO, message.GetExtension(unittest::optional_import_enum_extension )); 1453 1454 EXPECT_EQ("", message.GetExtension(unittest::optional_string_piece_extension)); 1455 EXPECT_EQ("", message.GetExtension(unittest::optional_cord_extension)); 1456 1457 // Repeated fields are empty. 1458 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int32_extension )); 1459 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int64_extension )); 1460 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint32_extension )); 1461 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint64_extension )); 1462 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint32_extension )); 1463 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint64_extension )); 1464 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed32_extension )); 1465 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed64_extension )); 1466 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed32_extension)); 1467 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed64_extension)); 1468 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_float_extension )); 1469 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_double_extension )); 1470 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bool_extension )); 1471 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_extension )); 1472 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bytes_extension )); 1473 1474 EXPECT_EQ(0, message.ExtensionSize(unittest::repeatedgroup_extension )); 1475 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_message_extension )); 1476 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_message_extension)); 1477 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_message_extension )); 1478 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_lazy_message_extension )); 1479 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_enum_extension )); 1480 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); 1481 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_enum_extension )); 1482 1483 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_piece_extension)); 1484 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_cord_extension)); 1485 1486 // has_blah() should also be false for all default fields. 1487 EXPECT_FALSE(message.HasExtension(unittest::default_int32_extension )); 1488 EXPECT_FALSE(message.HasExtension(unittest::default_int64_extension )); 1489 EXPECT_FALSE(message.HasExtension(unittest::default_uint32_extension )); 1490 EXPECT_FALSE(message.HasExtension(unittest::default_uint64_extension )); 1491 EXPECT_FALSE(message.HasExtension(unittest::default_sint32_extension )); 1492 EXPECT_FALSE(message.HasExtension(unittest::default_sint64_extension )); 1493 EXPECT_FALSE(message.HasExtension(unittest::default_fixed32_extension )); 1494 EXPECT_FALSE(message.HasExtension(unittest::default_fixed64_extension )); 1495 EXPECT_FALSE(message.HasExtension(unittest::default_sfixed32_extension)); 1496 EXPECT_FALSE(message.HasExtension(unittest::default_sfixed64_extension)); 1497 EXPECT_FALSE(message.HasExtension(unittest::default_float_extension )); 1498 EXPECT_FALSE(message.HasExtension(unittest::default_double_extension )); 1499 EXPECT_FALSE(message.HasExtension(unittest::default_bool_extension )); 1500 EXPECT_FALSE(message.HasExtension(unittest::default_string_extension )); 1501 EXPECT_FALSE(message.HasExtension(unittest::default_bytes_extension )); 1502 1503 EXPECT_FALSE(message.HasExtension(unittest::default_nested_enum_extension )); 1504 EXPECT_FALSE(message.HasExtension(unittest::default_foreign_enum_extension)); 1505 EXPECT_FALSE(message.HasExtension(unittest::default_import_enum_extension )); 1506 1507 EXPECT_FALSE(message.HasExtension(unittest::default_string_piece_extension)); 1508 EXPECT_FALSE(message.HasExtension(unittest::default_cord_extension)); 1509 1510 // Fields with defaults have their default values (duh). 1511 EXPECT_EQ( 41 , message.GetExtension(unittest::default_int32_extension )); 1512 EXPECT_EQ( 42 , message.GetExtension(unittest::default_int64_extension )); 1513 EXPECT_EQ( 43 , message.GetExtension(unittest::default_uint32_extension )); 1514 EXPECT_EQ( 44 , message.GetExtension(unittest::default_uint64_extension )); 1515 EXPECT_EQ(-45 , message.GetExtension(unittest::default_sint32_extension )); 1516 EXPECT_EQ( 46 , message.GetExtension(unittest::default_sint64_extension )); 1517 EXPECT_EQ( 47 , message.GetExtension(unittest::default_fixed32_extension )); 1518 EXPECT_EQ( 48 , message.GetExtension(unittest::default_fixed64_extension )); 1519 EXPECT_EQ( 49 , message.GetExtension(unittest::default_sfixed32_extension)); 1520 EXPECT_EQ(-50 , message.GetExtension(unittest::default_sfixed64_extension)); 1521 EXPECT_EQ( 51.5 , message.GetExtension(unittest::default_float_extension )); 1522 EXPECT_EQ( 52e3 , message.GetExtension(unittest::default_double_extension )); 1523 EXPECT_TRUE( message.GetExtension(unittest::default_bool_extension )); 1524 EXPECT_EQ("hello", message.GetExtension(unittest::default_string_extension )); 1525 EXPECT_EQ("world", message.GetExtension(unittest::default_bytes_extension )); 1526 1527 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::default_nested_enum_extension )); 1528 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::default_foreign_enum_extension)); 1529 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::default_import_enum_extension )); 1530 1531 EXPECT_EQ("abc", message.GetExtension(unittest::default_string_piece_extension)); 1532 EXPECT_EQ("123", message.GetExtension(unittest::default_cord_extension)); 1533 1534 EXPECT_FALSE(message.HasExtension(unittest::oneof_uint32_extension)); 1535 EXPECT_FALSE(message.GetExtension(unittest::oneof_nested_message_extension).has_bb()); 1536 EXPECT_FALSE(message.HasExtension(unittest::oneof_string_extension)); 1537 EXPECT_FALSE(message.HasExtension(unittest::oneof_bytes_extension)); 1538 } 1539 1540 // ------------------------------------------------------------------- 1541 1542 void TestUtil::ExpectRepeatedExtensionsModified( 1543 const unittest::TestAllExtensions& message) { 1544 // ModifyRepeatedFields only sets the second repeated element of each 1545 // field. In addition to verifying this, we also verify that the first 1546 // element and size were *not* modified. 1547 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension )); 1548 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension )); 1549 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension )); 1550 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension )); 1551 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension )); 1552 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension )); 1553 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension )); 1554 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension )); 1555 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension)); 1556 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension)); 1557 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension )); 1558 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension )); 1559 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension )); 1560 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension )); 1561 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension )); 1562 1563 ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension )); 1564 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension )); 1565 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension)); 1566 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension )); 1567 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension )); 1568 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension )); 1569 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); 1570 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension )); 1571 1572 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_piece_extension)); 1573 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_cord_extension)); 1574 1575 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension , 0)); 1576 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension , 0)); 1577 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension , 0)); 1578 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension , 0)); 1579 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension , 0)); 1580 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension , 0)); 1581 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension , 0)); 1582 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension , 0)); 1583 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension, 0)); 1584 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 0)); 1585 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 0)); 1586 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 0)); 1587 EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 0)); 1588 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 0)); 1589 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 0)); 1590 1591 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 0).a()); 1592 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); 1593 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); 1594 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); 1595 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb()); 1596 1597 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 0)); 1598 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 0)); 1599 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 0)); 1600 1601 EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 0)); 1602 EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 0)); 1603 1604 // Actually verify the second (modified) elements now. 1605 EXPECT_EQ(501 , message.GetExtension(unittest::repeated_int32_extension , 1)); 1606 EXPECT_EQ(502 , message.GetExtension(unittest::repeated_int64_extension , 1)); 1607 EXPECT_EQ(503 , message.GetExtension(unittest::repeated_uint32_extension , 1)); 1608 EXPECT_EQ(504 , message.GetExtension(unittest::repeated_uint64_extension , 1)); 1609 EXPECT_EQ(505 , message.GetExtension(unittest::repeated_sint32_extension , 1)); 1610 EXPECT_EQ(506 , message.GetExtension(unittest::repeated_sint64_extension , 1)); 1611 EXPECT_EQ(507 , message.GetExtension(unittest::repeated_fixed32_extension , 1)); 1612 EXPECT_EQ(508 , message.GetExtension(unittest::repeated_fixed64_extension , 1)); 1613 EXPECT_EQ(509 , message.GetExtension(unittest::repeated_sfixed32_extension, 1)); 1614 EXPECT_EQ(510 , message.GetExtension(unittest::repeated_sfixed64_extension, 1)); 1615 EXPECT_EQ(511 , message.GetExtension(unittest::repeated_float_extension , 1)); 1616 EXPECT_EQ(512 , message.GetExtension(unittest::repeated_double_extension , 1)); 1617 EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 1)); 1618 EXPECT_EQ("515", message.GetExtension(unittest::repeated_string_extension , 1)); 1619 EXPECT_EQ("516", message.GetExtension(unittest::repeated_bytes_extension , 1)); 1620 1621 EXPECT_EQ(517, message.GetExtension(unittest::repeatedgroup_extension , 1).a()); 1622 EXPECT_EQ(518, message.GetExtension(unittest::repeated_nested_message_extension , 1).bb()); 1623 EXPECT_EQ(519, message.GetExtension(unittest::repeated_foreign_message_extension, 1).c()); 1624 EXPECT_EQ(520, message.GetExtension(unittest::repeated_import_message_extension , 1).d()); 1625 EXPECT_EQ(527, message.GetExtension(unittest::repeated_lazy_message_extension , 1).bb()); 1626 1627 EXPECT_EQ(unittest::TestAllTypes::FOO, message.GetExtension(unittest::repeated_nested_enum_extension , 1)); 1628 EXPECT_EQ(unittest::FOREIGN_FOO , message.GetExtension(unittest::repeated_foreign_enum_extension, 1)); 1629 EXPECT_EQ(unittest_import::IMPORT_FOO, message.GetExtension(unittest::repeated_import_enum_extension , 1)); 1630 1631 EXPECT_EQ("524", message.GetExtension(unittest::repeated_string_piece_extension, 1)); 1632 EXPECT_EQ("525", message.GetExtension(unittest::repeated_cord_extension, 1)); 1633 } 1634 1635 // ------------------------------------------------------------------- 1636 1637 void TestUtil::SetPackedExtensions(unittest::TestPackedExtensions* message) { 1638 message->AddExtension(unittest::packed_int32_extension , 601); 1639 message->AddExtension(unittest::packed_int64_extension , 602); 1640 message->AddExtension(unittest::packed_uint32_extension , 603); 1641 message->AddExtension(unittest::packed_uint64_extension , 604); 1642 message->AddExtension(unittest::packed_sint32_extension , 605); 1643 message->AddExtension(unittest::packed_sint64_extension , 606); 1644 message->AddExtension(unittest::packed_fixed32_extension , 607); 1645 message->AddExtension(unittest::packed_fixed64_extension , 608); 1646 message->AddExtension(unittest::packed_sfixed32_extension, 609); 1647 message->AddExtension(unittest::packed_sfixed64_extension, 610); 1648 message->AddExtension(unittest::packed_float_extension , 611); 1649 message->AddExtension(unittest::packed_double_extension , 612); 1650 message->AddExtension(unittest::packed_bool_extension , true); 1651 message->AddExtension(unittest::packed_enum_extension, unittest::FOREIGN_BAR); 1652 // add a second one of each field 1653 message->AddExtension(unittest::packed_int32_extension , 701); 1654 message->AddExtension(unittest::packed_int64_extension , 702); 1655 message->AddExtension(unittest::packed_uint32_extension , 703); 1656 message->AddExtension(unittest::packed_uint64_extension , 704); 1657 message->AddExtension(unittest::packed_sint32_extension , 705); 1658 message->AddExtension(unittest::packed_sint64_extension , 706); 1659 message->AddExtension(unittest::packed_fixed32_extension , 707); 1660 message->AddExtension(unittest::packed_fixed64_extension , 708); 1661 message->AddExtension(unittest::packed_sfixed32_extension, 709); 1662 message->AddExtension(unittest::packed_sfixed64_extension, 710); 1663 message->AddExtension(unittest::packed_float_extension , 711); 1664 message->AddExtension(unittest::packed_double_extension , 712); 1665 message->AddExtension(unittest::packed_bool_extension , false); 1666 message->AddExtension(unittest::packed_enum_extension, unittest::FOREIGN_BAZ); 1667 } 1668 1669 // ------------------------------------------------------------------- 1670 1671 void TestUtil::ModifyPackedExtensions(unittest::TestPackedExtensions* message) { 1672 message->SetExtension(unittest::packed_int32_extension , 1, 801); 1673 message->SetExtension(unittest::packed_int64_extension , 1, 802); 1674 message->SetExtension(unittest::packed_uint32_extension , 1, 803); 1675 message->SetExtension(unittest::packed_uint64_extension , 1, 804); 1676 message->SetExtension(unittest::packed_sint32_extension , 1, 805); 1677 message->SetExtension(unittest::packed_sint64_extension , 1, 806); 1678 message->SetExtension(unittest::packed_fixed32_extension , 1, 807); 1679 message->SetExtension(unittest::packed_fixed64_extension , 1, 808); 1680 message->SetExtension(unittest::packed_sfixed32_extension, 1, 809); 1681 message->SetExtension(unittest::packed_sfixed64_extension, 1, 810); 1682 message->SetExtension(unittest::packed_float_extension , 1, 811); 1683 message->SetExtension(unittest::packed_double_extension , 1, 812); 1684 message->SetExtension(unittest::packed_bool_extension , 1, true); 1685 message->SetExtension(unittest::packed_enum_extension , 1, 1686 unittest::FOREIGN_FOO); 1687 } 1688 1689 // ------------------------------------------------------------------- 1690 1691 void TestUtil::ExpectPackedExtensionsSet( 1692 const unittest::TestPackedExtensions& message) { 1693 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension )); 1694 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension )); 1695 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension )); 1696 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension )); 1697 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension )); 1698 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension )); 1699 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension )); 1700 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension )); 1701 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension)); 1702 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension)); 1703 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension )); 1704 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension )); 1705 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension )); 1706 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension )); 1707 1708 EXPECT_EQ(601 , message.GetExtension(unittest::packed_int32_extension , 0)); 1709 EXPECT_EQ(602 , message.GetExtension(unittest::packed_int64_extension , 0)); 1710 EXPECT_EQ(603 , message.GetExtension(unittest::packed_uint32_extension , 0)); 1711 EXPECT_EQ(604 , message.GetExtension(unittest::packed_uint64_extension , 0)); 1712 EXPECT_EQ(605 , message.GetExtension(unittest::packed_sint32_extension , 0)); 1713 EXPECT_EQ(606 , message.GetExtension(unittest::packed_sint64_extension , 0)); 1714 EXPECT_EQ(607 , message.GetExtension(unittest::packed_fixed32_extension , 0)); 1715 EXPECT_EQ(608 , message.GetExtension(unittest::packed_fixed64_extension , 0)); 1716 EXPECT_EQ(609 , message.GetExtension(unittest::packed_sfixed32_extension, 0)); 1717 EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension, 0)); 1718 EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension , 0)); 1719 EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension , 0)); 1720 EXPECT_TRUE( message.GetExtension(unittest::packed_bool_extension , 0)); 1721 EXPECT_EQ(unittest::FOREIGN_BAR, 1722 message.GetExtension(unittest::packed_enum_extension, 0)); 1723 EXPECT_EQ(701 , message.GetExtension(unittest::packed_int32_extension , 1)); 1724 EXPECT_EQ(702 , message.GetExtension(unittest::packed_int64_extension , 1)); 1725 EXPECT_EQ(703 , message.GetExtension(unittest::packed_uint32_extension , 1)); 1726 EXPECT_EQ(704 , message.GetExtension(unittest::packed_uint64_extension , 1)); 1727 EXPECT_EQ(705 , message.GetExtension(unittest::packed_sint32_extension , 1)); 1728 EXPECT_EQ(706 , message.GetExtension(unittest::packed_sint64_extension , 1)); 1729 EXPECT_EQ(707 , message.GetExtension(unittest::packed_fixed32_extension , 1)); 1730 EXPECT_EQ(708 , message.GetExtension(unittest::packed_fixed64_extension , 1)); 1731 EXPECT_EQ(709 , message.GetExtension(unittest::packed_sfixed32_extension, 1)); 1732 EXPECT_EQ(710 , message.GetExtension(unittest::packed_sfixed64_extension, 1)); 1733 EXPECT_EQ(711 , message.GetExtension(unittest::packed_float_extension , 1)); 1734 EXPECT_EQ(712 , message.GetExtension(unittest::packed_double_extension , 1)); 1735 EXPECT_FALSE( message.GetExtension(unittest::packed_bool_extension , 1)); 1736 EXPECT_EQ(unittest::FOREIGN_BAZ, 1737 message.GetExtension(unittest::packed_enum_extension, 1)); 1738 } 1739 1740 // ------------------------------------------------------------------- 1741 1742 void TestUtil::ExpectPackedExtensionsClear( 1743 const unittest::TestPackedExtensions& message) { 1744 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int32_extension )); 1745 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int64_extension )); 1746 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint32_extension )); 1747 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint64_extension )); 1748 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint32_extension )); 1749 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint64_extension )); 1750 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed32_extension )); 1751 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed64_extension )); 1752 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed32_extension)); 1753 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed64_extension)); 1754 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_float_extension )); 1755 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_double_extension )); 1756 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_bool_extension )); 1757 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_enum_extension )); 1758 } 1759 1760 // ------------------------------------------------------------------- 1761 1762 void TestUtil::ExpectPackedExtensionsModified( 1763 const unittest::TestPackedExtensions& message) { 1764 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension )); 1765 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension )); 1766 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension )); 1767 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension )); 1768 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension )); 1769 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension )); 1770 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension )); 1771 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension )); 1772 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension)); 1773 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension)); 1774 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension )); 1775 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension )); 1776 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension )); 1777 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension )); 1778 EXPECT_EQ(601 , message.GetExtension(unittest::packed_int32_extension , 0)); 1779 EXPECT_EQ(602 , message.GetExtension(unittest::packed_int64_extension , 0)); 1780 EXPECT_EQ(603 , message.GetExtension(unittest::packed_uint32_extension , 0)); 1781 EXPECT_EQ(604 , message.GetExtension(unittest::packed_uint64_extension , 0)); 1782 EXPECT_EQ(605 , message.GetExtension(unittest::packed_sint32_extension , 0)); 1783 EXPECT_EQ(606 , message.GetExtension(unittest::packed_sint64_extension , 0)); 1784 EXPECT_EQ(607 , message.GetExtension(unittest::packed_fixed32_extension , 0)); 1785 EXPECT_EQ(608 , message.GetExtension(unittest::packed_fixed64_extension , 0)); 1786 EXPECT_EQ(609 , message.GetExtension(unittest::packed_sfixed32_extension, 0)); 1787 EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension, 0)); 1788 EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension , 0)); 1789 EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension , 0)); 1790 EXPECT_TRUE( message.GetExtension(unittest::packed_bool_extension , 0)); 1791 EXPECT_EQ(unittest::FOREIGN_BAR, 1792 message.GetExtension(unittest::packed_enum_extension, 0)); 1793 1794 // Actually verify the second (modified) elements now. 1795 EXPECT_EQ(801 , message.GetExtension(unittest::packed_int32_extension , 1)); 1796 EXPECT_EQ(802 , message.GetExtension(unittest::packed_int64_extension , 1)); 1797 EXPECT_EQ(803 , message.GetExtension(unittest::packed_uint32_extension , 1)); 1798 EXPECT_EQ(804 , message.GetExtension(unittest::packed_uint64_extension , 1)); 1799 EXPECT_EQ(805 , message.GetExtension(unittest::packed_sint32_extension , 1)); 1800 EXPECT_EQ(806 , message.GetExtension(unittest::packed_sint64_extension , 1)); 1801 EXPECT_EQ(807 , message.GetExtension(unittest::packed_fixed32_extension , 1)); 1802 EXPECT_EQ(808 , message.GetExtension(unittest::packed_fixed64_extension , 1)); 1803 EXPECT_EQ(809 , message.GetExtension(unittest::packed_sfixed32_extension, 1)); 1804 EXPECT_EQ(810 , message.GetExtension(unittest::packed_sfixed64_extension, 1)); 1805 EXPECT_EQ(811 , message.GetExtension(unittest::packed_float_extension , 1)); 1806 EXPECT_EQ(812 , message.GetExtension(unittest::packed_double_extension , 1)); 1807 EXPECT_TRUE( message.GetExtension(unittest::packed_bool_extension , 1)); 1808 EXPECT_EQ(unittest::FOREIGN_FOO, 1809 message.GetExtension(unittest::packed_enum_extension, 1)); 1810 } 1811 1812 // ------------------------------------------------------------------- 1813 1814 void TestUtil::ExpectUnpackedExtensionsSet( 1815 const unittest::TestUnpackedExtensions& message) { 1816 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_int32_extension )); 1817 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_int64_extension )); 1818 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_uint32_extension )); 1819 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_uint64_extension )); 1820 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_sint32_extension )); 1821 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_sint64_extension )); 1822 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_fixed32_extension )); 1823 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_fixed64_extension )); 1824 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_sfixed32_extension)); 1825 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_sfixed64_extension)); 1826 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_float_extension )); 1827 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_double_extension )); 1828 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_bool_extension )); 1829 ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_enum_extension )); 1830 1831 EXPECT_EQ(601 , message.GetExtension(unittest::unpacked_int32_extension , 0)); 1832 EXPECT_EQ(602 , message.GetExtension(unittest::unpacked_int64_extension , 0)); 1833 EXPECT_EQ(603 , message.GetExtension(unittest::unpacked_uint32_extension , 0)); 1834 EXPECT_EQ(604 , message.GetExtension(unittest::unpacked_uint64_extension , 0)); 1835 EXPECT_EQ(605 , message.GetExtension(unittest::unpacked_sint32_extension , 0)); 1836 EXPECT_EQ(606 , message.GetExtension(unittest::unpacked_sint64_extension , 0)); 1837 EXPECT_EQ(607 , message.GetExtension(unittest::unpacked_fixed32_extension , 0)); 1838 EXPECT_EQ(608 , message.GetExtension(unittest::unpacked_fixed64_extension , 0)); 1839 EXPECT_EQ(609 , message.GetExtension(unittest::unpacked_sfixed32_extension, 0)); 1840 EXPECT_EQ(610 , message.GetExtension(unittest::unpacked_sfixed64_extension, 0)); 1841 EXPECT_EQ(611 , message.GetExtension(unittest::unpacked_float_extension , 0)); 1842 EXPECT_EQ(612 , message.GetExtension(unittest::unpacked_double_extension , 0)); 1843 EXPECT_EQ(true , message.GetExtension(unittest::unpacked_bool_extension , 0)); 1844 EXPECT_EQ(unittest::FOREIGN_BAR, 1845 message.GetExtension(unittest::unpacked_enum_extension, 0)); 1846 EXPECT_EQ(701 , message.GetExtension(unittest::unpacked_int32_extension , 1)); 1847 EXPECT_EQ(702 , message.GetExtension(unittest::unpacked_int64_extension , 1)); 1848 EXPECT_EQ(703 , message.GetExtension(unittest::unpacked_uint32_extension , 1)); 1849 EXPECT_EQ(704 , message.GetExtension(unittest::unpacked_uint64_extension , 1)); 1850 EXPECT_EQ(705 , message.GetExtension(unittest::unpacked_sint32_extension , 1)); 1851 EXPECT_EQ(706 , message.GetExtension(unittest::unpacked_sint64_extension , 1)); 1852 EXPECT_EQ(707 , message.GetExtension(unittest::unpacked_fixed32_extension , 1)); 1853 EXPECT_EQ(708 , message.GetExtension(unittest::unpacked_fixed64_extension , 1)); 1854 EXPECT_EQ(709 , message.GetExtension(unittest::unpacked_sfixed32_extension, 1)); 1855 EXPECT_EQ(710 , message.GetExtension(unittest::unpacked_sfixed64_extension, 1)); 1856 EXPECT_EQ(711 , message.GetExtension(unittest::unpacked_float_extension , 1)); 1857 EXPECT_EQ(712 , message.GetExtension(unittest::unpacked_double_extension , 1)); 1858 EXPECT_EQ(false, message.GetExtension(unittest::unpacked_bool_extension , 1)); 1859 EXPECT_EQ(unittest::FOREIGN_BAZ, 1860 message.GetExtension(unittest::unpacked_enum_extension, 1)); 1861 } 1862 1863 // ------------------------------------------------------------------- 1864 1865 void TestUtil::ExpectAllFieldsAndExtensionsInOrder(const string& serialized) { 1866 // We set each field individually, serialize separately, and concatenate all 1867 // the strings in canonical order to determine the expected serialization. 1868 string expected; 1869 unittest::TestFieldOrderings message; 1870 message.set_my_int(1); // Field 1. 1871 message.AppendToString(&expected); 1872 message.Clear(); 1873 message.SetExtension(unittest::my_extension_int, 23); // Field 5. 1874 message.AppendToString(&expected); 1875 message.Clear(); 1876 message.set_my_string("foo"); // Field 11. 1877 message.AppendToString(&expected); 1878 message.Clear(); 1879 message.SetExtension(unittest::my_extension_string, "bar"); // Field 50. 1880 message.AppendToString(&expected); 1881 message.Clear(); 1882 message.set_my_float(1.0); // Field 101. 1883 message.AppendToString(&expected); 1884 message.Clear(); 1885 1886 // We don't EXPECT_EQ() since we don't want to print raw bytes to stdout. 1887 EXPECT_TRUE(serialized == expected); 1888 } 1889 1890 void TestUtil::ExpectLastRepeatedsRemoved( 1891 const unittest::TestAllTypes& message) { 1892 ASSERT_EQ(1, message.repeated_int32_size ()); 1893 ASSERT_EQ(1, message.repeated_int64_size ()); 1894 ASSERT_EQ(1, message.repeated_uint32_size ()); 1895 ASSERT_EQ(1, message.repeated_uint64_size ()); 1896 ASSERT_EQ(1, message.repeated_sint32_size ()); 1897 ASSERT_EQ(1, message.repeated_sint64_size ()); 1898 ASSERT_EQ(1, message.repeated_fixed32_size ()); 1899 ASSERT_EQ(1, message.repeated_fixed64_size ()); 1900 ASSERT_EQ(1, message.repeated_sfixed32_size()); 1901 ASSERT_EQ(1, message.repeated_sfixed64_size()); 1902 ASSERT_EQ(1, message.repeated_float_size ()); 1903 ASSERT_EQ(1, message.repeated_double_size ()); 1904 ASSERT_EQ(1, message.repeated_bool_size ()); 1905 ASSERT_EQ(1, message.repeated_string_size ()); 1906 ASSERT_EQ(1, message.repeated_bytes_size ()); 1907 1908 ASSERT_EQ(1, message.repeatedgroup_size ()); 1909 ASSERT_EQ(1, message.repeated_nested_message_size ()); 1910 ASSERT_EQ(1, message.repeated_foreign_message_size()); 1911 ASSERT_EQ(1, message.repeated_import_message_size ()); 1912 ASSERT_EQ(1, message.repeated_import_message_size ()); 1913 ASSERT_EQ(1, message.repeated_nested_enum_size ()); 1914 ASSERT_EQ(1, message.repeated_foreign_enum_size ()); 1915 ASSERT_EQ(1, message.repeated_import_enum_size ()); 1916 1917 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 1918 ASSERT_EQ(1, message.repeated_string_piece_size()); 1919 ASSERT_EQ(1, message.repeated_cord_size()); 1920 #endif 1921 1922 // Test that the remaining element is the correct one. 1923 EXPECT_EQ(201 , message.repeated_int32 (0)); 1924 EXPECT_EQ(202 , message.repeated_int64 (0)); 1925 EXPECT_EQ(203 , message.repeated_uint32 (0)); 1926 EXPECT_EQ(204 , message.repeated_uint64 (0)); 1927 EXPECT_EQ(205 , message.repeated_sint32 (0)); 1928 EXPECT_EQ(206 , message.repeated_sint64 (0)); 1929 EXPECT_EQ(207 , message.repeated_fixed32 (0)); 1930 EXPECT_EQ(208 , message.repeated_fixed64 (0)); 1931 EXPECT_EQ(209 , message.repeated_sfixed32(0)); 1932 EXPECT_EQ(210 , message.repeated_sfixed64(0)); 1933 EXPECT_EQ(211 , message.repeated_float (0)); 1934 EXPECT_EQ(212 , message.repeated_double (0)); 1935 EXPECT_TRUE( message.repeated_bool (0)); 1936 EXPECT_EQ("215", message.repeated_string (0)); 1937 EXPECT_EQ("216", message.repeated_bytes (0)); 1938 1939 EXPECT_EQ(217, message.repeatedgroup (0).a()); 1940 EXPECT_EQ(218, message.repeated_nested_message (0).bb()); 1941 EXPECT_EQ(219, message.repeated_foreign_message(0).c()); 1942 EXPECT_EQ(220, message.repeated_import_message (0).d()); 1943 EXPECT_EQ(220, message.repeated_import_message (0).d()); 1944 1945 EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (0)); 1946 EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(0)); 1947 EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (0)); 1948 } 1949 1950 void TestUtil::ExpectLastRepeatedExtensionsRemoved( 1951 const unittest::TestAllExtensions& message) { 1952 1953 // Test that one element was removed. 1954 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_int32_extension )); 1955 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_int64_extension )); 1956 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_uint32_extension )); 1957 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_uint64_extension )); 1958 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sint32_extension )); 1959 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sint64_extension )); 1960 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_fixed32_extension )); 1961 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_fixed64_extension )); 1962 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sfixed32_extension)); 1963 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sfixed64_extension)); 1964 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_float_extension )); 1965 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_double_extension )); 1966 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_bool_extension )); 1967 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_string_extension )); 1968 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_bytes_extension )); 1969 1970 ASSERT_EQ(1, message.ExtensionSize(unittest::repeatedgroup_extension )); 1971 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_nested_message_extension )); 1972 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_foreign_message_extension)); 1973 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_import_message_extension )); 1974 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_lazy_message_extension )); 1975 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_nested_enum_extension )); 1976 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); 1977 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_import_enum_extension )); 1978 1979 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_string_piece_extension)); 1980 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_cord_extension)); 1981 1982 // Test that the remaining element is the correct one. 1983 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension , 0)); 1984 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension , 0)); 1985 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension , 0)); 1986 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension , 0)); 1987 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension , 0)); 1988 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension , 0)); 1989 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension , 0)); 1990 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension , 0)); 1991 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension, 0)); 1992 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 0)); 1993 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 0)); 1994 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 0)); 1995 EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 0)); 1996 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 0)); 1997 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 0)); 1998 1999 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 0).a()); 2000 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); 2001 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); 2002 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); 2003 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb()); 2004 2005 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 0)); 2006 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 0)); 2007 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 0)); 2008 2009 EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 0)); 2010 EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 0)); 2011 } 2012 2013 void TestUtil::ExpectLastRepeatedsReleased( 2014 const unittest::TestAllTypes& message) { 2015 ASSERT_EQ(1, message.repeatedgroup_size ()); 2016 ASSERT_EQ(1, message.repeated_nested_message_size ()); 2017 ASSERT_EQ(1, message.repeated_foreign_message_size()); 2018 ASSERT_EQ(1, message.repeated_import_message_size ()); 2019 ASSERT_EQ(1, message.repeated_import_message_size ()); 2020 2021 EXPECT_EQ(217, message.repeatedgroup (0).a()); 2022 EXPECT_EQ(218, message.repeated_nested_message (0).bb()); 2023 EXPECT_EQ(219, message.repeated_foreign_message(0).c()); 2024 EXPECT_EQ(220, message.repeated_import_message (0).d()); 2025 EXPECT_EQ(220, message.repeated_import_message (0).d()); 2026 } 2027 2028 void TestUtil::ExpectLastRepeatedExtensionsReleased( 2029 const unittest::TestAllExtensions& message) { 2030 ASSERT_EQ(1, message.ExtensionSize(unittest::repeatedgroup_extension )); 2031 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_nested_message_extension )); 2032 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_foreign_message_extension)); 2033 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_import_message_extension )); 2034 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_lazy_message_extension )); 2035 2036 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 0).a()); 2037 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); 2038 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); 2039 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); 2040 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb()); 2041 } 2042 2043 void TestUtil::ExpectRepeatedsSwapped( 2044 const unittest::TestAllTypes& message) { 2045 ASSERT_EQ(2, message.repeated_int32_size ()); 2046 ASSERT_EQ(2, message.repeated_int64_size ()); 2047 ASSERT_EQ(2, message.repeated_uint32_size ()); 2048 ASSERT_EQ(2, message.repeated_uint64_size ()); 2049 ASSERT_EQ(2, message.repeated_sint32_size ()); 2050 ASSERT_EQ(2, message.repeated_sint64_size ()); 2051 ASSERT_EQ(2, message.repeated_fixed32_size ()); 2052 ASSERT_EQ(2, message.repeated_fixed64_size ()); 2053 ASSERT_EQ(2, message.repeated_sfixed32_size()); 2054 ASSERT_EQ(2, message.repeated_sfixed64_size()); 2055 ASSERT_EQ(2, message.repeated_float_size ()); 2056 ASSERT_EQ(2, message.repeated_double_size ()); 2057 ASSERT_EQ(2, message.repeated_bool_size ()); 2058 ASSERT_EQ(2, message.repeated_string_size ()); 2059 ASSERT_EQ(2, message.repeated_bytes_size ()); 2060 2061 ASSERT_EQ(2, message.repeatedgroup_size ()); 2062 ASSERT_EQ(2, message.repeated_nested_message_size ()); 2063 ASSERT_EQ(2, message.repeated_foreign_message_size()); 2064 ASSERT_EQ(2, message.repeated_import_message_size ()); 2065 ASSERT_EQ(2, message.repeated_import_message_size ()); 2066 ASSERT_EQ(2, message.repeated_nested_enum_size ()); 2067 ASSERT_EQ(2, message.repeated_foreign_enum_size ()); 2068 ASSERT_EQ(2, message.repeated_import_enum_size ()); 2069 2070 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 2071 ASSERT_EQ(2, message.repeated_string_piece_size()); 2072 ASSERT_EQ(2, message.repeated_cord_size()); 2073 #endif 2074 2075 // Test that the first element and second element are flipped. 2076 EXPECT_EQ(201 , message.repeated_int32 (1)); 2077 EXPECT_EQ(202 , message.repeated_int64 (1)); 2078 EXPECT_EQ(203 , message.repeated_uint32 (1)); 2079 EXPECT_EQ(204 , message.repeated_uint64 (1)); 2080 EXPECT_EQ(205 , message.repeated_sint32 (1)); 2081 EXPECT_EQ(206 , message.repeated_sint64 (1)); 2082 EXPECT_EQ(207 , message.repeated_fixed32 (1)); 2083 EXPECT_EQ(208 , message.repeated_fixed64 (1)); 2084 EXPECT_EQ(209 , message.repeated_sfixed32(1)); 2085 EXPECT_EQ(210 , message.repeated_sfixed64(1)); 2086 EXPECT_EQ(211 , message.repeated_float (1)); 2087 EXPECT_EQ(212 , message.repeated_double (1)); 2088 EXPECT_TRUE( message.repeated_bool (1)); 2089 EXPECT_EQ("215", message.repeated_string (1)); 2090 EXPECT_EQ("216", message.repeated_bytes (1)); 2091 2092 EXPECT_EQ(217, message.repeatedgroup (1).a()); 2093 EXPECT_EQ(218, message.repeated_nested_message (1).bb()); 2094 EXPECT_EQ(219, message.repeated_foreign_message(1).c()); 2095 EXPECT_EQ(220, message.repeated_import_message (1).d()); 2096 EXPECT_EQ(220, message.repeated_import_message (1).d()); 2097 2098 EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (1)); 2099 EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(1)); 2100 EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (1)); 2101 2102 EXPECT_EQ(301 , message.repeated_int32 (0)); 2103 EXPECT_EQ(302 , message.repeated_int64 (0)); 2104 EXPECT_EQ(303 , message.repeated_uint32 (0)); 2105 EXPECT_EQ(304 , message.repeated_uint64 (0)); 2106 EXPECT_EQ(305 , message.repeated_sint32 (0)); 2107 EXPECT_EQ(306 , message.repeated_sint64 (0)); 2108 EXPECT_EQ(307 , message.repeated_fixed32 (0)); 2109 EXPECT_EQ(308 , message.repeated_fixed64 (0)); 2110 EXPECT_EQ(309 , message.repeated_sfixed32(0)); 2111 EXPECT_EQ(310 , message.repeated_sfixed64(0)); 2112 EXPECT_EQ(311 , message.repeated_float (0)); 2113 EXPECT_EQ(312 , message.repeated_double (0)); 2114 EXPECT_FALSE( message.repeated_bool (0)); 2115 EXPECT_EQ("315", message.repeated_string (0)); 2116 EXPECT_EQ("316", message.repeated_bytes (0)); 2117 2118 EXPECT_EQ(317, message.repeatedgroup (0).a()); 2119 EXPECT_EQ(318, message.repeated_nested_message (0).bb()); 2120 EXPECT_EQ(319, message.repeated_foreign_message(0).c()); 2121 EXPECT_EQ(320, message.repeated_import_message (0).d()); 2122 EXPECT_EQ(320, message.repeated_import_message (0).d()); 2123 2124 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.repeated_nested_enum (0)); 2125 EXPECT_EQ(unittest::FOREIGN_BAZ , message.repeated_foreign_enum(0)); 2126 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.repeated_import_enum (0)); 2127 } 2128 2129 void TestUtil::ExpectRepeatedExtensionsSwapped( 2130 const unittest::TestAllExtensions& message) { 2131 2132 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension )); 2133 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension )); 2134 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension )); 2135 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension )); 2136 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension )); 2137 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension )); 2138 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension )); 2139 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension )); 2140 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension)); 2141 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension)); 2142 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension )); 2143 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension )); 2144 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension )); 2145 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension )); 2146 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension )); 2147 2148 ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension )); 2149 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension )); 2150 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension)); 2151 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension )); 2152 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension )); 2153 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension )); 2154 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); 2155 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension )); 2156 2157 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_piece_extension)); 2158 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_cord_extension)); 2159 2160 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension , 1)); 2161 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension , 1)); 2162 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension , 1)); 2163 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension , 1)); 2164 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension , 1)); 2165 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension , 1)); 2166 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension , 1)); 2167 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension , 1)); 2168 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension, 1)); 2169 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 1)); 2170 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 1)); 2171 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 1)); 2172 EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 1)); 2173 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 1)); 2174 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 1)); 2175 2176 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 1).a()); 2177 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 1).bb()); 2178 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 1).c()); 2179 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 1).d()); 2180 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 1).bb()); 2181 2182 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 1)); 2183 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 1)); 2184 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 1)); 2185 2186 EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 1)); 2187 EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 1)); 2188 2189 EXPECT_EQ(301 , message.GetExtension(unittest::repeated_int32_extension , 0)); 2190 EXPECT_EQ(302 , message.GetExtension(unittest::repeated_int64_extension , 0)); 2191 EXPECT_EQ(303 , message.GetExtension(unittest::repeated_uint32_extension , 0)); 2192 EXPECT_EQ(304 , message.GetExtension(unittest::repeated_uint64_extension , 0)); 2193 EXPECT_EQ(305 , message.GetExtension(unittest::repeated_sint32_extension , 0)); 2194 EXPECT_EQ(306 , message.GetExtension(unittest::repeated_sint64_extension , 0)); 2195 EXPECT_EQ(307 , message.GetExtension(unittest::repeated_fixed32_extension , 0)); 2196 EXPECT_EQ(308 , message.GetExtension(unittest::repeated_fixed64_extension , 0)); 2197 EXPECT_EQ(309 , message.GetExtension(unittest::repeated_sfixed32_extension, 0)); 2198 EXPECT_EQ(310 , message.GetExtension(unittest::repeated_sfixed64_extension, 0)); 2199 EXPECT_EQ(311 , message.GetExtension(unittest::repeated_float_extension , 0)); 2200 EXPECT_EQ(312 , message.GetExtension(unittest::repeated_double_extension , 0)); 2201 EXPECT_FALSE( message.GetExtension(unittest::repeated_bool_extension , 0)); 2202 EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension , 0)); 2203 EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension , 0)); 2204 2205 EXPECT_EQ(317, message.GetExtension(unittest::repeatedgroup_extension , 0).a()); 2206 EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); 2207 EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); 2208 EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); 2209 EXPECT_EQ(327, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb()); 2210 2211 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.GetExtension(unittest::repeated_nested_enum_extension , 0)); 2212 EXPECT_EQ(unittest::FOREIGN_BAZ , message.GetExtension(unittest::repeated_foreign_enum_extension, 0)); 2213 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.GetExtension(unittest::repeated_import_enum_extension , 0)); 2214 2215 EXPECT_EQ("324", message.GetExtension(unittest::repeated_string_piece_extension, 0)); 2216 EXPECT_EQ("325", message.GetExtension(unittest::repeated_cord_extension, 0)); 2217 } 2218 2219 void TestUtil::SetOneof1(unittest::TestOneof2* message) { 2220 message->mutable_foo_lazy_message()->set_qux_int(100); 2221 message->set_bar_string("101"); 2222 message->set_baz_int(102); 2223 message->set_baz_string("103"); 2224 } 2225 2226 void TestUtil::SetOneof2(unittest::TestOneof2* message) { 2227 message->set_foo_int(200); 2228 message->set_bar_enum(unittest::TestOneof2::BAZ); 2229 message->set_baz_int(202); 2230 message->set_baz_string("203"); 2231 } 2232 2233 void TestUtil::ExpectOneofSet1(const unittest::TestOneof2& message) { 2234 ExpectAtMostOneFieldSetInOneof(message); 2235 2236 EXPECT_TRUE(message.has_foo_lazy_message ()); 2237 EXPECT_TRUE(message.foo_lazy_message().has_qux_int()); 2238 2239 EXPECT_TRUE(message.has_bar_string()); 2240 EXPECT_TRUE(message.has_baz_int ()); 2241 EXPECT_TRUE(message.has_baz_string()); 2242 2243 ASSERT_EQ(0, message.foo_lazy_message().corge_int_size()); 2244 2245 EXPECT_EQ(100 , message.foo_lazy_message().qux_int()); 2246 EXPECT_EQ("101", message.bar_string ()); 2247 EXPECT_EQ(102 , message.baz_int ()); 2248 EXPECT_EQ("103", message.baz_string ()); 2249 } 2250 2251 void TestUtil::ExpectOneofSet2(const unittest::TestOneof2& message) { 2252 ExpectAtMostOneFieldSetInOneof(message); 2253 2254 EXPECT_TRUE(message.has_foo_int ()); 2255 EXPECT_TRUE(message.has_bar_enum ()); 2256 EXPECT_TRUE(message.has_baz_int ()); 2257 EXPECT_TRUE(message.has_baz_string()); 2258 2259 EXPECT_EQ(200 , message.foo_int ()); 2260 EXPECT_EQ(unittest::TestOneof2::BAZ, message.bar_enum ()); 2261 EXPECT_EQ(202 , message.baz_int ()); 2262 EXPECT_EQ("203" , message.baz_string()); 2263 } 2264 2265 void TestUtil::ExpectOneofClear(const unittest::TestOneof2& message) { 2266 EXPECT_FALSE(message.has_foo_int()); 2267 EXPECT_FALSE(message.has_foo_string()); 2268 EXPECT_FALSE(message.has_foo_bytes()); 2269 EXPECT_FALSE(message.has_foo_enum()); 2270 EXPECT_FALSE(message.has_foo_message()); 2271 EXPECT_FALSE(message.has_foogroup()); 2272 EXPECT_FALSE(message.has_foo_lazy_message()); 2273 2274 EXPECT_FALSE(message.has_bar_int()); 2275 EXPECT_FALSE(message.has_bar_string()); 2276 EXPECT_FALSE(message.has_bar_bytes()); 2277 EXPECT_FALSE(message.has_bar_enum()); 2278 2279 EXPECT_FALSE(message.has_baz_int()); 2280 EXPECT_FALSE(message.has_baz_string()); 2281 2282 EXPECT_EQ(unittest::TestOneof2::FOO_NOT_SET, message.foo_case()); 2283 EXPECT_EQ(unittest::TestOneof2::BAR_NOT_SET, message.bar_case()); 2284 } 2285 2286 void TestUtil::ExpectAtMostOneFieldSetInOneof( 2287 const unittest::TestOneof2& message) { 2288 int count = 0; 2289 if (message.has_foo_int()) count++; 2290 if (message.has_foo_string()) count++; 2291 if (message.has_foo_bytes()) count++; 2292 if (message.has_foo_enum()) count++; 2293 if (message.has_foo_message()) count++; 2294 if (message.has_foogroup()) count++; 2295 if (message.has_foo_lazy_message()) count++; 2296 EXPECT_LE(count, 1); 2297 count = 0; 2298 if (message.has_bar_int()) count++; 2299 if (message.has_bar_string()) count++; 2300 if (message.has_bar_bytes()) count++; 2301 if (message.has_bar_enum()) count++; 2302 EXPECT_TRUE(count == 0 || count == 1); 2303 } 2304 2305 // =================================================================== 2306 2307 TestUtil::ReflectionTester::ReflectionTester( 2308 const Descriptor* base_descriptor) 2309 : base_descriptor_(base_descriptor) { 2310 2311 const DescriptorPool* pool = base_descriptor->file()->pool(); 2312 2313 nested_b_ = 2314 pool->FindFieldByName("protobuf_unittest.TestAllTypes.NestedMessage.bb"); 2315 foreign_c_ = 2316 pool->FindFieldByName("protobuf_unittest.ForeignMessage.c"); 2317 import_d_ = 2318 pool->FindFieldByName("protobuf_unittest_import.ImportMessage.d"); 2319 import_e_ = 2320 pool->FindFieldByName("protobuf_unittest_import.PublicImportMessage.e"); 2321 nested_foo_ = 2322 pool->FindEnumValueByName("protobuf_unittest.TestAllTypes.FOO"); 2323 nested_bar_ = 2324 pool->FindEnumValueByName("protobuf_unittest.TestAllTypes.BAR"); 2325 nested_baz_ = 2326 pool->FindEnumValueByName("protobuf_unittest.TestAllTypes.BAZ"); 2327 foreign_foo_ = 2328 pool->FindEnumValueByName("protobuf_unittest.FOREIGN_FOO"); 2329 foreign_bar_ = 2330 pool->FindEnumValueByName("protobuf_unittest.FOREIGN_BAR"); 2331 foreign_baz_ = 2332 pool->FindEnumValueByName("protobuf_unittest.FOREIGN_BAZ"); 2333 import_foo_ = 2334 pool->FindEnumValueByName("protobuf_unittest_import.IMPORT_FOO"); 2335 import_bar_ = 2336 pool->FindEnumValueByName("protobuf_unittest_import.IMPORT_BAR"); 2337 import_baz_ = 2338 pool->FindEnumValueByName("protobuf_unittest_import.IMPORT_BAZ"); 2339 2340 if (base_descriptor_->name() == "TestAllExtensions") { 2341 group_a_ = 2342 pool->FindFieldByName("protobuf_unittest.OptionalGroup_extension.a"); 2343 repeated_group_a_ = 2344 pool->FindFieldByName("protobuf_unittest.RepeatedGroup_extension.a"); 2345 } else { 2346 group_a_ = 2347 pool->FindFieldByName("protobuf_unittest.TestAllTypes.OptionalGroup.a"); 2348 repeated_group_a_ = 2349 pool->FindFieldByName("protobuf_unittest.TestAllTypes.RepeatedGroup.a"); 2350 } 2351 2352 EXPECT_TRUE(group_a_ != NULL); 2353 EXPECT_TRUE(repeated_group_a_ != NULL); 2354 EXPECT_TRUE(nested_b_ != NULL); 2355 EXPECT_TRUE(foreign_c_ != NULL); 2356 EXPECT_TRUE(import_d_ != NULL); 2357 EXPECT_TRUE(import_e_ != NULL); 2358 EXPECT_TRUE(nested_foo_ != NULL); 2359 EXPECT_TRUE(nested_bar_ != NULL); 2360 EXPECT_TRUE(nested_baz_ != NULL); 2361 EXPECT_TRUE(foreign_foo_ != NULL); 2362 EXPECT_TRUE(foreign_bar_ != NULL); 2363 EXPECT_TRUE(foreign_baz_ != NULL); 2364 EXPECT_TRUE(import_foo_ != NULL); 2365 EXPECT_TRUE(import_bar_ != NULL); 2366 EXPECT_TRUE(import_baz_ != NULL); 2367 } 2368 2369 // Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes. 2370 const FieldDescriptor* TestUtil::ReflectionTester::F(const string& name) { 2371 const FieldDescriptor* result = NULL; 2372 if (base_descriptor_->name() == "TestAllExtensions" || 2373 base_descriptor_->name() == "TestPackedExtensions") { 2374 result = base_descriptor_->file()->FindExtensionByName(name + "_extension"); 2375 } else { 2376 result = base_descriptor_->FindFieldByName(name); 2377 } 2378 GOOGLE_CHECK(result != NULL); 2379 return result; 2380 } 2381 2382 // ------------------------------------------------------------------- 2383 2384 void TestUtil::ReflectionTester::SetAllFieldsViaReflection(Message* message) { 2385 const Reflection* reflection = message->GetReflection(); 2386 Message* sub_message; 2387 2388 reflection->SetInt32 (message, F("optional_int32" ), 101); 2389 reflection->SetInt64 (message, F("optional_int64" ), 102); 2390 reflection->SetUInt32(message, F("optional_uint32" ), 103); 2391 reflection->SetUInt64(message, F("optional_uint64" ), 104); 2392 reflection->SetInt32 (message, F("optional_sint32" ), 105); 2393 reflection->SetInt64 (message, F("optional_sint64" ), 106); 2394 reflection->SetUInt32(message, F("optional_fixed32" ), 107); 2395 reflection->SetUInt64(message, F("optional_fixed64" ), 108); 2396 reflection->SetInt32 (message, F("optional_sfixed32"), 109); 2397 reflection->SetInt64 (message, F("optional_sfixed64"), 110); 2398 reflection->SetFloat (message, F("optional_float" ), 111); 2399 reflection->SetDouble(message, F("optional_double" ), 112); 2400 reflection->SetBool (message, F("optional_bool" ), true); 2401 reflection->SetString(message, F("optional_string" ), "115"); 2402 reflection->SetString(message, F("optional_bytes" ), "116"); 2403 2404 sub_message = reflection->MutableMessage(message, F("optionalgroup")); 2405 sub_message->GetReflection()->SetInt32(sub_message, group_a_, 117); 2406 sub_message = reflection->MutableMessage(message, F("optional_nested_message")); 2407 sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 118); 2408 sub_message = reflection->MutableMessage(message, F("optional_foreign_message")); 2409 sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 119); 2410 sub_message = reflection->MutableMessage(message, F("optional_import_message")); 2411 sub_message->GetReflection()->SetInt32(sub_message, import_d_, 120); 2412 2413 reflection->SetEnum(message, F("optional_nested_enum" ), nested_baz_); 2414 reflection->SetEnum(message, F("optional_foreign_enum"), foreign_baz_); 2415 reflection->SetEnum(message, F("optional_import_enum" ), import_baz_); 2416 2417 reflection->SetString(message, F("optional_string_piece"), "124"); 2418 reflection->SetString(message, F("optional_cord"), "125"); 2419 2420 sub_message = reflection->MutableMessage(message, F("optional_public_import_message")); 2421 sub_message->GetReflection()->SetInt32(sub_message, import_e_, 126); 2422 2423 sub_message = reflection->MutableMessage(message, F("optional_lazy_message")); 2424 sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 127); 2425 2426 // ----------------------------------------------------------------- 2427 2428 reflection->AddInt32 (message, F("repeated_int32" ), 201); 2429 reflection->AddInt64 (message, F("repeated_int64" ), 202); 2430 reflection->AddUInt32(message, F("repeated_uint32" ), 203); 2431 reflection->AddUInt64(message, F("repeated_uint64" ), 204); 2432 reflection->AddInt32 (message, F("repeated_sint32" ), 205); 2433 reflection->AddInt64 (message, F("repeated_sint64" ), 206); 2434 reflection->AddUInt32(message, F("repeated_fixed32" ), 207); 2435 reflection->AddUInt64(message, F("repeated_fixed64" ), 208); 2436 reflection->AddInt32 (message, F("repeated_sfixed32"), 209); 2437 reflection->AddInt64 (message, F("repeated_sfixed64"), 210); 2438 reflection->AddFloat (message, F("repeated_float" ), 211); 2439 reflection->AddDouble(message, F("repeated_double" ), 212); 2440 reflection->AddBool (message, F("repeated_bool" ), true); 2441 reflection->AddString(message, F("repeated_string" ), "215"); 2442 reflection->AddString(message, F("repeated_bytes" ), "216"); 2443 2444 sub_message = reflection->AddMessage(message, F("repeatedgroup")); 2445 sub_message->GetReflection()->SetInt32(sub_message, repeated_group_a_, 217); 2446 sub_message = reflection->AddMessage(message, F("repeated_nested_message")); 2447 sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 218); 2448 sub_message = reflection->AddMessage(message, F("repeated_foreign_message")); 2449 sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 219); 2450 sub_message = reflection->AddMessage(message, F("repeated_import_message")); 2451 sub_message->GetReflection()->SetInt32(sub_message, import_d_, 220); 2452 sub_message = reflection->AddMessage(message, F("repeated_lazy_message")); 2453 sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 227); 2454 2455 reflection->AddEnum(message, F("repeated_nested_enum" ), nested_bar_); 2456 reflection->AddEnum(message, F("repeated_foreign_enum"), foreign_bar_); 2457 reflection->AddEnum(message, F("repeated_import_enum" ), import_bar_); 2458 2459 reflection->AddString(message, F("repeated_string_piece"), "224"); 2460 reflection->AddString(message, F("repeated_cord"), "225"); 2461 2462 // Add a second one of each field. 2463 reflection->AddInt32 (message, F("repeated_int32" ), 301); 2464 reflection->AddInt64 (message, F("repeated_int64" ), 302); 2465 reflection->AddUInt32(message, F("repeated_uint32" ), 303); 2466 reflection->AddUInt64(message, F("repeated_uint64" ), 304); 2467 reflection->AddInt32 (message, F("repeated_sint32" ), 305); 2468 reflection->AddInt64 (message, F("repeated_sint64" ), 306); 2469 reflection->AddUInt32(message, F("repeated_fixed32" ), 307); 2470 reflection->AddUInt64(message, F("repeated_fixed64" ), 308); 2471 reflection->AddInt32 (message, F("repeated_sfixed32"), 309); 2472 reflection->AddInt64 (message, F("repeated_sfixed64"), 310); 2473 reflection->AddFloat (message, F("repeated_float" ), 311); 2474 reflection->AddDouble(message, F("repeated_double" ), 312); 2475 reflection->AddBool (message, F("repeated_bool" ), false); 2476 reflection->AddString(message, F("repeated_string" ), "315"); 2477 reflection->AddString(message, F("repeated_bytes" ), "316"); 2478 2479 sub_message = reflection->AddMessage(message, F("repeatedgroup")); 2480 sub_message->GetReflection()->SetInt32(sub_message, repeated_group_a_, 317); 2481 sub_message = reflection->AddMessage(message, F("repeated_nested_message")); 2482 sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 318); 2483 sub_message = reflection->AddMessage(message, F("repeated_foreign_message")); 2484 sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 319); 2485 sub_message = reflection->AddMessage(message, F("repeated_import_message")); 2486 sub_message->GetReflection()->SetInt32(sub_message, import_d_, 320); 2487 sub_message = reflection->AddMessage(message, F("repeated_lazy_message")); 2488 sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 327); 2489 2490 reflection->AddEnum(message, F("repeated_nested_enum" ), nested_baz_); 2491 reflection->AddEnum(message, F("repeated_foreign_enum"), foreign_baz_); 2492 reflection->AddEnum(message, F("repeated_import_enum" ), import_baz_); 2493 2494 reflection->AddString(message, F("repeated_string_piece"), "324"); 2495 reflection->AddString(message, F("repeated_cord"), "325"); 2496 2497 // ----------------------------------------------------------------- 2498 2499 reflection->SetInt32 (message, F("default_int32" ), 401); 2500 reflection->SetInt64 (message, F("default_int64" ), 402); 2501 reflection->SetUInt32(message, F("default_uint32" ), 403); 2502 reflection->SetUInt64(message, F("default_uint64" ), 404); 2503 reflection->SetInt32 (message, F("default_sint32" ), 405); 2504 reflection->SetInt64 (message, F("default_sint64" ), 406); 2505 reflection->SetUInt32(message, F("default_fixed32" ), 407); 2506 reflection->SetUInt64(message, F("default_fixed64" ), 408); 2507 reflection->SetInt32 (message, F("default_sfixed32"), 409); 2508 reflection->SetInt64 (message, F("default_sfixed64"), 410); 2509 reflection->SetFloat (message, F("default_float" ), 411); 2510 reflection->SetDouble(message, F("default_double" ), 412); 2511 reflection->SetBool (message, F("default_bool" ), false); 2512 reflection->SetString(message, F("default_string" ), "415"); 2513 reflection->SetString(message, F("default_bytes" ), "416"); 2514 2515 reflection->SetEnum(message, F("default_nested_enum" ), nested_foo_); 2516 reflection->SetEnum(message, F("default_foreign_enum"), foreign_foo_); 2517 reflection->SetEnum(message, F("default_import_enum" ), import_foo_); 2518 2519 reflection->SetString(message, F("default_string_piece"), "424"); 2520 reflection->SetString(message, F("default_cord"), "425"); 2521 2522 reflection->SetUInt32(message, F("oneof_uint32" ), 601); 2523 sub_message = reflection->MutableMessage(message, F("oneof_nested_message")); 2524 sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 602); 2525 reflection->SetString(message, F("oneof_string"), "603"); 2526 reflection->SetString(message, F("oneof_bytes" ), "604"); 2527 } 2528 2529 void TestUtil::ReflectionTester::SetOneofViaReflection(Message* message) { 2530 const Descriptor* descriptor = message->GetDescriptor(); 2531 const Reflection* reflection = message->GetReflection(); 2532 Message* sub_message = reflection->MutableMessage( 2533 message, descriptor->FindFieldByName("foo_lazy_message")); 2534 sub_message->GetReflection()->SetInt64( 2535 sub_message, 2536 descriptor->file()->pool()->FindFieldByName( 2537 "protobuf_unittest.TestOneof2.NestedMessage.qux_int"), 2538 100); 2539 2540 reflection->SetString(message, 2541 descriptor->FindFieldByName("bar_cord"), 2542 "101"); 2543 reflection->SetInt32(message, 2544 descriptor->FindFieldByName("baz_int"), 2545 102); 2546 reflection->SetString(message, 2547 descriptor->FindFieldByName("baz_string"), 2548 "103"); 2549 } 2550 2551 void TestUtil::ReflectionTester::ExpectOneofSetViaReflection( 2552 const Message& message) { 2553 const Descriptor* descriptor = message.GetDescriptor(); 2554 const Reflection* reflection = message.GetReflection(); 2555 string scratch; 2556 EXPECT_TRUE(reflection->HasField( 2557 message, descriptor->FindFieldByName("foo_lazy_message"))); 2558 EXPECT_TRUE(reflection->HasField( 2559 message, descriptor->FindFieldByName("bar_cord"))); 2560 EXPECT_TRUE(reflection->HasField( 2561 message, descriptor->FindFieldByName("baz_int"))); 2562 EXPECT_TRUE(reflection->HasField( 2563 message, descriptor->FindFieldByName("baz_string"))); 2564 2565 const Message* sub_message = &reflection->GetMessage( 2566 message, descriptor->FindFieldByName("foo_lazy_message")); 2567 EXPECT_EQ(100, sub_message->GetReflection()->GetInt64( 2568 *sub_message, 2569 descriptor->file()->pool()->FindFieldByName( 2570 "protobuf_unittest.TestOneof2.NestedMessage.qux_int"))); 2571 2572 EXPECT_EQ("101", reflection->GetString( 2573 message, descriptor->FindFieldByName("bar_cord"))); 2574 EXPECT_EQ("101", reflection->GetStringReference( 2575 message, descriptor->FindFieldByName("bar_cord"), &scratch)); 2576 2577 EXPECT_EQ(102, reflection->GetInt32( 2578 message, descriptor->FindFieldByName("baz_int"))); 2579 2580 EXPECT_EQ("103", reflection->GetString( 2581 message, descriptor->FindFieldByName("baz_string"))); 2582 EXPECT_EQ("103", reflection->GetStringReference( 2583 message, descriptor->FindFieldByName("baz_string"), &scratch)); 2584 } 2585 2586 void TestUtil::ReflectionTester::SetPackedFieldsViaReflection( 2587 Message* message) { 2588 const Reflection* reflection = message->GetReflection(); 2589 reflection->AddInt32 (message, F("packed_int32" ), 601); 2590 reflection->AddInt64 (message, F("packed_int64" ), 602); 2591 reflection->AddUInt32(message, F("packed_uint32" ), 603); 2592 reflection->AddUInt64(message, F("packed_uint64" ), 604); 2593 reflection->AddInt32 (message, F("packed_sint32" ), 605); 2594 reflection->AddInt64 (message, F("packed_sint64" ), 606); 2595 reflection->AddUInt32(message, F("packed_fixed32" ), 607); 2596 reflection->AddUInt64(message, F("packed_fixed64" ), 608); 2597 reflection->AddInt32 (message, F("packed_sfixed32"), 609); 2598 reflection->AddInt64 (message, F("packed_sfixed64"), 610); 2599 reflection->AddFloat (message, F("packed_float" ), 611); 2600 reflection->AddDouble(message, F("packed_double" ), 612); 2601 reflection->AddBool (message, F("packed_bool" ), true); 2602 reflection->AddEnum (message, F("packed_enum" ), foreign_bar_); 2603 2604 reflection->AddInt32 (message, F("packed_int32" ), 701); 2605 reflection->AddInt64 (message, F("packed_int64" ), 702); 2606 reflection->AddUInt32(message, F("packed_uint32" ), 703); 2607 reflection->AddUInt64(message, F("packed_uint64" ), 704); 2608 reflection->AddInt32 (message, F("packed_sint32" ), 705); 2609 reflection->AddInt64 (message, F("packed_sint64" ), 706); 2610 reflection->AddUInt32(message, F("packed_fixed32" ), 707); 2611 reflection->AddUInt64(message, F("packed_fixed64" ), 708); 2612 reflection->AddInt32 (message, F("packed_sfixed32"), 709); 2613 reflection->AddInt64 (message, F("packed_sfixed64"), 710); 2614 reflection->AddFloat (message, F("packed_float" ), 711); 2615 reflection->AddDouble(message, F("packed_double" ), 712); 2616 reflection->AddBool (message, F("packed_bool" ), false); 2617 reflection->AddEnum (message, F("packed_enum" ), foreign_baz_); 2618 } 2619 2620 // ------------------------------------------------------------------- 2621 2622 void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection( 2623 const Message& message) { 2624 // We have to split this into three function otherwise it creates a stack 2625 // frame so large that it triggers a warning. 2626 ExpectAllFieldsSetViaReflection1(message); 2627 ExpectAllFieldsSetViaReflection2(message); 2628 ExpectAllFieldsSetViaReflection3(message); 2629 } 2630 2631 void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection1( 2632 const Message& message) { 2633 const Reflection* reflection = message.GetReflection(); 2634 string scratch; 2635 const Message* sub_message; 2636 2637 EXPECT_TRUE(reflection->HasField(message, F("optional_int32" ))); 2638 EXPECT_TRUE(reflection->HasField(message, F("optional_int64" ))); 2639 EXPECT_TRUE(reflection->HasField(message, F("optional_uint32" ))); 2640 EXPECT_TRUE(reflection->HasField(message, F("optional_uint64" ))); 2641 EXPECT_TRUE(reflection->HasField(message, F("optional_sint32" ))); 2642 EXPECT_TRUE(reflection->HasField(message, F("optional_sint64" ))); 2643 EXPECT_TRUE(reflection->HasField(message, F("optional_fixed32" ))); 2644 EXPECT_TRUE(reflection->HasField(message, F("optional_fixed64" ))); 2645 EXPECT_TRUE(reflection->HasField(message, F("optional_sfixed32"))); 2646 EXPECT_TRUE(reflection->HasField(message, F("optional_sfixed64"))); 2647 EXPECT_TRUE(reflection->HasField(message, F("optional_float" ))); 2648 EXPECT_TRUE(reflection->HasField(message, F("optional_double" ))); 2649 EXPECT_TRUE(reflection->HasField(message, F("optional_bool" ))); 2650 EXPECT_TRUE(reflection->HasField(message, F("optional_string" ))); 2651 EXPECT_TRUE(reflection->HasField(message, F("optional_bytes" ))); 2652 2653 EXPECT_TRUE(reflection->HasField(message, F("optionalgroup" ))); 2654 EXPECT_TRUE(reflection->HasField(message, F("optional_nested_message" ))); 2655 EXPECT_TRUE(reflection->HasField(message, F("optional_foreign_message" ))); 2656 EXPECT_TRUE(reflection->HasField(message, F("optional_import_message" ))); 2657 EXPECT_TRUE(reflection->HasField(message, F("optional_public_import_message"))); 2658 EXPECT_TRUE(reflection->HasField(message, F("optional_lazy_message" ))); 2659 2660 sub_message = &reflection->GetMessage(message, F("optionalgroup")); 2661 EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, group_a_)); 2662 sub_message = &reflection->GetMessage(message, F("optional_nested_message")); 2663 EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, nested_b_)); 2664 sub_message = &reflection->GetMessage(message, F("optional_foreign_message")); 2665 EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, foreign_c_)); 2666 sub_message = &reflection->GetMessage(message, F("optional_import_message")); 2667 EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, import_d_)); 2668 sub_message = &reflection->GetMessage(message, F("optional_public_import_message")); 2669 EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, import_e_)); 2670 sub_message = &reflection->GetMessage(message, F("optional_lazy_message")); 2671 EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, nested_b_)); 2672 2673 EXPECT_TRUE(reflection->HasField(message, F("optional_nested_enum" ))); 2674 EXPECT_TRUE(reflection->HasField(message, F("optional_foreign_enum"))); 2675 EXPECT_TRUE(reflection->HasField(message, F("optional_import_enum" ))); 2676 2677 EXPECT_TRUE(reflection->HasField(message, F("optional_string_piece"))); 2678 EXPECT_TRUE(reflection->HasField(message, F("optional_cord"))); 2679 2680 EXPECT_EQ(101 , reflection->GetInt32 (message, F("optional_int32" ))); 2681 EXPECT_EQ(102 , reflection->GetInt64 (message, F("optional_int64" ))); 2682 EXPECT_EQ(103 , reflection->GetUInt32(message, F("optional_uint32" ))); 2683 EXPECT_EQ(104 , reflection->GetUInt64(message, F("optional_uint64" ))); 2684 EXPECT_EQ(105 , reflection->GetInt32 (message, F("optional_sint32" ))); 2685 EXPECT_EQ(106 , reflection->GetInt64 (message, F("optional_sint64" ))); 2686 EXPECT_EQ(107 , reflection->GetUInt32(message, F("optional_fixed32" ))); 2687 EXPECT_EQ(108 , reflection->GetUInt64(message, F("optional_fixed64" ))); 2688 EXPECT_EQ(109 , reflection->GetInt32 (message, F("optional_sfixed32"))); 2689 EXPECT_EQ(110 , reflection->GetInt64 (message, F("optional_sfixed64"))); 2690 EXPECT_EQ(111 , reflection->GetFloat (message, F("optional_float" ))); 2691 EXPECT_EQ(112 , reflection->GetDouble(message, F("optional_double" ))); 2692 EXPECT_TRUE( reflection->GetBool (message, F("optional_bool" ))); 2693 EXPECT_EQ("115", reflection->GetString(message, F("optional_string" ))); 2694 EXPECT_EQ("116", reflection->GetString(message, F("optional_bytes" ))); 2695 2696 EXPECT_EQ("115", reflection->GetStringReference(message, F("optional_string"), &scratch)); 2697 EXPECT_EQ("116", reflection->GetStringReference(message, F("optional_bytes" ), &scratch)); 2698 2699 sub_message = &reflection->GetMessage(message, F("optionalgroup")); 2700 EXPECT_EQ(117, sub_message->GetReflection()->GetInt32(*sub_message, group_a_)); 2701 sub_message = &reflection->GetMessage(message, F("optional_nested_message")); 2702 EXPECT_EQ(118, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); 2703 sub_message = &reflection->GetMessage(message, F("optional_foreign_message")); 2704 EXPECT_EQ(119, sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_)); 2705 sub_message = &reflection->GetMessage(message, F("optional_import_message")); 2706 EXPECT_EQ(120, sub_message->GetReflection()->GetInt32(*sub_message, import_d_)); 2707 sub_message = &reflection->GetMessage(message, F("optional_public_import_message")); 2708 EXPECT_EQ(126, sub_message->GetReflection()->GetInt32(*sub_message, import_e_)); 2709 sub_message = &reflection->GetMessage(message, F("optional_lazy_message")); 2710 EXPECT_EQ(127, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); 2711 2712 EXPECT_EQ( nested_baz_, reflection->GetEnum(message, F("optional_nested_enum" ))); 2713 EXPECT_EQ(foreign_baz_, reflection->GetEnum(message, F("optional_foreign_enum"))); 2714 EXPECT_EQ( import_baz_, reflection->GetEnum(message, F("optional_import_enum" ))); 2715 2716 EXPECT_EQ("124", reflection->GetString(message, F("optional_string_piece"))); 2717 EXPECT_EQ("124", reflection->GetStringReference(message, F("optional_string_piece"), &scratch)); 2718 2719 EXPECT_EQ("125", reflection->GetString(message, F("optional_cord"))); 2720 EXPECT_EQ("125", reflection->GetStringReference(message, F("optional_cord"), &scratch)); 2721 2722 EXPECT_TRUE(reflection->HasField(message, F("oneof_bytes" ))); 2723 EXPECT_EQ("604", reflection->GetString(message, F("oneof_bytes" ))); 2724 2725 if (base_descriptor_->name() == "TestAllTypes") { 2726 EXPECT_FALSE(reflection->HasField(message, F("oneof_uint32"))); 2727 EXPECT_FALSE(reflection->HasField(message, F("oneof_string"))); 2728 } else { 2729 EXPECT_TRUE(reflection->HasField(message, F("oneof_uint32"))); 2730 EXPECT_TRUE(reflection->HasField(message, F("oneof_string"))); 2731 EXPECT_EQ(601 , reflection->GetUInt32(message, F("oneof_uint32"))); 2732 EXPECT_EQ("603", reflection->GetString(message, F("oneof_string"))); 2733 sub_message = &reflection->GetMessage(message, F("oneof_nested_message")); 2734 EXPECT_EQ(602, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); 2735 } 2736 } 2737 2738 void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection2( 2739 const Message& message) { 2740 const Reflection* reflection = message.GetReflection(); 2741 string scratch; 2742 const Message* sub_message; 2743 2744 // ----------------------------------------------------------------- 2745 2746 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_int32" ))); 2747 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_int64" ))); 2748 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_uint32" ))); 2749 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_uint64" ))); 2750 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sint32" ))); 2751 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sint64" ))); 2752 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_fixed32" ))); 2753 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_fixed64" ))); 2754 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sfixed32"))); 2755 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sfixed64"))); 2756 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_float" ))); 2757 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_double" ))); 2758 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_bool" ))); 2759 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_string" ))); 2760 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_bytes" ))); 2761 2762 ASSERT_EQ(2, reflection->FieldSize(message, F("repeatedgroup" ))); 2763 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_nested_message" ))); 2764 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_foreign_message"))); 2765 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_import_message" ))); 2766 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_lazy_message" ))); 2767 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_nested_enum" ))); 2768 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_foreign_enum" ))); 2769 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_import_enum" ))); 2770 2771 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_string_piece"))); 2772 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_cord"))); 2773 2774 EXPECT_EQ(201 , reflection->GetRepeatedInt32 (message, F("repeated_int32" ), 0)); 2775 EXPECT_EQ(202 , reflection->GetRepeatedInt64 (message, F("repeated_int64" ), 0)); 2776 EXPECT_EQ(203 , reflection->GetRepeatedUInt32(message, F("repeated_uint32" ), 0)); 2777 EXPECT_EQ(204 , reflection->GetRepeatedUInt64(message, F("repeated_uint64" ), 0)); 2778 EXPECT_EQ(205 , reflection->GetRepeatedInt32 (message, F("repeated_sint32" ), 0)); 2779 EXPECT_EQ(206 , reflection->GetRepeatedInt64 (message, F("repeated_sint64" ), 0)); 2780 EXPECT_EQ(207 , reflection->GetRepeatedUInt32(message, F("repeated_fixed32" ), 0)); 2781 EXPECT_EQ(208 , reflection->GetRepeatedUInt64(message, F("repeated_fixed64" ), 0)); 2782 EXPECT_EQ(209 , reflection->GetRepeatedInt32 (message, F("repeated_sfixed32"), 0)); 2783 EXPECT_EQ(210 , reflection->GetRepeatedInt64 (message, F("repeated_sfixed64"), 0)); 2784 EXPECT_EQ(211 , reflection->GetRepeatedFloat (message, F("repeated_float" ), 0)); 2785 EXPECT_EQ(212 , reflection->GetRepeatedDouble(message, F("repeated_double" ), 0)); 2786 EXPECT_TRUE( reflection->GetRepeatedBool (message, F("repeated_bool" ), 0)); 2787 EXPECT_EQ("215", reflection->GetRepeatedString(message, F("repeated_string" ), 0)); 2788 EXPECT_EQ("216", reflection->GetRepeatedString(message, F("repeated_bytes" ), 0)); 2789 2790 EXPECT_EQ("215", reflection->GetRepeatedStringReference(message, F("repeated_string"), 0, &scratch)); 2791 EXPECT_EQ("216", reflection->GetRepeatedStringReference(message, F("repeated_bytes"), 0, &scratch)); 2792 2793 sub_message = &reflection->GetRepeatedMessage(message, F("repeatedgroup"), 0); 2794 EXPECT_EQ(217, sub_message->GetReflection()->GetInt32(*sub_message, repeated_group_a_)); 2795 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_nested_message"), 0); 2796 EXPECT_EQ(218, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); 2797 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_foreign_message"), 0); 2798 EXPECT_EQ(219, sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_)); 2799 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_import_message"), 0); 2800 EXPECT_EQ(220, sub_message->GetReflection()->GetInt32(*sub_message, import_d_)); 2801 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_lazy_message"), 0); 2802 EXPECT_EQ(227, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); 2803 2804 EXPECT_EQ( nested_bar_, reflection->GetRepeatedEnum(message, F("repeated_nested_enum" ),0)); 2805 EXPECT_EQ(foreign_bar_, reflection->GetRepeatedEnum(message, F("repeated_foreign_enum"),0)); 2806 EXPECT_EQ( import_bar_, reflection->GetRepeatedEnum(message, F("repeated_import_enum" ),0)); 2807 2808 EXPECT_EQ("224", reflection->GetRepeatedString(message, F("repeated_string_piece"), 0)); 2809 EXPECT_EQ("224", reflection->GetRepeatedStringReference( 2810 message, F("repeated_string_piece"), 0, &scratch)); 2811 2812 EXPECT_EQ("225", reflection->GetRepeatedString(message, F("repeated_cord"), 0)); 2813 EXPECT_EQ("225", reflection->GetRepeatedStringReference( 2814 message, F("repeated_cord"), 0, &scratch)); 2815 2816 EXPECT_EQ(301 , reflection->GetRepeatedInt32 (message, F("repeated_int32" ), 1)); 2817 EXPECT_EQ(302 , reflection->GetRepeatedInt64 (message, F("repeated_int64" ), 1)); 2818 EXPECT_EQ(303 , reflection->GetRepeatedUInt32(message, F("repeated_uint32" ), 1)); 2819 EXPECT_EQ(304 , reflection->GetRepeatedUInt64(message, F("repeated_uint64" ), 1)); 2820 EXPECT_EQ(305 , reflection->GetRepeatedInt32 (message, F("repeated_sint32" ), 1)); 2821 EXPECT_EQ(306 , reflection->GetRepeatedInt64 (message, F("repeated_sint64" ), 1)); 2822 EXPECT_EQ(307 , reflection->GetRepeatedUInt32(message, F("repeated_fixed32" ), 1)); 2823 EXPECT_EQ(308 , reflection->GetRepeatedUInt64(message, F("repeated_fixed64" ), 1)); 2824 EXPECT_EQ(309 , reflection->GetRepeatedInt32 (message, F("repeated_sfixed32"), 1)); 2825 EXPECT_EQ(310 , reflection->GetRepeatedInt64 (message, F("repeated_sfixed64"), 1)); 2826 EXPECT_EQ(311 , reflection->GetRepeatedFloat (message, F("repeated_float" ), 1)); 2827 EXPECT_EQ(312 , reflection->GetRepeatedDouble(message, F("repeated_double" ), 1)); 2828 EXPECT_FALSE( reflection->GetRepeatedBool (message, F("repeated_bool" ), 1)); 2829 EXPECT_EQ("315", reflection->GetRepeatedString(message, F("repeated_string" ), 1)); 2830 EXPECT_EQ("316", reflection->GetRepeatedString(message, F("repeated_bytes" ), 1)); 2831 2832 EXPECT_EQ("315", reflection->GetRepeatedStringReference(message, F("repeated_string"), 2833 1, &scratch)); 2834 EXPECT_EQ("316", reflection->GetRepeatedStringReference(message, F("repeated_bytes"), 2835 1, &scratch)); 2836 2837 sub_message = &reflection->GetRepeatedMessage(message, F("repeatedgroup"), 1); 2838 EXPECT_EQ(317, sub_message->GetReflection()->GetInt32(*sub_message, repeated_group_a_)); 2839 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_nested_message"), 1); 2840 EXPECT_EQ(318, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); 2841 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_foreign_message"), 1); 2842 EXPECT_EQ(319, sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_)); 2843 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_import_message"), 1); 2844 EXPECT_EQ(320, sub_message->GetReflection()->GetInt32(*sub_message, import_d_)); 2845 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_lazy_message"), 1); 2846 EXPECT_EQ(327, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); 2847 2848 EXPECT_EQ( nested_baz_, reflection->GetRepeatedEnum(message, F("repeated_nested_enum" ),1)); 2849 EXPECT_EQ(foreign_baz_, reflection->GetRepeatedEnum(message, F("repeated_foreign_enum"),1)); 2850 EXPECT_EQ( import_baz_, reflection->GetRepeatedEnum(message, F("repeated_import_enum" ),1)); 2851 2852 EXPECT_EQ("324", reflection->GetRepeatedString(message, F("repeated_string_piece"), 1)); 2853 EXPECT_EQ("324", reflection->GetRepeatedStringReference( 2854 message, F("repeated_string_piece"), 1, &scratch)); 2855 2856 EXPECT_EQ("325", reflection->GetRepeatedString(message, F("repeated_cord"), 1)); 2857 EXPECT_EQ("325", reflection->GetRepeatedStringReference( 2858 message, F("repeated_cord"), 1, &scratch)); 2859 } 2860 2861 void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection3( 2862 const Message& message) { 2863 const Reflection* reflection = message.GetReflection(); 2864 string scratch; 2865 2866 // ----------------------------------------------------------------- 2867 2868 EXPECT_TRUE(reflection->HasField(message, F("default_int32" ))); 2869 EXPECT_TRUE(reflection->HasField(message, F("default_int64" ))); 2870 EXPECT_TRUE(reflection->HasField(message, F("default_uint32" ))); 2871 EXPECT_TRUE(reflection->HasField(message, F("default_uint64" ))); 2872 EXPECT_TRUE(reflection->HasField(message, F("default_sint32" ))); 2873 EXPECT_TRUE(reflection->HasField(message, F("default_sint64" ))); 2874 EXPECT_TRUE(reflection->HasField(message, F("default_fixed32" ))); 2875 EXPECT_TRUE(reflection->HasField(message, F("default_fixed64" ))); 2876 EXPECT_TRUE(reflection->HasField(message, F("default_sfixed32"))); 2877 EXPECT_TRUE(reflection->HasField(message, F("default_sfixed64"))); 2878 EXPECT_TRUE(reflection->HasField(message, F("default_float" ))); 2879 EXPECT_TRUE(reflection->HasField(message, F("default_double" ))); 2880 EXPECT_TRUE(reflection->HasField(message, F("default_bool" ))); 2881 EXPECT_TRUE(reflection->HasField(message, F("default_string" ))); 2882 EXPECT_TRUE(reflection->HasField(message, F("default_bytes" ))); 2883 2884 EXPECT_TRUE(reflection->HasField(message, F("default_nested_enum" ))); 2885 EXPECT_TRUE(reflection->HasField(message, F("default_foreign_enum"))); 2886 EXPECT_TRUE(reflection->HasField(message, F("default_import_enum" ))); 2887 2888 EXPECT_TRUE(reflection->HasField(message, F("default_string_piece"))); 2889 EXPECT_TRUE(reflection->HasField(message, F("default_cord"))); 2890 2891 EXPECT_EQ(401 , reflection->GetInt32 (message, F("default_int32" ))); 2892 EXPECT_EQ(402 , reflection->GetInt64 (message, F("default_int64" ))); 2893 EXPECT_EQ(403 , reflection->GetUInt32(message, F("default_uint32" ))); 2894 EXPECT_EQ(404 , reflection->GetUInt64(message, F("default_uint64" ))); 2895 EXPECT_EQ(405 , reflection->GetInt32 (message, F("default_sint32" ))); 2896 EXPECT_EQ(406 , reflection->GetInt64 (message, F("default_sint64" ))); 2897 EXPECT_EQ(407 , reflection->GetUInt32(message, F("default_fixed32" ))); 2898 EXPECT_EQ(408 , reflection->GetUInt64(message, F("default_fixed64" ))); 2899 EXPECT_EQ(409 , reflection->GetInt32 (message, F("default_sfixed32"))); 2900 EXPECT_EQ(410 , reflection->GetInt64 (message, F("default_sfixed64"))); 2901 EXPECT_EQ(411 , reflection->GetFloat (message, F("default_float" ))); 2902 EXPECT_EQ(412 , reflection->GetDouble(message, F("default_double" ))); 2903 EXPECT_FALSE( reflection->GetBool (message, F("default_bool" ))); 2904 EXPECT_EQ("415", reflection->GetString(message, F("default_string" ))); 2905 EXPECT_EQ("416", reflection->GetString(message, F("default_bytes" ))); 2906 2907 EXPECT_EQ("415", reflection->GetStringReference(message, F("default_string"), &scratch)); 2908 EXPECT_EQ("416", reflection->GetStringReference(message, F("default_bytes" ), &scratch)); 2909 2910 EXPECT_EQ( nested_foo_, reflection->GetEnum(message, F("default_nested_enum" ))); 2911 EXPECT_EQ(foreign_foo_, reflection->GetEnum(message, F("default_foreign_enum"))); 2912 EXPECT_EQ( import_foo_, reflection->GetEnum(message, F("default_import_enum" ))); 2913 2914 EXPECT_EQ("424", reflection->GetString(message, F("default_string_piece"))); 2915 EXPECT_EQ("424", reflection->GetStringReference(message, F("default_string_piece"), 2916 &scratch)); 2917 2918 EXPECT_EQ("425", reflection->GetString(message, F("default_cord"))); 2919 EXPECT_EQ("425", reflection->GetStringReference(message, F("default_cord"), &scratch)); 2920 } 2921 2922 void TestUtil::ReflectionTester::ExpectPackedFieldsSetViaReflection( 2923 const Message& message) { 2924 const Reflection* reflection = message.GetReflection(); 2925 2926 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_int32" ))); 2927 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_int64" ))); 2928 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_uint32" ))); 2929 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_uint64" ))); 2930 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sint32" ))); 2931 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sint64" ))); 2932 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_fixed32" ))); 2933 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_fixed64" ))); 2934 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sfixed32"))); 2935 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sfixed64"))); 2936 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_float" ))); 2937 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_double" ))); 2938 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_bool" ))); 2939 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_enum" ))); 2940 2941 EXPECT_EQ(601 , reflection->GetRepeatedInt32 (message, F("packed_int32" ), 0)); 2942 EXPECT_EQ(602 , reflection->GetRepeatedInt64 (message, F("packed_int64" ), 0)); 2943 EXPECT_EQ(603 , reflection->GetRepeatedUInt32(message, F("packed_uint32" ), 0)); 2944 EXPECT_EQ(604 , reflection->GetRepeatedUInt64(message, F("packed_uint64" ), 0)); 2945 EXPECT_EQ(605 , reflection->GetRepeatedInt32 (message, F("packed_sint32" ), 0)); 2946 EXPECT_EQ(606 , reflection->GetRepeatedInt64 (message, F("packed_sint64" ), 0)); 2947 EXPECT_EQ(607 , reflection->GetRepeatedUInt32(message, F("packed_fixed32" ), 0)); 2948 EXPECT_EQ(608 , reflection->GetRepeatedUInt64(message, F("packed_fixed64" ), 0)); 2949 EXPECT_EQ(609 , reflection->GetRepeatedInt32 (message, F("packed_sfixed32"), 0)); 2950 EXPECT_EQ(610 , reflection->GetRepeatedInt64 (message, F("packed_sfixed64"), 0)); 2951 EXPECT_EQ(611 , reflection->GetRepeatedFloat (message, F("packed_float" ), 0)); 2952 EXPECT_EQ(612 , reflection->GetRepeatedDouble(message, F("packed_double" ), 0)); 2953 EXPECT_TRUE( reflection->GetRepeatedBool (message, F("packed_bool" ), 0)); 2954 EXPECT_EQ(foreign_bar_, 2955 reflection->GetRepeatedEnum(message, F("packed_enum"), 0)); 2956 2957 EXPECT_EQ(701 , reflection->GetRepeatedInt32 (message, F("packed_int32" ), 1)); 2958 EXPECT_EQ(702 , reflection->GetRepeatedInt64 (message, F("packed_int64" ), 1)); 2959 EXPECT_EQ(703 , reflection->GetRepeatedUInt32(message, F("packed_uint32" ), 1)); 2960 EXPECT_EQ(704 , reflection->GetRepeatedUInt64(message, F("packed_uint64" ), 1)); 2961 EXPECT_EQ(705 , reflection->GetRepeatedInt32 (message, F("packed_sint32" ), 1)); 2962 EXPECT_EQ(706 , reflection->GetRepeatedInt64 (message, F("packed_sint64" ), 1)); 2963 EXPECT_EQ(707 , reflection->GetRepeatedUInt32(message, F("packed_fixed32" ), 1)); 2964 EXPECT_EQ(708 , reflection->GetRepeatedUInt64(message, F("packed_fixed64" ), 1)); 2965 EXPECT_EQ(709 , reflection->GetRepeatedInt32 (message, F("packed_sfixed32"), 1)); 2966 EXPECT_EQ(710 , reflection->GetRepeatedInt64 (message, F("packed_sfixed64"), 1)); 2967 EXPECT_EQ(711 , reflection->GetRepeatedFloat (message, F("packed_float" ), 1)); 2968 EXPECT_EQ(712 , reflection->GetRepeatedDouble(message, F("packed_double" ), 1)); 2969 EXPECT_FALSE( reflection->GetRepeatedBool (message, F("packed_bool" ), 1)); 2970 EXPECT_EQ(foreign_baz_, 2971 reflection->GetRepeatedEnum(message, F("packed_enum"), 1)); 2972 } 2973 2974 // ------------------------------------------------------------------- 2975 2976 void TestUtil::ReflectionTester::ExpectClearViaReflection( 2977 const Message& message) { 2978 const Reflection* reflection = message.GetReflection(); 2979 string scratch; 2980 const Message* sub_message; 2981 2982 // has_blah() should initially be false for all optional fields. 2983 EXPECT_FALSE(reflection->HasField(message, F("optional_int32" ))); 2984 EXPECT_FALSE(reflection->HasField(message, F("optional_int64" ))); 2985 EXPECT_FALSE(reflection->HasField(message, F("optional_uint32" ))); 2986 EXPECT_FALSE(reflection->HasField(message, F("optional_uint64" ))); 2987 EXPECT_FALSE(reflection->HasField(message, F("optional_sint32" ))); 2988 EXPECT_FALSE(reflection->HasField(message, F("optional_sint64" ))); 2989 EXPECT_FALSE(reflection->HasField(message, F("optional_fixed32" ))); 2990 EXPECT_FALSE(reflection->HasField(message, F("optional_fixed64" ))); 2991 EXPECT_FALSE(reflection->HasField(message, F("optional_sfixed32"))); 2992 EXPECT_FALSE(reflection->HasField(message, F("optional_sfixed64"))); 2993 EXPECT_FALSE(reflection->HasField(message, F("optional_float" ))); 2994 EXPECT_FALSE(reflection->HasField(message, F("optional_double" ))); 2995 EXPECT_FALSE(reflection->HasField(message, F("optional_bool" ))); 2996 EXPECT_FALSE(reflection->HasField(message, F("optional_string" ))); 2997 EXPECT_FALSE(reflection->HasField(message, F("optional_bytes" ))); 2998 2999 EXPECT_FALSE(reflection->HasField(message, F("optionalgroup" ))); 3000 EXPECT_FALSE(reflection->HasField(message, F("optional_nested_message" ))); 3001 EXPECT_FALSE(reflection->HasField(message, F("optional_foreign_message"))); 3002 EXPECT_FALSE(reflection->HasField(message, F("optional_import_message" ))); 3003 EXPECT_FALSE(reflection->HasField(message, F("optional_public_import_message"))); 3004 EXPECT_FALSE(reflection->HasField(message, F("optional_lazy_message"))); 3005 3006 EXPECT_FALSE(reflection->HasField(message, F("optional_nested_enum" ))); 3007 EXPECT_FALSE(reflection->HasField(message, F("optional_foreign_enum"))); 3008 EXPECT_FALSE(reflection->HasField(message, F("optional_import_enum" ))); 3009 3010 EXPECT_FALSE(reflection->HasField(message, F("optional_string_piece"))); 3011 EXPECT_FALSE(reflection->HasField(message, F("optional_cord"))); 3012 3013 // Optional fields without defaults are set to zero or something like it. 3014 EXPECT_EQ(0 , reflection->GetInt32 (message, F("optional_int32" ))); 3015 EXPECT_EQ(0 , reflection->GetInt64 (message, F("optional_int64" ))); 3016 EXPECT_EQ(0 , reflection->GetUInt32(message, F("optional_uint32" ))); 3017 EXPECT_EQ(0 , reflection->GetUInt64(message, F("optional_uint64" ))); 3018 EXPECT_EQ(0 , reflection->GetInt32 (message, F("optional_sint32" ))); 3019 EXPECT_EQ(0 , reflection->GetInt64 (message, F("optional_sint64" ))); 3020 EXPECT_EQ(0 , reflection->GetUInt32(message, F("optional_fixed32" ))); 3021 EXPECT_EQ(0 , reflection->GetUInt64(message, F("optional_fixed64" ))); 3022 EXPECT_EQ(0 , reflection->GetInt32 (message, F("optional_sfixed32"))); 3023 EXPECT_EQ(0 , reflection->GetInt64 (message, F("optional_sfixed64"))); 3024 EXPECT_EQ(0 , reflection->GetFloat (message, F("optional_float" ))); 3025 EXPECT_EQ(0 , reflection->GetDouble(message, F("optional_double" ))); 3026 EXPECT_FALSE( reflection->GetBool (message, F("optional_bool" ))); 3027 EXPECT_EQ("" , reflection->GetString(message, F("optional_string" ))); 3028 EXPECT_EQ("" , reflection->GetString(message, F("optional_bytes" ))); 3029 3030 EXPECT_EQ("", reflection->GetStringReference(message, F("optional_string"), &scratch)); 3031 EXPECT_EQ("", reflection->GetStringReference(message, F("optional_bytes" ), &scratch)); 3032 3033 // Embedded messages should also be clear. 3034 sub_message = &reflection->GetMessage(message, F("optionalgroup")); 3035 EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, group_a_)); 3036 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, group_a_)); 3037 sub_message = &reflection->GetMessage(message, F("optional_nested_message")); 3038 EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, nested_b_)); 3039 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); 3040 sub_message = &reflection->GetMessage(message, F("optional_foreign_message")); 3041 EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, foreign_c_)); 3042 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_)); 3043 sub_message = &reflection->GetMessage(message, F("optional_import_message")); 3044 EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, import_d_)); 3045 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, import_d_)); 3046 sub_message = &reflection->GetMessage(message, F("optional_public_import_message")); 3047 EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, import_e_)); 3048 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, import_e_)); 3049 sub_message = &reflection->GetMessage(message, F("optional_lazy_message")); 3050 EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, nested_b_)); 3051 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); 3052 3053 // Enums without defaults are set to the first value in the enum. 3054 EXPECT_EQ( nested_foo_, reflection->GetEnum(message, F("optional_nested_enum" ))); 3055 EXPECT_EQ(foreign_foo_, reflection->GetEnum(message, F("optional_foreign_enum"))); 3056 EXPECT_EQ( import_foo_, reflection->GetEnum(message, F("optional_import_enum" ))); 3057 3058 EXPECT_EQ("", reflection->GetString(message, F("optional_string_piece"))); 3059 EXPECT_EQ("", reflection->GetStringReference(message, F("optional_string_piece"), &scratch)); 3060 3061 EXPECT_EQ("", reflection->GetString(message, F("optional_cord"))); 3062 EXPECT_EQ("", reflection->GetStringReference(message, F("optional_cord"), &scratch)); 3063 3064 // Repeated fields are empty. 3065 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_int32" ))); 3066 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_int64" ))); 3067 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_uint32" ))); 3068 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_uint64" ))); 3069 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sint32" ))); 3070 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sint64" ))); 3071 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_fixed32" ))); 3072 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_fixed64" ))); 3073 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sfixed32"))); 3074 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sfixed64"))); 3075 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_float" ))); 3076 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_double" ))); 3077 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_bool" ))); 3078 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_string" ))); 3079 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_bytes" ))); 3080 3081 EXPECT_EQ(0, reflection->FieldSize(message, F("repeatedgroup" ))); 3082 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_nested_message" ))); 3083 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_foreign_message"))); 3084 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_import_message" ))); 3085 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_lazy_message" ))); 3086 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_nested_enum" ))); 3087 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_foreign_enum" ))); 3088 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_import_enum" ))); 3089 3090 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_string_piece"))); 3091 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_cord"))); 3092 3093 // has_blah() should also be false for all default fields. 3094 EXPECT_FALSE(reflection->HasField(message, F("default_int32" ))); 3095 EXPECT_FALSE(reflection->HasField(message, F("default_int64" ))); 3096 EXPECT_FALSE(reflection->HasField(message, F("default_uint32" ))); 3097 EXPECT_FALSE(reflection->HasField(message, F("default_uint64" ))); 3098 EXPECT_FALSE(reflection->HasField(message, F("default_sint32" ))); 3099 EXPECT_FALSE(reflection->HasField(message, F("default_sint64" ))); 3100 EXPECT_FALSE(reflection->HasField(message, F("default_fixed32" ))); 3101 EXPECT_FALSE(reflection->HasField(message, F("default_fixed64" ))); 3102 EXPECT_FALSE(reflection->HasField(message, F("default_sfixed32"))); 3103 EXPECT_FALSE(reflection->HasField(message, F("default_sfixed64"))); 3104 EXPECT_FALSE(reflection->HasField(message, F("default_float" ))); 3105 EXPECT_FALSE(reflection->HasField(message, F("default_double" ))); 3106 EXPECT_FALSE(reflection->HasField(message, F("default_bool" ))); 3107 EXPECT_FALSE(reflection->HasField(message, F("default_string" ))); 3108 EXPECT_FALSE(reflection->HasField(message, F("default_bytes" ))); 3109 3110 EXPECT_FALSE(reflection->HasField(message, F("default_nested_enum" ))); 3111 EXPECT_FALSE(reflection->HasField(message, F("default_foreign_enum"))); 3112 EXPECT_FALSE(reflection->HasField(message, F("default_import_enum" ))); 3113 3114 EXPECT_FALSE(reflection->HasField(message, F("default_string_piece"))); 3115 EXPECT_FALSE(reflection->HasField(message, F("default_cord"))); 3116 3117 // Fields with defaults have their default values (duh). 3118 EXPECT_EQ( 41 , reflection->GetInt32 (message, F("default_int32" ))); 3119 EXPECT_EQ( 42 , reflection->GetInt64 (message, F("default_int64" ))); 3120 EXPECT_EQ( 43 , reflection->GetUInt32(message, F("default_uint32" ))); 3121 EXPECT_EQ( 44 , reflection->GetUInt64(message, F("default_uint64" ))); 3122 EXPECT_EQ(-45 , reflection->GetInt32 (message, F("default_sint32" ))); 3123 EXPECT_EQ( 46 , reflection->GetInt64 (message, F("default_sint64" ))); 3124 EXPECT_EQ( 47 , reflection->GetUInt32(message, F("default_fixed32" ))); 3125 EXPECT_EQ( 48 , reflection->GetUInt64(message, F("default_fixed64" ))); 3126 EXPECT_EQ( 49 , reflection->GetInt32 (message, F("default_sfixed32"))); 3127 EXPECT_EQ(-50 , reflection->GetInt64 (message, F("default_sfixed64"))); 3128 EXPECT_EQ( 51.5 , reflection->GetFloat (message, F("default_float" ))); 3129 EXPECT_EQ( 52e3 , reflection->GetDouble(message, F("default_double" ))); 3130 EXPECT_TRUE( reflection->GetBool (message, F("default_bool" ))); 3131 EXPECT_EQ("hello", reflection->GetString(message, F("default_string" ))); 3132 EXPECT_EQ("world", reflection->GetString(message, F("default_bytes" ))); 3133 3134 EXPECT_EQ("hello", reflection->GetStringReference(message, F("default_string"), &scratch)); 3135 EXPECT_EQ("world", reflection->GetStringReference(message, F("default_bytes" ), &scratch)); 3136 3137 EXPECT_EQ( nested_bar_, reflection->GetEnum(message, F("default_nested_enum" ))); 3138 EXPECT_EQ(foreign_bar_, reflection->GetEnum(message, F("default_foreign_enum"))); 3139 EXPECT_EQ( import_bar_, reflection->GetEnum(message, F("default_import_enum" ))); 3140 3141 EXPECT_EQ("abc", reflection->GetString(message, F("default_string_piece"))); 3142 EXPECT_EQ("abc", reflection->GetStringReference(message, F("default_string_piece"), &scratch)); 3143 3144 EXPECT_EQ("123", reflection->GetString(message, F("default_cord"))); 3145 EXPECT_EQ("123", reflection->GetStringReference(message, F("default_cord"), &scratch)); 3146 } 3147 3148 void TestUtil::ReflectionTester::ExpectPackedClearViaReflection( 3149 const Message& message) { 3150 const Reflection* reflection = message.GetReflection(); 3151 3152 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_int32" ))); 3153 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_int64" ))); 3154 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_uint32" ))); 3155 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_uint64" ))); 3156 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_sint32" ))); 3157 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_sint64" ))); 3158 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_fixed32" ))); 3159 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_fixed64" ))); 3160 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_sfixed32"))); 3161 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_sfixed64"))); 3162 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_float" ))); 3163 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_double" ))); 3164 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_bool" ))); 3165 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_enum" ))); 3166 } 3167 3168 // ------------------------------------------------------------------- 3169 3170 void TestUtil::ReflectionTester::ModifyRepeatedFieldsViaReflection( 3171 Message* message) { 3172 const Reflection* reflection = message->GetReflection(); 3173 Message* sub_message; 3174 3175 reflection->SetRepeatedInt32 (message, F("repeated_int32" ), 1, 501); 3176 reflection->SetRepeatedInt64 (message, F("repeated_int64" ), 1, 502); 3177 reflection->SetRepeatedUInt32(message, F("repeated_uint32" ), 1, 503); 3178 reflection->SetRepeatedUInt64(message, F("repeated_uint64" ), 1, 504); 3179 reflection->SetRepeatedInt32 (message, F("repeated_sint32" ), 1, 505); 3180 reflection->SetRepeatedInt64 (message, F("repeated_sint64" ), 1, 506); 3181 reflection->SetRepeatedUInt32(message, F("repeated_fixed32" ), 1, 507); 3182 reflection->SetRepeatedUInt64(message, F("repeated_fixed64" ), 1, 508); 3183 reflection->SetRepeatedInt32 (message, F("repeated_sfixed32"), 1, 509); 3184 reflection->SetRepeatedInt64 (message, F("repeated_sfixed64"), 1, 510); 3185 reflection->SetRepeatedFloat (message, F("repeated_float" ), 1, 511); 3186 reflection->SetRepeatedDouble(message, F("repeated_double" ), 1, 512); 3187 reflection->SetRepeatedBool (message, F("repeated_bool" ), 1, true); 3188 reflection->SetRepeatedString(message, F("repeated_string" ), 1, "515"); 3189 reflection->SetRepeatedString(message, F("repeated_bytes" ), 1, "516"); 3190 3191 sub_message = reflection->MutableRepeatedMessage(message, F("repeatedgroup"), 1); 3192 sub_message->GetReflection()->SetInt32(sub_message, repeated_group_a_, 517); 3193 sub_message = reflection->MutableRepeatedMessage(message, F("repeated_nested_message"), 1); 3194 sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 518); 3195 sub_message = reflection->MutableRepeatedMessage(message, F("repeated_foreign_message"), 1); 3196 sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 519); 3197 sub_message = reflection->MutableRepeatedMessage(message, F("repeated_import_message"), 1); 3198 sub_message->GetReflection()->SetInt32(sub_message, import_d_, 520); 3199 sub_message = reflection->MutableRepeatedMessage(message, F("repeated_lazy_message"), 1); 3200 sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 527); 3201 3202 reflection->SetRepeatedEnum(message, F("repeated_nested_enum" ), 1, nested_foo_); 3203 reflection->SetRepeatedEnum(message, F("repeated_foreign_enum"), 1, foreign_foo_); 3204 reflection->SetRepeatedEnum(message, F("repeated_import_enum" ), 1, import_foo_); 3205 3206 reflection->SetRepeatedString(message, F("repeated_string_piece"), 1, "524"); 3207 reflection->SetRepeatedString(message, F("repeated_cord"), 1, "525"); 3208 } 3209 3210 void TestUtil::ReflectionTester::ModifyPackedFieldsViaReflection( 3211 Message* message) { 3212 const Reflection* reflection = message->GetReflection(); 3213 reflection->SetRepeatedInt32 (message, F("packed_int32" ), 1, 801); 3214 reflection->SetRepeatedInt64 (message, F("packed_int64" ), 1, 802); 3215 reflection->SetRepeatedUInt32(message, F("packed_uint32" ), 1, 803); 3216 reflection->SetRepeatedUInt64(message, F("packed_uint64" ), 1, 804); 3217 reflection->SetRepeatedInt32 (message, F("packed_sint32" ), 1, 805); 3218 reflection->SetRepeatedInt64 (message, F("packed_sint64" ), 1, 806); 3219 reflection->SetRepeatedUInt32(message, F("packed_fixed32" ), 1, 807); 3220 reflection->SetRepeatedUInt64(message, F("packed_fixed64" ), 1, 808); 3221 reflection->SetRepeatedInt32 (message, F("packed_sfixed32"), 1, 809); 3222 reflection->SetRepeatedInt64 (message, F("packed_sfixed64"), 1, 810); 3223 reflection->SetRepeatedFloat (message, F("packed_float" ), 1, 811); 3224 reflection->SetRepeatedDouble(message, F("packed_double" ), 1, 812); 3225 reflection->SetRepeatedBool (message, F("packed_bool" ), 1, true); 3226 reflection->SetRepeatedEnum (message, F("packed_enum" ), 1, foreign_foo_); 3227 } 3228 3229 void TestUtil::ReflectionTester::RemoveLastRepeatedsViaReflection( 3230 Message* message) { 3231 const Reflection* reflection = message->GetReflection(); 3232 3233 vector<const FieldDescriptor*> output; 3234 reflection->ListFields(*message, &output); 3235 for (int i=0; i<output.size(); ++i) { 3236 const FieldDescriptor* field = output[i]; 3237 if (!field->is_repeated()) continue; 3238 3239 reflection->RemoveLast(message, field); 3240 } 3241 } 3242 3243 void TestUtil::ReflectionTester::ReleaseLastRepeatedsViaReflection( 3244 Message* message, bool expect_extensions_notnull) { 3245 const Reflection* reflection = message->GetReflection(); 3246 3247 vector<const FieldDescriptor*> output; 3248 reflection->ListFields(*message, &output); 3249 for (int i=0; i<output.size(); ++i) { 3250 const FieldDescriptor* field = output[i]; 3251 if (!field->is_repeated()) continue; 3252 if (field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) continue; 3253 3254 Message* released = reflection->ReleaseLast(message, field); 3255 if (!field->is_extension() || expect_extensions_notnull) { 3256 ASSERT_TRUE(released != NULL) << "ReleaseLast returned NULL for: " 3257 << field->name(); 3258 } 3259 delete released; 3260 } 3261 } 3262 3263 void TestUtil::ReflectionTester::SwapRepeatedsViaReflection(Message* message) { 3264 const Reflection* reflection = message->GetReflection(); 3265 3266 vector<const FieldDescriptor*> output; 3267 reflection->ListFields(*message, &output); 3268 for (int i=0; i<output.size(); ++i) { 3269 const FieldDescriptor* field = output[i]; 3270 if (!field->is_repeated()) continue; 3271 3272 reflection->SwapElements(message, field, 0, 1); 3273 } 3274 } 3275 3276 void TestUtil::ReflectionTester:: 3277 SetAllocatedOptionalMessageFieldsToNullViaReflection( 3278 Message* message) { 3279 const Reflection* reflection = message->GetReflection(); 3280 3281 vector<const FieldDescriptor*> fields; 3282 reflection->ListFields(*message, &fields); 3283 3284 for (int i = 0; i < fields.size(); ++i) { 3285 const FieldDescriptor* field = fields[i]; 3286 if (!field->is_optional() || 3287 field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) continue; 3288 3289 reflection->SetAllocatedMessage(message, NULL, field); 3290 } 3291 } 3292 3293 void TestUtil::ReflectionTester:: 3294 SetAllocatedOptionalMessageFieldsToMessageViaReflection( 3295 Message* from_message, 3296 Message* to_message) { 3297 EXPECT_EQ(from_message->GetDescriptor(), to_message->GetDescriptor()); 3298 const Reflection* from_reflection = from_message->GetReflection(); 3299 const Reflection* to_reflection = to_message->GetReflection(); 3300 3301 vector<const FieldDescriptor*> fields; 3302 from_reflection->ListFields(*from_message, &fields); 3303 3304 for (int i = 0; i < fields.size(); ++i) { 3305 const FieldDescriptor* field = fields[i]; 3306 if (!field->is_optional() || 3307 field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) continue; 3308 3309 Message* sub_message = 3310 from_reflection->ReleaseMessage(from_message, field); 3311 to_reflection->SetAllocatedMessage(to_message, sub_message, field); 3312 } 3313 } 3314 3315 void TestUtil::ReflectionTester::ExpectMessagesReleasedViaReflection( 3316 Message* message, 3317 TestUtil::ReflectionTester::MessageReleaseState expected_release_state) { 3318 const Reflection* reflection = message->GetReflection(); 3319 3320 static const char* fields[] = { 3321 "optionalgroup", 3322 "optional_nested_message", 3323 "optional_foreign_message", 3324 "optional_import_message", 3325 }; 3326 for (int i = 0; i < GOOGLE_ARRAYSIZE(fields); i++) { 3327 const Message& sub_message = reflection->GetMessage(*message, F(fields[i])); 3328 Message* released = reflection->ReleaseMessage(message, F(fields[i])); 3329 switch (expected_release_state) { 3330 case IS_NULL: 3331 EXPECT_TRUE(released == NULL); 3332 break; 3333 case NOT_NULL: 3334 EXPECT_TRUE(released != NULL); 3335 EXPECT_EQ(&sub_message, released); 3336 break; 3337 case CAN_BE_NULL: 3338 break; 3339 } 3340 delete released; 3341 EXPECT_FALSE(reflection->HasField(*message, F(fields[i]))); 3342 } 3343 } 3344 3345 } // namespace protobuf 3346 } // namespace google 3347
