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