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