1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31 // Author: kenton@google.com (Kenton Varda)
32 // Based on original Protocol Buffers design by
33 // Sanjay Ghemawat, Jeff Dean, and others.
34
35 #include <google/protobuf/reflection_ops.h>
36 #include <google/protobuf/test_util.h>
37 #include <google/protobuf/unittest.pb.h>
38 #include <google/protobuf/descriptor.h>
39
40 #include <google/protobuf/stubs/logging.h>
41 #include <google/protobuf/stubs/common.h>
42 #include <google/protobuf/testing/googletest.h>
43 #include <gtest/gtest.h>
44
45 #include <google/protobuf/stubs/strutil.h>
46
47 namespace google {
48 namespace protobuf {
49 namespace internal {
50 namespace {
51
TEST(ReflectionOpsTest,SanityCheck)52 TEST(ReflectionOpsTest, SanityCheck) {
53 unittest::TestAllTypes message;
54
55 TestUtil::SetAllFields(&message);
56 TestUtil::ExpectAllFieldsSet(message);
57 }
58
TEST(ReflectionOpsTest,Copy)59 TEST(ReflectionOpsTest, Copy) {
60 unittest::TestAllTypes message, message2;
61
62 TestUtil::SetAllFields(&message);
63
64 ReflectionOps::Copy(message, &message2);
65
66 TestUtil::ExpectAllFieldsSet(message2);
67
68 // Copying from self should be a no-op.
69 ReflectionOps::Copy(message2, &message2);
70 TestUtil::ExpectAllFieldsSet(message2);
71 }
72
TEST(ReflectionOpsTest,CopyExtensions)73 TEST(ReflectionOpsTest, CopyExtensions) {
74 unittest::TestAllExtensions message, message2;
75
76 TestUtil::SetAllExtensions(&message);
77
78 ReflectionOps::Copy(message, &message2);
79
80 TestUtil::ExpectAllExtensionsSet(message2);
81 }
82
TEST(ReflectionOpsTest,CopyOneof)83 TEST(ReflectionOpsTest, CopyOneof) {
84 unittest::TestOneof2 message, message2;
85 TestUtil::SetOneof1(&message);
86 ReflectionOps::Copy(message, &message2);
87 TestUtil::ExpectOneofSet1(message2);
88
89 TestUtil::SetOneof2(&message);
90 TestUtil::ExpectOneofSet2(message);
91 ReflectionOps::Copy(message, &message2);
92 TestUtil::ExpectOneofSet2(message2);
93 }
94
TEST(ReflectionOpsTest,Merge)95 TEST(ReflectionOpsTest, Merge) {
96 // Note: Copy is implemented in terms of Merge() so technically the Copy
97 // test already tested most of this.
98
99 unittest::TestAllTypes message, message2;
100
101 TestUtil::SetAllFields(&message);
102
103 // This field will test merging into an empty spot.
104 message2.set_optional_int32(message.optional_int32());
105 message.clear_optional_int32();
106
107 // This tests overwriting.
108 message2.set_optional_string(message.optional_string());
109 message.set_optional_string("something else");
110
111 // This tests concatenating.
112 message2.add_repeated_int32(message.repeated_int32(1));
113 int32 i = message.repeated_int32(0);
114 message.clear_repeated_int32();
115 message.add_repeated_int32(i);
116
117 ReflectionOps::Merge(message2, &message);
118
119 TestUtil::ExpectAllFieldsSet(message);
120 }
121
TEST(ReflectionOpsTest,MergeExtensions)122 TEST(ReflectionOpsTest, MergeExtensions) {
123 // Note: Copy is implemented in terms of Merge() so technically the Copy
124 // test already tested most of this.
125
126 unittest::TestAllExtensions message, message2;
127
128 TestUtil::SetAllExtensions(&message);
129
130 // This field will test merging into an empty spot.
131 message2.SetExtension(
132 unittest::optional_int32_extension,
133 message.GetExtension(unittest::optional_int32_extension));
134 message.ClearExtension(unittest::optional_int32_extension);
135
136 // This tests overwriting.
137 message2.SetExtension(
138 unittest::optional_string_extension,
139 message.GetExtension(unittest::optional_string_extension));
140 message.SetExtension(unittest::optional_string_extension, "something else");
141
142 // This tests concatenating.
143 message2.AddExtension(
144 unittest::repeated_int32_extension,
145 message.GetExtension(unittest::repeated_int32_extension, 1));
146 int32 i = message.GetExtension(unittest::repeated_int32_extension, 0);
147 message.ClearExtension(unittest::repeated_int32_extension);
148 message.AddExtension(unittest::repeated_int32_extension, i);
149
150 ReflectionOps::Merge(message2, &message);
151
152 TestUtil::ExpectAllExtensionsSet(message);
153 }
154
TEST(ReflectionOpsTest,MergeUnknown)155 TEST(ReflectionOpsTest, MergeUnknown) {
156 // Test that the messages' UnknownFieldSets are correctly merged.
157 unittest::TestEmptyMessage message1, message2;
158 message1.mutable_unknown_fields()->AddVarint(1234, 1);
159 message2.mutable_unknown_fields()->AddVarint(1234, 2);
160
161 ReflectionOps::Merge(message2, &message1);
162
163 ASSERT_EQ(2, message1.unknown_fields().field_count());
164 ASSERT_EQ(UnknownField::TYPE_VARINT,
165 message1.unknown_fields().field(0).type());
166 EXPECT_EQ(1, message1.unknown_fields().field(0).varint());
167 ASSERT_EQ(UnknownField::TYPE_VARINT,
168 message1.unknown_fields().field(1).type());
169 EXPECT_EQ(2, message1.unknown_fields().field(1).varint());
170 }
171
TEST(ReflectionOpsTest,MergeOneof)172 TEST(ReflectionOpsTest, MergeOneof) {
173 unittest::TestOneof2 message1, message2;
174 TestUtil::SetOneof1(&message1);
175
176 // Merge to empty message
177 ReflectionOps::Merge(message1, &message2);
178 TestUtil::ExpectOneofSet1(message2);
179
180 // Merge with the same oneof fields
181 ReflectionOps::Merge(message1, &message2);
182 TestUtil::ExpectOneofSet1(message2);
183
184 // Merge with different oneof fields
185 TestUtil::SetOneof2(&message1);
186 ReflectionOps::Merge(message1, &message2);
187 TestUtil::ExpectOneofSet2(message2);
188 }
189
190 #ifdef PROTOBUF_HAS_DEATH_TEST
191
TEST(ReflectionOpsTest,MergeFromSelf)192 TEST(ReflectionOpsTest, MergeFromSelf) {
193 // Note: Copy is implemented in terms of Merge() so technically the Copy
194 // test already tested most of this.
195
196 unittest::TestAllTypes message;
197
198 EXPECT_DEATH(ReflectionOps::Merge(message, &message), "&from");
199 }
200
201 #endif // PROTOBUF_HAS_DEATH_TEST
202
TEST(ReflectionOpsTest,Clear)203 TEST(ReflectionOpsTest, Clear) {
204 unittest::TestAllTypes message;
205
206 TestUtil::SetAllFields(&message);
207
208 ReflectionOps::Clear(&message);
209
210 TestUtil::ExpectClear(message);
211
212 // Check that getting embedded messages returns the objects created during
213 // SetAllFields() rather than default instances.
214 EXPECT_NE(&unittest::TestAllTypes::OptionalGroup::default_instance(),
215 &message.optionalgroup());
216 EXPECT_NE(&unittest::TestAllTypes::NestedMessage::default_instance(),
217 &message.optional_nested_message());
218 EXPECT_NE(&unittest::ForeignMessage::default_instance(),
219 &message.optional_foreign_message());
220 EXPECT_NE(&unittest_import::ImportMessage::default_instance(),
221 &message.optional_import_message());
222 }
223
TEST(ReflectionOpsTest,ClearExtensions)224 TEST(ReflectionOpsTest, ClearExtensions) {
225 unittest::TestAllExtensions message;
226
227 TestUtil::SetAllExtensions(&message);
228
229 ReflectionOps::Clear(&message);
230
231 TestUtil::ExpectExtensionsClear(message);
232
233 // Check that getting embedded messages returns the objects created during
234 // SetAllExtensions() rather than default instances.
235 EXPECT_NE(&unittest::OptionalGroup_extension::default_instance(),
236 &message.GetExtension(unittest::optionalgroup_extension));
237 EXPECT_NE(&unittest::TestAllTypes::NestedMessage::default_instance(),
238 &message.GetExtension(unittest::optional_nested_message_extension));
239 EXPECT_NE(
240 &unittest::ForeignMessage::default_instance(),
241 &message.GetExtension(unittest::optional_foreign_message_extension));
242 EXPECT_NE(&unittest_import::ImportMessage::default_instance(),
243 &message.GetExtension(unittest::optional_import_message_extension));
244 }
245
TEST(ReflectionOpsTest,ClearUnknown)246 TEST(ReflectionOpsTest, ClearUnknown) {
247 // Test that the message's UnknownFieldSet is correctly cleared.
248 unittest::TestEmptyMessage message;
249 message.mutable_unknown_fields()->AddVarint(1234, 1);
250
251 ReflectionOps::Clear(&message);
252
253 EXPECT_EQ(0, message.unknown_fields().field_count());
254 }
255
TEST(ReflectionOpsTest,ClearOneof)256 TEST(ReflectionOpsTest, ClearOneof) {
257 unittest::TestOneof2 message;
258
259 TestUtil::ExpectOneofClear(message);
260 TestUtil::SetOneof1(&message);
261 TestUtil::ExpectOneofSet1(message);
262 ReflectionOps::Clear(&message);
263 TestUtil::ExpectOneofClear(message);
264
265 TestUtil::SetOneof1(&message);
266 TestUtil::ExpectOneofSet1(message);
267 TestUtil::SetOneof2(&message);
268 TestUtil::ExpectOneofSet2(message);
269 ReflectionOps::Clear(&message);
270 TestUtil::ExpectOneofClear(message);
271 }
272
TEST(ReflectionOpsTest,DiscardUnknownFields)273 TEST(ReflectionOpsTest, DiscardUnknownFields) {
274 unittest::TestAllTypes message;
275 TestUtil::SetAllFields(&message);
276
277 // Set some unknown fields in message.
278 message.mutable_unknown_fields()->AddVarint(123456, 654321);
279 message.mutable_optional_nested_message()
280 ->mutable_unknown_fields()
281 ->AddVarint(123456, 654321);
282 message.mutable_repeated_nested_message(0)
283 ->mutable_unknown_fields()
284 ->AddVarint(123456, 654321);
285
286 EXPECT_EQ(1, message.unknown_fields().field_count());
287 EXPECT_EQ(1,
288 message.optional_nested_message().unknown_fields().field_count());
289 EXPECT_EQ(1,
290 message.repeated_nested_message(0).unknown_fields().field_count());
291
292 // Discard them.
293 ReflectionOps::DiscardUnknownFields(&message);
294 TestUtil::ExpectAllFieldsSet(message);
295
296 EXPECT_EQ(0, message.unknown_fields().field_count());
297 EXPECT_EQ(0,
298 message.optional_nested_message().unknown_fields().field_count());
299 EXPECT_EQ(0,
300 message.repeated_nested_message(0).unknown_fields().field_count());
301 }
302
TEST(ReflectionOpsTest,DiscardUnknownExtensions)303 TEST(ReflectionOpsTest, DiscardUnknownExtensions) {
304 unittest::TestAllExtensions message;
305 TestUtil::SetAllExtensions(&message);
306
307 // Set some unknown fields.
308 message.mutable_unknown_fields()->AddVarint(123456, 654321);
309 message.MutableExtension(unittest::optional_nested_message_extension)
310 ->mutable_unknown_fields()
311 ->AddVarint(123456, 654321);
312 message.MutableExtension(unittest::repeated_nested_message_extension, 0)
313 ->mutable_unknown_fields()
314 ->AddVarint(123456, 654321);
315
316 EXPECT_EQ(1, message.unknown_fields().field_count());
317 EXPECT_EQ(1, message.GetExtension(unittest::optional_nested_message_extension)
318 .unknown_fields()
319 .field_count());
320 EXPECT_EQ(1,
321 message.GetExtension(unittest::repeated_nested_message_extension, 0)
322 .unknown_fields()
323 .field_count());
324
325 // Discard them.
326 ReflectionOps::DiscardUnknownFields(&message);
327 TestUtil::ExpectAllExtensionsSet(message);
328
329 EXPECT_EQ(0, message.unknown_fields().field_count());
330 EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension)
331 .unknown_fields()
332 .field_count());
333 EXPECT_EQ(0,
334 message.GetExtension(unittest::repeated_nested_message_extension, 0)
335 .unknown_fields()
336 .field_count());
337 }
338
TEST(ReflectionOpsTest,IsInitialized)339 TEST(ReflectionOpsTest, IsInitialized) {
340 unittest::TestRequired message;
341
342 EXPECT_FALSE(ReflectionOps::IsInitialized(message));
343 EXPECT_FALSE(ReflectionOps::IsInitialized(message, true, false));
344 EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
345 message.set_a(1);
346 EXPECT_FALSE(ReflectionOps::IsInitialized(message));
347 EXPECT_FALSE(ReflectionOps::IsInitialized(message, true, true));
348 EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
349 message.set_b(2);
350 EXPECT_FALSE(ReflectionOps::IsInitialized(message));
351 EXPECT_FALSE(ReflectionOps::IsInitialized(message, true, true));
352 EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
353 message.set_c(3);
354 EXPECT_TRUE(ReflectionOps::IsInitialized(message));
355 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
356 EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
357 }
358
TEST(ReflectionOpsTest,ForeignIsInitialized)359 TEST(ReflectionOpsTest, ForeignIsInitialized) {
360 unittest::TestRequiredForeign message;
361
362 // Starts out initialized because the foreign message is itself an optional
363 // field.
364 EXPECT_TRUE(ReflectionOps::IsInitialized(message));
365 EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
366
367 // Once we create that field, the message is no longer initialized.
368 message.mutable_optional_message();
369 EXPECT_FALSE(ReflectionOps::IsInitialized(message));
370 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
371 EXPECT_FALSE(ReflectionOps::IsInitialized(message, false, true));
372
373 // Initialize it. Now we're initialized.
374 message.mutable_optional_message()->set_a(1);
375 message.mutable_optional_message()->set_b(2);
376 message.mutable_optional_message()->set_c(3);
377 EXPECT_TRUE(ReflectionOps::IsInitialized(message));
378 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
379 EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
380
381 // Add a repeated version of the message. No longer initialized.
382 unittest::TestRequired* sub_message = message.add_repeated_message();
383 EXPECT_FALSE(ReflectionOps::IsInitialized(message));
384 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
385 EXPECT_FALSE(ReflectionOps::IsInitialized(message, false, true));
386
387 // Initialize that repeated version.
388 sub_message->set_a(1);
389 sub_message->set_b(2);
390 sub_message->set_c(3);
391 EXPECT_TRUE(ReflectionOps::IsInitialized(message));
392 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
393 EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
394 }
395
TEST(ReflectionOpsTest,ExtensionIsInitialized)396 TEST(ReflectionOpsTest, ExtensionIsInitialized) {
397 unittest::TestAllExtensions message;
398
399 // Starts out initialized because the foreign message is itself an optional
400 // field.
401 EXPECT_TRUE(ReflectionOps::IsInitialized(message));
402 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
403 EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
404
405 // Once we create that field, the message is no longer initialized.
406 message.MutableExtension(unittest::TestRequired::single);
407 EXPECT_FALSE(ReflectionOps::IsInitialized(message));
408 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
409 EXPECT_FALSE(ReflectionOps::IsInitialized(message, false, true));
410
411 // Initialize it. Now we're initialized.
412 message.MutableExtension(unittest::TestRequired::single)->set_a(1);
413 message.MutableExtension(unittest::TestRequired::single)->set_b(2);
414 message.MutableExtension(unittest::TestRequired::single)->set_c(3);
415 EXPECT_TRUE(ReflectionOps::IsInitialized(message));
416 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
417 EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
418
419 // Add a repeated version of the message. No longer initialized.
420 message.AddExtension(unittest::TestRequired::multi);
421 EXPECT_FALSE(ReflectionOps::IsInitialized(message));
422 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
423 EXPECT_FALSE(ReflectionOps::IsInitialized(message, false, true));
424
425 // Initialize that repeated version.
426 message.MutableExtension(unittest::TestRequired::multi, 0)->set_a(1);
427 message.MutableExtension(unittest::TestRequired::multi, 0)->set_b(2);
428 message.MutableExtension(unittest::TestRequired::multi, 0)->set_c(3);
429 EXPECT_TRUE(ReflectionOps::IsInitialized(message));
430 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
431 EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
432 }
433
TEST(ReflectionOpsTest,OneofIsInitialized)434 TEST(ReflectionOpsTest, OneofIsInitialized) {
435 unittest::TestRequiredOneof message;
436 EXPECT_TRUE(ReflectionOps::IsInitialized(message));
437 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
438 EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
439
440 message.mutable_foo_message();
441 EXPECT_FALSE(ReflectionOps::IsInitialized(message));
442 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
443 EXPECT_FALSE(ReflectionOps::IsInitialized(message, false, true));
444
445 message.set_foo_int(1);
446 EXPECT_TRUE(ReflectionOps::IsInitialized(message));
447 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
448 EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
449
450 message.mutable_foo_message();
451 EXPECT_FALSE(ReflectionOps::IsInitialized(message));
452 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
453 EXPECT_FALSE(ReflectionOps::IsInitialized(message, false, true));
454 message.mutable_foo_message()->set_required_double(0.1);
455 EXPECT_TRUE(ReflectionOps::IsInitialized(message));
456 EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
457 EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
458 }
459
FindInitializationErrors(const Message & message)460 static std::string FindInitializationErrors(const Message& message) {
461 std::vector<std::string> errors;
462 ReflectionOps::FindInitializationErrors(message, "", &errors);
463 return Join(errors, ",");
464 }
465
TEST(ReflectionOpsTest,FindInitializationErrors)466 TEST(ReflectionOpsTest, FindInitializationErrors) {
467 unittest::TestRequired message;
468 EXPECT_EQ("a,b,c", FindInitializationErrors(message));
469 }
470
TEST(ReflectionOpsTest,FindForeignInitializationErrors)471 TEST(ReflectionOpsTest, FindForeignInitializationErrors) {
472 unittest::TestRequiredForeign message;
473 message.mutable_optional_message();
474 message.add_repeated_message();
475 message.add_repeated_message();
476 EXPECT_EQ(
477 "optional_message.a,"
478 "optional_message.b,"
479 "optional_message.c,"
480 "repeated_message[0].a,"
481 "repeated_message[0].b,"
482 "repeated_message[0].c,"
483 "repeated_message[1].a,"
484 "repeated_message[1].b,"
485 "repeated_message[1].c",
486 FindInitializationErrors(message));
487 }
488
TEST(ReflectionOpsTest,FindExtensionInitializationErrors)489 TEST(ReflectionOpsTest, FindExtensionInitializationErrors) {
490 unittest::TestAllExtensions message;
491 message.MutableExtension(unittest::TestRequired::single);
492 message.AddExtension(unittest::TestRequired::multi);
493 message.AddExtension(unittest::TestRequired::multi);
494 EXPECT_EQ(
495 "(protobuf_unittest.TestRequired.single).a,"
496 "(protobuf_unittest.TestRequired.single).b,"
497 "(protobuf_unittest.TestRequired.single).c,"
498 "(protobuf_unittest.TestRequired.multi)[0].a,"
499 "(protobuf_unittest.TestRequired.multi)[0].b,"
500 "(protobuf_unittest.TestRequired.multi)[0].c,"
501 "(protobuf_unittest.TestRequired.multi)[1].a,"
502 "(protobuf_unittest.TestRequired.multi)[1].b,"
503 "(protobuf_unittest.TestRequired.multi)[1].c",
504 FindInitializationErrors(message));
505 }
506
TEST(ReflectionOpsTest,FindOneofInitializationErrors)507 TEST(ReflectionOpsTest, FindOneofInitializationErrors) {
508 unittest::TestRequiredOneof message;
509 message.mutable_foo_message();
510 EXPECT_EQ("foo_message.required_double", FindInitializationErrors(message));
511 }
512
TEST(ReflectionOpsTest,GenericSwap)513 TEST(ReflectionOpsTest, GenericSwap) {
514 Arena arena;
515 {
516 unittest::TestAllTypes message;
517 auto* arena_message = Arena::CreateMessage<unittest::TestAllTypes>(&arena);
518 TestUtil::SetAllFields(arena_message);
519 const uint64 initial_arena_size = arena.SpaceUsed();
520
521 GenericSwap(&message, arena_message);
522
523 TestUtil::ExpectAllFieldsSet(message);
524 TestUtil::ExpectClear(*arena_message);
525 // The temp should be allocated on the arena in this case.
526 EXPECT_GT(arena.SpaceUsed(), initial_arena_size);
527 }
528 {
529 unittest::TestAllTypes message;
530 auto* arena_message = Arena::CreateMessage<unittest::TestAllTypes>(&arena);
531 TestUtil::SetAllFields(arena_message);
532 const uint64 initial_arena_size = arena.SpaceUsed();
533
534 GenericSwap(arena_message, &message);
535
536 TestUtil::ExpectAllFieldsSet(message);
537 TestUtil::ExpectClear(*arena_message);
538 // The temp shouldn't be allocated on the arena in this case.
539 EXPECT_EQ(arena.SpaceUsed(), initial_arena_size);
540 }
541 }
542
543 } // namespace
544 } // namespace internal
545 } // namespace protobuf
546 } // namespace google
547