• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// -*- c++ -*-
2// Protocol Buffers - Google's data interchange format
3// Copyright 2008 Google Inc.  All rights reserved.
4//
5// Use of this source code is governed by a BSD-style
6// license that can be found in the LICENSE file or at
7// https://developers.google.com/open-source/licenses/bsd
8
9// Author: kenton@google.com (Kenton Varda)
10//  Based on original Protocol Buffers design by
11//  Sanjay Ghemawat, Jeff Dean, and others.
12//
13// This file needs to be included as .inc as it depends on the namespaces
14// (unittest and unittest_import) being set up properly. It is also included
15// within an enclosing namespace and requires header files to be included
16// out of this file.
17
18#include <gtest/gtest.h>
19#include "absl/log/absl_check.h"
20#include "google/protobuf/descriptor.h"
21#include "google/protobuf/message.h"
22#include "google/protobuf/unittest_import.pb.h"
23
24namespace google {
25namespace protobuf {
26namespace TestUtil {
27
28// Set every field in the message to a unique value.
29inline void SetAllFields(UNITTEST::TestAllTypes* message);
30inline void SetOptionalFields(UNITTEST::TestAllTypes* message);
31inline void AddRepeatedFields1(UNITTEST::TestAllTypes* message);
32inline void AddRepeatedFields2(UNITTEST::TestAllTypes* message);
33inline void SetDefaultFields(UNITTEST::TestAllTypes* message);
34inline void SetOneofFields(UNITTEST::TestAllTypes* message);
35inline void SetAllExtensions(UNITTEST::TestAllExtensions* message);
36inline void SetOneofFields(UNITTEST::TestAllExtensions* message);
37inline void SetAllFieldsAndExtensions(UNITTEST::TestFieldOrderings* message);
38inline void SetPackedFields(UNITTEST::TestPackedTypes* message);
39inline void SetPackedExtensions(UNITTEST::TestPackedExtensions* message);
40inline void SetUnpackedFields(UNITTEST::TestUnpackedTypes* message);
41inline void SetOneof1(UNITTEST::TestOneof2* message);
42inline void SetOneof2(UNITTEST::TestOneof2* message);
43
44// Use the repeated versions of the set_*() accessors to modify all the
45// repeated fields of the message (which should already have been
46// initialized with Set*Fields()).  Set*Fields() itself only tests
47// the add_*() accessors.
48inline void ModifyRepeatedFields(UNITTEST::TestAllTypes* message);
49inline void ModifyRepeatedExtensions(UNITTEST::TestAllExtensions* message);
50
51// Check that all fields have the values that they should have after
52// Set*Fields() is called.
53inline void ExpectAllFieldsSet(const UNITTEST::TestAllTypes& message);
54inline void ExpectAllExtensionsSet(const UNITTEST::TestAllExtensions& message);
55inline void ExpectPackedFieldsSet(const UNITTEST::TestPackedTypes& message);
56inline void ExpectPackedExtensionsSet(
57    const UNITTEST::TestPackedExtensions& message);
58inline void ExpectUnpackedFieldsSet(const UNITTEST::TestUnpackedTypes& message);
59inline void ExpectUnpackedExtensionsSet(
60    const UNITTEST::TestUnpackedExtensions& message);
61inline void ExpectOneofSet1(const UNITTEST::TestOneof2& message);
62inline void ExpectOneofSet2(const UNITTEST::TestOneof2& message);
63
64// Expect that the message is modified as would be expected from
65// Modify*Fields().
66inline void ExpectRepeatedFieldsModified(const UNITTEST::TestAllTypes& message);
67inline void ExpectRepeatedExtensionsModified(
68    const UNITTEST::TestAllExtensions& message);
69
70// Check that all fields have their default values.
71inline void ExpectClear(const UNITTEST::TestAllTypes& message);
72inline void ExpectExtensionsClear(const UNITTEST::TestAllExtensions& message);
73inline void ExpectOneofClear(const UNITTEST::TestOneof2& message);
74
75// Check that all repeated fields have had their last elements removed.
76inline void ExpectLastRepeatedsRemoved(const UNITTEST::TestAllTypes& message);
77inline void ExpectLastRepeatedExtensionsRemoved(
78    const UNITTEST::TestAllExtensions& message);
79inline void ExpectLastRepeatedExtensionsRemoved(
80    const UNITTEST::TestPackedExtensions& message);
81inline void ExpectLastRepeatedsReleased(const UNITTEST::TestAllTypes& message);
82inline void ExpectLastRepeatedExtensionsReleased(
83    const UNITTEST::TestAllExtensions& message);
84
85// Check that all repeated fields have had their first and last elements
86// swapped.
87inline void ExpectRepeatedsSwapped(const UNITTEST::TestAllTypes& message);
88inline void ExpectRepeatedExtensionsSwapped(
89    const UNITTEST::TestAllExtensions& message);
90
91inline void ExpectAtMostOneFieldSetInOneof(const UNITTEST::TestOneof2& message);
92
93}  // namespace TestUtil
94
95inline void TestUtil::SetAllFields(UNITTEST::TestAllTypes* message) {
96  SetOptionalFields(message);
97  AddRepeatedFields1(message);
98  AddRepeatedFields2(message);
99  SetDefaultFields(message);
100  SetOneofFields(message);
101}
102
103inline void TestUtil::SetOptionalFields(UNITTEST::TestAllTypes* message) {
104  message->set_optional_int32(101);
105  message->set_optional_int64(102);
106  message->set_optional_uint32(103);
107  message->set_optional_uint64(104);
108  message->set_optional_sint32(105);
109  message->set_optional_sint64(106);
110  message->set_optional_fixed32(107);
111  message->set_optional_fixed64(108);
112  message->set_optional_sfixed32(109);
113  message->set_optional_sfixed64(110);
114  message->set_optional_float(111);
115  message->set_optional_double(112);
116  message->set_optional_bool(true);
117  message->set_optional_string("115");
118  message->set_optional_bytes("116");
119
120  message->mutable_optionalgroup()->set_a(117);
121  message->mutable_optional_nested_message()->set_bb(118);
122  message->mutable_optional_foreign_message()->set_c(119);
123  message->mutable_optional_import_message()->set_d(120);
124  message->mutable_optional_public_import_message()->set_e(126);
125  message->mutable_optional_lazy_message()->set_bb(127);
126  message->mutable_optional_unverified_lazy_message()->set_bb(128);
127
128  message->set_optional_nested_enum(UNITTEST::TestAllTypes::BAZ);
129  message->set_optional_foreign_enum(UNITTEST::FOREIGN_BAZ);
130  message->set_optional_import_enum(UNITTEST_IMPORT::IMPORT_BAZ);
131
132  // StringPiece and Cord fields are only accessible via reflection in the
133  // open source release; see comments in compiler/cpp/string_field.cc.
134#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
135  message->GetReflection()->SetString(
136      message,
137      message->GetDescriptor()->FindFieldByName("optional_string_piece"),
138      "124");
139  message->GetReflection()->SetString(
140      message, message->GetDescriptor()->FindFieldByName("optional_cord"),
141      "125");
142#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
143  message->set_optional_bytes_cord("optional bytes cord");
144}
145
146// -------------------------------------------------------------------
147
148inline void TestUtil::AddRepeatedFields1(UNITTEST::TestAllTypes* message) {
149  message->add_repeated_int32(201);
150  message->add_repeated_int64(202);
151  message->add_repeated_uint32(203);
152  message->add_repeated_uint64(204);
153  message->add_repeated_sint32(205);
154  message->add_repeated_sint64(206);
155  message->add_repeated_fixed32(207);
156  message->add_repeated_fixed64(208);
157  message->add_repeated_sfixed32(209);
158  message->add_repeated_sfixed64(210);
159  message->add_repeated_float(211);
160  message->add_repeated_double(212);
161  message->add_repeated_bool(true);
162  message->add_repeated_string("215");
163  message->add_repeated_bytes("216");
164
165  message->add_repeatedgroup()->set_a(217);
166  message->add_repeated_nested_message()->set_bb(218);
167  message->add_repeated_foreign_message()->set_c(219);
168  message->add_repeated_import_message()->set_d(220);
169  message->add_repeated_lazy_message()->set_bb(227);
170
171  message->add_repeated_nested_enum(UNITTEST::TestAllTypes::BAR);
172  message->add_repeated_foreign_enum(UNITTEST::FOREIGN_BAR);
173  message->add_repeated_import_enum(UNITTEST_IMPORT::IMPORT_BAR);
174
175#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
176  message->GetReflection()->AddString(
177      message,
178      message->GetDescriptor()->FindFieldByName("repeated_string_piece"),
179      "224");
180  message->GetReflection()->AddString(
181      message, message->GetDescriptor()->FindFieldByName("repeated_cord"),
182      "225");
183#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
184}
185
186inline void TestUtil::AddRepeatedFields2(UNITTEST::TestAllTypes* message) {
187  // Add a second one of each field.
188  message->add_repeated_int32(301);
189  message->add_repeated_int64(302);
190  message->add_repeated_uint32(303);
191  message->add_repeated_uint64(304);
192  message->add_repeated_sint32(305);
193  message->add_repeated_sint64(306);
194  message->add_repeated_fixed32(307);
195  message->add_repeated_fixed64(308);
196  message->add_repeated_sfixed32(309);
197  message->add_repeated_sfixed64(310);
198  message->add_repeated_float(311);
199  message->add_repeated_double(312);
200  message->add_repeated_bool(false);
201  message->add_repeated_string("315");
202  message->add_repeated_bytes("316");
203
204  message->add_repeatedgroup()->set_a(317);
205  message->add_repeated_nested_message()->set_bb(318);
206  message->add_repeated_foreign_message()->set_c(319);
207  message->add_repeated_import_message()->set_d(320);
208  message->add_repeated_lazy_message()->set_bb(327);
209
210  message->add_repeated_nested_enum(UNITTEST::TestAllTypes::BAZ);
211  message->add_repeated_foreign_enum(UNITTEST::FOREIGN_BAZ);
212  message->add_repeated_import_enum(UNITTEST_IMPORT::IMPORT_BAZ);
213
214#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
215  message->GetReflection()->AddString(
216      message,
217      message->GetDescriptor()->FindFieldByName("repeated_string_piece"),
218      "324");
219  message->GetReflection()->AddString(
220      message, message->GetDescriptor()->FindFieldByName("repeated_cord"),
221      "325");
222#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
223}
224
225// -------------------------------------------------------------------
226
227inline void TestUtil::SetDefaultFields(UNITTEST::TestAllTypes* message) {
228  message->set_default_int32(401);
229  message->set_default_int64(402);
230  message->set_default_uint32(403);
231  message->set_default_uint64(404);
232  message->set_default_sint32(405);
233  message->set_default_sint64(406);
234  message->set_default_fixed32(407);
235  message->set_default_fixed64(408);
236  message->set_default_sfixed32(409);
237  message->set_default_sfixed64(410);
238  message->set_default_float(411);
239  message->set_default_double(412);
240  message->set_default_bool(false);
241  message->set_default_string("415");
242  message->set_default_bytes("416");
243
244  message->set_default_nested_enum(UNITTEST::TestAllTypes::FOO);
245  message->set_default_foreign_enum(UNITTEST::FOREIGN_FOO);
246  message->set_default_import_enum(UNITTEST_IMPORT::IMPORT_FOO);
247
248#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
249  message->GetReflection()->SetString(
250      message,
251      message->GetDescriptor()->FindFieldByName("default_string_piece"), "424");
252  message->GetReflection()->SetString(
253      message, message->GetDescriptor()->FindFieldByName("default_cord"),
254      "425");
255#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
256}
257
258// -------------------------------------------------------------------
259
260inline void TestUtil::ModifyRepeatedFields(UNITTEST::TestAllTypes* message) {
261  message->set_repeated_int32(1, 501);
262  message->set_repeated_int64(1, 502);
263  message->set_repeated_uint32(1, 503);
264  message->set_repeated_uint64(1, 504);
265  message->set_repeated_sint32(1, 505);
266  message->set_repeated_sint64(1, 506);
267  message->set_repeated_fixed32(1, 507);
268  message->set_repeated_fixed64(1, 508);
269  message->set_repeated_sfixed32(1, 509);
270  message->set_repeated_sfixed64(1, 510);
271  message->set_repeated_float(1, 511);
272  message->set_repeated_double(1, 512);
273  message->set_repeated_bool(1, true);
274  message->set_repeated_string(1, "515");
275  message->set_repeated_bytes(1, "516");
276
277  message->mutable_repeatedgroup(1)->set_a(517);
278  message->mutable_repeated_nested_message(1)->set_bb(518);
279  message->mutable_repeated_foreign_message(1)->set_c(519);
280  message->mutable_repeated_import_message(1)->set_d(520);
281  message->mutable_repeated_lazy_message(1)->set_bb(527);
282
283  message->set_repeated_nested_enum(1, UNITTEST::TestAllTypes::FOO);
284  message->set_repeated_foreign_enum(1, UNITTEST::FOREIGN_FOO);
285  message->set_repeated_import_enum(1, UNITTEST_IMPORT::IMPORT_FOO);
286
287#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
288  message->GetReflection()->SetRepeatedString(
289      message,
290      message->GetDescriptor()->FindFieldByName("repeated_string_piece"), 1,
291      "524");
292  message->GetReflection()->SetRepeatedString(
293      message, message->GetDescriptor()->FindFieldByName("repeated_cord"), 1,
294      "525");
295#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
296}
297
298// ------------------------------------------------------------------
299inline void TestUtil::SetOneofFields(UNITTEST::TestAllTypes* message) {
300  message->set_oneof_uint32(601);
301  message->mutable_oneof_nested_message()->set_bb(602);
302  message->mutable_oneof_lazy_nested_message()->set_bb(605);
303  message->set_oneof_string("603");
304#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
305  message->GetReflection()->SetString(
306      message, message->GetDescriptor()->FindFieldByName("oneof_cord"), "606");
307  message->GetReflection()->SetString(
308      message, message->GetDescriptor()->FindFieldByName("oneof_string_piece"),
309      "607");
310#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
311  // Must be last because tests are expecting it.
312  message->set_oneof_bytes("604");
313}
314
315// -------------------------------------------------------------------
316
317inline void TestUtil::ExpectAllFieldsSet(
318    const UNITTEST::TestAllTypes& message) {
319  EXPECT_TRUE(message.has_optional_int32());
320  EXPECT_TRUE(message.has_optional_int64());
321  EXPECT_TRUE(message.has_optional_uint32());
322  EXPECT_TRUE(message.has_optional_uint64());
323  EXPECT_TRUE(message.has_optional_sint32());
324  EXPECT_TRUE(message.has_optional_sint64());
325  EXPECT_TRUE(message.has_optional_fixed32());
326  EXPECT_TRUE(message.has_optional_fixed64());
327  EXPECT_TRUE(message.has_optional_sfixed32());
328  EXPECT_TRUE(message.has_optional_sfixed64());
329  EXPECT_TRUE(message.has_optional_float());
330  EXPECT_TRUE(message.has_optional_double());
331  EXPECT_TRUE(message.has_optional_bool());
332  EXPECT_TRUE(message.has_optional_string());
333  EXPECT_TRUE(message.has_optional_bytes());
334
335  EXPECT_TRUE(message.has_optionalgroup());
336  EXPECT_TRUE(message.has_optional_nested_message());
337  EXPECT_TRUE(message.has_optional_foreign_message());
338  EXPECT_TRUE(message.has_optional_import_message());
339  EXPECT_TRUE(message.has_optional_public_import_message());
340  EXPECT_TRUE(message.has_optional_lazy_message());
341  EXPECT_TRUE(message.has_optional_unverified_lazy_message());
342
343  EXPECT_TRUE(message.optionalgroup().has_a());
344  EXPECT_TRUE(message.optional_nested_message().has_bb());
345  EXPECT_TRUE(message.optional_foreign_message().has_c());
346  EXPECT_TRUE(message.optional_import_message().has_d());
347  EXPECT_TRUE(message.optional_public_import_message().has_e());
348  EXPECT_TRUE(message.optional_lazy_message().has_bb());
349  EXPECT_TRUE(message.optional_unverified_lazy_message().has_bb());
350
351  EXPECT_TRUE(message.has_optional_nested_enum());
352  EXPECT_TRUE(message.has_optional_foreign_enum());
353  EXPECT_TRUE(message.has_optional_import_enum());
354
355#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
356  EXPECT_TRUE(message.has_optional_string_piece());
357  EXPECT_TRUE(message.has_optional_cord());
358#endif
359  EXPECT_TRUE(message.has_optional_bytes_cord());
360
361  EXPECT_EQ(101, message.optional_int32());
362  EXPECT_EQ(102, message.optional_int64());
363  EXPECT_EQ(103, message.optional_uint32());
364  EXPECT_EQ(104, message.optional_uint64());
365  EXPECT_EQ(105, message.optional_sint32());
366  EXPECT_EQ(106, message.optional_sint64());
367  EXPECT_EQ(107, message.optional_fixed32());
368  EXPECT_EQ(108, message.optional_fixed64());
369  EXPECT_EQ(109, message.optional_sfixed32());
370  EXPECT_EQ(110, message.optional_sfixed64());
371  EXPECT_EQ(111, message.optional_float());
372  EXPECT_EQ(112, message.optional_double());
373  EXPECT_TRUE(message.optional_bool());
374  EXPECT_EQ("115", message.optional_string());
375  EXPECT_EQ("116", message.optional_bytes());
376
377  EXPECT_EQ(117, message.optionalgroup().a());
378  EXPECT_EQ(118, message.optional_nested_message().bb());
379  EXPECT_EQ(119, message.optional_foreign_message().c());
380  EXPECT_EQ(120, message.optional_import_message().d());
381  EXPECT_EQ(126, message.optional_public_import_message().e());
382  EXPECT_EQ(127, message.optional_lazy_message().bb());
383  EXPECT_EQ(128, message.optional_unverified_lazy_message().bb());
384
385  EXPECT_EQ(UNITTEST::TestAllTypes::BAZ, message.optional_nested_enum());
386  EXPECT_EQ(UNITTEST::FOREIGN_BAZ, message.optional_foreign_enum());
387  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAZ, message.optional_import_enum());
388
389  EXPECT_EQ("optional bytes cord", message.optional_bytes_cord());
390
391  // -----------------------------------------------------------------
392
393  ASSERT_EQ(2, message.repeated_int32_size());
394  ASSERT_EQ(2, message.repeated_int64_size());
395  ASSERT_EQ(2, message.repeated_uint32_size());
396  ASSERT_EQ(2, message.repeated_uint64_size());
397  ASSERT_EQ(2, message.repeated_sint32_size());
398  ASSERT_EQ(2, message.repeated_sint64_size());
399  ASSERT_EQ(2, message.repeated_fixed32_size());
400  ASSERT_EQ(2, message.repeated_fixed64_size());
401  ASSERT_EQ(2, message.repeated_sfixed32_size());
402  ASSERT_EQ(2, message.repeated_sfixed64_size());
403  ASSERT_EQ(2, message.repeated_float_size());
404  ASSERT_EQ(2, message.repeated_double_size());
405  ASSERT_EQ(2, message.repeated_bool_size());
406  ASSERT_EQ(2, message.repeated_string_size());
407  ASSERT_EQ(2, message.repeated_bytes_size());
408
409  ASSERT_EQ(2, message.repeatedgroup_size());
410  ASSERT_EQ(2, message.repeated_nested_message_size());
411  ASSERT_EQ(2, message.repeated_foreign_message_size());
412  ASSERT_EQ(2, message.repeated_import_message_size());
413  ASSERT_EQ(2, message.repeated_lazy_message_size());
414  ASSERT_EQ(2, message.repeated_nested_enum_size());
415  ASSERT_EQ(2, message.repeated_foreign_enum_size());
416  ASSERT_EQ(2, message.repeated_import_enum_size());
417
418#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
419  ASSERT_EQ(2, message.repeated_string_piece_size());
420  ASSERT_EQ(2, message.repeated_cord_size());
421#endif
422
423  EXPECT_EQ(201, message.repeated_int32(0));
424  EXPECT_EQ(202, message.repeated_int64(0));
425  EXPECT_EQ(203, message.repeated_uint32(0));
426  EXPECT_EQ(204, message.repeated_uint64(0));
427  EXPECT_EQ(205, message.repeated_sint32(0));
428  EXPECT_EQ(206, message.repeated_sint64(0));
429  EXPECT_EQ(207, message.repeated_fixed32(0));
430  EXPECT_EQ(208, message.repeated_fixed64(0));
431  EXPECT_EQ(209, message.repeated_sfixed32(0));
432  EXPECT_EQ(210, message.repeated_sfixed64(0));
433  EXPECT_EQ(211, message.repeated_float(0));
434  EXPECT_EQ(212, message.repeated_double(0));
435  EXPECT_TRUE(message.repeated_bool(0));
436  EXPECT_EQ("215", message.repeated_string(0));
437  EXPECT_EQ("216", message.repeated_bytes(0));
438
439  EXPECT_EQ(217, message.repeatedgroup(0).a());
440  EXPECT_EQ(218, message.repeated_nested_message(0).bb());
441  EXPECT_EQ(219, message.repeated_foreign_message(0).c());
442  EXPECT_EQ(220, message.repeated_import_message(0).d());
443  EXPECT_EQ(227, message.repeated_lazy_message(0).bb());
444
445
446  EXPECT_EQ(UNITTEST::TestAllTypes::BAR, message.repeated_nested_enum(0));
447  EXPECT_EQ(UNITTEST::FOREIGN_BAR, message.repeated_foreign_enum(0));
448  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAR, message.repeated_import_enum(0));
449
450  EXPECT_EQ(301, message.repeated_int32(1));
451  EXPECT_EQ(302, message.repeated_int64(1));
452  EXPECT_EQ(303, message.repeated_uint32(1));
453  EXPECT_EQ(304, message.repeated_uint64(1));
454  EXPECT_EQ(305, message.repeated_sint32(1));
455  EXPECT_EQ(306, message.repeated_sint64(1));
456  EXPECT_EQ(307, message.repeated_fixed32(1));
457  EXPECT_EQ(308, message.repeated_fixed64(1));
458  EXPECT_EQ(309, message.repeated_sfixed32(1));
459  EXPECT_EQ(310, message.repeated_sfixed64(1));
460  EXPECT_EQ(311, message.repeated_float(1));
461  EXPECT_EQ(312, message.repeated_double(1));
462  EXPECT_FALSE(message.repeated_bool(1));
463  EXPECT_EQ("315", message.repeated_string(1));
464  EXPECT_EQ("316", message.repeated_bytes(1));
465
466  EXPECT_EQ(317, message.repeatedgroup(1).a());
467  EXPECT_EQ(318, message.repeated_nested_message(1).bb());
468  EXPECT_EQ(319, message.repeated_foreign_message(1).c());
469  EXPECT_EQ(320, message.repeated_import_message(1).d());
470  EXPECT_EQ(327, message.repeated_lazy_message(1).bb());
471
472  EXPECT_EQ(UNITTEST::TestAllTypes::BAZ, message.repeated_nested_enum(1));
473  EXPECT_EQ(UNITTEST::FOREIGN_BAZ, message.repeated_foreign_enum(1));
474  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAZ, message.repeated_import_enum(1));
475
476
477  // -----------------------------------------------------------------
478
479  EXPECT_TRUE(message.has_default_int32());
480  EXPECT_TRUE(message.has_default_int64());
481  EXPECT_TRUE(message.has_default_uint32());
482  EXPECT_TRUE(message.has_default_uint64());
483  EXPECT_TRUE(message.has_default_sint32());
484  EXPECT_TRUE(message.has_default_sint64());
485  EXPECT_TRUE(message.has_default_fixed32());
486  EXPECT_TRUE(message.has_default_fixed64());
487  EXPECT_TRUE(message.has_default_sfixed32());
488  EXPECT_TRUE(message.has_default_sfixed64());
489  EXPECT_TRUE(message.has_default_float());
490  EXPECT_TRUE(message.has_default_double());
491  EXPECT_TRUE(message.has_default_bool());
492  EXPECT_TRUE(message.has_default_string());
493  EXPECT_TRUE(message.has_default_bytes());
494
495  EXPECT_TRUE(message.has_default_nested_enum());
496  EXPECT_TRUE(message.has_default_foreign_enum());
497  EXPECT_TRUE(message.has_default_import_enum());
498
499
500  EXPECT_EQ(401, message.default_int32());
501  EXPECT_EQ(402, message.default_int64());
502  EXPECT_EQ(403, message.default_uint32());
503  EXPECT_EQ(404, message.default_uint64());
504  EXPECT_EQ(405, message.default_sint32());
505  EXPECT_EQ(406, message.default_sint64());
506  EXPECT_EQ(407, message.default_fixed32());
507  EXPECT_EQ(408, message.default_fixed64());
508  EXPECT_EQ(409, message.default_sfixed32());
509  EXPECT_EQ(410, message.default_sfixed64());
510  EXPECT_EQ(411, message.default_float());
511  EXPECT_EQ(412, message.default_double());
512  EXPECT_FALSE(message.default_bool());
513  EXPECT_EQ("415", message.default_string());
514  EXPECT_EQ("416", message.default_bytes());
515
516  EXPECT_EQ(UNITTEST::TestAllTypes::FOO, message.default_nested_enum());
517  EXPECT_EQ(UNITTEST::FOREIGN_FOO, message.default_foreign_enum());
518  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_FOO, message.default_import_enum());
519
520
521  EXPECT_FALSE(message.has_oneof_uint32());
522  EXPECT_FALSE(message.has_oneof_nested_message());
523  EXPECT_FALSE(message.has_oneof_string());
524  EXPECT_TRUE(message.has_oneof_bytes());
525
526  EXPECT_EQ("604", message.oneof_bytes());
527}
528
529// -------------------------------------------------------------------
530
531inline void TestUtil::ExpectClear(const UNITTEST::TestAllTypes& message) {
532  // has_blah() should initially be false for all optional fields.
533  EXPECT_FALSE(message.has_optional_int32());
534  EXPECT_FALSE(message.has_optional_int64());
535  EXPECT_FALSE(message.has_optional_uint32());
536  EXPECT_FALSE(message.has_optional_uint64());
537  EXPECT_FALSE(message.has_optional_sint32());
538  EXPECT_FALSE(message.has_optional_sint64());
539  EXPECT_FALSE(message.has_optional_fixed32());
540  EXPECT_FALSE(message.has_optional_fixed64());
541  EXPECT_FALSE(message.has_optional_sfixed32());
542  EXPECT_FALSE(message.has_optional_sfixed64());
543  EXPECT_FALSE(message.has_optional_float());
544  EXPECT_FALSE(message.has_optional_double());
545  EXPECT_FALSE(message.has_optional_bool());
546  EXPECT_FALSE(message.has_optional_string());
547  EXPECT_FALSE(message.has_optional_bytes());
548
549  EXPECT_FALSE(message.has_optionalgroup());
550  EXPECT_FALSE(message.has_optional_nested_message());
551  EXPECT_FALSE(message.has_optional_foreign_message());
552  EXPECT_FALSE(message.has_optional_import_message());
553  EXPECT_FALSE(message.has_optional_public_import_message());
554  EXPECT_FALSE(message.has_optional_lazy_message());
555  EXPECT_FALSE(message.has_optional_unverified_lazy_message());
556
557  EXPECT_FALSE(message.has_optional_nested_enum());
558  EXPECT_FALSE(message.has_optional_foreign_enum());
559  EXPECT_FALSE(message.has_optional_import_enum());
560
561  EXPECT_FALSE(message.has_optional_string_piece());
562  EXPECT_FALSE(message.has_optional_cord());
563  EXPECT_FALSE(message.has_optional_bytes_cord());
564
565  // Optional fields without defaults are set to zero or something like it.
566  EXPECT_EQ(0, message.optional_int32());
567  EXPECT_EQ(0, message.optional_int64());
568  EXPECT_EQ(0, message.optional_uint32());
569  EXPECT_EQ(0, message.optional_uint64());
570  EXPECT_EQ(0, message.optional_sint32());
571  EXPECT_EQ(0, message.optional_sint64());
572  EXPECT_EQ(0, message.optional_fixed32());
573  EXPECT_EQ(0, message.optional_fixed64());
574  EXPECT_EQ(0, message.optional_sfixed32());
575  EXPECT_EQ(0, message.optional_sfixed64());
576  EXPECT_EQ(0, message.optional_float());
577  EXPECT_EQ(0, message.optional_double());
578  EXPECT_FALSE(message.optional_bool());
579  EXPECT_EQ("", message.optional_string());
580  EXPECT_EQ("", message.optional_bytes());
581
582  // Embedded messages should also be clear.
583  EXPECT_FALSE(message.optionalgroup().has_a());
584  EXPECT_FALSE(message.optional_nested_message().has_bb());
585  EXPECT_FALSE(message.optional_foreign_message().has_c());
586  EXPECT_FALSE(message.optional_import_message().has_d());
587  EXPECT_FALSE(message.optional_public_import_message().has_e());
588  EXPECT_FALSE(message.optional_lazy_message().has_bb());
589  EXPECT_FALSE(message.optional_unverified_lazy_message().has_bb());
590
591  EXPECT_EQ(0, message.optionalgroup().a());
592  EXPECT_EQ(0, message.optional_nested_message().bb());
593  EXPECT_EQ(0, message.optional_foreign_message().c());
594  EXPECT_EQ(0, message.optional_import_message().d());
595  EXPECT_EQ(0, message.optional_public_import_message().e());
596  EXPECT_EQ(0, message.optional_lazy_message().bb());
597  EXPECT_EQ(0, message.optional_unverified_lazy_message().bb());
598
599  // Enums without defaults are set to the first value in the enum.
600  EXPECT_EQ(UNITTEST::TestAllTypes::FOO, message.optional_nested_enum());
601  EXPECT_EQ(UNITTEST::FOREIGN_FOO, message.optional_foreign_enum());
602  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_FOO, message.optional_import_enum());
603
604  EXPECT_EQ("", message.optional_bytes_cord());
605
606  // Repeated fields are empty.
607  EXPECT_EQ(0, message.repeated_int32_size());
608  EXPECT_EQ(0, message.repeated_int64_size());
609  EXPECT_EQ(0, message.repeated_uint32_size());
610  EXPECT_EQ(0, message.repeated_uint64_size());
611  EXPECT_EQ(0, message.repeated_sint32_size());
612  EXPECT_EQ(0, message.repeated_sint64_size());
613  EXPECT_EQ(0, message.repeated_fixed32_size());
614  EXPECT_EQ(0, message.repeated_fixed64_size());
615  EXPECT_EQ(0, message.repeated_sfixed32_size());
616  EXPECT_EQ(0, message.repeated_sfixed64_size());
617  EXPECT_EQ(0, message.repeated_float_size());
618  EXPECT_EQ(0, message.repeated_double_size());
619  EXPECT_EQ(0, message.repeated_bool_size());
620  EXPECT_EQ(0, message.repeated_string_size());
621  EXPECT_EQ(0, message.repeated_bytes_size());
622
623  EXPECT_EQ(0, message.repeatedgroup_size());
624  EXPECT_EQ(0, message.repeated_nested_message_size());
625  EXPECT_EQ(0, message.repeated_foreign_message_size());
626  EXPECT_EQ(0, message.repeated_import_message_size());
627  EXPECT_EQ(0, message.repeated_lazy_message_size());
628  EXPECT_EQ(0, message.repeated_nested_enum_size());
629  EXPECT_EQ(0, message.repeated_foreign_enum_size());
630  EXPECT_EQ(0, message.repeated_import_enum_size());
631
632  EXPECT_EQ(0, message.repeated_string_piece_size());
633  EXPECT_EQ(0, message.repeated_cord_size());
634
635  // has_blah() should also be false for all default fields.
636  EXPECT_FALSE(message.has_default_int32());
637  EXPECT_FALSE(message.has_default_int64());
638  EXPECT_FALSE(message.has_default_uint32());
639  EXPECT_FALSE(message.has_default_uint64());
640  EXPECT_FALSE(message.has_default_sint32());
641  EXPECT_FALSE(message.has_default_sint64());
642  EXPECT_FALSE(message.has_default_fixed32());
643  EXPECT_FALSE(message.has_default_fixed64());
644  EXPECT_FALSE(message.has_default_sfixed32());
645  EXPECT_FALSE(message.has_default_sfixed64());
646  EXPECT_FALSE(message.has_default_float());
647  EXPECT_FALSE(message.has_default_double());
648  EXPECT_FALSE(message.has_default_bool());
649  EXPECT_FALSE(message.has_default_string());
650  EXPECT_FALSE(message.has_default_bytes());
651
652  EXPECT_FALSE(message.has_default_nested_enum());
653  EXPECT_FALSE(message.has_default_foreign_enum());
654  EXPECT_FALSE(message.has_default_import_enum());
655
656
657  // Fields with defaults have their default values (duh).
658  EXPECT_EQ(41, message.default_int32());
659  EXPECT_EQ(42, message.default_int64());
660  EXPECT_EQ(43, message.default_uint32());
661  EXPECT_EQ(44, message.default_uint64());
662  EXPECT_EQ(-45, message.default_sint32());
663  EXPECT_EQ(46, message.default_sint64());
664  EXPECT_EQ(47, message.default_fixed32());
665  EXPECT_EQ(48, message.default_fixed64());
666  EXPECT_EQ(49, message.default_sfixed32());
667  EXPECT_EQ(-50, message.default_sfixed64());
668  EXPECT_EQ(51.5, message.default_float());
669  EXPECT_EQ(52e3, message.default_double());
670  EXPECT_TRUE(message.default_bool());
671  EXPECT_EQ("hello", message.default_string());
672  EXPECT_EQ("world", message.default_bytes());
673
674  EXPECT_EQ(UNITTEST::TestAllTypes::BAR, message.default_nested_enum());
675  EXPECT_EQ(UNITTEST::FOREIGN_BAR, message.default_foreign_enum());
676  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAR, message.default_import_enum());
677
678
679  EXPECT_FALSE(message.has_oneof_uint32());
680  EXPECT_FALSE(message.has_oneof_nested_message());
681  EXPECT_FALSE(message.has_oneof_string());
682  EXPECT_FALSE(message.has_oneof_bytes());
683}
684
685// -------------------------------------------------------------------
686
687inline void TestUtil::ExpectRepeatedFieldsModified(
688    const UNITTEST::TestAllTypes& message) {
689  // ModifyRepeatedFields only sets the second repeated element of each
690  // field.  In addition to verifying this, we also verify that the first
691  // element and size were *not* modified.
692  ASSERT_EQ(2, message.repeated_int32_size());
693  ASSERT_EQ(2, message.repeated_int64_size());
694  ASSERT_EQ(2, message.repeated_uint32_size());
695  ASSERT_EQ(2, message.repeated_uint64_size());
696  ASSERT_EQ(2, message.repeated_sint32_size());
697  ASSERT_EQ(2, message.repeated_sint64_size());
698  ASSERT_EQ(2, message.repeated_fixed32_size());
699  ASSERT_EQ(2, message.repeated_fixed64_size());
700  ASSERT_EQ(2, message.repeated_sfixed32_size());
701  ASSERT_EQ(2, message.repeated_sfixed64_size());
702  ASSERT_EQ(2, message.repeated_float_size());
703  ASSERT_EQ(2, message.repeated_double_size());
704  ASSERT_EQ(2, message.repeated_bool_size());
705  ASSERT_EQ(2, message.repeated_string_size());
706  ASSERT_EQ(2, message.repeated_bytes_size());
707
708  ASSERT_EQ(2, message.repeatedgroup_size());
709  ASSERT_EQ(2, message.repeated_nested_message_size());
710  ASSERT_EQ(2, message.repeated_foreign_message_size());
711  ASSERT_EQ(2, message.repeated_import_message_size());
712  ASSERT_EQ(2, message.repeated_lazy_message_size());
713  ASSERT_EQ(2, message.repeated_nested_enum_size());
714  ASSERT_EQ(2, message.repeated_foreign_enum_size());
715  ASSERT_EQ(2, message.repeated_import_enum_size());
716
717#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
718  ASSERT_EQ(2, message.repeated_string_piece_size());
719  ASSERT_EQ(2, message.repeated_cord_size());
720#endif
721
722  EXPECT_EQ(201, message.repeated_int32(0));
723  EXPECT_EQ(202, message.repeated_int64(0));
724  EXPECT_EQ(203, message.repeated_uint32(0));
725  EXPECT_EQ(204, message.repeated_uint64(0));
726  EXPECT_EQ(205, message.repeated_sint32(0));
727  EXPECT_EQ(206, message.repeated_sint64(0));
728  EXPECT_EQ(207, message.repeated_fixed32(0));
729  EXPECT_EQ(208, message.repeated_fixed64(0));
730  EXPECT_EQ(209, message.repeated_sfixed32(0));
731  EXPECT_EQ(210, message.repeated_sfixed64(0));
732  EXPECT_EQ(211, message.repeated_float(0));
733  EXPECT_EQ(212, message.repeated_double(0));
734  EXPECT_TRUE(message.repeated_bool(0));
735  EXPECT_EQ("215", message.repeated_string(0));
736  EXPECT_EQ("216", message.repeated_bytes(0));
737
738  EXPECT_EQ(217, message.repeatedgroup(0).a());
739  EXPECT_EQ(218, message.repeated_nested_message(0).bb());
740  EXPECT_EQ(219, message.repeated_foreign_message(0).c());
741  EXPECT_EQ(220, message.repeated_import_message(0).d());
742  EXPECT_EQ(227, message.repeated_lazy_message(0).bb());
743
744  EXPECT_EQ(UNITTEST::TestAllTypes::BAR, message.repeated_nested_enum(0));
745  EXPECT_EQ(UNITTEST::FOREIGN_BAR, message.repeated_foreign_enum(0));
746  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAR, message.repeated_import_enum(0));
747
748
749  // Actually verify the second (modified) elements now.
750  EXPECT_EQ(501, message.repeated_int32(1));
751  EXPECT_EQ(502, message.repeated_int64(1));
752  EXPECT_EQ(503, message.repeated_uint32(1));
753  EXPECT_EQ(504, message.repeated_uint64(1));
754  EXPECT_EQ(505, message.repeated_sint32(1));
755  EXPECT_EQ(506, message.repeated_sint64(1));
756  EXPECT_EQ(507, message.repeated_fixed32(1));
757  EXPECT_EQ(508, message.repeated_fixed64(1));
758  EXPECT_EQ(509, message.repeated_sfixed32(1));
759  EXPECT_EQ(510, message.repeated_sfixed64(1));
760  EXPECT_EQ(511, message.repeated_float(1));
761  EXPECT_EQ(512, message.repeated_double(1));
762  EXPECT_TRUE(message.repeated_bool(1));
763  EXPECT_EQ("515", message.repeated_string(1));
764  EXPECT_EQ("516", message.repeated_bytes(1));
765
766  EXPECT_EQ(517, message.repeatedgroup(1).a());
767  EXPECT_EQ(518, message.repeated_nested_message(1).bb());
768  EXPECT_EQ(519, message.repeated_foreign_message(1).c());
769  EXPECT_EQ(520, message.repeated_import_message(1).d());
770  EXPECT_EQ(527, message.repeated_lazy_message(1).bb());
771
772  EXPECT_EQ(UNITTEST::TestAllTypes::FOO, message.repeated_nested_enum(1));
773  EXPECT_EQ(UNITTEST::FOREIGN_FOO, message.repeated_foreign_enum(1));
774  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_FOO, message.repeated_import_enum(1));
775
776}
777
778// -------------------------------------------------------------------
779
780inline void TestUtil::SetPackedFields(UNITTEST::TestPackedTypes* message) {
781  message->add_packed_int32(601);
782  message->add_packed_int64(602);
783  message->add_packed_uint32(603);
784  message->add_packed_uint64(604);
785  message->add_packed_sint32(605);
786  message->add_packed_sint64(606);
787  message->add_packed_fixed32(607);
788  message->add_packed_fixed64(608);
789  message->add_packed_sfixed32(609);
790  message->add_packed_sfixed64(610);
791  message->add_packed_float(611);
792  message->add_packed_double(612);
793  message->add_packed_bool(true);
794  message->add_packed_enum(UNITTEST::FOREIGN_BAR);
795  // add a second one of each field
796  message->add_packed_int32(701);
797  message->add_packed_int64(702);
798  message->add_packed_uint32(703);
799  message->add_packed_uint64(704);
800  message->add_packed_sint32(705);
801  message->add_packed_sint64(706);
802  message->add_packed_fixed32(707);
803  message->add_packed_fixed64(708);
804  message->add_packed_sfixed32(709);
805  message->add_packed_sfixed64(710);
806  message->add_packed_float(711);
807  message->add_packed_double(712);
808  message->add_packed_bool(false);
809  message->add_packed_enum(UNITTEST::FOREIGN_BAZ);
810}
811
812inline void TestUtil::SetUnpackedFields(UNITTEST::TestUnpackedTypes* message) {
813  // The values applied here must match those of SetPackedFields.
814
815  message->add_unpacked_int32(601);
816  message->add_unpacked_int64(602);
817  message->add_unpacked_uint32(603);
818  message->add_unpacked_uint64(604);
819  message->add_unpacked_sint32(605);
820  message->add_unpacked_sint64(606);
821  message->add_unpacked_fixed32(607);
822  message->add_unpacked_fixed64(608);
823  message->add_unpacked_sfixed32(609);
824  message->add_unpacked_sfixed64(610);
825  message->add_unpacked_float(611);
826  message->add_unpacked_double(612);
827  message->add_unpacked_bool(true);
828  message->add_unpacked_enum(UNITTEST::FOREIGN_BAR);
829  // add a second one of each field
830  message->add_unpacked_int32(701);
831  message->add_unpacked_int64(702);
832  message->add_unpacked_uint32(703);
833  message->add_unpacked_uint64(704);
834  message->add_unpacked_sint32(705);
835  message->add_unpacked_sint64(706);
836  message->add_unpacked_fixed32(707);
837  message->add_unpacked_fixed64(708);
838  message->add_unpacked_sfixed32(709);
839  message->add_unpacked_sfixed64(710);
840  message->add_unpacked_float(711);
841  message->add_unpacked_double(712);
842  message->add_unpacked_bool(false);
843  message->add_unpacked_enum(UNITTEST::FOREIGN_BAZ);
844}
845
846// -------------------------------------------------------------------
847
848inline void TestUtil::ExpectPackedFieldsSet(
849    const UNITTEST::TestPackedTypes& message) {
850  ASSERT_EQ(2, message.packed_int32_size());
851  ASSERT_EQ(2, message.packed_int64_size());
852  ASSERT_EQ(2, message.packed_uint32_size());
853  ASSERT_EQ(2, message.packed_uint64_size());
854  ASSERT_EQ(2, message.packed_sint32_size());
855  ASSERT_EQ(2, message.packed_sint64_size());
856  ASSERT_EQ(2, message.packed_fixed32_size());
857  ASSERT_EQ(2, message.packed_fixed64_size());
858  ASSERT_EQ(2, message.packed_sfixed32_size());
859  ASSERT_EQ(2, message.packed_sfixed64_size());
860  ASSERT_EQ(2, message.packed_float_size());
861  ASSERT_EQ(2, message.packed_double_size());
862  ASSERT_EQ(2, message.packed_bool_size());
863  ASSERT_EQ(2, message.packed_enum_size());
864
865  EXPECT_EQ(601, message.packed_int32(0));
866  EXPECT_EQ(602, message.packed_int64(0));
867  EXPECT_EQ(603, message.packed_uint32(0));
868  EXPECT_EQ(604, message.packed_uint64(0));
869  EXPECT_EQ(605, message.packed_sint32(0));
870  EXPECT_EQ(606, message.packed_sint64(0));
871  EXPECT_EQ(607, message.packed_fixed32(0));
872  EXPECT_EQ(608, message.packed_fixed64(0));
873  EXPECT_EQ(609, message.packed_sfixed32(0));
874  EXPECT_EQ(610, message.packed_sfixed64(0));
875  EXPECT_EQ(611, message.packed_float(0));
876  EXPECT_EQ(612, message.packed_double(0));
877  EXPECT_TRUE(message.packed_bool(0));
878  EXPECT_EQ(UNITTEST::FOREIGN_BAR, message.packed_enum(0));
879
880  EXPECT_EQ(701, message.packed_int32(1));
881  EXPECT_EQ(702, message.packed_int64(1));
882  EXPECT_EQ(703, message.packed_uint32(1));
883  EXPECT_EQ(704, message.packed_uint64(1));
884  EXPECT_EQ(705, message.packed_sint32(1));
885  EXPECT_EQ(706, message.packed_sint64(1));
886  EXPECT_EQ(707, message.packed_fixed32(1));
887  EXPECT_EQ(708, message.packed_fixed64(1));
888  EXPECT_EQ(709, message.packed_sfixed32(1));
889  EXPECT_EQ(710, message.packed_sfixed64(1));
890  EXPECT_EQ(711, message.packed_float(1));
891  EXPECT_EQ(712, message.packed_double(1));
892  EXPECT_FALSE(message.packed_bool(1));
893  EXPECT_EQ(UNITTEST::FOREIGN_BAZ, message.packed_enum(1));
894}
895
896inline void TestUtil::ExpectUnpackedFieldsSet(
897    const UNITTEST::TestUnpackedTypes& message) {
898  // The values expected here must match those of ExpectPackedFieldsSet.
899
900  ASSERT_EQ(2, message.unpacked_int32_size());
901  ASSERT_EQ(2, message.unpacked_int64_size());
902  ASSERT_EQ(2, message.unpacked_uint32_size());
903  ASSERT_EQ(2, message.unpacked_uint64_size());
904  ASSERT_EQ(2, message.unpacked_sint32_size());
905  ASSERT_EQ(2, message.unpacked_sint64_size());
906  ASSERT_EQ(2, message.unpacked_fixed32_size());
907  ASSERT_EQ(2, message.unpacked_fixed64_size());
908  ASSERT_EQ(2, message.unpacked_sfixed32_size());
909  ASSERT_EQ(2, message.unpacked_sfixed64_size());
910  ASSERT_EQ(2, message.unpacked_float_size());
911  ASSERT_EQ(2, message.unpacked_double_size());
912  ASSERT_EQ(2, message.unpacked_bool_size());
913  ASSERT_EQ(2, message.unpacked_enum_size());
914
915  EXPECT_EQ(601, message.unpacked_int32(0));
916  EXPECT_EQ(602, message.unpacked_int64(0));
917  EXPECT_EQ(603, message.unpacked_uint32(0));
918  EXPECT_EQ(604, message.unpacked_uint64(0));
919  EXPECT_EQ(605, message.unpacked_sint32(0));
920  EXPECT_EQ(606, message.unpacked_sint64(0));
921  EXPECT_EQ(607, message.unpacked_fixed32(0));
922  EXPECT_EQ(608, message.unpacked_fixed64(0));
923  EXPECT_EQ(609, message.unpacked_sfixed32(0));
924  EXPECT_EQ(610, message.unpacked_sfixed64(0));
925  EXPECT_EQ(611, message.unpacked_float(0));
926  EXPECT_EQ(612, message.unpacked_double(0));
927  EXPECT_TRUE(message.unpacked_bool(0));
928  EXPECT_EQ(UNITTEST::FOREIGN_BAR, message.unpacked_enum(0));
929
930  EXPECT_EQ(701, message.unpacked_int32(1));
931  EXPECT_EQ(702, message.unpacked_int64(1));
932  EXPECT_EQ(703, message.unpacked_uint32(1));
933  EXPECT_EQ(704, message.unpacked_uint64(1));
934  EXPECT_EQ(705, message.unpacked_sint32(1));
935  EXPECT_EQ(706, message.unpacked_sint64(1));
936  EXPECT_EQ(707, message.unpacked_fixed32(1));
937  EXPECT_EQ(708, message.unpacked_fixed64(1));
938  EXPECT_EQ(709, message.unpacked_sfixed32(1));
939  EXPECT_EQ(710, message.unpacked_sfixed64(1));
940  EXPECT_EQ(711, message.unpacked_float(1));
941  EXPECT_EQ(712, message.unpacked_double(1));
942  EXPECT_FALSE(message.unpacked_bool(1));
943  EXPECT_EQ(UNITTEST::FOREIGN_BAZ, message.unpacked_enum(1));
944}
945
946// ===================================================================
947// Extensions
948//
949// All this code is exactly equivalent to the above code except that it's
950// manipulating extension fields instead of normal ones.
951
952inline void TestUtil::SetAllExtensions(UNITTEST::TestAllExtensions* message) {
953  message->SetExtension(UNITTEST::optional_int32_extension, 101);
954  message->SetExtension(UNITTEST::optional_int64_extension, 102);
955  message->SetExtension(UNITTEST::optional_uint32_extension, 103);
956  message->SetExtension(UNITTEST::optional_uint64_extension, 104);
957  message->SetExtension(UNITTEST::optional_sint32_extension, 105);
958  message->SetExtension(UNITTEST::optional_sint64_extension, 106);
959  message->SetExtension(UNITTEST::optional_fixed32_extension, 107);
960  message->SetExtension(UNITTEST::optional_fixed64_extension, 108);
961  message->SetExtension(UNITTEST::optional_sfixed32_extension, 109);
962  message->SetExtension(UNITTEST::optional_sfixed64_extension, 110);
963  message->SetExtension(UNITTEST::optional_float_extension, 111);
964  message->SetExtension(UNITTEST::optional_double_extension, 112);
965  message->SetExtension(UNITTEST::optional_bool_extension, true);
966  message->SetExtension(UNITTEST::optional_string_extension, "115");
967  message->SetExtension(UNITTEST::optional_bytes_extension, "116");
968
969  message->MutableExtension(UNITTEST::optionalgroup_extension)->set_a(117);
970  message->MutableExtension(UNITTEST::optional_nested_message_extension)
971      ->set_bb(118);
972  message->MutableExtension(UNITTEST::optional_foreign_message_extension)
973      ->set_c(119);
974  message->MutableExtension(UNITTEST::optional_import_message_extension)
975      ->set_d(120);
976
977  message->SetExtension(UNITTEST::optional_nested_enum_extension,
978                        UNITTEST::TestAllTypes::BAZ);
979  message->SetExtension(UNITTEST::optional_foreign_enum_extension,
980                        UNITTEST::FOREIGN_BAZ);
981  message->SetExtension(UNITTEST::optional_import_enum_extension,
982                        UNITTEST_IMPORT::IMPORT_BAZ);
983
984  message->SetExtension(UNITTEST::optional_string_piece_extension, "124");
985  message->SetExtension(UNITTEST::optional_cord_extension, "125");
986  message->SetExtension(UNITTEST::optional_bytes_cord_extension,
987                        "optional bytes cord");
988
989  message->MutableExtension(UNITTEST::optional_public_import_message_extension)
990      ->set_e(126);
991  message->MutableExtension(UNITTEST::optional_lazy_message_extension)
992      ->set_bb(127);
993  message
994      ->MutableExtension(UNITTEST::optional_unverified_lazy_message_extension)
995      ->set_bb(128);
996
997  // -----------------------------------------------------------------
998
999  message->AddExtension(UNITTEST::repeated_int32_extension, 201);
1000  message->AddExtension(UNITTEST::repeated_int64_extension, 202);
1001  message->AddExtension(UNITTEST::repeated_uint32_extension, 203);
1002  message->AddExtension(UNITTEST::repeated_uint64_extension, 204);
1003  message->AddExtension(UNITTEST::repeated_sint32_extension, 205);
1004  message->AddExtension(UNITTEST::repeated_sint64_extension, 206);
1005  message->AddExtension(UNITTEST::repeated_fixed32_extension, 207);
1006  message->AddExtension(UNITTEST::repeated_fixed64_extension, 208);
1007  message->AddExtension(UNITTEST::repeated_sfixed32_extension, 209);
1008  message->AddExtension(UNITTEST::repeated_sfixed64_extension, 210);
1009  message->AddExtension(UNITTEST::repeated_float_extension, 211);
1010  message->AddExtension(UNITTEST::repeated_double_extension, 212);
1011  message->AddExtension(UNITTEST::repeated_bool_extension, true);
1012  message->AddExtension(UNITTEST::repeated_string_extension, "215");
1013  message->AddExtension(UNITTEST::repeated_bytes_extension, "216");
1014
1015  message->AddExtension(UNITTEST::repeatedgroup_extension)->set_a(217);
1016  message->AddExtension(UNITTEST::repeated_nested_message_extension)
1017      ->set_bb(218);
1018  message->AddExtension(UNITTEST::repeated_foreign_message_extension)
1019      ->set_c(219);
1020  message->AddExtension(UNITTEST::repeated_import_message_extension)
1021      ->set_d(220);
1022  message->AddExtension(UNITTEST::repeated_lazy_message_extension)->set_bb(227);
1023
1024  message->AddExtension(UNITTEST::repeated_nested_enum_extension,
1025                        UNITTEST::TestAllTypes::BAR);
1026  message->AddExtension(UNITTEST::repeated_foreign_enum_extension,
1027                        UNITTEST::FOREIGN_BAR);
1028  message->AddExtension(UNITTEST::repeated_import_enum_extension,
1029                        UNITTEST_IMPORT::IMPORT_BAR);
1030
1031  message->AddExtension(UNITTEST::repeated_string_piece_extension, "224");
1032  message->AddExtension(UNITTEST::repeated_cord_extension, "225");
1033
1034  // Add a second one of each field.
1035  message->AddExtension(UNITTEST::repeated_int32_extension, 301);
1036  message->AddExtension(UNITTEST::repeated_int64_extension, 302);
1037  message->AddExtension(UNITTEST::repeated_uint32_extension, 303);
1038  message->AddExtension(UNITTEST::repeated_uint64_extension, 304);
1039  message->AddExtension(UNITTEST::repeated_sint32_extension, 305);
1040  message->AddExtension(UNITTEST::repeated_sint64_extension, 306);
1041  message->AddExtension(UNITTEST::repeated_fixed32_extension, 307);
1042  message->AddExtension(UNITTEST::repeated_fixed64_extension, 308);
1043  message->AddExtension(UNITTEST::repeated_sfixed32_extension, 309);
1044  message->AddExtension(UNITTEST::repeated_sfixed64_extension, 310);
1045  message->AddExtension(UNITTEST::repeated_float_extension, 311);
1046  message->AddExtension(UNITTEST::repeated_double_extension, 312);
1047  message->AddExtension(UNITTEST::repeated_bool_extension, false);
1048  message->AddExtension(UNITTEST::repeated_string_extension, "315");
1049  message->AddExtension(UNITTEST::repeated_bytes_extension, "316");
1050
1051  message->AddExtension(UNITTEST::repeatedgroup_extension)->set_a(317);
1052  message->AddExtension(UNITTEST::repeated_nested_message_extension)
1053      ->set_bb(318);
1054  message->AddExtension(UNITTEST::repeated_foreign_message_extension)
1055      ->set_c(319);
1056  message->AddExtension(UNITTEST::repeated_import_message_extension)
1057      ->set_d(320);
1058  message->AddExtension(UNITTEST::repeated_lazy_message_extension)->set_bb(327);
1059
1060  message->AddExtension(UNITTEST::repeated_nested_enum_extension,
1061                        UNITTEST::TestAllTypes::BAZ);
1062  message->AddExtension(UNITTEST::repeated_foreign_enum_extension,
1063                        UNITTEST::FOREIGN_BAZ);
1064  message->AddExtension(UNITTEST::repeated_import_enum_extension,
1065                        UNITTEST_IMPORT::IMPORT_BAZ);
1066
1067  message->AddExtension(UNITTEST::repeated_string_piece_extension, "324");
1068  message->AddExtension(UNITTEST::repeated_cord_extension, "325");
1069
1070  // -----------------------------------------------------------------
1071
1072  message->SetExtension(UNITTEST::default_int32_extension, 401);
1073  message->SetExtension(UNITTEST::default_int64_extension, 402);
1074  message->SetExtension(UNITTEST::default_uint32_extension, 403);
1075  message->SetExtension(UNITTEST::default_uint64_extension, 404);
1076  message->SetExtension(UNITTEST::default_sint32_extension, 405);
1077  message->SetExtension(UNITTEST::default_sint64_extension, 406);
1078  message->SetExtension(UNITTEST::default_fixed32_extension, 407);
1079  message->SetExtension(UNITTEST::default_fixed64_extension, 408);
1080  message->SetExtension(UNITTEST::default_sfixed32_extension, 409);
1081  message->SetExtension(UNITTEST::default_sfixed64_extension, 410);
1082  message->SetExtension(UNITTEST::default_float_extension, 411);
1083  message->SetExtension(UNITTEST::default_double_extension, 412);
1084  message->SetExtension(UNITTEST::default_bool_extension, false);
1085  message->SetExtension(UNITTEST::default_string_extension, "415");
1086  message->SetExtension(UNITTEST::default_bytes_extension, "416");
1087
1088  message->SetExtension(UNITTEST::default_nested_enum_extension,
1089                        UNITTEST::TestAllTypes::FOO);
1090  message->SetExtension(UNITTEST::default_foreign_enum_extension,
1091                        UNITTEST::FOREIGN_FOO);
1092  message->SetExtension(UNITTEST::default_import_enum_extension,
1093                        UNITTEST_IMPORT::IMPORT_FOO);
1094
1095  message->SetExtension(UNITTEST::default_string_piece_extension, "424");
1096  message->SetExtension(UNITTEST::default_cord_extension, "425");
1097
1098  SetOneofFields(message);
1099}
1100
1101inline void TestUtil::SetOneofFields(UNITTEST::TestAllExtensions* message) {
1102  message->SetExtension(UNITTEST::oneof_uint32_extension, 601);
1103  message->MutableExtension(UNITTEST::oneof_nested_message_extension)
1104      ->set_bb(602);
1105  message->SetExtension(UNITTEST::oneof_string_extension, "603");
1106  message->SetExtension(UNITTEST::oneof_bytes_extension, "604");
1107}
1108
1109// -------------------------------------------------------------------
1110
1111inline void TestUtil::SetAllFieldsAndExtensions(
1112    UNITTEST::TestFieldOrderings* message) {
1113  ABSL_CHECK(message);
1114  message->set_my_int(1);
1115  message->set_my_string("foo");
1116  message->set_my_float(1.0);
1117  message->SetExtension(UNITTEST::my_extension_int, 23);
1118  message->SetExtension(UNITTEST::my_extension_string, "bar");
1119}
1120
1121// -------------------------------------------------------------------
1122
1123inline void TestUtil::ModifyRepeatedExtensions(
1124    UNITTEST::TestAllExtensions* message) {
1125  message->SetExtension(UNITTEST::repeated_int32_extension, 1, 501);
1126  message->SetExtension(UNITTEST::repeated_int64_extension, 1, 502);
1127  message->SetExtension(UNITTEST::repeated_uint32_extension, 1, 503);
1128  message->SetExtension(UNITTEST::repeated_uint64_extension, 1, 504);
1129  message->SetExtension(UNITTEST::repeated_sint32_extension, 1, 505);
1130  message->SetExtension(UNITTEST::repeated_sint64_extension, 1, 506);
1131  message->SetExtension(UNITTEST::repeated_fixed32_extension, 1, 507);
1132  message->SetExtension(UNITTEST::repeated_fixed64_extension, 1, 508);
1133  message->SetExtension(UNITTEST::repeated_sfixed32_extension, 1, 509);
1134  message->SetExtension(UNITTEST::repeated_sfixed64_extension, 1, 510);
1135  message->SetExtension(UNITTEST::repeated_float_extension, 1, 511);
1136  message->SetExtension(UNITTEST::repeated_double_extension, 1, 512);
1137  message->SetExtension(UNITTEST::repeated_bool_extension, 1, true);
1138  message->SetExtension(UNITTEST::repeated_string_extension, 1, "515");
1139  message->SetExtension(UNITTEST::repeated_bytes_extension, 1, "516");
1140
1141  message->MutableExtension(UNITTEST::repeatedgroup_extension, 1)->set_a(517);
1142  message->MutableExtension(UNITTEST::repeated_nested_message_extension, 1)
1143      ->set_bb(518);
1144  message->MutableExtension(UNITTEST::repeated_foreign_message_extension, 1)
1145      ->set_c(519);
1146  message->MutableExtension(UNITTEST::repeated_import_message_extension, 1)
1147      ->set_d(520);
1148  message->MutableExtension(UNITTEST::repeated_lazy_message_extension, 1)
1149      ->set_bb(527);
1150
1151  message->SetExtension(UNITTEST::repeated_nested_enum_extension, 1,
1152                        UNITTEST::TestAllTypes::FOO);
1153  message->SetExtension(UNITTEST::repeated_foreign_enum_extension, 1,
1154                        UNITTEST::FOREIGN_FOO);
1155  message->SetExtension(UNITTEST::repeated_import_enum_extension, 1,
1156                        UNITTEST_IMPORT::IMPORT_FOO);
1157
1158  message->SetExtension(UNITTEST::repeated_string_piece_extension, 1, "524");
1159  message->SetExtension(UNITTEST::repeated_cord_extension, 1, "525");
1160}
1161
1162// -------------------------------------------------------------------
1163
1164inline void TestUtil::ExpectAllExtensionsSet(
1165    const UNITTEST::TestAllExtensions& message) {
1166  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_int32_extension));
1167  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_int64_extension));
1168  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_uint32_extension));
1169  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_uint64_extension));
1170  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_sint32_extension));
1171  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_sint64_extension));
1172  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_fixed32_extension));
1173  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_fixed64_extension));
1174  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_sfixed32_extension));
1175  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_sfixed64_extension));
1176  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_float_extension));
1177  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_double_extension));
1178  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_bool_extension));
1179  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_string_extension));
1180  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_bytes_extension));
1181
1182  EXPECT_TRUE(message.HasExtension(UNITTEST::optionalgroup_extension));
1183  EXPECT_TRUE(
1184      message.HasExtension(UNITTEST::optional_nested_message_extension));
1185  EXPECT_TRUE(
1186      message.HasExtension(UNITTEST::optional_foreign_message_extension));
1187  EXPECT_TRUE(
1188      message.HasExtension(UNITTEST::optional_import_message_extension));
1189  EXPECT_TRUE(
1190      message.HasExtension(UNITTEST::optional_public_import_message_extension));
1191  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_lazy_message_extension));
1192  EXPECT_TRUE(message.HasExtension(
1193      UNITTEST::optional_unverified_lazy_message_extension));
1194
1195  EXPECT_TRUE(message.GetExtension(UNITTEST::optionalgroup_extension).has_a());
1196  EXPECT_TRUE(message.GetExtension(UNITTEST::optional_nested_message_extension)
1197                  .has_bb());
1198  EXPECT_TRUE(message.GetExtension(UNITTEST::optional_foreign_message_extension)
1199                  .has_c());
1200  EXPECT_TRUE(message.GetExtension(UNITTEST::optional_import_message_extension)
1201                  .has_d());
1202  EXPECT_TRUE(
1203      message.GetExtension(UNITTEST::optional_public_import_message_extension)
1204          .has_e());
1205  EXPECT_TRUE(
1206      message.GetExtension(UNITTEST::optional_lazy_message_extension).has_bb());
1207  EXPECT_TRUE(
1208      message.GetExtension(UNITTEST::optional_unverified_lazy_message_extension)
1209          .has_bb());
1210
1211  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_nested_enum_extension));
1212  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_foreign_enum_extension));
1213  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_import_enum_extension));
1214
1215  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_string_piece_extension));
1216  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_cord_extension));
1217  EXPECT_TRUE(message.HasExtension(UNITTEST::optional_bytes_cord_extension));
1218
1219  EXPECT_EQ(101, message.GetExtension(UNITTEST::optional_int32_extension));
1220  EXPECT_EQ(102, message.GetExtension(UNITTEST::optional_int64_extension));
1221  EXPECT_EQ(103, message.GetExtension(UNITTEST::optional_uint32_extension));
1222  EXPECT_EQ(104, message.GetExtension(UNITTEST::optional_uint64_extension));
1223  EXPECT_EQ(105, message.GetExtension(UNITTEST::optional_sint32_extension));
1224  EXPECT_EQ(106, message.GetExtension(UNITTEST::optional_sint64_extension));
1225  EXPECT_EQ(107, message.GetExtension(UNITTEST::optional_fixed32_extension));
1226  EXPECT_EQ(108, message.GetExtension(UNITTEST::optional_fixed64_extension));
1227  EXPECT_EQ(109, message.GetExtension(UNITTEST::optional_sfixed32_extension));
1228  EXPECT_EQ(110, message.GetExtension(UNITTEST::optional_sfixed64_extension));
1229  EXPECT_EQ(111, message.GetExtension(UNITTEST::optional_float_extension));
1230  EXPECT_EQ(112, message.GetExtension(UNITTEST::optional_double_extension));
1231  EXPECT_TRUE(message.GetExtension(UNITTEST::optional_bool_extension));
1232  EXPECT_EQ("115", message.GetExtension(UNITTEST::optional_string_extension));
1233  EXPECT_EQ("116", message.GetExtension(UNITTEST::optional_bytes_extension));
1234
1235  EXPECT_EQ(117, message.GetExtension(UNITTEST::optionalgroup_extension).a());
1236  EXPECT_EQ(
1237      118,
1238      message.GetExtension(UNITTEST::optional_nested_message_extension).bb());
1239  EXPECT_EQ(
1240      119,
1241      message.GetExtension(UNITTEST::optional_foreign_message_extension).c());
1242  EXPECT_EQ(
1243      120,
1244      message.GetExtension(UNITTEST::optional_import_message_extension).d());
1245
1246  EXPECT_EQ(UNITTEST::TestAllTypes::BAZ,
1247            message.GetExtension(UNITTEST::optional_nested_enum_extension));
1248  EXPECT_EQ(UNITTEST::FOREIGN_BAZ,
1249            message.GetExtension(UNITTEST::optional_foreign_enum_extension));
1250  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAZ,
1251            message.GetExtension(UNITTEST::optional_import_enum_extension));
1252
1253  EXPECT_EQ("124",
1254            message.GetExtension(UNITTEST::optional_string_piece_extension));
1255  EXPECT_EQ("125", message.GetExtension(UNITTEST::optional_cord_extension));
1256  EXPECT_EQ("optional bytes cord",
1257            message.GetExtension(UNITTEST::optional_bytes_cord_extension));
1258  EXPECT_EQ(
1259      126,
1260      message.GetExtension(UNITTEST::optional_public_import_message_extension)
1261          .e());
1262  EXPECT_EQ(
1263      127,
1264      message.GetExtension(UNITTEST::optional_lazy_message_extension).bb());
1265  EXPECT_EQ(
1266      128,
1267      message.GetExtension(UNITTEST::optional_unverified_lazy_message_extension)
1268          .bb());
1269
1270  // -----------------------------------------------------------------
1271
1272  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_int32_extension));
1273  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_int64_extension));
1274  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_uint32_extension));
1275  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_uint64_extension));
1276  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_sint32_extension));
1277  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_sint64_extension));
1278  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_fixed32_extension));
1279  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_fixed64_extension));
1280  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_sfixed32_extension));
1281  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_sfixed64_extension));
1282  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_float_extension));
1283  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_double_extension));
1284  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_bool_extension));
1285  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_string_extension));
1286  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_bytes_extension));
1287
1288  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeatedgroup_extension));
1289  ASSERT_EQ(2,
1290            message.ExtensionSize(UNITTEST::repeated_nested_message_extension));
1291  ASSERT_EQ(
1292      2, message.ExtensionSize(UNITTEST::repeated_foreign_message_extension));
1293  ASSERT_EQ(2,
1294            message.ExtensionSize(UNITTEST::repeated_import_message_extension));
1295  ASSERT_EQ(2,
1296            message.ExtensionSize(UNITTEST::repeated_lazy_message_extension));
1297  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_nested_enum_extension));
1298  ASSERT_EQ(2,
1299            message.ExtensionSize(UNITTEST::repeated_foreign_enum_extension));
1300  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_import_enum_extension));
1301
1302  ASSERT_EQ(2,
1303            message.ExtensionSize(UNITTEST::repeated_string_piece_extension));
1304  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_cord_extension));
1305
1306  EXPECT_EQ(201, message.GetExtension(UNITTEST::repeated_int32_extension, 0));
1307  EXPECT_EQ(202, message.GetExtension(UNITTEST::repeated_int64_extension, 0));
1308  EXPECT_EQ(203, message.GetExtension(UNITTEST::repeated_uint32_extension, 0));
1309  EXPECT_EQ(204, message.GetExtension(UNITTEST::repeated_uint64_extension, 0));
1310  EXPECT_EQ(205, message.GetExtension(UNITTEST::repeated_sint32_extension, 0));
1311  EXPECT_EQ(206, message.GetExtension(UNITTEST::repeated_sint64_extension, 0));
1312  EXPECT_EQ(207, message.GetExtension(UNITTEST::repeated_fixed32_extension, 0));
1313  EXPECT_EQ(208, message.GetExtension(UNITTEST::repeated_fixed64_extension, 0));
1314  EXPECT_EQ(209,
1315            message.GetExtension(UNITTEST::repeated_sfixed32_extension, 0));
1316  EXPECT_EQ(210,
1317            message.GetExtension(UNITTEST::repeated_sfixed64_extension, 0));
1318  EXPECT_EQ(211, message.GetExtension(UNITTEST::repeated_float_extension, 0));
1319  EXPECT_EQ(212, message.GetExtension(UNITTEST::repeated_double_extension, 0));
1320  EXPECT_TRUE(message.GetExtension(UNITTEST::repeated_bool_extension, 0));
1321  EXPECT_EQ("215",
1322            message.GetExtension(UNITTEST::repeated_string_extension, 0));
1323  EXPECT_EQ("216", message.GetExtension(UNITTEST::repeated_bytes_extension, 0));
1324
1325  EXPECT_EQ(217,
1326            message.GetExtension(UNITTEST::repeatedgroup_extension, 0).a());
1327  EXPECT_EQ(218,
1328            message.GetExtension(UNITTEST::repeated_nested_message_extension, 0)
1329                .bb());
1330  EXPECT_EQ(
1331      219, message.GetExtension(UNITTEST::repeated_foreign_message_extension, 0)
1332               .c());
1333  EXPECT_EQ(
1334      220,
1335      message.GetExtension(UNITTEST::repeated_import_message_extension, 0).d());
1336  EXPECT_EQ(
1337      227,
1338      message.GetExtension(UNITTEST::repeated_lazy_message_extension, 0).bb());
1339
1340  EXPECT_EQ(UNITTEST::TestAllTypes::BAR,
1341            message.GetExtension(UNITTEST::repeated_nested_enum_extension, 0));
1342  EXPECT_EQ(UNITTEST::FOREIGN_BAR,
1343            message.GetExtension(UNITTEST::repeated_foreign_enum_extension, 0));
1344  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAR,
1345            message.GetExtension(UNITTEST::repeated_import_enum_extension, 0));
1346
1347  EXPECT_EQ("224",
1348            message.GetExtension(UNITTEST::repeated_string_piece_extension, 0));
1349  EXPECT_EQ("225", message.GetExtension(UNITTEST::repeated_cord_extension, 0));
1350
1351  EXPECT_EQ(301, message.GetExtension(UNITTEST::repeated_int32_extension, 1));
1352  EXPECT_EQ(302, message.GetExtension(UNITTEST::repeated_int64_extension, 1));
1353  EXPECT_EQ(303, message.GetExtension(UNITTEST::repeated_uint32_extension, 1));
1354  EXPECT_EQ(304, message.GetExtension(UNITTEST::repeated_uint64_extension, 1));
1355  EXPECT_EQ(305, message.GetExtension(UNITTEST::repeated_sint32_extension, 1));
1356  EXPECT_EQ(306, message.GetExtension(UNITTEST::repeated_sint64_extension, 1));
1357  EXPECT_EQ(307, message.GetExtension(UNITTEST::repeated_fixed32_extension, 1));
1358  EXPECT_EQ(308, message.GetExtension(UNITTEST::repeated_fixed64_extension, 1));
1359  EXPECT_EQ(309,
1360            message.GetExtension(UNITTEST::repeated_sfixed32_extension, 1));
1361  EXPECT_EQ(310,
1362            message.GetExtension(UNITTEST::repeated_sfixed64_extension, 1));
1363  EXPECT_EQ(311, message.GetExtension(UNITTEST::repeated_float_extension, 1));
1364  EXPECT_EQ(312, message.GetExtension(UNITTEST::repeated_double_extension, 1));
1365  EXPECT_FALSE(message.GetExtension(UNITTEST::repeated_bool_extension, 1));
1366  EXPECT_EQ("315",
1367            message.GetExtension(UNITTEST::repeated_string_extension, 1));
1368  EXPECT_EQ("316", message.GetExtension(UNITTEST::repeated_bytes_extension, 1));
1369
1370  EXPECT_EQ(317,
1371            message.GetExtension(UNITTEST::repeatedgroup_extension, 1).a());
1372  EXPECT_EQ(318,
1373            message.GetExtension(UNITTEST::repeated_nested_message_extension, 1)
1374                .bb());
1375  EXPECT_EQ(
1376      319, message.GetExtension(UNITTEST::repeated_foreign_message_extension, 1)
1377               .c());
1378  EXPECT_EQ(
1379      320,
1380      message.GetExtension(UNITTEST::repeated_import_message_extension, 1).d());
1381  EXPECT_EQ(
1382      327,
1383      message.GetExtension(UNITTEST::repeated_lazy_message_extension, 1).bb());
1384
1385  EXPECT_EQ(UNITTEST::TestAllTypes::BAZ,
1386            message.GetExtension(UNITTEST::repeated_nested_enum_extension, 1));
1387  EXPECT_EQ(UNITTEST::FOREIGN_BAZ,
1388            message.GetExtension(UNITTEST::repeated_foreign_enum_extension, 1));
1389  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAZ,
1390            message.GetExtension(UNITTEST::repeated_import_enum_extension, 1));
1391
1392  EXPECT_EQ("324",
1393            message.GetExtension(UNITTEST::repeated_string_piece_extension, 1));
1394  EXPECT_EQ("325", message.GetExtension(UNITTEST::repeated_cord_extension, 1));
1395
1396  // -----------------------------------------------------------------
1397
1398  EXPECT_TRUE(message.HasExtension(UNITTEST::default_int32_extension));
1399  EXPECT_TRUE(message.HasExtension(UNITTEST::default_int64_extension));
1400  EXPECT_TRUE(message.HasExtension(UNITTEST::default_uint32_extension));
1401  EXPECT_TRUE(message.HasExtension(UNITTEST::default_uint64_extension));
1402  EXPECT_TRUE(message.HasExtension(UNITTEST::default_sint32_extension));
1403  EXPECT_TRUE(message.HasExtension(UNITTEST::default_sint64_extension));
1404  EXPECT_TRUE(message.HasExtension(UNITTEST::default_fixed32_extension));
1405  EXPECT_TRUE(message.HasExtension(UNITTEST::default_fixed64_extension));
1406  EXPECT_TRUE(message.HasExtension(UNITTEST::default_sfixed32_extension));
1407  EXPECT_TRUE(message.HasExtension(UNITTEST::default_sfixed64_extension));
1408  EXPECT_TRUE(message.HasExtension(UNITTEST::default_float_extension));
1409  EXPECT_TRUE(message.HasExtension(UNITTEST::default_double_extension));
1410  EXPECT_TRUE(message.HasExtension(UNITTEST::default_bool_extension));
1411  EXPECT_TRUE(message.HasExtension(UNITTEST::default_string_extension));
1412  EXPECT_TRUE(message.HasExtension(UNITTEST::default_bytes_extension));
1413
1414  EXPECT_TRUE(message.HasExtension(UNITTEST::default_nested_enum_extension));
1415  EXPECT_TRUE(message.HasExtension(UNITTEST::default_foreign_enum_extension));
1416  EXPECT_TRUE(message.HasExtension(UNITTEST::default_import_enum_extension));
1417
1418  EXPECT_TRUE(message.HasExtension(UNITTEST::default_string_piece_extension));
1419  EXPECT_TRUE(message.HasExtension(UNITTEST::default_cord_extension));
1420
1421  EXPECT_EQ(401, message.GetExtension(UNITTEST::default_int32_extension));
1422  EXPECT_EQ(402, message.GetExtension(UNITTEST::default_int64_extension));
1423  EXPECT_EQ(403, message.GetExtension(UNITTEST::default_uint32_extension));
1424  EXPECT_EQ(404, message.GetExtension(UNITTEST::default_uint64_extension));
1425  EXPECT_EQ(405, message.GetExtension(UNITTEST::default_sint32_extension));
1426  EXPECT_EQ(406, message.GetExtension(UNITTEST::default_sint64_extension));
1427  EXPECT_EQ(407, message.GetExtension(UNITTEST::default_fixed32_extension));
1428  EXPECT_EQ(408, message.GetExtension(UNITTEST::default_fixed64_extension));
1429  EXPECT_EQ(409, message.GetExtension(UNITTEST::default_sfixed32_extension));
1430  EXPECT_EQ(410, message.GetExtension(UNITTEST::default_sfixed64_extension));
1431  EXPECT_EQ(411, message.GetExtension(UNITTEST::default_float_extension));
1432  EXPECT_EQ(412, message.GetExtension(UNITTEST::default_double_extension));
1433  EXPECT_FALSE(message.GetExtension(UNITTEST::default_bool_extension));
1434  EXPECT_EQ("415", message.GetExtension(UNITTEST::default_string_extension));
1435  EXPECT_EQ("416", message.GetExtension(UNITTEST::default_bytes_extension));
1436
1437  EXPECT_EQ(UNITTEST::TestAllTypes::FOO,
1438            message.GetExtension(UNITTEST::default_nested_enum_extension));
1439  EXPECT_EQ(UNITTEST::FOREIGN_FOO,
1440            message.GetExtension(UNITTEST::default_foreign_enum_extension));
1441  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_FOO,
1442            message.GetExtension(UNITTEST::default_import_enum_extension));
1443
1444  EXPECT_EQ("424",
1445            message.GetExtension(UNITTEST::default_string_piece_extension));
1446  EXPECT_EQ("425", message.GetExtension(UNITTEST::default_cord_extension));
1447
1448  EXPECT_TRUE(message.HasExtension(UNITTEST::oneof_uint32_extension));
1449  EXPECT_TRUE(
1450      message.GetExtension(UNITTEST::oneof_nested_message_extension).has_bb());
1451  EXPECT_TRUE(message.HasExtension(UNITTEST::oneof_string_extension));
1452  EXPECT_TRUE(message.HasExtension(UNITTEST::oneof_bytes_extension));
1453
1454  EXPECT_EQ(601, message.GetExtension(UNITTEST::oneof_uint32_extension));
1455  EXPECT_EQ(
1456      602, message.GetExtension(UNITTEST::oneof_nested_message_extension).bb());
1457  EXPECT_EQ("603", message.GetExtension(UNITTEST::oneof_string_extension));
1458  EXPECT_EQ("604", message.GetExtension(UNITTEST::oneof_bytes_extension));
1459}
1460
1461// -------------------------------------------------------------------
1462
1463inline void TestUtil::ExpectExtensionsClear(
1464    const UNITTEST::TestAllExtensions& message) {
1465  std::string serialized;
1466  ASSERT_TRUE(message.SerializeToString(&serialized));
1467  EXPECT_EQ("", serialized);
1468  EXPECT_EQ(0, message.ByteSizeLong());
1469
1470  // has_blah() should initially be false for all optional fields.
1471  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_int32_extension));
1472  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_int64_extension));
1473  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_uint32_extension));
1474  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_uint64_extension));
1475  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_sint32_extension));
1476  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_sint64_extension));
1477  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_fixed32_extension));
1478  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_fixed64_extension));
1479  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_sfixed32_extension));
1480  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_sfixed64_extension));
1481  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_float_extension));
1482  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_double_extension));
1483  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_bool_extension));
1484  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_string_extension));
1485  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_bytes_extension));
1486
1487  EXPECT_FALSE(message.HasExtension(UNITTEST::optionalgroup_extension));
1488  EXPECT_FALSE(
1489      message.HasExtension(UNITTEST::optional_nested_message_extension));
1490  EXPECT_FALSE(
1491      message.HasExtension(UNITTEST::optional_foreign_message_extension));
1492  EXPECT_FALSE(
1493      message.HasExtension(UNITTEST::optional_import_message_extension));
1494  EXPECT_FALSE(
1495      message.HasExtension(UNITTEST::optional_public_import_message_extension));
1496  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_lazy_message_extension));
1497  EXPECT_FALSE(message.HasExtension(
1498      UNITTEST::optional_unverified_lazy_message_extension));
1499
1500  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_nested_enum_extension));
1501  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_foreign_enum_extension));
1502  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_import_enum_extension));
1503
1504  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_string_piece_extension));
1505  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_cord_extension));
1506  EXPECT_FALSE(message.HasExtension(UNITTEST::optional_bytes_cord_extension));
1507
1508  // Optional fields without defaults are set to zero or something like it.
1509  EXPECT_EQ(0, message.GetExtension(UNITTEST::optional_int32_extension));
1510  EXPECT_EQ(0, message.GetExtension(UNITTEST::optional_int64_extension));
1511  EXPECT_EQ(0, message.GetExtension(UNITTEST::optional_uint32_extension));
1512  EXPECT_EQ(0, message.GetExtension(UNITTEST::optional_uint64_extension));
1513  EXPECT_EQ(0, message.GetExtension(UNITTEST::optional_sint32_extension));
1514  EXPECT_EQ(0, message.GetExtension(UNITTEST::optional_sint64_extension));
1515  EXPECT_EQ(0, message.GetExtension(UNITTEST::optional_fixed32_extension));
1516  EXPECT_EQ(0, message.GetExtension(UNITTEST::optional_fixed64_extension));
1517  EXPECT_EQ(0, message.GetExtension(UNITTEST::optional_sfixed32_extension));
1518  EXPECT_EQ(0, message.GetExtension(UNITTEST::optional_sfixed64_extension));
1519  EXPECT_EQ(0, message.GetExtension(UNITTEST::optional_float_extension));
1520  EXPECT_EQ(0, message.GetExtension(UNITTEST::optional_double_extension));
1521  EXPECT_FALSE(message.GetExtension(UNITTEST::optional_bool_extension));
1522  EXPECT_EQ("", message.GetExtension(UNITTEST::optional_string_extension));
1523  EXPECT_EQ("", message.GetExtension(UNITTEST::optional_bytes_extension));
1524
1525  // Embedded messages should also be clear.
1526  EXPECT_FALSE(message.GetExtension(UNITTEST::optionalgroup_extension).has_a());
1527  EXPECT_FALSE(message.GetExtension(UNITTEST::optional_nested_message_extension)
1528                   .has_bb());
1529  EXPECT_FALSE(
1530      message.GetExtension(UNITTEST::optional_foreign_message_extension)
1531          .has_c());
1532  EXPECT_FALSE(message.GetExtension(UNITTEST::optional_import_message_extension)
1533                   .has_d());
1534  EXPECT_FALSE(
1535      message.GetExtension(UNITTEST::optional_public_import_message_extension)
1536          .has_e());
1537  EXPECT_FALSE(
1538      message.GetExtension(UNITTEST::optional_lazy_message_extension).has_bb());
1539  EXPECT_FALSE(
1540      message.GetExtension(UNITTEST::optional_unverified_lazy_message_extension)
1541          .has_bb());
1542
1543  EXPECT_EQ(0, message.GetExtension(UNITTEST::optionalgroup_extension).a());
1544  EXPECT_EQ(
1545      0,
1546      message.GetExtension(UNITTEST::optional_nested_message_extension).bb());
1547  EXPECT_EQ(
1548      0,
1549      message.GetExtension(UNITTEST::optional_foreign_message_extension).c());
1550  EXPECT_EQ(
1551      0, message.GetExtension(UNITTEST::optional_import_message_extension).d());
1552  EXPECT_EQ(
1553      0,
1554      message.GetExtension(UNITTEST::optional_public_import_message_extension)
1555          .e());
1556  EXPECT_EQ(
1557      0, message.GetExtension(UNITTEST::optional_lazy_message_extension).bb());
1558  EXPECT_EQ(
1559      0,
1560      message.GetExtension(UNITTEST::optional_unverified_lazy_message_extension)
1561          .bb());
1562
1563  // Enums without defaults are set to the first value in the enum.
1564  EXPECT_EQ(UNITTEST::TestAllTypes::FOO,
1565            message.GetExtension(UNITTEST::optional_nested_enum_extension));
1566  EXPECT_EQ(UNITTEST::FOREIGN_FOO,
1567            message.GetExtension(UNITTEST::optional_foreign_enum_extension));
1568  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_FOO,
1569            message.GetExtension(UNITTEST::optional_import_enum_extension));
1570
1571  EXPECT_EQ("",
1572            message.GetExtension(UNITTEST::optional_string_piece_extension));
1573  EXPECT_EQ("", message.GetExtension(UNITTEST::optional_cord_extension));
1574  EXPECT_EQ("", message.GetExtension(UNITTEST::optional_bytes_cord_extension));
1575
1576  // Repeated fields are empty.
1577  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_int32_extension));
1578  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_int64_extension));
1579  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_uint32_extension));
1580  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_uint64_extension));
1581  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_sint32_extension));
1582  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_sint64_extension));
1583  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_fixed32_extension));
1584  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_fixed64_extension));
1585  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_sfixed32_extension));
1586  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_sfixed64_extension));
1587  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_float_extension));
1588  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_double_extension));
1589  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_bool_extension));
1590  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_string_extension));
1591  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_bytes_extension));
1592
1593  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeatedgroup_extension));
1594  EXPECT_EQ(0,
1595            message.ExtensionSize(UNITTEST::repeated_nested_message_extension));
1596  EXPECT_EQ(
1597      0, message.ExtensionSize(UNITTEST::repeated_foreign_message_extension));
1598  EXPECT_EQ(0,
1599            message.ExtensionSize(UNITTEST::repeated_import_message_extension));
1600  EXPECT_EQ(0,
1601            message.ExtensionSize(UNITTEST::repeated_lazy_message_extension));
1602  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_nested_enum_extension));
1603  EXPECT_EQ(0,
1604            message.ExtensionSize(UNITTEST::repeated_foreign_enum_extension));
1605  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_import_enum_extension));
1606
1607  EXPECT_EQ(0,
1608            message.ExtensionSize(UNITTEST::repeated_string_piece_extension));
1609  EXPECT_EQ(0, message.ExtensionSize(UNITTEST::repeated_cord_extension));
1610
1611  // has_blah() should also be false for all default fields.
1612  EXPECT_FALSE(message.HasExtension(UNITTEST::default_int32_extension));
1613  EXPECT_FALSE(message.HasExtension(UNITTEST::default_int64_extension));
1614  EXPECT_FALSE(message.HasExtension(UNITTEST::default_uint32_extension));
1615  EXPECT_FALSE(message.HasExtension(UNITTEST::default_uint64_extension));
1616  EXPECT_FALSE(message.HasExtension(UNITTEST::default_sint32_extension));
1617  EXPECT_FALSE(message.HasExtension(UNITTEST::default_sint64_extension));
1618  EXPECT_FALSE(message.HasExtension(UNITTEST::default_fixed32_extension));
1619  EXPECT_FALSE(message.HasExtension(UNITTEST::default_fixed64_extension));
1620  EXPECT_FALSE(message.HasExtension(UNITTEST::default_sfixed32_extension));
1621  EXPECT_FALSE(message.HasExtension(UNITTEST::default_sfixed64_extension));
1622  EXPECT_FALSE(message.HasExtension(UNITTEST::default_float_extension));
1623  EXPECT_FALSE(message.HasExtension(UNITTEST::default_double_extension));
1624  EXPECT_FALSE(message.HasExtension(UNITTEST::default_bool_extension));
1625  EXPECT_FALSE(message.HasExtension(UNITTEST::default_string_extension));
1626  EXPECT_FALSE(message.HasExtension(UNITTEST::default_bytes_extension));
1627
1628  EXPECT_FALSE(message.HasExtension(UNITTEST::default_nested_enum_extension));
1629  EXPECT_FALSE(message.HasExtension(UNITTEST::default_foreign_enum_extension));
1630  EXPECT_FALSE(message.HasExtension(UNITTEST::default_import_enum_extension));
1631
1632  EXPECT_FALSE(message.HasExtension(UNITTEST::default_string_piece_extension));
1633  EXPECT_FALSE(message.HasExtension(UNITTEST::default_cord_extension));
1634
1635  // Fields with defaults have their default values (duh).
1636  EXPECT_EQ(41, message.GetExtension(UNITTEST::default_int32_extension));
1637  EXPECT_EQ(42, message.GetExtension(UNITTEST::default_int64_extension));
1638  EXPECT_EQ(43, message.GetExtension(UNITTEST::default_uint32_extension));
1639  EXPECT_EQ(44, message.GetExtension(UNITTEST::default_uint64_extension));
1640  EXPECT_EQ(-45, message.GetExtension(UNITTEST::default_sint32_extension));
1641  EXPECT_EQ(46, message.GetExtension(UNITTEST::default_sint64_extension));
1642  EXPECT_EQ(47, message.GetExtension(UNITTEST::default_fixed32_extension));
1643  EXPECT_EQ(48, message.GetExtension(UNITTEST::default_fixed64_extension));
1644  EXPECT_EQ(49, message.GetExtension(UNITTEST::default_sfixed32_extension));
1645  EXPECT_EQ(-50, message.GetExtension(UNITTEST::default_sfixed64_extension));
1646  EXPECT_EQ(51.5, message.GetExtension(UNITTEST::default_float_extension));
1647  EXPECT_EQ(52e3, message.GetExtension(UNITTEST::default_double_extension));
1648  EXPECT_TRUE(message.GetExtension(UNITTEST::default_bool_extension));
1649  EXPECT_EQ("hello", message.GetExtension(UNITTEST::default_string_extension));
1650  EXPECT_EQ("world", message.GetExtension(UNITTEST::default_bytes_extension));
1651
1652  EXPECT_EQ(UNITTEST::TestAllTypes::BAR,
1653            message.GetExtension(UNITTEST::default_nested_enum_extension));
1654  EXPECT_EQ(UNITTEST::FOREIGN_BAR,
1655            message.GetExtension(UNITTEST::default_foreign_enum_extension));
1656  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAR,
1657            message.GetExtension(UNITTEST::default_import_enum_extension));
1658
1659  EXPECT_EQ("abc",
1660            message.GetExtension(UNITTEST::default_string_piece_extension));
1661  EXPECT_EQ("123", message.GetExtension(UNITTEST::default_cord_extension));
1662
1663  EXPECT_FALSE(message.HasExtension(UNITTEST::oneof_uint32_extension));
1664  EXPECT_FALSE(
1665      message.GetExtension(UNITTEST::oneof_nested_message_extension).has_bb());
1666  EXPECT_FALSE(message.HasExtension(UNITTEST::oneof_string_extension));
1667  EXPECT_FALSE(message.HasExtension(UNITTEST::oneof_bytes_extension));
1668}
1669
1670// -------------------------------------------------------------------
1671
1672inline void TestUtil::ExpectRepeatedExtensionsModified(
1673    const UNITTEST::TestAllExtensions& message) {
1674  // ModifyRepeatedFields only sets the second repeated element of each
1675  // field.  In addition to verifying this, we also verify that the first
1676  // element and size were *not* modified.
1677  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_int32_extension));
1678  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_int64_extension));
1679  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_uint32_extension));
1680  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_uint64_extension));
1681  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_sint32_extension));
1682  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_sint64_extension));
1683  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_fixed32_extension));
1684  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_fixed64_extension));
1685  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_sfixed32_extension));
1686  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_sfixed64_extension));
1687  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_float_extension));
1688  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_double_extension));
1689  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_bool_extension));
1690  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_string_extension));
1691  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_bytes_extension));
1692
1693  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeatedgroup_extension));
1694  ASSERT_EQ(2,
1695            message.ExtensionSize(UNITTEST::repeated_nested_message_extension));
1696  ASSERT_EQ(
1697      2, message.ExtensionSize(UNITTEST::repeated_foreign_message_extension));
1698  ASSERT_EQ(2,
1699            message.ExtensionSize(UNITTEST::repeated_import_message_extension));
1700  ASSERT_EQ(2,
1701            message.ExtensionSize(UNITTEST::repeated_lazy_message_extension));
1702  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_nested_enum_extension));
1703  ASSERT_EQ(2,
1704            message.ExtensionSize(UNITTEST::repeated_foreign_enum_extension));
1705  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_import_enum_extension));
1706
1707  ASSERT_EQ(2,
1708            message.ExtensionSize(UNITTEST::repeated_string_piece_extension));
1709  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_cord_extension));
1710
1711  EXPECT_EQ(201, message.GetExtension(UNITTEST::repeated_int32_extension, 0));
1712  EXPECT_EQ(202, message.GetExtension(UNITTEST::repeated_int64_extension, 0));
1713  EXPECT_EQ(203, message.GetExtension(UNITTEST::repeated_uint32_extension, 0));
1714  EXPECT_EQ(204, message.GetExtension(UNITTEST::repeated_uint64_extension, 0));
1715  EXPECT_EQ(205, message.GetExtension(UNITTEST::repeated_sint32_extension, 0));
1716  EXPECT_EQ(206, message.GetExtension(UNITTEST::repeated_sint64_extension, 0));
1717  EXPECT_EQ(207, message.GetExtension(UNITTEST::repeated_fixed32_extension, 0));
1718  EXPECT_EQ(208, message.GetExtension(UNITTEST::repeated_fixed64_extension, 0));
1719  EXPECT_EQ(209,
1720            message.GetExtension(UNITTEST::repeated_sfixed32_extension, 0));
1721  EXPECT_EQ(210,
1722            message.GetExtension(UNITTEST::repeated_sfixed64_extension, 0));
1723  EXPECT_EQ(211, message.GetExtension(UNITTEST::repeated_float_extension, 0));
1724  EXPECT_EQ(212, message.GetExtension(UNITTEST::repeated_double_extension, 0));
1725  EXPECT_TRUE(message.GetExtension(UNITTEST::repeated_bool_extension, 0));
1726  EXPECT_EQ("215",
1727            message.GetExtension(UNITTEST::repeated_string_extension, 0));
1728  EXPECT_EQ("216", message.GetExtension(UNITTEST::repeated_bytes_extension, 0));
1729
1730  EXPECT_EQ(217,
1731            message.GetExtension(UNITTEST::repeatedgroup_extension, 0).a());
1732  EXPECT_EQ(218,
1733            message.GetExtension(UNITTEST::repeated_nested_message_extension, 0)
1734                .bb());
1735  EXPECT_EQ(
1736      219, message.GetExtension(UNITTEST::repeated_foreign_message_extension, 0)
1737               .c());
1738  EXPECT_EQ(
1739      220,
1740      message.GetExtension(UNITTEST::repeated_import_message_extension, 0).d());
1741  EXPECT_EQ(
1742      227,
1743      message.GetExtension(UNITTEST::repeated_lazy_message_extension, 0).bb());
1744
1745  EXPECT_EQ(UNITTEST::TestAllTypes::BAR,
1746            message.GetExtension(UNITTEST::repeated_nested_enum_extension, 0));
1747  EXPECT_EQ(UNITTEST::FOREIGN_BAR,
1748            message.GetExtension(UNITTEST::repeated_foreign_enum_extension, 0));
1749  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAR,
1750            message.GetExtension(UNITTEST::repeated_import_enum_extension, 0));
1751
1752  EXPECT_EQ("224",
1753            message.GetExtension(UNITTEST::repeated_string_piece_extension, 0));
1754  EXPECT_EQ("225", message.GetExtension(UNITTEST::repeated_cord_extension, 0));
1755
1756  // Actually verify the second (modified) elements now.
1757  EXPECT_EQ(501, message.GetExtension(UNITTEST::repeated_int32_extension, 1));
1758  EXPECT_EQ(502, message.GetExtension(UNITTEST::repeated_int64_extension, 1));
1759  EXPECT_EQ(503, message.GetExtension(UNITTEST::repeated_uint32_extension, 1));
1760  EXPECT_EQ(504, message.GetExtension(UNITTEST::repeated_uint64_extension, 1));
1761  EXPECT_EQ(505, message.GetExtension(UNITTEST::repeated_sint32_extension, 1));
1762  EXPECT_EQ(506, message.GetExtension(UNITTEST::repeated_sint64_extension, 1));
1763  EXPECT_EQ(507, message.GetExtension(UNITTEST::repeated_fixed32_extension, 1));
1764  EXPECT_EQ(508, message.GetExtension(UNITTEST::repeated_fixed64_extension, 1));
1765  EXPECT_EQ(509,
1766            message.GetExtension(UNITTEST::repeated_sfixed32_extension, 1));
1767  EXPECT_EQ(510,
1768            message.GetExtension(UNITTEST::repeated_sfixed64_extension, 1));
1769  EXPECT_EQ(511, message.GetExtension(UNITTEST::repeated_float_extension, 1));
1770  EXPECT_EQ(512, message.GetExtension(UNITTEST::repeated_double_extension, 1));
1771  EXPECT_TRUE(message.GetExtension(UNITTEST::repeated_bool_extension, 1));
1772  EXPECT_EQ("515",
1773            message.GetExtension(UNITTEST::repeated_string_extension, 1));
1774  EXPECT_EQ("516", message.GetExtension(UNITTEST::repeated_bytes_extension, 1));
1775
1776  EXPECT_EQ(517,
1777            message.GetExtension(UNITTEST::repeatedgroup_extension, 1).a());
1778  EXPECT_EQ(518,
1779            message.GetExtension(UNITTEST::repeated_nested_message_extension, 1)
1780                .bb());
1781  EXPECT_EQ(
1782      519, message.GetExtension(UNITTEST::repeated_foreign_message_extension, 1)
1783               .c());
1784  EXPECT_EQ(
1785      520,
1786      message.GetExtension(UNITTEST::repeated_import_message_extension, 1).d());
1787  EXPECT_EQ(
1788      527,
1789      message.GetExtension(UNITTEST::repeated_lazy_message_extension, 1).bb());
1790
1791  EXPECT_EQ(UNITTEST::TestAllTypes::FOO,
1792            message.GetExtension(UNITTEST::repeated_nested_enum_extension, 1));
1793  EXPECT_EQ(UNITTEST::FOREIGN_FOO,
1794            message.GetExtension(UNITTEST::repeated_foreign_enum_extension, 1));
1795  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_FOO,
1796            message.GetExtension(UNITTEST::repeated_import_enum_extension, 1));
1797
1798  EXPECT_EQ("524",
1799            message.GetExtension(UNITTEST::repeated_string_piece_extension, 1));
1800  EXPECT_EQ("525", message.GetExtension(UNITTEST::repeated_cord_extension, 1));
1801}
1802
1803// -------------------------------------------------------------------
1804
1805inline void TestUtil::SetPackedExtensions(
1806    UNITTEST::TestPackedExtensions* message) {
1807  message->AddExtension(UNITTEST::packed_int32_extension, 601);
1808  message->AddExtension(UNITTEST::packed_int64_extension, 602);
1809  message->AddExtension(UNITTEST::packed_uint32_extension, 603);
1810  message->AddExtension(UNITTEST::packed_uint64_extension, 604);
1811  message->AddExtension(UNITTEST::packed_sint32_extension, 605);
1812  message->AddExtension(UNITTEST::packed_sint64_extension, 606);
1813  message->AddExtension(UNITTEST::packed_fixed32_extension, 607);
1814  message->AddExtension(UNITTEST::packed_fixed64_extension, 608);
1815  message->AddExtension(UNITTEST::packed_sfixed32_extension, 609);
1816  message->AddExtension(UNITTEST::packed_sfixed64_extension, 610);
1817  message->AddExtension(UNITTEST::packed_float_extension, 611);
1818  message->AddExtension(UNITTEST::packed_double_extension, 612);
1819  message->AddExtension(UNITTEST::packed_bool_extension, true);
1820  message->AddExtension(UNITTEST::packed_enum_extension, UNITTEST::FOREIGN_BAR);
1821  // add a second one of each field
1822  message->AddExtension(UNITTEST::packed_int32_extension, 701);
1823  message->AddExtension(UNITTEST::packed_int64_extension, 702);
1824  message->AddExtension(UNITTEST::packed_uint32_extension, 703);
1825  message->AddExtension(UNITTEST::packed_uint64_extension, 704);
1826  message->AddExtension(UNITTEST::packed_sint32_extension, 705);
1827  message->AddExtension(UNITTEST::packed_sint64_extension, 706);
1828  message->AddExtension(UNITTEST::packed_fixed32_extension, 707);
1829  message->AddExtension(UNITTEST::packed_fixed64_extension, 708);
1830  message->AddExtension(UNITTEST::packed_sfixed32_extension, 709);
1831  message->AddExtension(UNITTEST::packed_sfixed64_extension, 710);
1832  message->AddExtension(UNITTEST::packed_float_extension, 711);
1833  message->AddExtension(UNITTEST::packed_double_extension, 712);
1834  message->AddExtension(UNITTEST::packed_bool_extension, false);
1835  message->AddExtension(UNITTEST::packed_enum_extension, UNITTEST::FOREIGN_BAZ);
1836}
1837
1838// -------------------------------------------------------------------
1839
1840inline void TestUtil::ExpectPackedExtensionsSet(
1841    const UNITTEST::TestPackedExtensions& message) {
1842  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_int32_extension));
1843  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_int64_extension));
1844  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_uint32_extension));
1845  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_uint64_extension));
1846  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_sint32_extension));
1847  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_sint64_extension));
1848  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_fixed32_extension));
1849  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_fixed64_extension));
1850  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_sfixed32_extension));
1851  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_sfixed64_extension));
1852  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_float_extension));
1853  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_double_extension));
1854  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_bool_extension));
1855  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::packed_enum_extension));
1856
1857  EXPECT_EQ(601, message.GetExtension(UNITTEST::packed_int32_extension, 0));
1858  EXPECT_EQ(602, message.GetExtension(UNITTEST::packed_int64_extension, 0));
1859  EXPECT_EQ(603, message.GetExtension(UNITTEST::packed_uint32_extension, 0));
1860  EXPECT_EQ(604, message.GetExtension(UNITTEST::packed_uint64_extension, 0));
1861  EXPECT_EQ(605, message.GetExtension(UNITTEST::packed_sint32_extension, 0));
1862  EXPECT_EQ(606, message.GetExtension(UNITTEST::packed_sint64_extension, 0));
1863  EXPECT_EQ(607, message.GetExtension(UNITTEST::packed_fixed32_extension, 0));
1864  EXPECT_EQ(608, message.GetExtension(UNITTEST::packed_fixed64_extension, 0));
1865  EXPECT_EQ(609, message.GetExtension(UNITTEST::packed_sfixed32_extension, 0));
1866  EXPECT_EQ(610, message.GetExtension(UNITTEST::packed_sfixed64_extension, 0));
1867  EXPECT_EQ(611, message.GetExtension(UNITTEST::packed_float_extension, 0));
1868  EXPECT_EQ(612, message.GetExtension(UNITTEST::packed_double_extension, 0));
1869  EXPECT_TRUE(message.GetExtension(UNITTEST::packed_bool_extension, 0));
1870  EXPECT_EQ(UNITTEST::FOREIGN_BAR,
1871            message.GetExtension(UNITTEST::packed_enum_extension, 0));
1872  EXPECT_EQ(701, message.GetExtension(UNITTEST::packed_int32_extension, 1));
1873  EXPECT_EQ(702, message.GetExtension(UNITTEST::packed_int64_extension, 1));
1874  EXPECT_EQ(703, message.GetExtension(UNITTEST::packed_uint32_extension, 1));
1875  EXPECT_EQ(704, message.GetExtension(UNITTEST::packed_uint64_extension, 1));
1876  EXPECT_EQ(705, message.GetExtension(UNITTEST::packed_sint32_extension, 1));
1877  EXPECT_EQ(706, message.GetExtension(UNITTEST::packed_sint64_extension, 1));
1878  EXPECT_EQ(707, message.GetExtension(UNITTEST::packed_fixed32_extension, 1));
1879  EXPECT_EQ(708, message.GetExtension(UNITTEST::packed_fixed64_extension, 1));
1880  EXPECT_EQ(709, message.GetExtension(UNITTEST::packed_sfixed32_extension, 1));
1881  EXPECT_EQ(710, message.GetExtension(UNITTEST::packed_sfixed64_extension, 1));
1882  EXPECT_EQ(711, message.GetExtension(UNITTEST::packed_float_extension, 1));
1883  EXPECT_EQ(712, message.GetExtension(UNITTEST::packed_double_extension, 1));
1884  EXPECT_FALSE(message.GetExtension(UNITTEST::packed_bool_extension, 1));
1885  EXPECT_EQ(UNITTEST::FOREIGN_BAZ,
1886            message.GetExtension(UNITTEST::packed_enum_extension, 1));
1887}
1888
1889// -------------------------------------------------------------------
1890
1891inline void TestUtil::ExpectUnpackedExtensionsSet(
1892    const UNITTEST::TestUnpackedExtensions& message) {
1893  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_int32_extension));
1894  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_int64_extension));
1895  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_uint32_extension));
1896  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_uint64_extension));
1897  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_sint32_extension));
1898  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_sint64_extension));
1899  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_fixed32_extension));
1900  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_fixed64_extension));
1901  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_sfixed32_extension));
1902  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_sfixed64_extension));
1903  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_float_extension));
1904  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_double_extension));
1905  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_bool_extension));
1906  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::unpacked_enum_extension));
1907
1908  EXPECT_EQ(601, message.GetExtension(UNITTEST::unpacked_int32_extension, 0));
1909  EXPECT_EQ(602, message.GetExtension(UNITTEST::unpacked_int64_extension, 0));
1910  EXPECT_EQ(603, message.GetExtension(UNITTEST::unpacked_uint32_extension, 0));
1911  EXPECT_EQ(604, message.GetExtension(UNITTEST::unpacked_uint64_extension, 0));
1912  EXPECT_EQ(605, message.GetExtension(UNITTEST::unpacked_sint32_extension, 0));
1913  EXPECT_EQ(606, message.GetExtension(UNITTEST::unpacked_sint64_extension, 0));
1914  EXPECT_EQ(607, message.GetExtension(UNITTEST::unpacked_fixed32_extension, 0));
1915  EXPECT_EQ(608, message.GetExtension(UNITTEST::unpacked_fixed64_extension, 0));
1916  EXPECT_EQ(609,
1917            message.GetExtension(UNITTEST::unpacked_sfixed32_extension, 0));
1918  EXPECT_EQ(610,
1919            message.GetExtension(UNITTEST::unpacked_sfixed64_extension, 0));
1920  EXPECT_EQ(611, message.GetExtension(UNITTEST::unpacked_float_extension, 0));
1921  EXPECT_EQ(612, message.GetExtension(UNITTEST::unpacked_double_extension, 0));
1922  EXPECT_EQ(true, message.GetExtension(UNITTEST::unpacked_bool_extension, 0));
1923  EXPECT_EQ(UNITTEST::FOREIGN_BAR,
1924            message.GetExtension(UNITTEST::unpacked_enum_extension, 0));
1925  EXPECT_EQ(701, message.GetExtension(UNITTEST::unpacked_int32_extension, 1));
1926  EXPECT_EQ(702, message.GetExtension(UNITTEST::unpacked_int64_extension, 1));
1927  EXPECT_EQ(703, message.GetExtension(UNITTEST::unpacked_uint32_extension, 1));
1928  EXPECT_EQ(704, message.GetExtension(UNITTEST::unpacked_uint64_extension, 1));
1929  EXPECT_EQ(705, message.GetExtension(UNITTEST::unpacked_sint32_extension, 1));
1930  EXPECT_EQ(706, message.GetExtension(UNITTEST::unpacked_sint64_extension, 1));
1931  EXPECT_EQ(707, message.GetExtension(UNITTEST::unpacked_fixed32_extension, 1));
1932  EXPECT_EQ(708, message.GetExtension(UNITTEST::unpacked_fixed64_extension, 1));
1933  EXPECT_EQ(709,
1934            message.GetExtension(UNITTEST::unpacked_sfixed32_extension, 1));
1935  EXPECT_EQ(710,
1936            message.GetExtension(UNITTEST::unpacked_sfixed64_extension, 1));
1937  EXPECT_EQ(711, message.GetExtension(UNITTEST::unpacked_float_extension, 1));
1938  EXPECT_EQ(712, message.GetExtension(UNITTEST::unpacked_double_extension, 1));
1939  EXPECT_FALSE(message.GetExtension(UNITTEST::unpacked_bool_extension, 1));
1940  EXPECT_EQ(UNITTEST::FOREIGN_BAZ,
1941            message.GetExtension(UNITTEST::unpacked_enum_extension, 1));
1942}
1943
1944// -------------------------------------------------------------------
1945
1946inline void TestUtil::ExpectLastRepeatedsRemoved(
1947    const UNITTEST::TestAllTypes& message) {
1948  ASSERT_EQ(1, message.repeated_int32_size());
1949  ASSERT_EQ(1, message.repeated_int64_size());
1950  ASSERT_EQ(1, message.repeated_uint32_size());
1951  ASSERT_EQ(1, message.repeated_uint64_size());
1952  ASSERT_EQ(1, message.repeated_sint32_size());
1953  ASSERT_EQ(1, message.repeated_sint64_size());
1954  ASSERT_EQ(1, message.repeated_fixed32_size());
1955  ASSERT_EQ(1, message.repeated_fixed64_size());
1956  ASSERT_EQ(1, message.repeated_sfixed32_size());
1957  ASSERT_EQ(1, message.repeated_sfixed64_size());
1958  ASSERT_EQ(1, message.repeated_float_size());
1959  ASSERT_EQ(1, message.repeated_double_size());
1960  ASSERT_EQ(1, message.repeated_bool_size());
1961  ASSERT_EQ(1, message.repeated_string_size());
1962  ASSERT_EQ(1, message.repeated_bytes_size());
1963
1964  ASSERT_EQ(1, message.repeatedgroup_size());
1965  ASSERT_EQ(1, message.repeated_nested_message_size());
1966  ASSERT_EQ(1, message.repeated_foreign_message_size());
1967  ASSERT_EQ(1, message.repeated_import_message_size());
1968  ASSERT_EQ(1, message.repeated_import_message_size());
1969  ASSERT_EQ(1, message.repeated_nested_enum_size());
1970  ASSERT_EQ(1, message.repeated_foreign_enum_size());
1971  ASSERT_EQ(1, message.repeated_import_enum_size());
1972
1973#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
1974  ASSERT_EQ(1, message.repeated_string_piece_size());
1975  ASSERT_EQ(1, message.repeated_cord_size());
1976#endif
1977
1978  // Test that the remaining element is the correct one.
1979  EXPECT_EQ(201, message.repeated_int32(0));
1980  EXPECT_EQ(202, message.repeated_int64(0));
1981  EXPECT_EQ(203, message.repeated_uint32(0));
1982  EXPECT_EQ(204, message.repeated_uint64(0));
1983  EXPECT_EQ(205, message.repeated_sint32(0));
1984  EXPECT_EQ(206, message.repeated_sint64(0));
1985  EXPECT_EQ(207, message.repeated_fixed32(0));
1986  EXPECT_EQ(208, message.repeated_fixed64(0));
1987  EXPECT_EQ(209, message.repeated_sfixed32(0));
1988  EXPECT_EQ(210, message.repeated_sfixed64(0));
1989  EXPECT_EQ(211, message.repeated_float(0));
1990  EXPECT_EQ(212, message.repeated_double(0));
1991  EXPECT_TRUE(message.repeated_bool(0));
1992  EXPECT_EQ("215", message.repeated_string(0));
1993  EXPECT_EQ("216", message.repeated_bytes(0));
1994
1995  EXPECT_EQ(217, message.repeatedgroup(0).a());
1996  EXPECT_EQ(218, message.repeated_nested_message(0).bb());
1997  EXPECT_EQ(219, message.repeated_foreign_message(0).c());
1998  EXPECT_EQ(220, message.repeated_import_message(0).d());
1999  EXPECT_EQ(220, message.repeated_import_message(0).d());
2000
2001  EXPECT_EQ(UNITTEST::TestAllTypes::BAR, message.repeated_nested_enum(0));
2002  EXPECT_EQ(UNITTEST::FOREIGN_BAR, message.repeated_foreign_enum(0));
2003  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAR, message.repeated_import_enum(0));
2004}
2005
2006inline void TestUtil::ExpectLastRepeatedExtensionsRemoved(
2007    const UNITTEST::TestAllExtensions& message) {
2008  // Test that one element was removed.
2009  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_int32_extension));
2010  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_int64_extension));
2011  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_uint32_extension));
2012  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_uint64_extension));
2013  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_sint32_extension));
2014  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_sint64_extension));
2015  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_fixed32_extension));
2016  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_fixed64_extension));
2017  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_sfixed32_extension));
2018  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_sfixed64_extension));
2019  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_float_extension));
2020  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_double_extension));
2021  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_bool_extension));
2022  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_string_extension));
2023  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_bytes_extension));
2024
2025  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeatedgroup_extension));
2026  ASSERT_EQ(1,
2027            message.ExtensionSize(UNITTEST::repeated_nested_message_extension));
2028  ASSERT_EQ(
2029      1, message.ExtensionSize(UNITTEST::repeated_foreign_message_extension));
2030  ASSERT_EQ(1,
2031            message.ExtensionSize(UNITTEST::repeated_import_message_extension));
2032  ASSERT_EQ(1,
2033            message.ExtensionSize(UNITTEST::repeated_lazy_message_extension));
2034  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_nested_enum_extension));
2035  ASSERT_EQ(1,
2036            message.ExtensionSize(UNITTEST::repeated_foreign_enum_extension));
2037  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_import_enum_extension));
2038
2039  ASSERT_EQ(1,
2040            message.ExtensionSize(UNITTEST::repeated_string_piece_extension));
2041  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeated_cord_extension));
2042
2043  // Test that the remaining element is the correct one.
2044  EXPECT_EQ(201, message.GetExtension(UNITTEST::repeated_int32_extension, 0));
2045  EXPECT_EQ(202, message.GetExtension(UNITTEST::repeated_int64_extension, 0));
2046  EXPECT_EQ(203, message.GetExtension(UNITTEST::repeated_uint32_extension, 0));
2047  EXPECT_EQ(204, message.GetExtension(UNITTEST::repeated_uint64_extension, 0));
2048  EXPECT_EQ(205, message.GetExtension(UNITTEST::repeated_sint32_extension, 0));
2049  EXPECT_EQ(206, message.GetExtension(UNITTEST::repeated_sint64_extension, 0));
2050  EXPECT_EQ(207, message.GetExtension(UNITTEST::repeated_fixed32_extension, 0));
2051  EXPECT_EQ(208, message.GetExtension(UNITTEST::repeated_fixed64_extension, 0));
2052  EXPECT_EQ(209,
2053            message.GetExtension(UNITTEST::repeated_sfixed32_extension, 0));
2054  EXPECT_EQ(210,
2055            message.GetExtension(UNITTEST::repeated_sfixed64_extension, 0));
2056  EXPECT_EQ(211, message.GetExtension(UNITTEST::repeated_float_extension, 0));
2057  EXPECT_EQ(212, message.GetExtension(UNITTEST::repeated_double_extension, 0));
2058  EXPECT_TRUE(message.GetExtension(UNITTEST::repeated_bool_extension, 0));
2059  EXPECT_EQ("215",
2060            message.GetExtension(UNITTEST::repeated_string_extension, 0));
2061  EXPECT_EQ("216", message.GetExtension(UNITTEST::repeated_bytes_extension, 0));
2062
2063  EXPECT_EQ(217,
2064            message.GetExtension(UNITTEST::repeatedgroup_extension, 0).a());
2065  EXPECT_EQ(218,
2066            message.GetExtension(UNITTEST::repeated_nested_message_extension, 0)
2067                .bb());
2068  EXPECT_EQ(
2069      219, message.GetExtension(UNITTEST::repeated_foreign_message_extension, 0)
2070               .c());
2071  EXPECT_EQ(
2072      220,
2073      message.GetExtension(UNITTEST::repeated_import_message_extension, 0).d());
2074  EXPECT_EQ(
2075      227,
2076      message.GetExtension(UNITTEST::repeated_lazy_message_extension, 0).bb());
2077
2078  EXPECT_EQ(UNITTEST::TestAllTypes::BAR,
2079            message.GetExtension(UNITTEST::repeated_nested_enum_extension, 0));
2080  EXPECT_EQ(UNITTEST::FOREIGN_BAR,
2081            message.GetExtension(UNITTEST::repeated_foreign_enum_extension, 0));
2082  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAR,
2083            message.GetExtension(UNITTEST::repeated_import_enum_extension, 0));
2084
2085  EXPECT_EQ("224",
2086            message.GetExtension(UNITTEST::repeated_string_piece_extension, 0));
2087  EXPECT_EQ("225", message.GetExtension(UNITTEST::repeated_cord_extension, 0));
2088}
2089
2090inline void TestUtil::ExpectLastRepeatedExtensionsRemoved(
2091    const UNITTEST::TestPackedExtensions& message) {
2092  // Test that one element was removed.
2093  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_int32_extension));
2094  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_int64_extension));
2095  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_uint32_extension));
2096  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_uint64_extension));
2097  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_sint32_extension));
2098  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_sint64_extension));
2099  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_fixed32_extension));
2100  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_fixed64_extension));
2101  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_sfixed32_extension));
2102  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_sfixed64_extension));
2103  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_float_extension));
2104  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_double_extension));
2105  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_bool_extension));
2106  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::packed_enum_extension));
2107
2108  // Test that the remaining element is the correct one.
2109  EXPECT_EQ(601, message.GetExtension(UNITTEST::packed_int32_extension, 0));
2110  EXPECT_EQ(602, message.GetExtension(UNITTEST::packed_int64_extension, 0));
2111  EXPECT_EQ(603, message.GetExtension(UNITTEST::packed_uint32_extension, 0));
2112  EXPECT_EQ(604, message.GetExtension(UNITTEST::packed_uint64_extension, 0));
2113  EXPECT_EQ(605, message.GetExtension(UNITTEST::packed_sint32_extension, 0));
2114  EXPECT_EQ(606, message.GetExtension(UNITTEST::packed_sint64_extension, 0));
2115  EXPECT_EQ(607, message.GetExtension(UNITTEST::packed_fixed32_extension, 0));
2116  EXPECT_EQ(608, message.GetExtension(UNITTEST::packed_fixed64_extension, 0));
2117  EXPECT_EQ(609, message.GetExtension(UNITTEST::packed_sfixed32_extension, 0));
2118  EXPECT_EQ(610, message.GetExtension(UNITTEST::packed_sfixed64_extension, 0));
2119  EXPECT_EQ(611, message.GetExtension(UNITTEST::packed_float_extension, 0));
2120  EXPECT_EQ(612, message.GetExtension(UNITTEST::packed_double_extension, 0));
2121  EXPECT_TRUE(message.GetExtension(UNITTEST::packed_bool_extension, 0));
2122  EXPECT_EQ(UNITTEST::FOREIGN_BAR,
2123            message.GetExtension(UNITTEST::packed_enum_extension, 0));
2124}
2125
2126inline void TestUtil::ExpectLastRepeatedsReleased(
2127    const UNITTEST::TestAllTypes& message) {
2128  ASSERT_EQ(1, message.repeatedgroup_size());
2129  ASSERT_EQ(1, message.repeated_nested_message_size());
2130  ASSERT_EQ(1, message.repeated_foreign_message_size());
2131  ASSERT_EQ(1, message.repeated_import_message_size());
2132  ASSERT_EQ(1, message.repeated_import_message_size());
2133
2134  EXPECT_EQ(217, message.repeatedgroup(0).a());
2135  EXPECT_EQ(218, message.repeated_nested_message(0).bb());
2136  EXPECT_EQ(219, message.repeated_foreign_message(0).c());
2137  EXPECT_EQ(220, message.repeated_import_message(0).d());
2138  EXPECT_EQ(220, message.repeated_import_message(0).d());
2139}
2140
2141inline void TestUtil::ExpectLastRepeatedExtensionsReleased(
2142    const UNITTEST::TestAllExtensions& message) {
2143  ASSERT_EQ(1, message.ExtensionSize(UNITTEST::repeatedgroup_extension));
2144  ASSERT_EQ(1,
2145            message.ExtensionSize(UNITTEST::repeated_nested_message_extension));
2146  ASSERT_EQ(
2147      1, message.ExtensionSize(UNITTEST::repeated_foreign_message_extension));
2148  ASSERT_EQ(1,
2149            message.ExtensionSize(UNITTEST::repeated_import_message_extension));
2150  ASSERT_EQ(1,
2151            message.ExtensionSize(UNITTEST::repeated_lazy_message_extension));
2152
2153  EXPECT_EQ(217,
2154            message.GetExtension(UNITTEST::repeatedgroup_extension, 0).a());
2155  EXPECT_EQ(218,
2156            message.GetExtension(UNITTEST::repeated_nested_message_extension, 0)
2157                .bb());
2158  EXPECT_EQ(
2159      219, message.GetExtension(UNITTEST::repeated_foreign_message_extension, 0)
2160               .c());
2161  EXPECT_EQ(
2162      220,
2163      message.GetExtension(UNITTEST::repeated_import_message_extension, 0).d());
2164  EXPECT_EQ(
2165      227,
2166      message.GetExtension(UNITTEST::repeated_lazy_message_extension, 0).bb());
2167}
2168
2169inline void TestUtil::ExpectRepeatedsSwapped(
2170    const UNITTEST::TestAllTypes& message) {
2171  ASSERT_EQ(2, message.repeated_int32_size());
2172  ASSERT_EQ(2, message.repeated_int64_size());
2173  ASSERT_EQ(2, message.repeated_uint32_size());
2174  ASSERT_EQ(2, message.repeated_uint64_size());
2175  ASSERT_EQ(2, message.repeated_sint32_size());
2176  ASSERT_EQ(2, message.repeated_sint64_size());
2177  ASSERT_EQ(2, message.repeated_fixed32_size());
2178  ASSERT_EQ(2, message.repeated_fixed64_size());
2179  ASSERT_EQ(2, message.repeated_sfixed32_size());
2180  ASSERT_EQ(2, message.repeated_sfixed64_size());
2181  ASSERT_EQ(2, message.repeated_float_size());
2182  ASSERT_EQ(2, message.repeated_double_size());
2183  ASSERT_EQ(2, message.repeated_bool_size());
2184  ASSERT_EQ(2, message.repeated_string_size());
2185  ASSERT_EQ(2, message.repeated_bytes_size());
2186
2187  ASSERT_EQ(2, message.repeatedgroup_size());
2188  ASSERT_EQ(2, message.repeated_nested_message_size());
2189  ASSERT_EQ(2, message.repeated_foreign_message_size());
2190  ASSERT_EQ(2, message.repeated_import_message_size());
2191  ASSERT_EQ(2, message.repeated_import_message_size());
2192  ASSERT_EQ(2, message.repeated_nested_enum_size());
2193  ASSERT_EQ(2, message.repeated_foreign_enum_size());
2194  ASSERT_EQ(2, message.repeated_import_enum_size());
2195
2196#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
2197  ASSERT_EQ(2, message.repeated_string_piece_size());
2198  ASSERT_EQ(2, message.repeated_cord_size());
2199#endif
2200
2201  // Test that the first element and second element are flipped.
2202  EXPECT_EQ(201, message.repeated_int32(1));
2203  EXPECT_EQ(202, message.repeated_int64(1));
2204  EXPECT_EQ(203, message.repeated_uint32(1));
2205  EXPECT_EQ(204, message.repeated_uint64(1));
2206  EXPECT_EQ(205, message.repeated_sint32(1));
2207  EXPECT_EQ(206, message.repeated_sint64(1));
2208  EXPECT_EQ(207, message.repeated_fixed32(1));
2209  EXPECT_EQ(208, message.repeated_fixed64(1));
2210  EXPECT_EQ(209, message.repeated_sfixed32(1));
2211  EXPECT_EQ(210, message.repeated_sfixed64(1));
2212  EXPECT_EQ(211, message.repeated_float(1));
2213  EXPECT_EQ(212, message.repeated_double(1));
2214  EXPECT_TRUE(message.repeated_bool(1));
2215  EXPECT_EQ("215", message.repeated_string(1));
2216  EXPECT_EQ("216", message.repeated_bytes(1));
2217
2218  EXPECT_EQ(217, message.repeatedgroup(1).a());
2219  EXPECT_EQ(218, message.repeated_nested_message(1).bb());
2220  EXPECT_EQ(219, message.repeated_foreign_message(1).c());
2221  EXPECT_EQ(220, message.repeated_import_message(1).d());
2222  EXPECT_EQ(220, message.repeated_import_message(1).d());
2223
2224  EXPECT_EQ(UNITTEST::TestAllTypes::BAR, message.repeated_nested_enum(1));
2225  EXPECT_EQ(UNITTEST::FOREIGN_BAR, message.repeated_foreign_enum(1));
2226  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAR, message.repeated_import_enum(1));
2227
2228  EXPECT_EQ(301, message.repeated_int32(0));
2229  EXPECT_EQ(302, message.repeated_int64(0));
2230  EXPECT_EQ(303, message.repeated_uint32(0));
2231  EXPECT_EQ(304, message.repeated_uint64(0));
2232  EXPECT_EQ(305, message.repeated_sint32(0));
2233  EXPECT_EQ(306, message.repeated_sint64(0));
2234  EXPECT_EQ(307, message.repeated_fixed32(0));
2235  EXPECT_EQ(308, message.repeated_fixed64(0));
2236  EXPECT_EQ(309, message.repeated_sfixed32(0));
2237  EXPECT_EQ(310, message.repeated_sfixed64(0));
2238  EXPECT_EQ(311, message.repeated_float(0));
2239  EXPECT_EQ(312, message.repeated_double(0));
2240  EXPECT_FALSE(message.repeated_bool(0));
2241  EXPECT_EQ("315", message.repeated_string(0));
2242  EXPECT_EQ("316", message.repeated_bytes(0));
2243
2244  EXPECT_EQ(317, message.repeatedgroup(0).a());
2245  EXPECT_EQ(318, message.repeated_nested_message(0).bb());
2246  EXPECT_EQ(319, message.repeated_foreign_message(0).c());
2247  EXPECT_EQ(320, message.repeated_import_message(0).d());
2248  EXPECT_EQ(320, message.repeated_import_message(0).d());
2249
2250  EXPECT_EQ(UNITTEST::TestAllTypes::BAZ, message.repeated_nested_enum(0));
2251  EXPECT_EQ(UNITTEST::FOREIGN_BAZ, message.repeated_foreign_enum(0));
2252  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAZ, message.repeated_import_enum(0));
2253}
2254
2255inline void TestUtil::ExpectRepeatedExtensionsSwapped(
2256    const UNITTEST::TestAllExtensions& message) {
2257  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_int32_extension));
2258  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_int64_extension));
2259  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_uint32_extension));
2260  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_uint64_extension));
2261  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_sint32_extension));
2262  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_sint64_extension));
2263  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_fixed32_extension));
2264  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_fixed64_extension));
2265  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_sfixed32_extension));
2266  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_sfixed64_extension));
2267  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_float_extension));
2268  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_double_extension));
2269  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_bool_extension));
2270  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_string_extension));
2271  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_bytes_extension));
2272
2273  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeatedgroup_extension));
2274  ASSERT_EQ(2,
2275            message.ExtensionSize(UNITTEST::repeated_nested_message_extension));
2276  ASSERT_EQ(
2277      2, message.ExtensionSize(UNITTEST::repeated_foreign_message_extension));
2278  ASSERT_EQ(2,
2279            message.ExtensionSize(UNITTEST::repeated_import_message_extension));
2280  ASSERT_EQ(2,
2281            message.ExtensionSize(UNITTEST::repeated_lazy_message_extension));
2282  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_nested_enum_extension));
2283  ASSERT_EQ(2,
2284            message.ExtensionSize(UNITTEST::repeated_foreign_enum_extension));
2285  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_import_enum_extension));
2286
2287  ASSERT_EQ(2,
2288            message.ExtensionSize(UNITTEST::repeated_string_piece_extension));
2289  ASSERT_EQ(2, message.ExtensionSize(UNITTEST::repeated_cord_extension));
2290
2291  EXPECT_EQ(201, message.GetExtension(UNITTEST::repeated_int32_extension, 1));
2292  EXPECT_EQ(202, message.GetExtension(UNITTEST::repeated_int64_extension, 1));
2293  EXPECT_EQ(203, message.GetExtension(UNITTEST::repeated_uint32_extension, 1));
2294  EXPECT_EQ(204, message.GetExtension(UNITTEST::repeated_uint64_extension, 1));
2295  EXPECT_EQ(205, message.GetExtension(UNITTEST::repeated_sint32_extension, 1));
2296  EXPECT_EQ(206, message.GetExtension(UNITTEST::repeated_sint64_extension, 1));
2297  EXPECT_EQ(207, message.GetExtension(UNITTEST::repeated_fixed32_extension, 1));
2298  EXPECT_EQ(208, message.GetExtension(UNITTEST::repeated_fixed64_extension, 1));
2299  EXPECT_EQ(209,
2300            message.GetExtension(UNITTEST::repeated_sfixed32_extension, 1));
2301  EXPECT_EQ(210,
2302            message.GetExtension(UNITTEST::repeated_sfixed64_extension, 1));
2303  EXPECT_EQ(211, message.GetExtension(UNITTEST::repeated_float_extension, 1));
2304  EXPECT_EQ(212, message.GetExtension(UNITTEST::repeated_double_extension, 1));
2305  EXPECT_TRUE(message.GetExtension(UNITTEST::repeated_bool_extension, 1));
2306  EXPECT_EQ("215",
2307            message.GetExtension(UNITTEST::repeated_string_extension, 1));
2308  EXPECT_EQ("216", message.GetExtension(UNITTEST::repeated_bytes_extension, 1));
2309
2310  EXPECT_EQ(217,
2311            message.GetExtension(UNITTEST::repeatedgroup_extension, 1).a());
2312  EXPECT_EQ(218,
2313            message.GetExtension(UNITTEST::repeated_nested_message_extension, 1)
2314                .bb());
2315  EXPECT_EQ(
2316      219, message.GetExtension(UNITTEST::repeated_foreign_message_extension, 1)
2317               .c());
2318  EXPECT_EQ(
2319      220,
2320      message.GetExtension(UNITTEST::repeated_import_message_extension, 1).d());
2321  EXPECT_EQ(
2322      227,
2323      message.GetExtension(UNITTEST::repeated_lazy_message_extension, 1).bb());
2324
2325  EXPECT_EQ(UNITTEST::TestAllTypes::BAR,
2326            message.GetExtension(UNITTEST::repeated_nested_enum_extension, 1));
2327  EXPECT_EQ(UNITTEST::FOREIGN_BAR,
2328            message.GetExtension(UNITTEST::repeated_foreign_enum_extension, 1));
2329  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAR,
2330            message.GetExtension(UNITTEST::repeated_import_enum_extension, 1));
2331
2332  EXPECT_EQ("224",
2333            message.GetExtension(UNITTEST::repeated_string_piece_extension, 1));
2334  EXPECT_EQ("225", message.GetExtension(UNITTEST::repeated_cord_extension, 1));
2335
2336  EXPECT_EQ(301, message.GetExtension(UNITTEST::repeated_int32_extension, 0));
2337  EXPECT_EQ(302, message.GetExtension(UNITTEST::repeated_int64_extension, 0));
2338  EXPECT_EQ(303, message.GetExtension(UNITTEST::repeated_uint32_extension, 0));
2339  EXPECT_EQ(304, message.GetExtension(UNITTEST::repeated_uint64_extension, 0));
2340  EXPECT_EQ(305, message.GetExtension(UNITTEST::repeated_sint32_extension, 0));
2341  EXPECT_EQ(306, message.GetExtension(UNITTEST::repeated_sint64_extension, 0));
2342  EXPECT_EQ(307, message.GetExtension(UNITTEST::repeated_fixed32_extension, 0));
2343  EXPECT_EQ(308, message.GetExtension(UNITTEST::repeated_fixed64_extension, 0));
2344  EXPECT_EQ(309,
2345            message.GetExtension(UNITTEST::repeated_sfixed32_extension, 0));
2346  EXPECT_EQ(310,
2347            message.GetExtension(UNITTEST::repeated_sfixed64_extension, 0));
2348  EXPECT_EQ(311, message.GetExtension(UNITTEST::repeated_float_extension, 0));
2349  EXPECT_EQ(312, message.GetExtension(UNITTEST::repeated_double_extension, 0));
2350  EXPECT_FALSE(message.GetExtension(UNITTEST::repeated_bool_extension, 0));
2351  EXPECT_EQ("315",
2352            message.GetExtension(UNITTEST::repeated_string_extension, 0));
2353  EXPECT_EQ("316", message.GetExtension(UNITTEST::repeated_bytes_extension, 0));
2354
2355  EXPECT_EQ(317,
2356            message.GetExtension(UNITTEST::repeatedgroup_extension, 0).a());
2357  EXPECT_EQ(318,
2358            message.GetExtension(UNITTEST::repeated_nested_message_extension, 0)
2359                .bb());
2360  EXPECT_EQ(
2361      319, message.GetExtension(UNITTEST::repeated_foreign_message_extension, 0)
2362               .c());
2363  EXPECT_EQ(
2364      320,
2365      message.GetExtension(UNITTEST::repeated_import_message_extension, 0).d());
2366  EXPECT_EQ(
2367      327,
2368      message.GetExtension(UNITTEST::repeated_lazy_message_extension, 0).bb());
2369
2370  EXPECT_EQ(UNITTEST::TestAllTypes::BAZ,
2371            message.GetExtension(UNITTEST::repeated_nested_enum_extension, 0));
2372  EXPECT_EQ(UNITTEST::FOREIGN_BAZ,
2373            message.GetExtension(UNITTEST::repeated_foreign_enum_extension, 0));
2374  EXPECT_EQ(UNITTEST_IMPORT::IMPORT_BAZ,
2375            message.GetExtension(UNITTEST::repeated_import_enum_extension, 0));
2376
2377  EXPECT_EQ("324",
2378            message.GetExtension(UNITTEST::repeated_string_piece_extension, 0));
2379  EXPECT_EQ("325", message.GetExtension(UNITTEST::repeated_cord_extension, 0));
2380}
2381
2382inline void TestUtil::SetOneof1(UNITTEST::TestOneof2* message) {
2383  message->mutable_foo_lazy_message()->set_moo_int(100);
2384  message->set_bar_string("101");
2385  message->set_baz_int(102);
2386  message->set_baz_string("103");
2387}
2388
2389inline void TestUtil::SetOneof2(UNITTEST::TestOneof2* message) {
2390  message->set_foo_int(200);
2391  message->set_bar_enum(UNITTEST::TestOneof2::BAZ);
2392  message->set_baz_int(202);
2393  message->set_baz_string("203");
2394}
2395
2396inline void TestUtil::ExpectOneofSet1(const UNITTEST::TestOneof2& message) {
2397  ExpectAtMostOneFieldSetInOneof(message);
2398
2399  EXPECT_TRUE(message.has_foo_lazy_message());
2400  EXPECT_TRUE(message.foo_lazy_message().has_moo_int());
2401
2402  EXPECT_TRUE(message.has_bar_string());
2403  EXPECT_TRUE(message.has_baz_int());
2404  EXPECT_TRUE(message.has_baz_string());
2405
2406  ASSERT_EQ(0, message.foo_lazy_message().corge_int_size());
2407
2408  EXPECT_EQ(100, message.foo_lazy_message().moo_int());
2409  EXPECT_EQ("101", message.bar_string());
2410  EXPECT_EQ(102, message.baz_int());
2411  EXPECT_EQ("103", message.baz_string());
2412}
2413
2414inline void TestUtil::ExpectOneofSet2(const UNITTEST::TestOneof2& message) {
2415  ExpectAtMostOneFieldSetInOneof(message);
2416
2417  EXPECT_TRUE(message.has_foo_int());
2418  EXPECT_TRUE(message.has_bar_enum());
2419  EXPECT_TRUE(message.has_baz_int());
2420  EXPECT_TRUE(message.has_baz_string());
2421
2422  EXPECT_EQ(200, message.foo_int());
2423  EXPECT_EQ(UNITTEST::TestOneof2::BAZ, message.bar_enum());
2424  EXPECT_EQ(202, message.baz_int());
2425  EXPECT_EQ("203", message.baz_string());
2426}
2427
2428inline void TestUtil::ExpectOneofClear(const UNITTEST::TestOneof2& message) {
2429  EXPECT_FALSE(message.has_foo_int());
2430  EXPECT_FALSE(message.has_foo_string());
2431  EXPECT_FALSE(message.has_foo_bytes());
2432  EXPECT_FALSE(message.has_foo_enum());
2433  EXPECT_FALSE(message.has_foo_message());
2434  EXPECT_FALSE(message.has_foogroup());
2435  EXPECT_FALSE(message.has_foo_lazy_message());
2436  EXPECT_FALSE(message.has_foo_bytes_cord());
2437
2438  EXPECT_FALSE(message.has_bar_int());
2439  EXPECT_FALSE(message.has_bar_string());
2440  EXPECT_FALSE(message.has_bar_bytes());
2441  EXPECT_FALSE(message.has_bar_enum());
2442
2443  EXPECT_FALSE(message.has_baz_int());
2444  EXPECT_FALSE(message.has_baz_string());
2445
2446  EXPECT_EQ(UNITTEST::TestOneof2::FOO_NOT_SET, message.foo_case());
2447  EXPECT_EQ(UNITTEST::TestOneof2::BAR_NOT_SET, message.bar_case());
2448}
2449
2450inline void TestUtil::ExpectAtMostOneFieldSetInOneof(
2451    const UNITTEST::TestOneof2& message) {
2452  int count = 0;
2453  if (message.has_foo_int()) count++;
2454  if (message.has_foo_string()) count++;
2455  if (message.has_foo_bytes()) count++;
2456  if (message.has_foo_enum()) count++;
2457  if (message.has_foo_message()) count++;
2458  if (message.has_foogroup()) count++;
2459  if (message.has_foo_lazy_message()) count++;
2460  if (message.has_foo_bytes_cord()) count++;
2461  EXPECT_LE(count, 1);
2462  count = 0;
2463  if (message.has_bar_int()) count++;
2464  if (message.has_bar_string()) count++;
2465  if (message.has_bar_bytes()) count++;
2466  if (message.has_bar_enum()) count++;
2467  EXPECT_TRUE(count == 0 || count == 1);
2468}
2469
2470// ===================================================================
2471
2472}  // namespace protobuf
2473}  // namespace google
2474