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 should be allocated on the arena in this case.
539     EXPECT_GT(arena.SpaceUsed(), initial_arena_size);
540   }
541 }
542 
543 }  // namespace
544 }  // namespace internal
545 }  // namespace protobuf
546 }  // namespace google
547