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

grpc
Author(s):
autogenerated on Fri May 16 2025 03:00:32