src/third_party/protobuf/src/google/protobuf/test_util.cc

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