src/google/protobuf/test_util_lite.cc

   1 // Protocol Buffers - Google's data interchange format
   2 // Copyright 2008 Google Inc.  All rights reserved.
   3 // https://developers.google.com/protocol-buffers/
   4 //
   5 // Redistribution and use in source and binary forms, with or without
   6 // modification, are permitted provided that the following conditions are
   7 // met:
   8 //
   9 //     * Redistributions of source code must retain the above copyright
  10 // notice, this list of conditions and the following disclaimer.
  11 //     * Redistributions in binary form must reproduce the above
  12 // copyright notice, this list of conditions and the following disclaimer
  13 // in the documentation and/or other materials provided with the
  14 // distribution.
  15 //     * Neither the name of Google Inc. nor the names of its
  16 // contributors may be used to endorse or promote products derived from
  17 // this software without specific prior written permission.
  18 //
  19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30
  31 // Author: kenton@google.com (Kenton Varda)
  32 //  Based on original Protocol Buffers design by
  33 //  Sanjay Ghemawat, Jeff Dean, and others.
  34
  35 #include <google/protobuf/test_util_lite.h>
  36 #include <google/protobuf/stubs/common.h>
  37
  38
  39 #define EXPECT_TRUE GOOGLE_CHECK
  40 #define ASSERT_TRUE GOOGLE_CHECK
  41 #define EXPECT_FALSE(COND) GOOGLE_CHECK(!(COND))
  42 #define EXPECT_EQ GOOGLE_CHECK_EQ
  43 #define ASSERT_EQ GOOGLE_CHECK_EQ
  44
  45 namespace google {
  46 namespace protobuf {
  47
  48 void TestUtilLite::SetAllFields(unittest::TestAllTypesLite* message) {
  49   message->set_optional_int32   (101);
  50   message->set_optional_int64   (102);
  51   message->set_optional_uint32  (103);
  52   message->set_optional_uint64  (104);
  53   message->set_optional_sint32  (105);
  54   message->set_optional_sint64  (106);
  55   message->set_optional_fixed32 (107);
  56   message->set_optional_fixed64 (108);
  57   message->set_optional_sfixed32(109);
  58   message->set_optional_sfixed64(110);
  59   message->set_optional_float   (111);
  60   message->set_optional_double  (112);
  61   message->set_optional_bool    (true);
  62   message->set_optional_string  ("115");
  63   message->set_optional_bytes   ("116");
  64
  65   message->mutable_optionalgroup                 ()->set_a(117);
  66   message->mutable_optional_nested_message       ()->set_bb(118);
  67   message->mutable_optional_foreign_message      ()->set_c(119);
  68   message->mutable_optional_import_message       ()->set_d(120);
  69   message->mutable_optional_public_import_message()->set_e(126);
  70   message->mutable_optional_lazy_message         ()->set_bb(127);
  71
  72   message->set_optional_nested_enum (unittest::TestAllTypesLite::BAZ );
  73   message->set_optional_foreign_enum(unittest::FOREIGN_LITE_BAZ      );
  74   message->set_optional_import_enum (unittest_import::IMPORT_LITE_BAZ);
  75
  76
  77   // -----------------------------------------------------------------
  78
  79   message->add_repeated_int32   (201);
  80   message->add_repeated_int64   (202);
  81   message->add_repeated_uint32  (203);
  82   message->add_repeated_uint64  (204);
  83   message->add_repeated_sint32  (205);
  84   message->add_repeated_sint64  (206);
  85   message->add_repeated_fixed32 (207);
  86   message->add_repeated_fixed64 (208);
  87   message->add_repeated_sfixed32(209);
  88   message->add_repeated_sfixed64(210);
  89   message->add_repeated_float   (211);
  90   message->add_repeated_double  (212);
  91   message->add_repeated_bool    (true);
  92   message->add_repeated_string  ("215");
  93   message->add_repeated_bytes   ("216");
  94
  95   message->add_repeatedgroup           ()->set_a(217);
  96   message->add_repeated_nested_message ()->set_bb(218);
  97   message->add_repeated_foreign_message()->set_c(219);
  98   message->add_repeated_import_message ()->set_d(220);
  99   message->add_repeated_lazy_message   ()->set_bb(227);
 100
 101   message->add_repeated_nested_enum (unittest::TestAllTypesLite::BAR );
 102   message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAR      );
 103   message->add_repeated_import_enum (unittest_import::IMPORT_LITE_BAR);
 104
 105
 106   // Add a second one of each field.
 107   message->add_repeated_int32   (301);
 108   message->add_repeated_int64   (302);
 109   message->add_repeated_uint32  (303);
 110   message->add_repeated_uint64  (304);
 111   message->add_repeated_sint32  (305);
 112   message->add_repeated_sint64  (306);
 113   message->add_repeated_fixed32 (307);
 114   message->add_repeated_fixed64 (308);
 115   message->add_repeated_sfixed32(309);
 116   message->add_repeated_sfixed64(310);
 117   message->add_repeated_float   (311);
 118   message->add_repeated_double  (312);
 119   message->add_repeated_bool    (false);
 120   message->add_repeated_string  ("315");
 121   message->add_repeated_bytes   ("316");
 122
 123   message->add_repeatedgroup           ()->set_a(317);
 124   message->add_repeated_nested_message ()->set_bb(318);
 125   message->add_repeated_foreign_message()->set_c(319);
 126   message->add_repeated_import_message ()->set_d(320);
 127   message->add_repeated_lazy_message   ()->set_bb(327);
 128
 129   message->add_repeated_nested_enum (unittest::TestAllTypesLite::BAZ );
 130   message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAZ      );
 131   message->add_repeated_import_enum (unittest_import::IMPORT_LITE_BAZ);
 132
 133
 134   // -----------------------------------------------------------------
 135
 136   message->set_default_int32   (401);
 137   message->set_default_int64   (402);
 138   message->set_default_uint32  (403);
 139   message->set_default_uint64  (404);
 140   message->set_default_sint32  (405);
 141   message->set_default_sint64  (406);
 142   message->set_default_fixed32 (407);
 143   message->set_default_fixed64 (408);
 144   message->set_default_sfixed32(409);
 145   message->set_default_sfixed64(410);
 146   message->set_default_float   (411);
 147   message->set_default_double  (412);
 148   message->set_default_bool    (false);
 149   message->set_default_string  ("415");
 150   message->set_default_bytes   ("416");
 151
 152   message->set_default_nested_enum (unittest::TestAllTypesLite::FOO );
 153   message->set_default_foreign_enum(unittest::FOREIGN_LITE_FOO      );
 154   message->set_default_import_enum (unittest_import::IMPORT_LITE_FOO);
 155
 156
 157   message->set_oneof_uint32(601);
 158   message->mutable_oneof_nested_message()->set_bb(602);
 159   message->set_oneof_string("603");
 160   message->set_oneof_bytes("604");
 161 }
 162
 163 // -------------------------------------------------------------------
 164
 165 void TestUtilLite::ModifyRepeatedFields(unittest::TestAllTypesLite* message) {
 166   message->set_repeated_int32   (1, 501);
 167   message->set_repeated_int64   (1, 502);
 168   message->set_repeated_uint32  (1, 503);
 169   message->set_repeated_uint64  (1, 504);
 170   message->set_repeated_sint32  (1, 505);
 171   message->set_repeated_sint64  (1, 506);
 172   message->set_repeated_fixed32 (1, 507);
 173   message->set_repeated_fixed64 (1, 508);
 174   message->set_repeated_sfixed32(1, 509);
 175   message->set_repeated_sfixed64(1, 510);
 176   message->set_repeated_float   (1, 511);
 177   message->set_repeated_double  (1, 512);
 178   message->set_repeated_bool    (1, true);
 179   message->set_repeated_string  (1, "515");
 180   message->set_repeated_bytes   (1, "516");
 181
 182   message->mutable_repeatedgroup           (1)->set_a(517);
 183   message->mutable_repeated_nested_message (1)->set_bb(518);
 184   message->mutable_repeated_foreign_message(1)->set_c(519);
 185   message->mutable_repeated_import_message (1)->set_d(520);
 186   message->mutable_repeated_lazy_message   (1)->set_bb(527);
 187
 188   message->set_repeated_nested_enum (1, unittest::TestAllTypesLite::FOO );
 189   message->set_repeated_foreign_enum(1, unittest::FOREIGN_LITE_FOO      );
 190   message->set_repeated_import_enum (1, unittest_import::IMPORT_LITE_FOO);
 191
 192 }
 193
 194 // -------------------------------------------------------------------
 195
 196 void TestUtilLite::ExpectAllFieldsSet(
 197     const unittest::TestAllTypesLite& message) {
 198   EXPECT_TRUE(message.has_optional_int32   ());
 199   EXPECT_TRUE(message.has_optional_int64   ());
 200   EXPECT_TRUE(message.has_optional_uint32  ());
 201   EXPECT_TRUE(message.has_optional_uint64  ());
 202   EXPECT_TRUE(message.has_optional_sint32  ());
 203   EXPECT_TRUE(message.has_optional_sint64  ());
 204   EXPECT_TRUE(message.has_optional_fixed32 ());
 205   EXPECT_TRUE(message.has_optional_fixed64 ());
 206   EXPECT_TRUE(message.has_optional_sfixed32());
 207   EXPECT_TRUE(message.has_optional_sfixed64());
 208   EXPECT_TRUE(message.has_optional_float   ());
 209   EXPECT_TRUE(message.has_optional_double  ());
 210   EXPECT_TRUE(message.has_optional_bool    ());
 211   EXPECT_TRUE(message.has_optional_string  ());
 212   EXPECT_TRUE(message.has_optional_bytes   ());
 213
 214   EXPECT_TRUE(message.has_optionalgroup                 ());
 215   EXPECT_TRUE(message.has_optional_nested_message       ());
 216   EXPECT_TRUE(message.has_optional_foreign_message      ());
 217   EXPECT_TRUE(message.has_optional_import_message       ());
 218   EXPECT_TRUE(message.has_optional_public_import_message());
 219   EXPECT_TRUE(message.has_optional_lazy_message         ());
 220
 221   EXPECT_TRUE(message.optionalgroup                 ().has_a());
 222   EXPECT_TRUE(message.optional_nested_message       ().has_bb());
 223   EXPECT_TRUE(message.optional_foreign_message      ().has_c());
 224   EXPECT_TRUE(message.optional_import_message       ().has_d());
 225   EXPECT_TRUE(message.optional_public_import_message().has_e());
 226   EXPECT_TRUE(message.optional_lazy_message         ().has_bb());
 227
 228   EXPECT_TRUE(message.has_optional_nested_enum ());
 229   EXPECT_TRUE(message.has_optional_foreign_enum());
 230   EXPECT_TRUE(message.has_optional_import_enum ());
 231
 232
 233   EXPECT_EQ(101  , message.optional_int32   ());
 234   EXPECT_EQ(102  , message.optional_int64   ());
 235   EXPECT_EQ(103  , message.optional_uint32  ());
 236   EXPECT_EQ(104  , message.optional_uint64  ());
 237   EXPECT_EQ(105  , message.optional_sint32  ());
 238   EXPECT_EQ(106  , message.optional_sint64  ());
 239   EXPECT_EQ(107  , message.optional_fixed32 ());
 240   EXPECT_EQ(108  , message.optional_fixed64 ());
 241   EXPECT_EQ(109  , message.optional_sfixed32());
 242   EXPECT_EQ(110  , message.optional_sfixed64());
 243   EXPECT_EQ(111  , message.optional_float   ());
 244   EXPECT_EQ(112  , message.optional_double  ());
 245   EXPECT_EQ(true , message.optional_bool    ());
 246   EXPECT_EQ("115", message.optional_string  ());
 247   EXPECT_EQ("116", message.optional_bytes   ());
 248
 249   EXPECT_EQ(117, message.optionalgroup                 ().a());
 250   EXPECT_EQ(118, message.optional_nested_message       ().bb());
 251   EXPECT_EQ(119, message.optional_foreign_message      ().c());
 252   EXPECT_EQ(120, message.optional_import_message       ().d());
 253   EXPECT_EQ(126, message.optional_public_import_message().e());
 254   EXPECT_EQ(127, message.optional_lazy_message         ().bb());
 255
 256   EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.optional_nested_enum ());
 257   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ      , message.optional_foreign_enum());
 258   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.optional_import_enum ());
 259
 260
 261   // -----------------------------------------------------------------
 262
 263   ASSERT_EQ(2, message.repeated_int32_size   ());
 264   ASSERT_EQ(2, message.repeated_int64_size   ());
 265   ASSERT_EQ(2, message.repeated_uint32_size  ());
 266   ASSERT_EQ(2, message.repeated_uint64_size  ());
 267   ASSERT_EQ(2, message.repeated_sint32_size  ());
 268   ASSERT_EQ(2, message.repeated_sint64_size  ());
 269   ASSERT_EQ(2, message.repeated_fixed32_size ());
 270   ASSERT_EQ(2, message.repeated_fixed64_size ());
 271   ASSERT_EQ(2, message.repeated_sfixed32_size());
 272   ASSERT_EQ(2, message.repeated_sfixed64_size());
 273   ASSERT_EQ(2, message.repeated_float_size   ());
 274   ASSERT_EQ(2, message.repeated_double_size  ());
 275   ASSERT_EQ(2, message.repeated_bool_size    ());
 276   ASSERT_EQ(2, message.repeated_string_size  ());
 277   ASSERT_EQ(2, message.repeated_bytes_size   ());
 278
 279   ASSERT_EQ(2, message.repeatedgroup_size           ());
 280   ASSERT_EQ(2, message.repeated_nested_message_size ());
 281   ASSERT_EQ(2, message.repeated_foreign_message_size());
 282   ASSERT_EQ(2, message.repeated_import_message_size ());
 283   ASSERT_EQ(2, message.repeated_lazy_message_size   ());
 284   ASSERT_EQ(2, message.repeated_nested_enum_size    ());
 285   ASSERT_EQ(2, message.repeated_foreign_enum_size   ());
 286   ASSERT_EQ(2, message.repeated_import_enum_size    ());
 287
 288
 289   EXPECT_EQ(201  , message.repeated_int32   (0));
 290   EXPECT_EQ(202  , message.repeated_int64   (0));
 291   EXPECT_EQ(203  , message.repeated_uint32  (0));
 292   EXPECT_EQ(204  , message.repeated_uint64  (0));
 293   EXPECT_EQ(205  , message.repeated_sint32  (0));
 294   EXPECT_EQ(206  , message.repeated_sint64  (0));
 295   EXPECT_EQ(207  , message.repeated_fixed32 (0));
 296   EXPECT_EQ(208  , message.repeated_fixed64 (0));
 297   EXPECT_EQ(209  , message.repeated_sfixed32(0));
 298   EXPECT_EQ(210  , message.repeated_sfixed64(0));
 299   EXPECT_EQ(211  , message.repeated_float   (0));
 300   EXPECT_EQ(212  , message.repeated_double  (0));
 301   EXPECT_EQ(true , message.repeated_bool    (0));
 302   EXPECT_EQ("215", message.repeated_string  (0));
 303   EXPECT_EQ("216", message.repeated_bytes   (0));
 304
 305   EXPECT_EQ(217, message.repeatedgroup           (0).a());
 306   EXPECT_EQ(218, message.repeated_nested_message (0).bb());
 307   EXPECT_EQ(219, message.repeated_foreign_message(0).c());
 308   EXPECT_EQ(220, message.repeated_import_message (0).d());
 309   EXPECT_EQ(227, message.repeated_lazy_message   (0).bb());
 310
 311
 312   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.repeated_nested_enum (0));
 313   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.repeated_foreign_enum(0));
 314   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum (0));
 315
 316   EXPECT_EQ(301  , message.repeated_int32   (1));
 317   EXPECT_EQ(302  , message.repeated_int64   (1));
 318   EXPECT_EQ(303  , message.repeated_uint32  (1));
 319   EXPECT_EQ(304  , message.repeated_uint64  (1));
 320   EXPECT_EQ(305  , message.repeated_sint32  (1));
 321   EXPECT_EQ(306  , message.repeated_sint64  (1));
 322   EXPECT_EQ(307  , message.repeated_fixed32 (1));
 323   EXPECT_EQ(308  , message.repeated_fixed64 (1));
 324   EXPECT_EQ(309  , message.repeated_sfixed32(1));
 325   EXPECT_EQ(310  , message.repeated_sfixed64(1));
 326   EXPECT_EQ(311  , message.repeated_float   (1));
 327   EXPECT_EQ(312  , message.repeated_double  (1));
 328   EXPECT_EQ(false, message.repeated_bool    (1));
 329   EXPECT_EQ("315", message.repeated_string  (1));
 330   EXPECT_EQ("316", message.repeated_bytes   (1));
 331
 332   EXPECT_EQ(317, message.repeatedgroup           (1).a());
 333   EXPECT_EQ(318, message.repeated_nested_message (1).bb());
 334   EXPECT_EQ(319, message.repeated_foreign_message(1).c());
 335   EXPECT_EQ(320, message.repeated_import_message (1).d());
 336   EXPECT_EQ(327, message.repeated_lazy_message   (1).bb());
 337
 338   EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.repeated_nested_enum (1));
 339   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ      , message.repeated_foreign_enum(1));
 340   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.repeated_import_enum (1));
 341
 342
 343   // -----------------------------------------------------------------
 344
 345   EXPECT_TRUE(message.has_default_int32   ());
 346   EXPECT_TRUE(message.has_default_int64   ());
 347   EXPECT_TRUE(message.has_default_uint32  ());
 348   EXPECT_TRUE(message.has_default_uint64  ());
 349   EXPECT_TRUE(message.has_default_sint32  ());
 350   EXPECT_TRUE(message.has_default_sint64  ());
 351   EXPECT_TRUE(message.has_default_fixed32 ());
 352   EXPECT_TRUE(message.has_default_fixed64 ());
 353   EXPECT_TRUE(message.has_default_sfixed32());
 354   EXPECT_TRUE(message.has_default_sfixed64());
 355   EXPECT_TRUE(message.has_default_float   ());
 356   EXPECT_TRUE(message.has_default_double  ());
 357   EXPECT_TRUE(message.has_default_bool    ());
 358   EXPECT_TRUE(message.has_default_string  ());
 359   EXPECT_TRUE(message.has_default_bytes   ());
 360
 361   EXPECT_TRUE(message.has_default_nested_enum ());
 362   EXPECT_TRUE(message.has_default_foreign_enum());
 363   EXPECT_TRUE(message.has_default_import_enum ());
 364
 365
 366   EXPECT_EQ(401  , message.default_int32   ());
 367   EXPECT_EQ(402  , message.default_int64   ());
 368   EXPECT_EQ(403  , message.default_uint32  ());
 369   EXPECT_EQ(404  , message.default_uint64  ());
 370   EXPECT_EQ(405  , message.default_sint32  ());
 371   EXPECT_EQ(406  , message.default_sint64  ());
 372   EXPECT_EQ(407  , message.default_fixed32 ());
 373   EXPECT_EQ(408  , message.default_fixed64 ());
 374   EXPECT_EQ(409  , message.default_sfixed32());
 375   EXPECT_EQ(410  , message.default_sfixed64());
 376   EXPECT_EQ(411  , message.default_float   ());
 377   EXPECT_EQ(412  , message.default_double  ());
 378   EXPECT_EQ(false, message.default_bool    ());
 379   EXPECT_EQ("415", message.default_string  ());
 380   EXPECT_EQ("416", message.default_bytes   ());
 381
 382   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.default_nested_enum ());
 383   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.default_foreign_enum());
 384   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.default_import_enum ());
 385
 386
 387   EXPECT_FALSE(message.has_oneof_uint32        ());
 388   EXPECT_FALSE(message.has_oneof_nested_message());
 389   EXPECT_FALSE(message.has_oneof_string        ());
 390   EXPECT_TRUE(message.has_oneof_bytes          ());
 391
 392   EXPECT_EQ("604", message.oneof_bytes());
 393 }
 394
 395 // -------------------------------------------------------------------
 396
 397 void TestUtilLite::ExpectClear(const unittest::TestAllTypesLite& message) {
 398   // has_blah() should initially be false for all optional fields.
 399   EXPECT_FALSE(message.has_optional_int32   ());
 400   EXPECT_FALSE(message.has_optional_int64   ());
 401   EXPECT_FALSE(message.has_optional_uint32  ());
 402   EXPECT_FALSE(message.has_optional_uint64  ());
 403   EXPECT_FALSE(message.has_optional_sint32  ());
 404   EXPECT_FALSE(message.has_optional_sint64  ());
 405   EXPECT_FALSE(message.has_optional_fixed32 ());
 406   EXPECT_FALSE(message.has_optional_fixed64 ());
 407   EXPECT_FALSE(message.has_optional_sfixed32());
 408   EXPECT_FALSE(message.has_optional_sfixed64());
 409   EXPECT_FALSE(message.has_optional_float   ());
 410   EXPECT_FALSE(message.has_optional_double  ());
 411   EXPECT_FALSE(message.has_optional_bool    ());
 412   EXPECT_FALSE(message.has_optional_string  ());
 413   EXPECT_FALSE(message.has_optional_bytes   ());
 414
 415   EXPECT_FALSE(message.has_optionalgroup                 ());
 416   EXPECT_FALSE(message.has_optional_nested_message       ());
 417   EXPECT_FALSE(message.has_optional_foreign_message      ());
 418   EXPECT_FALSE(message.has_optional_import_message       ());
 419   EXPECT_FALSE(message.has_optional_public_import_message());
 420   EXPECT_FALSE(message.has_optional_lazy_message         ());
 421
 422   EXPECT_FALSE(message.has_optional_nested_enum ());
 423   EXPECT_FALSE(message.has_optional_foreign_enum());
 424   EXPECT_FALSE(message.has_optional_import_enum ());
 425
 426
 427   // Optional fields without defaults are set to zero or something like it.
 428   EXPECT_EQ(0    , message.optional_int32   ());
 429   EXPECT_EQ(0    , message.optional_int64   ());
 430   EXPECT_EQ(0    , message.optional_uint32  ());
 431   EXPECT_EQ(0    , message.optional_uint64  ());
 432   EXPECT_EQ(0    , message.optional_sint32  ());
 433   EXPECT_EQ(0    , message.optional_sint64  ());
 434   EXPECT_EQ(0    , message.optional_fixed32 ());
 435   EXPECT_EQ(0    , message.optional_fixed64 ());
 436   EXPECT_EQ(0    , message.optional_sfixed32());
 437   EXPECT_EQ(0    , message.optional_sfixed64());
 438   EXPECT_EQ(0    , message.optional_float   ());
 439   EXPECT_EQ(0    , message.optional_double  ());
 440   EXPECT_EQ(false, message.optional_bool    ());
 441   EXPECT_EQ(""   , message.optional_string  ());
 442   EXPECT_EQ(""   , message.optional_bytes   ());
 443
 444   // Embedded messages should also be clear.
 445   EXPECT_FALSE(message.optionalgroup                 ().has_a());
 446   EXPECT_FALSE(message.optional_nested_message       ().has_bb());
 447   EXPECT_FALSE(message.optional_foreign_message      ().has_c());
 448   EXPECT_FALSE(message.optional_import_message       ().has_d());
 449   EXPECT_FALSE(message.optional_public_import_message().has_e());
 450   EXPECT_FALSE(message.optional_lazy_message         ().has_bb());
 451
 452   EXPECT_EQ(0, message.optionalgroup           ().a());
 453   EXPECT_EQ(0, message.optional_nested_message ().bb());
 454   EXPECT_EQ(0, message.optional_foreign_message().c());
 455   EXPECT_EQ(0, message.optional_import_message ().d());
 456
 457   // Enums without defaults are set to the first value in the enum.
 458   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.optional_nested_enum ());
 459   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.optional_foreign_enum());
 460   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.optional_import_enum ());
 461
 462
 463   // Repeated fields are empty.
 464   EXPECT_EQ(0, message.repeated_int32_size   ());
 465   EXPECT_EQ(0, message.repeated_int64_size   ());
 466   EXPECT_EQ(0, message.repeated_uint32_size  ());
 467   EXPECT_EQ(0, message.repeated_uint64_size  ());
 468   EXPECT_EQ(0, message.repeated_sint32_size  ());
 469   EXPECT_EQ(0, message.repeated_sint64_size  ());
 470   EXPECT_EQ(0, message.repeated_fixed32_size ());
 471   EXPECT_EQ(0, message.repeated_fixed64_size ());
 472   EXPECT_EQ(0, message.repeated_sfixed32_size());
 473   EXPECT_EQ(0, message.repeated_sfixed64_size());
 474   EXPECT_EQ(0, message.repeated_float_size   ());
 475   EXPECT_EQ(0, message.repeated_double_size  ());
 476   EXPECT_EQ(0, message.repeated_bool_size    ());
 477   EXPECT_EQ(0, message.repeated_string_size  ());
 478   EXPECT_EQ(0, message.repeated_bytes_size   ());
 479
 480   EXPECT_EQ(0, message.repeatedgroup_size           ());
 481   EXPECT_EQ(0, message.repeated_nested_message_size ());
 482   EXPECT_EQ(0, message.repeated_foreign_message_size());
 483   EXPECT_EQ(0, message.repeated_import_message_size ());
 484   EXPECT_EQ(0, message.repeated_lazy_message_size   ());
 485   EXPECT_EQ(0, message.repeated_nested_enum_size    ());
 486   EXPECT_EQ(0, message.repeated_foreign_enum_size   ());
 487   EXPECT_EQ(0, message.repeated_import_enum_size    ());
 488
 489
 490   // has_blah() should also be false for all default fields.
 491   EXPECT_FALSE(message.has_default_int32   ());
 492   EXPECT_FALSE(message.has_default_int64   ());
 493   EXPECT_FALSE(message.has_default_uint32  ());
 494   EXPECT_FALSE(message.has_default_uint64  ());
 495   EXPECT_FALSE(message.has_default_sint32  ());
 496   EXPECT_FALSE(message.has_default_sint64  ());
 497   EXPECT_FALSE(message.has_default_fixed32 ());
 498   EXPECT_FALSE(message.has_default_fixed64 ());
 499   EXPECT_FALSE(message.has_default_sfixed32());
 500   EXPECT_FALSE(message.has_default_sfixed64());
 501   EXPECT_FALSE(message.has_default_float   ());
 502   EXPECT_FALSE(message.has_default_double  ());
 503   EXPECT_FALSE(message.has_default_bool    ());
 504   EXPECT_FALSE(message.has_default_string  ());
 505   EXPECT_FALSE(message.has_default_bytes   ());
 506
 507   EXPECT_FALSE(message.has_default_nested_enum ());
 508   EXPECT_FALSE(message.has_default_foreign_enum());
 509   EXPECT_FALSE(message.has_default_import_enum ());
 510
 511
 512   // Fields with defaults have their default values (duh).
 513   EXPECT_EQ( 41    , message.default_int32   ());
 514   EXPECT_EQ( 42    , message.default_int64   ());
 515   EXPECT_EQ( 43    , message.default_uint32  ());
 516   EXPECT_EQ( 44    , message.default_uint64  ());
 517   EXPECT_EQ(-45    , message.default_sint32  ());
 518   EXPECT_EQ( 46    , message.default_sint64  ());
 519   EXPECT_EQ( 47    , message.default_fixed32 ());
 520   EXPECT_EQ( 48    , message.default_fixed64 ());
 521   EXPECT_EQ( 49    , message.default_sfixed32());
 522   EXPECT_EQ(-50    , message.default_sfixed64());
 523   EXPECT_EQ( 51.5  , message.default_float   ());
 524   EXPECT_EQ( 52e3  , message.default_double  ());
 525   EXPECT_EQ(true   , message.default_bool    ());
 526   EXPECT_EQ("hello", message.default_string  ());
 527   EXPECT_EQ("world", message.default_bytes   ());
 528
 529   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.default_nested_enum ());
 530   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.default_foreign_enum());
 531   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.default_import_enum ());
 532
 533
 534   EXPECT_FALSE(message.has_oneof_uint32        ());
 535   EXPECT_FALSE(message.has_oneof_nested_message());
 536   EXPECT_FALSE(message.has_oneof_string        ());
 537   EXPECT_FALSE(message.has_oneof_bytes         ());
 538 }
 539
 540 // -------------------------------------------------------------------
 541
 542 void TestUtilLite::ExpectRepeatedFieldsModified(
 543     const unittest::TestAllTypesLite& message) {
 544   // ModifyRepeatedFields only sets the second repeated element of each
 545   // field.  In addition to verifying this, we also verify that the first
 546   // element and size were *not* modified.
 547   ASSERT_EQ(2, message.repeated_int32_size   ());
 548   ASSERT_EQ(2, message.repeated_int64_size   ());
 549   ASSERT_EQ(2, message.repeated_uint32_size  ());
 550   ASSERT_EQ(2, message.repeated_uint64_size  ());
 551   ASSERT_EQ(2, message.repeated_sint32_size  ());
 552   ASSERT_EQ(2, message.repeated_sint64_size  ());
 553   ASSERT_EQ(2, message.repeated_fixed32_size ());
 554   ASSERT_EQ(2, message.repeated_fixed64_size ());
 555   ASSERT_EQ(2, message.repeated_sfixed32_size());
 556   ASSERT_EQ(2, message.repeated_sfixed64_size());
 557   ASSERT_EQ(2, message.repeated_float_size   ());
 558   ASSERT_EQ(2, message.repeated_double_size  ());
 559   ASSERT_EQ(2, message.repeated_bool_size    ());
 560   ASSERT_EQ(2, message.repeated_string_size  ());
 561   ASSERT_EQ(2, message.repeated_bytes_size   ());
 562
 563   ASSERT_EQ(2, message.repeatedgroup_size           ());
 564   ASSERT_EQ(2, message.repeated_nested_message_size ());
 565   ASSERT_EQ(2, message.repeated_foreign_message_size());
 566   ASSERT_EQ(2, message.repeated_import_message_size ());
 567   ASSERT_EQ(2, message.repeated_lazy_message_size   ());
 568   ASSERT_EQ(2, message.repeated_nested_enum_size    ());
 569   ASSERT_EQ(2, message.repeated_foreign_enum_size   ());
 570   ASSERT_EQ(2, message.repeated_import_enum_size    ());
 571
 572
 573   EXPECT_EQ(201  , message.repeated_int32   (0));
 574   EXPECT_EQ(202  , message.repeated_int64   (0));
 575   EXPECT_EQ(203  , message.repeated_uint32  (0));
 576   EXPECT_EQ(204  , message.repeated_uint64  (0));
 577   EXPECT_EQ(205  , message.repeated_sint32  (0));
 578   EXPECT_EQ(206  , message.repeated_sint64  (0));
 579   EXPECT_EQ(207  , message.repeated_fixed32 (0));
 580   EXPECT_EQ(208  , message.repeated_fixed64 (0));
 581   EXPECT_EQ(209  , message.repeated_sfixed32(0));
 582   EXPECT_EQ(210  , message.repeated_sfixed64(0));
 583   EXPECT_EQ(211  , message.repeated_float   (0));
 584   EXPECT_EQ(212  , message.repeated_double  (0));
 585   EXPECT_EQ(true , message.repeated_bool    (0));
 586   EXPECT_EQ("215", message.repeated_string  (0));
 587   EXPECT_EQ("216", message.repeated_bytes   (0));
 588
 589   EXPECT_EQ(217, message.repeatedgroup           (0).a());
 590   EXPECT_EQ(218, message.repeated_nested_message (0).bb());
 591   EXPECT_EQ(219, message.repeated_foreign_message(0).c());
 592   EXPECT_EQ(220, message.repeated_import_message (0).d());
 593   EXPECT_EQ(227, message.repeated_lazy_message   (0).bb());
 594
 595   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.repeated_nested_enum (0));
 596   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.repeated_foreign_enum(0));
 597   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum (0));
 598
 599
 600   // Actually verify the second (modified) elements now.
 601   EXPECT_EQ(501  , message.repeated_int32   (1));
 602   EXPECT_EQ(502  , message.repeated_int64   (1));
 603   EXPECT_EQ(503  , message.repeated_uint32  (1));
 604   EXPECT_EQ(504  , message.repeated_uint64  (1));
 605   EXPECT_EQ(505  , message.repeated_sint32  (1));
 606   EXPECT_EQ(506  , message.repeated_sint64  (1));
 607   EXPECT_EQ(507  , message.repeated_fixed32 (1));
 608   EXPECT_EQ(508  , message.repeated_fixed64 (1));
 609   EXPECT_EQ(509  , message.repeated_sfixed32(1));
 610   EXPECT_EQ(510  , message.repeated_sfixed64(1));
 611   EXPECT_EQ(511  , message.repeated_float   (1));
 612   EXPECT_EQ(512  , message.repeated_double  (1));
 613   EXPECT_EQ(true , message.repeated_bool    (1));
 614   EXPECT_EQ("515", message.repeated_string  (1));
 615   EXPECT_EQ("516", message.repeated_bytes   (1));
 616
 617   EXPECT_EQ(517, message.repeatedgroup           (1).a());
 618   EXPECT_EQ(518, message.repeated_nested_message (1).bb());
 619   EXPECT_EQ(519, message.repeated_foreign_message(1).c());
 620   EXPECT_EQ(520, message.repeated_import_message (1).d());
 621   EXPECT_EQ(527, message.repeated_lazy_message   (1).bb());
 622
 623   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.repeated_nested_enum (1));
 624   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.repeated_foreign_enum(1));
 625   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.repeated_import_enum (1));
 626
 627 }
 628
 629 // -------------------------------------------------------------------
 630
 631 void TestUtilLite::SetPackedFields(unittest::TestPackedTypesLite* message) {
 632   message->add_packed_int32   (601);
 633   message->add_packed_int64   (602);
 634   message->add_packed_uint32  (603);
 635   message->add_packed_uint64  (604);
 636   message->add_packed_sint32  (605);
 637   message->add_packed_sint64  (606);
 638   message->add_packed_fixed32 (607);
 639   message->add_packed_fixed64 (608);
 640   message->add_packed_sfixed32(609);
 641   message->add_packed_sfixed64(610);
 642   message->add_packed_float   (611);
 643   message->add_packed_double  (612);
 644   message->add_packed_bool    (true);
 645   message->add_packed_enum    (unittest::FOREIGN_LITE_BAR);
 646   // add a second one of each field
 647   message->add_packed_int32   (701);
 648   message->add_packed_int64   (702);
 649   message->add_packed_uint32  (703);
 650   message->add_packed_uint64  (704);
 651   message->add_packed_sint32  (705);
 652   message->add_packed_sint64  (706);
 653   message->add_packed_fixed32 (707);
 654   message->add_packed_fixed64 (708);
 655   message->add_packed_sfixed32(709);
 656   message->add_packed_sfixed64(710);
 657   message->add_packed_float   (711);
 658   message->add_packed_double  (712);
 659   message->add_packed_bool    (false);
 660   message->add_packed_enum    (unittest::FOREIGN_LITE_BAZ);
 661 }
 662
 663 // -------------------------------------------------------------------
 664
 665 void TestUtilLite::ModifyPackedFields(unittest::TestPackedTypesLite* message) {
 666   message->set_packed_int32   (1, 801);
 667   message->set_packed_int64   (1, 802);
 668   message->set_packed_uint32  (1, 803);
 669   message->set_packed_uint64  (1, 804);
 670   message->set_packed_sint32  (1, 805);
 671   message->set_packed_sint64  (1, 806);
 672   message->set_packed_fixed32 (1, 807);
 673   message->set_packed_fixed64 (1, 808);
 674   message->set_packed_sfixed32(1, 809);
 675   message->set_packed_sfixed64(1, 810);
 676   message->set_packed_float   (1, 811);
 677   message->set_packed_double  (1, 812);
 678   message->set_packed_bool    (1, true);
 679   message->set_packed_enum    (1, unittest::FOREIGN_LITE_FOO);
 680 }
 681
 682 // -------------------------------------------------------------------
 683
 684 void TestUtilLite::ExpectPackedFieldsSet(
 685     const unittest::TestPackedTypesLite& message) {
 686   ASSERT_EQ(2, message.packed_int32_size   ());
 687   ASSERT_EQ(2, message.packed_int64_size   ());
 688   ASSERT_EQ(2, message.packed_uint32_size  ());
 689   ASSERT_EQ(2, message.packed_uint64_size  ());
 690   ASSERT_EQ(2, message.packed_sint32_size  ());
 691   ASSERT_EQ(2, message.packed_sint64_size  ());
 692   ASSERT_EQ(2, message.packed_fixed32_size ());
 693   ASSERT_EQ(2, message.packed_fixed64_size ());
 694   ASSERT_EQ(2, message.packed_sfixed32_size());
 695   ASSERT_EQ(2, message.packed_sfixed64_size());
 696   ASSERT_EQ(2, message.packed_float_size   ());
 697   ASSERT_EQ(2, message.packed_double_size  ());
 698   ASSERT_EQ(2, message.packed_bool_size    ());
 699   ASSERT_EQ(2, message.packed_enum_size    ());
 700
 701   EXPECT_EQ(601  , message.packed_int32   (0));
 702   EXPECT_EQ(602  , message.packed_int64   (0));
 703   EXPECT_EQ(603  , message.packed_uint32  (0));
 704   EXPECT_EQ(604  , message.packed_uint64  (0));
 705   EXPECT_EQ(605  , message.packed_sint32  (0));
 706   EXPECT_EQ(606  , message.packed_sint64  (0));
 707   EXPECT_EQ(607  , message.packed_fixed32 (0));
 708   EXPECT_EQ(608  , message.packed_fixed64 (0));
 709   EXPECT_EQ(609  , message.packed_sfixed32(0));
 710   EXPECT_EQ(610  , message.packed_sfixed64(0));
 711   EXPECT_EQ(611  , message.packed_float   (0));
 712   EXPECT_EQ(612  , message.packed_double  (0));
 713   EXPECT_EQ(true , message.packed_bool    (0));
 714   EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0));
 715
 716   EXPECT_EQ(701  , message.packed_int32   (1));
 717   EXPECT_EQ(702  , message.packed_int64   (1));
 718   EXPECT_EQ(703  , message.packed_uint32  (1));
 719   EXPECT_EQ(704  , message.packed_uint64  (1));
 720   EXPECT_EQ(705  , message.packed_sint32  (1));
 721   EXPECT_EQ(706  , message.packed_sint64  (1));
 722   EXPECT_EQ(707  , message.packed_fixed32 (1));
 723   EXPECT_EQ(708  , message.packed_fixed64 (1));
 724   EXPECT_EQ(709  , message.packed_sfixed32(1));
 725   EXPECT_EQ(710  , message.packed_sfixed64(1));
 726   EXPECT_EQ(711  , message.packed_float   (1));
 727   EXPECT_EQ(712  , message.packed_double  (1));
 728   EXPECT_EQ(false, message.packed_bool    (1));
 729   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ, message.packed_enum(1));
 730 }
 731
 732 // -------------------------------------------------------------------
 733
 734 void TestUtilLite::ExpectPackedClear(
 735     const unittest::TestPackedTypesLite& message) {
 736   // Packed repeated fields are empty.
 737   EXPECT_EQ(0, message.packed_int32_size   ());
 738   EXPECT_EQ(0, message.packed_int64_size   ());
 739   EXPECT_EQ(0, message.packed_uint32_size  ());
 740   EXPECT_EQ(0, message.packed_uint64_size  ());
 741   EXPECT_EQ(0, message.packed_sint32_size  ());
 742   EXPECT_EQ(0, message.packed_sint64_size  ());
 743   EXPECT_EQ(0, message.packed_fixed32_size ());
 744   EXPECT_EQ(0, message.packed_fixed64_size ());
 745   EXPECT_EQ(0, message.packed_sfixed32_size());
 746   EXPECT_EQ(0, message.packed_sfixed64_size());
 747   EXPECT_EQ(0, message.packed_float_size   ());
 748   EXPECT_EQ(0, message.packed_double_size  ());
 749   EXPECT_EQ(0, message.packed_bool_size    ());
 750   EXPECT_EQ(0, message.packed_enum_size    ());
 751 }
 752
 753 // -------------------------------------------------------------------
 754
 755 void TestUtilLite::ExpectPackedFieldsModified(
 756     const unittest::TestPackedTypesLite& message) {
 757   // Do the same for packed repeated fields.
 758   ASSERT_EQ(2, message.packed_int32_size   ());
 759   ASSERT_EQ(2, message.packed_int64_size   ());
 760   ASSERT_EQ(2, message.packed_uint32_size  ());
 761   ASSERT_EQ(2, message.packed_uint64_size  ());
 762   ASSERT_EQ(2, message.packed_sint32_size  ());
 763   ASSERT_EQ(2, message.packed_sint64_size  ());
 764   ASSERT_EQ(2, message.packed_fixed32_size ());
 765   ASSERT_EQ(2, message.packed_fixed64_size ());
 766   ASSERT_EQ(2, message.packed_sfixed32_size());
 767   ASSERT_EQ(2, message.packed_sfixed64_size());
 768   ASSERT_EQ(2, message.packed_float_size   ());
 769   ASSERT_EQ(2, message.packed_double_size  ());
 770   ASSERT_EQ(2, message.packed_bool_size    ());
 771   ASSERT_EQ(2, message.packed_enum_size    ());
 772
 773   EXPECT_EQ(601  , message.packed_int32   (0));
 774   EXPECT_EQ(602  , message.packed_int64   (0));
 775   EXPECT_EQ(603  , message.packed_uint32  (0));
 776   EXPECT_EQ(604  , message.packed_uint64  (0));
 777   EXPECT_EQ(605  , message.packed_sint32  (0));
 778   EXPECT_EQ(606  , message.packed_sint64  (0));
 779   EXPECT_EQ(607  , message.packed_fixed32 (0));
 780   EXPECT_EQ(608  , message.packed_fixed64 (0));
 781   EXPECT_EQ(609  , message.packed_sfixed32(0));
 782   EXPECT_EQ(610  , message.packed_sfixed64(0));
 783   EXPECT_EQ(611  , message.packed_float   (0));
 784   EXPECT_EQ(612  , message.packed_double  (0));
 785   EXPECT_EQ(true , message.packed_bool    (0));
 786   EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0));
 787   // Actually verify the second (modified) elements now.
 788   EXPECT_EQ(801  , message.packed_int32   (1));
 789   EXPECT_EQ(802  , message.packed_int64   (1));
 790   EXPECT_EQ(803  , message.packed_uint32  (1));
 791   EXPECT_EQ(804  , message.packed_uint64  (1));
 792   EXPECT_EQ(805  , message.packed_sint32  (1));
 793   EXPECT_EQ(806  , message.packed_sint64  (1));
 794   EXPECT_EQ(807  , message.packed_fixed32 (1));
 795   EXPECT_EQ(808  , message.packed_fixed64 (1));
 796   EXPECT_EQ(809  , message.packed_sfixed32(1));
 797   EXPECT_EQ(810  , message.packed_sfixed64(1));
 798   EXPECT_EQ(811  , message.packed_float   (1));
 799   EXPECT_EQ(812  , message.packed_double  (1));
 800   EXPECT_EQ(true , message.packed_bool    (1));
 801   EXPECT_EQ(unittest::FOREIGN_LITE_FOO, message.packed_enum(1));
 802 }
 803
 804 // ===================================================================
 805 // Extensions
 806 //
 807 // All this code is exactly equivalent to the above code except that it's
 808 // manipulating extension fields instead of normal ones.
 809 //
 810 // I gave up on the 80-char limit here.  Sorry.
 811
 812 void TestUtilLite::SetAllExtensions(unittest::TestAllExtensionsLite* message) {
 813   message->SetExtension(unittest::optional_int32_extension_lite   , 101);
 814   message->SetExtension(unittest::optional_int64_extension_lite   , 102);
 815   message->SetExtension(unittest::optional_uint32_extension_lite  , 103);
 816   message->SetExtension(unittest::optional_uint64_extension_lite  , 104);
 817   message->SetExtension(unittest::optional_sint32_extension_lite  , 105);
 818   message->SetExtension(unittest::optional_sint64_extension_lite  , 106);
 819   message->SetExtension(unittest::optional_fixed32_extension_lite , 107);
 820   message->SetExtension(unittest::optional_fixed64_extension_lite , 108);
 821   message->SetExtension(unittest::optional_sfixed32_extension_lite, 109);
 822   message->SetExtension(unittest::optional_sfixed64_extension_lite, 110);
 823   message->SetExtension(unittest::optional_float_extension_lite   , 111);
 824   message->SetExtension(unittest::optional_double_extension_lite  , 112);
 825   message->SetExtension(unittest::optional_bool_extension_lite    , true);
 826   message->SetExtension(unittest::optional_string_extension_lite  , "115");
 827   message->SetExtension(unittest::optional_bytes_extension_lite   , "116");
 828
 829   message->MutableExtension(unittest::optionalgroup_extension_lite                 )->set_a(117);
 830   message->MutableExtension(unittest::optional_nested_message_extension_lite       )->set_bb(118);
 831   message->MutableExtension(unittest::optional_foreign_message_extension_lite      )->set_c(119);
 832   message->MutableExtension(unittest::optional_import_message_extension_lite       )->set_d(120);
 833   message->MutableExtension(unittest::optional_public_import_message_extension_lite)->set_e(126);
 834   message->MutableExtension(unittest::optional_lazy_message_extension_lite         )->set_bb(127);
 835
 836   message->SetExtension(unittest::optional_nested_enum_extension_lite , unittest::TestAllTypesLite::BAZ );
 837   message->SetExtension(unittest::optional_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAZ      );
 838   message->SetExtension(unittest::optional_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAZ);
 839
 840
 841   // -----------------------------------------------------------------
 842
 843   message->AddExtension(unittest::repeated_int32_extension_lite   , 201);
 844   message->AddExtension(unittest::repeated_int64_extension_lite   , 202);
 845   message->AddExtension(unittest::repeated_uint32_extension_lite  , 203);
 846   message->AddExtension(unittest::repeated_uint64_extension_lite  , 204);
 847   message->AddExtension(unittest::repeated_sint32_extension_lite  , 205);
 848   message->AddExtension(unittest::repeated_sint64_extension_lite  , 206);
 849   message->AddExtension(unittest::repeated_fixed32_extension_lite , 207);
 850   message->AddExtension(unittest::repeated_fixed64_extension_lite , 208);
 851   message->AddExtension(unittest::repeated_sfixed32_extension_lite, 209);
 852   message->AddExtension(unittest::repeated_sfixed64_extension_lite, 210);
 853   message->AddExtension(unittest::repeated_float_extension_lite   , 211);
 854   message->AddExtension(unittest::repeated_double_extension_lite  , 212);
 855   message->AddExtension(unittest::repeated_bool_extension_lite    , true);
 856   message->AddExtension(unittest::repeated_string_extension_lite  , "215");
 857   message->AddExtension(unittest::repeated_bytes_extension_lite   , "216");
 858
 859   message->AddExtension(unittest::repeatedgroup_extension_lite           )->set_a(217);
 860   message->AddExtension(unittest::repeated_nested_message_extension_lite )->set_bb(218);
 861   message->AddExtension(unittest::repeated_foreign_message_extension_lite)->set_c(219);
 862   message->AddExtension(unittest::repeated_import_message_extension_lite )->set_d(220);
 863   message->AddExtension(unittest::repeated_lazy_message_extension_lite   )->set_bb(227);
 864
 865   message->AddExtension(unittest::repeated_nested_enum_extension_lite , unittest::TestAllTypesLite::BAR );
 866   message->AddExtension(unittest::repeated_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAR      );
 867   message->AddExtension(unittest::repeated_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAR);
 868
 869
 870   // Add a second one of each field.
 871   message->AddExtension(unittest::repeated_int32_extension_lite   , 301);
 872   message->AddExtension(unittest::repeated_int64_extension_lite   , 302);
 873   message->AddExtension(unittest::repeated_uint32_extension_lite  , 303);
 874   message->AddExtension(unittest::repeated_uint64_extension_lite  , 304);
 875   message->AddExtension(unittest::repeated_sint32_extension_lite  , 305);
 876   message->AddExtension(unittest::repeated_sint64_extension_lite  , 306);
 877   message->AddExtension(unittest::repeated_fixed32_extension_lite , 307);
 878   message->AddExtension(unittest::repeated_fixed64_extension_lite , 308);
 879   message->AddExtension(unittest::repeated_sfixed32_extension_lite, 309);
 880   message->AddExtension(unittest::repeated_sfixed64_extension_lite, 310);
 881   message->AddExtension(unittest::repeated_float_extension_lite   , 311);
 882   message->AddExtension(unittest::repeated_double_extension_lite  , 312);
 883   message->AddExtension(unittest::repeated_bool_extension_lite    , false);
 884   message->AddExtension(unittest::repeated_string_extension_lite  , "315");
 885   message->AddExtension(unittest::repeated_bytes_extension_lite   , "316");
 886
 887   message->AddExtension(unittest::repeatedgroup_extension_lite           )->set_a(317);
 888   message->AddExtension(unittest::repeated_nested_message_extension_lite )->set_bb(318);
 889   message->AddExtension(unittest::repeated_foreign_message_extension_lite)->set_c(319);
 890   message->AddExtension(unittest::repeated_import_message_extension_lite )->set_d(320);
 891   message->AddExtension(unittest::repeated_lazy_message_extension_lite   )->set_bb(327);
 892
 893   message->AddExtension(unittest::repeated_nested_enum_extension_lite , unittest::TestAllTypesLite::BAZ );
 894   message->AddExtension(unittest::repeated_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAZ      );
 895   message->AddExtension(unittest::repeated_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAZ);
 896
 897
 898   // -----------------------------------------------------------------
 899
 900   message->SetExtension(unittest::default_int32_extension_lite   , 401);
 901   message->SetExtension(unittest::default_int64_extension_lite   , 402);
 902   message->SetExtension(unittest::default_uint32_extension_lite  , 403);
 903   message->SetExtension(unittest::default_uint64_extension_lite  , 404);
 904   message->SetExtension(unittest::default_sint32_extension_lite  , 405);
 905   message->SetExtension(unittest::default_sint64_extension_lite  , 406);
 906   message->SetExtension(unittest::default_fixed32_extension_lite , 407);
 907   message->SetExtension(unittest::default_fixed64_extension_lite , 408);
 908   message->SetExtension(unittest::default_sfixed32_extension_lite, 409);
 909   message->SetExtension(unittest::default_sfixed64_extension_lite, 410);
 910   message->SetExtension(unittest::default_float_extension_lite   , 411);
 911   message->SetExtension(unittest::default_double_extension_lite  , 412);
 912   message->SetExtension(unittest::default_bool_extension_lite    , false);
 913   message->SetExtension(unittest::default_string_extension_lite  , "415");
 914   message->SetExtension(unittest::default_bytes_extension_lite   , "416");
 915
 916   message->SetExtension(unittest::default_nested_enum_extension_lite , unittest::TestAllTypesLite::FOO );
 917   message->SetExtension(unittest::default_foreign_enum_extension_lite, unittest::FOREIGN_LITE_FOO      );
 918   message->SetExtension(unittest::default_import_enum_extension_lite , unittest_import::IMPORT_LITE_FOO);
 919
 920
 921   message->SetExtension(unittest::oneof_uint32_extension_lite, 601);
 922   message->MutableExtension(unittest::oneof_nested_message_extension_lite)->set_bb(602);;
 923   message->SetExtension(unittest::oneof_string_extension_lite, "603");
 924   message->SetExtension(unittest::oneof_bytes_extension_lite, "604");
 925 }
 926
 927 // -------------------------------------------------------------------
 928
 929 void TestUtilLite::ModifyRepeatedExtensions(
 930     unittest::TestAllExtensionsLite* message) {
 931   message->SetExtension(unittest::repeated_int32_extension_lite   , 1, 501);
 932   message->SetExtension(unittest::repeated_int64_extension_lite   , 1, 502);
 933   message->SetExtension(unittest::repeated_uint32_extension_lite  , 1, 503);
 934   message->SetExtension(unittest::repeated_uint64_extension_lite  , 1, 504);
 935   message->SetExtension(unittest::repeated_sint32_extension_lite  , 1, 505);
 936   message->SetExtension(unittest::repeated_sint64_extension_lite  , 1, 506);
 937   message->SetExtension(unittest::repeated_fixed32_extension_lite , 1, 507);
 938   message->SetExtension(unittest::repeated_fixed64_extension_lite , 1, 508);
 939   message->SetExtension(unittest::repeated_sfixed32_extension_lite, 1, 509);
 940   message->SetExtension(unittest::repeated_sfixed64_extension_lite, 1, 510);
 941   message->SetExtension(unittest::repeated_float_extension_lite   , 1, 511);
 942   message->SetExtension(unittest::repeated_double_extension_lite  , 1, 512);
 943   message->SetExtension(unittest::repeated_bool_extension_lite    , 1, true);
 944   message->SetExtension(unittest::repeated_string_extension_lite  , 1, "515");
 945   message->SetExtension(unittest::repeated_bytes_extension_lite   , 1, "516");
 946
 947   message->MutableExtension(unittest::repeatedgroup_extension_lite           , 1)->set_a(517);
 948   message->MutableExtension(unittest::repeated_nested_message_extension_lite , 1)->set_bb(518);
 949   message->MutableExtension(unittest::repeated_foreign_message_extension_lite, 1)->set_c(519);
 950   message->MutableExtension(unittest::repeated_import_message_extension_lite , 1)->set_d(520);
 951   message->MutableExtension(unittest::repeated_lazy_message_extension_lite   , 1)->set_bb(527);
 952
 953   message->SetExtension(unittest::repeated_nested_enum_extension_lite , 1, unittest::TestAllTypesLite::FOO );
 954   message->SetExtension(unittest::repeated_foreign_enum_extension_lite, 1, unittest::FOREIGN_LITE_FOO      );
 955   message->SetExtension(unittest::repeated_import_enum_extension_lite , 1, unittest_import::IMPORT_LITE_FOO);
 956
 957 }
 958
 959 // -------------------------------------------------------------------
 960
 961 void TestUtilLite::ExpectAllExtensionsSet(
 962     const unittest::TestAllExtensionsLite& message) {
 963   EXPECT_TRUE(message.HasExtension(unittest::optional_int32_extension_lite   ));
 964   EXPECT_TRUE(message.HasExtension(unittest::optional_int64_extension_lite   ));
 965   EXPECT_TRUE(message.HasExtension(unittest::optional_uint32_extension_lite  ));
 966   EXPECT_TRUE(message.HasExtension(unittest::optional_uint64_extension_lite  ));
 967   EXPECT_TRUE(message.HasExtension(unittest::optional_sint32_extension_lite  ));
 968   EXPECT_TRUE(message.HasExtension(unittest::optional_sint64_extension_lite  ));
 969   EXPECT_TRUE(message.HasExtension(unittest::optional_fixed32_extension_lite ));
 970   EXPECT_TRUE(message.HasExtension(unittest::optional_fixed64_extension_lite ));
 971   EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed32_extension_lite));
 972   EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed64_extension_lite));
 973   EXPECT_TRUE(message.HasExtension(unittest::optional_float_extension_lite   ));
 974   EXPECT_TRUE(message.HasExtension(unittest::optional_double_extension_lite  ));
 975   EXPECT_TRUE(message.HasExtension(unittest::optional_bool_extension_lite    ));
 976   EXPECT_TRUE(message.HasExtension(unittest::optional_string_extension_lite  ));
 977   EXPECT_TRUE(message.HasExtension(unittest::optional_bytes_extension_lite   ));
 978
 979   EXPECT_TRUE(message.HasExtension(unittest::optionalgroup_extension_lite                 ));
 980   EXPECT_TRUE(message.HasExtension(unittest::optional_nested_message_extension_lite       ));
 981   EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_message_extension_lite      ));
 982   EXPECT_TRUE(message.HasExtension(unittest::optional_import_message_extension_lite       ));
 983   EXPECT_TRUE(message.HasExtension(unittest::optional_public_import_message_extension_lite));
 984   EXPECT_TRUE(message.HasExtension(unittest::optional_lazy_message_extension_lite         ));
 985
 986   EXPECT_TRUE(message.GetExtension(unittest::optionalgroup_extension_lite                 ).has_a());
 987   EXPECT_TRUE(message.GetExtension(unittest::optional_nested_message_extension_lite       ).has_bb());
 988   EXPECT_TRUE(message.GetExtension(unittest::optional_foreign_message_extension_lite      ).has_c());
 989   EXPECT_TRUE(message.GetExtension(unittest::optional_import_message_extension_lite       ).has_d());
 990   EXPECT_TRUE(message.GetExtension(unittest::optional_public_import_message_extension_lite).has_e());
 991   EXPECT_TRUE(message.GetExtension(unittest::optional_lazy_message_extension_lite         ).has_bb());
 992
 993   EXPECT_TRUE(message.HasExtension(unittest::optional_nested_enum_extension_lite ));
 994   EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_enum_extension_lite));
 995   EXPECT_TRUE(message.HasExtension(unittest::optional_import_enum_extension_lite ));
 996
 997
 998   EXPECT_EQ(101  , message.GetExtension(unittest::optional_int32_extension_lite   ));
 999   EXPECT_EQ(102  , message.GetExtension(unittest::optional_int64_extension_lite   ));
