Lines Matching refs:message
43 #include <google/protobuf/message.h>
52 void TestUtil::SetAllFields(unittest::TestAllTypes* message) {
53 SetOptionalFields(message);
54 AddRepeatedFields1(message);
55 AddRepeatedFields2(message);
56 SetDefaultFields(message);
59 void TestUtil::SetOptionalFields(unittest::TestAllTypes* message) {
60 message->set_optional_int32 (101);
61 message->set_optional_int64 (102);
62 message->set_optional_uint32 (103);
63 message->set_optional_uint64 (104);
64 message->set_optional_sint32 (105);
65 message->set_optional_sint64 (106);
66 message->set_optional_fixed32 (107);
67 message->set_optional_fixed64 (108);
68 message->set_optional_sfixed32(109);
69 message->set_optional_sfixed64(110);
70 message->set_optional_float (111);
71 message->set_optional_double (112);
72 message->set_optional_bool (true);
73 message->set_optional_string ("115");
74 message->set_optional_bytes ("116");
76 message->mutable_optionalgroup ()->set_a(117);
77 message->mutable_optional_nested_message ()->set_bb(118);
78 message->mutable_optional_foreign_message ()->set_c(119);
79 message->mutable_optional_import_message ()->set_d(120);
80 message->mutable_optional_public_import_message()->set_e(126);
81 message->mutable_optional_lazy_message ()->set_bb(127);
83 message->set_optional_nested_enum (unittest::TestAllTypes::BAZ);
84 message->set_optional_foreign_enum(unittest::FOREIGN_BAZ );
85 message->set_optional_import_enum (unittest_import::IMPORT_BAZ);
90 message->GetReflection()->SetString(
91 message,
92 message->GetDescriptor()->FindFieldByName("optional_string_piece"),
94 message->GetReflection()->SetString(
95 message,
96 message->GetDescriptor()->FindFieldByName("optional_cord"),
103 void TestUtil::AddRepeatedFields1(unittest::TestAllTypes* message) {
104 message->add_repeated_int32 (201);
105 message->add_repeated_int64 (202);
106 message->add_repeated_uint32 (203);
107 message->add_repeated_uint64 (204);
108 message->add_repeated_sint32 (205);
109 message->add_repeated_sint64 (206);
110 message->add_repeated_fixed32 (207);
111 message->add_repeated_fixed64 (208);
112 message->add_repeated_sfixed32(209);
113 message->add_repeated_sfixed64(210);
114 message->add_repeated_float (211);
115 message->add_repeated_double (212);
116 message->add_repeated_bool (true);
117 message->add_repeated_string ("215");
118 message->add_repeated_bytes ("216");
120 message->add_repeatedgroup ()->set_a(217);
121 message->add_repeated_nested_message ()->set_bb(218);
122 message->add_repeated_foreign_message()->set_c(219);
123 message->add_repeated_import_message ()->set_d(220);
124 message->add_repeated_lazy_message ()->set_bb(227);
126 message->add_repeated_nested_enum (unittest::TestAllTypes::BAR);
127 message->add_repeated_foreign_enum(unittest::FOREIGN_BAR );
128 message->add_repeated_import_enum (unittest_import::IMPORT_BAR);
131 message->GetReflection()->AddString(
132 message,
133 message->GetDescriptor()->FindFieldByName("repeated_string_piece"),
135 message->GetReflection()->AddString(
136 message,
137 message->GetDescriptor()->FindFieldByName("repeated_cord"),
142 void TestUtil::AddRepeatedFields2(unittest::TestAllTypes* message) {
144 message->add_repeated_int32 (301);
145 message->add_repeated_int64 (302);
146 message->add_repeated_uint32 (303);
147 message->add_repeated_uint64 (304);
148 message->add_repeated_sint32 (305);
149 message->add_repeated_sint64 (306);
150 message->add_repeated_fixed32 (307);
151 message->add_repeated_fixed64 (308);
152 message->add_repeated_sfixed32(309);
153 message->add_repeated_sfixed64(310);
154 message->add_repeated_float (311);
155 message->add_repeated_double (312);
156 message->add_repeated_bool (false);
157 message->add_repeated_string ("315");
158 message->add_repeated_bytes ("316");
160 message->add_repeatedgroup ()->set_a(317);
161 message->add_repeated_nested_message ()->set_bb(318);
162 message->add_repeated_foreign_message()->set_c(319);
163 message->add_repeated_import_message ()->set_d(320);
164 message->add_repeated_lazy_message ()->set_bb(327);
166 message->add_repeated_nested_enum (unittest::TestAllTypes::BAZ);
167 message->add_repeated_foreign_enum(unittest::FOREIGN_BAZ );
168 message->add_repeated_import_enum (unittest_import::IMPORT_BAZ);
171 message->GetReflection()->AddString(
172 message,
173 message->GetDescriptor()->FindFieldByName("repeated_string_piece"),
175 message->GetReflection()->AddString(
176 message,
177 message->GetDescriptor()->FindFieldByName("repeated_cord"),
184 void TestUtil::SetDefaultFields(unittest::TestAllTypes* message) {
185 message->set_default_int32 (401);
186 message->set_default_int64 (402);
187 message->set_default_uint32 (403);
188 message->set_default_uint64 (404);
189 message->set_default_sint32 (405);
190 message->set_default_sint64 (406);
191 message->set_default_fixed32 (407);
192 message->set_default_fixed64 (408);
193 message->set_default_sfixed32(409);
194 message->set_default_sfixed64(410);
195 message->set_default_float (411);
196 message->set_default_double (412);
197 message->set_default_bool (false);
198 message->set_default_string ("415");
199 message->set_default_bytes ("416");
201 message->set_default_nested_enum (unittest::TestAllTypes::FOO);
202 message->set_default_foreign_enum(unittest::FOREIGN_FOO );
203 message->set_default_import_enum (unittest_import::IMPORT_FOO);
206 message->GetReflection()->SetString(
207 message,
208 message->GetDescriptor()->FindFieldByName("default_string_piece"),
210 message->GetReflection()->SetString(
211 message,
212 message->GetDescriptor()->FindFieldByName("default_cord"),
219 void TestUtil::ModifyRepeatedFields(unittest::TestAllTypes* message) {
220 message->set_repeated_int32 (1, 501);
221 message->set_repeated_int64 (1, 502);
222 message->set_repeated_uint32 (1, 503);
223 message->set_repeated_uint64 (1, 504);
224 message->set_repeated_sint32 (1, 505);
225 message->set_repeated_sint64 (1, 506);
226 message->set_repeated_fixed32 (1, 507);
227 message->set_repeated_fixed64 (1, 508);
228 message->set_repeated_sfixed32(1, 509);
229 message->set_repeated_sfixed64(1, 510);
230 message->set_repeated_float (1, 511);
231 message->set_repeated_double (1, 512);
232 message->set_repeated_bool (1, true);
233 message->set_repeated_string (1, "515");
234 message->set_repeated_bytes (1, "516");
236 message->mutable_repeatedgroup (1)->set_a(517);
237 message->mutable_repeated_nested_message (1)->set_bb(518);
238 message->mutable_repeated_foreign_message(1)->set_c(519);
239 message->mutable_repeated_import_message (1)->set_d(520);
240 message->mutable_repeated_lazy_message (1)->set_bb(527);
242 message->set_repeated_nested_enum (1, unittest::TestAllTypes::FOO);
243 message->set_repeated_foreign_enum(1, unittest::FOREIGN_FOO );
244 message->set_repeated_import_enum (1, unittest_import::IMPORT_FOO);
247 message->GetReflection()->SetRepeatedString(
248 message,
249 message->GetDescriptor()->FindFieldByName("repeated_string_piece"),
251 message->GetReflection()->SetRepeatedString(
252 message,
253 message->GetDescriptor()->FindFieldByName("repeated_cord"),
260 void TestUtil::ExpectAllFieldsSet(const unittest::TestAllTypes& message) {
261 EXPECT_TRUE(message.has_optional_int32 ());
262 EXPECT_TRUE(message.has_optional_int64 ());
263 EXPECT_TRUE(message.has_optional_uint32 ());
264 EXPECT_TRUE(message.has_optional_uint64 ());
265 EXPECT_TRUE(message.has_optional_sint32 ());
266 EXPECT_TRUE(message.has_optional_sint64 ());
267 EXPECT_TRUE(message.has_optional_fixed32 ());
268 EXPECT_TRUE(message.has_optional_fixed64 ());
269 EXPECT_TRUE(message.has_optional_sfixed32());
270 EXPECT_TRUE(message.has_optional_sfixed64());
271 EXPECT_TRUE(message.has_optional_float ());
272 EXPECT_TRUE(message.has_optional_double ());
273 EXPECT_TRUE(message.has_optional_bool ());
274 EXPECT_TRUE(message.has_optional_string ());
275 EXPECT_TRUE(message.has_optional_bytes ());
277 EXPECT_TRUE(message.has_optionalgroup ());
278 EXPECT_TRUE(message.has_optional_nested_message ());
279 EXPECT_TRUE(message.has_optional_foreign_message ());
280 EXPECT_TRUE(message.has_optional_import_message ());
281 EXPECT_TRUE(message.has_optional_public_import_message());
282 EXPECT_TRUE(message.has_optional_lazy_message ());
284 EXPECT_TRUE(message.optionalgroup ().has_a());
285 EXPECT_TRUE(message.optional_nested_message ().has_bb());
286 EXPECT_TRUE(message.optional_foreign_message ().has_c());
287 EXPECT_TRUE(message.optional_import_message ().has_d());
288 EXPECT_TRUE(message.optional_public_import_message().has_e());
289 EXPECT_TRUE(message.optional_lazy_message ().has_bb());
291 EXPECT_TRUE(message.has_optional_nested_enum ());
292 EXPECT_TRUE(message.has_optional_foreign_enum());
293 EXPECT_TRUE(message.has_optional_import_enum ());
296 EXPECT_TRUE(message.has_optional_string_piece());
297 EXPECT_TRUE(message.has_optional_cord());
300 EXPECT_EQ(101 , message.optional_int32 ());
301 EXPECT_EQ(102 , message.optional_int64 ());
302 EXPECT_EQ(103 , message.optional_uint32 ());
303 EXPECT_EQ(104 , message.optional_uint64 ());
304 EXPECT_EQ(105 , message.optional_sint32 ());
305 EXPECT_EQ(106 , message.optional_sint64 ());
306 EXPECT_EQ(107 , message.optional_fixed32 ());
307 EXPECT_EQ(108 , message.optional_fixed64 ());
308 EXPECT_EQ(109 , message.optional_sfixed32());
309 EXPECT_EQ(110 , message.optional_sfixed64());
310 EXPECT_EQ(111 , message.optional_float ());
311 EXPECT_EQ(112 , message.optional_double ());
312 EXPECT_TRUE( message.optional_bool ());
313 EXPECT_EQ("115", message.optional_string ());
314 EXPECT_EQ("116", message.optional_bytes ());
316 EXPECT_EQ(117, message.optionalgroup ().a());
317 EXPECT_EQ(118, message.optional_nested_message ().bb());
318 EXPECT_EQ(119, message.optional_foreign_message ().c());
319 EXPECT_EQ(120, message.optional_import_message ().d());
320 EXPECT_EQ(126, message.optional_public_import_message ().e());
321 EXPECT_EQ(127, message.optional_lazy_message ().bb());
323 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.optional_nested_enum ());
324 EXPECT_EQ(unittest::FOREIGN_BAZ , message.optional_foreign_enum());
325 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.optional_import_enum ());
330 ASSERT_EQ(2, message.repeated_int32_size ());
331 ASSERT_EQ(2, message.repeated_int64_size ());
332 ASSERT_EQ(2, message.repeated_uint32_size ());
333 ASSERT_EQ(2, message.repeated_uint64_size ());
334 ASSERT_EQ(2, message.repeated_sint32_size ());
335 ASSERT_EQ(2, message.repeated_sint64_size ());
336 ASSERT_EQ(2, message.repeated_fixed32_size ());
337 ASSERT_EQ(2, message.repeated_fixed64_size ());
338 ASSERT_EQ(2, message.repeated_sfixed32_size());
339 ASSERT_EQ(2, message.repeated_sfixed64_size());
340 ASSERT_EQ(2, message.repeated_float_size ());
341 ASSERT_EQ(2, message.repeated_double_size ());
342 ASSERT_EQ(2, message.repeated_bool_size ());
343 ASSERT_EQ(2, message.repeated_string_size ());
344 ASSERT_EQ(2, message.repeated_bytes_size ());
346 ASSERT_EQ(2, message.repeatedgroup_size ());
347 ASSERT_EQ(2, message.repeated_nested_message_size ());
348 ASSERT_EQ(2, message.repeated_foreign_message_size());
349 ASSERT_EQ(2, message.repeated_import_message_size ());
350 ASSERT_EQ(2, message.repeated_lazy_message_size ());
351 ASSERT_EQ(2, message.repeated_nested_enum_size ());
352 ASSERT_EQ(2, message.repeated_foreign_enum_size ());
353 ASSERT_EQ(2, message.repeated_import_enum_size ());
356 ASSERT_EQ(2, message.repeated_string_piece_size());
357 ASSERT_EQ(2, message.repeated_cord_size());
360 EXPECT_EQ(201 , message.repeated_int32 (0));
361 EXPECT_EQ(202 , message.repeated_int64 (0));
362 EXPECT_EQ(203 , message.repeated_uint32 (0));
363 EXPECT_EQ(204 , message.repeated_uint64 (0));
364 EXPECT_EQ(205 , message.repeated_sint32 (0));
365 EXPECT_EQ(206 , message.repeated_sint64 (0));
366 EXPECT_EQ(207 , message.repeated_fixed32 (0));
367 EXPECT_EQ(208 , message.repeated_fixed64 (0));
368 EXPECT_EQ(209 , message.repeated_sfixed32(0));
369 EXPECT_EQ(210 , message.repeated_sfixed64(0));
370 EXPECT_EQ(211 , message.repeated_float (0));
371 EXPECT_EQ(212 , message.repeated_double (0));
372 EXPECT_TRUE( message.repeated_bool (0));
373 EXPECT_EQ("215", message.repeated_string (0));
374 EXPECT_EQ("216", message.repeated_bytes (0));
376 EXPECT_EQ(217, message.repeatedgroup (0).a());
377 EXPECT_EQ(218, message.repeated_nested_message (0).bb());
378 EXPECT_EQ(219, message.repeated_foreign_message(0).c());
379 EXPECT_EQ(220, message.repeated_import_message (0).d());
380 EXPECT_EQ(227, message.repeated_lazy_message (0).bb());
383 EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (0));
384 EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(0));
385 EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (0));
387 EXPECT_EQ(301 , message.repeated_int32 (1));
388 EXPECT_EQ(302 , message.repeated_int64 (1));
389 EXPECT_EQ(303 , message.repeated_uint32 (1));
390 EXPECT_EQ(304 , message.repeated_uint64 (1));
391 EXPECT_EQ(305 , message.repeated_sint32 (1));
392 EXPECT_EQ(306 , message.repeated_sint64 (1));
393 EXPECT_EQ(307 , message.repeated_fixed32 (1));
394 EXPECT_EQ(308 , message.repeated_fixed64 (1));
395 EXPECT_EQ(309 , message.repeated_sfixed32(1));
396 EXPECT_EQ(310 , message.repeated_sfixed64(1));
397 EXPECT_EQ(311 , message.repeated_float (1));
398 EXPECT_EQ(312 , message.repeated_double (1));
399 EXPECT_FALSE( message.repeated_bool (1));
400 EXPECT_EQ("315", message.repeated_string (1));
401 EXPECT_EQ("316", message.repeated_bytes (1));
403 EXPECT_EQ(317, message.repeatedgroup (1).a());
404 EXPECT_EQ(318, message.repeated_nested_message (1).bb());
405 EXPECT_EQ(319, message.repeated_foreign_message(1).c());
406 EXPECT_EQ(320, message.repeated_import_message (1).d());
407 EXPECT_EQ(327, message.repeated_lazy_message (1).bb());
409 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.repeated_nested_enum (1));
410 EXPECT_EQ(unittest::FOREIGN_BAZ , message.repeated_foreign_enum(1));
411 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.repeated_import_enum (1));
416 EXPECT_TRUE(message.has_default_int32 ());
417 EXPECT_TRUE(message.has_default_int64 ());
418 EXPECT_TRUE(message.has_default_uint32 ());
419 EXPECT_TRUE(message.has_default_uint64 ());
420 EXPECT_TRUE(message.has_default_sint32 ());
421 EXPECT_TRUE(message.has_default_sint64 ());
422 EXPECT_TRUE(message.has_default_fixed32 ());
423 EXPECT_TRUE(message.has_default_fixed64 ());
424 EXPECT_TRUE(message.has_default_sfixed32());
425 EXPECT_TRUE(message.has_default_sfixed64());
426 EXPECT_TRUE(message.has_default_float ());
427 EXPECT_TRUE(message.has_default_double ());
428 EXPECT_TRUE(message.has_default_bool ());
429 EXPECT_TRUE(message.has_default_string ());
430 EXPECT_TRUE(message.has_default_bytes ());
432 EXPECT_TRUE(message.has_default_nested_enum ());
433 EXPECT_TRUE(message.has_default_foreign_enum());
434 EXPECT_TRUE(message.has_default_import_enum ());
437 EXPECT_EQ(401 , message.default_int32 ());
438 EXPECT_EQ(402 , message.default_int64 ());
439 EXPECT_EQ(403 , message.default_uint32 ());
440 EXPECT_EQ(404 , message.default_uint64 ());
441 EXPECT_EQ(405 , message.default_sint32 ());
442 EXPECT_EQ(406 , message.default_sint64 ());
443 EXPECT_EQ(407 , message.default_fixed32 ());
444 EXPECT_EQ(408 , message.default_fixed64 ());
445 EXPECT_EQ(409 , message.default_sfixed32());
446 EXPECT_EQ(410 , message.default_sfixed64());
447 EXPECT_EQ(411 , message.default_float ());
448 EXPECT_EQ(412 , message.default_double ());
449 EXPECT_FALSE( message.default_bool ());
450 EXPECT_EQ("415", message.default_string ());
451 EXPECT_EQ("416", message.default_bytes ());
453 EXPECT_EQ(unittest::TestAllTypes::FOO, message.default_nested_enum ());
454 EXPECT_EQ(unittest::FOREIGN_FOO , message.default_foreign_enum());
455 EXPECT_EQ(unittest_import::IMPORT_FOO, message.default_import_enum ());
461 void TestUtil::ExpectClear(const unittest::TestAllTypes& message) {
463 EXPECT_FALSE(message.has_optional_int32 ());
464 EXPECT_FALSE(message.has_optional_int64 ());
465 EXPECT_FALSE(message.has_optional_uint32 ());
466 EXPECT_FALSE(message.has_optional_uint64 ());
467 EXPECT_FALSE(message.has_optional_sint32 ());
468 EXPECT_FALSE(message.has_optional_sint64 ());
469 EXPECT_FALSE(message.has_optional_fixed32 ());
470 EXPECT_FALSE(message.has_optional_fixed64 ());
471 EXPECT_FALSE(message.has_optional_sfixed32());
472 EXPECT_FALSE(message.has_optional_sfixed64());
473 EXPECT_FALSE(message.has_optional_float ());
474 EXPECT_FALSE(message.has_optional_double ());
475 EXPECT_FALSE(message.has_optional_bool ());
476 EXPECT_FALSE(message.has_optional_string ());
477 EXPECT_FALSE(message.has_optional_bytes ());
479 EXPECT_FALSE(message.has_optionalgroup ());
480 EXPECT_FALSE(message.has_optional_nested_message ());
481 EXPECT_FALSE(message.has_optional_foreign_message ());
482 EXPECT_FALSE(message.has_optional_import_message ());
483 EXPECT_FALSE(message.has_optional_public_import_message());
484 EXPECT_FALSE(message.has_optional_lazy_message ());
486 EXPECT_FALSE(message.has_optional_nested_enum ());
487 EXPECT_FALSE(message.has_optional_foreign_enum());
488 EXPECT_FALSE(message.has_optional_import_enum ());
490 EXPECT_FALSE(message.has_optional_string_piece());
491 EXPECT_FALSE(message.has_optional_cord());
494 EXPECT_EQ(0 , message.optional_int32 ());
495 EXPECT_EQ(0 , message.optional_int64 ());
496 EXPECT_EQ(0 , message.optional_uint32 ());
497 EXPECT_EQ(0 , message.optional_uint64 ());
498 EXPECT_EQ(0 , message.optional_sint32 ());
499 EXPECT_EQ(0 , message.optional_sint64 ());
500 EXPECT_EQ(0 , message.optional_fixed32 ());
501 EXPECT_EQ(0 , message.optional_fixed64 ());
502 EXPECT_EQ(0 , message.optional_sfixed32());
503 EXPECT_EQ(0 , message.optional_sfixed64());
504 EXPECT_EQ(0 , message.optional_float ());
505 EXPECT_EQ(0 , message.optional_double ());
506 EXPECT_FALSE( message.optional_bool ());
507 EXPECT_EQ("" , message.optional_string ());
508 EXPECT_EQ("" , message.optional_bytes ());
511 EXPECT_FALSE(message.optionalgroup ().has_a());
512 EXPECT_FALSE(message.optional_nested_message ().has_bb());
513 EXPECT_FALSE(message.optional_foreign_message ().has_c());
514 EXPECT_FALSE(message.optional_import_message ().has_d());
515 EXPECT_FALSE(message.optional_public_import_message().has_e());
516 EXPECT_FALSE(message.optional_lazy_message ().has_bb());
518 EXPECT_EQ(0, message.optionalgroup ().a());
519 EXPECT_EQ(0, message.optional_nested_message ().bb());
520 EXPECT_EQ(0, message.optional_foreign_message ().c());
521 EXPECT_EQ(0, message.optional_import_message ().d());
522 EXPECT_EQ(0, message.optional_public_import_message().e());
523 EXPECT_EQ(0, message.optional_lazy_message ().bb());
526 EXPECT_EQ(unittest::TestAllTypes::FOO, message.optional_nested_enum ());
527 EXPECT_EQ(unittest::FOREIGN_FOO , message.optional_foreign_enum());
528 EXPECT_EQ(unittest_import::IMPORT_FOO, message.optional_import_enum ());
532 EXPECT_EQ(0, message.repeated_int32_size ());
533 EXPECT_EQ(0, message.repeated_int64_size ());
534 EXPECT_EQ(0, message.repeated_uint32_size ());
535 EXPECT_EQ(0, message.repeated_uint64_size ());
536 EXPECT_EQ(0, message.repeated_sint32_size ());
537 EXPECT_EQ(0, message.repeated_sint64_size ());
538 EXPECT_EQ(0, message.repeated_fixed32_size ());
539 EXPECT_EQ(0, message.repeated_fixed64_size ());
540 EXPECT_EQ(0, message.repeated_sfixed32_size());
541 EXPECT_EQ(0, message.repeated_sfixed64_size());
542 EXPECT_EQ(0, message.repeated_float_size ());
543 EXPECT_EQ(0, message.repeated_double_size ());
544 EXPECT_EQ(0, message.repeated_bool_size ());
545 EXPECT_EQ(0, message.repeated_string_size ());
546 EXPECT_EQ(0, message.repeated_bytes_size ());
548 EXPECT_EQ(0, message.repeatedgroup_size ());
549 EXPECT_EQ(0, message.repeated_nested_message_size ());
550 EXPECT_EQ(0, message.repeated_foreign_message_size());
551 EXPECT_EQ(0, message.repeated_import_message_size ());
552 EXPECT_EQ(0, message.repeated_lazy_message_size ());
553 EXPECT_EQ(0, message.repeated_nested_enum_size ());
554 EXPECT_EQ(0, message.repeated_foreign_enum_size ());
555 EXPECT_EQ(0, message.repeated_import_enum_size ());
557 EXPECT_EQ(0, message.repeated_string_piece_size());
558 EXPECT_EQ(0, message.repeated_cord_size());
561 EXPECT_FALSE(message.has_default_int32 ());
562 EXPECT_FALSE(message.has_default_int64 ());
563 EXPECT_FALSE(message.has_default_uint32 ());
564 EXPECT_FALSE(message.has_default_uint64 ());
565 EXPECT_FALSE(message.has_default_sint32 ());
566 EXPECT_FALSE(message.has_default_sint64 ());
567 EXPECT_FALSE(message.has_default_fixed32 ());
568 EXPECT_FALSE(message.has_default_fixed64 ());
569 EXPECT_FALSE(message.has_default_sfixed32());
570 EXPECT_FALSE(message.has_default_sfixed64());
571 EXPECT_FALSE(message.has_default_float ());
572 EXPECT_FALSE(message.has_default_double ());
573 EXPECT_FALSE(message.has_default_bool ());
574 EXPECT_FALSE(message.has_default_string ());
575 EXPECT_FALSE(message.has_default_bytes ());
577 EXPECT_FALSE(message.has_default_nested_enum ());
578 EXPECT_FALSE(message.has_default_foreign_enum());
579 EXPECT_FALSE(message.has_default_import_enum ());
583 EXPECT_EQ( 41 , message.default_int32 ());
584 EXPECT_EQ( 42 , message.default_int64 ());
585 EXPECT_EQ( 43 , message.default_uint32 ());
586 EXPECT_EQ( 44 , message.default_uint64 ());
587 EXPECT_EQ(-45 , message.default_sint32 ());
588 EXPECT_EQ( 46 , message.default_sint64 ());
589 EXPECT_EQ( 47 , message.default_fixed32 ());
590 EXPECT_EQ( 48 , message.default_fixed64 ());
591 EXPECT_EQ( 49 , message.default_sfixed32());
592 EXPECT_EQ(-50 , message.default_sfixed64());
593 EXPECT_EQ( 51.5 , message.default_float ());
594 EXPECT_EQ( 52e3 , message.default_double ());
595 EXPECT_TRUE( message.default_bool ());
596 EXPECT_EQ("hello", message.default_string ());
597 EXPECT_EQ("world", message.default_bytes ());
599 EXPECT_EQ(unittest::TestAllTypes::BAR, message.default_nested_enum ());
600 EXPECT_EQ(unittest::FOREIGN_BAR , message.default_foreign_enum());
601 EXPECT_EQ(unittest_import::IMPORT_BAR, message.default_import_enum ());
608 const unittest::TestAllTypes& message) {
612 ASSERT_EQ(2, message.repeated_int32_size ());
613 ASSERT_EQ(2, message.repeated_int64_size ());
614 ASSERT_EQ(2, message.repeated_uint32_size ());
615 ASSERT_EQ(2, message.repeated_uint64_size ());
616 ASSERT_EQ(2, message.repeated_sint32_size ());
617 ASSERT_EQ(2, message.repeated_sint64_size ());
618 ASSERT_EQ(2, message.repeated_fixed32_size ());
619 ASSERT_EQ(2, message.repeated_fixed64_size ());
620 ASSERT_EQ(2, message.repeated_sfixed32_size());
621 ASSERT_EQ(2, message.repeated_sfixed64_size());
622 ASSERT_EQ(2, message.repeated_float_size ());
623 ASSERT_EQ(2, message.repeated_double_size ());
624 ASSERT_EQ(2, message.repeated_bool_size ());
625 ASSERT_EQ(2, message.repeated_string_size ());
626 ASSERT_EQ(2, message.repeated_bytes_size ());
628 ASSERT_EQ(2, message.repeatedgroup_size ());
629 ASSERT_EQ(2, message.repeated_nested_message_size ());
630 ASSERT_EQ(2, message.repeated_foreign_message_size());
631 ASSERT_EQ(2, message.repeated_import_message_size ());
632 ASSERT_EQ(2, message.repeated_lazy_message_size ());
633 ASSERT_EQ(2, message.repeated_nested_enum_size ());
634 ASSERT_EQ(2, message.repeated_foreign_enum_size ());
635 ASSERT_EQ(2, message.repeated_import_enum_size ());
638 ASSERT_EQ(2, message.repeated_string_piece_size());
639 ASSERT_EQ(2, message.repeated_cord_size());
642 EXPECT_EQ(201 , message.repeated_int32 (0));
643 EXPECT_EQ(202 , message.repeated_int64 (0));
644 EXPECT_EQ(203 , message.repeated_uint32 (0));
645 EXPECT_EQ(204 , message.repeated_uint64 (0));
646 EXPECT_EQ(205 , message.repeated_sint32 (0));
647 EXPECT_EQ(206 , message.repeated_sint64 (0));
648 EXPECT_EQ(207 , message.repeated_fixed32 (0));
649 EXPECT_EQ(208 , message.repeated_fixed64 (0));
650 EXPECT_EQ(209 , message.repeated_sfixed32(0));
651 EXPECT_EQ(210 , message.repeated_sfixed64(0));
652 EXPECT_EQ(211 , message.repeated_float (0));
653 EXPECT_EQ(212 , message.repeated_double (0));
654 EXPECT_TRUE( message.repeated_bool (0));
655 EXPECT_EQ("215", message.repeated_string (0));
656 EXPECT_EQ("216", message.repeated_bytes (0));
658 EXPECT_EQ(217, message.repeatedgroup (0).a());
659 EXPECT_EQ(218, message.repeated_nested_message (0).bb());
660 EXPECT_EQ(219, message.repeated_foreign_message(0).c());
661 EXPECT_EQ(220, message.repeated_import_message (0).d());
662 EXPECT_EQ(227, message.repeated_lazy_message (0).bb());
664 EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (0));
665 EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(0));
666 EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (0));
670 EXPECT_EQ(501 , message.repeated_int32 (1));
671 EXPECT_EQ(502 , message.repeated_int64 (1));
672 EXPECT_EQ(503 , message.repeated_uint32 (1));
673 EXPECT_EQ(504 , message.repeated_uint64 (1));
674 EXPECT_EQ(505 , message.repeated_sint32 (1));
675 EXPECT_EQ(506 , message.repeated_sint64 (1));
676 EXPECT_EQ(507 , message.repeated_fixed32 (1));
677 EXPECT_EQ(508 , message.repeated_fixed64 (1));
678 EXPECT_EQ(509 , message.repeated_sfixed32(1));
679 EXPECT_EQ(510 , message.repeated_sfixed64(1));
680 EXPECT_EQ(511 , message.repeated_float (1));
681 EXPECT_EQ(512 , message.repeated_double (1));
682 EXPECT_TRUE( message.repeated_bool (1));
683 EXPECT_EQ("515", message.repeated_string (1));
684 EXPECT_EQ("516", message.repeated_bytes (1));
686 EXPECT_EQ(517, message.repeatedgroup (1).a());
687 EXPECT_EQ(518, message.repeated_nested_message (1).bb());
688 EXPECT_EQ(519, message.repeated_foreign_message(1).c());
689 EXPECT_EQ(520, message.repeated_import_message (1).d());
690 EXPECT_EQ(527, message.repeated_lazy_message (1).bb());
692 EXPECT_EQ(unittest::TestAllTypes::FOO, message.repeated_nested_enum (1));
693 EXPECT_EQ(unittest::FOREIGN_FOO , message.repeated_foreign_enum(1));
694 EXPECT_EQ(unittest_import::IMPORT_FOO, message.repeated_import_enum (1));
700 void TestUtil::SetPackedFields(unittest::TestPackedTypes* message) {
701 message->add_packed_int32 (601);
702 message->add_packed_int64 (602);
703 message->add_packed_uint32 (603);
704 message->add_packed_uint64 (604);
705 message->add_packed_sint32 (605);
706 message->add_packed_sint64 (606);
707 message->add_packed_fixed32 (607);
708 message->add_packed_fixed64 (608);
709 message->add_packed_sfixed32(609);
710 message->add_packed_sfixed64(610);
711 message->add_packed_float (611);
712 message->add_packed_double (612);
713 message->add_packed_bool (true);
714 message->add_packed_enum (unittest::FOREIGN_BAR);
716 message->add_packed_int32 (701);
717 message->add_packed_int64 (702);
718 message->add_packed_uint32 (703);
719 message->add_packed_uint64 (704);
720 message->add_packed_sint32 (705);
721 message->add_packed_sint64 (706);
722 message->add_packed_fixed32 (707);
723 message->add_packed_fixed64 (708);
724 message->add_packed_sfixed32(709);
725 message->add_packed_sfixed64(710);
726 message->add_packed_float (711);
727 message->add_packed_double (712);
728 message->add_packed_bool (false);
729 message->add_packed_enum (unittest::FOREIGN_BAZ);
732 void TestUtil::SetUnpackedFields(unittest::TestUnpackedTypes* message) {
735 message->add_unpacked_int32 (601);
736 message->add_unpacked_int64 (602);
737 message->add_unpacked_uint32 (603);
738 message->add_unpacked_uint64 (604);
739 message->add_unpacked_sint32 (605);
740 message->add_unpacked_sint64 (606);
741 message->add_unpacked_fixed32 (607);
742 message->add_unpacked_fixed64 (608);
743 message->add_unpacked_sfixed32(609);
744 message->add_unpacked_sfixed64(610);
745 message->add_unpacked_float (611);
746 message->add_unpacked_double (612);
747 message->add_unpacked_bool (true);
748 message->add_unpacked_enum (unittest::FOREIGN_BAR);
750 message->add_unpacked_int32 (701);
751 message->add_unpacked_int64 (702);
752 message->add_unpacked_uint32 (703);
753 message->add_unpacked_uint64 (704);
754 message->add_unpacked_sint32 (705);
755 message->add_unpacked_sint64 (706);
756 message->add_unpacked_fixed32 (707);
757 message->add_unpacked_fixed64 (708);
758 message->add_unpacked_sfixed32(709);
759 message->add_unpacked_sfixed64(710);
760 message->add_unpacked_float (711);
761 message->add_unpacked_double (712);
762 message->add_unpacked_bool (false);
763 message->add_unpacked_enum (unittest::FOREIGN_BAZ);
768 void TestUtil::ModifyPackedFields(unittest::TestPackedTypes* message) {
769 message->set_packed_int32 (1, 801);
770 message->set_packed_int64 (1, 802);
771 message->set_packed_uint32 (1, 803);
772 message->set_packed_uint64 (1, 804);
773 message->set_packed_sint32 (1, 805);
774 message->set_packed_sint64 (1, 806);
775 message->set_packed_fixed32 (1, 807);
776 message->set_packed_fixed64 (1, 808);
777 message->set_packed_sfixed32(1, 809);
778 message->set_packed_sfixed64(1, 810);
779 message->set_packed_float (1, 811);
780 message->set_packed_double (1, 812);
781 message->set_packed_bool (1, true);
782 message->set_packed_enum (1, unittest::FOREIGN_FOO);
787 void TestUtil::ExpectPackedFieldsSet(const unittest::TestPackedTypes& message) {
788 ASSERT_EQ(2, message.packed_int32_size ());
789 ASSERT_EQ(2, message.packed_int64_size ());
790 ASSERT_EQ(2, message.packed_uint32_size ());
791 ASSERT_EQ(2, message.packed_uint64_size ());
792 ASSERT_EQ(2, message.packed_sint32_size ());
793 ASSERT_EQ(2, message.packed_sint64_size ());
794 ASSERT_EQ(2, message.packed_fixed32_size ());
795 ASSERT_EQ(2, message.packed_fixed64_size ());
796 ASSERT_EQ(2, message.packed_sfixed32_size());
797 ASSERT_EQ(2, message.packed_sfixed64_size());
798 ASSERT_EQ(2, message.packed_float_size ());
799 ASSERT_EQ(2, message.packed_double_size ());
800 ASSERT_EQ(2, message.packed_bool_size ());
801 ASSERT_EQ(2, message.packed_enum_size ());
803 EXPECT_EQ(601 , message.packed_int32 (0));
804 EXPECT_EQ(602 , message.packed_int64 (0));
805 EXPECT_EQ(603 , message.packed_uint32 (0));
806 EXPECT_EQ(604 , message.packed_uint64 (0));
807 EXPECT_EQ(605 , message.packed_sint32 (0));
808 EXPECT_EQ(606 , message.packed_sint64 (0));
809 EXPECT_EQ(607 , message.packed_fixed32 (0));
810 EXPECT_EQ(608 , message.packed_fixed64 (0));
811 EXPECT_EQ(609 , message.packed_sfixed32(0));
812 EXPECT_EQ(610 , message.packed_sfixed64(0));
813 EXPECT_EQ(611 , message.packed_float (0));
814 EXPECT_EQ(612 , message.packed_double (0));
815 EXPECT_TRUE( message.packed_bool (0));
816 EXPECT_EQ(unittest::FOREIGN_BAR, message.packed_enum(0));
818 EXPECT_EQ(701 , message.packed_int32 (1));
819 EXPECT_EQ(702 , message.packed_int64 (1));
820 EXPECT_EQ(703 , message.packed_uint32 (1));
821 EXPECT_EQ(704 , message.packed_uint64 (1));
822 EXPECT_EQ(705 , message.packed_sint32 (1));
823 EXPECT_EQ(706 , message.packed_sint64 (1));
824 EXPECT_EQ(707 , message.packed_fixed32 (1));
825 EXPECT_EQ(708 , message.packed_fixed64 (1));
826 EXPECT_EQ(709 , message.packed_sfixed32(1));
827 EXPECT_EQ(710 , message.packed_sfixed64(1));
828 EXPECT_EQ(711 , message.packed_float (1));
829 EXPECT_EQ(712 , message.packed_double (1));
830 EXPECT_FALSE( message.packed_bool (1));
831 EXPECT_EQ(unittest::FOREIGN_BAZ, message.packed_enum(1));
835 const unittest::TestUnpackedTypes& message) {
838 ASSERT_EQ(2, message.unpacked_int32_size ());
839 ASSERT_EQ(2, message.unpacked_int64_size ());
840 ASSERT_EQ(2, message.unpacked_uint32_size ());
841 ASSERT_EQ(2, message.unpacked_uint64_size ());
842 ASSERT_EQ(2, message.unpacked_sint32_size ());
843 ASSERT_EQ(2, message.unpacked_sint64_size ());
844 ASSERT_EQ(2, message.unpacked_fixed32_size ());
845 ASSERT_EQ(2, message.unpacked_fixed64_size ());
846 ASSERT_EQ(2, message.unpacked_sfixed32_size());
847 ASSERT_EQ(2, message.unpacked_sfixed64_size());
848 ASSERT_EQ(2, message.unpacked_float_size ());
849 ASSERT_EQ(2, message.unpacked_double_size ());
850 ASSERT_EQ(2, message.unpacked_bool_size ());
851 ASSERT_EQ(2, message.unpacked_enum_size ());
853 EXPECT_EQ(601 , message.unpacked_int32 (0));
854 EXPECT_EQ(602 , message.unpacked_int64 (0));
855 EXPECT_EQ(603 , message.unpacked_uint32 (0));
856 EXPECT_EQ(604 , message.unpacked_uint64 (0));
857 EXPECT_EQ(605 , message.unpacked_sint32 (0));
858 EXPECT_EQ(606 , message.unpacked_sint64 (0));
859 EXPECT_EQ(607 , message.unpacked_fixed32 (0));
860 EXPECT_EQ(608 , message.unpacked_fixed64 (0));
861 EXPECT_EQ(609 , message.unpacked_sfixed32(0));
862 EXPECT_EQ(610 , message.unpacked_sfixed64(0));
863 EXPECT_EQ(611 , message.unpacked_float (0));
864 EXPECT_EQ(612 , message.unpacked_double (0));
865 EXPECT_TRUE( message.unpacked_bool (0));
866 EXPECT_EQ(unittest::FOREIGN_BAR, message.unpacked_enum(0));
868 EXPECT_EQ(701 , message.unpacked_int32 (1));
869 EXPECT_EQ(702 , message.unpacked_int64 (1));
870 EXPECT_EQ(703 , message.unpacked_uint32 (1));
871 EXPECT_EQ(704 , message.unpacked_uint64 (1));
872 EXPECT_EQ(705 , message.unpacked_sint32 (1));
873 EXPECT_EQ(706 , message.unpacked_sint64 (1));
874 EXPECT_EQ(707 , message.unpacked_fixed32 (1));
875 EXPECT_EQ(708 , message.unpacked_fixed64 (1));
876 EXPECT_EQ(709 , message.unpacked_sfixed32(1));
877 EXPECT_EQ(710 , message.unpacked_sfixed64(1));
878 EXPECT_EQ(711 , message.unpacked_float (1));
879 EXPECT_EQ(712 , message.unpacked_double (1));
880 EXPECT_FALSE( message.unpacked_bool (1));
881 EXPECT_EQ(unittest::FOREIGN_BAZ, message.unpacked_enum(1));
887 const unittest::TestPackedTypes& message) {
889 EXPECT_EQ(0, message.packed_int32_size ());
890 EXPECT_EQ(0, message.packed_int64_size ());
891 EXPECT_EQ(0, message.packed_uint32_size ());
892 EXPECT_EQ(0, message.packed_uint64_size ());
893 EXPECT_EQ(0, message.packed_sint32_size ());
894 EXPECT_EQ(0, message.packed_sint64_size ());
895 EXPECT_EQ(0, message.packed_fixed32_size ());
896 EXPECT_EQ(0, message.packed_fixed64_size ());
897 EXPECT_EQ(0, message.packed_sfixed32_size());
898 EXPECT_EQ(0, message.packed_sfixed64_size());
899 EXPECT_EQ(0, message.packed_float_size ());
900 EXPECT_EQ(0, message.packed_double_size ());
901 EXPECT_EQ(0, message.packed_bool_size ());
902 EXPECT_EQ(0, message.packed_enum_size ());
908 const unittest::TestPackedTypes& message) {
910 ASSERT_EQ(2, message.packed_int32_size ());
911 ASSERT_EQ(2, message.packed_int64_size ());
912 ASSERT_EQ(2, message.packed_uint32_size ());
913 ASSERT_EQ(2, message.packed_uint64_size ());
914 ASSERT_EQ(2, message.packed_sint32_size ());
915 ASSERT_EQ(2, message.packed_sint64_size ());
916 ASSERT_EQ(2, message.packed_fixed32_size ());
917 ASSERT_EQ(2, message.packed_fixed64_size ());
918 ASSERT_EQ(2, message.packed_sfixed32_size());
919 ASSERT_EQ(2, message.packed_sfixed64_size());
920 ASSERT_EQ(2, message.packed_float_size ());
921 ASSERT_EQ(2, message.packed_double_size ());
922 ASSERT_EQ(2, message.packed_bool_size ());
923 ASSERT_EQ(2, message.packed_enum_size ());
925 EXPECT_EQ(601 , message.packed_int32 (0));
926 EXPECT_EQ(602 , message.packed_int64 (0));
927 EXPECT_EQ(603 , message.packed_uint32 (0));
928 EXPECT_EQ(604 , message.packed_uint64 (0));
929 EXPECT_EQ(605 , message.packed_sint32 (0));
930 EXPECT_EQ(606 , message.packed_sint64 (0));
931 EXPECT_EQ(607 , message.packed_fixed32 (0));
932 EXPECT_EQ(608 , message.packed_fixed64 (0));
933 EXPECT_EQ(609 , message.packed_sfixed32(0));
934 EXPECT_EQ(610 , message.packed_sfixed64(0));
935 EXPECT_EQ(611 , message.packed_float (0));
936 EXPECT_EQ(612 , message.packed_double (0));
937 EXPECT_TRUE( message.packed_bool (0));
938 EXPECT_EQ(unittest::FOREIGN_BAR, message.packed_enum(0));
940 EXPECT_EQ(801 , message.packed_int32 (1));
941 EXPECT_EQ(802 , message.packed_int64 (1));
942 EXPECT_EQ(803 , message.packed_uint32 (1));
943 EXPECT_EQ(804 , message.packed_uint64 (1));
944 EXPECT_EQ(805 , message.packed_sint32 (1));
945 EXPECT_EQ(806 , message.packed_sint64 (1));
946 EXPECT_EQ(807 , message.packed_fixed32 (1));
947 EXPECT_EQ(808 , message.packed_fixed64 (1));
948 EXPECT_EQ(809 , message.packed_sfixed32(1));
949 EXPECT_EQ(810 , message.packed_sfixed64(1));
950 EXPECT_EQ(811 , message.packed_float (1));
951 EXPECT_EQ(812 , message.packed_double (1));
952 EXPECT_TRUE( message.packed_bool (1));
953 EXPECT_EQ(unittest::FOREIGN_FOO, message.packed_enum(1));
964 void TestUtil::SetAllExtensions(unittest::TestAllExtensions* message) {
965 message->SetExtension(unittest::optional_int32_extension , 101);
966 message->SetExtension(unittest::optional_int64_extension , 102);
967 message->SetExtension(unittest::optional_uint32_extension , 103);
968 message->SetExtension(unittest::optional_uint64_extension , 104);
969 message->SetExtension(unittest::optional_sint32_extension , 105);
970 message->SetExtension(unittest::optional_sint64_extension , 106);
971 message->SetExtension(unittest::optional_fixed32_extension , 107);
972 message->SetExtension(unittest::optional_fixed64_extension , 108);
973 message->SetExtension(unittest::optional_sfixed32_extension, 109);
974 message->SetExtension(unittest::optional_sfixed64_extension, 110);
975 message->SetExtension(unittest::optional_float_extension , 111);
976 message->SetExtension(unittest::optional_double_extension , 112);
977 message->SetExtension(unittest::optional_bool_extension , true);
978 message->SetExtension(unittest::optional_string_extension , "115");
979 message->SetExtension(unittest::optional_bytes_extension , "116");
981 message->MutableExtension(unittest::optionalgroup_extension )->set_a(117);
982 message->MutableExtension(unittest::optional_nested_message_extension )->set_bb(118);
983 message->MutableExtension(unittest::optional_foreign_message_extension)->set_c(119);
984 message->MutableExtension(unittest::optional_import_message_extension )->set_d(120);
986 message->SetExtension(unittest::optional_nested_enum_extension , unittest::TestAllTypes::BAZ);
987 message->SetExtension(unittest::optional_foreign_enum_extension, unittest::FOREIGN_BAZ );
988 message->SetExtension(unittest::optional_import_enum_extension , unittest_import::IMPORT_BAZ);
990 message->SetExtension(unittest::optional_string_piece_extension, "124");
991 message->SetExtension(unittest::optional_cord_extension, "125");
993 message->MutableExtension(unittest::optional_public_import_message_extension)->set_e(126);
994 message->MutableExtension(unittest::optional_lazy_message_extension)->set_bb(127);
998 message->AddExtension(unittest::repeated_int32_extension , 201);
999 message->AddExtension(unittest::repeated_int64_extension , 202);
1000 message->AddExtension(unittest::repeated_uint32_extension , 203);
1001 message->AddExtension(unittest::repeated_uint64_extension , 204);
1002 message->AddExtension(unittest::repeated_sint32_extension , 205);
1003 message->AddExtension(unittest::repeated_sint64_extension , 206);
1004 message->AddExtension(unittest::repeated_fixed32_extension , 207);
1005 message->AddExtension(unittest::repeated_fixed64_extension , 208);
1006 message->AddExtension(unittest::repeated_sfixed32_extension, 209);
1007 message->AddExtension(unittest::repeated_sfixed64_extension, 210);
1008 message->AddExtension(unittest::repeated_float_extension , 211);
1009 message->AddExtension(unittest::repeated_double_extension , 212);
1010 message->AddExtension(unittest::repeated_bool_extension , true);
1011 message->AddExtension(unittest::repeated_string_extension , "215");
1012 message->AddExtension(unittest::repeated_bytes_extension , "216");
1014 message->AddExtension(unittest::repeatedgroup_extension )->set_a(217);
1015 message->AddExtension(unittest::repeated_nested_message_extension )->set_bb(218);
1016 message->AddExtension(unittest::repeated_foreign_message_extension)->set_c(219);
1017 message->AddExtension(unittest::repeated_import_message_extension )->set_d(220);
1018 message->AddExtension(unittest::repeated_lazy_message_extension )->set_bb(227);
1020 message->AddExtension(unittest::repeated_nested_enum_extension , unittest::TestAllTypes::BAR);
1021 message->AddExtension(unittest::repeated_foreign_enum_extension, unittest::FOREIGN_BAR );
1022 message->AddExtension(unittest::repeated_import_enum_extension , unittest_import::IMPORT_BAR);
1024 message->AddExtension(unittest::repeated_string_piece_extension, "224");
1025 message->AddExtension(unittest::repeated_cord_extension, "225");
1028 message->AddExtension(unittest::repeated_int32_extension , 301);
1029 message->AddExtension(unittest::repeated_int64_extension , 302);
1030 message->AddExtension(unittest::repeated_uint32_extension , 303);
1031 message->AddExtension(unittest::repeated_uint64_extension , 304);
1032 message->AddExtension(unittest::repeated_sint32_extension , 305);
1033 message->AddExtension(unittest::repeated_sint64_extension , 306);
1034 message->AddExtension(unittest::repeated_fixed32_extension , 307);
1035 message->AddExtension(unittest::repeated_fixed64_extension , 308);
1036 message->AddExtension(unittest::repeated_sfixed32_extension, 309);
1037 message->AddExtension(unittest::repeated_sfixed64_extension, 310);
1038 message->AddExtension(unittest::repeated_float_extension , 311);
1039 message->AddExtension(unittest::repeated_double_extension , 312);
1040 message->AddExtension(unittest::repeated_bool_extension , false);
1041 message->AddExtension(unittest::repeated_string_extension , "315");
1042 message->AddExtension(unittest::repeated_bytes_extension , "316");
1044 message->AddExtension(unittest::repeatedgroup_extension )->set_a(317);
1045 message->AddExtension(unittest::repeated_nested_message_extension )->set_bb(318);
1046 message->AddExtension(unittest::repeated_foreign_message_extension)->set_c(319);
1047 message->AddExtension(unittest::repeated_import_message_extension )->set_d(320);
1048 message->AddExtension(unittest::repeated_lazy_message_extension )->set_bb(327);
1050 message->AddExtension(unittest::repeated_nested_enum_extension , unittest::TestAllTypes::BAZ);
1051 message->AddExtension(unittest::repeated_foreign_enum_extension, unittest::FOREIGN_BAZ );
1052 message->AddExtension(unittest::repeated_import_enum_extension , unittest_import::IMPORT_BAZ);
1054 message->AddExtension(unittest::repeated_string_piece_extension, "324");
1055 message->AddExtension(unittest::repeated_cord_extension, "325");
1059 message->SetExtension(unittest::default_int32_extension , 401);
1060 message->SetExtension(unittest::default_int64_extension , 402);
1061 message->SetExtension(unittest::default_uint32_extension , 403);
1062 message->SetExtension(unittest::default_uint64_extension , 404);
1063 message->SetExtension(unittest::default_sint32_extension , 405);
1064 message->SetExtension(unittest::default_sint64_extension , 406);
1065 message->SetExtension(unittest::default_fixed32_extension , 407);
1066 message->SetExtension(unittest::default_fixed64_extension , 408);
1067 message->SetExtension(unittest::default_sfixed32_extension, 409);
1068 message->SetExtension(unittest::default_sfixed64_extension, 410);
1069 message->SetExtension(unittest::default_float_extension , 411);
1070 message->SetExtension(unittest::default_double_extension , 412);
1071 message->SetExtension(unittest::default_bool_extension , false);
1072 message->SetExtension(unittest::default_string_extension , "415");
1073 message->SetExtension(unittest::default_bytes_extension , "416");
1075 message->SetExtension(unittest::default_nested_enum_extension , unittest::TestAllTypes::FOO);
1076 message->SetExtension(unittest::default_foreign_enum_extension, unittest::FOREIGN_FOO );
1077 message->SetExtension(unittest::default_import_enum_extension , unittest_import::IMPORT_FOO);
1079 message->SetExtension(unittest::default_string_piece_extension, "424");
1080 message->SetExtension(unittest::default_cord_extension, "425");
1086 unittest::TestFieldOrderings* message) {
1087 GOOGLE_CHECK(message);
1088 message->set_my_int(1);
1089 message->set_my_string("foo");
1090 message->set_my_float(1.0);
1091 message->SetExtension(unittest::my_extension_int, 23);
1092 message->SetExtension(unittest::my_extension_string, "bar");
1097 void TestUtil::ModifyRepeatedExtensions(unittest::TestAllExtensions* message) {
1098 message->SetExtension(unittest::repeated_int32_extension , 1, 501);
1099 message->SetExtension(unittest::repeated_int64_extension , 1, 502);
1100 message->SetExtension(unittest::repeated_uint32_extension , 1, 503);
1101 message->SetExtension(unittest::repeated_uint64_extension , 1, 504);
1102 message->SetExtension(unittest::repeated_sint32_extension , 1, 505);
1103 message->SetExtension(unittest::repeated_sint64_extension , 1, 506);
1104 message->SetExtension(unittest::repeated_fixed32_extension , 1, 507);
1105 message->SetExtension(unittest::repeated_fixed64_extension , 1, 508);
1106 message->SetExtension(unittest::repeated_sfixed32_extension, 1, 509);
1107 message->SetExtension(unittest::repeated_sfixed64_extension, 1, 510);
1108 message->SetExtension(unittest::repeated_float_extension , 1, 511);
1109 message->SetExtension(unittest::repeated_double_extension , 1, 512);
1110 message->SetExtension(unittest::repeated_bool_extension , 1, true);
1111 message->SetExtension(unittest::repeated_string_extension , 1, "515");
1112 message->SetExtension(unittest::repeated_bytes_extension , 1, "516");
1114 message->MutableExtension(unittest::repeatedgroup_extension , 1)->set_a(517);
1115 message->MutableExtension(unittest::repeated_nested_message_extension , 1)->set_bb(518);
1116 message->MutableExtension(unittest::repeated_foreign_message_extension, 1)->set_c(519);
1117 message->MutableExtension(unittest::repeated_import_message_extension , 1)->set_d(520);
1118 message->MutableExtension(unittest::repeated_lazy_message_extension , 1)->set_bb(527);
1120 message->SetExtension(unittest::repeated_nested_enum_extension , 1, unittest::TestAllTypes::FOO);
1121 message->SetExtension(unittest::repeated_foreign_enum_extension, 1, unittest::FOREIGN_FOO );
1122 message->SetExtension(unittest::repeated_import_enum_extension , 1, unittest_import::IMPORT_FOO);
1124 message->SetExtension(unittest::repeated_string_piece_extension, 1, "524");
1125 message->SetExtension(unittest::repeated_cord_extension, 1, "525");
1131 const unittest::TestAllExtensions& message) {
1132 EXPECT_TRUE(message.HasExtension(unittest::optional_int32_extension ));
1133 EXPECT_TRUE(message.HasExtension(unittest::optional_int64_extension ));
1134 EXPECT_TRUE(message.HasExtension(unittest::optional_uint32_extension ));
1135 EXPECT_TRUE(message.HasExtension(unittest::optional_uint64_extension ));
1136 EXPECT_TRUE(message.HasExtension(unittest::optional_sint32_extension ));
1137 EXPECT_TRUE(message.HasExtension(unittest::optional_sint64_extension ));
1138 EXPECT_TRUE(message.HasExtension(unittest::optional_fixed32_extension ));
1139 EXPECT_TRUE(message.HasExtension(unittest::optional_fixed64_extension ));
1140 EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed32_extension));
1141 EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed64_extension));
1142 EXPECT_TRUE(message.HasExtension(unittest::optional_float_extension ));
1143 EXPECT_TRUE(message.HasExtension(unittest::optional_double_extension ));
1144 EXPECT_TRUE(message.HasExtension(unittest::optional_bool_extension ));
1145 EXPECT_TRUE(message.HasExtension(unittest::optional_string_extension ));
1146 EXPECT_TRUE(message.HasExtension(unittest::optional_bytes_extension ));
1148 EXPECT_TRUE(message.HasExtension(unittest::optionalgroup_extension ));
1149 EXPECT_TRUE(message.HasExtension(unittest::optional_nested_message_extension ));
1150 EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_message_extension ));
1151 EXPECT_TRUE(message.HasExtension(unittest::optional_import_message_extension ));
1152 EXPECT_TRUE(message.HasExtension(unittest::optional_public_import_message_extension));
1153 EXPECT_TRUE(message.HasExtension(unittest::optional_lazy_message_extension ));
1155 EXPECT_TRUE(message.GetExtension(unittest::optionalgroup_extension ).has_a());
1156 EXPECT_TRUE(message.GetExtension(unittest::optional_nested_message_extension ).has_bb());
1157 EXPECT_TRUE(message.GetExtension(unittest::optional_foreign_message_extension ).has_c());
1158 EXPECT_TRUE(message.GetExtension(unittest::optional_import_message_extension ).has_d());
1159 EXPECT_TRUE(message.GetExtension(unittest::optional_public_import_message_extension).has_e());
1160 EXPECT_TRUE(message.GetExtension(unittest::optional_lazy_message_extension ).has_bb());
1162 EXPECT_TRUE(message.HasExtension(unittest::optional_nested_enum_extension ));
1163 EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_enum_extension));
1164 EXPECT_TRUE(message.HasExtension(unittest::optional_import_enum_extension ));
1166 EXPECT_TRUE(message.HasExtension(unittest::optional_string_piece_extension));
1167 EXPECT_TRUE(message.HasExtension(unittest::optional_cord_extension));
1169 EXPECT_EQ(101 , message.GetExtension(unittest::optional_int32_extension ));
1170 EXPECT_EQ(102 , message.GetExtension(unittest::optional_int64_extension ));
1171 EXPECT_EQ(103 , message.GetExtension(unittest::optional_uint32_extension ));
1172 EXPECT_EQ(104 , message.GetExtension(unittest::optional_uint64_extension ));
1173 EXPECT_EQ(105 , message.GetExtension(unittest::optional_sint32_extension ));
1174 EXPECT_EQ(106 , message.GetExtension(unittest::optional_sint64_extension ));
1175 EXPECT_EQ(107 , message.GetExtension(unittest::optional_fixed32_extension ));
1176 EXPECT_EQ(108 , message.GetExtension(unittest::optional_fixed64_extension ));
1177 EXPECT_EQ(109 , message.GetExtension(unittest::optional_sfixed32_extension));
1178 EXPECT_EQ(110 , message.GetExtension(unittest::optional_sfixed64_extension));
1179 EXPECT_EQ(111 , message.GetExtension(unittest::optional_float_extension ));
1180 EXPECT_EQ(112 , message.GetExtension(unittest::optional_double_extension ));
1181 EXPECT_TRUE( message.GetExtension(unittest::optional_bool_extension ));
1182 EXPECT_EQ("115", message.GetExtension(unittest::optional_string_extension ));
1183 EXPECT_EQ("116", message.GetExtension(unittest::optional_bytes_extension ));
1185 EXPECT_EQ(117, message.GetExtension(unittest::optionalgroup_extension ).a());
1186 EXPECT_EQ(118, message.GetExtension(unittest::optional_nested_message_extension ).bb());
1187 EXPECT_EQ(119, message.GetExtension(unittest::optional_foreign_message_extension).c());
1188 EXPECT_EQ(120, message.GetExtension(unittest::optional_import_message_extension ).d());
1190 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.GetExtension(unittest::optional_nested_enum_extension ));
1191 EXPECT_EQ(unittest::FOREIGN_BAZ , message.GetExtension(unittest::optional_foreign_enum_extension));
1192 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.GetExtension(unittest::optional_import_enum_extension ));
1194 EXPECT_EQ("124", message.GetExtension(unittest::optional_string_piece_extension));
1195 EXPECT_EQ("125", message.GetExtension(unittest::optional_cord_extension));
1196 EXPECT_EQ(126, message.GetExtension(unittest::optional_public_import_message_extension ).e());
1197 EXPECT_EQ(127, message.GetExtension(unittest::optional_lazy_message_extension).bb());
1201 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension ));
1202 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension ));
1203 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension ));
1204 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension ));
1205 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension ));
1206 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension ));
1207 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension ));
1208 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension ));
1209 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension));
1210 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension));
1211 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension ));
1212 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension ));
1213 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension ));
1214 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension ));
1215 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension ));
1217 ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension ));
1218 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension ));
1219 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension));
1220 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension ));
1221 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension ));
1222 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension ));
1223 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension ));
1224 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension ));
1226 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_piece_extension));
1227 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_cord_extension));
1229 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension , 0));
1230 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension , 0));
1231 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension , 0));
1232 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension , 0));
1233 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension , 0));
1234 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension , 0));
1235 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension , 0));
1236 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension , 0));
1237 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension, 0));
1238 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 0));
1239 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 0));
1240 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 0));
1241 EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 0));
1242 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 0));
1243 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 0));
1245 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 0).a());
1246 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb());
1247 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c());
1248 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d());
1249 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb());
1251 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 0));
1252 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 0));
1253 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 0));
1255 EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 0));
1256 EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 0));
1258 EXPECT_EQ(301 , message.GetExtension(unittest::repeated_int32_extension , 1));
1259 EXPECT_EQ(302 , message.GetExtension(unittest::repeated_int64_extension , 1));
1260 EXPECT_EQ(303 , message.GetExtension(unittest::repeated_uint32_extension , 1));
1261 EXPECT_EQ(304 , message.GetExtension(unittest::repeated_uint64_extension , 1));
1262 EXPECT_EQ(305 , message.GetExtension(unittest::repeated_sint32_extension , 1));
1263 EXPECT_EQ(306 , message.GetExtension(unittest::repeated_sint64_extension , 1));
1264 EXPECT_EQ(307 , message.GetExtension(unittest::repeated_fixed32_extension , 1));
1265 EXPECT_EQ(308 , message.GetExtension(unittest::repeated_fixed64_extension , 1));
1266 EXPECT_EQ(309 , message.GetExtension(unittest::repeated_sfixed32_extension, 1));
1267 EXPECT_EQ(310 , message.GetExtension(unittest::repeated_sfixed64_extension, 1));
1268 EXPECT_EQ(311 , message.GetExtension(unittest::repeated_float_extension , 1));
1269 EXPECT_EQ(312 , message.GetExtension(unittest::repeated_double_extension , 1));
1270 EXPECT_FALSE( message.GetExtension(unittest::repeated_bool_extension , 1));
1271 EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension , 1));
1272 EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension , 1));
1274 EXPECT_EQ(317, message.GetExtension(unittest::repeatedgroup_extension , 1).a());
1275 EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension , 1).bb());
1276 EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension, 1).c());
1277 EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension , 1).d());
1278 EXPECT_EQ(327, message.GetExtension(unittest::repeated_lazy_message_extension , 1).bb());
1280 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.GetExtension(unittest::repeated_nested_enum_extension , 1));
1281 EXPECT_EQ(unittest::FOREIGN_BAZ , message.GetExtension(unittest::repeated_foreign_enum_extension, 1));
1282 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.GetExtension(unittest::repeated_import_enum_extension , 1));
1284 EXPECT_EQ("324", message.GetExtension(unittest::repeated_string_piece_extension, 1));
1285 EXPECT_EQ("325", message.GetExtension(unittest::repeated_cord_extension, 1));
1289 EXPECT_TRUE(message.HasExtension(unittest::default_int32_extension ));
1290 EXPECT_TRUE(message.HasExtension(unittest::default_int64_extension ));
1291 EXPECT_TRUE(message.HasExtension(unittest::default_uint32_extension ));
1292 EXPECT_TRUE(message.HasExtension(unittest::default_uint64_extension ));
1293 EXPECT_TRUE(message.HasExtension(unittest::default_sint32_extension ));
1294 EXPECT_TRUE(message.HasExtension(unittest::default_sint64_extension ));
1295 EXPECT_TRUE(message.HasExtension(unittest::default_fixed32_extension ));
1296 EXPECT_TRUE(message.HasExtension(unittest::default_fixed64_extension ));
1297 EXPECT_TRUE(message.HasExtension(unittest::default_sfixed32_extension));
1298 EXPECT_TRUE(message.HasExtension(unittest::default_sfixed64_extension));
1299 EXPECT_TRUE(message.HasExtension(unittest::default_float_extension ));
1300 EXPECT_TRUE(message.HasExtension(unittest::default_double_extension ));
1301 EXPECT_TRUE(message.HasExtension(unittest::default_bool_extension ));
1302 EXPECT_TRUE(message.HasExtension(unittest::default_string_extension ));
1303 EXPECT_TRUE(message.HasExtension(unittest::default_bytes_extension ));
1305 EXPECT_TRUE(message.HasExtension(unittest::default_nested_enum_extension ));
1306 EXPECT_TRUE(message.HasExtension(unittest::default_foreign_enum_extension));
1307 EXPECT_TRUE(message.HasExtension(unittest::default_import_enum_extension ));
1309 EXPECT_TRUE(message.HasExtension(unittest::default_string_piece_extension));
1310 EXPECT_TRUE(message.HasExtension(unittest::default_cord_extension));
1312 EXPECT_EQ(401 , message.GetExtension(unittest::default_int32_extension ));
1313 EXPECT_EQ(402 , message.GetExtension(unittest::default_int64_extension ));
1314 EXPECT_EQ(403 , message.GetExtension(unittest::default_uint32_extension ));
1315 EXPECT_EQ(404 , message.GetExtension(unittest::default_uint64_extension ));
1316 EXPECT_EQ(405 , message.GetExtension(unittest::default_sint32_extension ));
1317 EXPECT_EQ(406 , message.GetExtension(unittest::default_sint64_extension ));
1318 EXPECT_EQ(407 , message.GetExtension(unittest::default_fixed32_extension ));
1319 EXPECT_EQ(408 , message.GetExtension(unittest::default_fixed64_extension ));
1320 EXPECT_EQ(409 , message.GetExtension(unittest::default_sfixed32_extension));
1321 EXPECT_EQ(410 , message.GetExtension(unittest::default_sfixed64_extension));
1322 EXPECT_EQ(411 , message.GetExtension(unittest::default_float_extension ));
1323 EXPECT_EQ(412 , message.GetExtension(unittest::default_double_extension ));
1324 EXPECT_FALSE( message.GetExtension(unittest::default_bool_extension ));
1325 EXPECT_EQ("415", message.GetExtension(unittest::default_string_extension ));
1326 EXPECT_EQ("416", message.GetExtension(unittest::default_bytes_extension ));
1328 EXPECT_EQ(unittest::TestAllTypes::FOO, message.GetExtension(unittest::default_nested_enum_extension ));
1329 EXPECT_EQ(unittest::FOREIGN_FOO , message.GetExtension(unittest::default_foreign_enum_extension));
1330 EXPECT_EQ(unittest_import::IMPORT_FOO, message.GetExtension(unittest::default_import_enum_extension ));
1332 EXPECT_EQ("424", message.GetExtension(unittest::default_string_piece_extension));
1333 EXPECT_EQ("425", message.GetExtension(unittest::default_cord_extension));
1339 const unittest::TestAllExtensions& message) {
1341 ASSERT_TRUE(message.SerializeToString(&serialized));
1343 EXPECT_EQ(0, message.ByteSize());
1346 EXPECT_FALSE(message.HasExtension(unittest::optional_int32_extension ));
1347 EXPECT_FALSE(message.HasExtension(unittest::optional_int64_extension ));
1348 EXPECT_FALSE(message.HasExtension(unittest::optional_uint32_extension ));
1349 EXPECT_FALSE(message.HasExtension(unittest::optional_uint64_extension ));
1350 EXPECT_FALSE(message.HasExtension(unittest::optional_sint32_extension ));
1351 EXPECT_FALSE(message.HasExtension(unittest::optional_sint64_extension ));
1352 EXPECT_FALSE(message.HasExtension(unittest::optional_fixed32_extension ));
1353 EXPECT_FALSE(message.HasExtension(unittest::optional_fixed64_extension ));
1354 EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed32_extension));
1355 EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed64_extension));
1356 EXPECT_FALSE(message.HasExtension(unittest::optional_float_extension ));
1357 EXPECT_FALSE(message.HasExtension(unittest::optional_double_extension ));
1358 EXPECT_FALSE(message.HasExtension(unittest::optional_bool_extension ));
1359 EXPECT_FALSE(message.HasExtension(unittest::optional_string_extension ));
1360 EXPECT_FALSE(message.HasExtension(unittest::optional_bytes_extension ));
1362 EXPECT_FALSE(message.HasExtension(unittest::optionalgroup_extension ));
1363 EXPECT_FALSE(message.HasExtension(unittest::optional_nested_message_extension ));
1364 EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_message_extension ));
1365 EXPECT_FALSE(message.HasExtension(unittest::optional_import_message_extension ));
1366 EXPECT_FALSE(message.HasExtension(unittest::optional_public_import_message_extension));
1367 EXPECT_FALSE(message.HasExtension(unittest::optional_lazy_message_extension ));
1369 EXPECT_FALSE(message.HasExtension(unittest::optional_nested_enum_extension ));
1370 EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_enum_extension));
1371 EXPECT_FALSE(message.HasExtension(unittest::optional_import_enum_extension ));
1373 EXPECT_FALSE(message.HasExtension(unittest::optional_string_piece_extension));
1374 EXPECT_FALSE(message.HasExtension(unittest::optional_cord_extension));
1377 EXPECT_EQ(0 , message.GetExtension(unittest::optional_int32_extension ));
1378 EXPECT_EQ(0 , message.GetExtension(unittest::optional_int64_extension ));
1379 EXPECT_EQ(0 , message.GetExtension(unittest::optional_uint32_extension ));
1380 EXPECT_EQ(0 , message.GetExtension(unittest::optional_uint64_extension ));
1381 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sint32_extension ));
1382 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sint64_extension ));
1383 EXPECT_EQ(0 , message.GetExtension(unittest::optional_fixed32_extension ));
1384 EXPECT_EQ(0 , message.GetExtension(unittest::optional_fixed64_extension ));
1385 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sfixed32_extension));
1386 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sfixed64_extension));
1387 EXPECT_EQ(0 , message.GetExtension(unittest::optional_float_extension ));
1388 EXPECT_EQ(0 , message.GetExtension(unittest::optional_double_extension ));
1389 EXPECT_FALSE( message.GetExtension(unittest::optional_bool_extension ));
1390 EXPECT_EQ("" , message.GetExtension(unittest::optional_string_extension ));
1391 EXPECT_EQ("" , message.GetExtension(unittest::optional_bytes_extension ));
1394 EXPECT_FALSE(message.GetExtension(unittest::optionalgroup_extension ).has_a());
1395 EXPECT_FALSE(message.GetExtension(unittest::optional_nested_message_extension ).has_bb());
1396 EXPECT_FALSE(message.GetExtension(unittest::optional_foreign_message_extension ).has_c());
1397 EXPECT_FALSE(message.GetExtension(unittest::optional_import_message_extension ).has_d());
1398 EXPECT_FALSE(message.GetExtension(unittest::optional_public_import_message_extension).has_e());
1399 EXPECT_FALSE(message.GetExtension(unittest::optional_lazy_message_extension ).has_bb());
1401 EXPECT_EQ(0, message.GetExtension(unittest::optionalgroup_extension ).a());
1402 EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension ).bb());
1403 EXPECT_EQ(0, message.GetExtension(unittest::optional_foreign_message_extension ).c());
1404 EXPECT_EQ(0, message.GetExtension(unittest::optional_import_message_extension ).d());
1405 EXPECT_EQ(0, message.GetExtension(unittest::optional_public_import_message_extension).e());
1406 EXPECT_EQ(0, message.GetExtension(unittest::optional_lazy_message_extension ).bb());
1409 EXPECT_EQ(unittest::TestAllTypes::FOO, message.GetExtension(unittest::optional_nested_enum_extension ));
1410 EXPECT_EQ(unittest::FOREIGN_FOO , message.GetExtension(unittest::optional_foreign_enum_extension));
1411 EXPECT_EQ(unittest_import::IMPORT_FOO, message.GetExtension(unittest::optional_import_enum_extension ));
1413 EXPECT_EQ("", message.GetExtension(unittest::optional_string_piece_extension));
1414 EXPECT_EQ("", message.GetExtension(unittest::optional_cord_extension));
1417 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int32_extension ));
1418 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int64_extension ));
1419 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint32_extension ));
1420 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint64_extension ));
1421 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint32_extension ));
1422 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint64_extension ));
1423 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed32_extension ));
1424 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed64_extension ));
1425 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed32_extension));
1426 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed64_extension));
1427 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_float_extension ));
1428 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_double_extension ));
1429 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bool_extension ));
1430 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_extension ));
1431 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bytes_extension ));
1433 EXPECT_EQ(0, message.ExtensionSize(unittest::repeatedgroup_extension ));
1434 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_message_extension ));
1435 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_message_extension));
1436 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_message_extension ));
1437 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_lazy_message_extension ));
1438 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_enum_extension ));
1439 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_enum_extension ));
1440 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_enum_extension ));
1442 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_piece_extension));
1443 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_cord_extension));
1446 EXPECT_FALSE(message.HasExtension(unittest::default_int32_extension ));
1447 EXPECT_FALSE(message.HasExtension(unittest::default_int64_extension ));
1448 EXPECT_FALSE(message.HasExtension(unittest::default_uint32_extension ));
1449 EXPECT_FALSE(message.HasExtension(unittest::default_uint64_extension ));
1450 EXPECT_FALSE(message.HasExtension(unittest::default_sint32_extension ));
1451 EXPECT_FALSE(message.HasExtension(unittest::default_sint64_extension ));
1452 EXPECT_FALSE(message.HasExtension(unittest::default_fixed32_extension ));
1453 EXPECT_FALSE(message.HasExtension(unittest::default_fixed64_extension ));
1454 EXPECT_FALSE(message.HasExtension(unittest::default_sfixed32_extension));
1455 EXPECT_FALSE(message.HasExtension(unittest::default_sfixed64_extension));
1456 EXPECT_FALSE(message.HasExtension(unittest::default_float_extension ));
1457 EXPECT_FALSE(message.HasExtension(unittest::default_double_extension ));
1458 EXPECT_FALSE(message.HasExtension(unittest::default_bool_extension ));
1459 EXPECT_FALSE(message.HasExtension(unittest::default_string_extension ));
1460 EXPECT_FALSE(message.HasExtension(unittest::default_bytes_extension ));
1462 EXPECT_FALSE(message.HasExtension(unittest::default_nested_enum_extension ));
1463 EXPECT_FALSE(message.HasExtension(unittest::default_foreign_enum_extension));
1464 EXPECT_FALSE(message.HasExtension(unittest::default_import_enum_extension ));
1466 EXPECT_FALSE(message.HasExtension(unittest::default_string_piece_extension));
1467 EXPECT_FALSE(message.HasExtension(unittest::default_cord_extension));
1470 EXPECT_EQ( 41 , message.GetExtension(unittest::default_int32_extension ));
1471 EXPECT_EQ( 42 , message.GetExtension(unittest::default_int64_extension ));
1472 EXPECT_EQ( 43 , message.GetExtension(unittest::default_uint32_extension ));
1473 EXPECT_EQ( 44 , message.GetExtension(unittest::default_uint64_extension ));
1474 EXPECT_EQ(-45 , message.GetExtension(unittest::default_sint32_extension ));
1475 EXPECT_EQ( 46 , message.GetExtension(unittest::default_sint64_extension ));
1476 EXPECT_EQ( 47 , message.GetExtension(unittest::default_fixed32_extension ));
1477 EXPECT_EQ( 48 , message.GetExtension(unittest::default_fixed64_extension ));
1478 EXPECT_EQ( 49 , message.GetExtension(unittest::default_sfixed32_extension));
1479 EXPECT_EQ(-50 , message.GetExtension(unittest::default_sfixed64_extension));
1480 EXPECT_EQ( 51.5 , message.GetExtension(unittest::default_float_extension ));
1481 EXPECT_EQ( 52e3 , message.GetExtension(unittest::default_double_extension ));
1482 EXPECT_TRUE( message.GetExtension(unittest::default_bool_extension ));
1483 EXPECT_EQ("hello", message.GetExtension(unittest::default_string_extension ));
1484 EXPECT_EQ("world", message.GetExtension(unittest::default_bytes_extension ));
1486 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::default_nested_enum_extension ));
1487 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::default_foreign_enum_extension));
1488 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::default_import_enum_extension ));
1490 EXPECT_EQ("abc", message.GetExtension(unittest::default_string_piece_extension));
1491 EXPECT_EQ("123", message.GetExtension(unittest::default_cord_extension));
1497 const unittest::TestAllExtensions& message) {
1501 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension ));
1502 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension ));
1503 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension ));
1504 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension ));
1505 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension ));
1506 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension ));
1507 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension ));
1508 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension ));
1509 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension));
1510 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension));
1511 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension ));
1512 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension ));
1513 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension ));
1514 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension ));
1515 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension ));
1517 ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension ));
1518 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension ));
1519 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension));
1520 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension ));
1521 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension ));
1522 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension ));
1523 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension ));
1524 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension ));
1526 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_piece_extension));
1527 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_cord_extension));
1529 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension , 0));
1530 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension , 0));
1531 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension , 0));
1532 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension , 0));
1533 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension , 0));
1534 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension , 0));
1535 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension , 0));
1536 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension , 0));
1537 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension, 0));
1538 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 0));
1539 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 0));
1540 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 0));
1541 EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 0));
1542 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 0));
1543 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 0));
1545 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 0).a());
1546 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb());
1547 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c());
1548 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d());
1549 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb());
1551 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 0));
1552 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 0));
1553 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 0));
1555 EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 0));
1556 EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 0));
1559 EXPECT_EQ(501 , message.GetExtension(unittest::repeated_int32_extension , 1));
1560 EXPECT_EQ(502 , message.GetExtension(unittest::repeated_int64_extension , 1));
1561 EXPECT_EQ(503 , message.GetExtension(unittest::repeated_uint32_extension , 1));
1562 EXPECT_EQ(504 , message.GetExtension(unittest::repeated_uint64_extension , 1));
1563 EXPECT_EQ(505 , message.GetExtension(unittest::repeated_sint32_extension , 1));
1564 EXPECT_EQ(506 , message.GetExtension(unittest::repeated_sint64_extension , 1));
1565 EXPECT_EQ(507 , message.GetExtension(unittest::repeated_fixed32_extension , 1));
1566 EXPECT_EQ(508 , message.GetExtension(unittest::repeated_fixed64_extension , 1));
1567 EXPECT_EQ(509 , message.GetExtension(unittest::repeated_sfixed32_extension, 1));
1568 EXPECT_EQ(510 , message.GetExtension(unittest::repeated_sfixed64_extension, 1));
1569 EXPECT_EQ(511 , message.GetExtension(unittest::repeated_float_extension , 1));
1570 EXPECT_EQ(512 , message.GetExtension(unittest::repeated_double_extension , 1));
1571 EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 1));
1572 EXPECT_EQ("515", message.GetExtension(unittest::repeated_string_extension , 1));
1573 EXPECT_EQ("516", message.GetExtension(unittest::repeated_bytes_extension , 1));
1575 EXPECT_EQ(517, message.GetExtension(unittest::repeatedgroup_extension , 1).a());
1576 EXPECT_EQ(518, message.GetExtension(unittest::repeated_nested_message_extension , 1).bb());
1577 EXPECT_EQ(519, message.GetExtension(unittest::repeated_foreign_message_extension, 1).c());
1578 EXPECT_EQ(520, message.GetExtension(unittest::repeated_import_message_extension , 1).d());
1579 EXPECT_EQ(527, message.GetExtension(unittest::repeated_lazy_message_extension , 1).bb());
1581 EXPECT_EQ(unittest::TestAllTypes::FOO, message.GetExtension(unittest::repeated_nested_enum_extension , 1));
1582 EXPECT_EQ(unittest::FOREIGN_FOO , message.GetExtension(unittest::repeated_foreign_enum_extension, 1));
1583 EXPECT_EQ(unittest_import::IMPORT_FOO, message.GetExtension(unittest::repeated_import_enum_extension , 1));
1585 EXPECT_EQ("524", message.GetExtension(unittest::repeated_string_piece_extension, 1));
1586 EXPECT_EQ("525", message.GetExtension(unittest::repeated_cord_extension, 1));
1591 void TestUtil::SetPackedExtensions(unittest::TestPackedExtensions* message) {
1592 message->AddExtension(unittest::packed_int32_extension , 601);
1593 message->AddExtension(unittest::packed_int64_extension , 602);
1594 message->AddExtension(unittest::packed_uint32_extension , 603);
1595 message->AddExtension(unittest::packed_uint64_extension , 604);
1596 message->AddExtension(unittest::packed_sint32_extension , 605);
1597 message->AddExtension(unittest::packed_sint64_extension , 606);
1598 message->AddExtension(unittest::packed_fixed32_extension , 607);
1599 message->AddExtension(unittest::packed_fixed64_extension , 608);
1600 message->AddExtension(unittest::packed_sfixed32_extension, 609);
1601 message->AddExtension(unittest::packed_sfixed64_extension, 610);
1602 message->AddExtension(unittest::packed_float_extension , 611);
1603 message->AddExtension(unittest::packed_double_extension , 612);
1604 message->AddExtension(unittest::packed_bool_extension , true);
1605 message->AddExtension(unittest::packed_enum_extension, unittest::FOREIGN_BAR);
1607 message->AddExtension(unittest::packed_int32_extension , 701);
1608 message->AddExtension(unittest::packed_int64_extension , 702);
1609 message->AddExtension(unittest::packed_uint32_extension , 703);
1610 message->AddExtension(unittest::packed_uint64_extension , 704);
1611 message->AddExtension(unittest::packed_sint32_extension , 705);
1612 message->AddExtension(unittest::packed_sint64_extension , 706);
1613 message->AddExtension(unittest::packed_fixed32_extension , 707);
1614 message->AddExtension(unittest::packed_fixed64_extension , 708);
1615 message->AddExtension(unittest::packed_sfixed32_extension, 709);
1616 message->AddExtension(unittest::packed_sfixed64_extension, 710);
1617 message->AddExtension(unittest::packed_float_extension , 711);
1618 message->AddExtension(unittest::packed_double_extension , 712);
1619 message->AddExtension(unittest::packed_bool_extension , false);
1620 message->AddExtension(unittest::packed_enum_extension, unittest::FOREIGN_BAZ);
1625 void TestUtil::ModifyPackedExtensions(unittest::TestPackedExtensions* message) {
1626 message->SetExtension(unittest::packed_int32_extension , 1, 801);
1627 message->SetExtension(unittest::packed_int64_extension , 1, 802);
1628 message->SetExtension(unittest::packed_uint32_extension , 1, 803);
1629 message->SetExtension(unittest::packed_uint64_extension , 1, 804);
1630 message->SetExtension(unittest::packed_sint32_extension , 1, 805);
1631 message->SetExtension(unittest::packed_sint64_extension , 1, 806);
1632 message->SetExtension(unittest::packed_fixed32_extension , 1, 807);
1633 message->SetExtension(unittest::packed_fixed64_extension , 1, 808);
1634 message->SetExtension(unittest::packed_sfixed32_extension, 1, 809);
1635 message->SetExtension(unittest::packed_sfixed64_extension, 1, 810);
1636 message->SetExtension(unittest::packed_float_extension , 1, 811);
1637 message->SetExtension(unittest::packed_double_extension , 1, 812);
1638 message->SetExtension(unittest::packed_bool_extension , 1, true);
1639 message->SetExtension(unittest::packed_enum_extension , 1,
1646 const unittest::TestPackedExtensions& message) {
1647 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension ));
1648 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension ));
1649 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension ));
1650 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension ));
1651 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension ));
1652 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension ));
1653 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension ));
1654 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension ));
1655 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension));
1656 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension));
1657 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension ));
1658 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension ));
1659 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension ));
1660 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension ));
1662 EXPECT_EQ(601 , message.GetExtension(unittest::packed_int32_extension , 0));
1663 EXPECT_EQ(602 , message.GetExtension(unittest::packed_int64_extension , 0));
1664 EXPECT_EQ(603 , message.GetExtension(unittest::packed_uint32_extension , 0));
1665 EXPECT_EQ(604 , message.GetExtension(unittest::packed_uint64_extension , 0));
1666 EXPECT_EQ(605 , message.GetExtension(unittest::packed_sint32_extension , 0));
1667 EXPECT_EQ(606 , message.GetExtension(unittest::packed_sint64_extension , 0));
1668 EXPECT_EQ(607 , message.GetExtension(unittest::packed_fixed32_extension , 0));
1669 EXPECT_EQ(608 , message.GetExtension(unittest::packed_fixed64_extension , 0));
1670 EXPECT_EQ(609 , message.GetExtension(unittest::packed_sfixed32_extension, 0));
1671 EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension, 0));
1672 EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension , 0));
1673 EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension , 0));
1674 EXPECT_TRUE( message.GetExtension(unittest::packed_bool_extension , 0));
1676 message.GetExtension(unittest::packed_enum_extension, 0));
1677 EXPECT_EQ(701 , message.GetExtension(unittest::packed_int32_extension , 1));
1678 EXPECT_EQ(702 , message.GetExtension(unittest::packed_int64_extension , 1));
1679 EXPECT_EQ(703 , message.GetExtension(unittest::packed_uint32_extension , 1));
1680 EXPECT_EQ(704 , message.GetExtension(unittest::packed_uint64_extension , 1));
1681 EXPECT_EQ(705 , message.GetExtension(unittest::packed_sint32_extension , 1));
1682 EXPECT_EQ(706 , message.GetExtension(unittest::packed_sint64_extension , 1));
1683 EXPECT_EQ(707 , message.GetExtension(unittest::packed_fixed32_extension , 1));
1684 EXPECT_EQ(708 , message.GetExtension(unittest::packed_fixed64_extension , 1));
1685 EXPECT_EQ(709 , message.GetExtension(unittest::packed_sfixed32_extension, 1));
1686 EXPECT_EQ(710 , message.GetExtension(unittest::packed_sfixed64_extension, 1));
1687 EXPECT_EQ(711 , message.GetExtension(unittest::packed_float_extension , 1));
1688 EXPECT_EQ(712 , message.GetExtension(unittest::packed_double_extension , 1));
1689 EXPECT_FALSE( message.GetExtension(unittest::packed_bool_extension , 1));
1691 message.GetExtension(unittest::packed_enum_extension, 1));
1697 const unittest::TestPackedExtensions& message) {
1698 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int32_extension ));
1699 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int64_extension ));
1700 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint32_extension ));
1701 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint64_extension ));
1702 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint32_extension ));
1703 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint64_extension ));
1704 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed32_extension ));
1705 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed64_extension ));
1706 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed32_extension));
1707 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed64_extension));
1708 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_float_extension ));
1709 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_double_extension ));
1710 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_bool_extension ));
1711 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_enum_extension ));
1717 const unittest::TestPackedExtensions& message) {
1718 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension ));
1719 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension ));
1720 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension ));
1721 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension ));
1722 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension ));
1723 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension ));
1724 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension ));
1725 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension ));
1726 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension));
1727 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension));
1728 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension ));
1729 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension ));
1730 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension ));
1731 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension ));
1732 EXPECT_EQ(601 , message.GetExtension(unittest::packed_int32_extension , 0));
1733 EXPECT_EQ(602 , message.GetExtension(unittest::packed_int64_extension , 0));
1734 EXPECT_EQ(603 , message.GetExtension(unittest::packed_uint32_extension , 0));
1735 EXPECT_EQ(604 , message.GetExtension(unittest::packed_uint64_extension , 0));
1736 EXPECT_EQ(605 , message.GetExtension(unittest::packed_sint32_extension , 0));
1737 EXPECT_EQ(606 , message.GetExtension(unittest::packed_sint64_extension , 0));
1738 EXPECT_EQ(607 , message.GetExtension(unittest::packed_fixed32_extension , 0));
1739 EXPECT_EQ(608 , message.GetExtension(unittest::packed_fixed64_extension , 0));
1740 EXPECT_EQ(609 , message.GetExtension(unittest::packed_sfixed32_extension, 0));
1741 EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension, 0));
1742 EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension , 0));
1743 EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension , 0));
1744 EXPECT_TRUE( message.GetExtension(unittest::packed_bool_extension , 0));
1746 message.GetExtension(unittest::packed_enum_extension, 0));
1749 EXPECT_EQ(801 , message.GetExtension(unittest::packed_int32_extension , 1));
1750 EXPECT_EQ(802 , message.GetExtension(unittest::packed_int64_extension , 1));
1751 EXPECT_EQ(803 , message.GetExtension(unittest::packed_uint32_extension , 1));
1752 EXPECT_EQ(804 , message.GetExtension(unittest::packed_uint64_extension , 1));
1753 EXPECT_EQ(805 , message.GetExtension(unittest::packed_sint32_extension , 1));
1754 EXPECT_EQ(806 , message.GetExtension(unittest::packed_sint64_extension , 1));
1755 EXPECT_EQ(807 , message.GetExtension(unittest::packed_fixed32_extension , 1));
1756 EXPECT_EQ(808 , message.GetExtension(unittest::packed_fixed64_extension , 1));
1757 EXPECT_EQ(809 , message.GetExtension(unittest::packed_sfixed32_extension, 1));
1758 EXPECT_EQ(810 , message.GetExtension(unittest::packed_sfixed64_extension, 1));
1759 EXPECT_EQ(811 , message.GetExtension(unittest::packed_float_extension , 1));
1760 EXPECT_EQ(812 , message.GetExtension(unittest::packed_double_extension , 1));
1761 EXPECT_TRUE( message.GetExtension(unittest::packed_bool_extension , 1));
1763 message.GetExtension(unittest::packed_enum_extension, 1));
1772 unittest::TestFieldOrderings message;
1773 message.set_my_int(1); // Field 1.
1774 message.AppendToString(&expected);
1775 message.Clear();
1776 message.SetExtension(unittest::my_extension_int, 23); // Field 5.
1777 message.AppendToString(&expected);
1778 message.Clear();
1779 message.set_my_string("foo"); // Field 11.
1780 message.AppendToString(&expected);
1781 message.Clear();
1782 message.SetExtension(unittest::my_extension_string, "bar"); // Field 50.
1783 message.AppendToString(&expected);
1784 message.Clear();
1785 message.set_my_float(1.0); // Field 101.
1786 message.AppendToString(&expected);
1787 message.Clear();
1794 const unittest::TestAllTypes& message) {
1795 ASSERT_EQ(1, message.repeated_int32_size ());
1796 ASSERT_EQ(1, message.repeated_int64_size ());
1797 ASSERT_EQ(1, message.repeated_uint32_size ());
1798 ASSERT_EQ(1, message.repeated_uint64_size ());
1799 ASSERT_EQ(1, message.repeated_sint32_size ());
1800 ASSERT_EQ(1, message.repeated_sint64_size ());
1801 ASSERT_EQ(1, message.repeated_fixed32_size ());
1802 ASSERT_EQ(1, message.repeated_fixed64_size ());
1803 ASSERT_EQ(1, message.repeated_sfixed32_size());
1804 ASSERT_EQ(1, message.repeated_sfixed64_size());
1805 ASSERT_EQ(1, message.repeated_float_size ());
1806 ASSERT_EQ(1, message.repeated_double_size ());
1807 ASSERT_EQ(1, message.repeated_bool_size ());
1808 ASSERT_EQ(1, message.repeated_string_size ());
1809 ASSERT_EQ(1, message.repeated_bytes_size ());
1811 ASSERT_EQ(1, message.repeatedgroup_size ());
1812 ASSERT_EQ(1, message.repeated_nested_message_size ());
1813 ASSERT_EQ(1, message.repeated_foreign_message_size());
1814 ASSERT_EQ(1, message.repeated_import_message_size ());
1815 ASSERT_EQ(1, message.repeated_import_message_size ());
1816 ASSERT_EQ(1, message.repeated_nested_enum_size ());
1817 ASSERT_EQ(1, message.repeated_foreign_enum_size ());
1818 ASSERT_EQ(1, message.repeated_import_enum_size ());
1821 ASSERT_EQ(1, message.repeated_string_piece_size());
1822 ASSERT_EQ(1, message.repeated_cord_size());
1826 EXPECT_EQ(201 , message.repeated_int32 (0));
1827 EXPECT_EQ(202 , message.repeated_int64 (0));
1828 EXPECT_EQ(203 , message.repeated_uint32 (0));
1829 EXPECT_EQ(204 , message.repeated_uint64 (0));
1830 EXPECT_EQ(205 , message.repeated_sint32 (0));
1831 EXPECT_EQ(206 , message.repeated_sint64 (0));
1832 EXPECT_EQ(207 , message.repeated_fixed32 (0));
1833 EXPECT_EQ(208 , message.repeated_fixed64 (0));
1834 EXPECT_EQ(209 , message.repeated_sfixed32(0));
1835 EXPECT_EQ(210 , message.repeated_sfixed64(0));
1836 EXPECT_EQ(211 , message.repeated_float (0));
1837 EXPECT_EQ(212 , message.repeated_double (0));
1838 EXPECT_TRUE( message.repeated_bool (0));
1839 EXPECT_EQ("215", message.repeated_string (0));
1840 EXPECT_EQ("216", message.repeated_bytes (0));
1842 EXPECT_EQ(217, message.repeatedgroup (0).a());
1843 EXPECT_EQ(218, message.repeated_nested_message (0).bb());
1844 EXPECT_EQ(219, message.repeated_foreign_message(0).c());
1845 EXPECT_EQ(220, message.repeated_import_message (0).d());
1846 EXPECT_EQ(220, message.repeated_import_message (0).d());
1848 EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (0));
1849 EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(0));
1850 EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (0));
1854 const unittest::TestAllExtensions& message) {
1857 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_int32_extension ));
1858 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_int64_extension ));
1859 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_uint32_extension ));
1860 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_uint64_extension ));
1861 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sint32_extension ));
1862 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sint64_extension ));
1863 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_fixed32_extension ));
1864 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_fixed64_extension ));
1865 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sfixed32_extension));
1866 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sfixed64_extension));
1867 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_float_extension ));
1868 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_double_extension ));
1869 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_bool_extension ));
1870 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_string_extension ));
1871 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_bytes_extension ));
1873 ASSERT_EQ(1, message.ExtensionSize(unittest::repeatedgroup_extension ));
1874 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_nested_message_extension ));
1875 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_foreign_message_extension));
1876 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_import_message_extension ));
1877 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_lazy_message_extension ));
1878 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_nested_enum_extension ));
1879 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_foreign_enum_extension ));
1880 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_import_enum_extension ));
1882 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_string_piece_extension));
1883 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_cord_extension));
1886 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension , 0));
1887 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension , 0));
1888 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension , 0));
1889 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension , 0));
1890 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension , 0));
1891 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension , 0));
1892 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension , 0));
1893 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension , 0));
1894 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension, 0));
1895 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 0));
1896 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 0));
1897 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 0));
1898 EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 0));
1899 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 0));
1900 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 0));
1902 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 0).a());
1903 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb());
1904 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c());
1905 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d());
1906 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb());
1908 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 0));
1909 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 0));
1910 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 0));
1912 EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 0));
1913 EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 0));
1917 const unittest::TestAllTypes& message) {
1918 ASSERT_EQ(1, message.repeatedgroup_size ());
1919 ASSERT_EQ(1, message.repeated_nested_message_size ());
1920 ASSERT_EQ(1, message.repeated_foreign_message_size());
1921 ASSERT_EQ(1, message.repeated_import_message_size ());
1922 ASSERT_EQ(1, message.repeated_import_message_size ());
1924 EXPECT_EQ(217, message.repeatedgroup (0).a());
1925 EXPECT_EQ(218, message.repeated_nested_message (0).bb());
1926 EXPECT_EQ(219, message.repeated_foreign_message(0).c());
1927 EXPECT_EQ(220, message.repeated_import_message (0).d());
1928 EXPECT_EQ(220, message.repeated_import_message (0).d());
1932 const unittest::TestAllExtensions& message) {
1933 ASSERT_EQ(1, message.ExtensionSize(unittest::repeatedgroup_extension ));
1934 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_nested_message_extension ));
1935 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_foreign_message_extension));
1936 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_import_message_extension ));
1937 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_lazy_message_extension ));
1939 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 0).a());
1940 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb());
1941 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c());
1942 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d());
1943 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb());
1947 const unittest::TestAllTypes& message) {
1948 ASSERT_EQ(2, message.repeated_int32_size ());
1949 ASSERT_EQ(2, message.repeated_int64_size ());
1950 ASSERT_EQ(2, message.repeated_uint32_size ());
1951 ASSERT_EQ(2, message.repeated_uint64_size ());
1952 ASSERT_EQ(2, message.repeated_sint32_size ());
1953 ASSERT_EQ(2, message.repeated_sint64_size ());
1954 ASSERT_EQ(2, message.repeated_fixed32_size ());
1955 ASSERT_EQ(2, message.repeated_fixed64_size ());
1956 ASSERT_EQ(2, message.repeated_sfixed32_size());
1957 ASSERT_EQ(2, message.repeated_sfixed64_size());
1958 ASSERT_EQ(2, message.repeated_float_size ());
1959 ASSERT_EQ(2, message.repeated_double_size ());
1960 ASSERT_EQ(2, message.repeated_bool_size ());
1961 ASSERT_EQ(2, message.repeated_string_size ());
1962 ASSERT_EQ(2, message.repeated_bytes_size ());
1964 ASSERT_EQ(2, message.repeatedgroup_size ());
1965 ASSERT_EQ(2, message.repeated_nested_message_size ());
1966 ASSERT_EQ(2, message.repeated_foreign_message_size());
1967 ASSERT_EQ(2, message.repeated_import_message_size ());
1968 ASSERT_EQ(2, message.repeated_import_message_size ());
1969 ASSERT_EQ(2, message.repeated_nested_enum_size ());
1970 ASSERT_EQ(2, message.repeated_foreign_enum_size ());
1971 ASSERT_EQ(2, message.repeated_import_enum_size ());
1974 ASSERT_EQ(2, message.repeated_string_piece_size());
1975 ASSERT_EQ(2, message.repeated_cord_size());
1979 EXPECT_EQ(201 , message.repeated_int32 (1));
1980 EXPECT_EQ(202 , message.repeated_int64 (1));
1981 EXPECT_EQ(203 , message.repeated_uint32 (1));
1982 EXPECT_EQ(204 , message.repeated_uint64 (1));
1983 EXPECT_EQ(205 , message.repeated_sint32 (1));
1984 EXPECT_EQ(206 , message.repeated_sint64 (1));
1985 EXPECT_EQ(207 , message.repeated_fixed32 (1));
1986 EXPECT_EQ(208 , message.repeated_fixed64 (1));
1987 EXPECT_EQ(209 , message.repeated_sfixed32(1));
1988 EXPECT_EQ(210 , message.repeated_sfixed64(1));
1989 EXPECT_EQ(211 , message.repeated_float (1));
1990 EXPECT_EQ(212 , message.repeated_double (1));
1991 EXPECT_TRUE( message.repeated_bool (1));
1992 EXPECT_EQ("215", message.repeated_string (1));
1993 EXPECT_EQ("216", message.repeated_bytes (1));
1995 EXPECT_EQ(217, message.repeatedgroup (1).a());
1996 EXPECT_EQ(218, message.repeated_nested_message (1).bb());
1997 EXPECT_EQ(219, message.repeated_foreign_message(1).c());
1998 EXPECT_EQ(220, message.repeated_import_message (1).d());
1999 EXPECT_EQ(220, message.repeated_import_message (1).d());
2001 EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (1));
2002 EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(1));
2003 EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (1));
2005 EXPECT_EQ(301 , message.repeated_int32 (0));
2006 EXPECT_EQ(302 , message.repeated_int64 (0));
2007 EXPECT_EQ(303 , message.repeated_uint32 (0));
2008 EXPECT_EQ(304 , message.repeated_uint64 (0));
2009 EXPECT_EQ(305 , message.repeated_sint32 (0));
2010 EXPECT_EQ(306 , message.repeated_sint64 (0));
2011 EXPECT_EQ(307 , message.repeated_fixed32 (0));
2012 EXPECT_EQ(308 , message.repeated_fixed64 (0));
2013 EXPECT_EQ(309 , message.repeated_sfixed32(0));
2014 EXPECT_EQ(310 , message.repeated_sfixed64(0));
2015 EXPECT_EQ(311 , message.repeated_float (0));
2016 EXPECT_EQ(312 , message.repeated_double (0));
2017 EXPECT_FALSE( message.repeated_bool (0));
2018 EXPECT_EQ("315", message.repeated_string (0));
2019 EXPECT_EQ("316", message.repeated_bytes (0));
2021 EXPECT_EQ(317, message.repeatedgroup (0).a());
2022 EXPECT_EQ(318, message.repeated_nested_message (0).bb());
2023 EXPECT_EQ(319, message.repeated_foreign_message(0).c());
2024 EXPECT_EQ(320, message.repeated_import_message (0).d());
2025 EXPECT_EQ(320, message.repeated_import_message (0).d());
2027 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.repeated_nested_enum (0));
2028 EXPECT_EQ(unittest::FOREIGN_BAZ , message.repeated_foreign_enum(0));
2029 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.repeated_import_enum (0));
2033 const unittest::TestAllExtensions& message) {
2035 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension ));
2036 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension ));
2037 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension ));
2038 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension ));
2039 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension ));
2040 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension ));
2041 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension ));
2042 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension ));
2043 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension));
2044 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension));
2045 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension ));
2046 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension ));
2047 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension ));
2048 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension ));
2049 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension ));
2051 ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension ));
2052 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension ));
2053 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension));
2054 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension ));
2055 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension ));
2056 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension ));
2057 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension ));
2058 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension ));
2060 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_piece_extension));
2061 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_cord_extension));
2063 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension , 1));
2064 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension , 1));
2065 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension , 1));
2066 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension , 1));
2067 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension , 1));
2068 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension , 1));
2069 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension , 1));
2070 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension , 1));
2071 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension, 1));
2072 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 1));
2073 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 1));
2074 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 1));
2075 EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 1));
2076 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 1));
2077 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 1));
2079 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 1).a());
2080 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 1).bb());
2081 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 1).c());
2082 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 1).d());
2083 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 1).bb());
2085 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 1));
2086 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 1));
2087 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 1));
2089 EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 1));
2090 EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 1));
2092 EXPECT_EQ(301 , message.GetExtension(unittest::repeated_int32_extension , 0));
2093 EXPECT_EQ(302 , message.GetExtension(unittest::repeated_int64_extension , 0));
2094 EXPECT_EQ(303 , message.GetExtension(unittest::repeated_uint32_extension , 0));
2095 EXPECT_EQ(304 , message.GetExtension(unittest::repeated_uint64_extension , 0));
2096 EXPECT_EQ(305 , message.GetExtension(unittest::repeated_sint32_extension , 0));
2097 EXPECT_EQ(306 , message.GetExtension(unittest::repeated_sint64_extension , 0));
2098 EXPECT_EQ(307 , message.GetExtension(unittest::repeated_fixed32_extension , 0));
2099 EXPECT_EQ(308 , message.GetExtension(unittest::repeated_fixed64_extension , 0));
2100 EXPECT_EQ(309 , message.GetExtension(unittest::repeated_sfixed32_extension, 0));
2101 EXPECT_EQ(310 , message.GetExtension(unittest::repeated_sfixed64_extension, 0));
2102 EXPECT_EQ(311 , message.GetExtension(unittest::repeated_float_extension , 0));
2103 EXPECT_EQ(312 , message.GetExtension(unittest::repeated_double_extension , 0));
2104 EXPECT_FALSE( message.GetExtension(unittest::repeated_bool_extension , 0));
2105 EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension , 0));
2106 EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension , 0));
2108 EXPECT_EQ(317, message.GetExtension(unittest::repeatedgroup_extension , 0).a());
2109 EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb());
2110 EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c());
2111 EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension , 0).d());
2112 EXPECT_EQ(327, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb());
2114 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.GetExtension(unittest::repeated_nested_enum_extension , 0));
2115 EXPECT_EQ(unittest::FOREIGN_BAZ , message.GetExtension(unittest::repeated_foreign_enum_extension, 0));
2116 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.GetExtension(unittest::repeated_import_enum_extension , 0));
2118 EXPECT_EQ("324", message.GetExtension(unittest::repeated_string_piece_extension, 0));
2119 EXPECT_EQ("325", message.GetExtension(unittest::repeated_cord_extension, 0));
2201 void TestUtil::ReflectionTester::SetAllFieldsViaReflection(Message* message) {
2202 const Reflection* reflection = message->GetReflection();
2205 reflection->SetInt32 (message, F("optional_int32" ), 101);
2206 reflection->SetInt64 (message, F("optional_int64" ), 102);
2207 reflection->SetUInt32(message, F("optional_uint32" ), 103);
2208 reflection->SetUInt64(message, F("optional_uint64" ), 104);
2209 reflection->SetInt32 (message, F("optional_sint32" ), 105);
2210 reflection->SetInt64 (message, F("optional_sint64" ), 106);
2211 reflection->SetUInt32(message, F("optional_fixed32" ), 107);
2212 reflection->SetUInt64(message, F("optional_fixed64" ), 108);
2213 reflection->SetInt32 (message, F("optional_sfixed32"), 109);
2214 reflection->SetInt64 (message, F("optional_sfixed64"), 110);
2215 reflection->SetFloat (message, F("optional_float" ), 111);
2216 reflection->SetDouble(message, F("optional_double" ), 112);
2217 reflection->SetBool (message, F("optional_bool" ), true);
2218 reflection->SetString(message, F("optional_string" ), "115");
2219 reflection->SetString(message, F("optional_bytes" ), "116");
2221 sub_message = reflection->MutableMessage(message, F("optionalgroup"));
2223 sub_message = reflection->MutableMessage(message, F("optional_nested_message"));
2225 sub_message = reflection->MutableMessage(message, F("optional_foreign_message"));
2227 sub_message = reflection->MutableMessage(message, F("optional_import_message"));
2230 reflection->SetEnum(message, F("optional_nested_enum" ), nested_baz_);
2231 reflection->SetEnum(message, F("optional_foreign_enum"), foreign_baz_);
2232 reflection->SetEnum(message, F("optional_import_enum" ), import_baz_);
2234 reflection->SetString(message, F("optional_string_piece"), "124");
2235 reflection->SetString(message, F("optional_cord"), "125");
2237 sub_message = reflection->MutableMessage(message, F("optional_public_import_message"));
2240 sub_message = reflection->MutableMessage(message, F("optional_lazy_message"));
2245 reflection->AddInt32 (message, F("repeated_int32" ), 201);
2246 reflection->AddInt64 (message, F("repeated_int64" ), 202);
2247 reflection->AddUInt32(message, F("repeated_uint32" ), 203);
2248 reflection->AddUInt64(message, F("repeated_uint64" ), 204);
2249 reflection->AddInt32 (message, F("repeated_sint32" ), 205);
2250 reflection->AddInt64 (message, F("repeated_sint64" ), 206);
2251 reflection->AddUInt32(message, F("repeated_fixed32" ), 207);
2252 reflection->AddUInt64(message, F("repeated_fixed64" ), 208);
2253 reflection->AddInt32 (message, F("repeated_sfixed32"), 209);
2254 reflection->AddInt64 (message, F("repeated_sfixed64"), 210);
2255 reflection->AddFloat (message, F("repeated_float" ), 211);
2256 reflection->AddDouble(message, F("repeated_double" ), 212);
2257 reflection->AddBool (message, F("repeated_bool" ), true);
2258 reflection->AddString(message, F("repeated_string" ), "215");
2259 reflection->AddString(message, F("repeated_bytes" ), "216");
2261 sub_message = reflection->AddMessage(message, F("repeatedgroup"));
2263 sub_message = reflection->AddMessage(message, F("repeated_nested_message"));
2265 sub_message = reflection->AddMessage(message, F("repeated_foreign_message"));
2267 sub_message = reflection->AddMessage(message, F("repeated_import_message"));
2269 sub_message = reflection->AddMessage(message, F("repeated_lazy_message"));
2272 reflection->AddEnum(message, F("repeated_nested_enum" ), nested_bar_);
2273 reflection->AddEnum(message, F("repeated_foreign_enum"), foreign_bar_);
2274 reflection->AddEnum(message, F("repeated_import_enum" ), import_bar_);
2276 reflection->AddString(message, F("repeated_string_piece"), "224");
2277 reflection->AddString(message, F("repeated_cord"), "225");
2280 reflection->AddInt32 (message, F("repeated_int32" ), 301);
2281 reflection->AddInt64 (message, F("repeated_int64" ), 302);
2282 reflection->AddUInt32(message, F("repeated_uint32" ), 303);
2283 reflection->AddUInt64(message, F("repeated_uint64" ), 304);
2284 reflection->AddInt32 (message, F("repeated_sint32" ), 305);
2285 reflection->AddInt64 (message, F("repeated_sint64" ), 306);
2286 reflection->AddUInt32(message, F("repeated_fixed32" ), 307);
2287 reflection->AddUInt64(message, F("repeated_fixed64" ), 308);
2288 reflection->AddInt32 (message, F("repeated_sfixed32"), 309);
2289 reflection->AddInt64 (message, F("repeated_sfixed64"), 310);
2290 reflection->AddFloat (message, F("repeated_float" ), 311);
2291 reflection->AddDouble(message, F("repeated_double" ), 312);
2292 reflection->AddBool (message, F("repeated_bool" ), false);
2293 reflection->AddString(message, F("repeated_string" ), "315");
2294 reflection->AddString(message, F("repeated_bytes" ), "316");
2296 sub_message = reflection->AddMessage(message, F("repeatedgroup"));
2298 sub_message = reflection->AddMessage(message, F("repeated_nested_message"));
2300 sub_message = reflection->AddMessage(message, F("repeated_foreign_message"));
2302 sub_message = reflection->AddMessage(message, F("repeated_import_message"));
2304 sub_message = reflection->AddMessage(message, F("repeated_lazy_message"));
2307 reflection->AddEnum(message, F("repeated_nested_enum" ), nested_baz_);
2308 reflection->AddEnum(message, F("repeated_foreign_enum"), foreign_baz_);
2309 reflection->AddEnum(message, F("repeated_import_enum" ), import_baz_);
2311 reflection->AddString(message, F("repeated_string_piece"), "324");
2312 reflection->AddString(message, F("repeated_cord"), "325");
2316 reflection->SetInt32 (message, F("default_int32" ), 401);
2317 reflection->SetInt64 (message, F("default_int64" ), 402);
2318 reflection->SetUInt32(message, F("default_uint32" ), 403);
2319 reflection->SetUInt64(message, F("default_uint64" ), 404);
2320 reflection->SetInt32 (message, F("default_sint32" ), 405);
2321 reflection->SetInt64 (message, F("default_sint64" ), 406);
2322 reflection->SetUInt32(message, F("default_fixed32" ), 407);
2323 reflection->SetUInt64(message, F("default_fixed64" ), 408);
2324 reflection->SetInt32 (message, F("default_sfixed32"), 409);
2325 reflection->SetInt64 (message, F("default_sfixed64"), 410);
2326 reflection->SetFloat (message, F("default_float" ), 411);
2327 reflection->SetDouble(message, F("default_double" ), 412);
2328 reflection->SetBool (message, F("default_bool" ), false);
2329 reflection->SetString(message, F("default_string" ), "415");
2330 reflection->SetString(message, F("default_bytes" ), "416");
2332 reflection->SetEnum(message, F("default_nested_enum" ), nested_foo_);
2333 reflection->SetEnum(message, F("default_foreign_enum"), foreign_foo_);
2334 reflection->SetEnum(message, F("default_import_enum" ), import_foo_);
2336 reflection->SetString(message, F("default_string_piece"), "424");
2337 reflection->SetString(message, F("default_cord"), "425");
2341 Message* message) {
2342 const Reflection* reflection = message->GetReflection();
2343 reflection->AddInt32 (message, F("packed_int32" ), 601);
2344 reflection->AddInt64 (message, F("packed_int64" ), 602);
2345 reflection->AddUInt32(message, F("packed_uint32" ), 603);
2346 reflection->AddUInt64(message, F("packed_uint64" ), 604);
2347 reflection->AddInt32 (message, F("packed_sint32" ), 605);
2348 reflection->AddInt64 (message, F("packed_sint64" ), 606);
2349 reflection->AddUInt32(message, F("packed_fixed32" ), 607);
2350 reflection->AddUInt64(message, F("packed_fixed64" ), 608);
2351 reflection->AddInt32 (message, F("packed_sfixed32"), 609);
2352 reflection->AddInt64 (message, F("packed_sfixed64"), 610);
2353 reflection->AddFloat (message, F("packed_float" ), 611);
2354 reflection->AddDouble(message, F("packed_double" ), 612);
2355 reflection->AddBool (message, F("packed_bool" ), true);
2356 reflection->AddEnum (message, F("packed_enum" ), foreign_bar_);
2358 reflection->AddInt32 (message, F("packed_int32" ), 701);
2359 reflection->AddInt64 (message, F("packed_int64" ), 702);
2360 reflection->AddUInt32(message, F("packed_uint32" ), 703);
2361 reflection->AddUInt64(message, F("packed_uint64" ), 704);
2362 reflection->AddInt32 (message, F("packed_sint32" ), 705);
2363 reflection->AddInt64 (message, F("packed_sint64" ), 706);
2364 reflection->AddUInt32(message, F("packed_fixed32" ), 707);
2365 reflection->AddUInt64(message, F("packed_fixed64" ), 708);
2366 reflection->AddInt32 (message, F("packed_sfixed32"), 709);
2367 reflection->AddInt64 (message, F("packed_sfixed64"), 710);
2368 reflection->AddFloat (message, F("packed_float" ), 711);
2369 reflection->AddDouble(message, F("packed_double" ), 712);
2370 reflection->AddBool (message, F("packed_bool" ), false);
2371 reflection->AddEnum (message, F("packed_enum" ), foreign_baz_);
2377 const Message& message) {
2380 ExpectAllFieldsSetViaReflection1(message);
2381 ExpectAllFieldsSetViaReflection2(message);
2382 ExpectAllFieldsSetViaReflection3(message);
2386 const Message& message) {
2387 const Reflection* reflection = message.GetReflection();
2391 EXPECT_TRUE(reflection->HasField(message, F("optional_int32" )));
2392 EXPECT_TRUE(reflection->HasField(message, F("optional_int64" )));
2393 EXPECT_TRUE(reflection->HasField(message, F("optional_uint32" )));
2394 EXPECT_TRUE(reflection->HasField(message, F("optional_uint64" )));
2395 EXPECT_TRUE(reflection->HasField(message, F("optional_sint32" )));
2396 EXPECT_TRUE(reflection->HasField(message, F("optional_sint64" )));
2397 EXPECT_TRUE(reflection->HasField(message, F("optional_fixed32" )));
2398 EXPECT_TRUE(reflection->HasField(message, F("optional_fixed64" )));
2399 EXPECT_TRUE(reflection->HasField(message, F("optional_sfixed32")));
2400 EXPECT_TRUE(reflection->HasField(message, F("optional_sfixed64")));
2401 EXPECT_TRUE(reflection->HasField(message, F("optional_float" )));
2402 EXPECT_TRUE(reflection->HasField(message, F("optional_double" )));
2403 EXPECT_TRUE(reflection->HasField(message, F("optional_bool" )));
2404 EXPECT_TRUE(reflection->HasField(message, F("optional_string" )));
2405 EXPECT_TRUE(reflection->HasField(message, F("optional_bytes" )));
2407 EXPECT_TRUE(reflection->HasField(message, F("optionalgroup" )));
2408 EXPECT_TRUE(reflection->HasField(message, F("optional_nested_message" )));
2409 EXPECT_TRUE(reflection->HasField(message, F("optional_foreign_message" )));
2410 EXPECT_TRUE(reflection->HasField(message, F("optional_import_message" )));
2411 EXPECT_TRUE(reflection->HasField(message, F("optional_public_import_message")));
2412 EXPECT_TRUE(reflection->HasField(message, F("optional_lazy_message" )));
2414 sub_message = &reflection->GetMessage(message, F("optionalgroup"));
2416 sub_message = &reflection->GetMessage(message, F("optional_nested_message"));
2418 sub_message = &reflection->GetMessage(message, F("optional_foreign_message"));
2420 sub_message = &reflection->GetMessage(message, F("optional_import_message"));
2422 sub_message = &reflection->GetMessage(message, F("optional_public_import_message"));
2424 sub_message = &reflection->GetMessage(message, F("optional_lazy_message"));
2427 EXPECT_TRUE(reflection->HasField(message, F("optional_nested_enum" )));
2428 EXPECT_TRUE(reflection->HasField(message, F("optional_foreign_enum")));
2429 EXPECT_TRUE(reflection->HasField(message, F("optional_import_enum" )));
2431 EXPECT_TRUE(reflection->HasField(message, F("optional_string_piece")));
2432 EXPECT_TRUE(reflection->HasField(message, F("optional_cord")));
2434 EXPECT_EQ(101 , reflection->GetInt32 (message, F("optional_int32" )));
2435 EXPECT_EQ(102 , reflection->GetInt64 (message, F("optional_int64" )));
2436 EXPECT_EQ(103 , reflection->GetUInt32(message, F("optional_uint32" )));
2437 EXPECT_EQ(104 , reflection->GetUInt64(message, F("optional_uint64" )));
2438 EXPECT_EQ(105 , reflection->GetInt32 (message, F("optional_sint32" )));
2439 EXPECT_EQ(106 , reflection->GetInt64 (message, F("optional_sint64" )));
2440 EXPECT_EQ(107 , reflection->GetUInt32(message, F("optional_fixed32" )));
2441 EXPECT_EQ(108 , reflection->GetUInt64(message, F("optional_fixed64" )));
2442 EXPECT_EQ(109 , reflection->GetInt32 (message, F("optional_sfixed32")));
2443 EXPECT_EQ(110 , reflection->GetInt64 (message, F("optional_sfixed64")));
2444 EXPECT_EQ(111 , reflection->GetFloat (message, F("optional_float" )));
2445 EXPECT_EQ(112 , reflection->GetDouble(message, F("optional_double" )));
2446 EXPECT_TRUE( reflection->GetBool (message, F("optional_bool" )));
2447 EXPECT_EQ("115", reflection->GetString(message, F("optional_string" )));
2448 EXPECT_EQ("116", reflection->GetString(message, F("optional_bytes" )));
2450 EXPECT_EQ("115", reflection->GetStringReference(message, F("optional_string"), &scratch));
2451 EXPECT_EQ("116", reflection->GetStringReference(message, F("optional_bytes" ), &scratch));
2453 sub_message = &reflection->GetMessage(message, F("optionalgroup"));
2455 sub_message = &reflection->GetMessage(message, F("optional_nested_message"));
2457 sub_message = &reflection->GetMessage(message, F("optional_foreign_message"));
2459 sub_message = &reflection->GetMessage(message, F("optional_import_message"));
2461 sub_message = &reflection->GetMessage(message, F("optional_public_import_message"));
2463 sub_message = &reflection->GetMessage(message, F("optional_lazy_message"));
2466 EXPECT_EQ( nested_baz_, reflection->GetEnum(message, F("optional_nested_enum" )));
2467 EXPECT_EQ(foreign_baz_, reflection->GetEnum(message, F("optional_foreign_enum")));
2468 EXPECT_EQ( import_baz_, reflection->GetEnum(message, F("optional_import_enum" )));
2470 EXPECT_EQ("124", reflection->GetString(message, F("optional_string_piece")));
2471 EXPECT_EQ("124", reflection->GetStringReference(message, F("optional_string_piece"), &scratch));
2473 EXPECT_EQ("125", reflection->GetString(message, F("optional_cord")));
2474 EXPECT_EQ("125", reflection->GetStringReference(message, F("optional_cord"), &scratch));
2479 const Message& message) {
2480 const Reflection* reflection = message.GetReflection();
2486 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_int32" )));
2487 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_int64" )));
2488 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_uint32" )));
2489 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_uint64" )));
2490 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sint32" )));
2491 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sint64" )));
2492 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_fixed32" )));
2493 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_fixed64" )));
2494 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sfixed32")));
2495 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sfixed64")));
2496 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_float" )));
2497 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_double" )));
2498 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_bool" )));
2499 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_string" )));
2500 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_bytes" )));
2502 ASSERT_EQ(2, reflection->FieldSize(message, F("repeatedgroup" )));
2503 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_nested_message" )));
2504 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_foreign_message")));
2505 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_import_message" )));
2506 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_lazy_message" )));
2507 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_nested_enum" )));
2508 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_foreign_enum" )));
2509 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_import_enum" )));
2511 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_string_piece")));
2512 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_cord")));
2514 EXPECT_EQ(201 , reflection->GetRepeatedInt32 (message, F("repeated_int32" ), 0));
2515 EXPECT_EQ(202 , reflection->GetRepeatedInt64 (message, F("repeated_int64" ), 0));
2516 EXPECT_EQ(203 , reflection->GetRepeatedUInt32(message, F("repeated_uint32" ), 0));
2517 EXPECT_EQ(204 , reflection->GetRepeatedUInt64(message, F("repeated_uint64" ), 0));
2518 EXPECT_EQ(205 , reflection->GetRepeatedInt32 (message, F("repeated_sint32" ), 0));
2519 EXPECT_EQ(206 , reflection->GetRepeatedInt64 (message, F("repeated_sint64" ), 0));
2520 EXPECT_EQ(207 , reflection->GetRepeatedUInt32(message, F("repeated_fixed32" ), 0));
2521 EXPECT_EQ(208 , reflection->GetRepeatedUInt64(message, F("repeated_fixed64" ), 0));
2522 EXPECT_EQ(209 , reflection->GetRepeatedInt32 (message, F("repeated_sfixed32"), 0));
2523 EXPECT_EQ(210 , reflection->GetRepeatedInt64 (message, F("repeated_sfixed64"), 0));
2524 EXPECT_EQ(211 , reflection->GetRepeatedFloat (message, F("repeated_float" ), 0));
2525 EXPECT_EQ(212 , reflection->GetRepeatedDouble(message, F("repeated_double" ), 0));
2526 EXPECT_TRUE( reflection->GetRepeatedBool (message, F("repeated_bool" ), 0));
2527 EXPECT_EQ("215", reflection->GetRepeatedString(message, F("repeated_string" ), 0));
2528 EXPECT_EQ("216", reflection->GetRepeatedString(message, F("repeated_bytes" ), 0));
2530 EXPECT_EQ("215", reflection->GetRepeatedStringReference(message, F("repeated_string"), 0, &scratch));
2531 EXPECT_EQ("216", reflection->GetRepeatedStringReference(message, F("repeated_bytes"), 0, &scratch));
2533 sub_message = &reflection->GetRepeatedMessage(message, F("repeatedgroup"), 0);
2535 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_nested_message"), 0);
2537 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_foreign_message"), 0);
2539 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_import_message"), 0);
2541 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_lazy_message"), 0);
2544 EXPECT_EQ( nested_bar_, reflection->GetRepeatedEnum(message, F("repeated_nested_enum" ),0));
2545 EXPECT_EQ(foreign_bar_, reflection->GetRepeatedEnum(message, F("repeated_foreign_enum"),0));
2546 EXPECT_EQ( import_bar_, reflection->GetRepeatedEnum(message, F("repeated_import_enum" ),0));
2548 EXPECT_EQ("224", reflection->GetRepeatedString(message, F("repeated_string_piece"), 0));
2550 message, F("repeated_string_piece"), 0, &scratch));
2552 EXPECT_EQ("225", reflection->GetRepeatedString(message, F("repeated_cord"), 0));
2554 message, F("repeated_cord"), 0, &scratch));
2556 EXPECT_EQ(301 , reflection->GetRepeatedInt32 (message, F("repeated_int32" ), 1));
2557 EXPECT_EQ(302 , reflection->GetRepeatedInt64 (message, F("repeated_int64" ), 1));
2558 EXPECT_EQ(303 , reflection->GetRepeatedUInt32(message, F("repeated_uint32" ), 1));
2559 EXPECT_EQ(304 , reflection->GetRepeatedUInt64(message, F("repeated_uint64" ), 1));
2560 EXPECT_EQ(305 , reflection->GetRepeatedInt32 (message, F("repeated_sint32" ), 1));
2561 EXPECT_EQ(306 , reflection->GetRepeatedInt64 (message, F("repeated_sint64" ), 1));
2562 EXPECT_EQ(307 , reflection->GetRepeatedUInt32(message, F("repeated_fixed32" ), 1));
2563 EXPECT_EQ(308 , reflection->GetRepeatedUInt64(message, F("repeated_fixed64" ), 1));
2564 EXPECT_EQ(309 , reflection->GetRepeatedInt32 (message, F("repeated_sfixed32"), 1));
2565 EXPECT_EQ(310 , reflection->GetRepeatedInt64 (message, F("repeated_sfixed64"), 1));
2566 EXPECT_EQ(311 , reflection->GetRepeatedFloat (message, F("repeated_float" ), 1));
2567 EXPECT_EQ(312 , reflection->GetRepeatedDouble(message, F("repeated_double" ), 1));
2568 EXPECT_FALSE( reflection->GetRepeatedBool (message, F("repeated_bool" ), 1));
2569 EXPECT_EQ("315", reflection->GetRepeatedString(message, F("repeated_string" ), 1));
2570 EXPECT_EQ("316", reflection->GetRepeatedString(message, F("repeated_bytes" ), 1));
2572 EXPECT_EQ("315", reflection->GetRepeatedStringReference(message, F("repeated_string"),
2574 EXPECT_EQ("316", reflection->GetRepeatedStringReference(message, F("repeated_bytes"),
2577 sub_message = &reflection->GetRepeatedMessage(message, F("repeatedgroup"), 1);
2579 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_nested_message"), 1);
2581 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_foreign_message"), 1);
2583 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_import_message"), 1);
2585 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_lazy_message"), 1);
2588 EXPECT_EQ( nested_baz_, reflection->GetRepeatedEnum(message, F("repeated_nested_enum" ),1));
2589 EXPECT_EQ(foreign_baz_, reflection->GetRepeatedEnum(message, F("repeated_foreign_enum"),1));
2590 EXPECT_EQ( import_baz_, reflection->GetRepeatedEnum(message, F("repeated_import_enum" ),1));
2592 EXPECT_EQ("324", reflection->GetRepeatedString(message, F("repeated_string_piece"), 1));
2594 message, F("repeated_string_piece"), 1, &scratch));
2596 EXPECT_EQ("325", reflection->GetRepeatedString(message, F("repeated_cord"), 1));
2598 message, F("repeated_cord"), 1, &scratch));
2602 const Message& message) {
2603 const Reflection* reflection = message.GetReflection();
2608 EXPECT_TRUE(reflection->HasField(message, F("default_int32" )));
2609 EXPECT_TRUE(reflection->HasField(message, F("default_int64" )));
2610 EXPECT_TRUE(reflection->HasField(message, F("default_uint32" )));
2611 EXPECT_TRUE(reflection->HasField(message, F("default_uint64" )));
2612 EXPECT_TRUE(reflection->HasField(message, F("default_sint32" )));
2613 EXPECT_TRUE(reflection->HasField(message, F("default_sint64" )));
2614 EXPECT_TRUE(reflection->HasField(message, F("default_fixed32" )));
2615 EXPECT_TRUE(reflection->HasField(message, F("default_fixed64" )));
2616 EXPECT_TRUE(reflection->HasField(message, F("default_sfixed32")));
2617 EXPECT_TRUE(reflection->HasField(message, F("default_sfixed64")));
2618 EXPECT_TRUE(reflection->HasField(message, F("default_float" )));
2619 EXPECT_TRUE(reflection->HasField(message, F("default_double" )));
2620 EXPECT_TRUE(reflection->HasField(message, F("default_bool" )));
2621 EXPECT_TRUE(reflection->HasField(message, F("default_string" )));
2622 EXPECT_TRUE(reflection->HasField(message, F("default_bytes" )));
2624 EXPECT_TRUE(reflection->HasField(message, F("default_nested_enum" )));
2625 EXPECT_TRUE(reflection->HasField(message, F("default_foreign_enum")));
2626 EXPECT_TRUE(reflection->HasField(message, F("default_import_enum" )));
2628 EXPECT_TRUE(reflection->HasField(message, F("default_string_piece")));
2629 EXPECT_TRUE(reflection->HasField(message, F("default_cord")));
2631 EXPECT_EQ(401 , reflection->GetInt32 (message, F("default_int32" )));
2632 EXPECT_EQ(402 , reflection->GetInt64 (message, F("default_int64" )));
2633 EXPECT_EQ(403 , reflection->GetUInt32(message, F("default_uint32" )));
2634 EXPECT_EQ(404 , reflection->GetUInt64(message, F("default_uint64" )));
2635 EXPECT_EQ(405 , reflection->GetInt32 (message, F("default_sint32" )));
2636 EXPECT_EQ(406 , reflection->GetInt64 (message, F("default_sint64" )));
2637 EXPECT_EQ(407 , reflection->GetUInt32(message, F("default_fixed32" )));
2638 EXPECT_EQ(408 , reflection->GetUInt64(message, F("default_fixed64" )));
2639 EXPECT_EQ(409 , reflection->GetInt32 (message, F("default_sfixed32")));
2640 EXPECT_EQ(410 , reflection->GetInt64 (message, F("default_sfixed64")));
2641 EXPECT_EQ(411 , reflection->GetFloat (message, F("default_float" )));
2642 EXPECT_EQ(412 , reflection->GetDouble(message, F("default_double" )));
2643 EXPECT_FALSE( reflection->GetBool (message, F("default_bool" )));
2644 EXPECT_EQ("415", reflection->GetString(message, F("default_string" )));
2645 EXPECT_EQ("416", reflection->GetString(message, F("default_bytes" )));
2647 EXPECT_EQ("415", reflection->GetStringReference(message, F("default_string"), &scratch));
2648 EXPECT_EQ("416", reflection->GetStringReference(message, F("default_bytes" ), &scratch));
2650 EXPECT_EQ( nested_foo_, reflection->GetEnum(message, F("default_nested_enum" )));
2651 EXPECT_EQ(foreign_foo_, reflection->GetEnum(message, F("default_foreign_enum")));
2652 EXPECT_EQ( import_foo_, reflection->GetEnum(message, F("default_import_enum" )));
2654 EXPECT_EQ("424", reflection->GetString(message, F("default_string_piece")));
2655 EXPECT_EQ("424", reflection->GetStringReference(message, F("default_string_piece"),
2658 EXPECT_EQ("425", reflection->GetString(message, F("default_cord")));
2659 EXPECT_EQ("425", reflection->GetStringReference(message, F("default_cord"), &scratch));
2663 const Message& message) {
2664 const Reflection* reflection = message.GetReflection();
2666 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_int32" )));
2667 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_int64" )));
2668 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_uint32" )));
2669 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_uint64" )));
2670 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sint32" )));
2671 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sint64" )));
2672 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_fixed32" )));
2673 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_fixed64" )));
2674 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sfixed32")));
2675 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sfixed64")));
2676 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_float" )));
2677 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_double" )));
2678 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_bool" )));
2679 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_enum" )));
2681 EXPECT_EQ(601 , reflection->GetRepeatedInt32 (message, F("packed_int32" ), 0));
2682 EXPECT_EQ(602 , reflection->GetRepeatedInt64 (message, F("packed_int64" ), 0));
2683 EXPECT_EQ(603 , reflection->GetRepeatedUInt32(message, F("packed_uint32" ), 0));
2684 EXPECT_EQ(604 , reflection->GetRepeatedUInt64(message, F("packed_uint64" ), 0));
2685 EXPECT_EQ(605 , reflection->GetRepeatedInt32 (message, F("packed_sint32" ), 0));
2686 EXPECT_EQ(606 , reflection->GetRepeatedInt64 (message, F("packed_sint64" ), 0));
2687 EXPECT_EQ(607 , reflection->GetRepeatedUInt32(message, F("packed_fixed32" ), 0));
2688 EXPECT_EQ(608 , reflection->GetRepeatedUInt64(message, F("packed_fixed64" ), 0));
2689 EXPECT_EQ(609 , reflection->GetRepeatedInt32 (message, F("packed_sfixed32"), 0));
2690 EXPECT_EQ(610 , reflection->GetRepeatedInt64 (message, F("packed_sfixed64"), 0));
2691 EXPECT_EQ(611 , reflection->GetRepeatedFloat (message, F("packed_float" ), 0));
2692 EXPECT_EQ(612 , reflection->GetRepeatedDouble(message, F("packed_double" ), 0));
2693 EXPECT_TRUE( reflection->GetRepeatedBool (message, F("packed_bool" ), 0));
2695 reflection->GetRepeatedEnum(message, F("packed_enum"), 0));
2697 EXPECT_EQ(701 , reflection->GetRepeatedInt32 (message, F("packed_int32" ), 1));
2698 EXPECT_EQ(702 , reflection->GetRepeatedInt64 (message, F("packed_int64" ), 1));
2699 EXPECT_EQ(703 , reflection->GetRepeatedUInt32(message, F("packed_uint32" ), 1));
2700 EXPECT_EQ(704 , reflection->GetRepeatedUInt64(message, F("packed_uint64" ), 1));
2701 EXPECT_EQ(705 , reflection->GetRepeatedInt32 (message, F("packed_sint32" ), 1));
2702 EXPECT_EQ(706 , reflection->GetRepeatedInt64 (message, F("packed_sint64" ), 1));
2703 EXPECT_EQ(707 , reflection->GetRepeatedUInt32(message, F("packed_fixed32" ), 1));
2704 EXPECT_EQ(708 , reflection->GetRepeatedUInt64(message, F("packed_fixed64" ), 1));
2705 EXPECT_EQ(709 , reflection->GetRepeatedInt32 (message, F("packed_sfixed32"), 1));
2706 EXPECT_EQ(710 , reflection->GetRepeatedInt64 (message, F("packed_sfixed64"), 1));
2707 EXPECT_EQ(711 , reflection->GetRepeatedFloat (message, F("packed_float" ), 1));
2708 EXPECT_EQ(712 , reflection->GetRepeatedDouble(message, F("packed_double" ), 1));
2709 EXPECT_FALSE( reflection->GetRepeatedBool (message, F("packed_bool" ), 1));
2711 reflection->GetRepeatedEnum(message, F("packed_enum"), 1));
2717 const Message& message) {
2718 const Reflection* reflection = message.GetReflection();
2723 EXPECT_FALSE(reflection->HasField(message, F("optional_int32" )));
2724 EXPECT_FALSE(reflection->HasField(message, F("optional_int64" )));
2725 EXPECT_FALSE(reflection->HasField(message, F("optional_uint32" )));
2726 EXPECT_FALSE(reflection->HasField(message, F("optional_uint64" )));
2727 EXPECT_FALSE(reflection->HasField(message, F("optional_sint32" )));
2728 EXPECT_FALSE(reflection->HasField(message, F("optional_sint64" )));
2729 EXPECT_FALSE(reflection->HasField(message, F("optional_fixed32" )));
2730 EXPECT_FALSE(reflection->HasField(message, F("optional_fixed64" )));
2731 EXPECT_FALSE(reflection->HasField(message, F("optional_sfixed32")));
2732 EXPECT_FALSE(reflection->HasField(message, F("optional_sfixed64")));
2733 EXPECT_FALSE(reflection->HasField(message, F("optional_float" )));
2734 EXPECT_FALSE(reflection->HasField(message, F("optional_double" )));
2735 EXPECT_FALSE(reflection->HasField(message, F("optional_bool" )));
2736 EXPECT_FALSE(reflection->HasField(message, F("optional_string" )));
2737 EXPECT_FALSE(reflection->HasField(message, F("optional_bytes" )));
2739 EXPECT_FALSE(reflection->HasField(message, F("optionalgroup" )));
2740 EXPECT_FALSE(reflection->HasField(message, F("optional_nested_message" )));
2741 EXPECT_FALSE(reflection->HasField(message, F("optional_foreign_message")));
2742 EXPECT_FALSE(reflection->HasField(message, F("optional_import_message" )));
2743 EXPECT_FALSE(reflection->HasField(message, F("optional_public_import_message")));
2744 EXPECT_FALSE(reflection->HasField(message, F("optional_lazy_message")));
2746 EXPECT_FALSE(reflection->HasField(message, F("optional_nested_enum" )));
2747 EXPECT_FALSE(reflection->HasField(message, F("optional_foreign_enum")));
2748 EXPECT_FALSE(reflection->HasField(message, F("optional_import_enum" )));
2750 EXPECT_FALSE(reflection->HasField(message, F("optional_string_piece")));
2751 EXPECT_FALSE(reflection->HasField(message, F("optional_cord")));
2754 EXPECT_EQ(0 , reflection->GetInt32 (message, F("optional_int32" )));
2755 EXPECT_EQ(0 , reflection->GetInt64 (message, F("optional_int64" )));
2756 EXPECT_EQ(0 , reflection->GetUInt32(message, F("optional_uint32" )));
2757 EXPECT_EQ(0 , reflection->GetUInt64(message, F("optional_uint64" )));
2758 EXPECT_EQ(0 , reflection->GetInt32 (message, F("optional_sint32" )));
2759 EXPECT_EQ(0 , reflection->GetInt64 (message, F("optional_sint64" )));
2760 EXPECT_EQ(0 , reflection->GetUInt32(message, F("optional_fixed32" )));
2761 EXPECT_EQ(0 , reflection->GetUInt64(message, F("optional_fixed64" )));
2762 EXPECT_EQ(0 , reflection->GetInt32 (message, F("optional_sfixed32")));
2763 EXPECT_EQ(0 , reflection->GetInt64 (message, F("optional_sfixed64")));
2764 EXPECT_EQ(0 , reflection->GetFloat (message, F("optional_float" )));
2765 EXPECT_EQ(0 , reflection->GetDouble(message, F("optional_double" )));
2766 EXPECT_FALSE( reflection->GetBool (message, F("optional_bool" )));
2767 EXPECT_EQ("" , reflection->GetString(message, F("optional_string" )));
2768 EXPECT_EQ("" , reflection->GetString(message, F("optional_bytes" )));
2770 EXPECT_EQ("", reflection->GetStringReference(message, F("optional_string"), &scratch));
2771 EXPECT_EQ("", reflection->GetStringReference(message, F("optional_bytes" ), &scratch));
2774 sub_message = &reflection->GetMessage(message, F("optionalgroup"));
2777 sub_message = &reflection->GetMessage(message, F("optional_nested_message"));
2780 sub_message = &reflection->GetMessage(message, F("optional_foreign_message"));
2783 sub_message = &reflection->GetMessage(message, F("optional_import_message"));
2786 sub_message = &reflection->GetMessage(message, F("optional_public_import_message"));
2789 sub_message = &reflection->GetMessage(message, F("optional_lazy_message"));
2794 EXPECT_EQ( nested_foo_, reflection->GetEnum(message, F("optional_nested_enum" )));
2795 EXPECT_EQ(foreign_foo_, reflection->GetEnum(message, F("optional_foreign_enum")));
2796 EXPECT_EQ( import_foo_, reflection->GetEnum(message, F("optional_import_enum" )));
2798 EXPECT_EQ("", reflection->GetString(message, F("optional_string_piece")));
2799 EXPECT_EQ("", reflection->GetStringReference(message, F("optional_string_piece"), &scratch));
2801 EXPECT_EQ("", reflection->GetString(message, F("optional_cord")));
2802 EXPECT_EQ("", reflection->GetStringReference(message, F("optional_cord"), &scratch));
2805 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_int32" )));
2806 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_int64" )));
2807 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_uint32" )));
2808 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_uint64" )));
2809 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sint32" )));
2810 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sint64" )));
2811 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_fixed32" )));
2812 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_fixed64" )));
2813 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sfixed32")));
2814 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sfixed64")));
2815 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_float" )));
2816 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_double" )));
2817 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_bool" )));
2818 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_string" )));
2819 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_bytes" )));
2821 EXPECT_EQ(0, reflection->FieldSize(message, F("repeatedgroup" )));
2822 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_nested_message" )));
2823 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_foreign_message")));
2824 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_import_message" )));
2825 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_lazy_message" )));
2826 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_nested_enum" )));
2827 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_foreign_enum" )));
2828 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_import_enum" )));
2830 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_string_piece")));
2831 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_cord")));
2834 EXPECT_FALSE(reflection->HasField(message, F("default_int32" )));
2835 EXPECT_FALSE(reflection->HasField(message, F("default_int64" )));
2836 EXPECT_FALSE(reflection->HasField(message, F("default_uint32" )));
2837 EXPECT_FALSE(reflection->HasField(message, F("default_uint64" )));
2838 EXPECT_FALSE(reflection->HasField(message, F("default_sint32" )));
2839 EXPECT_FALSE(reflection->HasField(message, F("default_sint64" )));
2840 EXPECT_FALSE(reflection->HasField(message, F("default_fixed32" )));
2841 EXPECT_FALSE(reflection->HasField(message, F("default_fixed64" )));
2842 EXPECT_FALSE(reflection->HasField(message, F("default_sfixed32")));
2843 EXPECT_FALSE(reflection->HasField(message, F("default_sfixed64")));
2844 EXPECT_FALSE(reflection->HasField(message, F("default_float" )));
2845 EXPECT_FALSE(reflection->HasField(message, F("default_double" )));
2846 EXPECT_FALSE(reflection->HasField(message, F("default_bool" )));
2847 EXPECT_FALSE(reflection->HasField(message, F("default_string" )));
2848 EXPECT_FALSE(reflection->HasField(message, F("default_bytes" )));
2850 EXPECT_FALSE(reflection->HasField(message, F("default_nested_enum" )));
2851 EXPECT_FALSE(reflection->HasField(message, F("default_foreign_enum")));
2852 EXPECT_FALSE(reflection->HasField(message, F("default_import_enum" )));
2854 EXPECT_FALSE(reflection->HasField(message, F("default_string_piece")));
2855 EXPECT_FALSE(reflection->HasField(message, F("default_cord")));
2858 EXPECT_EQ( 41 , reflection->GetInt32 (message, F("default_int32" )));
2859 EXPECT_EQ( 42 , reflection->GetInt64 (message, F("default_int64" )));
2860 EXPECT_EQ( 43 , reflection->GetUInt32(message, F("default_uint32" )));
2861 EXPECT_EQ( 44 , reflection->GetUInt64(message, F("default_uint64" )));
2862 EXPECT_EQ(-45 , reflection->GetInt32 (message, F("default_sint32" )));
2863 EXPECT_EQ( 46 , reflection->GetInt64 (message, F("default_sint64" )));
2864 EXPECT_EQ( 47 , reflection->GetUInt32(message, F("default_fixed32" )));
2865 EXPECT_EQ( 48 , reflection->GetUInt64(message, F("default_fixed64" )));
2866 EXPECT_EQ( 49 , reflection->GetInt32 (message, F("default_sfixed32")));
2867 EXPECT_EQ(-50 , reflection->GetInt64 (message, F("default_sfixed64")));
2868 EXPECT_EQ( 51.5 , reflection->GetFloat (message, F("default_float" )));
2869 EXPECT_EQ( 52e3 , reflection->GetDouble(message, F("default_double" )));
2870 EXPECT_TRUE( reflection->GetBool (message, F("default_bool" )));
2871 EXPECT_EQ("hello", reflection->GetString(message, F("default_string" )));
2872 EXPECT_EQ("world", reflection->GetString(message, F("default_bytes" )));
2874 EXPECT_EQ("hello", reflection->GetStringReference(message, F("default_string"), &scratch));
2875 EXPECT_EQ("world", reflection->GetStringReference(message, F("default_bytes" ), &scratch));
2877 EXPECT_EQ( nested_bar_, reflection->GetEnum(message, F("default_nested_enum" )));
2878 EXPECT_EQ(foreign_bar_, reflection->GetEnum(message, F("default_foreign_enum")));
2879 EXPECT_EQ( import_bar_, reflection->GetEnum(message, F("default_import_enum" )));
2881 EXPECT_EQ("abc", reflection->GetString(message, F("default_string_piece")));
2882 EXPECT_EQ("abc", reflection->GetStringReference(message, F("default_string_piece"), &scratch));
2884 EXPECT_EQ("123", reflection->GetString(message, F("default_cord")));
2885 EXPECT_EQ("123", reflection->GetStringReference(message, F("default_cord"), &scratch));
2889 const Message& message) {
2890 const Reflection* reflection = message.GetReflection();
2892 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_int32" )));
2893 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_int64" )));
2894 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_uint32" )));
2895 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_uint64" )));
2896 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_sint32" )));
2897 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_sint64" )));
2898 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_fixed32" )));
2899 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_fixed64" )));
2900 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_sfixed32")));
2901 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_sfixed64")));
2902 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_float" )));
2903 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_double" )));
2904 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_bool" )));
2905 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_enum" )));
2911 Message* message) {
2912 const Reflection* reflection = message->GetReflection();
2915 reflection->SetRepeatedInt32 (message, F("repeated_int32" ), 1, 501);
2916 reflection->SetRepeatedInt64 (message, F("repeated_int64" ), 1, 502);
2917 reflection->SetRepeatedUInt32(message, F("repeated_uint32" ), 1, 503);
2918 reflection->SetRepeatedUInt64(message, F("repeated_uint64" ), 1, 504);
2919 reflection->SetRepeatedInt32 (message, F("repeated_sint32" ), 1, 505);
2920 reflection->SetRepeatedInt64 (message, F("repeated_sint64" ), 1, 506);
2921 reflection->SetRepeatedUInt32(message, F("repeated_fixed32" ), 1, 507);
2922 reflection->SetRepeatedUInt64(message, F("repeated_fixed64" ), 1, 508);
2923 reflection->SetRepeatedInt32 (message, F("repeated_sfixed32"), 1, 509);
2924 reflection->SetRepeatedInt64 (message, F("repeated_sfixed64"), 1, 510);
2925 reflection->SetRepeatedFloat (message, F("repeated_float" ), 1, 511);
2926 reflection->SetRepeatedDouble(message, F("repeated_double" ), 1, 512);
2927 reflection->SetRepeatedBool (message, F("repeated_bool" ), 1, true);
2928 reflection->SetRepeatedString(message, F("repeated_string" ), 1, "515");
2929 reflection->SetRepeatedString(message, F("repeated_bytes" ), 1, "516");
2931 sub_message = reflection->MutableRepeatedMessage(message, F("repeatedgroup"), 1);
2933 sub_message = reflection->MutableRepeatedMessage(message, F("repeated_nested_message"), 1);
2935 sub_message = reflection->MutableRepeatedMessage(message, F("repeated_foreign_message"), 1);
2937 sub_message = reflection->MutableRepeatedMessage(message, F("repeated_import_message"), 1);
2939 sub_message = reflection->MutableRepeatedMessage(message, F("repeated_lazy_message"), 1);
2942 reflection->SetRepeatedEnum(message, F("repeated_nested_enum" ), 1, nested_foo_);
2943 reflection->SetRepeatedEnum(message, F("repeated_foreign_enum"), 1, foreign_foo_);
2944 reflection->SetRepeatedEnum(message, F("repeated_import_enum" ), 1, import_foo_);
2946 reflection->SetRepeatedString(message, F("repeated_string_piece"), 1, "524");
2947 reflection->SetRepeatedString(message, F("repeated_cord"), 1, "525");
2951 Message* message) {
2952 const Reflection* reflection = message->GetReflection();
2953 reflection->SetRepeatedInt32 (message, F("packed_int32" ), 1, 801);
2954 reflection->SetRepeatedInt64 (message, F("packed_int64" ), 1, 802);
2955 reflection->SetRepeatedUInt32(message, F("packed_uint32" ), 1, 803);
2956 reflection->SetRepeatedUInt64(message, F("packed_uint64" ), 1, 804);
2957 reflection->SetRepeatedInt32 (message, F("packed_sint32" ), 1, 805);
2958 reflection->SetRepeatedInt64 (message, F("packed_sint64" ), 1, 806);
2959 reflection->SetRepeatedUInt32(message, F("packed_fixed32" ), 1, 807);
2960 reflection->SetRepeatedUInt64(message, F("packed_fixed64" ), 1, 808);
2961 reflection->SetRepeatedInt32 (message, F("packed_sfixed32"), 1, 809);
2962 reflection->SetRepeatedInt64 (message, F("packed_sfixed64"), 1, 810);
2963 reflection->SetRepeatedFloat (message, F("packed_float" ), 1, 811);
2964 reflection->SetRepeatedDouble(message, F("packed_double" ), 1, 812);
2965 reflection->SetRepeatedBool (message, F("packed_bool" ), 1, true);
2966 reflection->SetRepeatedEnum (message, F("packed_enum" ), 1, foreign_foo_);
2970 Message* message) {
2971 const Reflection* reflection = message->GetReflection();
2974 reflection->ListFields(*message, &output);
2979 reflection->RemoveLast(message, field);
2984 Message* message, bool expect_extensions_notnull) {
2985 const Reflection* reflection = message->GetReflection();
2988 reflection->ListFields(*message, &output);
2994 Message* released = reflection->ReleaseLast(message, field);
3003 void TestUtil::ReflectionTester::SwapRepeatedsViaReflection(Message* message) {
3004 const Reflection* reflection = message->GetReflection();
3007 reflection->ListFields(*message, &output);
3012 reflection->SwapElements(message, field, 0, 1);
3017 Message* message,
3019 const Reflection* reflection = message->GetReflection();
3028 const Message& sub_message = reflection->GetMessage(*message, F(fields[i]));
3029 Message* released = reflection->ReleaseMessage(message, F(fields[i]));
3042 EXPECT_FALSE(reflection->HasField(*message, F(fields[i])));