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