Lines Matching refs:message
49 void TestUtilLite::SetAllFields(unittest::TestAllTypesLite* message) {
50 message->set_optional_int32 (101);
51 message->set_optional_int64 (102);
52 message->set_optional_uint32 (103);
53 message->set_optional_uint64 (104);
54 message->set_optional_sint32 (105);
55 message->set_optional_sint64 (106);
56 message->set_optional_fixed32 (107);
57 message->set_optional_fixed64 (108);
58 message->set_optional_sfixed32(109);
59 message->set_optional_sfixed64(110);
60 message->set_optional_float (111);
61 message->set_optional_double (112);
62 message->set_optional_bool (true);
63 message->set_optional_string ("115");
64 message->set_optional_bytes ("116");
66 message->mutable_optionalgroup ()->set_a(117);
67 message->mutable_optional_nested_message ()->set_bb(118);
68 message->mutable_optional_foreign_message ()->set_c(119);
69 message->mutable_optional_import_message ()->set_d(120);
70 message->mutable_optional_public_import_message()->set_e(126);
71 message->mutable_optional_lazy_message ()->set_bb(127);
73 message->set_optional_nested_enum (unittest::TestAllTypesLite::BAZ );
74 message->set_optional_foreign_enum(unittest::FOREIGN_LITE_BAZ );
75 message->set_optional_import_enum (unittest_import::IMPORT_LITE_BAZ);
80 message->add_repeated_int32 (201);
81 message->add_repeated_int64 (202);
82 message->add_repeated_uint32 (203);
83 message->add_repeated_uint64 (204);
84 message->add_repeated_sint32 (205);
85 message->add_repeated_sint64 (206);
86 message->add_repeated_fixed32 (207);
87 message->add_repeated_fixed64 (208);
88 message->add_repeated_sfixed32(209);
89 message->add_repeated_sfixed64(210);
90 message->add_repeated_float (211);
91 message->add_repeated_double (212);
92 message->add_repeated_bool (true);
93 message->add_repeated_string ("215");
94 message->add_repeated_bytes ("216");
96 message->add_repeatedgroup ()->set_a(217);
97 message->add_repeated_nested_message ()->set_bb(218);
98 message->add_repeated_foreign_message()->set_c(219);
99 message->add_repeated_import_message ()->set_d(220);
100 message->add_repeated_lazy_message ()->set_bb(227);
102 message->add_repeated_nested_enum (unittest::TestAllTypesLite::BAR );
103 message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAR );
104 message->add_repeated_import_enum (unittest_import::IMPORT_LITE_BAR);
108 message->add_repeated_int32 (301);
109 message->add_repeated_int64 (302);
110 message->add_repeated_uint32 (303);
111 message->add_repeated_uint64 (304);
112 message->add_repeated_sint32 (305);
113 message->add_repeated_sint64 (306);
114 message->add_repeated_fixed32 (307);
115 message->add_repeated_fixed64 (308);
116 message->add_repeated_sfixed32(309);
117 message->add_repeated_sfixed64(310);
118 message->add_repeated_float (311);
119 message->add_repeated_double (312);
120 message->add_repeated_bool (false);
121 message->add_repeated_string ("315");
122 message->add_repeated_bytes ("316");
124 message->add_repeatedgroup ()->set_a(317);
125 message->add_repeated_nested_message ()->set_bb(318);
126 message->add_repeated_foreign_message()->set_c(319);
127 message->add_repeated_import_message ()->set_d(320);
128 message->add_repeated_lazy_message ()->set_bb(327);
130 message->add_repeated_nested_enum (unittest::TestAllTypesLite::BAZ );
131 message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAZ );
132 message->add_repeated_import_enum (unittest_import::IMPORT_LITE_BAZ);
137 message->set_default_int32 (401);
138 message->set_default_int64 (402);
139 message->set_default_uint32 (403);
140 message->set_default_uint64 (404);
141 message->set_default_sint32 (405);
142 message->set_default_sint64 (406);
143 message->set_default_fixed32 (407);
144 message->set_default_fixed64 (408);
145 message->set_default_sfixed32(409);
146 message->set_default_sfixed64(410);
147 message->set_default_float (411);
148 message->set_default_double (412);
149 message->set_default_bool (false);
150 message->set_default_string ("415");
151 message->set_default_bytes ("416");
153 message->set_default_nested_enum (unittest::TestAllTypesLite::FOO );
154 message->set_default_foreign_enum(unittest::FOREIGN_LITE_FOO );
155 message->set_default_import_enum (unittest_import::IMPORT_LITE_FOO);
158 message->set_oneof_uint32(601);
159 message->mutable_oneof_nested_message()->set_bb(602);
160 message->set_oneof_string("603");
161 message->set_oneof_bytes("604");
166 void TestUtilLite::ModifyRepeatedFields(unittest::TestAllTypesLite* message) {
167 message->set_repeated_int32 (1, 501);
168 message->set_repeated_int64 (1, 502);
169 message->set_repeated_uint32 (1, 503);
170 message->set_repeated_uint64 (1, 504);
171 message->set_repeated_sint32 (1, 505);
172 message->set_repeated_sint64 (1, 506);
173 message->set_repeated_fixed32 (1, 507);
174 message->set_repeated_fixed64 (1, 508);
175 message->set_repeated_sfixed32(1, 509);
176 message->set_repeated_sfixed64(1, 510);
177 message->set_repeated_float (1, 511);
178 message->set_repeated_double (1, 512);
179 message->set_repeated_bool (1, true);
180 message->set_repeated_string (1, "515");
181 message->set_repeated_bytes (1, "516");
183 message->mutable_repeatedgroup (1)->set_a(517);
184 message->mutable_repeated_nested_message (1)->set_bb(518);
185 message->mutable_repeated_foreign_message(1)->set_c(519);
186 message->mutable_repeated_import_message (1)->set_d(520);
187 message->mutable_repeated_lazy_message (1)->set_bb(527);
189 message->set_repeated_nested_enum (1, unittest::TestAllTypesLite::FOO );
190 message->set_repeated_foreign_enum(1, unittest::FOREIGN_LITE_FOO );
191 message->set_repeated_import_enum (1, unittest_import::IMPORT_LITE_FOO);
198 const unittest::TestAllTypesLite& message) {
199 EXPECT_TRUE(message.has_optional_int32 ());
200 EXPECT_TRUE(message.has_optional_int64 ());
201 EXPECT_TRUE(message.has_optional_uint32 ());
202 EXPECT_TRUE(message.has_optional_uint64 ());
203 EXPECT_TRUE(message.has_optional_sint32 ());
204 EXPECT_TRUE(message.has_optional_sint64 ());
205 EXPECT_TRUE(message.has_optional_fixed32 ());
206 EXPECT_TRUE(message.has_optional_fixed64 ());
207 EXPECT_TRUE(message.has_optional_sfixed32());
208 EXPECT_TRUE(message.has_optional_sfixed64());
209 EXPECT_TRUE(message.has_optional_float ());
210 EXPECT_TRUE(message.has_optional_double ());
211 EXPECT_TRUE(message.has_optional_bool ());
212 EXPECT_TRUE(message.has_optional_string ());
213 EXPECT_TRUE(message.has_optional_bytes ());
215 EXPECT_TRUE(message.has_optionalgroup ());
216 EXPECT_TRUE(message.has_optional_nested_message ());
217 EXPECT_TRUE(message.has_optional_foreign_message ());
218 EXPECT_TRUE(message.has_optional_import_message ());
219 EXPECT_TRUE(message.has_optional_public_import_message());
220 EXPECT_TRUE(message.has_optional_lazy_message ());
222 EXPECT_TRUE(message.optionalgroup ().has_a());
223 EXPECT_TRUE(message.optional_nested_message ().has_bb());
224 EXPECT_TRUE(message.optional_foreign_message ().has_c());
225 EXPECT_TRUE(message.optional_import_message ().has_d());
226 EXPECT_TRUE(message.optional_public_import_message().has_e());
227 EXPECT_TRUE(message.optional_lazy_message ().has_bb());
229 EXPECT_TRUE(message.has_optional_nested_enum ());
230 EXPECT_TRUE(message.has_optional_foreign_enum());
231 EXPECT_TRUE(message.has_optional_import_enum ());
234 EXPECT_EQ(101 , message.optional_int32 ());
235 EXPECT_EQ(102 , message.optional_int64 ());
236 EXPECT_EQ(103 , message.optional_uint32 ());
237 EXPECT_EQ(104 , message.optional_uint64 ());
238 EXPECT_EQ(105 , message.optional_sint32 ());
239 EXPECT_EQ(106 , message.optional_sint64 ());
240 EXPECT_EQ(107 , message.optional_fixed32 ());
241 EXPECT_EQ(108 , message.optional_fixed64 ());
242 EXPECT_EQ(109 , message.optional_sfixed32());
243 EXPECT_EQ(110 , message.optional_sfixed64());
244 EXPECT_EQ(111 , message.optional_float ());
245 EXPECT_EQ(112 , message.optional_double ());
246 EXPECT_EQ(true , message.optional_bool ());
247 EXPECT_EQ("115", message.optional_string ());
248 EXPECT_EQ("116", message.optional_bytes ());
250 EXPECT_EQ(117, message.optionalgroup ().a());
251 EXPECT_EQ(118, message.optional_nested_message ().bb());
252 EXPECT_EQ(119, message.optional_foreign_message ().c());
253 EXPECT_EQ(120, message.optional_import_message ().d());
254 EXPECT_EQ(126, message.optional_public_import_message().e());
255 EXPECT_EQ(127, message.optional_lazy_message ().bb());
257 EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.optional_nested_enum ());
258 EXPECT_EQ(unittest::FOREIGN_LITE_BAZ , message.optional_foreign_enum());
259 EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.optional_import_enum ());
264 ASSERT_EQ(2, message.repeated_int32_size ());
265 ASSERT_EQ(2, message.repeated_int64_size ());
266 ASSERT_EQ(2, message.repeated_uint32_size ());
267 ASSERT_EQ(2, message.repeated_uint64_size ());
268 ASSERT_EQ(2, message.repeated_sint32_size ());
269 ASSERT_EQ(2, message.repeated_sint64_size ());
270 ASSERT_EQ(2, message.repeated_fixed32_size ());
271 ASSERT_EQ(2, message.repeated_fixed64_size ());
272 ASSERT_EQ(2, message.repeated_sfixed32_size());
273 ASSERT_EQ(2, message.repeated_sfixed64_size());
274 ASSERT_EQ(2, message.repeated_float_size ());
275 ASSERT_EQ(2, message.repeated_double_size ());
276 ASSERT_EQ(2, message.repeated_bool_size ());
277 ASSERT_EQ(2, message.repeated_string_size ());
278 ASSERT_EQ(2, message.repeated_bytes_size ());
280 ASSERT_EQ(2, message.repeatedgroup_size ());
281 ASSERT_EQ(2, message.repeated_nested_message_size ());
282 ASSERT_EQ(2, message.repeated_foreign_message_size());
283 ASSERT_EQ(2, message.repeated_import_message_size ());
284 ASSERT_EQ(2, message.repeated_lazy_message_size ());
285 ASSERT_EQ(2, message.repeated_nested_enum_size ());
286 ASSERT_EQ(2, message.repeated_foreign_enum_size ());
287 ASSERT_EQ(2, message.repeated_import_enum_size ());
290 EXPECT_EQ(201 , message.repeated_int32 (0));
291 EXPECT_EQ(202 , message.repeated_int64 (0));
292 EXPECT_EQ(203 , message.repeated_uint32 (0));
293 EXPECT_EQ(204 , message.repeated_uint64 (0));
294 EXPECT_EQ(205 , message.repeated_sint32 (0));
295 EXPECT_EQ(206 , message.repeated_sint64 (0));
296 EXPECT_EQ(207 , message.repeated_fixed32 (0));
297 EXPECT_EQ(208 , message.repeated_fixed64 (0));
298 EXPECT_EQ(209 , message.repeated_sfixed32(0));
299 EXPECT_EQ(210 , message.repeated_sfixed64(0));
300 EXPECT_EQ(211 , message.repeated_float (0));
301 EXPECT_EQ(212 , message.repeated_double (0));
302 EXPECT_EQ(true , message.repeated_bool (0));
303 EXPECT_EQ("215", message.repeated_string (0));
304 EXPECT_EQ("216", message.repeated_bytes (0));
306 EXPECT_EQ(217, message.repeatedgroup (0).a());
307 EXPECT_EQ(218, message.repeated_nested_message (0).bb());
308 EXPECT_EQ(219, message.repeated_foreign_message(0).c());
309 EXPECT_EQ(220, message.repeated_import_message (0).d());
310 EXPECT_EQ(227, message.repeated_lazy_message (0).bb());
313 EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.repeated_nested_enum (0));
314 EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.repeated_foreign_enum(0));
315 EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum (0));
317 EXPECT_EQ(301 , message.repeated_int32 (1));
318 EXPECT_EQ(302 , message.repeated_int64 (1));
319 EXPECT_EQ(303 , message.repeated_uint32 (1));
320 EXPECT_EQ(304 , message.repeated_uint64 (1));
321 EXPECT_EQ(305 , message.repeated_sint32 (1));
322 EXPECT_EQ(306 , message.repeated_sint64 (1));
323 EXPECT_EQ(307 , message.repeated_fixed32 (1));
324 EXPECT_EQ(308 , message.repeated_fixed64 (1));
325 EXPECT_EQ(309 , message.repeated_sfixed32(1));
326 EXPECT_EQ(310 , message.repeated_sfixed64(1));
327 EXPECT_EQ(311 , message.repeated_float (1));
328 EXPECT_EQ(312 , message.repeated_double (1));
329 EXPECT_EQ(false, message.repeated_bool (1));
330 EXPECT_EQ("315", message.repeated_string (1));
331 EXPECT_EQ("316", message.repeated_bytes (1));
333 EXPECT_EQ(317, message.repeatedgroup (1).a());
334 EXPECT_EQ(318, message.repeated_nested_message (1).bb());
335 EXPECT_EQ(319, message.repeated_foreign_message(1).c());
336 EXPECT_EQ(320, message.repeated_import_message (1).d());
337 EXPECT_EQ(327, message.repeated_lazy_message (1).bb());
339 EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.repeated_nested_enum (1));
340 EXPECT_EQ(unittest::FOREIGN_LITE_BAZ , message.repeated_foreign_enum(1));
341 EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.repeated_import_enum (1));
346 EXPECT_TRUE(message.has_default_int32 ());
347 EXPECT_TRUE(message.has_default_int64 ());
348 EXPECT_TRUE(message.has_default_uint32 ());
349 EXPECT_TRUE(message.has_default_uint64 ());
350 EXPECT_TRUE(message.has_default_sint32 ());
351 EXPECT_TRUE(message.has_default_sint64 ());
352 EXPECT_TRUE(message.has_default_fixed32 ());
353 EXPECT_TRUE(message.has_default_fixed64 ());
354 EXPECT_TRUE(message.has_default_sfixed32());
355 EXPECT_TRUE(message.has_default_sfixed64());
356 EXPECT_TRUE(message.has_default_float ());
357 EXPECT_TRUE(message.has_default_double ());
358 EXPECT_TRUE(message.has_default_bool ());
359 EXPECT_TRUE(message.has_default_string ());
360 EXPECT_TRUE(message.has_default_bytes ());
362 EXPECT_TRUE(message.has_default_nested_enum ());
363 EXPECT_TRUE(message.has_default_foreign_enum());
364 EXPECT_TRUE(message.has_default_import_enum ());
367 EXPECT_EQ(401 , message.default_int32 ());
368 EXPECT_EQ(402 , message.default_int64 ());
369 EXPECT_EQ(403 , message.default_uint32 ());
370 EXPECT_EQ(404 , message.default_uint64 ());
371 EXPECT_EQ(405 , message.default_sint32 ());
372 EXPECT_EQ(406 , message.default_sint64 ());
373 EXPECT_EQ(407 , message.default_fixed32 ());
374 message.default_fixed64 ());
375 EXPECT_EQ(409 , message.default_sfixed32());
376 EXPECT_EQ(410 , message.default_sfixed64());
377 EXPECT_EQ(411 , message.default_float ());
378 EXPECT_EQ(412 , message.default_double ());
379 EXPECT_EQ(false, message.default_bool ());
380 EXPECT_EQ("415", message.default_string ());
381 EXPECT_EQ("416", message.default_bytes ());
383 EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.default_nested_enum ());
384 EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.default_foreign_enum());
385 EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.default_import_enum ());
388 EXPECT_FALSE(message.has_oneof_uint32 ());
389 EXPECT_FALSE(message.has_oneof_nested_message());
390 EXPECT_FALSE(message.has_oneof_string ());
391 EXPECT_TRUE(message.has_oneof_bytes ());
393 EXPECT_EQ("604", message.oneof_bytes());
398 void TestUtilLite::ExpectClear(const unittest::TestAllTypesLite& message) {
400 EXPECT_FALSE(message.has_optional_int32 ());
401 EXPECT_FALSE(message.has_optional_int64 ());
402 EXPECT_FALSE(message.has_optional_uint32 ());
403 EXPECT_FALSE(message.has_optional_uint64 ());
404 EXPECT_FALSE(message.has_optional_sint32 ());
405 EXPECT_FALSE(message.has_optional_sint64 ());
406 EXPECT_FALSE(message.has_optional_fixed32 ());
407 EXPECT_FALSE(message.has_optional_fixed64 ());
408 EXPECT_FALSE(message.has_optional_sfixed32());
409 EXPECT_FALSE(message.has_optional_sfixed64());
410 EXPECT_FALSE(message.has_optional_float ());
411 EXPECT_FALSE(message.has_optional_double ());
412 EXPECT_FALSE(message.has_optional_bool ());
413 EXPECT_FALSE(message.has_optional_string ());
414 EXPECT_FALSE(message.has_optional_bytes ());
416 EXPECT_FALSE(message.has_optionalgroup ());
417 EXPECT_FALSE(message.has_optional_nested_message ());
418 EXPECT_FALSE(message.has_optional_foreign_message ());
419 EXPECT_FALSE(message.has_optional_import_message ());
420 EXPECT_FALSE(message.has_optional_public_import_message());
421 EXPECT_FALSE(message.has_optional_lazy_message ());
423 EXPECT_FALSE(message.has_optional_nested_enum ());
424 EXPECT_FALSE(message.has_optional_foreign_enum());
425 EXPECT_FALSE(message.has_optional_import_enum ());
429 EXPECT_EQ(0 , message.optional_int32 ());
430 EXPECT_EQ(0 , message.optional_int64 ());
431 EXPECT_EQ(0 , message.optional_uint32 ());
432 EXPECT_EQ(0 , message.optional_uint64 ());
433 EXPECT_EQ(0 , message.optional_sint32 ());
434 EXPECT_EQ(0 , message.optional_sint64 ());
435 EXPECT_EQ(0 , message.optional_fixed32 ());
436 EXPECT_EQ(0 , message.optional_fixed64 ());
437 EXPECT_EQ(0 , message.optional_sfixed32());
438 EXPECT_EQ(0 , message.optional_sfixed64());
439 EXPECT_EQ(0 , message.optional_float ());
440 EXPECT_EQ(0 , message.optional_double ());
441 EXPECT_EQ(false, message.optional_bool ());
442 EXPECT_EQ("" , message.optional_string ());
443 EXPECT_EQ("" , message.optional_bytes ());
446 EXPECT_FALSE(message.optionalgroup ().has_a());
447 EXPECT_FALSE(message.optional_nested_message ().has_bb());
448 EXPECT_FALSE(message.optional_foreign_message ().has_c());
449 EXPECT_FALSE(message.optional_import_message ().has_d());
450 EXPECT_FALSE(message.optional_public_import_message().has_e());
451 EXPECT_FALSE(message.optional_lazy_message ().has_bb());
453 EXPECT_EQ(0, message.optionalgroup ().a());
454 EXPECT_EQ(0, message.optional_nested_message ().bb());
455 EXPECT_EQ(0, message.optional_foreign_message().c());
456 EXPECT_EQ(0, message.optional_import_message ().d());
459 EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.optional_nested_enum ());
460 EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.optional_foreign_enum());
461 EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.optional_import_enum ());
465 EXPECT_EQ(0, message.repeated_int32_size ());
466 EXPECT_EQ(0, message.repeated_int64_size ());
467 EXPECT_EQ(0, message.repeated_uint32_size ());
468 EXPECT_EQ(0, message.repeated_uint64_size ());
469 EXPECT_EQ(0, message.repeated_sint32_size ());
470 EXPECT_EQ(0, message.repeated_sint64_size ());
471 EXPECT_EQ(0, message.repeated_fixed32_size ());
472 EXPECT_EQ(0, message.repeated_fixed64_size ());
473 EXPECT_EQ(0, message.repeated_sfixed32_size());
474 EXPECT_EQ(0, message.repeated_sfixed64_size());
475 EXPECT_EQ(0, message.repeated_float_size ());
476 EXPECT_EQ(0, message.repeated_double_size ());
477 EXPECT_EQ(0, message.repeated_bool_size ());
478 EXPECT_EQ(0, message.repeated_string_size ());
479 EXPECT_EQ(0, message.repeated_bytes_size ());
481 EXPECT_EQ(0, message.repeatedgroup_size ());
482 EXPECT_EQ(0, message.repeated_nested_message_size ());
483 EXPECT_EQ(0, message.repeated_foreign_message_size());
484 EXPECT_EQ(0, message.repeated_import_message_size ());
485 EXPECT_EQ(0, message.repeated_lazy_message_size ());
486 EXPECT_EQ(0, message.repeated_nested_enum_size ());
487 EXPECT_EQ(0, message.repeated_foreign_enum_size ());
488 EXPECT_EQ(0, message.repeated_import_enum_size ());
492 EXPECT_FALSE(message.has_default_int32 ());
493 EXPECT_FALSE(message.has_default_int64 ());
494 EXPECT_FALSE(message.has_default_uint32 ());
495 EXPECT_FALSE(message.has_default_uint64 ());
496 EXPECT_FALSE(message.has_default_sint32 ());
497 EXPECT_FALSE(message.has_default_sint64 ());
498 EXPECT_FALSE(message.has_default_fixed32 ());
499 EXPECT_FALSE(message.has_default_fixed64 ());
500 EXPECT_FALSE(message.has_default_sfixed32());
501 EXPECT_FALSE(message.has_default_sfixed64());
502 EXPECT_FALSE(message.has_default_float ());
503 EXPECT_FALSE(message.has_default_double ());
504 EXPECT_FALSE(message.has_default_bool ());
505 EXPECT_FALSE(message.has_default_string ());
506 EXPECT_FALSE(message.has_default_bytes ());
508 EXPECT_FALSE(message.has_default_nested_enum ());
509 EXPECT_FALSE(message.has_default_foreign_enum());
510 EXPECT_FALSE(message.has_default_import_enum ());
514 EXPECT_EQ( 41 , message.default_int32 ());
515 EXPECT_EQ( 42 , message.default_int64 ());
516 EXPECT_EQ( 43 , message.default_uint32 ());
517 EXPECT_EQ( 44 , message.default_uint64 ());
518 EXPECT_EQ(-45 , message.default_sint32 ());
519 EXPECT_EQ( 46 , message.default_sint64 ());
520 EXPECT_EQ( 47 , message.default_fixed32 ());
521 EXPECT_EQ( 48 , message.default_fixed64 ());
522 EXPECT_EQ( 49 , message.default_sfixed32());
523 EXPECT_EQ(-50 , message.default_sfixed64());
524 EXPECT_EQ( 51.5 , message.default_float ());
525 EXPECT_EQ( 52e3 , message.default_double ());
526 EXPECT_EQ(true , message.default_bool ());
527 EXPECT_EQ("hello", message.default_string ());
528 EXPECT_EQ("world", message.default_bytes ());
530 EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.default_nested_enum ());
531 EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.default_foreign_enum());
532 EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.default_import_enum ());
535 EXPECT_FALSE(message.has_oneof_uint32 ());
536 EXPECT_FALSE(message.has_oneof_nested_message());
537 EXPECT_FALSE(message.has_oneof_string ());
538 EXPECT_FALSE(message.has_oneof_bytes ());
544 const unittest::TestAllTypesLite& message) {
548 ASSERT_EQ(2, message.repeated_int32_size ());
549 ASSERT_EQ(2, message.repeated_int64_size ());
550 ASSERT_EQ(2, message.repeated_uint32_size ());
551 ASSERT_EQ(2, message.repeated_uint64_size ());
552 ASSERT_EQ(2, message.repeated_sint32_size ());
553 ASSERT_EQ(2, message.repeated_sint64_size ());
554 ASSERT_EQ(2, message.repeated_fixed32_size ());
555 ASSERT_EQ(2, message.repeated_fixed64_size ());
556 ASSERT_EQ(2, message.repeated_sfixed32_size());
557 ASSERT_EQ(2, message.repeated_sfixed64_size());
558 ASSERT_EQ(2, message.repeated_float_size ());
559 ASSERT_EQ(2, message.repeated_double_size ());
560 ASSERT_EQ(2, message.repeated_bool_size ());
561 ASSERT_EQ(2, message.repeated_string_size ());
562 ASSERT_EQ(2, message.repeated_bytes_size ());
564 ASSERT_EQ(2, message.repeatedgroup_size ());
565 ASSERT_EQ(2, message.repeated_nested_message_size ());
566 ASSERT_EQ(2, message.repeated_foreign_message_size());
567 ASSERT_EQ(2, message.repeated_import_message_size ());
568 ASSERT_EQ(2, message.repeated_lazy_message_size ());
569 ASSERT_EQ(2, message.repeated_nested_enum_size ());
570 ASSERT_EQ(2, message.repeated_foreign_enum_size ());
571 ASSERT_EQ(2, message.repeated_import_enum_size ());
574 EXPECT_EQ(201 , message.repeated_int32 (0));
575 EXPECT_EQ(202 , message.repeated_int64 (0));
576 EXPECT_EQ(203 , message.repeated_uint32 (0));
577 EXPECT_EQ(204 , message.repeated_uint64 (0));
578 EXPECT_EQ(205 , message.repeated_sint32 (0));
579 EXPECT_EQ(206 , message.repeated_sint64 (0));
580 EXPECT_EQ(207 , message.repeated_fixed32 (0));
581 EXPECT_EQ(208 , message.repeated_fixed64 (0));
582 EXPECT_EQ(209 , message.repeated_sfixed32(0));
583 EXPECT_EQ(210 , message.repeated_sfixed64(0));
584 EXPECT_EQ(211 , message.repeated_float (0));
585 EXPECT_EQ(212 , message.repeated_double (0));
586 EXPECT_EQ(true , message.repeated_bool (0));
587 EXPECT_EQ("215", message.repeated_string (0));
588 EXPECT_EQ("216", message.repeated_bytes (0));
590 EXPECT_EQ(217, message.repeatedgroup (0).a());
591 EXPECT_EQ(218, message.repeated_nested_message (0).bb());
592 EXPECT_EQ(219, message.repeated_foreign_message(0).c());
593 EXPECT_EQ(220, message.repeated_import_message (0).d());
594 EXPECT_EQ(227, message.repeated_lazy_message (0).bb());
596 EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.repeated_nested_enum (0));
597 EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.repeated_foreign_enum(0));
598 EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum (0));
602 EXPECT_EQ(501 , message.repeated_int32 (1));
603 EXPECT_EQ(502 , message.repeated_int64 (1));
604 EXPECT_EQ(503 , message.repeated_uint32 (1));
605 EXPECT_EQ(504 , message.repeated_uint64 (1));
606 EXPECT_EQ(505 , message.repeated_sint32 (1));
607 EXPECT_EQ(506 , message.repeated_sint64 (1));
608 EXPECT_EQ(507 , message.repeated_fixed32 (1));
609 EXPECT_EQ(508 , message.repeated_fixed64 (1));
610 EXPECT_EQ(509 , message.repeated_sfixed32(1));
611 EXPECT_EQ(510 , message.repeated_sfixed64(1));
612 EXPECT_EQ(511 , message.repeated_float (1));
613 EXPECT_EQ(512 , message.repeated_double (1));
614 EXPECT_EQ(true , message.repeated_bool (1));
615 EXPECT_EQ("515", message.repeated_string (1));
616 EXPECT_EQ("516", message.repeated_bytes (1));
618 EXPECT_EQ(517, message.repeatedgroup (1).a());
619 EXPECT_EQ(518, message.repeated_nested_message (1).bb());
620 EXPECT_EQ(519, message.repeated_foreign_message(1).c());
621 EXPECT_EQ(520, message.repeated_import_message (1).d());
622 EXPECT_EQ(527, message.repeated_lazy_message (1).bb());
624 EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.repeated_nested_enum (1));
625 EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.repeated_foreign_enum(1));
626 EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.repeated_import_enum (1));
632 void TestUtilLite::SetPackedFields(unittest::TestPackedTypesLite* message) {
633 message->add_packed_int32 (601);
634 message->add_packed_int64 (602);
635 message->add_packed_uint32 (603);
636 message->add_packed_uint64 (604);
637 message->add_packed_sint32 (605);
638 message->add_packed_sint64 (606);
639 message->add_packed_fixed32 (607);
640 message->add_packed_fixed64 (608);
641 message->add_packed_sfixed32(609);
642 message->add_packed_sfixed64(610);
643 message->add_packed_float (611);
644 message->add_packed_double (612);
645 message->add_packed_bool (true);
646 message->add_packed_enum (unittest::FOREIGN_LITE_BAR);
648 message->add_packed_int32 (701);
649 message->add_packed_int64 (702);
650 message->add_packed_uint32 (703);
651 message->add_packed_uint64 (704);
652 message->add_packed_sint32 (705);
653 message->add_packed_sint64 (706);
654 message->add_packed_fixed32 (707);
655 message->add_packed_fixed64 (708);
656 message->add_packed_sfixed32(709);
657 message->add_packed_sfixed64(710);
658 message->add_packed_float (711);
659 message->add_packed_double (712);
660 message->add_packed_bool (false);
661 message->add_packed_enum (unittest::FOREIGN_LITE_BAZ);
666 void TestUtilLite::ModifyPackedFields(unittest::TestPackedTypesLite* message) {
667 message->set_packed_int32 (1, 801);
668 message->set_packed_int64 (1, 802);
669 message->set_packed_uint32 (1, 803);
670 message->set_packed_uint64 (1, 804);
671 message->set_packed_sint32 (1, 805);
672 message->set_packed_sint64 (1, 806);
673 message->set_packed_fixed32 (1, 807);
674 message->set_packed_fixed64 (1, 808);
675 message->set_packed_sfixed32(1, 809);
676 message->set_packed_sfixed64(1, 810);
677 message->set_packed_float (1, 811);
678 message->set_packed_double (1, 812);
679 message->set_packed_bool (1, true);
680 message->set_packed_enum (1, unittest::FOREIGN_LITE_FOO);
686 const unittest::TestPackedTypesLite& message) {
687 ASSERT_EQ(2, message.packed_int32_size ());
688 ASSERT_EQ(2, message.packed_int64_size ());
689 ASSERT_EQ(2, message.packed_uint32_size ());
690 ASSERT_EQ(2, message.packed_uint64_size ());
691 ASSERT_EQ(2, message.packed_sint32_size ());
692 ASSERT_EQ(2, message.packed_sint64_size ());
693 ASSERT_EQ(2, message.packed_fixed32_size ());
694 ASSERT_EQ(2, message.packed_fixed64_size ());
695 ASSERT_EQ(2, message.packed_sfixed32_size());
696 ASSERT_EQ(2, message.packed_sfixed64_size());
697 ASSERT_EQ(2, message.packed_float_size ());
698 ASSERT_EQ(2, message.packed_double_size ());
699 ASSERT_EQ(2, message.packed_bool_size ());
700 ASSERT_EQ(2, message.packed_enum_size ());
702 EXPECT_EQ(601 , message.packed_int32 (0));
703 EXPECT_EQ(602 , message.packed_int64 (0));
704 EXPECT_EQ(603 , message.packed_uint32 (0));
705 EXPECT_EQ(604 , message.packed_uint64 (0));
706 EXPECT_EQ(605 , message.packed_sint32 (0));
707 EXPECT_EQ(606 , message.packed_sint64 (0));
708 EXPECT_EQ(607 , message.packed_fixed32 (0));
709 EXPECT_EQ(608 , message.packed_fixed64 (0));
710 EXPECT_EQ(609 , message.packed_sfixed32(0));
711 EXPECT_EQ(610 , message.packed_sfixed64(0));
712 EXPECT_EQ(611 , message.packed_float (0));
713 EXPECT_EQ(612 , message.packed_double (0));
714 EXPECT_EQ(true , message.packed_bool (0));
715 EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0));
717 EXPECT_EQ(701 , message.packed_int32 (1));
718 EXPECT_EQ(702 , message.packed_int64 (1));
719 EXPECT_EQ(703 , message.packed_uint32 (1));
720 EXPECT_EQ(704 , message.packed_uint64 (1));
721 EXPECT_EQ(705 , message.packed_sint32 (1));
722 EXPECT_EQ(706 , message.packed_sint64 (1));
723 EXPECT_EQ(707 , message.packed_fixed32 (1));
724 EXPECT_EQ(708 , message.packed_fixed64 (1));
725 EXPECT_EQ(709 , message.packed_sfixed32(1));
726 EXPECT_EQ(710 , message.packed_sfixed64(1));
727 EXPECT_EQ(711 , message.packed_float (1));
728 EXPECT_EQ(712 , message.packed_double (1));
729 EXPECT_EQ(false, message.packed_bool (1));
730 EXPECT_EQ(unittest::FOREIGN_LITE_BAZ, message.packed_enum(1));
736 const unittest::TestPackedTypesLite& message) {
738 EXPECT_EQ(0, message.packed_int32_size ());
739 EXPECT_EQ(0, message.packed_int64_size ());
740 EXPECT_EQ(0, message.packed_uint32_size ());
741 message.packed_uint64_size ());
742 EXPECT_EQ(0, message.packed_sint32_size ());
743 EXPECT_EQ(0, message.packed_sint64_size ());
744 EXPECT_EQ(0, message.packed_fixed32_size ());
745 EXPECT_EQ(0, message.packed_fixed64_size ());
746 EXPECT_EQ(0, message.packed_sfixed32_size());
747 EXPECT_EQ(0, message.packed_sfixed64_size());
748 EXPECT_EQ(0, message.packed_float_size ());
749 EXPECT_EQ(0, message.packed_double_size ());
750 EXPECT_EQ(0, message.packed_bool_size ());
751 EXPECT_EQ(0, message.packed_enum_size ());
757 const unittest::TestPackedTypesLite& message) {
759 ASSERT_EQ(2, message.packed_int32_size ());
760 ASSERT_EQ(2, message.packed_int64_size ());
761 ASSERT_EQ(2, message.packed_uint32_size ());
762 ASSERT_EQ(2, message.packed_uint64_size ());
763 ASSERT_EQ(2, message.packed_sint32_size ());
764 ASSERT_EQ(2, message.packed_sint64_size ());
765 ASSERT_EQ(2, message.packed_fixed32_size ());
766 ASSERT_EQ(2, message.packed_fixed64_size ());
767 ASSERT_EQ(2, message.packed_sfixed32_size());
768 ASSERT_EQ(2, message.packed_sfixed64_size());
769 ASSERT_EQ(2, message.packed_float_size ());
770 ASSERT_EQ(2, message.packed_double_size ());
771 ASSERT_EQ(2, message.packed_bool_size ());
772 ASSERT_EQ(2, message.packed_enum_size ());
774 EXPECT_EQ(601 , message.packed_int32 (0));
775 EXPECT_EQ(602 , message.packed_int64 (0));
776 EXPECT_EQ(603 , message.packed_uint32 (0));
777 EXPECT_EQ(604 , message.packed_uint64 (0));
778 EXPECT_EQ(605 , message.packed_sint32 (0));
779 EXPECT_EQ(606 , message.packed_sint64 (0));
780 EXPECT_EQ(607 , message.packed_fixed32 (0));
781 EXPECT_EQ(608 , message.packed_fixed64 (0));
782 EXPECT_EQ(609 , message.packed_sfixed32(0));
783 EXPECT_EQ(610 , message.packed_sfixed64(0));
784 EXPECT_EQ(611 , message.packed_float (0));
785 EXPECT_EQ(612 , message.packed_double (0));
786 EXPECT_EQ(true , message.packed_bool (0));
787 EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0));
789 EXPECT_EQ(801 , message.packed_int32 (1));
790 EXPECT_EQ(802 , message.packed_int64 (1));
791 EXPECT_EQ(803 , message.packed_uint32 (1));
792 EXPECT_EQ(804 , message.packed_uint64 (1));
793 EXPECT_EQ(805 , message.packed_sint32 (1));
794 EXPECT_EQ(806 , message.packed_sint64 (1));
795 EXPECT_EQ(807 , message.packed_fixed32 (1));
796 EXPECT_EQ(808 , message.packed_fixed64 (1));
797 EXPECT_EQ(809 , message.packed_sfixed32(1));
798 EXPECT_EQ(810 , message.packed_sfixed64(1));
799 EXPECT_EQ(811 , message.packed_float (1));
800 EXPECT_EQ(812 , message.packed_double (1));
801 EXPECT_EQ(true , message.packed_bool (1));
802 EXPECT_EQ(unittest::FOREIGN_LITE_FOO, message.packed_enum(1));
813 void TestUtilLite::SetAllExtensions(unittest::TestAllExtensionsLite* message) {
814 message->SetExtension(unittest::optional_int32_extension_lite , 101);
815 message->SetExtension(unittest::optional_int64_extension_lite , 102);
816 message->SetExtension(unittest::optional_uint32_extension_lite , 103);
817 message->SetExtension(unittest::optional_uint64_extension_lite , 104);
818 message->SetExtension(unittest::optional_sint32_extension_lite , 105);
819 message->SetExtension(unittest::optional_sint64_extension_lite , 106);
820 message->SetExtension(unittest::optional_fixed32_extension_lite , 107);
821 message->SetExtension(unittest::optional_fixed64_extension_lite , 108);
822 message->SetExtension(unittest::optional_sfixed32_extension_lite, 109);
823 message->SetExtension(unittest::optional_sfixed64_extension_lite, 110);
824 message->SetExtension(unittest::optional_float_extension_lite , 111);
825 message->SetExtension(unittest::optional_double_extension_lite , 112);
826 message->SetExtension(unittest::optional_bool_extension_lite , true);
827 message->SetExtension(unittest::optional_string_extension_lite , "115");
828 message->SetExtension(unittest::optional_bytes_extension_lite , "116");
830 message->MutableExtension(unittest::optionalgroup_extension_lite )->set_a(117);
831 message->MutableExtension(unittest::optional_nested_message_extension_lite )->set_bb(118);
832 message->MutableExtension(unittest::optional_foreign_message_extension_lite )->set_c(119);
833 message->MutableExtension(unittest::optional_import_message_extension_lite )->set_d(120);
834 message->MutableExtension(unittest::optional_public_import_message_extension_lite)->set_e(126);
835 message->MutableExtension(unittest::optional_lazy_message_extension_lite )->set_bb(127);
837 message->SetExtension(unittest::optional_nested_enum_extension_lite , unittest::TestAllTypesLite::BAZ );
838 message->SetExtension(unittest::optional_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAZ );
839 message->SetExtension(unittest::optional_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAZ);
844 message->AddExtension(unittest::repeated_int32_extension_lite , 201);
845 message->AddExtension(unittest::repeated_int64_extension_lite , 202);
846 message->AddExtension(unittest::repeated_uint32_extension_lite , 203);
847 message->AddExtension(unittest::repeated_uint64_extension_lite , 204);
848 message->AddExtension(unittest::repeated_sint32_extension_lite , 205);
849 message->AddExtension(unittest::repeated_sint64_extension_lite , 206);
850 message->AddExtension(unittest::repeated_fixed32_extension_lite , 207);
851 message->AddExtension(unittest::repeated_fixed64_extension_lite , 208);
852 message->AddExtension(unittest::repeated_sfixed32_extension_lite, 209);
853 message->AddExtension(unittest::repeated_sfixed64_extension_lite, 210);
854 message->AddExtension(unittest::repeated_float_extension_lite , 211);
855 message->AddExtension(unittest::repeated_double_extension_lite , 212);
856 message->AddExtension(unittest::repeated_bool_extension_lite , true);
857 message->AddExtension(unittest::repeated_string_extension_lite , "215");
858 message->AddExtension(unittest::repeated_bytes_extension_lite , "216");
860 message->AddExtension(unittest::repeatedgroup_extension_lite )->set_a(217);
861 message->AddExtension(unittest::repeated_nested_message_extension_lite )->set_bb(218);
862 message->AddExtension(unittest::repeated_foreign_message_extension_lite)->set_c(219);
863 message->AddExtension(unittest::repeated_import_message_extension_lite )->set_d(220);
864 message->AddExtension(unittest::repeated_lazy_message_extension_lite )->set_bb(227);
866 message->AddExtension(unittest::repeated_nested_enum_extension_lite , unittest::TestAllTypesLite::BAR );
867 message->AddExtension(unittest::repeated_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAR );
868 message->AddExtension(unittest::repeated_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAR);
872 message->AddExtension(unittest::repeated_int32_extension_lite , 301);
873 message->AddExtension(unittest::repeated_int64_extension_lite , 302);
874 message->AddExtension(unittest::repeated_uint32_extension_lite , 303);
875 message->AddExtension(unittest::repeated_uint64_extension_lite , 304);
876 message->AddExtension(unittest::repeated_sint32_extension_lite , 305);
877 message->AddExtension(unittest::repeated_sint64_extension_lite , 306);
878 message->AddExtension(unittest::repeated_fixed32_extension_lite , 307);
879 message->AddExtension(unittest::repeated_fixed64_extension_lite , 308);
880 message->AddExtension(unittest::repeated_sfixed32_extension_lite, 309);
881 message->AddExtension(unittest::repeated_sfixed64_extension_lite, 310);
882 message->AddExtension(unittest::repeated_float_extension_lite , 311);
883 message->AddExtension(unittest::repeated_double_extension_lite , 312);
884 message->AddExtension(unittest::repeated_bool_extension_lite , false);
885 message->AddExtension(unittest::repeated_string_extension_lite , "315");
886 message->AddExtension(unittest::repeated_bytes_extension_lite , "316");
888 message->AddExtension(unittest::repeatedgroup_extension_lite )->set_a(317);
889 message->AddExtension(unittest::repeated_nested_message_extension_lite )->set_bb(318);
890 message->AddExtension(unittest::repeated_foreign_message_extension_lite)->set_c(319);
891 message->AddExtension(unittest::repeated_import_message_extension_lite )->set_d(320);
892 message->AddExtension(unittest::repeated_lazy_message_extension_lite )->set_bb(327);
894 message->AddExtension(unittest::repeated_nested_enum_extension_lite , unittest::TestAllTypesLite::BAZ );
895 message->AddExtension(unittest::repeated_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAZ );
896 message->AddExtension(unittest::repeated_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAZ);
901 message->SetExtension(unittest::default_int32_extension_lite , 401);
902 message->SetExtension(unittest::default_int64_extension_lite , 402);
903 message->SetExtension(unittest::default_uint32_extension_lite , 403);
904 message->SetExtension(unittest::default_uint64_extension_lite , 404);
905 message->SetExtension(unittest::default_sint32_extension_lite , 405);
906 message->SetExtension(unittest::default_sint64_extension_lite , 406);
907 message->SetExtension(unittest::default_fixed32_extension_lite , 407);
908 message->SetExtension(unittest::default_fixed64_extension_lite , 408);
909 message->SetExtension(unittest::default_sfixed32_extension_lite, 409);
910 message->SetExtension(unittest::default_sfixed64_extension_lite, 410);
911 message->SetExtension(unittest::default_float_extension_lite , 411);
912 message->SetExtension(unittest::default_double_extension_lite , 412);
913 message->SetExtension(unittest::default_bool_extension_lite , false);
914 message->SetExtension(unittest::default_string_extension_lite , "415");
915 message->SetExtension(unittest::default_bytes_extension_lite , "416");
917 message->SetExtension(unittest::default_nested_enum_extension_lite , unittest::TestAllTypesLite::FOO );
918 message->SetExtension(unittest::default_foreign_enum_extension_lite, unittest::FOREIGN_LITE_FOO );
919 message->SetExtension(unittest::default_import_enum_extension_lite , unittest_import::IMPORT_LITE_FOO);
922 message->SetExtension(unittest::oneof_uint32_extension_lite, 601);
923 message->MutableExtension(unittest::oneof_nested_message_extension_lite)->set_bb(602);;
924 message->SetExtension(unittest::oneof_string_extension_lite, "603");
925 message->SetExtension(unittest::oneof_bytes_extension_lite, "604");
931 unittest::TestAllExtensionsLite* message) {
932 message->SetExtension(unittest::repeated_int32_extension_lite , 1, 501);
933 message->SetExtension(unittest::repeated_int64_extension_lite , 1, 502);
934 message->SetExtension(unittest::repeated_uint32_extension_lite , 1, 503);
935 message->SetExtension(unittest::repeated_uint64_extension_lite , 1, 504);
936 message->SetExtension(unittest::repeated_sint32_extension_lite , 1, 505);
937 message->SetExtension(unittest::repeated_sint64_extension_lite , 1, 506);
938 message->SetExtension(unittest::repeated_fixed32_extension_lite , 1, 507);
939 message->SetExtension(unittest::repeated_fixed64_extension_lite , 1, 508);
940 message->SetExtension(unittest::repeated_sfixed32_extension_lite, 1, 509);
941 message->SetExtension(unittest::repeated_sfixed64_extension_lite, 1, 510);
942 message->SetExtension(unittest::repeated_float_extension_lite , 1, 511);
943 message->SetExtension(unittest::repeated_double_extension_lite , 1, 512);
944 message->SetExtension(unittest::repeated_bool_extension_lite , 1, true);
945 message->SetExtension(unittest::repeated_string_extension_lite , 1, "515");
946 message->SetExtension(unittest::repeated_bytes_extension_lite , 1, "516");
948 message->MutableExtension(unittest::repeatedgroup_extension_lite , 1)->set_a(517);
949 message->MutableExtension(unittest::repeated_nested_message_extension_lite , 1)->set_bb(518);
950 message->MutableExtension(unittest::repeated_foreign_message_extension_lite, 1)->set_c(519);
951 message->MutableExtension(unittest::repeated_import_message_extension_lite , 1)->set_d(520);
952 message->MutableExtension(unittest::repeated_lazy_message_extension_lite , 1)->set_bb(527);
954 message->SetExtension(unittest::repeated_nested_enum_extension_lite , 1, unittest::TestAllTypesLite::FOO );
955 message->SetExtension(unittest::repeated_foreign_enum_extension_lite, 1, unittest::FOREIGN_LITE_FOO );
956 message->SetExtension(unittest::repeated_import_enum_extension_lite , 1, unittest_import::IMPORT_LITE_FOO);
963 const unittest::TestAllExtensionsLite& message) {
964 EXPECT_TRUE(message.HasExtension(unittest::optional_int32_extension_lite ));
965 EXPECT_TRUE(message.HasExtension(unittest::optional_int64_extension_lite ));
966 EXPECT_TRUE(message.HasExtension(unittest::optional_uint32_extension_lite ));
967 EXPECT_TRUE(message.HasExtension(unittest::optional_uint64_extension_lite ));
968 EXPECT_TRUE(message.HasExtension(unittest::optional_sint32_extension_lite ));
969 EXPECT_TRUE(message.HasExtension(unittest::optional_sint64_extension_lite ));
970 EXPECT_TRUE(message.HasExtension(unittest::optional_fixed32_extension_lite ));
971 EXPECT_TRUE(message.HasExtension(unittest::optional_fixed64_extension_lite ));
972 EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed32_extension_lite));
973 EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed64_extension_lite));
974 EXPECT_TRUE(message.HasExtension(unittest::optional_float_extension_lite ));
975 EXPECT_TRUE(message.HasExtension(unittest::optional_double_extension_lite ));
976 EXPECT_TRUE(message.HasExtension(unittest::optional_bool_extension_lite ));
977 EXPECT_TRUE(message.HasExtension(unittest::optional_string_extension_lite ));
978 EXPECT_TRUE(message.HasExtension(unittest::optional_bytes_extension_lite ));
980 EXPECT_TRUE(message.HasExtension(unittest::optionalgroup_extension_lite ));
981 EXPECT_TRUE(message.HasExtension(unittest::optional_nested_message_extension_lite ));
982 EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_message_extension_lite ));
983 EXPECT_TRUE(message.HasExtension(unittest::optional_import_message_extension_lite ));
984 EXPECT_TRUE(message.HasExtension(unittest::optional_public_import_message_extension_lite));
985 EXPECT_TRUE(message.HasExtension(unittest::optional_lazy_message_extension_lite ));
987 EXPECT_TRUE(message.GetExtension(unittest::optionalgroup_extension_lite ).has_a());
988 EXPECT_TRUE(message.GetExtension(unittest::optional_nested_message_extension_lite ).has_bb());
989 EXPECT_TRUE(message.GetExtension(unittest::optional_foreign_message_extension_lite ).has_c());
990 EXPECT_TRUE(message.GetExtension(unittest::optional_import_message_extension_lite ).has_d());
991 EXPECT_TRUE(message.GetExtension(unittest::optional_public_import_message_extension_lite).has_e());
992 EXPECT_TRUE(message.GetExtension(unittest::optional_lazy_message_extension_lite ).has_bb());
994 EXPECT_TRUE(message.HasExtension(unittest::optional_nested_enum_extension_lite ));
995 EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_enum_extension_lite));
996 EXPECT_TRUE(message.HasExtension(unittest::optional_import_enum_extension_lite ));
999 EXPECT_EQ(101 , message.GetExtension(unittest::optional_int32_extension_lite ));
1000 EXPECT_EQ(102 , message.GetExtension(unittest::optional_int64_extension_lite ));
1001 EXPECT_EQ(103 , message.GetExtension(unittest::optional_uint32_extension_lite ));
1002 EXPECT_EQ(104 , message.GetExtension(unittest::optional_uint64_extension_lite ));
1003 EXPECT_EQ(105 , message.GetExtension(unittest::optional_sint32_extension_lite ));
1004 EXPECT_EQ(106 , message.GetExtension(unittest::optional_sint64_extension_lite ));
1005 message.GetExtension(unittest::optional_fixed32_extension_lite ));
1006 EXPECT_EQ(108 , message.GetExtension(unittest::optional_fixed64_extension_lite ));
1007 EXPECT_EQ(109 , message.GetExtension(unittest::optional_sfixed32_extension_lite));
1008 EXPECT_EQ(110 , message.GetExtension(unittest::optional_sfixed64_extension_lite));
1009 EXPECT_EQ(111 , message.GetExtension(unittest::optional_float_extension_lite ));
1010 EXPECT_EQ(112 , message.GetExtension(unittest::optional_double_extension_lite ));
1011 EXPECT_EQ(true , message.GetExtension(unittest::optional_bool_extension_lite ));
1012 EXPECT_EQ("115", message.GetExtension(unittest::optional_string_extension_lite ));
1013 EXPECT_EQ("116", message.GetExtension(unittest::optional_bytes_extension_lite ));
1015 EXPECT_EQ(117, message.GetExtension(unittest::optionalgroup_extension_lite ).a());
1016 EXPECT_EQ(118, message.GetExtension(unittest::optional_nested_message_extension_lite ).bb());
1017 EXPECT_EQ(119, message.GetExtension(unittest::optional_foreign_message_extension_lite ).c());
1018 EXPECT_EQ(120, message.GetExtension(unittest::optional_import_message_extension_lite ).d());
1019 EXPECT_EQ(126, message.GetExtension(unittest::optional_public_import_message_extension_lite).e());
1020 EXPECT_EQ(127, message.GetExtension(unittest::optional_lazy_message_extension_lite ).bb());
1022 EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.GetExtension(unittest::optional_nested_enum_extension_lite ));
1023 EXPECT_EQ(unittest::FOREIGN_LITE_BAZ , message.GetExtension(unittest::optional_foreign_enum_extension_lite));
1024 EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.GetExtension(unittest::optional_import_enum_extension_lite ));
1029 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite ));
1030 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite ));
1031 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite ));
1032 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite ));
1033 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite ));
1034 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite ));
1035 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
1036 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
1037 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
1038 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
1039 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite ));
1040 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite ));
1041 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite ));
1042 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite ));
1043 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite ));
1045 ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite ));
1046 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
1047 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
1048 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
1049 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite ));
1050 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite ));
1051 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite ));
1052 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite ));
1055 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension_lite , 0));
1056 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension_lite , 0));
1057 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension_lite , 0));
1058 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension_lite , 0));
1059 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension_lite , 0));
1060 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension_lite , 0));
1061 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension_lite , 0));
1062 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension_lite , 0));
1063 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));
1064 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));
1065 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension_lite , 0));
1066 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension_lite , 0));
1067 EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite , 0));
1068 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension_lite , 0));
1069 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension_lite , 0));
1071 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension_lite , 0).a());
1072 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension_lite , 0).bb());
1073 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0).c());
1074 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension_lite , 0).d());
1075 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension_lite , 0).bb());
1077 EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 0));
1078 EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));
1079 EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::repeated_import_enum_extension_lite , 0));
1082 EXPECT_EQ(301 , message.GetExtension(unittest::repeated_int32_extension_lite , 1));
1083 EXPECT_EQ(302 , message.GetExtension(unittest::repeated_int64_extension_lite , 1));
1084 EXPECT_EQ(303 , message.GetExtension(unittest::repeated_uint32_extension_lite , 1));
1085 EXPECT_EQ(304 , message.GetExtension(unittest::repeated_uint64_extension_lite , 1));
1086 EXPECT_EQ(305 , message.GetExtension(unittest::repeated_sint32_extension_lite , 1));
1087 EXPECT_EQ(306 , message.GetExtension(unittest::repeated_sint64_extension_lite , 1));
1088 EXPECT_EQ(307 , message.GetExtension(unittest::repeated_fixed32_extension_lite , 1));
1089 EXPECT_EQ(308 , message.GetExtension(unittest::repeated_fixed64_extension_lite , 1));
1090 EXPECT_EQ(309 , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));
1091 EXPECT_EQ(310 , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));
1092 EXPECT_EQ(311 , message.GetExtension(unittest::repeated_float_extension_lite , 1));
1093 EXPECT_EQ(312 , message.GetExtension(unittest::repeated_double_extension_lite , 1));
1094 EXPECT_EQ(false, message.GetExtension(unittest::repeated_bool_extension_lite , 1));
1095 EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension_lite , 1));
1096 EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension_lite , 1));
1098 EXPECT_EQ(317, message.GetExtension(unittest::repeatedgroup_extension_lite , 1).a());
1099 EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension_lite , 1).bb());
1100 EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1).c());
1101 EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension_lite , 1).d());
1102 EXPECT_EQ(327, message.GetExtension(unittest::repeated_lazy_message_extension_lite , 1).bb());
1104 EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 1));
1105 EXPECT_EQ(unittest::FOREIGN_LITE_BAZ , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));
1106 EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.GetExtension(unittest::repeated_import_enum_extension_lite , 1));
1111 EXPECT_TRUE(message.HasExtension(unittest::default_int32_extension_lite ));
1112 EXPECT_TRUE(message.HasExtension(unittest::default_int64_extension_lite ));
1113 EXPECT_TRUE(message.HasExtension(unittest::default_uint32_extension_lite ));
1114 EXPECT_TRUE(message.HasExtension(unittest::default_uint64_extension_lite ));
1115 EXPECT_TRUE(message.HasExtension(unittest::default_sint32_extension_lite ));
1116 EXPECT_TRUE(message.HasExtension(unittest::default_sint64_extension_lite ));
1117 EXPECT_TRUE(message.HasExtension(unittest::default_fixed32_extension_lite ));
1118 EXPECT_TRUE(message.HasExtension(unittest::default_fixed64_extension_lite ));
1119 EXPECT_TRUE(message.HasExtension(unittest::default_sfixed32_extension_lite));
1120 EXPECT_TRUE(message.HasExtension(unittest::default_sfixed64_extension_lite));
1121 EXPECT_TRUE(message.HasExtension(unittest::default_float_extension_lite ));
1122 EXPECT_TRUE(message.HasExtension(unittest::default_double_extension_lite ));
1123 EXPECT_TRUE(message.HasExtension(unittest::default_bool_extension_lite ));
1124 EXPECT_TRUE(message.HasExtension(unittest::default_string_extension_lite ));
1125 EXPECT_TRUE(message.HasExtension(unittest::default_bytes_extension_lite ));
1127 EXPECT_TRUE(message.HasExtension(unittest::default_nested_enum_extension_lite ));
1128 EXPECT_TRUE(message.HasExtension(unittest::default_foreign_enum_extension_lite));
1129 EXPECT_TRUE(message.HasExtension(unittest::default_import_enum_extension_lite ));
1132 EXPECT_EQ(401 , message.GetExtension(unittest::default_int32_extension_lite ));
1133 EXPECT_EQ(402 , message.GetExtension(unittest::default_int64_extension_lite ));
1134 EXPECT_EQ(403 , message.GetExtension(unittest::default_uint32_extension_lite ));
1135 EXPECT_EQ(404 , message.GetExtension(unittest::default_uint64_extension_lite ));
1136 EXPECT_EQ(405 , message.GetExtension(unittest::default_sint32_extension_lite ));
1137 EXPECT_EQ(406 , message.GetExtension(unittest::default_sint64_extension_lite ));
1138 EXPECT_EQ(407 , message.GetExtension(unittest::default_fixed32_extension_lite ));
1139 EXPECT_EQ(408 , message.GetExtension(unittest::default_fixed64_extension_lite ));
1140 EXPECT_EQ(409 , message.GetExtension(unittest::default_sfixed32_extension_lite));
1141 EXPECT_EQ(410 , message.GetExtension(unittest::default_sfixed64_extension_lite));
1142 EXPECT_EQ(411 , message.GetExtension(unittest::default_float_extension_lite ));
1143 EXPECT_EQ(412 , message.GetExtension(unittest::default_double_extension_lite ));
1144 EXPECT_EQ(false, message.GetExtension(unittest::default_bool_extension_lite ));
1145 EXPECT_EQ("415", message.GetExtension(unittest::default_string_extension_lite ));
1146 EXPECT_EQ("416", message.GetExtension(unittest::default_bytes_extension_lite ));
1148 EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::default_nested_enum_extension_lite ));
1149 EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.GetExtension(unittest::default_foreign_enum_extension_lite));
1150 EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::default_import_enum_extension_lite ));
1153 EXPECT_TRUE(message.HasExtension(unittest::oneof_uint32_extension_lite));
1154 EXPECT_TRUE(message.GetExtension(unittest::oneof_nested_message_extension_lite).has_bb());
1155 EXPECT_TRUE(message.HasExtension(unittest::oneof_string_extension_lite));
1156 EXPECT_TRUE(message.HasExtension(unittest::oneof_bytes_extension_lite));
1158 EXPECT_EQ(601, message.GetExtension(unittest::oneof_uint32_extension_lite));
1159 EXPECT_EQ(602, message.GetExtension(unittest::oneof_nested_message_extension_lite).bb());
1160 EXPECT_EQ("603", message.GetExtension(unittest::oneof_string_extension_lite));
1161 EXPECT_EQ("604", message.GetExtension(unittest::oneof_bytes_extension_lite));
1167 const unittest::TestAllExtensionsLite& message) {
1169 ASSERT_TRUE(message.SerializeToString(&serialized));
1171 EXPECT_EQ(0, message.ByteSize());
1174 EXPECT_FALSE(message.HasExtension(unittest::optional_int32_extension_lite ));
1175 EXPECT_FALSE(message.HasExtension(unittest::optional_int64_extension_lite ));
1176 EXPECT_FALSE(message.HasExtension(unittest::optional_uint32_extension_lite ));
1177 EXPECT_FALSE(message.HasExtension(unittest::optional_uint64_extension_lite ));
1178 EXPECT_FALSE(message.HasExtension(unittest::optional_sint32_extension_lite ));
1179 EXPECT_FALSE(message.HasExtension(unittest::optional_sint64_extension_lite ));
1180 EXPECT_FALSE(message.HasExtension(unittest::optional_fixed32_extension_lite ));
1181 EXPECT_FALSE(message.HasExtension(unittest::optional_fixed64_extension_lite ));
1182 EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed32_extension_lite));
1183 EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed64_extension_lite));
1184 EXPECT_FALSE(message.HasExtension(unittest::optional_float_extension_lite ));
1185 EXPECT_FALSE(message.HasExtension(unittest::optional_double_extension_lite ));
1186 EXPECT_FALSE(message.HasExtension(unittest::optional_bool_extension_lite ));
1187 EXPECT_FALSE(message.HasExtension(unittest::optional_string_extension_lite ));
1188 EXPECT_FALSE(message.HasExtension(unittest::optional_bytes_extension_lite ));
1190 EXPECT_FALSE(message.HasExtension(unittest::optionalgroup_extension_lite ));
1191 EXPECT_FALSE(message.HasExtension(unittest::optional_nested_message_extension_lite ));
1192 EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_message_extension_lite ));
1193 EXPECT_FALSE(message.HasExtension(unittest::optional_import_message_extension_lite ));
1194 EXPECT_FALSE(message.HasExtension(unittest::optional_public_import_message_extension_lite));
1195 EXPECT_FALSE(message.HasExtension(unittest::optional_lazy_message_extension_lite ));
1197 EXPECT_FALSE(message.HasExtension(unittest::optional_nested_enum_extension_lite ));
1198 EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_enum_extension_lite));
1199 EXPECT_FALSE(message.HasExtension(unittest::optional_import_enum_extension_lite ));
1203 EXPECT_EQ(0 , message.GetExtension(unittest::optional_int32_extension_lite ));
1204 EXPECT_EQ(0 , message.GetExtension(unittest::optional_int64_extension_lite ));
1205 EXPECT_EQ(0 , message.GetExtension(unittest::optional_uint32_extension_lite ));
1206 EXPECT_EQ(0 , message.GetExtension(unittest::optional_uint64_extension_lite ));
1207 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sint32_extension_lite ));
1208 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sint64_extension_lite ));
1209 EXPECT_EQ(0 , message.GetExtension(unittest::optional_fixed32_extension_lite ));
1210 EXPECT_EQ(0 , message.GetExtension(unittest::optional_fixed64_extension_lite ));
1211 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sfixed32_extension_lite));
1212 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sfixed64_extension_lite));
1213 EXPECT_EQ(0 , message.GetExtension(unittest::optional_float_extension_lite ));
1214 EXPECT_EQ(0 , message.GetExtension(unittest::optional_double_extension_lite ));
1215 EXPECT_EQ(false, message.GetExtension(unittest::optional_bool_extension_lite ));
1216 EXPECT_EQ("" , message.GetExtension(unittest::optional_string_extension_lite ));
1217 EXPECT_EQ("" , message.GetExtension(unittest::optional_bytes_extension_lite ));
1220 EXPECT_FALSE(message.GetExtension(unittest::optionalgroup_extension_lite ).has_a());
1221 EXPECT_FALSE(message.GetExtension(unittest::optional_nested_message_extension_lite ).has_bb());
1222 EXPECT_FALSE(message.GetExtension(unittest::optional_foreign_message_extension_lite ).has_c());
1223 EXPECT_FALSE(message.GetExtension(unittest::optional_import_message_extension_lite ).has_d());
1224 EXPECT_FALSE(message.GetExtension(unittest::optional_public_import_message_extension_lite).has_e());
1225 EXPECT_FALSE(message
1227 EXPECT_EQ(0, message.GetExtension(unittest::optionalgroup_extension_lite ).a());
1228 EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension_lite ).bb());
1229 EXPECT_EQ(0, message.GetExtension(unittest::optional_foreign_message_extension_lite ).c());
1230 EXPECT_EQ(0, message.GetExtension(unittest::optional_import_message_extension_lite ).d());
1231 EXPECT_EQ(0, message.GetExtension(unittest::optional_public_import_message_extension_lite).e());
1232 EXPECT_EQ(0, message.GetExtension(unittest::optional_lazy_message_extension_lite ).bb());
1235 EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::optional_nested_enum_extension_lite ));
1236 EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.GetExtension(unittest::optional_foreign_enum_extension_lite));
1237 EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::optional_import_enum_extension_lite ));
1241 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int32_extension_lite ));
1242 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int64_extension_lite ));
1243 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint32_extension_lite ));
1244 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint64_extension_lite ));
1245 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint32_extension_lite ));
1246 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint64_extension_lite ));
1247 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
1248 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
1249 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
1250 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
1251 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_float_extension_lite ));
1252 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_double_extension_lite ));
1253 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bool_extension_lite ));
1254 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_extension_lite ));
1255 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bytes_extension_lite ));
1257 EXPECT_EQ(0, message.ExtensionSize(unittest::repeatedgroup_extension_lite ));
1258 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
1259 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
1260 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
1261 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite ));
1262 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite ));
1263 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite ));
1264 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_enum_extension_lite ));
1268 EXPECT_FALSE(message.HasExtension(unittest::default_int32_extension_lite ));
1269 EXPECT_FALSE(message.HasExtension(unittest::default_int64_extension_lite ));
1270 EXPECT_FALSE(message.HasExtension(unittest::default_uint32_extension_lite ));
1271 EXPECT_FALSE(message.HasExtension(unittest::default_uint64_extension_lite ));
1272 EXPECT_FALSE(message.HasExtension(unittest::default_sint32_extension_lite ));
1273 EXPECT_FALSE(message.HasExtension(unittest::default_sint64_extension_lite ));
1274 EXPECT_FALSE(message.HasExtension(unittest::default_fixed32_extension_lite ));
1275 EXPECT_FALSE(message.HasExtension(unittest::default_fixed64_extension_lite ));
1276 EXPECT_FALSE(message.HasExtension(unittest::default_sfixed32_extension_lite));
1277 EXPECT_FALSE(message.HasExtension(unittest::default_sfixed64_extension_lite));
1278 EXPECT_FALSE(message.HasExtension(unittest::default_float_extension_lite ));
1279 EXPECT_FALSE(message.HasExtension(unittest::default_double_extension_lite ));
1280 EXPECT_FALSE(message.HasExtension(unittest::default_bool_extension_lite ));
1281 EXPECT_FALSE(message.HasExtension(unittest::default_string_extension_lite ));
1282 EXPECT_FALSE(message.HasExtension(unittest::default_bytes_extension_lite ));
1284 EXPECT_FALSE(message.HasExtension(unittest::default_nested_enum_extension_lite ));
1285 EXPECT_FALSE(message.HasExtension(unittest::default_foreign_enum_extension_lite));
1286 EXPECT_FALSE(message.HasExtension(unittest::default_import_enum_extension_lite ));
1290 EXPECT_EQ( 41 , message.GetExtension(unittest::default_int32_extension_lite ));
1291 EXPECT_EQ( 42 , message.GetExtension(unittest::default_int64_extension_lite ));
1292 EXPECT_EQ( 43 , message.GetExtension(unittest::default_uint32_extension_lite ));
1293 EXPECT_EQ( 44 , message.GetExtension(unittest::default_uint64_extension_lite ));
1294 EXPECT_EQ(-45 , message.GetExtension(unittest::default_sint32_extension_lite ));
1295 EXPECT_EQ( 46 , message.GetExtension(unittest::default_sint64_extension_lite ));
1296 EXPECT_EQ( 47 , message.GetExtension(unittest::default_fixed32_extension_lite ));
1297 EXPECT_EQ( 48 , message.GetExtension(unittest::default_fixed64_extension_lite ));
1298 EXPECT_EQ( 49 , message.GetExtension(unittest::default_sfixed32_extension_lite));
1299 EXPECT_EQ(-50 , message.GetExtension(unittest::default_sfixed64_extension_lite));
1300 EXPECT_EQ( 51.5 , message.GetExtension(unittest::default_float_extension_lite ));
1301 EXPECT_EQ( 52e3 , message.GetExtension(unittest::default_double_extension_lite ));
1302 EXPECT_EQ(true , message.GetExtension(unittest::default_bool_extension_lite ));
1303 EXPECT_EQ("hello", message.GetExtension(unittest::default_string_extension_lite ));
1304 EXPECT_EQ("world", message.GetExtension(unittest::default_bytes_extension_lite ));
1306 EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::default_nested_enum_extension_lite ));
1307 EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.GetExtension(unittest::default_foreign_enum_extension_lite));
1308 EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::default_import_enum_extension_lite ));
1311 EXPECT_FALSE(message.HasExtension(unittest::oneof_uint32_extension_lite));
1312 EXPECT_FALSE(message.GetExtension(unittest::oneof_nested_message_extension_lite).has_bb());
1313 EXPECT_FALSE(message.HasExtension(unittest::oneof_string_extension_lite));
1314 EXPECT_FALSE(message.HasExtension(unittest::oneof_bytes_extension_lite));
1320 const unittest::TestAllExtensionsLite& message) {
1324 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite ));
1325 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite ));
1326 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite ));
1327 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite ));
1328 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite ));
1329 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite ));
1330 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension_lite ));
1331 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension_lite ));
1332 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));
1333 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));
1334 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite ));
1335 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite ));
1336 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite ));
1337 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite ));
1338 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite ));
1340 ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite ));
1341 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension_lite ));
1342 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite));
1343 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension_lite ));
1344 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite ));
1345 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite ));
1346 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite ));
1347 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite ));
1350 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension_lite , 0));
1351 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension_lite , 0));
1352 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension_lite , 0));
1353 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension_lite , 0));
1354 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension_lite , 0));
1355 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension_lite , 0));
1356 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension_lite , 0));
1357 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension_lite , 0));
1358 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));
1359 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));
1360 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension_lite , 0));
1361 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension_lite , 0));
1362 EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite , 0));
1363 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension_lite , 0));
1364 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension_lite , 0));
1366 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension_lite , 0).a());
1367 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension_lite , 0).bb());
1368 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0).c());
1369 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension_lite , 0).d());
1370 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension_lite , 0).bb());
1372 EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 0));
1373 EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));
1374 EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::repeated_import_enum_extension_lite , 0));
1378 EXPECT_EQ(501 , message.GetExtension(unittest::repeated_int32_extension_lite , 1));
1379 EXPECT_EQ(502 , message.GetExtension(unittest::repeated_int64_extension_lite , 1));
1380 EXPECT_EQ(503 , message.GetExtension(unittest::repeated_uint32_extension_lite , 1));
1381 EXPECT_EQ(504 , message.GetExtension(unittest::repeated_uint64_extension_lite , 1));
1382 EXPECT_EQ(505 , message.GetExtension(unittest::repeated_sint32_extension_lite , 1));
1383 EXPECT_EQ(506 , message.GetExtension(unittest::repeated_sint64_extension_lite , 1));
1384 EXPECT_EQ(507 , message.GetExtension(unittest::repeated_fixed32_extension_lite , 1));
1385 EXPECT_EQ(508 , message.GetExtension(unittest::repeated_fixed64_extension_lite , 1));
1386 EXPECT_EQ(509 , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));
1387 EXPECT_EQ(510 , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));
1388 EXPECT_EQ(511 , message.GetExtension(unittest::repeated_float_extension_lite , 1));
1389 EXPECT_EQ(512 , message.GetExtension(unittest::repeated_double_extension_lite , 1));
1390 EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite , 1));
1391 EXPECT_EQ("515", message.GetExtension(unittest::repeated_string_extension_lite , 1));
1392 EXPECT_EQ("516", message.GetExtension(unittest::repeated_bytes_extension_lite , 1));
1394 EXPECT_EQ(517, message.GetExtension(unittest::repeatedgroup_extension_lite , 1).a());
1395 EXPECT_EQ(518, message.GetExtension(unittest::repeated_nested_message_extension_lite , 1).bb());
1396 EXPECT_EQ(519, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1).c());
1397 EXPECT_EQ(520, message.GetExtension(unittest::repeated_import_message_extension_lite , 1).d());
1398 EXPECT_EQ(527, message.GetExtension(unittest::repeated_lazy_message_extension_lite , 1).bb());
1400 EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 1));
1401 EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));
1402 EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::repeated_import_enum_extension_lite , 1));
1409 unittest::TestPackedExtensionsLite* message) {
1410 message->AddExtension(unittest::packed_int32_extension_lite , 601);
1411 message->AddExtension(unittest::packed_int64_extension_lite , 602);
1412 message->AddExtension(unittest::packed_uint32_extension_lite , 603);
1413 message->AddExtension(unittest::packed_uint64_extension_lite , 604);
1414 message->AddExtension(unittest::packed_sint32_extension_lite , 605);
1415 message->AddExtension(unittest::packed_sint64_extension_lite , 606);
1416 message->AddExtension(unittest::packed_fixed32_extension_lite , 607);
1417 message->AddExtension(unittest::packed_fixed64_extension_lite , 608);
1418 message->AddExtension(unittest::packed_sfixed32_extension_lite, 609);
1419 message->AddExtension(unittest::packed_sfixed64_extension_lite, 610);
1420 message->AddExtension(unittest::packed_float_extension_lite , 611);
1421 message->AddExtension(unittest::packed_double_extension_lite , 612);
1422 message->AddExtension(unittest::packed_bool_extension_lite , true);
1423 message->AddExtension(unittest::packed_enum_extension_lite, unittest::FOREIGN_LITE_BAR);
1425 message->AddExtension(unittest::packed_int32_extension_lite , 701);
1426 message->AddExtension(unittest::packed_int64_extension_lite , 702);
1427 message->AddExtension(unittest::packed_uint32_extension_lite , 703);
1428 message->AddExtension(unittest::packed_uint64_extension_lite , 704);
1429 message->AddExtension(unittest::packed_sint32_extension_lite , 705);
1430 message->AddExtension(unittest::packed_sint64_extension_lite , 706);
1431 message->AddExtension(unittest::packed_fixed32_extension_lite , 707);
1432 message->AddExtension(unittest::packed_fixed64_extension_lite , 708);
1433 message->AddExtension(unittest::packed_sfixed32_extension_lite, 709);
1434 message->AddExtension(unittest::packed_sfixed64_extension_lite, 710);
1435 message->AddExtension(unittest::packed_float_extension_lite , 711);
1436 message->AddExtension(unittest::packed_double_extension_lite , 712);
1437 message->AddExtension(unittest::packed_bool_extension_lite , false);
1438 message->AddExtension(unittest::packed_enum_extension_lite, unittest::FOREIGN_LITE_BAZ);
1444 unittest::TestPackedExtensionsLite* message) {
1445 message->SetExtension(unittest::packed_int32_extension_lite , 1, 801);
1446 message->SetExtension(unittest::packed_int64_extension_lite , 1, 802);
1447 message->SetExtension(unittest::packed_uint32_extension_lite , 1, 803);
1448 message->SetExtension(unittest::packed_uint64_extension_lite , 1, 804);
1449 message->SetExtension(unittest::packed_sint32_extension_lite , 1, 805);
1450 message->SetExtension(unittest::packed_sint64_extension_lite , 1, 806);
1451 message->SetExtension(unittest::packed_fixed32_extension_lite , 1, 807);
1452 message->SetExtension(unittest::packed_fixed64_extension_lite , 1, 808);
1453 message->SetExtension(unittest::packed_sfixed32_extension_lite, 1, 809);
1454 message->SetExtension(unittest::packed_sfixed64_extension_lite, 1, 810);
1455 message->SetExtension(unittest::packed_float_extension_lite , 1, 811);
1456 message->SetExtension(unittest::packed_double_extension_lite , 1, 812);
1457 message->SetExtension(unittest::packed_bool_extension_lite , 1, true);
1458 message->SetExtension(unittest::packed_enum_extension_lite , 1,
1465 const unittest::TestPackedExtensionsLite& message) {
1466 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite ));
1467 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite ));
1468 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite ));
1469 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite ));
1470 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite ));
1471 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite ));
1472 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
1473 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
1474 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
1475 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
1476 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite ));
1477 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite ));
1478 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite ));
1479 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite ));
1481 EXPECT_EQ(601 , message.GetExtension(unittest::packed_int32_extension_lite , 0));
1482 EXPECT_EQ(602 , message.GetExtension(unittest::packed_int64_extension_lite , 0));
1483 EXPECT_EQ(603 , message.GetExtension(unittest::packed_uint32_extension_lite , 0));
1484 EXPECT_EQ(604 , message.GetExtension(unittest::packed_uint64_extension_lite , 0));
1485 EXPECT_EQ(605 , message.GetExtension(unittest::packed_sint32_extension_lite , 0));
1486 EXPECT_EQ(606 , message.GetExtension(unittest::packed_sint64_extension_lite , 0));
1487 EXPECT_EQ(607 , message.GetExtension(unittest::packed_fixed32_extension_lite , 0));
1488 EXPECT_EQ(608 , message.GetExtension(unittest::packed_fixed64_extension_lite , 0));
1489 EXPECT_EQ(609 , message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));
1490 EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));
1491 EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension_lite , 0));
1492 EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension_lite , 0));
1493 EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite , 0));
1495 message.GetExtension(unittest::packed_enum_extension_lite, 0));
1496 EXPECT_EQ(701 , message.GetExtension(unittest::packed_int32_extension_lite , 1));
1497 EXPECT_EQ(702 , message.GetExtension(unittest::packed_int64_extension_lite , 1));
1498 EXPECT_EQ(703 , message.GetExtension(unittest::packed_uint32_extension_lite , 1));
1499 EXPECT_EQ(704 , message.GetExtension(unittest::packed_uint64_extension_lite , 1));
1500 EXPECT_EQ(705 , message.GetExtension(unittest::packed_sint32_extension_lite , 1));
1501 EXPECT_EQ(706 , message.GetExtension(unittest::packed_sint64_extension_lite , 1));
1502 EXPECT_EQ(707 , message.GetExtension(unittest::packed_fixed32_extension_lite , 1));
1503 EXPECT_EQ(708 , message.GetExtension(unittest::packed_fixed64_extension_lite , 1));
1504 EXPECT_EQ(709 , message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));
1505 EXPECT_EQ(710 , message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));
1506 EXPECT_EQ(711 , message.GetExtension(unittest::packed_float_extension_lite , 1));
1507 EXPECT_EQ(712 , message.GetExtension(unittest::packed_double_extension_lite , 1));
1508 EXPECT_EQ(false, message.GetExtension(unittest::packed_bool_extension_lite , 1));
1510 message.GetExtension(unittest::packed_enum_extension_lite, 1));
1516 const unittest::TestPackedExtensionsLite& message) {
1517 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int32_extension_lite ));
1518 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int64_extension_lite ));
1519 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint32_extension_lite ));
1520 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint64_extension_lite ));
1521 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint32_extension_lite ));
1522 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint64_extension_lite ));
1523 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
1524 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
1525 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
1526 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
1527 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_float_extension_lite ));
1528 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_double_extension_lite ));
1529 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_bool_extension_lite ));
1530 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_enum_extension_lite ));
1536 const unittest::TestPackedExtensionsLite& message) {
1537 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite ));
1538 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite ));
1539 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite ));
1540 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite ));
1541 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite ));
1542 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite ));
1543 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite ));
1544 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite ));
1545 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));
1546 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));
1547 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite ));
1548 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite ));
1549 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite ));
1550 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite ));
1551 EXPECT_EQ(601 , message.GetExtension(unittest::packed_int32_extension_lite , 0));
1552 EXPECT_EQ(602 , message.GetExtension(unittest::packed_int64_extension_lite , 0));
1553 EXPECT_EQ(603 , message.GetExtension(unittest::packed_uint32_extension_lite , 0));
1554 EXPECT_EQ(604 , message.GetExtension(unittest::packed_uint64_extension_lite , 0));
1555 EXPECT_EQ(605 , message.GetExtension(unittest::packed_sint32_extension_lite , 0));
1556 EXPECT_EQ(606 , message.GetExtension(unittest::packed_sint64_extension_lite , 0));
1557 EXPECT_EQ(607 , message.GetExtension(unittest::packed_fixed32_extension_lite , 0));
1558 EXPECT_EQ(608 , message.GetExtension(unittest::packed_fixed64_extension_lite , 0));
1559 EXPECT_EQ(609 , message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));
1560 EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));
1561 EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension_lite , 0));
1562 EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension_lite , 0));
1563 EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite , 0));
1565 message.GetExtension(unittest::packed_enum_extension_lite, 0));
1568 EXPECT_EQ(801 , message.GetExtension(unittest::packed_int32_extension_lite , 1));
1569 EXPECT_EQ(802 , message.GetExtension(unittest::packed_int64_extension_lite , 1));
1570 EXPECT_EQ(803 , message.GetExtension(unittest::packed_uint32_extension_lite , 1));
1571 EXPECT_EQ(804 , message.GetExtension(unittest::packed_uint64_extension_lite , 1));
1572 EXPECT_EQ(805 , message.GetExtension(unittest::packed_sint32_extension_lite , 1));
1573 EXPECT_EQ(806 , message.GetExtension(unittest::packed_sint64_extension_lite , 1));
1574 EXPECT_EQ(807 , message.GetExtension(unittest::packed_fixed32_extension_lite , 1));
1575 EXPECT_EQ(808 , message.GetExtension(unittest::packed_fixed64_extension_lite , 1));
1576 EXPECT_EQ(809 , message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));
1577 EXPECT_EQ(810 , message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));
1578 EXPECT_EQ(811 , message.GetExtension(unittest::packed_float_extension_lite , 1));
1579 EXPECT_EQ(812 , message.GetExtension(unittest::packed_double_extension_lite , 1));
1580 EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite , 1));
1582 message.GetExtension(unittest::packed_enum_extension_lite, 1));
