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