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");
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);
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);
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");
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);
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);
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");
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);
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);
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");
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);
160 void TestUtilLite::ModifyRepeatedFields(unittest::TestAllTypesLite* message) {
161   message->set_repeated_int32   (1, 501);
162   message->set_repeated_int64   (1, 502);
163   message->set_repeated_uint32  (1, 503);
164   message->set_repeated_uint64  (1, 504);
165   message->set_repeated_sint32  (1, 505);
166   message->set_repeated_sint64  (1, 506);
167   message->set_repeated_fixed32 (1, 507);
168   message->set_repeated_fixed64 (1, 508);
169   message->set_repeated_sfixed32(1, 509);
170   message->set_repeated_sfixed64(1, 510);
171   message->set_repeated_float   (1, 511);
172   message->set_repeated_double  (1, 512);
173   message->set_repeated_bool    (1, true);
174   message->set_repeated_string  (1, "515");
175   message->set_repeated_bytes   (1, "516");
177   message->mutable_repeatedgroup           (1)->set_a(517);
178   message->mutable_repeated_nested_message (1)->set_bb(518);
179   message->mutable_repeated_foreign_message(1)->set_c(519);
180   message->mutable_repeated_import_message (1)->set_d(520);
181   message->mutable_repeated_lazy_message   (1)->set_bb(527);
183   message->set_repeated_nested_enum (1, unittest::TestAllTypesLite::FOO );
184   message->set_repeated_foreign_enum(1, unittest::FOREIGN_LITE_FOO      );
185   message->set_repeated_import_enum (1, unittest_import::IMPORT_LITE_FOO);
192     const unittest::TestAllTypesLite& message) {
193   EXPECT_TRUE(message.has_optional_int32   ());
194   EXPECT_TRUE(message.has_optional_int64   ());
195   EXPECT_TRUE(message.has_optional_uint32  ());
196   EXPECT_TRUE(message.has_optional_uint64  ());
197   EXPECT_TRUE(message.has_optional_sint32  ());
198   EXPECT_TRUE(message.has_optional_sint64  ());
199   EXPECT_TRUE(message.has_optional_fixed32 ());
200   EXPECT_TRUE(message.has_optional_fixed64 ());
201   EXPECT_TRUE(message.has_optional_sfixed32());
202   EXPECT_TRUE(message.has_optional_sfixed64());
203   EXPECT_TRUE(message.has_optional_float   ());
204   EXPECT_TRUE(message.has_optional_double  ());
205   EXPECT_TRUE(message.has_optional_bool    ());
206   EXPECT_TRUE(message.has_optional_string  ());
207   EXPECT_TRUE(message.has_optional_bytes   ());
209   EXPECT_TRUE(message.has_optionalgroup                 ());
210   EXPECT_TRUE(message.has_optional_nested_message       ());
211   EXPECT_TRUE(message.has_optional_foreign_message      ());
212   EXPECT_TRUE(message.has_optional_import_message       ());
213   EXPECT_TRUE(message.has_optional_public_import_message());
214   EXPECT_TRUE(message.has_optional_lazy_message         ());
216   EXPECT_TRUE(message.optionalgroup                 ().has_a());
217   EXPECT_TRUE(message.optional_nested_message       ().has_bb());
218   EXPECT_TRUE(message.optional_foreign_message      ().has_c());
219   EXPECT_TRUE(message.optional_import_message       ().has_d());
220   EXPECT_TRUE(message.optional_public_import_message().has_e());
221   EXPECT_TRUE(message.optional_lazy_message         ().has_bb());
223   EXPECT_TRUE(message.has_optional_nested_enum ());
224   EXPECT_TRUE(message.has_optional_foreign_enum());
225   EXPECT_TRUE(message.has_optional_import_enum ());
228   EXPECT_EQ(101  , message.optional_int32   ());
229   EXPECT_EQ(102  , message.optional_int64   ());
230   EXPECT_EQ(103  , message.optional_uint32  ());
231   EXPECT_EQ(104  , message.optional_uint64  ());
232   EXPECT_EQ(105  , message.optional_sint32  ());
233   EXPECT_EQ(106  , message.optional_sint64  ());
234   EXPECT_EQ(107  , message.optional_fixed32 ());
235   EXPECT_EQ(108  , message.optional_fixed64 ());
236   EXPECT_EQ(109  , message.optional_sfixed32());
237   EXPECT_EQ(110  , message.optional_sfixed64());
238   EXPECT_EQ(111  , message.optional_float   ());
239   EXPECT_EQ(112  , message.optional_double  ());
240   EXPECT_EQ(true , message.optional_bool    ());
241   EXPECT_EQ("115", message.optional_string  ());
242   EXPECT_EQ("116", message.optional_bytes   ());
244   EXPECT_EQ(117, message.optionalgroup                 ().a());
245   EXPECT_EQ(118, message.optional_nested_message       ().bb());
246   EXPECT_EQ(119, message.optional_foreign_message      ().c());
247   EXPECT_EQ(120, message.optional_import_message       ().d());
248   EXPECT_EQ(126, message.optional_public_import_message().e());
249   EXPECT_EQ(127, message.optional_lazy_message         ().bb());
251   EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.optional_nested_enum ());
252   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ      , message.optional_foreign_enum());
253   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.optional_import_enum ());
258   ASSERT_EQ(2, message.repeated_int32_size   ());
259   ASSERT_EQ(2, message.repeated_int64_size   ());
260   ASSERT_EQ(2, message.repeated_uint32_size  ());
261   ASSERT_EQ(2, message.repeated_uint64_size  ());
262   ASSERT_EQ(2, message.repeated_sint32_size  ());
263   ASSERT_EQ(2, message.repeated_sint64_size  ());
264   ASSERT_EQ(2, message.repeated_fixed32_size ());
265   ASSERT_EQ(2, message.repeated_fixed64_size ());
266   ASSERT_EQ(2, message.repeated_sfixed32_size());
267   ASSERT_EQ(2, message.repeated_sfixed64_size());
268   ASSERT_EQ(2, message.repeated_float_size   ());
269   ASSERT_EQ(2, message.repeated_double_size  ());
270   ASSERT_EQ(2, message.repeated_bool_size    ());
271   ASSERT_EQ(2, message.repeated_string_size  ());
272   ASSERT_EQ(2, message.repeated_bytes_size   ());
274   ASSERT_EQ(2, message.repeatedgroup_size           ());
275   ASSERT_EQ(2, message.repeated_nested_message_size ());
276   ASSERT_EQ(2, message.repeated_foreign_message_size());
277   ASSERT_EQ(2, message.repeated_import_message_size ());
278   ASSERT_EQ(2, message.repeated_lazy_message_size   ());
279   ASSERT_EQ(2, message.repeated_nested_enum_size    ());
280   ASSERT_EQ(2, message.repeated_foreign_enum_size   ());
281   ASSERT_EQ(2, message.repeated_import_enum_size    ());
284   EXPECT_EQ(201  , message.repeated_int32   (0));
285   EXPECT_EQ(202  , message.repeated_int64   (0));
286   EXPECT_EQ(203  , message.repeated_uint32  (0));
287   EXPECT_EQ(204  , message.repeated_uint64  (0));
288   EXPECT_EQ(205  , message.repeated_sint32  (0));
289   EXPECT_EQ(206  , message.repeated_sint64  (0));
290   EXPECT_EQ(207  , message.repeated_fixed32 (0));
291   EXPECT_EQ(208  , message.repeated_fixed64 (0));
292   EXPECT_EQ(209  , message.repeated_sfixed32(0));
293   EXPECT_EQ(210  , message.repeated_sfixed64(0));
294   EXPECT_EQ(211  , message.repeated_float   (0));
295   EXPECT_EQ(212  , message.repeated_double  (0));
296   EXPECT_EQ(true , message.repeated_bool    (0));
297   EXPECT_EQ("215", message.repeated_string  (0));
298   EXPECT_EQ("216", message.repeated_bytes   (0));
300   EXPECT_EQ(217, message.repeatedgroup           (0).a());
301   EXPECT_EQ(218, message.repeated_nested_message (0).bb());
302   EXPECT_EQ(219, message.repeated_foreign_message(0).c());
303   EXPECT_EQ(220, message.repeated_import_message (0).d());
304   EXPECT_EQ(227, message.repeated_lazy_message   (0).bb());
307   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.repeated_nested_enum (0));
308   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.repeated_foreign_enum(0));
309   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum (0));
311   EXPECT_EQ(301  , message.repeated_int32   (1));
312   EXPECT_EQ(302  , message.repeated_int64   (1));
313   EXPECT_EQ(303  , message.repeated_uint32  (1));
314   EXPECT_EQ(304  , message.repeated_uint64  (1));
315   EXPECT_EQ(305  , message.repeated_sint32  (1));
316   EXPECT_EQ(306  , message.repeated_sint64  (1));
317   EXPECT_EQ(307  , message.repeated_fixed32 (1));
318   EXPECT_EQ(308  , message.repeated_fixed64 (1));
319   EXPECT_EQ(309  , message.repeated_sfixed32(1));
320   EXPECT_EQ(310  , message.repeated_sfixed64(1));
321   EXPECT_EQ(311  , message.repeated_float   (1));
322   EXPECT_EQ(312  , message.repeated_double  (1));
323   EXPECT_EQ(false, message.repeated_bool    (1));
324   EXPECT_EQ("315", message.repeated_string  (1));
325   EXPECT_EQ("316", message.repeated_bytes   (1));
327   EXPECT_EQ(317, message.repeatedgroup           (1).a());
328   EXPECT_EQ(318, message.repeated_nested_message (1).bb());
329   EXPECT_EQ(319, message.repeated_foreign_message(1).c());
330   EXPECT_EQ(320, message.repeated_import_message (1).d());
331   EXPECT_EQ(327, message.repeated_lazy_message   (1).bb());
333   EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.repeated_nested_enum (1));
334   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ      , message.repeated_foreign_enum(1));
335   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.repeated_import_enum (1));
340   EXPECT_TRUE(message.has_default_int32   ());
341   EXPECT_TRUE(message.has_default_int64   ());
342   EXPECT_TRUE(message.has_default_uint32  ());
343   EXPECT_TRUE(message.has_default_uint64  ());
344   EXPECT_TRUE(message.has_default_sint32  ());
345   EXPECT_TRUE(message.has_default_sint64  ());
346   EXPECT_TRUE(message.has_default_fixed32 ());
347   EXPECT_TRUE(message.has_default_fixed64 ());
348   EXPECT_TRUE(message.has_default_sfixed32());
349   EXPECT_TRUE(message.has_default_sfixed64());
350   EXPECT_TRUE(message.has_default_float   ());
351   EXPECT_TRUE(message.has_default_double  ());
352   EXPECT_TRUE(message.has_default_bool    ());
353   EXPECT_TRUE(message.has_default_string  ());
354   EXPECT_TRUE(message.has_default_bytes   ());
356   EXPECT_TRUE(message.has_default_nested_enum ());
357   EXPECT_TRUE(message.has_default_foreign_enum());
358   EXPECT_TRUE(message.has_default_import_enum ());
361   EXPECT_EQ(401  , message.default_int32   ());
362   EXPECT_EQ(402  , message.default_int64   ());
363   EXPECT_EQ(403  , message.default_uint32  ());
364   EXPECT_EQ(404  , message.default_uint64  ());
365   EXPECT_EQ(405  , message.default_sint32  ());
366   EXPECT_EQ(406  , message.default_sint64  ());
367   EXPECT_EQ(407  , message.default_fixed32 ());
368   EXPECT_EQ(408  , message.default_fixed64 ());
369   EXPECT_EQ(409  , message.default_sfixed32());
370   EXPECT_EQ(410  , message.default_sfixed64());
371   EXPECT_EQ(411  , message.default_float   ());
372   EXPECT_EQ(412  , message.default_double  ());
373   EXPECT_EQ(false, message.default_bool    ());
374   EXPECT_EQ("415", message.default_string  ());
375   EXPECT_EQ("416", message.default_bytes   ());
377   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.default_nested_enum ());
378   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.default_foreign_enum());
379   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.default_import_enum ());
385 void TestUtilLite::ExpectClear(const unittest::TestAllTypesLite& message) {
387   EXPECT_FALSE(message.has_optional_int32   ());
388   EXPECT_FALSE(message.has_optional_int64   ());
389   EXPECT_FALSE(message.has_optional_uint32  ());
390   EXPECT_FALSE(message.has_optional_uint64  ());
391   EXPECT_FALSE(message.has_optional_sint32  ());
392   EXPECT_FALSE(message.has_optional_sint64  ());
393   EXPECT_FALSE(message.has_optional_fixed32 ());
394   EXPECT_FALSE(message.has_optional_fixed64 ());
395   EXPECT_FALSE(message.has_optional_sfixed32());
396   EXPECT_FALSE(message.has_optional_sfixed64());
397   EXPECT_FALSE(message.has_optional_float   ());
398   EXPECT_FALSE(message.has_optional_double  ());
399   EXPECT_FALSE(message.has_optional_bool    ());
400   EXPECT_FALSE(message.has_optional_string  ());
401   EXPECT_FALSE(message.has_optional_bytes   ());
403   EXPECT_FALSE(message.has_optionalgroup                 ());
404   EXPECT_FALSE(message.has_optional_nested_message       ());
405   EXPECT_FALSE(message.has_optional_foreign_message      ());
406   EXPECT_FALSE(message.has_optional_import_message       ());
407   EXPECT_FALSE(message.has_optional_public_import_message());
408   EXPECT_FALSE(message.has_optional_lazy_message         ());
410   EXPECT_FALSE(message.has_optional_nested_enum ());
411   EXPECT_FALSE(message.has_optional_foreign_enum());
412   EXPECT_FALSE(message.has_optional_import_enum ());
416   EXPECT_EQ(0    , message.optional_int32   ());
417   EXPECT_EQ(0    , message.optional_int64   ());
418   EXPECT_EQ(0    , message.optional_uint32  ());
419   EXPECT_EQ(0    , message.optional_uint64  ());
420   EXPECT_EQ(0    , message.optional_sint32  ());
421   EXPECT_EQ(0    , message.optional_sint64  ());
422   EXPECT_EQ(0    , message.optional_fixed32 ());
423   EXPECT_EQ(0    , message.optional_fixed64 ());
424   EXPECT_EQ(0    , message.optional_sfixed32());
425   EXPECT_EQ(0    , message.optional_sfixed64());
426   EXPECT_EQ(0    , message.optional_float   ());
427   EXPECT_EQ(0    , message.optional_double  ());
428   EXPECT_EQ(false, message.optional_bool    ());
429   EXPECT_EQ(""   , message.optional_string  ());
430   EXPECT_EQ(""   , message.optional_bytes   ());
433   EXPECT_FALSE(message.optionalgroup                 ().has_a());
434   EXPECT_FALSE(message.optional_nested_message       ().has_bb());
435   EXPECT_FALSE(message.optional_foreign_message      ().has_c());
436   EXPECT_FALSE(message.optional_import_message       ().has_d());
437   EXPECT_FALSE(message.optional_public_import_message().has_e());
438   EXPECT_FALSE(message.optional_lazy_message         ().has_bb());
440   EXPECT_EQ(0, message.optionalgroup           ().a());
441   EXPECT_EQ(0, message.optional_nested_message ().bb());
442   EXPECT_EQ(0, message.optional_foreign_message().c());
443   EXPECT_EQ(0, message.optional_import_message ().d());
446   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.optional_nested_enum ());
447   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.optional_foreign_enum());
448   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.optional_import_enum ());
452   EXPECT_EQ(0, message.repeated_int32_size   ());
453   EXPECT_EQ(0, message.repeated_int64_size   ());
454   EXPECT_EQ(0, message.repeated_uint32_size  ());
455   EXPECT_EQ(0, message.repeated_uint64_size  ());
456   EXPECT_EQ(0, message.repeated_sint32_size  ());
457   EXPECT_EQ(0, message.repeated_sint64_size  ());
458   EXPECT_EQ(0, message.repeated_fixed32_size ());
459   EXPECT_EQ(0, message.repeated_fixed64_size ());
460   EXPECT_EQ(0, message.repeated_sfixed32_size());
461   EXPECT_EQ(0, message.repeated_sfixed64_size());
462   EXPECT_EQ(0, message.repeated_float_size   ());
463   EXPECT_EQ(0, message.repeated_double_size  ());
464   EXPECT_EQ(0, message.repeated_bool_size    ());
465   EXPECT_EQ(0, message.repeated_string_size  ());
466   EXPECT_EQ(0, message.repeated_bytes_size   ());
468   EXPECT_EQ(0, message.repeatedgroup_size           ());
469   EXPECT_EQ(0, message.repeated_nested_message_size ());
470   EXPECT_EQ(0, message.repeated_foreign_message_size());
471   EXPECT_EQ(0, message.repeated_import_message_size ());
472   EXPECT_EQ(0, message.repeated_lazy_message_size   ());
473   EXPECT_EQ(0, message.repeated_nested_enum_size    ());
474   EXPECT_EQ(0, message.repeated_foreign_enum_size   ());
475   EXPECT_EQ(0, message.repeated_import_enum_size    ());
479   EXPECT_FALSE(message.has_default_int32   ());
480   EXPECT_FALSE(message.has_default_int64   ());
481   EXPECT_FALSE(message.has_default_uint32  ());
482   EXPECT_FALSE(message.has_default_uint64  ());
483   EXPECT_FALSE(message.has_default_sint32  ());
484   EXPECT_FALSE(message.has_default_sint64  ());
485   EXPECT_FALSE(message.has_default_fixed32 ());
486   EXPECT_FALSE(message.has_default_fixed64 ());
487   EXPECT_FALSE(message.has_default_sfixed32());
488   EXPECT_FALSE(message.has_default_sfixed64());
489   EXPECT_FALSE(message.has_default_float   ());
490   EXPECT_FALSE(message.has_default_double  ());
491   EXPECT_FALSE(message.has_default_bool    ());
492   EXPECT_FALSE(message.has_default_string  ());
493   EXPECT_FALSE(message.has_default_bytes   ());
495   EXPECT_FALSE(message.has_default_nested_enum ());
496   EXPECT_FALSE(message.has_default_foreign_enum());
497   EXPECT_FALSE(message.has_default_import_enum ());
501   EXPECT_EQ( 41    , message.default_int32   ());
502   EXPECT_EQ( 42    , message.default_int64   ());
503   EXPECT_EQ( 43    , message.default_uint32  ());
504   EXPECT_EQ( 44    , message.default_uint64  ());
505   EXPECT_EQ(-45    , message.default_sint32  ());
506   EXPECT_EQ( 46    , message.default_sint64  ());
507   EXPECT_EQ( 47    , message.default_fixed32 ());
508   EXPECT_EQ( 48    , message.default_fixed64 ());
509   EXPECT_EQ( 49    , message.default_sfixed32());
510   EXPECT_EQ(-50    , message.default_sfixed64());
511   EXPECT_EQ( 51.5  , message.default_float   ());
512   EXPECT_EQ( 52e3  , message.default_double  ());
513   EXPECT_EQ(true   , message.default_bool    ());
514   EXPECT_EQ("hello", message.default_string  ());
515   EXPECT_EQ("world", message.default_bytes   ());
517   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.default_nested_enum ());
518   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.default_foreign_enum());
519   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.default_import_enum ());
526     const unittest::TestAllTypesLite& message) {
530   ASSERT_EQ(2, message.repeated_int32_size   ());
531   ASSERT_EQ(2, message.repeated_int64_size   ());
532   ASSERT_EQ(2, message.repeated_uint32_size  ());
533   ASSERT_EQ(2, message.repeated_uint64_size  ());
534   ASSERT_EQ(2, message.repeated_sint32_size  ());
535   ASSERT_EQ(2, message.repeated_sint64_size  ());
536   ASSERT_EQ(2, message.repeated_fixed32_size ());
537   ASSERT_EQ(2, message.repeated_fixed64_size ());
538   ASSERT_EQ(2, message.repeated_sfixed32_size());
539   ASSERT_EQ(2, message.repeated_sfixed64_size());
540   ASSERT_EQ(2, message.repeated_float_size   ());
541   ASSERT_EQ(2, message.repeated_double_size  ());
542   ASSERT_EQ(2, message.repeated_bool_size    ());
543   ASSERT_EQ(2, message.repeated_string_size  ());
544   ASSERT_EQ(2, message.repeated_bytes_size   ());
546   ASSERT_EQ(2, message.repeatedgroup_size           ());
547   ASSERT_EQ(2, message.repeated_nested_message_size ());
548   ASSERT_EQ(2, message.repeated_foreign_message_size());
549   ASSERT_EQ(2, message.repeated_import_message_size ());
550   ASSERT_EQ(2, message.repeated_lazy_message_size   ());
551   ASSERT_EQ(2, message.repeated_nested_enum_size    ());
552   ASSERT_EQ(2, message.repeated_foreign_enum_size   ());
553   ASSERT_EQ(2, message.repeated_import_enum_size    ());
556   EXPECT_EQ(201  , message.repeated_int32   (0));
557   EXPECT_EQ(202  , message.repeated_int64   (0));
558   EXPECT_EQ(203  , message.repeated_uint32  (0));
559   EXPECT_EQ(204  , message.repeated_uint64  (0));
560   EXPECT_EQ(205  , message.repeated_sint32  (0));
561   EXPECT_EQ(206  , message.repeated_sint64  (0));
562   EXPECT_EQ(207  , message.repeated_fixed32 (0));
563   EXPECT_EQ(208  , message.repeated_fixed64 (0));
564   EXPECT_EQ(209  , message.repeated_sfixed32(0));
565   EXPECT_EQ(210  , message.repeated_sfixed64(0));
566   EXPECT_EQ(211  , message.repeated_float   (0));
567   EXPECT_EQ(212  , message.repeated_double  (0));
568   EXPECT_EQ(true , message.repeated_bool    (0));
569   EXPECT_EQ("215", message.repeated_string  (0));
570   EXPECT_EQ("216", message.repeated_bytes   (0));
572   EXPECT_EQ(217, message.repeatedgroup           (0).a());
573   EXPECT_EQ(218, message.repeated_nested_message (0).bb());
574   EXPECT_EQ(219, message.repeated_foreign_message(0).c());
575   EXPECT_EQ(220, message.repeated_import_message (0).d());
576   EXPECT_EQ(227, message.repeated_lazy_message   (0).bb());
578   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.repeated_nested_enum (0));
579   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.repeated_foreign_enum(0));
580   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum (0));
584   EXPECT_EQ(501  , message.repeated_int32   (1));
585   EXPECT_EQ(502  , message.repeated_int64   (1));
586   EXPECT_EQ(503  , message.repeated_uint32  (1));
587   EXPECT_EQ(504  , message.repeated_uint64  (1));
588   EXPECT_EQ(505  , message.repeated_sint32  (1));
589   EXPECT_EQ(506  , message.repeated_sint64  (1));
590   EXPECT_EQ(507  , message.repeated_fixed32 (1));
591   EXPECT_EQ(508  , message.repeated_fixed64 (1));
592   EXPECT_EQ(509  , message.repeated_sfixed32(1));
593   EXPECT_EQ(510  , message.repeated_sfixed64(1));
594   EXPECT_EQ(511  , message.repeated_float   (1));
595   EXPECT_EQ(512  , message.repeated_double  (1));
596   EXPECT_EQ(true , message.repeated_bool    (1));
597   EXPECT_EQ("515", message.repeated_string  (1));
598   EXPECT_EQ("516", message.repeated_bytes   (1));
600   EXPECT_EQ(517, message.repeatedgroup           (1).a());
601   EXPECT_EQ(518, message.repeated_nested_message (1).bb());
602   EXPECT_EQ(519, message.repeated_foreign_message(1).c());
603   EXPECT_EQ(520, message.repeated_import_message (1).d());
604   EXPECT_EQ(527, message.repeated_lazy_message   (1).bb());
606   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.repeated_nested_enum (1));
607   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.repeated_foreign_enum(1));
608   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.repeated_import_enum (1));
614 void TestUtilLite::SetPackedFields(unittest::TestPackedTypesLite* message) {
615   message->add_packed_int32   (601);
616   message->add_packed_int64   (602);
617   message->add_packed_uint32  (603);
618   message->add_packed_uint64  (604);
619   message->add_packed_sint32  (605);
620   message->add_packed_sint64  (606);
621   message->add_packed_fixed32 (607);
622   message->add_packed_fixed64 (608);
623   message->add_packed_sfixed32(609);
624   message->add_packed_sfixed64(610);
625   message->add_packed_float   (611);
626   message->add_packed_double  (612);
627   message->add_packed_bool    (true);
628   message->add_packed_enum    (unittest::FOREIGN_LITE_BAR);
630   message->add_packed_int32   (701);
631   message->add_packed_int64   (702);
632   message->add_packed_uint32  (703);
633   message->add_packed_uint64  (704);
634   message->add_packed_sint32  (705);
635   message->add_packed_sint64  (706);
636   message->add_packed_fixed32 (707);
637   message->add_packed_fixed64 (708);
638   message->add_packed_sfixed32(709);
639   message->add_packed_sfixed64(710);
640   message->add_packed_float   (711);
641   message->add_packed_double  (712);
642   message->add_packed_bool    (false);
643   message->add_packed_enum    (unittest::FOREIGN_LITE_BAZ);
648 void TestUtilLite::ModifyPackedFields(unittest::TestPackedTypesLite* message) {
649   message->set_packed_int32   (1, 801);
650   message->set_packed_int64   (1, 802);
651   message->set_packed_uint32  (1, 803);
652   message->set_packed_uint64  (1, 804);
653   message->set_packed_sint32  (1, 805);
654   message->set_packed_sint64  (1, 806);
655   message->set_packed_fixed32 (1, 807);
656   message->set_packed_fixed64 (1, 808);
657   message->set_packed_sfixed32(1, 809);
658   message->set_packed_sfixed64(1, 810);
659   message->set_packed_float   (1, 811);
660   message->set_packed_double  (1, 812);
661   message->set_packed_bool    (1, true);
662   message->set_packed_enum    (1, unittest::FOREIGN_LITE_FOO);
668     const unittest::TestPackedTypesLite& message) {
669   ASSERT_EQ(2, message.packed_int32_size   ());
670   ASSERT_EQ(2, message.packed_int64_size   ());
671   ASSERT_EQ(2, message.packed_uint32_size  ());
672   ASSERT_EQ(2, message.packed_uint64_size  ());
673   ASSERT_EQ(2, message.packed_sint32_size  ());
674   ASSERT_EQ(2, message.packed_sint64_size  ());
675   ASSERT_EQ(2, message.packed_fixed32_size ());
676   ASSERT_EQ(2, message.packed_fixed64_size ());
677   ASSERT_EQ(2, message.packed_sfixed32_size());
678   ASSERT_EQ(2, message.packed_sfixed64_size());
679   ASSERT_EQ(2, message.packed_float_size   ());
680   ASSERT_EQ(2, message.packed_double_size  ());
681   ASSERT_EQ(2, message.packed_bool_size    ());
682   ASSERT_EQ(2, message.packed_enum_size    ());
684   EXPECT_EQ(601  , message.packed_int32   (0));
685   EXPECT_EQ(602  , message.packed_int64   (0));
686   EXPECT_EQ(603  , message.packed_uint32  (0));
687   EXPECT_EQ(604  , message.packed_uint64  (0));
688   EXPECT_EQ(605  , message.packed_sint32  (0));
689   EXPECT_EQ(606  , message.packed_sint64  (0));
690   EXPECT_EQ(607  , message.packed_fixed32 (0));
691   EXPECT_EQ(608  , message.packed_fixed64 (0));
692   EXPECT_EQ(609  , message.packed_sfixed32(0));
693   EXPECT_EQ(610  , message.packed_sfixed64(0));
694   EXPECT_EQ(611  , message.packed_float   (0));
695   EXPECT_EQ(612  , message.packed_double  (0));
696   EXPECT_EQ(true , message.packed_bool    (0));
697   EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0));
699   EXPECT_EQ(701  , message.packed_int32   (1));
700   EXPECT_EQ(702  , message.packed_int64   (1));
701   EXPECT_EQ(703  , message.packed_uint32  (1));
702   EXPECT_EQ(704  , message.packed_uint64  (1));
703   EXPECT_EQ(705  , message.packed_sint32  (1));
704   EXPECT_EQ(706  , message.packed_sint64  (1));
705   EXPECT_EQ(707  , message.packed_fixed32 (1));
706   EXPECT_EQ(708  , message.packed_fixed64 (1));
707   EXPECT_EQ(709  , message.packed_sfixed32(1));
708   EXPECT_EQ(710  , message.packed_sfixed64(1));
709   EXPECT_EQ(711  , message.packed_float   (1));
710   EXPECT_EQ(712  , message.packed_double  (1));
711   EXPECT_EQ(false, message.packed_bool    (1));
712   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ, message.packed_enum(1));
718     const unittest::TestPackedTypesLite& message) {
720   EXPECT_EQ(0, message.packed_int32_size   ());
721   EXPECT_EQ(0, message.packed_int64_size   ());
722   EXPECT_EQ(0, message.packed_uint32_size  ());
723   EXPECT_EQ(0, message.packed_uint64_size  ());
724   EXPECT_EQ(0, message.packed_sint32_size  ());
725   EXPECT_EQ(0, message.packed_sint64_size  ());
726   EXPECT_EQ(0, message.packed_fixed32_size ());
727   EXPECT_EQ(0, message.packed_fixed64_size ());
728   EXPECT_EQ(0, message.packed_sfixed32_size());
729   EXPECT_EQ(0, message.packed_sfixed64_size());
730   EXPECT_EQ(0, message.packed_float_size   ());
731   EXPECT_EQ(0, message.packed_double_size  ());
732   EXPECT_EQ(0, message.packed_bool_size    ());
733   EXPECT_EQ(0, message.packed_enum_size    ());
739     const unittest::TestPackedTypesLite& message) {
741   ASSERT_EQ(2, message.packed_int32_size   ());
742   ASSERT_EQ(2, message.packed_int64_size   ());
743   ASSERT_EQ(2, message.packed_uint32_size  ());
744   ASSERT_EQ(2, message.packed_uint64_size  ());
745   ASSERT_EQ(2, message.packed_sint32_size  ());
746   ASSERT_EQ(2, message.packed_sint64_size  ());
747   ASSERT_EQ(2, message.packed_fixed32_size ());
748   ASSERT_EQ(2, message.packed_fixed64_size ());
749   ASSERT_EQ(2, message.packed_sfixed32_size());
750   ASSERT_EQ(2, message.packed_sfixed64_size());
751   ASSERT_EQ(2, message.packed_float_size   ());
752   ASSERT_EQ(2, message.packed_double_size  ());
753   ASSERT_EQ(2, message.packed_bool_size    ());
754   ASSERT_EQ(2, message.packed_enum_size    ());
756   EXPECT_EQ(601  , message.packed_int32   (0));
757   EXPECT_EQ(602  , message.packed_int64   (0));
758   EXPECT_EQ(603  , message.packed_uint32  (0));
759   EXPECT_EQ(604  , message.packed_uint64  (0));
760   EXPECT_EQ(605  , message.packed_sint32  (0));
761   EXPECT_EQ(606  , message.packed_sint64  (0));
762   EXPECT_EQ(607  , message.packed_fixed32 (0));
763   EXPECT_EQ(608  , message.packed_fixed64 (0));
764   EXPECT_EQ(609  , message.packed_sfixed32(0));
765   EXPECT_EQ(610  , message.packed_sfixed64(0));
766   EXPECT_EQ(611  , message.packed_float   (0));
767   EXPECT_EQ(612  , message.packed_double  (0));
768   EXPECT_EQ(true , message.packed_bool    (0));
769   EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0));
771   EXPECT_EQ(801  , message.packed_int32   (1));
772   EXPECT_EQ(802  , message.packed_int64   (1));
773   EXPECT_EQ(803  , message.packed_uint32  (1));
774   EXPECT_EQ(804  , message.packed_uint64  (1));
775   EXPECT_EQ(805  , message.packed_sint32  (1));
776   EXPECT_EQ(806  , message.packed_sint64  (1));
777   EXPECT_EQ(807  , message.packed_fixed32 (1));
778   EXPECT_EQ(808  , message.packed_fixed64 (1));
779   EXPECT_EQ(809  , message.packed_sfixed32(1));
780   EXPECT_EQ(810  , message.packed_sfixed64(1));
781   EXPECT_EQ(811  , message.packed_float   (1));
782   EXPECT_EQ(812  , message.packed_double  (1));
783   EXPECT_EQ(true , message.packed_bool    (1));
784   EXPECT_EQ(unittest::FOREIGN_LITE_FOO, message.packed_enum(1));
795 void TestUtilLite::SetAllExtensions(unittest::TestAllExtensionsLite* message) {
796   message->SetExtension(unittest::optional_int32_extension_lite   , 101);
797   message->SetExtension(unittest::optional_int64_extension_lite   , 102);
798   message->SetExtension(unittest::optional_uint32_extension_lite  , 103);
799   message->SetExtension(unittest::optional_uint64_extension_lite  , 104);
800   message->SetExtension(unittest::optional_sint32_extension_lite  , 105);
801   message->SetExtension(unittest::optional_sint64_extension_lite  , 106);
802   message->SetExtension(unittest::optional_fixed32_extension_lite , 107);
803   message->SetExtension(unittest::optional_fixed64_extension_lite , 108);
804   message->SetExtension(unittest::optional_sfixed32_extension_lite, 109);
805   message->SetExtension(unittest::optional_sfixed64_extension_lite, 110);
806   message->SetExtension(unittest::optional_float_extension_lite   , 111);
807   message->SetExtension(unittest::optional_double_extension_lite  , 112);
808   message->SetExtension(unittest::optional_bool_extension_lite    , true);
809   message->SetExtension(unittest::optional_string_extension_lite  , "115");
810   message->SetExtension(unittest::optional_bytes_extension_lite   , "116");
812   message->MutableExtension(unittest::optionalgroup_extension_lite                 )->set_a(117);
813   message->MutableExtension(unittest::optional_nested_message_extension_lite       )->set_bb(118);
814   message->MutableExtension(unittest::optional_foreign_message_extension_lite      )->set_c(119);
815   message->MutableExtension(unittest::optional_import_message_extension_lite       )->set_d(120);
816   message->MutableExtension(unittest::optional_public_import_message_extension_lite)->set_e(126);
817   message->MutableExtension(unittest::optional_lazy_message_extension_lite         )->set_bb(127);
819   message->SetExtension(unittest::optional_nested_enum_extension_lite , unittest::TestAllTypesLite::BAZ );
820   message->SetExtension(unittest::optional_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAZ      );
821   message->SetExtension(unittest::optional_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAZ);
826   message->AddExtension(unittest::repeated_int32_extension_lite   , 201);
827   message->AddExtension(unittest::repeated_int64_extension_lite   , 202);
828   message->AddExtension(unittest::repeated_uint32_extension_lite  , 203);
829   message->AddExtension(unittest::repeated_uint64_extension_lite  , 204);
830   message->AddExtension(unittest::repeated_sint32_extension_lite  , 205);
831   message->AddExtension(unittest::repeated_sint64_extension_lite  , 206);
832   message->AddExtension(unittest::repeated_fixed32_extension_lite , 207);
833   message->AddExtension(unittest::repeated_fixed64_extension_lite , 208);
834   message->AddExtension(unittest::repeated_sfixed32_extension_lite, 209);
835   message->AddExtension(unittest::repeated_sfixed64_extension_lite, 210);
836   message->AddExtension(unittest::repeated_float_extension_lite   , 211);
837   message->AddExtension(unittest::repeated_double_extension_lite  , 212);
838   message->AddExtension(unittest::repeated_bool_extension_lite    , true);
839   message->AddExtension(unittest::repeated_string_extension_lite  , "215");
840   message->AddExtension(unittest::repeated_bytes_extension_lite   , "216");
842   message->AddExtension(unittest::repeatedgroup_extension_lite           )->set_a(217);
843   message->AddExtension(unittest::repeated_nested_message_extension_lite )->set_bb(218);
844   message->AddExtension(unittest::repeated_foreign_message_extension_lite)->set_c(219);
845   message->AddExtension(unittest::repeated_import_message_extension_lite )->set_d(220);
846   message->AddExtension(unittest::repeated_lazy_message_extension_lite   )->set_bb(227);
848   message->AddExtension(unittest::repeated_nested_enum_extension_lite , unittest::TestAllTypesLite::BAR );
849   message->AddExtension(unittest::repeated_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAR      );
850   message->AddExtension(unittest::repeated_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAR);
854   message->AddExtension(unittest::repeated_int32_extension_lite   , 301);
855   message->AddExtension(unittest::repeated_int64_extension_lite   , 302);
856   message->AddExtension(unittest::repeated_uint32_extension_lite  , 303);
857   message->AddExtension(unittest::repeated_uint64_extension_lite  , 304);
858   message->AddExtension(unittest::repeated_sint32_extension_lite  , 305);
859   message->AddExtension(unittest::repeated_sint64_extension_lite  , 306);
860   message->AddExtension(unittest::repeated_fixed32_extension_lite , 307);
861   message->AddExtension(unittest::repeated_fixed64_extension_lite , 308);
862   message->AddExtension(unittest::repeated_sfixed32_extension_lite, 309);
863   message->AddExtension(unittest::repeated_sfixed64_extension_lite, 310);
864   message->AddExtension(unittest::repeated_float_extension_lite   , 311);
865   message->AddExtension(unittest::repeated_double_extension_lite  , 312);
866   message->AddExtension(unittest::repeated_bool_extension_lite    , false);
867   message->AddExtension(unittest::repeated_string_extension_lite  , "315");
868   message->AddExtension(unittest::repeated_bytes_extension_lite   , "316");
870   message->AddExtension(unittest::repeatedgroup_extension_lite           )->set_a(317);
871   message->AddExtension(unittest::repeated_nested_message_extension_lite )->set_bb(318);
872   message->AddExtension(unittest::repeated_foreign_message_extension_lite)->set_c(319);
873   message->AddExtension(unittest::repeated_import_message_extension_lite )->set_d(320);
874   message->AddExtension(unittest::repeated_lazy_message_extension_lite   )->set_bb(327);
876   message->AddExtension(unittest::repeated_nested_enum_extension_lite , unittest::TestAllTypesLite::BAZ );
877   message->AddExtension(unittest::repeated_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAZ      );
878   message->AddExtension(unittest::repeated_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAZ);
883   message->SetExtension(unittest::default_int32_extension_lite   , 401);
884   message->SetExtension(unittest::default_int64_extension_lite   , 402);
885   message->SetExtension(unittest::default_uint32_extension_lite  , 403);
886   message->SetExtension(unittest::default_uint64_extension_lite  , 404);
887   message->SetExtension(unittest::default_sint32_extension_lite  , 405);
888   message->SetExtension(unittest::default_sint64_extension_lite  , 406);
889   message->SetExtension(unittest::default_fixed32_extension_lite , 407);
890   message->SetExtension(unittest::default_fixed64_extension_lite , 408);
891   message->SetExtension(unittest::default_sfixed32_extension_lite, 409);
892   message->SetExtension(unittest::default_sfixed64_extension_lite, 410);
893   message->SetExtension(unittest::default_float_extension_lite   , 411);
894   message->SetExtension(unittest::default_double_extension_lite  , 412);
895   message->SetExtension(unittest::default_bool_extension_lite    , false);
896   message->SetExtension(unittest::default_string_extension_lite  , "415");
897   message->SetExtension(unittest::default_bytes_extension_lite   , "416");
899   message->SetExtension(unittest::default_nested_enum_extension_lite , unittest::TestAllTypesLite::FOO );
900   message->SetExtension(unittest::default_foreign_enum_extension_lite, unittest::FOREIGN_LITE_FOO      );
901   message->SetExtension(unittest::default_import_enum_extension_lite , unittest_import::IMPORT_LITE_FOO);
908     unittest::TestAllExtensionsLite* message) {
909   message->SetExtension(unittest::repeated_int32_extension_lite   , 1, 501);
910   message->SetExtension(unittest::repeated_int64_extension_lite   , 1, 502);
911   message->SetExtension(unittest::repeated_uint32_extension_lite  , 1, 503);
912   message->SetExtension(unittest::repeated_uint64_extension_lite  , 1, 504);
913   message->SetExtension(unittest::repeated_sint32_extension_lite  , 1, 505);
914   message->SetExtension(unittest::repeated_sint64_extension_lite  , 1, 506);
915   message->SetExtension(unittest::repeated_fixed32_extension_lite , 1, 507);
916   message->SetExtension(unittest::repeated_fixed64_extension_lite , 1, 508);
917   message->SetExtension(unittest::repeated_sfixed32_extension_lite, 1, 509);
918   message->SetExtension(unittest::repeated_sfixed64_extension_lite, 1, 510);
919   message->SetExtension(unittest::repeated_float_extension_lite   , 1, 511);
920   message->SetExtension(unittest::repeated_double_extension_lite  , 1, 512);
921   message->SetExtension(unittest::repeated_bool_extension_lite    , 1, true);
922   message->SetExtension(unittest::repeated_string_extension_lite  , 1, "515");
923   message->SetExtension(unittest::repeated_bytes_extension_lite   , 1, "516");
925   message->MutableExtension(unittest::repeatedgroup_extension_lite           , 1)->set_a(517);
926   message->MutableExtension(unittest::repeated_nested_message_extension_lite , 1)->set_bb(518);
927   message->MutableExtension(unittest::repeated_foreign_message_extension_lite, 1)->set_c(519);
928   message->MutableExtension(unittest::repeated_import_message_extension_lite , 1)->set_d(520);
929   message->MutableExtension(unittest::repeated_lazy_message_extension_lite   , 1)->set_bb(527);
931   message->SetExtension(unittest::repeated_nested_enum_extension_lite , 1, unittest::TestAllTypesLite::FOO );
932   message->SetExtension(unittest::repeated_foreign_enum_extension_lite, 1, unittest::FOREIGN_LITE_FOO      );
933   message->SetExtension(unittest::repeated_import_enum_extension_lite , 1, unittest_import::IMPORT_LITE_FOO);
940     const unittest::TestAllExtensionsLite& message) {
941   EXPECT_TRUE(message.HasExtension(unittest::optional_int32_extension_lite   ));
942   EXPECT_TRUE(message.HasExtension(unittest::optional_int64_extension_lite   ));
943   EXPECT_TRUE(message.HasExtension(unittest::optional_uint32_extension_lite  ));
944   EXPECT_TRUE(message.HasExtension(unittest::optional_uint64_extension_lite  ));
945   EXPECT_TRUE(message.HasExtension(unittest::optional_sint32_extension_lite  ));
946   EXPECT_TRUE(message.HasExtension(unittest::optional_sint64_extension_lite  ));
947   EXPECT_TRUE(message.HasExtension(unittest::optional_fixed32_extension_lite ));
948   EXPECT_TRUE(message.HasExtension(unittest::optional_fixed64_extension_lite ));
949   EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed32_extension_lite));
950   EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed64_extension_lite));
951   EXPECT_TRUE(message.HasExtension(unittest::optional_float_extension_lite   ));
952   EXPECT_TRUE(message.HasExtension(unittest::optional_double_extension_lite  ));
953   EXPECT_TRUE(message.HasExtension(unittest::optional_bool_extension_lite    ));
954   EXPECT_TRUE(message.HasExtension(unittest::optional_string_extension_lite  ));
955   EXPECT_TRUE(message.HasExtension(unittest::optional_bytes_extension_lite   ));
957   EXPECT_TRUE(message.HasExtension(unittest::optionalgroup_extension_lite                 ));
958   EXPECT_TRUE(message.HasExtension(unittest::optional_nested_message_extension_lite       ));
959   EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_message_extension_lite      ));
960   EXPECT_TRUE(message.HasExtension(unittest::optional_import_message_extension_lite       ));
961   EXPECT_TRUE(message.HasExtension(unittest::optional_public_import_message_extension_lite));
962   EXPECT_TRUE(message.HasExtension(unittest::optional_lazy_message_extension_lite         ));
964   EXPECT_TRUE(message.GetExtension(unittest::optionalgroup_extension_lite                 ).has_a());
965   EXPECT_TRUE(message.GetExtension(unittest::optional_nested_message_extension_lite       ).has_bb());
966   EXPECT_TRUE(message.GetExtension(unittest::optional_foreign_message_extension_lite      ).has_c());
967   EXPECT_TRUE(message.GetExtension(unittest::optional_import_message_extension_lite       ).has_d());
968   EXPECT_TRUE(message.GetExtension(unittest::optional_public_import_message_extension_lite).has_e());
969   EXPECT_TRUE(message.GetExtension(unittest::optional_lazy_message_extension_lite         ).has_bb());
971   EXPECT_TRUE(message.HasExtension(unittest::optional_nested_enum_extension_lite ));
972   EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_enum_extension_lite));
973   EXPECT_TRUE(message.HasExtension(unittest::optional_import_enum_extension_lite ));
976   EXPECT_EQ(101  , message.GetExtension(unittest::optional_int32_extension_lite   ));
977   EXPECT_EQ(102  , message.GetExtension(unittest::optional_int64_extension_lite   ));
978   EXPECT_EQ(103  , message.GetExtension(unittest::optional_uint32_extension_lite  ));
979   EXPECT_EQ(104  , message.GetExtension(unittest::optional_uint64_extension_lite  ));
980   EXPECT_EQ(105  , message.GetExtension(unittest::optional_sint32_extension_lite  ));
981   EXPECT_EQ(106  , message.GetExtension(unittest::optional_sint64_extension_lite  ));
982   EXPECT_EQ(107  , message.GetExtension(unittest::optional_fixed32_extension_lite ));
983   EXPECT_EQ(108  , message.GetExtension(unittest::optional_fixed64_extension_lite ));
984   EXPECT_EQ(109  , message.GetExtension(unittest::optional_sfixed32_extension_lite));
985   EXPECT_EQ(110  , message.GetExtension(unittest::optional_sfixed64_extension_lite));
986   EXPECT_EQ(111  , message.GetExtension(unittest::optional_float_extension_lite   ));
987   EXPECT_EQ(112  , message.GetExtension(unittest::optional_double_extension_lite  ));
988   EXPECT_EQ(true , message.GetExtension(unittest::optional_bool_extension_lite    ));
989   EXPECT_EQ("115", message.GetExtension(unittest::optional_string_extension_lite  ));
990   EXPECT_EQ("116", message.GetExtension(unittest::optional_bytes_extension_lite   ));
992   EXPECT_EQ(117, message.GetExtension(unittest::optionalgroup_extension_lite                 ).a());
993   EXPECT_EQ(118, message.GetExtension(unittest::optional_nested_message_extension_lite       ).bb());
994   EXPECT_EQ(119, message.GetExtension(unittest::optional_foreign_message_extension_lite      ).c());
995   EXPECT_EQ(120, message.GetExtension(unittest::optional_import_message_extension_lite       ).d());
996   EXPECT_EQ(126, message.GetExtension(unittest::optional_public_import_message_extension_lite).e());
997   EXPECT_EQ(127, message.GetExtension(unittest::optional_lazy_message_extension_lite         ).bb());
999   EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.GetExtension(unittest::optional_nested_enum_extension_lite ));
1000   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ      , message.GetExtension(unittest::optional_foreign_enum_extension_lite));
1001   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.GetExtension(unittest::optional_import_enum_extension_lite ));
1006   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite   ));
1007   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite   ));
1008   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite  ));
1009   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite  ));
1010   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite  ));
1011   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite  ));
1012   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
1013   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
1014   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
1015   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
1016   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite   ));
1017   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite  ));
1018   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite    ));
1019   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite  ));
1020   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite   ));
1022   ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite           ));
1023   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
1024   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
1025   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
1026   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite   ));
1027   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite    ));
1028   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite   ));
1029   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite    ));
1032   EXPECT_EQ(201  , message.GetExtension(unittest::repeated_int32_extension_lite   , 0));
1033   EXPECT_EQ(202  , message.GetExtension(unittest::repeated_int64_extension_lite   , 0));
1034   EXPECT_EQ(203  , message.GetExtension(unittest::repeated_uint32_extension_lite  , 0));
1035   EXPECT_EQ(204  , message.GetExtension(unittest::repeated_uint64_extension_lite  , 0));
1036   EXPECT_EQ(205  , message.GetExtension(unittest::repeated_sint32_extension_lite  , 0));
1037   EXPECT_EQ(206  , message.GetExtension(unittest::repeated_sint64_extension_lite  , 0));
1038   EXPECT_EQ(207  , message.GetExtension(unittest::repeated_fixed32_extension_lite , 0));
1039   EXPECT_EQ(208  , message.GetExtension(unittest::repeated_fixed64_extension_lite , 0));
1040   EXPECT_EQ(209  , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));
1041   EXPECT_EQ(210  , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));
1042   EXPECT_EQ(211  , message.GetExtension(unittest::repeated_float_extension_lite   , 0));
1043   EXPECT_EQ(212  , message.GetExtension(unittest::repeated_double_extension_lite  , 0));
1044   EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite    , 0));
1045   EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension_lite  , 0));
1046   EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension_lite   , 0));
1048   EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension_lite           , 0).a());
1049   EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension_lite , 0).bb());
1050   EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0).c());
1051   EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension_lite , 0).d());
1052   EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension_lite   , 0).bb());
1054   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 0));
1055   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));
1056   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::repeated_import_enum_extension_lite , 0));
1059   EXPECT_EQ(301  , message.GetExtension(unittest::repeated_int32_extension_lite   , 1));
1060   EXPECT_EQ(302  , message.GetExtension(unittest::repeated_int64_extension_lite   , 1));
1061   EXPECT_EQ(303  , message.GetExtension(unittest::repeated_uint32_extension_lite  , 1));
1062   EXPECT_EQ(304  , message.GetExtension(unittest::repeated_uint64_extension_lite  , 1));
1063   EXPECT_EQ(305  , message.GetExtension(unittest::repeated_sint32_extension_lite  , 1));
1064   EXPECT_EQ(306  , message.GetExtension(unittest::repeated_sint64_extension_lite  , 1));
1065   EXPECT_EQ(307  , message.GetExtension(unittest::repeated_fixed32_extension_lite , 1));
1066   EXPECT_EQ(308  , message.GetExtension(unittest::repeated_fixed64_extension_lite , 1));
1067   EXPECT_EQ(309  , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));
1068   EXPECT_EQ(310  , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));
1069   EXPECT_EQ(311  , message.GetExtension(unittest::repeated_float_extension_lite   , 1));
1070   EXPECT_EQ(312  , message.GetExtension(unittest::repeated_double_extension_lite  , 1));
1071   EXPECT_EQ(false, message.GetExtension(unittest::repeated_bool_extension_lite    , 1));
1072   EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension_lite  , 1));
1073   EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension_lite   , 1));
1075   EXPECT_EQ(317, message.GetExtension(unittest::repeatedgroup_extension_lite           , 1).a());
1076   EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension_lite , 1).bb());
1077   EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1).c());
1078   EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension_lite , 1).d());
1079   EXPECT_EQ(327, message.GetExtension(unittest::repeated_lazy_message_extension_lite   , 1).bb());
1081   EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 1));
1082   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ      , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));
1083   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.GetExtension(unittest::repeated_import_enum_extension_lite , 1));
1088   EXPECT_TRUE(message.HasExtension(unittest::default_int32_extension_lite   ));
1089   EXPECT_TRUE(message.HasExtension(unittest::default_int64_extension_lite   ));
1090   EXPECT_TRUE(message.HasExtension(unittest::default_uint32_extension_lite  ));
1091   EXPECT_TRUE(message.HasExtension(unittest::default_uint64_extension_lite  ));
1092   EXPECT_TRUE(message.HasExtension(unittest::default_sint32_extension_lite  ));
1093   EXPECT_TRUE(message.HasExtension(unittest::default_sint64_extension_lite  ));
1094   EXPECT_TRUE(message.HasExtension(unittest::default_fixed32_extension_lite ));
1095   EXPECT_TRUE(message.HasExtension(unittest::default_fixed64_extension_lite ));
1096   EXPECT_TRUE(message.HasExtension(unittest::default_sfixed32_extension_lite));
1097   EXPECT_TRUE(message.HasExtension(unittest::default_sfixed64_extension_lite));
1098   EXPECT_TRUE(message.HasExtension(unittest::default_float_extension_lite   ));
1099   EXPECT_TRUE(message.HasExtension(unittest::default_double_extension_lite  ));
1100   EXPECT_TRUE(message.HasExtension(unittest::default_bool_extension_lite    ));
1101   EXPECT_TRUE(message.HasExtension(unittest::default_string_extension_lite  ));
1102   EXPECT_TRUE(message.HasExtension(unittest::default_bytes_extension_lite   ));
1104   EXPECT_TRUE(message.HasExtension(unittest::default_nested_enum_extension_lite ));
1105   EXPECT_TRUE(message.HasExtension(unittest::default_foreign_enum_extension_lite));
1106   EXPECT_TRUE(message.HasExtension(unittest::default_import_enum_extension_lite ));
1109   EXPECT_EQ(401  , message.GetExtension(unittest::default_int32_extension_lite   ));
1110   EXPECT_EQ(402  , message.GetExtension(unittest::default_int64_extension_lite   ));
1111   EXPECT_EQ(403  , message.GetExtension(unittest::default_uint32_extension_lite  ));
1112   EXPECT_EQ(404  , message.GetExtension(unittest::default_uint64_extension_lite  ));
1113   EXPECT_EQ(405  , message.GetExtension(unittest::default_sint32_extension_lite  ));
1114   EXPECT_EQ(406  , message.GetExtension(unittest::default_sint64_extension_lite  ));
1115   EXPECT_EQ(407  , message.GetExtension(unittest::default_fixed32_extension_lite ));
1116   EXPECT_EQ(408  , message.GetExtension(unittest::default_fixed64_extension_lite ));
1117   EXPECT_EQ(409  , message.GetExtension(unittest::default_sfixed32_extension_lite));
1118   EXPECT_EQ(410  , message.GetExtension(unittest::default_sfixed64_extension_lite));
1119   EXPECT_EQ(411  , message.GetExtension(unittest::default_float_extension_lite   ));
1120   EXPECT_EQ(412  , message.GetExtension(unittest::default_double_extension_lite  ));
1121   EXPECT_EQ(false, message.GetExtension(unittest::default_bool_extension_lite    ));
1122   EXPECT_EQ("415", message.GetExtension(unittest::default_string_extension_lite  ));
1123   EXPECT_EQ("416", message.GetExtension(unittest::default_bytes_extension_lite   ));
1125   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::default_nested_enum_extension_lite ));
1126   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.GetExtension(unittest::default_foreign_enum_extension_lite));
1127   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::default_import_enum_extension_lite ));
1134     const unittest::TestAllExtensionsLite& message) {
1136   ASSERT_TRUE(message.SerializeToString(&serialized));
1138   EXPECT_EQ(0, message.ByteSize());
1141   EXPECT_FALSE(message.HasExtension(unittest::optional_int32_extension_lite   ));
1142   EXPECT_FALSE(message.HasExtension(unittest::optional_int64_extension_lite   ));
1143   EXPECT_FALSE(message.HasExtension(unittest::optional_uint32_extension_lite  ));
1144   EXPECT_FALSE(message.HasExtension(unittest::optional_uint64_extension_lite  ));
1145   EXPECT_FALSE(message.HasExtension(unittest::optional_sint32_extension_lite  ));
1146   EXPECT_FALSE(message.HasExtension(unittest::optional_sint64_extension_lite  ));
1147   EXPECT_FALSE(message.HasExtension(unittest::optional_fixed32_extension_lite ));
1148   EXPECT_FALSE(message.HasExtension(unittest::optional_fixed64_extension_lite ));
1149   EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed32_extension_lite));
1150   EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed64_extension_lite));
1151   EXPECT_FALSE(message.HasExtension(unittest::optional_float_extension_lite   ));
1152   EXPECT_FALSE(message.HasExtension(unittest::optional_double_extension_lite  ));
1153   EXPECT_FALSE(message.HasExtension(unittest::optional_bool_extension_lite    ));
1154   EXPECT_FALSE(message.HasExtension(unittest::optional_string_extension_lite  ));
1155   EXPECT_FALSE(message.HasExtension(unittest::optional_bytes_extension_lite   ));
1157   EXPECT_FALSE(message.HasExtension(unittest::optionalgroup_extension_lite                 ));
1158   EXPECT_FALSE(message.HasExtension(unittest::optional_nested_message_extension_lite       ));
1159   EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_message_extension_lite      ));
1160   EXPECT_FALSE(message.HasExtension(unittest::optional_import_message_extension_lite       ));
1161   EXPECT_FALSE(message.HasExtension(unittest::optional_public_import_message_extension_lite));
1162   EXPECT_FALSE(message.HasExtension(unittest::optional_lazy_message_extension_lite         ));
1164   EXPECT_FALSE(message.HasExtension(unittest::optional_nested_enum_extension_lite ));
1165   EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_enum_extension_lite));
1166   EXPECT_FALSE(message.HasExtension(unittest::optional_import_enum_extension_lite ));
1170   EXPECT_EQ(0    , message.GetExtension(unittest::optional_int32_extension_lite   ));
1171   EXPECT_EQ(0    , message.GetExtension(unittest::optional_int64_extension_lite   ));
1172   EXPECT_EQ(0    , message.GetExtension(unittest::optional_uint32_extension_lite  ));
1173   EXPECT_EQ(0    , message.GetExtension(unittest::optional_uint64_extension_lite  ));
1174   EXPECT_EQ(0    , message.GetExtension(unittest::optional_sint32_extension_lite  ));
1175   EXPECT_EQ(0    , message.GetExtension(unittest::optional_sint64_extension_lite  ));
1176   EXPECT_EQ(0    , message.GetExtension(unittest::optional_fixed32_extension_lite ));
1177   EXPECT_EQ(0    , message.GetExtension(unittest::optional_fixed64_extension_lite ));
1178   EXPECT_EQ(0    , message.GetExtension(unittest::optional_sfixed32_extension_lite));
1179   EXPECT_EQ(0    , message.GetExtension(unittest::optional_sfixed64_extension_lite));
1180   EXPECT_EQ(0    , message.GetExtension(unittest::optional_float_extension_lite   ));
1181   EXPECT_EQ(0    , message.GetExtension(unittest::optional_double_extension_lite  ));
1182   EXPECT_EQ(false, message.GetExtension(unittest::optional_bool_extension_lite    ));
1183   EXPECT_EQ(""   , message.GetExtension(unittest::optional_string_extension_lite  ));
1184   EXPECT_EQ(""   , message.GetExtension(unittest::optional_bytes_extension_lite   ));
1187   EXPECT_FALSE(message.GetExtension(unittest::optionalgroup_extension_lite                 ).has_a());
1188   EXPECT_FALSE(message.GetExtension(unittest::optional_nested_message_extension_lite       ).has_bb());
1189   EXPECT_FALSE(message.GetExtension(unittest::optional_foreign_message_extension_lite      ).has_c());
1190   EXPECT_FALSE(message.GetExtension(unittest::optional_import_message_extension_lite       ).has_d());
1191   EXPECT_FALSE(message.GetExtension(unittest::optional_public_import_message_extension_lite).has_e());
1192   EXPECT_FALSE(message.GetExtension(unittest::optional_lazy_message_extension_lite         ).has_bb());
1194   EXPECT_EQ(0, message.GetExtension(unittest::optionalgroup_extension_lite                 ).a());
1195   EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension_lite       ).bb());
1196   EXPECT_EQ(0, message.GetExtension(unittest::optional_foreign_message_extension_lite      ).c());
1197   EXPECT_EQ(0, message.GetExtension(unittest::optional_import_message_extension_lite       ).d());
1198   EXPECT_EQ(0, message.GetExtension(unittest::optional_public_import_message_extension_lite).e());
1199   EXPECT_EQ(0, message.GetExtension(unittest::optional_lazy_message_extension_lite         ).bb());
1202   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::optional_nested_enum_extension_lite ));
1203   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.GetExtension(unittest::optional_foreign_enum_extension_lite));
1204   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::optional_import_enum_extension_lite ));
1208   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int32_extension_lite   ));
1209   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int64_extension_lite   ));
1210   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint32_extension_lite  ));
1211   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint64_extension_lite  ));
1212   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint32_extension_lite  ));
1213   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint64_extension_lite  ));
1214   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
1215   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
1216   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
1217   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
1218   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_float_extension_lite   ));
1219   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_double_extension_lite  ));
1220   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bool_extension_lite    ));
1221   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_extension_lite  ));
1222   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bytes_extension_lite   ));
1224   EXPECT_EQ(0, message.ExtensionSize(unittest::repeatedgroup_extension_lite           ));
1225   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
1226   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
1227   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
1228   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite   ));
1229   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite    ));
1230   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite   ));
1231   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_enum_extension_lite    ));
1235   EXPECT_FALSE(message.HasExtension(unittest::default_int32_extension_lite   ));
1236   EXPECT_FALSE(message.HasExtension(unittest::default_int64_extension_lite   ));
1237   EXPECT_FALSE(message.HasExtension(unittest::default_uint32_extension_lite  ));
1238   EXPECT_FALSE(message.HasExtension(unittest::default_uint64_extension_lite  ));
1239   EXPECT_FALSE(message.HasExtension(unittest::default_sint32_extension_lite  ));
1240   EXPECT_FALSE(message.HasExtension(unittest::default_sint64_extension_lite  ));
1241   EXPECT_FALSE(message.HasExtension(unittest::default_fixed32_extension_lite ));
1242   EXPECT_FALSE(message.HasExtension(unittest::default_fixed64_extension_lite ));
1243   EXPECT_FALSE(message.HasExtension(unittest::default_sfixed32_extension_lite));
1244   EXPECT_FALSE(message.HasExtension(unittest::default_sfixed64_extension_lite));
1245   EXPECT_FALSE(message.HasExtension(unittest::default_float_extension_lite   ));
1246   EXPECT_FALSE(message.HasExtension(unittest::default_double_extension_lite  ));
1247   EXPECT_FALSE(message.HasExtension(unittest::default_bool_extension_lite    ));
1248   EXPECT_FALSE(message.HasExtension(unittest::default_string_extension_lite  ));
1249   EXPECT_FALSE(message.HasExtension(unittest::default_bytes_extension_lite   ));
1251   EXPECT_FALSE(message.HasExtension(unittest::default_nested_enum_extension_lite ));
1252   EXPECT_FALSE(message.HasExtension(unittest::default_foreign_enum_extension_lite));
1253   EXPECT_FALSE(message.HasExtension(unittest::default_import_enum_extension_lite ));
1257   EXPECT_EQ( 41    , message.GetExtension(unittest::default_int32_extension_lite   ));
1258   EXPECT_EQ( 42    , message.GetExtension(unittest::default_int64_extension_lite   ));
1259   EXPECT_EQ( 43    , message.GetExtension(unittest::default_uint32_extension_lite  ));
1260   EXPECT_EQ( 44    , message.GetExtension(unittest::default_uint64_extension_lite  ));
1261   EXPECT_EQ(-45    , message.GetExtension(unittest::default_sint32_extension_lite  ));
1262   EXPECT_EQ( 46    , message.GetExtension(unittest::default_sint64_extension_lite  ));
1263   EXPECT_EQ( 47    , message.GetExtension(unittest::default_fixed32_extension_lite ));
1264   EXPECT_EQ( 48    , message.GetExtension(unittest::default_fixed64_extension_lite ));
1265   EXPECT_EQ( 49    , message.GetExtension(unittest::default_sfixed32_extension_lite));
1266   EXPECT_EQ(-50    , message.GetExtension(unittest::default_sfixed64_extension_lite));
1267   EXPECT_EQ( 51.5  , message.GetExtension(unittest::default_float_extension_lite   ));
1268   EXPECT_EQ( 52e3  , message.GetExtension(unittest::default_double_extension_lite  ));
1269   EXPECT_EQ(true   , message.GetExtension(unittest::default_bool_extension_lite    ));
1270   EXPECT_EQ("hello", message.GetExtension(unittest::default_string_extension_lite  ));
1271   EXPECT_EQ("world", message.GetExtension(unittest::default_bytes_extension_lite   ));
1273   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::default_nested_enum_extension_lite ));
1274   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.GetExtension(unittest::default_foreign_enum_extension_lite));
1275   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::default_import_enum_extension_lite ));
1282     const unittest::TestAllExtensionsLite& message) {
1286   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite   ));
1287   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite   ));
1288   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite  ));
1289   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite  ));
1290   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite  ));
1291   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite  ));
1292   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
1293   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
1294   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
1295   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
1296   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite   ));
1297   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite  ));
1298   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite    ));
1299   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite  ));
1300   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite   ));
1302   ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite           ));
1303   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
1304   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
1305   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
1306   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite   ));
1307   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite    ));
1308   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite   ));
1309   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite    ));
1312   EXPECT_EQ(201  , message.GetExtension(unittest::repeated_int32_extension_lite   , 0));
1313   EXPECT_EQ(202  , message.GetExtension(unittest::repeated_int64_extension_lite   , 0));
1314   EXPECT_EQ(203  , message.GetExtension(unittest::repeated_uint32_extension_lite  , 0));
1315   EXPECT_EQ(204  , message.GetExtension(unittest::repeated_uint64_extension_lite  , 0));
1316   EXPECT_EQ(205  , message.GetExtension(unittest::repeated_sint32_extension_lite  , 0));
1317   EXPECT_EQ(206  , message.GetExtension(unittest::repeated_sint64_extension_lite  , 0));
1318   EXPECT_EQ(207  , message.GetExtension(unittest::repeated_fixed32_extension_lite , 0));
1319   EXPECT_EQ(208  , message.GetExtension(unittest::repeated_fixed64_extension_lite , 0));
1320   EXPECT_EQ(209  , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));
1321   EXPECT_EQ(210  , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));
1322   EXPECT_EQ(211  , message.GetExtension(unittest::repeated_float_extension_lite   , 0));
1323   EXPECT_EQ(212  , message.GetExtension(unittest::repeated_double_extension_lite  , 0));
1324   EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite    , 0));
1325   EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension_lite  , 0));
1326   EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension_lite   , 0));
1328   EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension_lite           , 0).a());
1329   EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension_lite , 0).bb());
1330   EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0).c());
1331   EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension_lite , 0).d());
1332   EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension_lite   , 0).bb());
1334   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 0));
1335   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));
1336   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::repeated_import_enum_extension_lite , 0));
1340   EXPECT_EQ(501  , message.GetExtension(unittest::repeated_int32_extension_lite   , 1));
1341   EXPECT_EQ(502  , message.GetExtension(unittest::repeated_int64_extension_lite   , 1));
1342   EXPECT_EQ(503  , message.GetExtension(unittest::repeated_uint32_extension_lite  , 1));
1343   EXPECT_EQ(504  , message.GetExtension(unittest::repeated_uint64_extension_lite  , 1));
1344   EXPECT_EQ(505  , message.GetExtension(unittest::repeated_sint32_extension_lite  , 1));
1345   EXPECT_EQ(506  , message.GetExtension(unittest::repeated_sint64_extension_lite  , 1));
1346   EXPECT_EQ(507  , message.GetExtension(unittest::repeated_fixed32_extension_lite , 1));
1347   EXPECT_EQ(508  , message.GetExtension(unittest::repeated_fixed64_extension_lite , 1));
1348   EXPECT_EQ(509  , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));
1349   EXPECT_EQ(510  , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));
1350   EXPECT_EQ(511  , message.GetExtension(unittest::repeated_float_extension_lite   , 1));
1351   EXPECT_EQ(512  , message.GetExtension(unittest::repeated_double_extension_lite  , 1));
1352   EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite    , 1));
1353   EXPECT_EQ("515", message.GetExtension(unittest::repeated_string_extension_lite  , 1));
1354   EXPECT_EQ("516", message.GetExtension(unittest::repeated_bytes_extension_lite   , 1));
1356   EXPECT_EQ(517, message.GetExtension(unittest::repeatedgroup_extension_lite           , 1).a());
1357   EXPECT_EQ(518, message.GetExtension(unittest::repeated_nested_message_extension_lite , 1).bb());
1358   EXPECT_EQ(519, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1).c());
1359   EXPECT_EQ(520, message.GetExtension(unittest::repeated_import_message_extension_lite , 1).d());
1360   EXPECT_EQ(527, message.GetExtension(unittest::repeated_lazy_message_extension_lite   , 1).bb());
1362   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 1));
1363   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));
1364   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::repeated_import_enum_extension_lite , 1));
1371     unittest::TestPackedExtensionsLite* message) {
1372   message->AddExtension(unittest::packed_int32_extension_lite   , 601);
1373   message->AddExtension(unittest::packed_int64_extension_lite   , 602);
1374   message->AddExtension(unittest::packed_uint32_extension_lite  , 603);
1375   message->AddExtension(unittest::packed_uint64_extension_lite  , 604);
1376   message->AddExtension(unittest::packed_sint32_extension_lite  , 605);
1377   message->AddExtension(unittest::packed_sint64_extension_lite  , 606);
1378   message->AddExtension(unittest::packed_fixed32_extension_lite , 607);
1379   message->AddExtension(unittest::packed_fixed64_extension_lite , 608);
1380   message->AddExtension(unittest::packed_sfixed32_extension_lite, 609);
1381   message->AddExtension(unittest::packed_sfixed64_extension_lite, 610);
1382   message->AddExtension(unittest::packed_float_extension_lite   , 611);
1383   message->AddExtension(unittest::packed_double_extension_lite  , 612);
1384   message->AddExtension(unittest::packed_bool_extension_lite    , true);
1385   message->AddExtension(unittest::packed_enum_extension_lite, unittest::FOREIGN_LITE_BAR);
1387   message->AddExtension(unittest::packed_int32_extension_lite   , 701);
1388   message->AddExtension(unittest::packed_int64_extension_lite   , 702);
1389   message->AddExtension(unittest::packed_uint32_extension_lite  , 703);
1390   message->AddExtension(unittest::packed_uint64_extension_lite  , 704);
1391   message->AddExtension(unittest::packed_sint32_extension_lite  , 705);
1392   message->AddExtension(unittest::packed_sint64_extension_lite  , 706);
1393   message->AddExtension(unittest::packed_fixed32_extension_lite , 707);
1394   message->AddExtension(unittest::packed_fixed64_extension_lite , 708);
1395   message->AddExtension(unittest::packed_sfixed32_extension_lite, 709);
1396   message->AddExtension(unittest::packed_sfixed64_extension_lite, 710);
1397   message->AddExtension(unittest::packed_float_extension_lite   , 711);
1398   message->AddExtension(unittest::packed_double_extension_lite  , 712);
1399   message->AddExtension(unittest::packed_bool_extension_lite    , false);
1400   message->AddExtension(unittest::packed_enum_extension_lite, unittest::FOREIGN_LITE_BAZ);
1406     unittest::TestPackedExtensionsLite* message) {
1407   message->SetExtension(unittest::packed_int32_extension_lite   , 1, 801);
1408   message->SetExtension(unittest::packed_int64_extension_lite   , 1, 802);
1409   message->SetExtension(unittest::packed_uint32_extension_lite  , 1, 803);
1410   message->SetExtension(unittest::packed_uint64_extension_lite  , 1, 804);
1411   message->SetExtension(unittest::packed_sint32_extension_lite  , 1, 805);
1412   message->SetExtension(unittest::packed_sint64_extension_lite  , 1, 806);
1413   message->SetExtension(unittest::packed_fixed32_extension_lite , 1, 807);
1414   message->SetExtension(unittest::packed_fixed64_extension_lite , 1, 808);
1415   message->SetExtension(unittest::packed_sfixed32_extension_lite, 1, 809);
1416   message->SetExtension(unittest::packed_sfixed64_extension_lite, 1, 810);
1417   message->SetExtension(unittest::packed_float_extension_lite   , 1, 811);
1418   message->SetExtension(unittest::packed_double_extension_lite  , 1, 812);
1419   message->SetExtension(unittest::packed_bool_extension_lite    , 1, true);
1420   message->SetExtension(unittest::packed_enum_extension_lite    , 1,
1427     const unittest::TestPackedExtensionsLite& message) {
1428   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite   ));
1429   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite   ));
1430   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite  ));
1431   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite  ));
1432   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite  ));
1433   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite  ));
1434   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
1435   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
1436   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
1437   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
1438   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite   ));
1439   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite  ));
1440   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite    ));
1441   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite    ));
1443   EXPECT_EQ(601  , message.GetExtension(unittest::packed_int32_extension_lite   , 0));
1444   EXPECT_EQ(602  , message.GetExtension(unittest::packed_int64_extension_lite   , 0));
1445   EXPECT_EQ(603  , message.GetExtension(unittest::packed_uint32_extension_lite  , 0));
1446   EXPECT_EQ(604  , message.GetExtension(unittest::packed_uint64_extension_lite  , 0));
1447   EXPECT_EQ(605  , message.GetExtension(unittest::packed_sint32_extension_lite  , 0));
1448   EXPECT_EQ(606  , message.GetExtension(unittest::packed_sint64_extension_lite  , 0));
1449   EXPECT_EQ(607  , message.GetExtension(unittest::packed_fixed32_extension_lite , 0));
1450   EXPECT_EQ(608  , message.GetExtension(unittest::packed_fixed64_extension_lite , 0));
1451   EXPECT_EQ(609  , message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));
1452   EXPECT_EQ(610  , message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));
1453   EXPECT_EQ(611  , message.GetExtension(unittest::packed_float_extension_lite   , 0));
1454   EXPECT_EQ(612  , message.GetExtension(unittest::packed_double_extension_lite  , 0));
1455   EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite    , 0));
1457             message.GetExtension(unittest::packed_enum_extension_lite, 0));
1458   EXPECT_EQ(701  , message.GetExtension(unittest::packed_int32_extension_lite   , 1));
1459   EXPECT_EQ(702  , message.GetExtension(unittest::packed_int64_extension_lite   , 1));
1460   EXPECT_EQ(703  , message.GetExtension(unittest::packed_uint32_extension_lite  , 1));
1461   EXPECT_EQ(704  , message.GetExtension(unittest::packed_uint64_extension_lite  , 1));
1462   EXPECT_EQ(705  , message.GetExtension(unittest::packed_sint32_extension_lite  , 1));
1463   EXPECT_EQ(706  , message.GetExtension(unittest::packed_sint64_extension_lite  , 1));
1464   EXPECT_EQ(707  , message.GetExtension(unittest::packed_fixed32_extension_lite , 1));
1465   EXPECT_EQ(708  , message.GetExtension(unittest::packed_fixed64_extension_lite , 1));
1466   EXPECT_EQ(709  , message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));
1467   EXPECT_EQ(710  , message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));
1468   EXPECT_EQ(711  , message.GetExtension(unittest::packed_float_extension_lite   , 1));
1469   EXPECT_EQ(712  , message.GetExtension(unittest::packed_double_extension_lite  , 1));
1470   EXPECT_EQ(false, message.GetExtension(unittest::packed_bool_extension_lite    , 1));
1472             message.GetExtension(unittest::packed_enum_extension_lite, 1));
1478     const unittest::TestPackedExtensionsLite& message) {
1479   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int32_extension_lite   ));
1480   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int64_extension_lite   ));
1481   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint32_extension_lite  ));
1482   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint64_extension_lite  ));
1483   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint32_extension_lite  ));
1484   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint64_extension_lite  ));
1485   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
1486   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
1487   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
1488   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
1489   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_float_extension_lite   ));
1490   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_double_extension_lite  ));
1491   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_bool_extension_lite    ));
1492   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_enum_extension_lite    ));
1498     const unittest::TestPackedExtensionsLite& message) {
1499   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite   ));
1500   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite   ));
1501   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite  ));
1502   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite  ));
1503   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite  ));
1504   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite  ));
1505   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
1506   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
1507   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
1508   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
1509   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite   ));
1510   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite  ));
1511   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite    ));
1512   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite    ));
1513   EXPECT_EQ(601  , message.GetExtension(unittest::packed_int32_extension_lite   , 0));
1514   EXPECT_EQ(602  , message.GetExtension(unittest::packed_int64_extension_lite   , 0));
1515   EXPECT_EQ(603  , message.GetExtension(unittest::packed_uint32_extension_lite  , 0));
1516   EXPECT_EQ(604  , message.GetExtension(unittest::packed_uint64_extension_lite  , 0));
1517   EXPECT_EQ(605  , message.GetExtension(unittest::packed_sint32_extension_lite  , 0));
1518   EXPECT_EQ(606  , message.GetExtension(unittest::packed_sint64_extension_lite  , 0));
1519   EXPECT_EQ(607  , message.GetExtension(unittest::packed_fixed32_extension_lite , 0));
1520   EXPECT_EQ(608  , message.GetExtension(unittest::packed_fixed64_extension_lite , 0));
1521   EXPECT_EQ(609  , message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));
1522   EXPECT_EQ(610  , message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));
1523   EXPECT_EQ(611  , message.GetExtension(unittest::packed_float_extension_lite   , 0));
1524   EXPECT_EQ(612  , message.GetExtension(unittest::packed_double_extension_lite  , 0));
1525   EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite    , 0));
1527             message.GetExtension(unittest::packed_enum_extension_lite, 0));
1530   EXPECT_EQ(801  , message.GetExtension(unittest::packed_int32_extension_lite   , 1));
1531   EXPECT_EQ(802  , message.GetExtension(unittest::packed_int64_extension_lite   , 1));
1532   EXPECT_EQ(803  , message.GetExtension(unittest::packed_uint32_extension_lite  , 1));
1533   EXPECT_EQ(804  , message.GetExtension(unittest::packed_uint64_extension_lite  , 1));
1534   EXPECT_EQ(805  , message.GetExtension(unittest::packed_sint32_extension_lite  , 1));
1535   EXPECT_EQ(806  , message.GetExtension(unittest::packed_sint64_extension_lite  , 1));
1536   EXPECT_EQ(807  , message.GetExtension(unittest::packed_fixed32_extension_lite , 1));
1537   EXPECT_EQ(808  , message.GetExtension(unittest::packed_fixed64_extension_lite , 1));
1538   EXPECT_EQ(809  , message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));
1539   EXPECT_EQ(810  , message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));
1540   EXPECT_EQ(811  , message.GetExtension(unittest::packed_float_extension_lite   , 1));
1541   EXPECT_EQ(812  , message.GetExtension(unittest::packed_double_extension_lite  , 1));
1542   EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite    , 1));
1544             message.GetExtension(unittest::packed_enum_extension_lite, 1));

Indexes created Fri Mar 13 02:32:08 CET 2015