1000   EXPECT_EQ(103  , message.GetExtension(unittest::optional_uint32_extension_lite  ));
1001   EXPECT_EQ(104  , message.GetExtension(unittest::optional_uint64_extension_lite  ));
1002   EXPECT_EQ(105  , message.GetExtension(unittest::optional_sint32_extension_lite  ));
1003   EXPECT_EQ(106  , message.GetExtension(unittest::optional_sint64_extension_lite  ));
1004   EXPECT_EQ(107  , message.GetExtension(unittest::optional_fixed32_extension_lite ));
1005   EXPECT_EQ(108  , message.GetExtension(unittest::optional_fixed64_extension_lite ));
1006   EXPECT_EQ(109  , message.GetExtension(unittest::optional_sfixed32_extension_lite));
1007   EXPECT_EQ(110  , message.GetExtension(unittest::optional_sfixed64_extension_lite));
1008   EXPECT_EQ(111  , message.GetExtension(unittest::optional_float_extension_lite   ));
1009   EXPECT_EQ(112  , message.GetExtension(unittest::optional_double_extension_lite  ));
1010   EXPECT_EQ(true , message.GetExtension(unittest::optional_bool_extension_lite    ));
1011   EXPECT_EQ("115", message.GetExtension(unittest::optional_string_extension_lite  ));
1012   EXPECT_EQ("116", message.GetExtension(unittest::optional_bytes_extension_lite   ));
1013
1014   EXPECT_EQ(117, message.GetExtension(unittest::optionalgroup_extension_lite                 ).a());
1015   EXPECT_EQ(118, message.GetExtension(unittest::optional_nested_message_extension_lite       ).bb());
1016   EXPECT_EQ(119, message.GetExtension(unittest::optional_foreign_message_extension_lite      ).c());
1017   EXPECT_EQ(120, message.GetExtension(unittest::optional_import_message_extension_lite       ).d());
1018   EXPECT_EQ(126, message.GetExtension(unittest::optional_public_import_message_extension_lite).e());
1019   EXPECT_EQ(127, message.GetExtension(unittest::optional_lazy_message_extension_lite         ).bb());
1020
1021   EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.GetExtension(unittest::optional_nested_enum_extension_lite ));
1022   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ      , message.GetExtension(unittest::optional_foreign_enum_extension_lite));
1023   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.GetExtension(unittest::optional_import_enum_extension_lite ));
1024
1025
1026   // -----------------------------------------------------------------
1027
1028   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite   ));
1029   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite   ));
1030   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite  ));
1031   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite  ));
1032   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite  ));
1033   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite  ));
1034   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
1035   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
1036   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
1037   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
1038   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite   ));
1039   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite  ));
1040   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite    ));
1041   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite  ));
1042   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite   ));
1043
1044   ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite           ));
1045   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
1046   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
1047   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
1048   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite   ));
1049   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite    ));
1050   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite   ));
1051   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite    ));
1052
1053
1054   EXPECT_EQ(201  , message.GetExtension(unittest::repeated_int32_extension_lite   , 0));
1055   EXPECT_EQ(202  , message.GetExtension(unittest::repeated_int64_extension_lite   , 0));
1056   EXPECT_EQ(203  , message.GetExtension(unittest::repeated_uint32_extension_lite  , 0));
1057   EXPECT_EQ(204  , message.GetExtension(unittest::repeated_uint64_extension_lite  , 0));
1058   EXPECT_EQ(205  , message.GetExtension(unittest::repeated_sint32_extension_lite  , 0));
1059   EXPECT_EQ(206  , message.GetExtension(unittest::repeated_sint64_extension_lite  , 0));
1060   EXPECT_EQ(207  , message.GetExtension(unittest::repeated_fixed32_extension_lite , 0));
1061   EXPECT_EQ(208  , message.GetExtension(unittest::repeated_fixed64_extension_lite , 0));
1062   EXPECT_EQ(209  , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));
1063   EXPECT_EQ(210  , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));
1064   EXPECT_EQ(211  , message.GetExtension(unittest::repeated_float_extension_lite   , 0));
1065   EXPECT_EQ(212  , message.GetExtension(unittest::repeated_double_extension_lite  , 0));
1066   EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite    , 0));
1067   EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension_lite  , 0));
1068   EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension_lite   , 0));
1069
1070   EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension_lite           , 0).a());
1071   EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension_lite , 0).bb());
1072   EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0).c());
1073   EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension_lite , 0).d());
1074   EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension_lite   , 0).bb());
1075
1076   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 0));
1077   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));
1078   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::repeated_import_enum_extension_lite , 0));
1079
1080
1081   EXPECT_EQ(301  , message.GetExtension(unittest::repeated_int32_extension_lite   , 1));
1082   EXPECT_EQ(302  , message.GetExtension(unittest::repeated_int64_extension_lite   , 1));
1083   EXPECT_EQ(303  , message.GetExtension(unittest::repeated_uint32_extension_lite  , 1));
1084   EXPECT_EQ(304  , message.GetExtension(unittest::repeated_uint64_extension_lite  , 1));
1085   EXPECT_EQ(305  , message.GetExtension(unittest::repeated_sint32_extension_lite  , 1));
1086   EXPECT_EQ(306  , message.GetExtension(unittest::repeated_sint64_extension_lite  , 1));
1087   EXPECT_EQ(307  , message.GetExtension(unittest::repeated_fixed32_extension_lite , 1));
1088   EXPECT_EQ(308  , message.GetExtension(unittest::repeated_fixed64_extension_lite , 1));
1089   EXPECT_EQ(309  , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));
1090   EXPECT_EQ(310  , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));
1091   EXPECT_EQ(311  , message.GetExtension(unittest::repeated_float_extension_lite   , 1));
1092   EXPECT_EQ(312  , message.GetExtension(unittest::repeated_double_extension_lite  , 1));
1093   EXPECT_EQ(false, message.GetExtension(unittest::repeated_bool_extension_lite    , 1));
1094   EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension_lite  , 1));
1095   EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension_lite   , 1));
1096
1097   EXPECT_EQ(317, message.GetExtension(unittest::repeatedgroup_extension_lite           , 1).a());
1098   EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension_lite , 1).bb());
1099   EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1).c());
1100   EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension_lite , 1).d());
1101   EXPECT_EQ(327, message.GetExtension(unittest::repeated_lazy_message_extension_lite   , 1).bb());
1102
1103   EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 1));
1104   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ      , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));
1105   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.GetExtension(unittest::repeated_import_enum_extension_lite , 1));
1106
1107
1108   // -----------------------------------------------------------------
1109
1110   EXPECT_TRUE(message.HasExtension(unittest::default_int32_extension_lite   ));
1111   EXPECT_TRUE(message.HasExtension(unittest::default_int64_extension_lite   ));
1112   EXPECT_TRUE(message.HasExtension(unittest::default_uint32_extension_lite  ));
1113   EXPECT_TRUE(message.HasExtension(unittest::default_uint64_extension_lite  ));
1114   EXPECT_TRUE(message.HasExtension(unittest::default_sint32_extension_lite  ));
1115   EXPECT_TRUE(message.HasExtension(unittest::default_sint64_extension_lite  ));
1116   EXPECT_TRUE(message.HasExtension(unittest::default_fixed32_extension_lite ));
1117   EXPECT_TRUE(message.HasExtension(unittest::default_fixed64_extension_lite ));
1118   EXPECT_TRUE(message.HasExtension(unittest::default_sfixed32_extension_lite));
1119   EXPECT_TRUE(message.HasExtension(unittest::default_sfixed64_extension_lite));
1120   EXPECT_TRUE(message.HasExtension(unittest::default_float_extension_lite   ));
1121   EXPECT_TRUE(message.HasExtension(unittest::default_double_extension_lite  ));
1122   EXPECT_TRUE(message.HasExtension(unittest::default_bool_extension_lite    ));
1123   EXPECT_TRUE(message.HasExtension(unittest::default_string_extension_lite  ));
1124   EXPECT_TRUE(message.HasExtension(unittest::default_bytes_extension_lite   ));
1125
1126   EXPECT_TRUE(message.HasExtension(unittest::default_nested_enum_extension_lite ));
1127   EXPECT_TRUE(message.HasExtension(unittest::default_foreign_enum_extension_lite));
1128   EXPECT_TRUE(message.HasExtension(unittest::default_import_enum_extension_lite ));
1129
1130
1131   EXPECT_EQ(401  , message.GetExtension(unittest::default_int32_extension_lite   ));
1132   EXPECT_EQ(402  , message.GetExtension(unittest::default_int64_extension_lite   ));
1133   EXPECT_EQ(403  , message.GetExtension(unittest::default_uint32_extension_lite  ));
1134   EXPECT_EQ(404  , message.GetExtension(unittest::default_uint64_extension_lite  ));
1135   EXPECT_EQ(405  , message.GetExtension(unittest::default_sint32_extension_lite  ));
1136   EXPECT_EQ(406  , message.GetExtension(unittest::default_sint64_extension_lite  ));
1137   EXPECT_EQ(407  , message.GetExtension(unittest::default_fixed32_extension_lite ));
1138   EXPECT_EQ(408  , message.GetExtension(unittest::default_fixed64_extension_lite ));
1139   EXPECT_EQ(409  , message.GetExtension(unittest::default_sfixed32_extension_lite));
1140   EXPECT_EQ(410  , message.GetExtension(unittest::default_sfixed64_extension_lite));
1141   EXPECT_EQ(411  , message.GetExtension(unittest::default_float_extension_lite   ));
1142   EXPECT_EQ(412  , message.GetExtension(unittest::default_double_extension_lite  ));
1143   EXPECT_EQ(false, message.GetExtension(unittest::default_bool_extension_lite    ));
1144   EXPECT_EQ("415", message.GetExtension(unittest::default_string_extension_lite  ));
1145   EXPECT_EQ("416", message.GetExtension(unittest::default_bytes_extension_lite   ));
1146
1147   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::default_nested_enum_extension_lite ));
1148   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.GetExtension(unittest::default_foreign_enum_extension_lite));
1149   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::default_import_enum_extension_lite ));
1150
1151
1152   EXPECT_TRUE(message.HasExtension(unittest::oneof_uint32_extension_lite));
1153   EXPECT_TRUE(message.GetExtension(unittest::oneof_nested_message_extension_lite).has_bb());
1154   EXPECT_TRUE(message.HasExtension(unittest::oneof_string_extension_lite));
1155   EXPECT_TRUE(message.HasExtension(unittest::oneof_bytes_extension_lite));
1156
1157   EXPECT_EQ(601, message.GetExtension(unittest::oneof_uint32_extension_lite));
1158   EXPECT_EQ(602, message.GetExtension(unittest::oneof_nested_message_extension_lite).bb());
1159   EXPECT_EQ("603", message.GetExtension(unittest::oneof_string_extension_lite));
1160   EXPECT_EQ("604", message.GetExtension(unittest::oneof_bytes_extension_lite));
1161 }
1162
1163 // -------------------------------------------------------------------
1164
1165 void TestUtilLite::ExpectExtensionsClear(
1166     const unittest::TestAllExtensionsLite& message) {
1167   string serialized;
1168   ASSERT_TRUE(message.SerializeToString(&serialized));
1169   EXPECT_EQ("", serialized);
1170   EXPECT_EQ(0, message.ByteSize());
1171
1172   // has_blah() should initially be false for all optional fields.
1173   EXPECT_FALSE(message.HasExtension(unittest::optional_int32_extension_lite   ));
1174   EXPECT_FALSE(message.HasExtension(unittest::optional_int64_extension_lite   ));
1175   EXPECT_FALSE(message.HasExtension(unittest::optional_uint32_extension_lite  ));
1176   EXPECT_FALSE(message.HasExtension(unittest::optional_uint64_extension_lite  ));
1177   EXPECT_FALSE(message.HasExtension(unittest::optional_sint32_extension_lite  ));
1178   EXPECT_FALSE(message.HasExtension(unittest::optional_sint64_extension_lite  ));
1179   EXPECT_FALSE(message.HasExtension(unittest::optional_fixed32_extension_lite ));
1180   EXPECT_FALSE(message.HasExtension(unittest::optional_fixed64_extension_lite ));
1181   EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed32_extension_lite));
1182   EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed64_extension_lite));
1183   EXPECT_FALSE(message.HasExtension(unittest::optional_float_extension_lite   ));
1184   EXPECT_FALSE(message.HasExtension(unittest::optional_double_extension_lite  ));
1185   EXPECT_FALSE(message.HasExtension(unittest::optional_bool_extension_lite    ));
1186   EXPECT_FALSE(message.HasExtension(unittest::optional_string_extension_lite  ));
1187   EXPECT_FALSE(message.HasExtension(unittest::optional_bytes_extension_lite   ));
1188
1189   EXPECT_FALSE(message.HasExtension(unittest::optionalgroup_extension_lite                 ));
1190   EXPECT_FALSE(message.HasExtension(unittest::optional_nested_message_extension_lite       ));
1191   EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_message_extension_lite      ));
1192   EXPECT_FALSE(message.HasExtension(unittest::optional_import_message_extension_lite       ));
1193   EXPECT_FALSE(message.HasExtension(unittest::optional_public_import_message_extension_lite));
1194   EXPECT_FALSE(message.HasExtension(unittest::optional_lazy_message_extension_lite         ));
1195
1196   EXPECT_FALSE(message.HasExtension(unittest::optional_nested_enum_extension_lite ));
1197   EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_enum_extension_lite));
1198   EXPECT_FALSE(message.HasExtension(unittest::optional_import_enum_extension_lite ));
1199
1200
1201   // Optional fields without defaults are set to zero or something like it.
1202   EXPECT_EQ(0    , message.GetExtension(unittest::optional_int32_extension_lite   ));
1203   EXPECT_EQ(0    , message.GetExtension(unittest::optional_int64_extension_lite   ));
1204   EXPECT_EQ(0    , message.GetExtension(unittest::optional_uint32_extension_lite  ));
1205   EXPECT_EQ(0    , message.GetExtension(unittest::optional_uint64_extension_lite  ));
1206   EXPECT_EQ(0    , message.GetExtension(unittest::optional_sint32_extension_lite  ));
1207   EXPECT_EQ(0    , message.GetExtension(unittest::optional_sint64_extension_lite  ));
1208   EXPECT_EQ(0    , message.GetExtension(unittest::optional_fixed32_extension_lite ));
1209   EXPECT_EQ(0    , message.GetExtension(unittest::optional_fixed64_extension_lite ));
1210   EXPECT_EQ(0    , message.GetExtension(unittest::optional_sfixed32_extension_lite));
1211   EXPECT_EQ(0    , message.GetExtension(unittest::optional_sfixed64_extension_lite));
1212   EXPECT_EQ(0    , message.GetExtension(unittest::optional_float_extension_lite   ));
1213   EXPECT_EQ(0    , message.GetExtension(unittest::optional_double_extension_lite  ));
1214   EXPECT_EQ(false, message.GetExtension(unittest::optional_bool_extension_lite    ));
1215   EXPECT_EQ(""   , message.GetExtension(unittest::optional_string_extension_lite  ));
1216   EXPECT_EQ(""   , message.GetExtension(unittest::optional_bytes_extension_lite   ));
1217
1218   // Embedded messages should also be clear.
1219   EXPECT_FALSE(message.GetExtension(unittest::optionalgroup_extension_lite                 ).has_a());
1220   EXPECT_FALSE(message.GetExtension(unittest::optional_nested_message_extension_lite       ).has_bb());
1221   EXPECT_FALSE(message.GetExtension(unittest::optional_foreign_message_extension_lite      ).has_c());
1222   EXPECT_FALSE(message.GetExtension(unittest::optional_import_message_extension_lite       ).has_d());
1223   EXPECT_FALSE(message.GetExtension(unittest::optional_public_import_message_extension_lite).has_e());
1224   EXPECT_FALSE(message.GetExtension(unittest::optional_lazy_message_extension_lite         ).has_bb());
1225
1226   EXPECT_EQ(0, message.GetExtension(unittest::optionalgroup_extension_lite                 ).a());
1227   EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension_lite       ).bb());
1228   EXPECT_EQ(0, message.GetExtension(unittest::optional_foreign_message_extension_lite      ).c());
1229   EXPECT_EQ(0, message.GetExtension(unittest::optional_import_message_extension_lite       ).d());
1230   EXPECT_EQ(0, message.GetExtension(unittest::optional_public_import_message_extension_lite).e());
1231   EXPECT_EQ(0, message.GetExtension(unittest::optional_lazy_message_extension_lite         ).bb());
1232
1233   // Enums without defaults are set to the first value in the enum.
1234   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::optional_nested_enum_extension_lite ));
1235   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.GetExtension(unittest::optional_foreign_enum_extension_lite));
1236   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::optional_import_enum_extension_lite ));
1237
1238
1239   // Repeated fields are empty.
1240   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int32_extension_lite   ));
1241   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int64_extension_lite   ));
1242   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint32_extension_lite  ));
1243   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint64_extension_lite  ));
1244   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint32_extension_lite  ));
1245   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint64_extension_lite  ));
1246   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
1247   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
1248   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
1249   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
1250   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_float_extension_lite   ));
1251   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_double_extension_lite  ));
1252   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bool_extension_lite    ));
1253   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_extension_lite  ));
1254   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bytes_extension_lite   ));
1255
1256   EXPECT_EQ(0, message.ExtensionSize(unittest::repeatedgroup_extension_lite           ));
1257   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
1258   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
1259   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
1260   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite   ));
1261   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite    ));
1262   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite   ));
1263   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_enum_extension_lite    ));
1264
1265
1266   // has_blah() should also be false for all default fields.
1267   EXPECT_FALSE(message.HasExtension(unittest::default_int32_extension_lite   ));
1268   EXPECT_FALSE(message.HasExtension(unittest::default_int64_extension_lite   ));
1269   EXPECT_FALSE(message.HasExtension(unittest::default_uint32_extension_lite  ));
1270   EXPECT_FALSE(message.HasExtension(unittest::default_uint64_extension_lite  ));
1271   EXPECT_FALSE(message.HasExtension(unittest::default_sint32_extension_lite  ));
1272   EXPECT_FALSE(message.HasExtension(unittest::default_sint64_extension_lite  ));
1273   EXPECT_FALSE(message.HasExtension(unittest::default_fixed32_extension_lite ));
1274   EXPECT_FALSE(message.HasExtension(unittest::default_fixed64_extension_lite ));
1275   EXPECT_FALSE(message.HasExtension(unittest::default_sfixed32_extension_lite));
1276   EXPECT_FALSE(message.HasExtension(unittest::default_sfixed64_extension_lite));
1277   EXPECT_FALSE(message.HasExtension(unittest::default_float_extension_lite   ));
1278   EXPECT_FALSE(message.HasExtension(unittest::default_double_extension_lite  ));
1279   EXPECT_FALSE(message.HasExtension(unittest::default_bool_extension_lite    ));
1280   EXPECT_FALSE(message.HasExtension(unittest::default_string_extension_lite  ));
1281   EXPECT_FALSE(message.HasExtension(unittest::default_bytes_extension_lite   ));
1282
1283   EXPECT_FALSE(message.HasExtension(unittest::default_nested_enum_extension_lite ));
1284   EXPECT_FALSE(message.HasExtension(unittest::default_foreign_enum_extension_lite));
1285   EXPECT_FALSE(message.HasExtension(unittest::default_import_enum_extension_lite ));
1286
1287
1288   // Fields with defaults have their default values (duh).
1289   EXPECT_EQ( 41    , message.GetExtension(unittest::default_int32_extension_lite   ));
1290   EXPECT_EQ( 42    , message.GetExtension(unittest::default_int64_extension_lite   ));
1291   EXPECT_EQ( 43    , message.GetExtension(unittest::default_uint32_extension_lite  ));
1292   EXPECT_EQ( 44    , message.GetExtension(unittest::default_uint64_extension_lite  ));
1293   EXPECT_EQ(-45    , message.GetExtension(unittest::default_sint32_extension_lite  ));
1294   EXPECT_EQ( 46    , message.GetExtension(unittest::default_sint64_extension_lite  ));
1295   EXPECT_EQ( 47    , message.GetExtension(unittest::default_fixed32_extension_lite ));
1296   EXPECT_EQ( 48    , message.GetExtension(unittest::default_fixed64_extension_lite ));
1297   EXPECT_EQ( 49    , message.GetExtension(unittest::default_sfixed32_extension_lite));
1298   EXPECT_EQ(-50    , message.GetExtension(unittest::default_sfixed64_extension_lite));
1299   EXPECT_EQ( 51.5  , message.GetExtension(unittest::default_float_extension_lite   ));
1300   EXPECT_EQ( 52e3  , message.GetExtension(unittest::default_double_extension_lite  ));
1301   EXPECT_EQ(true   , message.GetExtension(unittest::default_bool_extension_lite    ));
1302   EXPECT_EQ("hello", message.GetExtension(unittest::default_string_extension_lite  ));
1303   EXPECT_EQ("world", message.GetExtension(unittest::default_bytes_extension_lite   ));
1304
1305   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::default_nested_enum_extension_lite ));
1306   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.GetExtension(unittest::default_foreign_enum_extension_lite));
1307   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::default_import_enum_extension_lite ));
1308
1309
1310   EXPECT_FALSE(message.HasExtension(unittest::oneof_uint32_extension_lite));
1311   EXPECT_FALSE(message.GetExtension(unittest::oneof_nested_message_extension_lite).has_bb());
1312   EXPECT_FALSE(message.HasExtension(unittest::oneof_string_extension_lite));
1313   EXPECT_FALSE(message.HasExtension(unittest::oneof_bytes_extension_lite));
1314 }
1315
1316 // -------------------------------------------------------------------
1317
1318 void TestUtilLite::ExpectRepeatedExtensionsModified(
1319     const unittest::TestAllExtensionsLite& message) {
1320   // ModifyRepeatedFields only sets the second repeated element of each
1321   // field.  In addition to verifying this, we also verify that the first
1322   // element and size were *not* modified.
1323   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite   ));
1324   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite   ));
1325   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite  ));
1326   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite  ));
1327   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite  ));
1328   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite  ));
1329   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
1330   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
1331   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
1332   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
1333   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite   ));
1334   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite  ));
1335   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite    ));
1336   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite  ));
1337   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite   ));
1338
1339   ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite           ));
1340   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
1341   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
1342   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
1343   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite   ));
1344   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite    ));
1345   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite   ));
1346   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite    ));
1347
1348
1349   EXPECT_EQ(201  , message.GetExtension(unittest::repeated_int32_extension_lite   , 0));
1350   EXPECT_EQ(202  , message.GetExtension(unittest::repeated_int64_extension_lite   , 0));
1351   EXPECT_EQ(203  , message.GetExtension(unittest::repeated_uint32_extension_lite  , 0));
1352   EXPECT_EQ(204  , message.GetExtension(unittest::repeated_uint64_extension_lite  , 0));
1353   EXPECT_EQ(205  , message.GetExtension(unittest::repeated_sint32_extension_lite  , 0));
1354   EXPECT_EQ(206  , message.GetExtension(unittest::repeated_sint64_extension_lite  , 0));
1355   EXPECT_EQ(207  , message.GetExtension(unittest::repeated_fixed32_extension_lite , 0));
1356   EXPECT_EQ(208  , message.GetExtension(unittest::repeated_fixed64_extension_lite , 0));
1357   EXPECT_EQ(209  , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));
1358   EXPECT_EQ(210  , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));
1359   EXPECT_EQ(211  , message.GetExtension(unittest::repeated_float_extension_lite   , 0));
1360   EXPECT_EQ(212  , message.GetExtension(unittest::repeated_double_extension_lite  , 0));
1361   EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite    , 0));
1362   EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension_lite  , 0));
1363   EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension_lite   , 0));
1364
1365   EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension_lite           , 0).a());
1366   EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension_lite , 0).bb());
1367   EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0).c());
1368   EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension_lite , 0).d());
1369   EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension_lite   , 0).bb());
1370
1371   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 0));
1372   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));
1373   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::repeated_import_enum_extension_lite , 0));
1374
1375
1376   // Actually verify the second (modified) elements now.
1377   EXPECT_EQ(501  , message.GetExtension(unittest::repeated_int32_extension_lite   , 1));
1378   EXPECT_EQ(502  , message.GetExtension(unittest::repeated_int64_extension_lite   , 1));
1379   EXPECT_EQ(503  , message.GetExtension(unittest::repeated_uint32_extension_lite  , 1));
1380   EXPECT_EQ(504  , message.GetExtension(unittest::repeated_uint64_extension_lite  , 1));
1381   EXPECT_EQ(505  , message.GetExtension(unittest::repeated_sint32_extension_lite  , 1));
1382   EXPECT_EQ(506  , message.GetExtension(unittest::repeated_sint64_extension_lite  , 1));
1383   EXPECT_EQ(507  , message.GetExtension(unittest::repeated_fixed32_extension_lite , 1));
1384   EXPECT_EQ(508  , message.GetExtension(unittest::repeated_fixed64_extension_lite , 1));
1385   EXPECT_EQ(509  , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));
1386   EXPECT_EQ(510  , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));
1387   EXPECT_EQ(511  , message.GetExtension(unittest::repeated_float_extension_lite   , 1));
1388   EXPECT_EQ(512  , message.GetExtension(unittest::repeated_double_extension_lite  , 1));
1389   EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite    , 1));
1390   EXPECT_EQ("515", message.GetExtension(unittest::repeated_string_extension_lite  , 1));
1391   EXPECT_EQ("516", message.GetExtension(unittest::repeated_bytes_extension_lite   , 1));
1392
1393   EXPECT_EQ(517, message.GetExtension(unittest::repeatedgroup_extension_lite           , 1).a());
1394   EXPECT_EQ(518, message.GetExtension(unittest::repeated_nested_message_extension_lite , 1).bb());
1395   EXPECT_EQ(519, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1).c());
1396   EXPECT_EQ(520, message.GetExtension(unittest::repeated_import_message_extension_lite , 1).d());
1397   EXPECT_EQ(527, message.GetExtension(unittest::repeated_lazy_message_extension_lite   , 1).bb());
1398
1399   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 1));
1400   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));
1401   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::repeated_import_enum_extension_lite , 1));
1402
1403 }
1404
1405 // -------------------------------------------------------------------
1406
1407 void TestUtilLite::SetPackedExtensions(
1408     unittest::TestPackedExtensionsLite* message) {
1409   message->AddExtension(unittest::packed_int32_extension_lite   , 601);
1410   message->AddExtension(unittest::packed_int64_extension_lite   , 602);
1411   message->AddExtension(unittest::packed_uint32_extension_lite  , 603);
1412   message->AddExtension(unittest::packed_uint64_extension_lite  , 604);
1413   message->AddExtension(unittest::packed_sint32_extension_lite  , 605);
1414   message->AddExtension(unittest::packed_sint64_extension_lite  , 606);
1415   message->AddExtension(unittest::packed_fixed32_extension_lite , 607);
1416   message->AddExtension(unittest::packed_fixed64_extension_lite , 608);
1417   message->AddExtension(unittest::packed_sfixed32_extension_lite, 609);
1418   message->AddExtension(unittest::packed_sfixed64_extension_lite, 610);
1419   message->AddExtension(unittest::packed_float_extension_lite   , 611);
1420   message->AddExtension(unittest::packed_double_extension_lite  , 612);
1421   message->AddExtension(unittest::packed_bool_extension_lite    , true);
1422   message->AddExtension(unittest::packed_enum_extension_lite, unittest::FOREIGN_LITE_BAR);
1423   // add a second one of each field
1424   message->AddExtension(unittest::packed_int32_extension_lite   , 701);
1425   message->AddExtension(unittest::packed_int64_extension_lite   , 702);
1426   message->AddExtension(unittest::packed_uint32_extension_lite  , 703);
1427   message->AddExtension(unittest::packed_uint64_extension_lite  , 704);
1428   message->AddExtension(unittest::packed_sint32_extension_lite  , 705);
1429   message->AddExtension(unittest::packed_sint64_extension_lite  , 706);
1430   message->AddExtension(unittest::packed_fixed32_extension_lite , 707);
1431   message->AddExtension(unittest::packed_fixed64_extension_lite , 708);
1432   message->AddExtension(unittest::packed_sfixed32_extension_lite, 709);
1433   message->AddExtension(unittest::packed_sfixed64_extension_lite, 710);
1434   message->AddExtension(unittest::packed_float_extension_lite   , 711);
1435   message->AddExtension(unittest::packed_double_extension_lite  , 712);
1436   message->AddExtension(unittest::packed_bool_extension_lite    , false);
1437   message->AddExtension(unittest::packed_enum_extension_lite, unittest::FOREIGN_LITE_BAZ);
1438 }
1439
1440 // -------------------------------------------------------------------
1441
1442 void TestUtilLite::ModifyPackedExtensions(
1443     unittest::TestPackedExtensionsLite* message) {
1444   message->SetExtension(unittest::packed_int32_extension_lite   , 1, 801);
1445   message->SetExtension(unittest::packed_int64_extension_lite   , 1, 802);
1446   message->SetExtension(unittest::packed_uint32_extension_lite  , 1, 803);
1447   message->SetExtension(unittest::packed_uint64_extension_lite  , 1, 804);
1448   message->SetExtension(unittest::packed_sint32_extension_lite  , 1, 805);
1449   message->SetExtension(unittest::packed_sint64_extension_lite  , 1, 806);
1450   message->SetExtension(unittest::packed_fixed32_extension_lite , 1, 807);
1451   message->SetExtension(unittest::packed_fixed64_extension_lite , 1, 808);
1452   message->SetExtension(unittest::packed_sfixed32_extension_lite, 1, 809);
1453   message->SetExtension(unittest::packed_sfixed64_extension_lite, 1, 810);
1454   message->SetExtension(unittest::packed_float_extension_lite   , 1, 811);
1455   message->SetExtension(unittest::packed_double_extension_lite  , 1, 812);
1456   message->SetExtension(unittest::packed_bool_extension_lite    , 1, true);
1457   message->SetExtension(unittest::packed_enum_extension_lite    , 1,
1458                         unittest::FOREIGN_LITE_FOO);
1459 }
1460
1461 // -------------------------------------------------------------------
1462
1463 void TestUtilLite::ExpectPackedExtensionsSet(
1464     const unittest::TestPackedExtensionsLite& message) {
1465   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite   ));
1466   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite   ));
1467   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite  ));
1468   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite  ));
1469   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite  ));
1470   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite  ));
1471   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
1472   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
1473   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
1474   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
1475   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite   ));
1476   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite  ));
1477   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite    ));
1478   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite    ));
1479
1480   EXPECT_EQ(601  , message.GetExtension(unittest::packed_int32_extension_lite   , 0));
1481   EXPECT_EQ(602  , message.GetExtension(unittest::packed_int64_extension_lite   , 0));
1482   EXPECT_EQ(603  , message.GetExtension(unittest::packed_uint32_extension_lite  , 0));
1483   EXPECT_EQ(604  , message.GetExtension(unittest::packed_uint64_extension_lite  , 0));
1484   EXPECT_EQ(605  , message.GetExtension(unittest::packed_sint32_extension_lite  , 0));
1485   EXPECT_EQ(606  , message.GetExtension(unittest::packed_sint64_extension_lite  , 0));
1486   EXPECT_EQ(607  , message.GetExtension(unittest::packed_fixed32_extension_lite , 0));
1487   EXPECT_EQ(608  , message.GetExtension(unittest::packed_fixed64_extension_lite , 0));
1488   EXPECT_EQ(609  , message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));
1489   EXPECT_EQ(610  , message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));
1490   EXPECT_EQ(611  , message.GetExtension(unittest::packed_float_extension_lite   , 0));
1491   EXPECT_EQ(612  , message.GetExtension(unittest::packed_double_extension_lite  , 0));
1492   EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite    , 0));
1493   EXPECT_EQ(unittest::FOREIGN_LITE_BAR,
1494             message.GetExtension(unittest::packed_enum_extension_lite, 0));
1495   EXPECT_EQ(701  , message.GetExtension(unittest::packed_int32_extension_lite   , 1));
1496   EXPECT_EQ(702  , message.GetExtension(unittest::packed_int64_extension_lite   , 1));
1497   EXPECT_EQ(703  , message.GetExtension(unittest::packed_uint32_extension_lite  , 1));
1498   EXPECT_EQ(704  , message.GetExtension(unittest::packed_uint64_extension_lite  , 1));
1499   EXPECT_EQ(705  , message.GetExtension(unittest::packed_sint32_extension_lite  , 1));
1500   EXPECT_EQ(706  , message.GetExtension(unittest::packed_sint64_extension_lite  , 1));
1501   EXPECT_EQ(707  , message.GetExtension(unittest::packed_fixed32_extension_lite , 1));
1502   EXPECT_EQ(708  , message.GetExtension(unittest::packed_fixed64_extension_lite , 1));
1503   EXPECT_EQ(709  , message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));
1504   EXPECT_EQ(710  , message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));
1505   EXPECT_EQ(711  , message.GetExtension(unittest::packed_float_extension_lite   , 1));
1506   EXPECT_EQ(712  , message.GetExtension(unittest::packed_double_extension_lite  , 1));
1507   EXPECT_EQ(false, message.GetExtension(unittest::packed_bool_extension_lite    , 1));
1508   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ,
1509             message.GetExtension(unittest::packed_enum_extension_lite, 1));
1510 }
1511
1512 // -------------------------------------------------------------------
1513
1514 void TestUtilLite::ExpectPackedExtensionsClear(
1515     const unittest::TestPackedExtensionsLite& message) {
1516   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int32_extension_lite   ));
1517   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int64_extension_lite   ));
1518   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint32_extension_lite  ));
1519   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint64_extension_lite  ));
1520   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint32_extension_lite  ));
1521   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint64_extension_lite  ));
1522   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
1523   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
1524   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
1525   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
1526   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_float_extension_lite   ));
1527   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_double_extension_lite  ));
1528   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_bool_extension_lite    ));
1529   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_enum_extension_lite    ));
1530 }
1531
1532 // -------------------------------------------------------------------
1533
1534 void TestUtilLite::ExpectPackedExtensionsModified(
1535     const unittest::TestPackedExtensionsLite& message) {
1536   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite   ));
1537   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite   ));
1538   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite  ));
1539   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite  ));
1540   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite  ));
1541   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite  ));
1542   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
1543   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
1544   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
1545   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
1546   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite   ));
1547   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite  ));
1548   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite    ));
1549   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite    ));
1550   EXPECT_EQ(601  , message.GetExtension(unittest::packed_int32_extension_lite   , 0));
1551   EXPECT_EQ(602  , message.GetExtension(unittest::packed_int64_extension_lite   , 0));
1552   EXPECT_EQ(603  , message.GetExtension(unittest::packed_uint32_extension_lite  , 0));
1553   EXPECT_EQ(604  , message.GetExtension(unittest::packed_uint64_extension_lite  , 0));
1554   EXPECT_EQ(605  , message.GetExtension(unittest::packed_sint32_extension_lite  , 0));
1555   EXPECT_EQ(606  , message.GetExtension(unittest::packed_sint64_extension_lite  , 0));
1556   EXPECT_EQ(607  , message.GetExtension(unittest::packed_fixed32_extension_lite , 0));
1557   EXPECT_EQ(608  , message.GetExtension(unittest::packed_fixed64_extension_lite , 0));
1558   EXPECT_EQ(609  , message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));
1559   EXPECT_EQ(610  , message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));
1560   EXPECT_EQ(611  , message.GetExtension(unittest::packed_float_extension_lite   , 0));
1561   EXPECT_EQ(612  , message.GetExtension(unittest::packed_double_extension_lite  , 0));
1562   EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite    , 0));
1563   EXPECT_EQ(unittest::FOREIGN_LITE_BAR,
1564             message.GetExtension(unittest::packed_enum_extension_lite, 0));
1565
1566   // Actually verify the second (modified) elements now.
1567   EXPECT_EQ(801  , message.GetExtension(unittest::packed_int32_extension_lite   , 1));
1568   EXPECT_EQ(802  , message.GetExtension(unittest::packed_int64_extension_lite   , 1));
1569   EXPECT_EQ(803  , message.GetExtension(unittest::packed_uint32_extension_lite  , 1));
1570   EXPECT_EQ(804  , message.GetExtension(unittest::packed_uint64_extension_lite  , 1));
1571   EXPECT_EQ(805  , message.GetExtension(unittest::packed_sint32_extension_lite  , 1));
1572   EXPECT_EQ(806  , message.GetExtension(unittest::packed_sint64_extension_lite  , 1));
1573   EXPECT_EQ(807  , message.GetExtension(unittest::packed_fixed32_extension_lite , 1));
1574   EXPECT_EQ(808  , message.GetExtension(unittest::packed_fixed64_extension_lite , 1));
1575   EXPECT_EQ(809  , message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));
1576   EXPECT_EQ(810  , message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));
1577   EXPECT_EQ(811  , message.GetExtension(unittest::packed_float_extension_lite   , 1));
1578   EXPECT_EQ(812  , message.GetExtension(unittest::packed_double_extension_lite  , 1));
1579   EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite    , 1));
1580   EXPECT_EQ(unittest::FOREIGN_LITE_FOO,
1581             message.GetExtension(unittest::packed_enum_extension_lite, 1));
1582 }
1583
1584 }  // namespace protobuf
1585 }  // namespace google