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);
70   message->set_optional_nested_enum (unittest::TestAllTypesLite::BAZ );
71   message->set_optional_foreign_enum(unittest::FOREIGN_LITE_BAZ      );
72   message->set_optional_import_enum (unittest_import::IMPORT_LITE_BAZ);
77   message->add_repeated_int32   (201);
78   message->add_repeated_int64   (202);
79   message->add_repeated_uint32  (203);
80   message->add_repeated_uint64  (204);
81   message->add_repeated_sint32  (205);
82   message->add_repeated_sint64  (206);
83   message->add_repeated_fixed32 (207);
84   message->add_repeated_fixed64 (208);
85   message->add_repeated_sfixed32(209);
86   message->add_repeated_sfixed64(210);
87   message->add_repeated_float   (211);
88   message->add_repeated_double  (212);
89   message->add_repeated_bool    (true);
90   message->add_repeated_string  ("215");
91   message->add_repeated_bytes   ("216");
93   message->add_repeatedgroup           ()->set_a(217);
94   message->add_repeated_nested_message ()->set_bb(218);
95   message->add_repeated_foreign_message()->set_c(219);
96   message->add_repeated_import_message ()->set_d(220);
98   message->add_repeated_nested_enum (unittest::TestAllTypesLite::BAR );
99   message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAR      );
100   message->add_repeated_import_enum (unittest_import::IMPORT_LITE_BAR);
104   message->add_repeated_int32   (301);
105   message->add_repeated_int64   (302);
106   message->add_repeated_uint32  (303);
107   message->add_repeated_uint64  (304);
108   message->add_repeated_sint32  (305);
109   message->add_repeated_sint64  (306);
110   message->add_repeated_fixed32 (307);
111   message->add_repeated_fixed64 (308);
112   message->add_repeated_sfixed32(309);
113   message->add_repeated_sfixed64(310);
114   message->add_repeated_float   (311);
115   message->add_repeated_double  (312);
116   message->add_repeated_bool    (false);
117   message->add_repeated_string  ("315");
118   message->add_repeated_bytes   ("316");
120   message->add_repeatedgroup           ()->set_a(317);
121   message->add_repeated_nested_message ()->set_bb(318);
122   message->add_repeated_foreign_message()->set_c(319);
123   message->add_repeated_import_message ()->set_d(320);
125   message->add_repeated_nested_enum (unittest::TestAllTypesLite::BAZ );
126   message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAZ      );
127   message->add_repeated_import_enum (unittest_import::IMPORT_LITE_BAZ);
132   message->set_default_int32   (401);
133   message->set_default_int64   (402);
134   message->set_default_uint32  (403);
135   message->set_default_uint64  (404);
136   message->set_default_sint32  (405);
137   message->set_default_sint64  (406);
138   message->set_default_fixed32 (407);
139   message->set_default_fixed64 (408);
140   message->set_default_sfixed32(409);
141   message->set_default_sfixed64(410);
142   message->set_default_float   (411);
143   message->set_default_double  (412);
144   message->set_default_bool    (false);
145   message->set_default_string  ("415");
146   message->set_default_bytes   ("416");
148   message->set_default_nested_enum (unittest::TestAllTypesLite::FOO );
149   message->set_default_foreign_enum(unittest::FOREIGN_LITE_FOO      );
150   message->set_default_import_enum (unittest_import::IMPORT_LITE_FOO);
156 void TestUtilLite::ModifyRepeatedFields(unittest::TestAllTypesLite* message) {
157   message->set_repeated_int32   (1, 501);
158   message->set_repeated_int64   (1, 502);
159   message->set_repeated_uint32  (1, 503);
160   message->set_repeated_uint64  (1, 504);
161   message->set_repeated_sint32  (1, 505);
162   message->set_repeated_sint64  (1, 506);
163   message->set_repeated_fixed32 (1, 507);
164   message->set_repeated_fixed64 (1, 508);
165   message->set_repeated_sfixed32(1, 509);
166   message->set_repeated_sfixed64(1, 510);
167   message->set_repeated_float   (1, 511);
168   message->set_repeated_double  (1, 512);
169   message->set_repeated_bool    (1, true);
170   message->set_repeated_string  (1, "515");
171   message->set_repeated_bytes   (1, "516");
173   message->mutable_repeatedgroup           (1)->set_a(517);
174   message->mutable_repeated_nested_message (1)->set_bb(518);
175   message->mutable_repeated_foreign_message(1)->set_c(519);
176   message->mutable_repeated_import_message (1)->set_d(520);
178   message->set_repeated_nested_enum (1, unittest::TestAllTypesLite::FOO );
179   message->set_repeated_foreign_enum(1, unittest::FOREIGN_LITE_FOO      );
180   message->set_repeated_import_enum (1, unittest_import::IMPORT_LITE_FOO);
187     const unittest::TestAllTypesLite& message) {
188   EXPECT_TRUE(message.has_optional_int32   ());
189   EXPECT_TRUE(message.has_optional_int64   ());
190   EXPECT_TRUE(message.has_optional_uint32  ());
191   EXPECT_TRUE(message.has_optional_uint64  ());
192   EXPECT_TRUE(message.has_optional_sint32  ());
193   EXPECT_TRUE(message.has_optional_sint64  ());
194   EXPECT_TRUE(message.has_optional_fixed32 ());
195   EXPECT_TRUE(message.has_optional_fixed64 ());
196   EXPECT_TRUE(message.has_optional_sfixed32());
197   EXPECT_TRUE(message.has_optional_sfixed64());
198   EXPECT_TRUE(message.has_optional_float   ());
199   EXPECT_TRUE(message.has_optional_double  ());
200   EXPECT_TRUE(message.has_optional_bool    ());
201   EXPECT_TRUE(message.has_optional_string  ());
202   EXPECT_TRUE(message.has_optional_bytes   ());
204   EXPECT_TRUE(message.has_optionalgroup           ());
205   EXPECT_TRUE(message.has_optional_nested_message ());
206   EXPECT_TRUE(message.has_optional_foreign_message());
207   EXPECT_TRUE(message.has_optional_import_message ());
209   EXPECT_TRUE(message.optionalgroup           ().has_a());
210   EXPECT_TRUE(message.optional_nested_message ().has_bb());
211   EXPECT_TRUE(message.optional_foreign_message().has_c());
212   EXPECT_TRUE(message.optional_import_message ().has_d());
214   EXPECT_TRUE(message.has_optional_nested_enum ());
215   EXPECT_TRUE(message.has_optional_foreign_enum());
216   EXPECT_TRUE(message.has_optional_import_enum ());
219   EXPECT_EQ(101  , message.optional_int32   ());
220   EXPECT_EQ(102  , message.optional_int64   ());
221   EXPECT_EQ(103  , message.optional_uint32  ());
222   EXPECT_EQ(104  , message.optional_uint64  ());
223   EXPECT_EQ(105  , message.optional_sint32  ());
224   EXPECT_EQ(106  , message.optional_sint64  ());
225   EXPECT_EQ(107  , message.optional_fixed32 ());
226   EXPECT_EQ(108  , message.optional_fixed64 ());
227   EXPECT_EQ(109  , message.optional_sfixed32());
228   EXPECT_EQ(110  , message.optional_sfixed64());
229   EXPECT_EQ(111  , message.optional_float   ());
230   EXPECT_EQ(112  , message.optional_double  ());
231   EXPECT_EQ(true , message.optional_bool    ());
232   EXPECT_EQ("115", message.optional_string  ());
233   EXPECT_EQ("116", message.optional_bytes   ());
235   EXPECT_EQ(117, message.optionalgroup           ().a());
236   EXPECT_EQ(118, message.optional_nested_message ().bb());
237   EXPECT_EQ(119, message.optional_foreign_message().c());
238   EXPECT_EQ(120, message.optional_import_message ().d());
240   EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.optional_nested_enum ());
241   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ      , message.optional_foreign_enum());
242   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.optional_import_enum ());
247   ASSERT_EQ(2, message.repeated_int32_size   ());
248   ASSERT_EQ(2, message.repeated_int64_size   ());
249   ASSERT_EQ(2, message.repeated_uint32_size  ());
250   ASSERT_EQ(2, message.repeated_uint64_size  ());
251   ASSERT_EQ(2, message.repeated_sint32_size  ());
252   ASSERT_EQ(2, message.repeated_sint64_size  ());
253   ASSERT_EQ(2, message.repeated_fixed32_size ());
254   ASSERT_EQ(2, message.repeated_fixed64_size ());
255   ASSERT_EQ(2, message.repeated_sfixed32_size());
256   ASSERT_EQ(2, message.repeated_sfixed64_size());
257   ASSERT_EQ(2, message.repeated_float_size   ());
258   ASSERT_EQ(2, message.repeated_double_size  ());
259   ASSERT_EQ(2, message.repeated_bool_size    ());
260   ASSERT_EQ(2, message.repeated_string_size  ());
261   ASSERT_EQ(2, message.repeated_bytes_size   ());
263   ASSERT_EQ(2, message.repeatedgroup_size           ());
264   ASSERT_EQ(2, message.repeated_nested_message_size ());
265   ASSERT_EQ(2, message.repeated_foreign_message_size());
266   ASSERT_EQ(2, message.repeated_import_message_size ());
267   ASSERT_EQ(2, message.repeated_nested_enum_size    ());
268   ASSERT_EQ(2, message.repeated_foreign_enum_size   ());
269   ASSERT_EQ(2, message.repeated_import_enum_size    ());
272   EXPECT_EQ(201  , message.repeated_int32   (0));
273   EXPECT_EQ(202  , message.repeated_int64   (0));
274   EXPECT_EQ(203  , message.repeated_uint32  (0));
275   EXPECT_EQ(204  , message.repeated_uint64  (0));
276   EXPECT_EQ(205  , message.repeated_sint32  (0));
277   EXPECT_EQ(206  , message.repeated_sint64  (0));
278   EXPECT_EQ(207  , message.repeated_fixed32 (0));
279   EXPECT_EQ(208  , message.repeated_fixed64 (0));
280   EXPECT_EQ(209  , message.repeated_sfixed32(0));
281   EXPECT_EQ(210  , message.repeated_sfixed64(0));
282   EXPECT_EQ(211  , message.repeated_float   (0));
283   EXPECT_EQ(212  , message.repeated_double  (0));
284   EXPECT_EQ(true , message.repeated_bool    (0));
285   EXPECT_EQ("215", message.repeated_string  (0));
286   EXPECT_EQ("216", message.repeated_bytes   (0));
288   EXPECT_EQ(217, message.repeatedgroup           (0).a());
289   EXPECT_EQ(218, message.repeated_nested_message (0).bb());
290   EXPECT_EQ(219, message.repeated_foreign_message(0).c());
291   EXPECT_EQ(220, message.repeated_import_message (0).d());
294   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.repeated_nested_enum (0));
295   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.repeated_foreign_enum(0));
296   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum (0));
298   EXPECT_EQ(301  , message.repeated_int32   (1));
299   EXPECT_EQ(302  , message.repeated_int64   (1));
300   EXPECT_EQ(303  , message.repeated_uint32  (1));
301   EXPECT_EQ(304  , message.repeated_uint64  (1));
302   EXPECT_EQ(305  , message.repeated_sint32  (1));
303   EXPECT_EQ(306  , message.repeated_sint64  (1));
304   EXPECT_EQ(307  , message.repeated_fixed32 (1));
305   EXPECT_EQ(308  , message.repeated_fixed64 (1));
306   EXPECT_EQ(309  , message.repeated_sfixed32(1));
307   EXPECT_EQ(310  , message.repeated_sfixed64(1));
308   EXPECT_EQ(311  , message.repeated_float   (1));
309   EXPECT_EQ(312  , message.repeated_double  (1));
310   EXPECT_EQ(false, message.repeated_bool    (1));
311   EXPECT_EQ("315", message.repeated_string  (1));
312   EXPECT_EQ("316", message.repeated_bytes   (1));
314   EXPECT_EQ(317, message.repeatedgroup           (1).a());
315   EXPECT_EQ(318, message.repeated_nested_message (1).bb());
316   EXPECT_EQ(319, message.repeated_foreign_message(1).c());
317   EXPECT_EQ(320, message.repeated_import_message (1).d());
319   EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.repeated_nested_enum (1));
320   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ      , message.repeated_foreign_enum(1));
321   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.repeated_import_enum (1));
326   EXPECT_TRUE(message.has_default_int32   ());
327   EXPECT_TRUE(message.has_default_int64   ());
328   EXPECT_TRUE(message.has_default_uint32  ());
329   EXPECT_TRUE(message.has_default_uint64  ());
330   EXPECT_TRUE(message.has_default_sint32  ());
331   EXPECT_TRUE(message.has_default_sint64  ());
332   EXPECT_TRUE(message.has_default_fixed32 ());
333   EXPECT_TRUE(message.has_default_fixed64 ());
334   EXPECT_TRUE(message.has_default_sfixed32());
335   EXPECT_TRUE(message.has_default_sfixed64());
336   EXPECT_TRUE(message.has_default_float   ());
337   EXPECT_TRUE(message.has_default_double  ());
338   EXPECT_TRUE(message.has_default_bool    ());
339   EXPECT_TRUE(message.has_default_string  ());
340   EXPECT_TRUE(message.has_default_bytes   ());
342   EXPECT_TRUE(message.has_default_nested_enum ());
343   EXPECT_TRUE(message.has_default_foreign_enum());
344   EXPECT_TRUE(message.has_default_import_enum ());
347   EXPECT_EQ(401  , message.default_int32   ());
348   EXPECT_EQ(402  , message.default_int64   ());
349   EXPECT_EQ(403  , message.default_uint32  ());
350   EXPECT_EQ(404  , message.default_uint64  ());
351   EXPECT_EQ(405  , message.default_sint32  ());
352   EXPECT_EQ(406  , message.default_sint64  ());
353   EXPECT_EQ(407  , message.default_fixed32 ());
354   EXPECT_EQ(408  , message.default_fixed64 ());
355   EXPECT_EQ(409  , message.default_sfixed32());
356   EXPECT_EQ(410  , message.default_sfixed64());
357   EXPECT_EQ(411  , message.default_float   ());
358   EXPECT_EQ(412  , message.default_double  ());
359   EXPECT_EQ(false, message.default_bool    ());
360   EXPECT_EQ("415", message.default_string  ());
361   EXPECT_EQ("416", message.default_bytes   ());
363   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.default_nested_enum ());
364   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.default_foreign_enum());
365   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.default_import_enum ());
371 void TestUtilLite::ExpectClear(const unittest::TestAllTypesLite& message) {
373   EXPECT_FALSE(message.has_optional_int32   ());
374   EXPECT_FALSE(message.has_optional_int64   ());
375   EXPECT_FALSE(message.has_optional_uint32  ());
376   EXPECT_FALSE(message.has_optional_uint64  ());
377   EXPECT_FALSE(message.has_optional_sint32  ());
378   EXPECT_FALSE(message.has_optional_sint64  ());
379   EXPECT_FALSE(message.has_optional_fixed32 ());
380   EXPECT_FALSE(message.has_optional_fixed64 ());
381   EXPECT_FALSE(message.has_optional_sfixed32());
382   EXPECT_FALSE(message.has_optional_sfixed64());
383   EXPECT_FALSE(message.has_optional_float   ());
384   EXPECT_FALSE(message.has_optional_double  ());
385   EXPECT_FALSE(message.has_optional_bool    ());
386   EXPECT_FALSE(message.has_optional_string  ());
387   EXPECT_FALSE(message.has_optional_bytes   ());
389   EXPECT_FALSE(message.has_optionalgroup           ());
390   EXPECT_FALSE(message.has_optional_nested_message ());
391   EXPECT_FALSE(message.has_optional_foreign_message());
392   EXPECT_FALSE(message.has_optional_import_message ());
394   EXPECT_FALSE(message.has_optional_nested_enum ());
395   EXPECT_FALSE(message.has_optional_foreign_enum());
396   EXPECT_FALSE(message.has_optional_import_enum ());
400   EXPECT_EQ(0    , message.optional_int32   ());
401   EXPECT_EQ(0    , message.optional_int64   ());
402   EXPECT_EQ(0    , message.optional_uint32  ());
403   EXPECT_EQ(0    , message.optional_uint64  ());
404   EXPECT_EQ(0    , message.optional_sint32  ());
405   EXPECT_EQ(0    , message.optional_sint64  ());
406   EXPECT_EQ(0    , message.optional_fixed32 ());
407   EXPECT_EQ(0    , message.optional_fixed64 ());
408   EXPECT_EQ(0    , message.optional_sfixed32());
409   EXPECT_EQ(0    , message.optional_sfixed64());
410   EXPECT_EQ(0    , message.optional_float   ());
411   EXPECT_EQ(0    , message.optional_double  ());
412   EXPECT_EQ(false, message.optional_bool    ());
413   EXPECT_EQ(""   , message.optional_string  ());
414   EXPECT_EQ(""   , message.optional_bytes   ());
417   EXPECT_FALSE(message.optionalgroup           ().has_a());
418   EXPECT_FALSE(message.optional_nested_message ().has_bb());
419   EXPECT_FALSE(message.optional_foreign_message().has_c());
420   EXPECT_FALSE(message.optional_import_message ().has_d());
422   EXPECT_EQ(0, message.optionalgroup           ().a());
423   EXPECT_EQ(0, message.optional_nested_message ().bb());
424   EXPECT_EQ(0, message.optional_foreign_message().c());
425   EXPECT_EQ(0, message.optional_import_message ().d());
428   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.optional_nested_enum ());
429   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.optional_foreign_enum());
430   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.optional_import_enum ());
434   EXPECT_EQ(0, message.repeated_int32_size   ());
435   EXPECT_EQ(0, message.repeated_int64_size   ());
436   EXPECT_EQ(0, message.repeated_uint32_size  ());
437   EXPECT_EQ(0, message.repeated_uint64_size  ());
438   EXPECT_EQ(0, message.repeated_sint32_size  ());
439   EXPECT_EQ(0, message.repeated_sint64_size  ());
440   EXPECT_EQ(0, message.repeated_fixed32_size ());
441   EXPECT_EQ(0, message.repeated_fixed64_size ());
442   EXPECT_EQ(0, message.repeated_sfixed32_size());
443   EXPECT_EQ(0, message.repeated_sfixed64_size());
444   EXPECT_EQ(0, message.repeated_float_size   ());
445   EXPECT_EQ(0, message.repeated_double_size  ());
446   EXPECT_EQ(0, message.repeated_bool_size    ());
447   EXPECT_EQ(0, message.repeated_string_size  ());
448   EXPECT_EQ(0, message.repeated_bytes_size   ());
450   EXPECT_EQ(0, message.repeatedgroup_size           ());
451   EXPECT_EQ(0, message.repeated_nested_message_size ());
452   EXPECT_EQ(0, message.repeated_foreign_message_size());
453   EXPECT_EQ(0, message.repeated_import_message_size ());
454   EXPECT_EQ(0, message.repeated_nested_enum_size    ());
455   EXPECT_EQ(0, message.repeated_foreign_enum_size   ());
456   EXPECT_EQ(0, message.repeated_import_enum_size    ());
460   EXPECT_FALSE(message.has_default_int32   ());
461   EXPECT_FALSE(message.has_default_int64   ());
462   EXPECT_FALSE(message.has_default_uint32  ());
463   EXPECT_FALSE(message.has_default_uint64  ());
464   EXPECT_FALSE(message.has_default_sint32  ());
465   EXPECT_FALSE(message.has_default_sint64  ());
466   EXPECT_FALSE(message.has_default_fixed32 ());
467   EXPECT_FALSE(message.has_default_fixed64 ());
468   EXPECT_FALSE(message.has_default_sfixed32());
469   EXPECT_FALSE(message.has_default_sfixed64());
470   EXPECT_FALSE(message.has_default_float   ());
471   EXPECT_FALSE(message.has_default_double  ());
472   EXPECT_FALSE(message.has_default_bool    ());
473   EXPECT_FALSE(message.has_default_string  ());
474   EXPECT_FALSE(message.has_default_bytes   ());
476   EXPECT_FALSE(message.has_default_nested_enum ());
477   EXPECT_FALSE(message.has_default_foreign_enum());
478   EXPECT_FALSE(message.has_default_import_enum ());
482   EXPECT_EQ( 41    , message.default_int32   ());
483   EXPECT_EQ( 42    , message.default_int64   ());
484   EXPECT_EQ( 43    , message.default_uint32  ());
485   EXPECT_EQ( 44    , message.default_uint64  ());
486   EXPECT_EQ(-45    , message.default_sint32  ());
487   EXPECT_EQ( 46    , message.default_sint64  ());
488   EXPECT_EQ( 47    , message.default_fixed32 ());
489   EXPECT_EQ( 48    , message.default_fixed64 ());
490   EXPECT_EQ( 49    , message.default_sfixed32());
491   EXPECT_EQ(-50    , message.default_sfixed64());
492   EXPECT_EQ( 51.5  , message.default_float   ());
493   EXPECT_EQ( 52e3  , message.default_double  ());
494   EXPECT_EQ(true   , message.default_bool    ());
495   EXPECT_EQ("hello", message.default_string  ());
496   EXPECT_EQ("world", message.default_bytes   ());
498   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.default_nested_enum ());
499   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.default_foreign_enum());
500   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.default_import_enum ());
507     const unittest::TestAllTypesLite& message) {
511   ASSERT_EQ(2, message.repeated_int32_size   ());
512   ASSERT_EQ(2, message.repeated_int64_size   ());
513   ASSERT_EQ(2, message.repeated_uint32_size  ());
514   ASSERT_EQ(2, message.repeated_uint64_size  ());
515   ASSERT_EQ(2, message.repeated_sint32_size  ());
516   ASSERT_EQ(2, message.repeated_sint64_size  ());
517   ASSERT_EQ(2, message.repeated_fixed32_size ());
518   ASSERT_EQ(2, message.repeated_fixed64_size ());
519   ASSERT_EQ(2, message.repeated_sfixed32_size());
520   ASSERT_EQ(2, message.repeated_sfixed64_size());
521   ASSERT_EQ(2, message.repeated_float_size   ());
522   ASSERT_EQ(2, message.repeated_double_size  ());
523   ASSERT_EQ(2, message.repeated_bool_size    ());
524   ASSERT_EQ(2, message.repeated_string_size  ());
525   ASSERT_EQ(2, message.repeated_bytes_size   ());
527   ASSERT_EQ(2, message.repeatedgroup_size           ());
528   ASSERT_EQ(2, message.repeated_nested_message_size ());
529   ASSERT_EQ(2, message.repeated_foreign_message_size());
530   ASSERT_EQ(2, message.repeated_import_message_size ());
531   ASSERT_EQ(2, message.repeated_nested_enum_size    ());
532   ASSERT_EQ(2, message.repeated_foreign_enum_size   ());
533   ASSERT_EQ(2, message.repeated_import_enum_size    ());
536   EXPECT_EQ(201  , message.repeated_int32   (0));
537   EXPECT_EQ(202  , message.repeated_int64   (0));
538   EXPECT_EQ(203  , message.repeated_uint32  (0));
539   EXPECT_EQ(204  , message.repeated_uint64  (0));
540   EXPECT_EQ(205  , message.repeated_sint32  (0));
541   EXPECT_EQ(206  , message.repeated_sint64  (0));
542   EXPECT_EQ(207  , message.repeated_fixed32 (0));
543   EXPECT_EQ(208  , message.repeated_fixed64 (0));
544   EXPECT_EQ(209  , message.repeated_sfixed32(0));
545   EXPECT_EQ(210  , message.repeated_sfixed64(0));
546   EXPECT_EQ(211  , message.repeated_float   (0));
547   EXPECT_EQ(212  , message.repeated_double  (0));
548   EXPECT_EQ(true , message.repeated_bool    (0));
549   EXPECT_EQ("215", message.repeated_string  (0));
550   EXPECT_EQ("216", message.repeated_bytes   (0));
552   EXPECT_EQ(217, message.repeatedgroup           (0).a());
553   EXPECT_EQ(218, message.repeated_nested_message (0).bb());
554   EXPECT_EQ(219, message.repeated_foreign_message(0).c());
555   EXPECT_EQ(220, message.repeated_import_message (0).d());
557   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.repeated_nested_enum (0));
558   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.repeated_foreign_enum(0));
559   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum (0));
563   EXPECT_EQ(501  , message.repeated_int32   (1));
564   EXPECT_EQ(502  , message.repeated_int64   (1));
565   EXPECT_EQ(503  , message.repeated_uint32  (1));
566   EXPECT_EQ(504  , message.repeated_uint64  (1));
567   EXPECT_EQ(505  , message.repeated_sint32  (1));
568   EXPECT_EQ(506  , message.repeated_sint64  (1));
569   EXPECT_EQ(507  , message.repeated_fixed32 (1));
570   EXPECT_EQ(508  , message.repeated_fixed64 (1));
571   EXPECT_EQ(509  , message.repeated_sfixed32(1));
572   EXPECT_EQ(510  , message.repeated_sfixed64(1));
573   EXPECT_EQ(511  , message.repeated_float   (1));
574   EXPECT_EQ(512  , message.repeated_double  (1));
575   EXPECT_EQ(true , message.repeated_bool    (1));
576   EXPECT_EQ("515", message.repeated_string  (1));
577   EXPECT_EQ("516", message.repeated_bytes   (1));
579   EXPECT_EQ(517, message.repeatedgroup           (1).a());
580   EXPECT_EQ(518, message.repeated_nested_message (1).bb());
581   EXPECT_EQ(519, message.repeated_foreign_message(1).c());
582   EXPECT_EQ(520, message.repeated_import_message (1).d());
584   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.repeated_nested_enum (1));
585   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.repeated_foreign_enum(1));
586   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.repeated_import_enum (1));
592 void TestUtilLite::SetPackedFields(unittest::TestPackedTypesLite* message) {
593   message->add_packed_int32   (601);
594   message->add_packed_int64   (602);
595   message->add_packed_uint32  (603);
596   message->add_packed_uint64  (604);
597   message->add_packed_sint32  (605);
598   message->add_packed_sint64  (606);
599   message->add_packed_fixed32 (607);
600   message->add_packed_fixed64 (608);
601   message->add_packed_sfixed32(609);
602   message->add_packed_sfixed64(610);
603   message->add_packed_float   (611);
604   message->add_packed_double  (612);
605   message->add_packed_bool    (true);
606   message->add_packed_enum    (unittest::FOREIGN_LITE_BAR);
608   message->add_packed_int32   (701);
609   message->add_packed_int64   (702);
610   message->add_packed_uint32  (703);
611   message->add_packed_uint64  (704);
612   message->add_packed_sint32  (705);
613   message->add_packed_sint64  (706);
614   message->add_packed_fixed32 (707);
615   message->add_packed_fixed64 (708);
616   message->add_packed_sfixed32(709);
617   message->add_packed_sfixed64(710);
618   message->add_packed_float   (711);
619   message->add_packed_double  (712);
620   message->add_packed_bool    (false);
621   message->add_packed_enum    (unittest::FOREIGN_LITE_BAZ);
626 void TestUtilLite::ModifyPackedFields(unittest::TestPackedTypesLite* message) {
627   message->set_packed_int32   (1, 801);
628   message->set_packed_int64   (1, 802);
629   message->set_packed_uint32  (1, 803);
630   message->set_packed_uint64  (1, 804);
631   message->set_packed_sint32  (1, 805);
632   message->set_packed_sint64  (1, 806);
633   message->set_packed_fixed32 (1, 807);
634   message->set_packed_fixed64 (1, 808);
635   message->set_packed_sfixed32(1, 809);
636   message->set_packed_sfixed64(1, 810);
637   message->set_packed_float   (1, 811);
638   message->set_packed_double  (1, 812);
639   message->set_packed_bool    (1, true);
640   message->set_packed_enum    (1, unittest::FOREIGN_LITE_FOO);
646     const unittest::TestPackedTypesLite& message) {
647   ASSERT_EQ(2, message.packed_int32_size   ());
648   ASSERT_EQ(2, message.packed_int64_size   ());
649   ASSERT_EQ(2, message.packed_uint32_size  ());
650   ASSERT_EQ(2, message.packed_uint64_size  ());
651   ASSERT_EQ(2, message.packed_sint32_size  ());
652   ASSERT_EQ(2, message.packed_sint64_size  ());
653   ASSERT_EQ(2, message.packed_fixed32_size ());
654   ASSERT_EQ(2, message.packed_fixed64_size ());
655   ASSERT_EQ(2, message.packed_sfixed32_size());
656   ASSERT_EQ(2, message.packed_sfixed64_size());
657   ASSERT_EQ(2, message.packed_float_size   ());
658   ASSERT_EQ(2, message.packed_double_size  ());
659   ASSERT_EQ(2, message.packed_bool_size    ());
660   ASSERT_EQ(2, message.packed_enum_size    ());
662   EXPECT_EQ(601  , message.packed_int32   (0));
663   EXPECT_EQ(602  , message.packed_int64   (0));
664   EXPECT_EQ(603  , message.packed_uint32  (0));
665   EXPECT_EQ(604  , message.packed_uint64  (0));
666   EXPECT_EQ(605  , message.packed_sint32  (0));
667   EXPECT_EQ(606  , message.packed_sint64  (0));
668   EXPECT_EQ(607  , message.packed_fixed32 (0));
669   EXPECT_EQ(608  , message.packed_fixed64 (0));
670   EXPECT_EQ(609  , message.packed_sfixed32(0));
671   EXPECT_EQ(610  , message.packed_sfixed64(0));
672   EXPECT_EQ(611  , message.packed_float   (0));
673   EXPECT_EQ(612  , message.packed_double  (0));
674   EXPECT_EQ(true , message.packed_bool    (0));
675   EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0));
677   EXPECT_EQ(701  , message.packed_int32   (1));
678   EXPECT_EQ(702  , message.packed_int64   (1));
679   EXPECT_EQ(703  , message.packed_uint32  (1));
680   EXPECT_EQ(704  , message.packed_uint64  (1));
681   EXPECT_EQ(705  , message.packed_sint32  (1));
682   EXPECT_EQ(706  , message.packed_sint64  (1));
683   EXPECT_EQ(707  , message.packed_fixed32 (1));
684   EXPECT_EQ(708  , message.packed_fixed64 (1));
685   EXPECT_EQ(709  , message.packed_sfixed32(1));
686   EXPECT_EQ(710  , message.packed_sfixed64(1));
687   EXPECT_EQ(711  , message.packed_float   (1));
688   EXPECT_EQ(712  , message.packed_double  (1));
689   EXPECT_EQ(false, message.packed_bool    (1));
690   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ, message.packed_enum(1));
696     const unittest::TestPackedTypesLite& message) {
698   EXPECT_EQ(0, message.packed_int32_size   ());
699   EXPECT_EQ(0, message.packed_int64_size   ());
700   EXPECT_EQ(0, message.packed_uint32_size  ());
701   EXPECT_EQ(0, message.packed_uint64_size  ());
702   EXPECT_EQ(0, message.packed_sint32_size  ());
703   EXPECT_EQ(0, message.packed_sint64_size  ());
704   EXPECT_EQ(0, message.packed_fixed32_size ());
705   EXPECT_EQ(0, message.packed_fixed64_size ());
706   EXPECT_EQ(0, message.packed_sfixed32_size());
707   EXPECT_EQ(0, message.packed_sfixed64_size());
708   EXPECT_EQ(0, message.packed_float_size   ());
709   EXPECT_EQ(0, message.packed_double_size  ());
710   EXPECT_EQ(0, message.packed_bool_size    ());
711   EXPECT_EQ(0, message.packed_enum_size    ());
717     const unittest::TestPackedTypesLite& message) {
719   ASSERT_EQ(2, message.packed_int32_size   ());
720   ASSERT_EQ(2, message.packed_int64_size   ());
721   ASSERT_EQ(2, message.packed_uint32_size  ());
722   ASSERT_EQ(2, message.packed_uint64_size  ());
723   ASSERT_EQ(2, message.packed_sint32_size  ());
724   ASSERT_EQ(2, message.packed_sint64_size  ());
725   ASSERT_EQ(2, message.packed_fixed32_size ());
726   ASSERT_EQ(2, message.packed_fixed64_size ());
727   ASSERT_EQ(2, message.packed_sfixed32_size());
728   ASSERT_EQ(2, message.packed_sfixed64_size());
729   ASSERT_EQ(2, message.packed_float_size   ());
730   ASSERT_EQ(2, message.packed_double_size  ());
731   ASSERT_EQ(2, message.packed_bool_size    ());
732   ASSERT_EQ(2, message.packed_enum_size    ());
734   EXPECT_EQ(601  , message.packed_int32   (0));
735   EXPECT_EQ(602  , message.packed_int64   (0));
736   EXPECT_EQ(603  , message.packed_uint32  (0));
737   EXPECT_EQ(604  , message.packed_uint64  (0));
738   EXPECT_EQ(605  , message.packed_sint32  (0));
739   EXPECT_EQ(606  , message.packed_sint64  (0));
740   EXPECT_EQ(607  , message.packed_fixed32 (0));
741   EXPECT_EQ(608  , message.packed_fixed64 (0));
742   EXPECT_EQ(609  , message.packed_sfixed32(0));
743   EXPECT_EQ(610  , message.packed_sfixed64(0));
744   EXPECT_EQ(611  , message.packed_float   (0));
745   EXPECT_EQ(612  , message.packed_double  (0));
746   EXPECT_EQ(true , message.packed_bool    (0));
747   EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0));
749   EXPECT_EQ(801  , message.packed_int32   (1));
750   EXPECT_EQ(802  , message.packed_int64   (1));
751   EXPECT_EQ(803  , message.packed_uint32  (1));
752   EXPECT_EQ(804  , message.packed_uint64  (1));
753   EXPECT_EQ(805  , message.packed_sint32  (1));
754   EXPECT_EQ(806  , message.packed_sint64  (1));
755   EXPECT_EQ(807  , message.packed_fixed32 (1));
756   EXPECT_EQ(808  , message.packed_fixed64 (1));
757   EXPECT_EQ(809  , message.packed_sfixed32(1));
758   EXPECT_EQ(810  , message.packed_sfixed64(1));
759   EXPECT_EQ(811  , message.packed_float   (1));
760   EXPECT_EQ(812  , message.packed_double  (1));
761   EXPECT_EQ(true , message.packed_bool    (1));
762   EXPECT_EQ(unittest::FOREIGN_LITE_FOO, message.packed_enum(1));
773 void TestUtilLite::SetAllExtensions(unittest::TestAllExtensionsLite* message) {
774   message->SetExtension(unittest::optional_int32_extension_lite   , 101);
775   message->SetExtension(unittest::optional_int64_extension_lite   , 102);
776   message->SetExtension(unittest::optional_uint32_extension_lite  , 103);
777   message->SetExtension(unittest::optional_uint64_extension_lite  , 104);
778   message->SetExtension(unittest::optional_sint32_extension_lite  , 105);
779   message->SetExtension(unittest::optional_sint64_extension_lite  , 106);
780   message->SetExtension(unittest::optional_fixed32_extension_lite , 107);
781   message->SetExtension(unittest::optional_fixed64_extension_lite , 108);
782   message->SetExtension(unittest::optional_sfixed32_extension_lite, 109);
783   message->SetExtension(unittest::optional_sfixed64_extension_lite, 110);
784   message->SetExtension(unittest::optional_float_extension_lite   , 111);
785   message->SetExtension(unittest::optional_double_extension_lite  , 112);
786   message->SetExtension(unittest::optional_bool_extension_lite    , true);
787   message->SetExtension(unittest::optional_string_extension_lite  , "115");
788   message->SetExtension(unittest::optional_bytes_extension_lite   , "116");
790   message->MutableExtension(unittest::optionalgroup_extension_lite           )->set_a(117);
791   message->MutableExtension(unittest::optional_nested_message_extension_lite )->set_bb(118);
792   message->MutableExtension(unittest::optional_foreign_message_extension_lite)->set_c(119);
793   message->MutableExtension(unittest::optional_import_message_extension_lite )->set_d(120);
795   message->SetExtension(unittest::optional_nested_enum_extension_lite , unittest::TestAllTypesLite::BAZ );
796   message->SetExtension(unittest::optional_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAZ      );
797   message->SetExtension(unittest::optional_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAZ);
802   message->AddExtension(unittest::repeated_int32_extension_lite   , 201);
803   message->AddExtension(unittest::repeated_int64_extension_lite   , 202);
804   message->AddExtension(unittest::repeated_uint32_extension_lite  , 203);
805   message->AddExtension(unittest::repeated_uint64_extension_lite  , 204);
806   message->AddExtension(unittest::repeated_sint32_extension_lite  , 205);
807   message->AddExtension(unittest::repeated_sint64_extension_lite  , 206);
808   message->AddExtension(unittest::repeated_fixed32_extension_lite , 207);
809   message->AddExtension(unittest::repeated_fixed64_extension_lite , 208);
810   message->AddExtension(unittest::repeated_sfixed32_extension_lite, 209);
811   message->AddExtension(unittest::repeated_sfixed64_extension_lite, 210);
812   message->AddExtension(unittest::repeated_float_extension_lite   , 211);
813   message->AddExtension(unittest::repeated_double_extension_lite  , 212);
814   message->AddExtension(unittest::repeated_bool_extension_lite    , true);
815   message->AddExtension(unittest::repeated_string_extension_lite  , "215");
816   message->AddExtension(unittest::repeated_bytes_extension_lite   , "216");
818   message->AddExtension(unittest::repeatedgroup_extension_lite           )->set_a(217);
819   message->AddExtension(unittest::repeated_nested_message_extension_lite )->set_bb(218);
820   message->AddExtension(unittest::repeated_foreign_message_extension_lite)->set_c(219);
821   message->AddExtension(unittest::repeated_import_message_extension_lite )->set_d(220);
823   message->AddExtension(unittest::repeated_nested_enum_extension_lite , unittest::TestAllTypesLite::BAR );
824   message->AddExtension(unittest::repeated_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAR      );
825   message->AddExtension(unittest::repeated_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAR);
829   message->AddExtension(unittest::repeated_int32_extension_lite   , 301);
830   message->AddExtension(unittest::repeated_int64_extension_lite   , 302);
831   message->AddExtension(unittest::repeated_uint32_extension_lite  , 303);
832   message->AddExtension(unittest::repeated_uint64_extension_lite  , 304);
833   message->AddExtension(unittest::repeated_sint32_extension_lite  , 305);
834   message->AddExtension(unittest::repeated_sint64_extension_lite  , 306);
835   message->AddExtension(unittest::repeated_fixed32_extension_lite , 307);
836   message->AddExtension(unittest::repeated_fixed64_extension_lite , 308);
837   message->AddExtension(unittest::repeated_sfixed32_extension_lite, 309);
838   message->AddExtension(unittest::repeated_sfixed64_extension_lite, 310);
839   message->AddExtension(unittest::repeated_float_extension_lite   , 311);
840   message->AddExtension(unittest::repeated_double_extension_lite  , 312);
841   message->AddExtension(unittest::repeated_bool_extension_lite    , false);
842   message->AddExtension(unittest::repeated_string_extension_lite  , "315");
843   message->AddExtension(unittest::repeated_bytes_extension_lite   , "316");
845   message->AddExtension(unittest::repeatedgroup_extension_lite           )->set_a(317);
846   message->AddExtension(unittest::repeated_nested_message_extension_lite )->set_bb(318);
847   message->AddExtension(unittest::repeated_foreign_message_extension_lite)->set_c(319);
848   message->AddExtension(unittest::repeated_import_message_extension_lite )->set_d(320);
850   message->AddExtension(unittest::repeated_nested_enum_extension_lite , unittest::TestAllTypesLite::BAZ );
851   message->AddExtension(unittest::repeated_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAZ      );
852   message->AddExtension(unittest::repeated_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAZ);
857   message->SetExtension(unittest::default_int32_extension_lite   , 401);
858   message->SetExtension(unittest::default_int64_extension_lite   , 402);
859   message->SetExtension(unittest::default_uint32_extension_lite  , 403);
860   message->SetExtension(unittest::default_uint64_extension_lite  , 404);
861   message->SetExtension(unittest::default_sint32_extension_lite  , 405);
862   message->SetExtension(unittest::default_sint64_extension_lite  , 406);
863   message->SetExtension(unittest::default_fixed32_extension_lite , 407);
864   message->SetExtension(unittest::default_fixed64_extension_lite , 408);
865   message->SetExtension(unittest::default_sfixed32_extension_lite, 409);
866   message->SetExtension(unittest::default_sfixed64_extension_lite, 410);
867   message->SetExtension(unittest::default_float_extension_lite   , 411);
868   message->SetExtension(unittest::default_double_extension_lite  , 412);
869   message->SetExtension(unittest::default_bool_extension_lite    , false);
870   message->SetExtension(unittest::default_string_extension_lite  , "415");
871   message->SetExtension(unittest::default_bytes_extension_lite   , "416");
873   message->SetExtension(unittest::default_nested_enum_extension_lite , unittest::TestAllTypesLite::FOO );
874   message->SetExtension(unittest::default_foreign_enum_extension_lite, unittest::FOREIGN_LITE_FOO      );
875   message->SetExtension(unittest::default_import_enum_extension_lite , unittest_import::IMPORT_LITE_FOO);
882     unittest::TestAllExtensionsLite* message) {
883   message->SetExtension(unittest::repeated_int32_extension_lite   , 1, 501);
884   message->SetExtension(unittest::repeated_int64_extension_lite   , 1, 502);
885   message->SetExtension(unittest::repeated_uint32_extension_lite  , 1, 503);
886   message->SetExtension(unittest::repeated_uint64_extension_lite  , 1, 504);
887   message->SetExtension(unittest::repeated_sint32_extension_lite  , 1, 505);
888   message->SetExtension(unittest::repeated_sint64_extension_lite  , 1, 506);
889   message->SetExtension(unittest::repeated_fixed32_extension_lite , 1, 507);
890   message->SetExtension(unittest::repeated_fixed64_extension_lite , 1, 508);
891   message->SetExtension(unittest::repeated_sfixed32_extension_lite, 1, 509);
892   message->SetExtension(unittest::repeated_sfixed64_extension_lite, 1, 510);
893   message->SetExtension(unittest::repeated_float_extension_lite   , 1, 511);
894   message->SetExtension(unittest::repeated_double_extension_lite  , 1, 512);
895   message->SetExtension(unittest::repeated_bool_extension_lite    , 1, true);
896   message->SetExtension(unittest::repeated_string_extension_lite  , 1, "515");
897   message->SetExtension(unittest::repeated_bytes_extension_lite   , 1, "516");
899   message->MutableExtension(unittest::repeatedgroup_extension_lite           , 1)->set_a(517);
900   message->MutableExtension(unittest::repeated_nested_message_extension_lite , 1)->set_bb(518);
901   message->MutableExtension(unittest::repeated_foreign_message_extension_lite, 1)->set_c(519);
902   message->MutableExtension(unittest::repeated_import_message_extension_lite , 1)->set_d(520);
904   message->SetExtension(unittest::repeated_nested_enum_extension_lite , 1, unittest::TestAllTypesLite::FOO );
905   message->SetExtension(unittest::repeated_foreign_enum_extension_lite, 1, unittest::FOREIGN_LITE_FOO      );
906   message->SetExtension(unittest::repeated_import_enum_extension_lite , 1, unittest_import::IMPORT_LITE_FOO);
913     const unittest::TestAllExtensionsLite& message) {
914   EXPECT_TRUE(message.HasExtension(unittest::optional_int32_extension_lite   ));
915   EXPECT_TRUE(message.HasExtension(unittest::optional_int64_extension_lite   ));
916   EXPECT_TRUE(message.HasExtension(unittest::optional_uint32_extension_lite  ));
917   EXPECT_TRUE(message.HasExtension(unittest::optional_uint64_extension_lite  ));
918   EXPECT_TRUE(message.HasExtension(unittest::optional_sint32_extension_lite  ));
919   EXPECT_TRUE(message.HasExtension(unittest::optional_sint64_extension_lite  ));
920   EXPECT_TRUE(message.HasExtension(unittest::optional_fixed32_extension_lite ));
921   EXPECT_TRUE(message.HasExtension(unittest::optional_fixed64_extension_lite ));
922   EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed32_extension_lite));
923   EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed64_extension_lite));
924   EXPECT_TRUE(message.HasExtension(unittest::optional_float_extension_lite   ));
925   EXPECT_TRUE(message.HasExtension(unittest::optional_double_extension_lite  ));
926   EXPECT_TRUE(message.HasExtension(unittest::optional_bool_extension_lite    ));
927   EXPECT_TRUE(message.HasExtension(unittest::optional_string_extension_lite  ));
928   EXPECT_TRUE(message.HasExtension(unittest::optional_bytes_extension_lite   ));
930   EXPECT_TRUE(message.HasExtension(unittest::optionalgroup_extension_lite           ));
931   EXPECT_TRUE(message.HasExtension(unittest::optional_nested_message_extension_lite ));
932   EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_message_extension_lite));
933   EXPECT_TRUE(message.HasExtension(unittest::optional_import_message_extension_lite ));
935   EXPECT_TRUE(message.GetExtension(unittest::optionalgroup_extension_lite           ).has_a());
936   EXPECT_TRUE(message.GetExtension(unittest::optional_nested_message_extension_lite ).has_bb());
937   EXPECT_TRUE(message.GetExtension(unittest::optional_foreign_message_extension_lite).has_c());
938   EXPECT_TRUE(message.GetExtension(unittest::optional_import_message_extension_lite ).has_d());
940   EXPECT_TRUE(message.HasExtension(unittest::optional_nested_enum_extension_lite ));
941   EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_enum_extension_lite));
942   EXPECT_TRUE(message.HasExtension(unittest::optional_import_enum_extension_lite ));
945   EXPECT_EQ(101  , message.GetExtension(unittest::optional_int32_extension_lite   ));
946   EXPECT_EQ(102  , message.GetExtension(unittest::optional_int64_extension_lite   ));
947   EXPECT_EQ(103  , message.GetExtension(unittest::optional_uint32_extension_lite  ));
948   EXPECT_EQ(104  , message.GetExtension(unittest::optional_uint64_extension_lite  ));
949   EXPECT_EQ(105  , message.GetExtension(unittest::optional_sint32_extension_lite  ));
950   EXPECT_EQ(106  , message.GetExtension(unittest::optional_sint64_extension_lite  ));
951   EXPECT_EQ(107  , message.GetExtension(unittest::optional_fixed32_extension_lite ));
952   EXPECT_EQ(108  , message.GetExtension(unittest::optional_fixed64_extension_lite ));
953   EXPECT_EQ(109  , message.GetExtension(unittest::optional_sfixed32_extension_lite));
954   EXPECT_EQ(110  , message.GetExtension(unittest::optional_sfixed64_extension_lite));
955   EXPECT_EQ(111  , message.GetExtension(unittest::optional_float_extension_lite   ));
956   EXPECT_EQ(112  , message.GetExtension(unittest::optional_double_extension_lite  ));
957   EXPECT_EQ(true , message.GetExtension(unittest::optional_bool_extension_lite    ));
958   EXPECT_EQ("115", message.GetExtension(unittest::optional_string_extension_lite  ));
959   EXPECT_EQ("116", message.GetExtension(unittest::optional_bytes_extension_lite   ));
961   EXPECT_EQ(117, message.GetExtension(unittest::optionalgroup_extension_lite           ).a());
962   EXPECT_EQ(118, message.GetExtension(unittest::optional_nested_message_extension_lite ).bb());
963   EXPECT_EQ(119, message.GetExtension(unittest::optional_foreign_message_extension_lite).c());
964   EXPECT_EQ(120, message.GetExtension(unittest::optional_import_message_extension_lite ).d());
966   EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.GetExtension(unittest::optional_nested_enum_extension_lite ));
967   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ      , message.GetExtension(unittest::optional_foreign_enum_extension_lite));
968   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.GetExtension(unittest::optional_import_enum_extension_lite ));
973   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite   ));
974   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite   ));
975   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite  ));
976   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite  ));
977   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite  ));
978   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite  ));
979   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
980   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
981   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
982   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
983   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite   ));
984   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite  ));
985   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite    ));
986   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite  ));
987   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite   ));
989   ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite           ));
990   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
991   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
992   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
993   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite    ));
994   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite   ));
995   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite    ));
998   EXPECT_EQ(201  , message.GetExtension(unittest::repeated_int32_extension_lite   , 0));
999   EXPECT_EQ(202  , message.GetExtension(unittest::repeated_int64_extension_lite   , 0));
1000   EXPECT_EQ(203  , message.GetExtension(unittest::repeated_uint32_extension_lite  , 0));
1001   EXPECT_EQ(204  , message.GetExtension(unittest::repeated_uint64_extension_lite  , 0));
1002   EXPECT_EQ(205  , message.GetExtension(unittest::repeated_sint32_extension_lite  , 0));
1003   EXPECT_EQ(206  , message.GetExtension(unittest::repeated_sint64_extension_lite  , 0));
1004   EXPECT_EQ(207  , message.GetExtension(unittest::repeated_fixed32_extension_lite , 0));
1005   EXPECT_EQ(208  , message.GetExtension(unittest::repeated_fixed64_extension_lite , 0));
1006   EXPECT_EQ(209  , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));
1007   EXPECT_EQ(210  , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));
1008   EXPECT_EQ(211  , message.GetExtension(unittest::repeated_float_extension_lite   , 0));
1009   EXPECT_EQ(212  , message.GetExtension(unittest::repeated_double_extension_lite  , 0));
1010   EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite    , 0));
1011   EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension_lite  , 0));
1012   EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension_lite   , 0));
1014   EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension_lite           , 0).a());
1015   EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension_lite , 0).bb());
1016   EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0).c());
1017   EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension_lite , 0).d());
1019   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 0));
1020   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));
1021   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::repeated_import_enum_extension_lite , 0));
1024   EXPECT_EQ(301  , message.GetExtension(unittest::repeated_int32_extension_lite   , 1));
1025   EXPECT_EQ(302  , message.GetExtension(unittest::repeated_int64_extension_lite   , 1));
1026   EXPECT_EQ(303  , message.GetExtension(unittest::repeated_uint32_extension_lite  , 1));
1027   EXPECT_EQ(304  , message.GetExtension(unittest::repeated_uint64_extension_lite  , 1));
1028   EXPECT_EQ(305  , message.GetExtension(unittest::repeated_sint32_extension_lite  , 1));
1029   EXPECT_EQ(306  , message.GetExtension(unittest::repeated_sint64_extension_lite  , 1));
1030   EXPECT_EQ(307  , message.GetExtension(unittest::repeated_fixed32_extension_lite , 1));
1031   EXPECT_EQ(308  , message.GetExtension(unittest::repeated_fixed64_extension_lite , 1));
1032   EXPECT_EQ(309  , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));
1033   EXPECT_EQ(310  , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));
1034   EXPECT_EQ(311  , message.GetExtension(unittest::repeated_float_extension_lite   , 1));
1035   EXPECT_EQ(312  , message.GetExtension(unittest::repeated_double_extension_lite  , 1));
1036   EXPECT_EQ(false, message.GetExtension(unittest::repeated_bool_extension_lite    , 1));
1037   EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension_lite  , 1));
1038   EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension_lite   , 1));
1040   EXPECT_EQ(317, message.GetExtension(unittest::repeatedgroup_extension_lite           , 1).a());
1041   EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension_lite , 1).bb());
1042   EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1).c());
1043   EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension_lite , 1).d());
1045   EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 1));
1046   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ      , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));
1047   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.GetExtension(unittest::repeated_import_enum_extension_lite , 1));
1052   EXPECT_TRUE(message.HasExtension(unittest::default_int32_extension_lite   ));
1053   EXPECT_TRUE(message.HasExtension(unittest::default_int64_extension_lite   ));
1054   EXPECT_TRUE(message.HasExtension(unittest::default_uint32_extension_lite  ));
1055   EXPECT_TRUE(message.HasExtension(unittest::default_uint64_extension_lite  ));
1056   EXPECT_TRUE(message.HasExtension(unittest::default_sint32_extension_lite  ));
1057   EXPECT_TRUE(message.HasExtension(unittest::default_sint64_extension_lite  ));
1058   EXPECT_TRUE(message.HasExtension(unittest::default_fixed32_extension_lite ));
1059   EXPECT_TRUE(message.HasExtension(unittest::default_fixed64_extension_lite ));
1060   EXPECT_TRUE(message.HasExtension(unittest::default_sfixed32_extension_lite));
1061   EXPECT_TRUE(message.HasExtension(unittest::default_sfixed64_extension_lite));
1062   EXPECT_TRUE(message.HasExtension(unittest::default_float_extension_lite   ));
1063   EXPECT_TRUE(message.HasExtension(unittest::default_double_extension_lite  ));
1064   EXPECT_TRUE(message.HasExtension(unittest::default_bool_extension_lite    ));
1065   EXPECT_TRUE(message.HasExtension(unittest::default_string_extension_lite  ));
1066   EXPECT_TRUE(message.HasExtension(unittest::default_bytes_extension_lite   ));
1068   EXPECT_TRUE(message.HasExtension(unittest::default_nested_enum_extension_lite ));
1069   EXPECT_TRUE(message.HasExtension(unittest::default_foreign_enum_extension_lite));
1070   EXPECT_TRUE(message.HasExtension(unittest::default_import_enum_extension_lite ));
1073   EXPECT_EQ(401  , message.GetExtension(unittest::default_int32_extension_lite   ));
1074   EXPECT_EQ(402  , message.GetExtension(unittest::default_int64_extension_lite   ));
1075   EXPECT_EQ(403  , message.GetExtension(unittest::default_uint32_extension_lite  ));
1076   EXPECT_EQ(404  , message.GetExtension(unittest::default_uint64_extension_lite  ));
1077   EXPECT_EQ(405  , message.GetExtension(unittest::default_sint32_extension_lite  ));
1078   EXPECT_EQ(406  , message.GetExtension(unittest::default_sint64_extension_lite  ));
1079   EXPECT_EQ(407  , message.GetExtension(unittest::default_fixed32_extension_lite ));
1080   EXPECT_EQ(408  , message.GetExtension(unittest::default_fixed64_extension_lite ));
1081   EXPECT_EQ(409  , message.GetExtension(unittest::default_sfixed32_extension_lite));
1082   EXPECT_EQ(410  , message.GetExtension(unittest::default_sfixed64_extension_lite));
1083   EXPECT_EQ(411  , message.GetExtension(unittest::default_float_extension_lite   ));
1084   EXPECT_EQ(412  , message.GetExtension(unittest::default_double_extension_lite  ));
1085   EXPECT_EQ(false, message.GetExtension(unittest::default_bool_extension_lite    ));
1086   EXPECT_EQ("415", message.GetExtension(unittest::default_string_extension_lite  ));
1087   EXPECT_EQ("416", message.GetExtension(unittest::default_bytes_extension_lite   ));
1089   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::default_nested_enum_extension_lite ));
1090   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.GetExtension(unittest::default_foreign_enum_extension_lite));
1091   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::default_import_enum_extension_lite ));
1098     const unittest::TestAllExtensionsLite& message) {
1100   ASSERT_TRUE(message.SerializeToString(&serialized));
1102   EXPECT_EQ(0, message.ByteSize());
1105   EXPECT_FALSE(message.HasExtension(unittest::optional_int32_extension_lite   ));
1106   EXPECT_FALSE(message.HasExtension(unittest::optional_int64_extension_lite   ));
1107   EXPECT_FALSE(message.HasExtension(unittest::optional_uint32_extension_lite  ));
1108   EXPECT_FALSE(message.HasExtension(unittest::optional_uint64_extension_lite  ));
1109   EXPECT_FALSE(message.HasExtension(unittest::optional_sint32_extension_lite  ));
1110   EXPECT_FALSE(message.HasExtension(unittest::optional_sint64_extension_lite  ));
1111   EXPECT_FALSE(message.HasExtension(unittest::optional_fixed32_extension_lite ));
1112   EXPECT_FALSE(message.HasExtension(unittest::optional_fixed64_extension_lite ));
1113   EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed32_extension_lite));
1114   EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed64_extension_lite));
1115   EXPECT_FALSE(message.HasExtension(unittest::optional_float_extension_lite   ));
1116   EXPECT_FALSE(message.HasExtension(unittest::optional_double_extension_lite  ));
1117   EXPECT_FALSE(message.HasExtension(unittest::optional_bool_extension_lite    ));
1118   EXPECT_FALSE(message.HasExtension(unittest::optional_string_extension_lite  ));
1119   EXPECT_FALSE(message.HasExtension(unittest::optional_bytes_extension_lite   ));
1121   EXPECT_FALSE(message.HasExtension(unittest::optionalgroup_extension_lite           ));
1122   EXPECT_FALSE(message.HasExtension(unittest::optional_nested_message_extension_lite ));
1123   EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_message_extension_lite));
1124   EXPECT_FALSE(message.HasExtension(unittest::optional_import_message_extension_lite ));
1126   EXPECT_FALSE(message.HasExtension(unittest::optional_nested_enum_extension_lite ));
1127   EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_enum_extension_lite));
1128   EXPECT_FALSE(message.HasExtension(unittest::optional_import_enum_extension_lite ));
1132   EXPECT_EQ(0    , message.GetExtension(unittest::optional_int32_extension_lite   ));
1133   EXPECT_EQ(0    , message.GetExtension(unittest::optional_int64_extension_lite   ));
1134   EXPECT_EQ(0    , message.GetExtension(unittest::optional_uint32_extension_lite  ));
1135   EXPECT_EQ(0    , message.GetExtension(unittest::optional_uint64_extension_lite  ));
1136   EXPECT_EQ(0    , message.GetExtension(unittest::optional_sint32_extension_lite  ));
1137   EXPECT_EQ(0    , message.GetExtension(unittest::optional_sint64_extension_lite  ));
1138   EXPECT_EQ(0    , message.GetExtension(unittest::optional_fixed32_extension_lite ));
1139   EXPECT_EQ(0    , message.GetExtension(unittest::optional_fixed64_extension_lite ));
1140   EXPECT_EQ(0    , message.GetExtension(unittest::optional_sfixed32_extension_lite));
1141   EXPECT_EQ(0    , message.GetExtension(unittest::optional_sfixed64_extension_lite));
1142   EXPECT_EQ(0    , message.GetExtension(unittest::optional_float_extension_lite   ));
1143   EXPECT_EQ(0    , message.GetExtension(unittest::optional_double_extension_lite  ));
1144   EXPECT_EQ(false, message.GetExtension(unittest::optional_bool_extension_lite    ));
1145   EXPECT_EQ(""   , message.GetExtension(unittest::optional_string_extension_lite  ));
1146   EXPECT_EQ(""   , message.GetExtension(unittest::optional_bytes_extension_lite   ));
1149   EXPECT_FALSE(message.GetExtension(unittest::optionalgroup_extension_lite           ).has_a());
1150   EXPECT_FALSE(message.GetExtension(unittest::optional_nested_message_extension_lite ).has_bb());
1151   EXPECT_FALSE(message.GetExtension(unittest::optional_foreign_message_extension_lite).has_c());
1152   EXPECT_FALSE(message.GetExtension(unittest::optional_import_message_extension_lite ).has_d());
1154   EXPECT_EQ(0, message.GetExtension(unittest::optionalgroup_extension_lite           ).a());
1155   EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension_lite ).bb());
1156   EXPECT_EQ(0, message.GetExtension(unittest::optional_foreign_message_extension_lite).c());
1157   EXPECT_EQ(0, message.GetExtension(unittest::optional_import_message_extension_lite ).d());
1160   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::optional_nested_enum_extension_lite ));
1161   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.GetExtension(unittest::optional_foreign_enum_extension_lite));
1162   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::optional_import_enum_extension_lite ));
1166   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int32_extension_lite   ));
1167   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int64_extension_lite   ));
1168   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint32_extension_lite  ));
1169   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint64_extension_lite  ));
1170   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint32_extension_lite  ));
1171   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint64_extension_lite  ));
1172   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
1173   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
1174   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
1175   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
1176   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_float_extension_lite   ));
1177   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_double_extension_lite  ));
1178   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bool_extension_lite    ));
1179   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_extension_lite  ));
1180   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bytes_extension_lite   ));
1182   EXPECT_EQ(0, message.ExtensionSize(unittest::repeatedgroup_extension_lite           ));
1183   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
1184   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
1185   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
1186   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite    ));
1187   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite   ));
1188   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_enum_extension_lite    ));
1192   EXPECT_FALSE(message.HasExtension(unittest::default_int32_extension_lite   ));
1193   EXPECT_FALSE(message.HasExtension(unittest::default_int64_extension_lite   ));
1194   EXPECT_FALSE(message.HasExtension(unittest::default_uint32_extension_lite  ));
1195   EXPECT_FALSE(message.HasExtension(unittest::default_uint64_extension_lite  ));
1196   EXPECT_FALSE(message.HasExtension(unittest::default_sint32_extension_lite  ));
1197   EXPECT_FALSE(message.HasExtension(unittest::default_sint64_extension_lite  ));
1198   EXPECT_FALSE(message.HasExtension(unittest::default_fixed32_extension_lite ));
1199   EXPECT_FALSE(message.HasExtension(unittest::default_fixed64_extension_lite ));
1200   EXPECT_FALSE(message.HasExtension(unittest::default_sfixed32_extension_lite));
1201   EXPECT_FALSE(message.HasExtension(unittest::default_sfixed64_extension_lite));
1202   EXPECT_FALSE(message.HasExtension(unittest::default_float_extension_lite   ));
1203   EXPECT_FALSE(message.HasExtension(unittest::default_double_extension_lite  ));
1204   EXPECT_FALSE(message.HasExtension(unittest::default_bool_extension_lite    ));
1205   EXPECT_FALSE(message.HasExtension(unittest::default_string_extension_lite  ));
1206   EXPECT_FALSE(message.HasExtension(unittest::default_bytes_extension_lite   ));
1208   EXPECT_FALSE(message.HasExtension(unittest::default_nested_enum_extension_lite ));
1209   EXPECT_FALSE(message.HasExtension(unittest::default_foreign_enum_extension_lite));
1210   EXPECT_FALSE(message.HasExtension(unittest::default_import_enum_extension_lite ));
1214   EXPECT_EQ( 41    , message.GetExtension(unittest::default_int32_extension_lite   ));
1215   EXPECT_EQ( 42    , message.GetExtension(unittest::default_int64_extension_lite   ));
1216   EXPECT_EQ( 43    , message.GetExtension(unittest::default_uint32_extension_lite  ));
1217   EXPECT_EQ( 44    , message.GetExtension(unittest::default_uint64_extension_lite  ));
1218   EXPECT_EQ(-45    , message.GetExtension(unittest::default_sint32_extension_lite  ));
1219   EXPECT_EQ( 46    , message.GetExtension(unittest::default_sint64_extension_lite  ));
1220   EXPECT_EQ( 47    , message.GetExtension(unittest::default_fixed32_extension_lite ));
1221   EXPECT_EQ( 48    , message.GetExtension(unittest::default_fixed64_extension_lite ));
1222   EXPECT_EQ( 49    , message.GetExtension(unittest::default_sfixed32_extension_lite));
1223   EXPECT_EQ(-50    , message.GetExtension(unittest::default_sfixed64_extension_lite));
1224   EXPECT_EQ( 51.5  , message.GetExtension(unittest::default_float_extension_lite   ));
1225   EXPECT_EQ( 52e3  , message.GetExtension(unittest::default_double_extension_lite  ));
1226   EXPECT_EQ(true   , message.GetExtension(unittest::default_bool_extension_lite    ));
1227   EXPECT_EQ("hello", message.GetExtension(unittest::default_string_extension_lite  ));
1228   EXPECT_EQ("world", message.GetExtension(unittest::default_bytes_extension_lite   ));
1230   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::default_nested_enum_extension_lite ));
1231   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.GetExtension(unittest::default_foreign_enum_extension_lite));
1232   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::default_import_enum_extension_lite ));
1239     const unittest::TestAllExtensionsLite& message) {
1243   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite   ));
1244   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite   ));
1245   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite  ));
1246   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite  ));
1247   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite  ));
1248   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite  ));
1249   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
1250   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
1251   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
1252   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
1253   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite   ));
1254   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite  ));
1255   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite    ));
1256   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite  ));
1257   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite   ));
1259   ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite           ));
1260   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
1261   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
1262   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
1263   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite    ));
1264   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite   ));
1265   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite    ));
1268   EXPECT_EQ(201  , message.GetExtension(unittest::repeated_int32_extension_lite   , 0));
1269   EXPECT_EQ(202  , message.GetExtension(unittest::repeated_int64_extension_lite   , 0));
1270   EXPECT_EQ(203  , message.GetExtension(unittest::repeated_uint32_extension_lite  , 0));
1271   EXPECT_EQ(204  , message.GetExtension(unittest::repeated_uint64_extension_lite  , 0));
1272   EXPECT_EQ(205  , message.GetExtension(unittest::repeated_sint32_extension_lite  , 0));
1273   EXPECT_EQ(206  , message.GetExtension(unittest::repeated_sint64_extension_lite  , 0));
1274   EXPECT_EQ(207  , message.GetExtension(unittest::repeated_fixed32_extension_lite , 0));
1275   EXPECT_EQ(208  , message.GetExtension(unittest::repeated_fixed64_extension_lite , 0));
1276   EXPECT_EQ(209  , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));
1277   EXPECT_EQ(210  , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));
1278   EXPECT_EQ(211  , message.GetExtension(unittest::repeated_float_extension_lite   , 0));
1279   EXPECT_EQ(212  , message.GetExtension(unittest::repeated_double_extension_lite  , 0));
1280   EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite    , 0));
1281   EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension_lite  , 0));
1282   EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension_lite   , 0));
1284   EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension_lite           , 0).a());
1285   EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension_lite , 0).bb());
1286   EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0).c());
1287   EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension_lite , 0).d());
1289   EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 0));
1290   EXPECT_EQ(unittest::FOREIGN_LITE_BAR      , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));
1291   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::repeated_import_enum_extension_lite , 0));
1295   EXPECT_EQ(501  , message.GetExtension(unittest::repeated_int32_extension_lite   , 1));
1296   EXPECT_EQ(502  , message.GetExtension(unittest::repeated_int64_extension_lite   , 1));
1297   EXPECT_EQ(503  , message.GetExtension(unittest::repeated_uint32_extension_lite  , 1));
1298   EXPECT_EQ(504  , message.GetExtension(unittest::repeated_uint64_extension_lite  , 1));
1299   EXPECT_EQ(505  , message.GetExtension(unittest::repeated_sint32_extension_lite  , 1));
1300   EXPECT_EQ(506  , message.GetExtension(unittest::repeated_sint64_extension_lite  , 1));
1301   EXPECT_EQ(507  , message.GetExtension(unittest::repeated_fixed32_extension_lite , 1));
1302   EXPECT_EQ(508  , message.GetExtension(unittest::repeated_fixed64_extension_lite , 1));
1303   EXPECT_EQ(509  , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));
1304   EXPECT_EQ(510  , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));
1305   EXPECT_EQ(511  , message.GetExtension(unittest::repeated_float_extension_lite   , 1));
1306   EXPECT_EQ(512  , message.GetExtension(unittest::repeated_double_extension_lite  , 1));
1307   EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite    , 1));
1308   EXPECT_EQ("515", message.GetExtension(unittest::repeated_string_extension_lite  , 1));
1309   EXPECT_EQ("516", message.GetExtension(unittest::repeated_bytes_extension_lite   , 1));
1311   EXPECT_EQ(517, message.GetExtension(unittest::repeatedgroup_extension_lite           , 1).a());
1312   EXPECT_EQ(518, message.GetExtension(unittest::repeated_nested_message_extension_lite , 1).bb());
1313   EXPECT_EQ(519, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1).c());
1314   EXPECT_EQ(520, message.GetExtension(unittest::repeated_import_message_extension_lite , 1).d());
1316   EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 1));
1317   EXPECT_EQ(unittest::FOREIGN_LITE_FOO      , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));
1318   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::repeated_import_enum_extension_lite , 1));
1325     unittest::TestPackedExtensionsLite* message) {
1326   message->AddExtension(unittest::packed_int32_extension_lite   , 601);
1327   message->AddExtension(unittest::packed_int64_extension_lite   , 602);
1328   message->AddExtension(unittest::packed_uint32_extension_lite  , 603);
1329   message->AddExtension(unittest::packed_uint64_extension_lite  , 604);
1330   message->AddExtension(unittest::packed_sint32_extension_lite  , 605);
1331   message->AddExtension(unittest::packed_sint64_extension_lite  , 606);
1332   message->AddExtension(unittest::packed_fixed32_extension_lite , 607);
1333   message->AddExtension(unittest::packed_fixed64_extension_lite , 608);
1334   message->AddExtension(unittest::packed_sfixed32_extension_lite, 609);
1335   message->AddExtension(unittest::packed_sfixed64_extension_lite, 610);
1336   message->AddExtension(unittest::packed_float_extension_lite   , 611);
1337   message->AddExtension(unittest::packed_double_extension_lite  , 612);
1338   message->AddExtension(unittest::packed_bool_extension_lite    , true);
1339   message->AddExtension(unittest::packed_enum_extension_lite, unittest::FOREIGN_LITE_BAR);
1341   message->AddExtension(unittest::packed_int32_extension_lite   , 701);
1342   message->AddExtension(unittest::packed_int64_extension_lite   , 702);
1343   message->AddExtension(unittest::packed_uint32_extension_lite  , 703);
1344   message->AddExtension(unittest::packed_uint64_extension_lite  , 704);
1345   message->AddExtension(unittest::packed_sint32_extension_lite  , 705);
1346   message->AddExtension(unittest::packed_sint64_extension_lite  , 706);
1347   message->AddExtension(unittest::packed_fixed32_extension_lite , 707);
1348   message->AddExtension(unittest::packed_fixed64_extension_lite , 708);
1349   message->AddExtension(unittest::packed_sfixed32_extension_lite, 709);
1350   message->AddExtension(unittest::packed_sfixed64_extension_lite, 710);
1351   message->AddExtension(unittest::packed_float_extension_lite   , 711);
1352   message->AddExtension(unittest::packed_double_extension_lite  , 712);
1353   message->AddExtension(unittest::packed_bool_extension_lite    , false);
1354   message->AddExtension(unittest::packed_enum_extension_lite, unittest::FOREIGN_LITE_BAZ);
1360     unittest::TestPackedExtensionsLite* message) {
1361   message->SetExtension(unittest::packed_int32_extension_lite   , 1, 801);
1362   message->SetExtension(unittest::packed_int64_extension_lite   , 1, 802);
1363   message->SetExtension(unittest::packed_uint32_extension_lite  , 1, 803);
1364   message->SetExtension(unittest::packed_uint64_extension_lite  , 1, 804);
1365   message->SetExtension(unittest::packed_sint32_extension_lite  , 1, 805);
1366   message->SetExtension(unittest::packed_sint64_extension_lite  , 1, 806);
1367   message->SetExtension(unittest::packed_fixed32_extension_lite , 1, 807);
1368   message->SetExtension(unittest::packed_fixed64_extension_lite , 1, 808);
1369   message->SetExtension(unittest::packed_sfixed32_extension_lite, 1, 809);
1370   message->SetExtension(unittest::packed_sfixed64_extension_lite, 1, 810);
1371   message->SetExtension(unittest::packed_float_extension_lite   , 1, 811);
1372   message->SetExtension(unittest::packed_double_extension_lite  , 1, 812);
1373   message->SetExtension(unittest::packed_bool_extension_lite    , 1, true);
1374   message->SetExtension(unittest::packed_enum_extension_lite    , 1,
1381     const unittest::TestPackedExtensionsLite& message) {
1382   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite   ));
1383   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite   ));
1384   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite  ));
1385   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite  ));
1386   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite  ));
1387   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite  ));
1388   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
1389   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
1390   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
1391   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
1392   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite   ));
1393   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite  ));
1394   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite    ));
1395   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite    ));
1397   EXPECT_EQ(601  , message.GetExtension(unittest::packed_int32_extension_lite   , 0));
1398   EXPECT_EQ(602  , message.GetExtension(unittest::packed_int64_extension_lite   , 0));
1399   EXPECT_EQ(603  , message.GetExtension(unittest::packed_uint32_extension_lite  , 0));
1400   EXPECT_EQ(604  , message.GetExtension(unittest::packed_uint64_extension_lite  , 0));
1401   EXPECT_EQ(605  , message.GetExtension(unittest::packed_sint32_extension_lite  , 0));
1402   EXPECT_EQ(606  , message.GetExtension(unittest::packed_sint64_extension_lite  , 0));
1403   EXPECT_EQ(607  , message.GetExtension(unittest::packed_fixed32_extension_lite , 0));
1404   EXPECT_EQ(608  , message.GetExtension(unittest::packed_fixed64_extension_lite , 0));
1405   EXPECT_EQ(609  , message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));
1406   EXPECT_EQ(610  , message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));
1407   EXPECT_EQ(611  , message.GetExtension(unittest::packed_float_extension_lite   , 0));
1408   EXPECT_EQ(612  , message.GetExtension(unittest::packed_double_extension_lite  , 0));
1409   EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite    , 0));
1411             message.GetExtension(unittest::packed_enum_extension_lite, 0));
1412   EXPECT_EQ(701  , message.GetExtension(unittest::packed_int32_extension_lite   , 1));
1413   EXPECT_EQ(702  , message.GetExtension(unittest::packed_int64_extension_lite   , 1));
1414   EXPECT_EQ(703  , message.GetExtension(unittest::packed_uint32_extension_lite  , 1));
1415   EXPECT_EQ(704  , message.GetExtension(unittest::packed_uint64_extension_lite  , 1));
1416   EXPECT_EQ(705  , message.GetExtension(unittest::packed_sint32_extension_lite  , 1));
1417   EXPECT_EQ(706  , message.GetExtension(unittest::packed_sint64_extension_lite  , 1));
1418   EXPECT_EQ(707  , message.GetExtension(unittest::packed_fixed32_extension_lite , 1));
1419   EXPECT_EQ(708  , message.GetExtension(unittest::packed_fixed64_extension_lite , 1));
1420   EXPECT_EQ(709  , message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));
1421   EXPECT_EQ(710  , message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));
1422   EXPECT_EQ(711  , message.GetExtension(unittest::packed_float_extension_lite   , 1));
1423   EXPECT_EQ(712  , message.GetExtension(unittest::packed_double_extension_lite  , 1));
1424   EXPECT_EQ(false, message.GetExtension(unittest::packed_bool_extension_lite    , 1));
1426             message.GetExtension(unittest::packed_enum_extension_lite, 1));
1432     const unittest::TestPackedExtensionsLite& message) {
1433   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int32_extension_lite   ));
1434   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int64_extension_lite   ));
1435   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint32_extension_lite  ));
1436   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint64_extension_lite  ));
1437   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint32_extension_lite  ));
1438   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint64_extension_lite  ));
1439   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
1440   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
1441   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
1442   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
1443   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_float_extension_lite   ));
1444   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_double_extension_lite  ));
1445   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_bool_extension_lite    ));
1446   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_enum_extension_lite    ));
1452     const unittest::TestPackedExtensionsLite& message) {
1453   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite   ));
1454   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite   ));
1455   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite  ));
1456   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite  ));
1457   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite  ));
1458   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite  ));
1459   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
1460   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
1461   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
1462   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
1463   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite   ));
1464   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite  ));
1465   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite    ));
1466   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite    ));
1467   EXPECT_EQ(601  , message.GetExtension(unittest::packed_int32_extension_lite   , 0));
1468   EXPECT_EQ(602  , message.GetExtension(unittest::packed_int64_extension_lite   , 0));
1469   EXPECT_EQ(603  , message.GetExtension(unittest::packed_uint32_extension_lite  , 0));
1470   EXPECT_EQ(604  , message.GetExtension(unittest::packed_uint64_extension_lite  , 0));
1471   EXPECT_EQ(605  , message.GetExtension(unittest::packed_sint32_extension_lite  , 0));
1472   EXPECT_EQ(606  , message.GetExtension(unittest::packed_sint64_extension_lite  , 0));
1473   EXPECT_EQ(607  , message.GetExtension(unittest::packed_fixed32_extension_lite , 0));
1474   EXPECT_EQ(608  , message.GetExtension(unittest::packed_fixed64_extension_lite , 0));
1475   EXPECT_EQ(609  , message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));
1476   EXPECT_EQ(610  , message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));
1477   EXPECT_EQ(611  , message.GetExtension(unittest::packed_float_extension_lite   , 0));
1478   EXPECT_EQ(612  , message.GetExtension(unittest::packed_double_extension_lite  , 0));
1479   EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite    , 0));
1481             message.GetExtension(unittest::packed_enum_extension_lite, 0));
1484   EXPECT_EQ(801  , message.GetExtension(unittest::packed_int32_extension_lite   , 1));
1485   EXPECT_EQ(802  , message.GetExtension(unittest::packed_int64_extension_lite   , 1));
1486   EXPECT_EQ(803  , message.GetExtension(unittest::packed_uint32_extension_lite  , 1));
1487   EXPECT_EQ(804  , message.GetExtension(unittest::packed_uint64_extension_lite  , 1));
1488   EXPECT_EQ(805  , message.GetExtension(unittest::packed_sint32_extension_lite  , 1));
1489   EXPECT_EQ(806  , message.GetExtension(unittest::packed_sint64_extension_lite  , 1));
1490   EXPECT_EQ(807  , message.GetExtension(unittest::packed_fixed32_extension_lite , 1));
1491   EXPECT_EQ(808  , message.GetExtension(unittest::packed_fixed64_extension_lite , 1));
1492   EXPECT_EQ(809  , message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));
1493   EXPECT_EQ(810  , message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));
1494   EXPECT_EQ(811  , message.GetExtension(unittest::packed_float_extension_lite   , 1));
1495   EXPECT_EQ(812  , message.GetExtension(unittest::packed_double_extension_lite  , 1));
1496   EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite    , 1));
1498             message.GetExtension(unittest::packed_enum_extension_lite, 1));

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