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