Debian Codegraph @

extra/protobuf/protobuf-24.4/src/google/protobuf/reflection_ops_unittest.cc

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