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 // To test GeneratedMessageReflection, we actually let the protocol compiler
36 // generate a full protocol message implementation and then test its
37 // reflection interface. This is much easier and more maintainable than
38 // trying to create our own Message class for GeneratedMessageReflection
39 // to wrap.
40 //
41 // The tests here closely mirror some of the tests in
42 // compiler/cpp/unittest, except using the reflection interface
43 // rather than generated accessors.
44
45 #include <google/protobuf/generated_message_reflection.h>
46 #include <memory>
47 #ifndef _SHARED_PTR_H
48 #include <google/protobuf/stubs/shared_ptr.h>
49 #endif
50
51 #include <google/protobuf/descriptor.h>
52 #include <google/protobuf/test_util.h>
53 #include <google/protobuf/unittest.pb.h>
54
55 #include <google/protobuf/stubs/logging.h>
56 #include <google/protobuf/stubs/common.h>
57 #include <google/protobuf/testing/googletest.h>
58 #include <gtest/gtest.h>
59
60 namespace google {
61 namespace protobuf {
62
63 namespace {
64
65 // Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes.
F(const string & name)66 const FieldDescriptor* F(const string& name) {
67 const FieldDescriptor* result =
68 unittest::TestAllTypes::descriptor()->FindFieldByName(name);
69 GOOGLE_CHECK(result != NULL);
70 return result;
71 }
72
TEST(GeneratedMessageReflectionTest,Defaults)73 TEST(GeneratedMessageReflectionTest, Defaults) {
74 // Check that all default values are set correctly in the initial message.
75 unittest::TestAllTypes message;
76 TestUtil::ReflectionTester reflection_tester(
77 unittest::TestAllTypes::descriptor());
78
79 reflection_tester.ExpectClearViaReflection(message);
80
81 const Reflection* reflection = message.GetReflection();
82
83 // Messages should return pointers to default instances until first use.
84 // (This is not checked by ExpectClear() since it is not actually true after
85 // the fields have been set and then cleared.)
86 EXPECT_EQ(&unittest::TestAllTypes::OptionalGroup::default_instance(),
87 &reflection->GetMessage(message, F("optionalgroup")));
88 EXPECT_EQ(&unittest::TestAllTypes::NestedMessage::default_instance(),
89 &reflection->GetMessage(message, F("optional_nested_message")));
90 EXPECT_EQ(&unittest::ForeignMessage::default_instance(),
91 &reflection->GetMessage(message, F("optional_foreign_message")));
92 EXPECT_EQ(&unittest_import::ImportMessage::default_instance(),
93 &reflection->GetMessage(message, F("optional_import_message")));
94 }
95
TEST(GeneratedMessageReflectionTest,Accessors)96 TEST(GeneratedMessageReflectionTest, Accessors) {
97 // Set every field to a unique value then go back and check all those
98 // values.
99 unittest::TestAllTypes message;
100 TestUtil::ReflectionTester reflection_tester(
101 unittest::TestAllTypes::descriptor());
102
103 reflection_tester.SetAllFieldsViaReflection(&message);
104 TestUtil::ExpectAllFieldsSet(message);
105 reflection_tester.ExpectAllFieldsSetViaReflection(message);
106
107 reflection_tester.ModifyRepeatedFieldsViaReflection(&message);
108 TestUtil::ExpectRepeatedFieldsModified(message);
109 }
110
TEST(GeneratedMessageReflectionTest,GetStringReference)111 TEST(GeneratedMessageReflectionTest, GetStringReference) {
112 // Test that GetStringReference() returns the underlying string when it is
113 // a normal string field.
114 unittest::TestAllTypes message;
115 message.set_optional_string("foo");
116 message.add_repeated_string("foo");
117
118 const Reflection* reflection = message.GetReflection();
119 string scratch;
120
121 EXPECT_EQ(&message.optional_string(),
122 &reflection->GetStringReference(message, F("optional_string"), &scratch))
123 << "For simple string fields, GetStringReference() should return a "
124 "reference to the underlying string.";
125 EXPECT_EQ(&message.repeated_string(0),
126 &reflection->GetRepeatedStringReference(message, F("repeated_string"),
127 0, &scratch))
128 << "For simple string fields, GetRepeatedStringReference() should return "
129 "a reference to the underlying string.";
130 }
131
132
TEST(GeneratedMessageReflectionTest,DefaultsAfterClear)133 TEST(GeneratedMessageReflectionTest, DefaultsAfterClear) {
134 // Check that after setting all fields and then clearing, getting an
135 // embedded message does NOT return the default instance.
136 unittest::TestAllTypes message;
137 TestUtil::ReflectionTester reflection_tester(
138 unittest::TestAllTypes::descriptor());
139
140 TestUtil::SetAllFields(&message);
141 message.Clear();
142
143 const Reflection* reflection = message.GetReflection();
144
145 EXPECT_NE(&unittest::TestAllTypes::OptionalGroup::default_instance(),
146 &reflection->GetMessage(message, F("optionalgroup")));
147 EXPECT_NE(&unittest::TestAllTypes::NestedMessage::default_instance(),
148 &reflection->GetMessage(message, F("optional_nested_message")));
149 EXPECT_NE(&unittest::ForeignMessage::default_instance(),
150 &reflection->GetMessage(message, F("optional_foreign_message")));
151 EXPECT_NE(&unittest_import::ImportMessage::default_instance(),
152 &reflection->GetMessage(message, F("optional_import_message")));
153 }
154
155
TEST(GeneratedMessageReflectionTest,Swap)156 TEST(GeneratedMessageReflectionTest, Swap) {
157 unittest::TestAllTypes message1;
158 unittest::TestAllTypes message2;
159
160 TestUtil::SetAllFields(&message1);
161
162 const Reflection* reflection = message1.GetReflection();
163 reflection->Swap(&message1, &message2);
164
165 TestUtil::ExpectClear(message1);
166 TestUtil::ExpectAllFieldsSet(message2);
167 }
168
TEST(GeneratedMessageReflectionTest,SwapWithBothSet)169 TEST(GeneratedMessageReflectionTest, SwapWithBothSet) {
170 unittest::TestAllTypes message1;
171 unittest::TestAllTypes message2;
172
173 TestUtil::SetAllFields(&message1);
174 TestUtil::SetAllFields(&message2);
175 TestUtil::ModifyRepeatedFields(&message2);
176
177 const Reflection* reflection = message1.GetReflection();
178 reflection->Swap(&message1, &message2);
179
180 TestUtil::ExpectRepeatedFieldsModified(message1);
181 TestUtil::ExpectAllFieldsSet(message2);
182
183 message1.set_optional_int32(532819);
184
185 reflection->Swap(&message1, &message2);
186
187 EXPECT_EQ(532819, message2.optional_int32());
188 }
189
TEST(GeneratedMessageReflectionTest,SwapExtensions)190 TEST(GeneratedMessageReflectionTest, SwapExtensions) {
191 unittest::TestAllExtensions message1;
192 unittest::TestAllExtensions message2;
193
194 TestUtil::SetAllExtensions(&message1);
195
196 const Reflection* reflection = message1.GetReflection();
197 reflection->Swap(&message1, &message2);
198
199 TestUtil::ExpectExtensionsClear(message1);
200 TestUtil::ExpectAllExtensionsSet(message2);
201 }
202
TEST(GeneratedMessageReflectionTest,SwapUnknown)203 TEST(GeneratedMessageReflectionTest, SwapUnknown) {
204 unittest::TestEmptyMessage message1, message2;
205
206 message1.mutable_unknown_fields()->AddVarint(1234, 1);
207
208 EXPECT_EQ(1, message1.unknown_fields().field_count());
209 EXPECT_EQ(0, message2.unknown_fields().field_count());
210 const Reflection* reflection = message1.GetReflection();
211 reflection->Swap(&message1, &message2);
212 EXPECT_EQ(0, message1.unknown_fields().field_count());
213 EXPECT_EQ(1, message2.unknown_fields().field_count());
214 }
215
TEST(GeneratedMessageReflectionTest,SwapFields)216 TEST(GeneratedMessageReflectionTest, SwapFields) {
217 unittest::TestAllTypes message1, message2;
218 message1.set_optional_double(12.3);
219 message1.mutable_repeated_int32()->Add(10);
220 message1.mutable_repeated_int32()->Add(20);
221
222 message2.set_optional_string("hello");
223 message2.mutable_repeated_int64()->Add(30);
224
225 vector<const FieldDescriptor*> fields;
226 const Descriptor* descriptor = message1.GetDescriptor();
227 fields.push_back(descriptor->FindFieldByName("optional_double"));
228 fields.push_back(descriptor->FindFieldByName("repeated_int32"));
229 fields.push_back(descriptor->FindFieldByName("optional_string"));
230 fields.push_back(descriptor->FindFieldByName("optional_uint64"));
231
232 const Reflection* reflection = message1.GetReflection();
233 reflection->SwapFields(&message1, &message2, fields);
234
235 EXPECT_FALSE(message1.has_optional_double());
236 EXPECT_EQ(0, message1.repeated_int32_size());
237 EXPECT_TRUE(message1.has_optional_string());
238 EXPECT_EQ("hello", message1.optional_string());
239 EXPECT_EQ(0, message1.repeated_int64_size());
240 EXPECT_FALSE(message1.has_optional_uint64());
241
242 EXPECT_TRUE(message2.has_optional_double());
243 EXPECT_EQ(12.3, message2.optional_double());
244 EXPECT_EQ(2, message2.repeated_int32_size());
245 EXPECT_EQ(10, message2.repeated_int32(0));
246 EXPECT_EQ(20, message2.repeated_int32(1));
247 EXPECT_FALSE(message2.has_optional_string());
248 EXPECT_EQ(1, message2.repeated_int64_size());
249 EXPECT_FALSE(message2.has_optional_uint64());
250 }
251
TEST(GeneratedMessageReflectionTest,SwapFieldsAll)252 TEST(GeneratedMessageReflectionTest, SwapFieldsAll) {
253 unittest::TestAllTypes message1;
254 unittest::TestAllTypes message2;
255
256 TestUtil::SetAllFields(&message2);
257
258 vector<const FieldDescriptor*> fields;
259 const Reflection* reflection = message1.GetReflection();
260 reflection->ListFields(message2, &fields);
261 reflection->SwapFields(&message1, &message2, fields);
262
263 TestUtil::ExpectAllFieldsSet(message1);
264 TestUtil::ExpectClear(message2);
265 }
266
TEST(GeneratedMessageReflectionTest,SwapFieldsAllExtension)267 TEST(GeneratedMessageReflectionTest, SwapFieldsAllExtension) {
268 unittest::TestAllExtensions message1;
269 unittest::TestAllExtensions message2;
270
271 TestUtil::SetAllExtensions(&message1);
272
273 vector<const FieldDescriptor*> fields;
274 const Reflection* reflection = message1.GetReflection();
275 reflection->ListFields(message1, &fields);
276 reflection->SwapFields(&message1, &message2, fields);
277
278 TestUtil::ExpectExtensionsClear(message1);
279 TestUtil::ExpectAllExtensionsSet(message2);
280 }
281
TEST(GeneratedMessageReflectionTest,SwapOneof)282 TEST(GeneratedMessageReflectionTest, SwapOneof) {
283 unittest::TestOneof2 message1, message2;
284 TestUtil::SetOneof1(&message1);
285
286 const Reflection* reflection = message1.GetReflection();
287 reflection->Swap(&message1, &message2);
288
289 TestUtil::ExpectOneofClear(message1);
290 TestUtil::ExpectOneofSet1(message2);
291 }
292
TEST(GeneratedMessageReflectionTest,SwapOneofBothSet)293 TEST(GeneratedMessageReflectionTest, SwapOneofBothSet) {
294 unittest::TestOneof2 message1, message2;
295 TestUtil::SetOneof1(&message1);
296 TestUtil::SetOneof2(&message2);
297
298 const Reflection* reflection = message1.GetReflection();
299 reflection->Swap(&message1, &message2);
300
301 TestUtil::ExpectOneofSet2(message1);
302 TestUtil::ExpectOneofSet1(message2);
303 }
304
TEST(GeneratedMessageReflectionTest,SwapFieldsOneof)305 TEST(GeneratedMessageReflectionTest, SwapFieldsOneof) {
306 unittest::TestOneof2 message1, message2;
307 TestUtil::SetOneof1(&message1);
308
309 vector<const FieldDescriptor*> fields;
310 const Descriptor* descriptor = message1.GetDescriptor();
311 for (int i = 0; i < descriptor->field_count(); i++) {
312 fields.push_back(descriptor->field(i));
313 }
314 const Reflection* reflection = message1.GetReflection();
315 reflection->SwapFields(&message1, &message2, fields);
316
317 TestUtil::ExpectOneofClear(message1);
318 TestUtil::ExpectOneofSet1(message2);
319 }
320
TEST(GeneratedMessageReflectionTest,RemoveLast)321 TEST(GeneratedMessageReflectionTest, RemoveLast) {
322 unittest::TestAllTypes message;
323 TestUtil::ReflectionTester reflection_tester(
324 unittest::TestAllTypes::descriptor());
325
326 TestUtil::SetAllFields(&message);
327
328 reflection_tester.RemoveLastRepeatedsViaReflection(&message);
329
330 TestUtil::ExpectLastRepeatedsRemoved(message);
331 }
332
TEST(GeneratedMessageReflectionTest,RemoveLastExtensions)333 TEST(GeneratedMessageReflectionTest, RemoveLastExtensions) {
334 unittest::TestAllExtensions message;
335 TestUtil::ReflectionTester reflection_tester(
336 unittest::TestAllExtensions::descriptor());
337
338 TestUtil::SetAllExtensions(&message);
339
340 reflection_tester.RemoveLastRepeatedsViaReflection(&message);
341
342 TestUtil::ExpectLastRepeatedExtensionsRemoved(message);
343 }
344
TEST(GeneratedMessageReflectionTest,ReleaseLast)345 TEST(GeneratedMessageReflectionTest, ReleaseLast) {
346 unittest::TestAllTypes message;
347 const Descriptor* descriptor = message.GetDescriptor();
348 TestUtil::ReflectionTester reflection_tester(descriptor);
349
350 TestUtil::SetAllFields(&message);
351
352 reflection_tester.ReleaseLastRepeatedsViaReflection(&message, false);
353
354 TestUtil::ExpectLastRepeatedsReleased(message);
355
356 // Now test that we actually release the right message.
357 message.Clear();
358 TestUtil::SetAllFields(&message);
359 ASSERT_EQ(2, message.repeated_foreign_message_size());
360 const protobuf_unittest::ForeignMessage* expected =
361 message.mutable_repeated_foreign_message(1);
362 google::protobuf::scoped_ptr<Message> released(message.GetReflection()->ReleaseLast(
363 &message, descriptor->FindFieldByName("repeated_foreign_message")));
364 EXPECT_EQ(expected, released.get());
365 }
366
TEST(GeneratedMessageReflectionTest,ReleaseLastExtensions)367 TEST(GeneratedMessageReflectionTest, ReleaseLastExtensions) {
368 unittest::TestAllExtensions message;
369 const Descriptor* descriptor = message.GetDescriptor();
370 TestUtil::ReflectionTester reflection_tester(descriptor);
371
372 TestUtil::SetAllExtensions(&message);
373
374 reflection_tester.ReleaseLastRepeatedsViaReflection(&message, true);
375
376 TestUtil::ExpectLastRepeatedExtensionsReleased(message);
377
378 // Now test that we actually release the right message.
379 message.Clear();
380 TestUtil::SetAllExtensions(&message);
381 ASSERT_EQ(2, message.ExtensionSize(
382 unittest::repeated_foreign_message_extension));
383 const protobuf_unittest::ForeignMessage* expected = message.MutableExtension(
384 unittest::repeated_foreign_message_extension, 1);
385 google::protobuf::scoped_ptr<Message> released(message.GetReflection()->ReleaseLast(
386 &message, descriptor->file()->FindExtensionByName(
387 "repeated_foreign_message_extension")));
388 EXPECT_EQ(expected, released.get());
389
390 }
391
TEST(GeneratedMessageReflectionTest,SwapRepeatedElements)392 TEST(GeneratedMessageReflectionTest, SwapRepeatedElements) {
393 unittest::TestAllTypes message;
394 TestUtil::ReflectionTester reflection_tester(
395 unittest::TestAllTypes::descriptor());
396
397 TestUtil::SetAllFields(&message);
398
399 // Swap and test that fields are all swapped.
400 reflection_tester.SwapRepeatedsViaReflection(&message);
401 TestUtil::ExpectRepeatedsSwapped(message);
402
403 // Swap back and test that fields are all back to original values.
404 reflection_tester.SwapRepeatedsViaReflection(&message);
405 TestUtil::ExpectAllFieldsSet(message);
406 }
407
TEST(GeneratedMessageReflectionTest,SwapRepeatedElementsExtension)408 TEST(GeneratedMessageReflectionTest, SwapRepeatedElementsExtension) {
409 unittest::TestAllExtensions message;
410 TestUtil::ReflectionTester reflection_tester(
411 unittest::TestAllExtensions::descriptor());
412
413 TestUtil::SetAllExtensions(&message);
414
415 // Swap and test that fields are all swapped.
416 reflection_tester.SwapRepeatedsViaReflection(&message);
417 TestUtil::ExpectRepeatedExtensionsSwapped(message);
418
419 // Swap back and test that fields are all back to original values.
420 reflection_tester.SwapRepeatedsViaReflection(&message);
421 TestUtil::ExpectAllExtensionsSet(message);
422 }
423
TEST(GeneratedMessageReflectionTest,Extensions)424 TEST(GeneratedMessageReflectionTest, Extensions) {
425 // Set every extension to a unique value then go back and check all those
426 // values.
427 unittest::TestAllExtensions message;
428 TestUtil::ReflectionTester reflection_tester(
429 unittest::TestAllExtensions::descriptor());
430
431 reflection_tester.SetAllFieldsViaReflection(&message);
432 TestUtil::ExpectAllExtensionsSet(message);
433 reflection_tester.ExpectAllFieldsSetViaReflection(message);
434
435 reflection_tester.ModifyRepeatedFieldsViaReflection(&message);
436 TestUtil::ExpectRepeatedExtensionsModified(message);
437 }
438
TEST(GeneratedMessageReflectionTest,FindExtensionTypeByNumber)439 TEST(GeneratedMessageReflectionTest, FindExtensionTypeByNumber) {
440 const Reflection* reflection =
441 unittest::TestAllExtensions::default_instance().GetReflection();
442
443 const FieldDescriptor* extension1 =
444 unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
445 "optional_int32_extension");
446 const FieldDescriptor* extension2 =
447 unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
448 "repeated_string_extension");
449
450 EXPECT_EQ(extension1,
451 reflection->FindKnownExtensionByNumber(extension1->number()));
452 EXPECT_EQ(extension2,
453 reflection->FindKnownExtensionByNumber(extension2->number()));
454
455 // Non-existent extension.
456 EXPECT_TRUE(reflection->FindKnownExtensionByNumber(62341) == NULL);
457
458 // Extensions of TestAllExtensions should not show up as extensions of
459 // other types.
460 EXPECT_TRUE(unittest::TestAllTypes::default_instance().GetReflection()->
461 FindKnownExtensionByNumber(extension1->number()) == NULL);
462 }
463
TEST(GeneratedMessageReflectionTest,FindKnownExtensionByName)464 TEST(GeneratedMessageReflectionTest, FindKnownExtensionByName) {
465 const Reflection* reflection =
466 unittest::TestAllExtensions::default_instance().GetReflection();
467
468 const FieldDescriptor* extension1 =
469 unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
470 "optional_int32_extension");
471 const FieldDescriptor* extension2 =
472 unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
473 "repeated_string_extension");
474
475 EXPECT_EQ(extension1,
476 reflection->FindKnownExtensionByName(extension1->full_name()));
477 EXPECT_EQ(extension2,
478 reflection->FindKnownExtensionByName(extension2->full_name()));
479
480 // Non-existent extension.
481 EXPECT_TRUE(reflection->FindKnownExtensionByName("no_such_ext") == NULL);
482
483 // Extensions of TestAllExtensions should not show up as extensions of
484 // other types.
485 EXPECT_TRUE(unittest::TestAllTypes::default_instance().GetReflection()->
486 FindKnownExtensionByName(extension1->full_name()) == NULL);
487 }
488
TEST(GeneratedMessageReflectionTest,SetAllocatedMessageTest)489 TEST(GeneratedMessageReflectionTest, SetAllocatedMessageTest) {
490 unittest::TestAllTypes from_message1;
491 unittest::TestAllTypes from_message2;
492 unittest::TestAllTypes to_message;
493 TestUtil::ReflectionTester reflection_tester(
494 unittest::TestAllTypes::descriptor());
495 reflection_tester.SetAllFieldsViaReflection(&from_message1);
496 reflection_tester.SetAllFieldsViaReflection(&from_message2);
497
498 // Before moving fields, we expect the nested messages to be NULL.
499 reflection_tester.ExpectMessagesReleasedViaReflection(
500 &to_message, TestUtil::ReflectionTester::IS_NULL);
501
502 // After fields are moved we should get non-NULL releases.
503 reflection_tester.SetAllocatedOptionalMessageFieldsToMessageViaReflection(
504 &from_message1, &to_message);
505 reflection_tester.ExpectMessagesReleasedViaReflection(
506 &to_message, TestUtil::ReflectionTester::NOT_NULL);
507
508 // Another move to make sure that we can SetAllocated several times.
509 reflection_tester.SetAllocatedOptionalMessageFieldsToMessageViaReflection(
510 &from_message2, &to_message);
511 reflection_tester.ExpectMessagesReleasedViaReflection(
512 &to_message, TestUtil::ReflectionTester::NOT_NULL);
513
514 // After SetAllocatedOptionalMessageFieldsToNullViaReflection() we expect the
515 // releases to be NULL again.
516 reflection_tester.SetAllocatedOptionalMessageFieldsToNullViaReflection(
517 &to_message);
518 reflection_tester.ExpectMessagesReleasedViaReflection(
519 &to_message, TestUtil::ReflectionTester::IS_NULL);
520 }
521
TEST(GeneratedMessageReflectionTest,SetAllocatedExtensionMessageTest)522 TEST(GeneratedMessageReflectionTest, SetAllocatedExtensionMessageTest) {
523 unittest::TestAllExtensions from_message1;
524 unittest::TestAllExtensions from_message2;
525 unittest::TestAllExtensions to_message;
526 TestUtil::ReflectionTester reflection_tester(
527 unittest::TestAllExtensions::descriptor());
528 reflection_tester.SetAllFieldsViaReflection(&from_message1);
529 reflection_tester.SetAllFieldsViaReflection(&from_message2);
530
531 // Before moving fields, we expect the nested messages to be NULL.
532 reflection_tester.ExpectMessagesReleasedViaReflection(
533 &to_message, TestUtil::ReflectionTester::IS_NULL);
534
535 // After fields are moved we should get non-NULL releases.
536 reflection_tester.SetAllocatedOptionalMessageFieldsToMessageViaReflection(
537 &from_message1, &to_message);
538 reflection_tester.ExpectMessagesReleasedViaReflection(
539 &to_message, TestUtil::ReflectionTester::NOT_NULL);
540
541 // Another move to make sure that we can SetAllocated several times.
542 reflection_tester.SetAllocatedOptionalMessageFieldsToMessageViaReflection(
543 &from_message2, &to_message);
544 reflection_tester.ExpectMessagesReleasedViaReflection(
545 &to_message, TestUtil::ReflectionTester::NOT_NULL);
546
547 // After SetAllocatedOptionalMessageFieldsToNullViaReflection() we expect the
548 // releases to be NULL again.
549 reflection_tester.SetAllocatedOptionalMessageFieldsToNullViaReflection(
550 &to_message);
551 reflection_tester.ExpectMessagesReleasedViaReflection(
552 &to_message, TestUtil::ReflectionTester::IS_NULL);
553 }
554
TEST(GeneratedMessageReflectionTest,AddRepeatedMessage)555 TEST(GeneratedMessageReflectionTest, AddRepeatedMessage) {
556 unittest::TestAllTypes message;
557
558 const Reflection* reflection = message.GetReflection();
559 const Reflection* nested_reflection =
560 unittest::TestAllTypes::NestedMessage::default_instance().GetReflection();
561
562 const FieldDescriptor* nested_bb =
563 unittest::TestAllTypes::NestedMessage::descriptor()->FindFieldByName(
564 "bb");
565
566 Message* nested = reflection->AddMessage(
567 &message, F("repeated_nested_message"));
568 nested_reflection->SetInt32(nested, nested_bb, 11);
569
570 EXPECT_EQ(11, message.repeated_nested_message(0).bb());
571 }
572
TEST(GeneratedMessageReflectionTest,MutableRepeatedMessage)573 TEST(GeneratedMessageReflectionTest, MutableRepeatedMessage) {
574 unittest::TestAllTypes message;
575
576 const Reflection* reflection = message.GetReflection();
577 const Reflection* nested_reflection =
578 unittest::TestAllTypes::NestedMessage::default_instance().GetReflection();
579
580 const FieldDescriptor* nested_bb =
581 unittest::TestAllTypes::NestedMessage::descriptor()->FindFieldByName(
582 "bb");
583
584 message.add_repeated_nested_message()->set_bb(12);
585
586 Message* nested = reflection->MutableRepeatedMessage(
587 &message, F("repeated_nested_message"), 0);
588 EXPECT_EQ(12, nested_reflection->GetInt32(*nested, nested_bb));
589 nested_reflection->SetInt32(nested, nested_bb, 13);
590 EXPECT_EQ(13, message.repeated_nested_message(0).bb());
591 }
592
TEST(GeneratedMessageReflectionTest,AddAllocatedMessage)593 TEST(GeneratedMessageReflectionTest, AddAllocatedMessage) {
594 unittest::TestAllTypes message;
595
596 const Reflection* reflection = message.GetReflection();
597
598 unittest::TestAllTypes::NestedMessage* nested =
599 new unittest::TestAllTypes::NestedMessage();
600 nested->set_bb(11);
601 reflection->AddAllocatedMessage(&message, F("repeated_nested_message"), nested);
602 EXPECT_EQ(1, message.repeated_nested_message_size());
603 EXPECT_EQ(11, message.repeated_nested_message(0).bb());
604 }
605
TEST(GeneratedMessageReflectionTest,ListFieldsOneOf)606 TEST(GeneratedMessageReflectionTest, ListFieldsOneOf) {
607 unittest::TestOneof2 message;
608 TestUtil::SetOneof1(&message);
609
610 const Reflection* reflection = message.GetReflection();
611 vector<const FieldDescriptor*> fields;
612 reflection->ListFields(message, &fields);
613 EXPECT_EQ(4, fields.size());
614 }
615
TEST(GeneratedMessageReflectionTest,Oneof)616 TEST(GeneratedMessageReflectionTest, Oneof) {
617 unittest::TestOneof2 message;
618 const Descriptor* descriptor = message.GetDescriptor();
619 const Reflection* reflection = message.GetReflection();
620
621 // Check default values.
622 EXPECT_EQ(0, reflection->GetInt32(
623 message, descriptor->FindFieldByName("foo_int")));
624 EXPECT_EQ("", reflection->GetString(
625 message, descriptor->FindFieldByName("foo_string")));
626 EXPECT_EQ("", reflection->GetString(
627 message, descriptor->FindFieldByName("foo_cord")));
628 EXPECT_EQ("", reflection->GetString(
629 message, descriptor->FindFieldByName("foo_string_piece")));
630 EXPECT_EQ("", reflection->GetString(
631 message, descriptor->FindFieldByName("foo_bytes")));
632 EXPECT_EQ(unittest::TestOneof2::FOO, reflection->GetEnum(
633 message, descriptor->FindFieldByName("foo_enum"))->number());
634 EXPECT_EQ(&unittest::TestOneof2::NestedMessage::default_instance(),
635 &reflection->GetMessage(
636 message, descriptor->FindFieldByName("foo_message")));
637 EXPECT_EQ(&unittest::TestOneof2::FooGroup::default_instance(),
638 &reflection->GetMessage(
639 message, descriptor->FindFieldByName("foogroup")));
640 EXPECT_NE(&unittest::TestOneof2::FooGroup::default_instance(),
641 &reflection->GetMessage(
642 message, descriptor->FindFieldByName("foo_lazy_message")));
643 EXPECT_EQ(5, reflection->GetInt32(
644 message, descriptor->FindFieldByName("bar_int")));
645 EXPECT_EQ("STRING", reflection->GetString(
646 message, descriptor->FindFieldByName("bar_string")));
647 EXPECT_EQ("CORD", reflection->GetString(
648 message, descriptor->FindFieldByName("bar_cord")));
649 EXPECT_EQ("SPIECE", reflection->GetString(
650 message, descriptor->FindFieldByName("bar_string_piece")));
651 EXPECT_EQ("BYTES", reflection->GetString(
652 message, descriptor->FindFieldByName("bar_bytes")));
653 EXPECT_EQ(unittest::TestOneof2::BAR, reflection->GetEnum(
654 message, descriptor->FindFieldByName("bar_enum"))->number());
655
656 // Check Set functions.
657 reflection->SetInt32(
658 &message, descriptor->FindFieldByName("foo_int"), 123);
659 EXPECT_EQ(123, reflection->GetInt32(
660 message, descriptor->FindFieldByName("foo_int")));
661 reflection->SetString(
662 &message, descriptor->FindFieldByName("foo_string"), "abc");
663 EXPECT_EQ("abc", reflection->GetString(
664 message, descriptor->FindFieldByName("foo_string")));
665 reflection->SetString(
666 &message, descriptor->FindFieldByName("foo_bytes"), "bytes");
667 EXPECT_EQ("bytes", reflection->GetString(
668 message, descriptor->FindFieldByName("foo_bytes")));
669 reflection->SetString(
670 &message, descriptor->FindFieldByName("bar_cord"), "change_cord");
671 EXPECT_EQ("change_cord", reflection->GetString(
672 message, descriptor->FindFieldByName("bar_cord")));
673 reflection->SetString(
674 &message, descriptor->FindFieldByName("bar_string_piece"),
675 "change_spiece");
676 EXPECT_EQ("change_spiece", reflection->GetString(
677 message, descriptor->FindFieldByName("bar_string_piece")));
678 }
679
TEST(GeneratedMessageReflectionTest,SetAllocatedOneofMessageTest)680 TEST(GeneratedMessageReflectionTest, SetAllocatedOneofMessageTest) {
681 unittest::TestOneof2 from_message1;
682 unittest::TestOneof2 from_message2;
683 unittest::TestOneof2 to_message;
684 const Descriptor* descriptor = unittest::TestOneof2::descriptor();
685 const Reflection* reflection = to_message.GetReflection();
686
687 Message* released = reflection->ReleaseMessage(
688 &to_message, descriptor->FindFieldByName("foo_lazy_message"));
689 EXPECT_TRUE(released == NULL);
690 released = reflection->ReleaseMessage(
691 &to_message, descriptor->FindFieldByName("foo_message"));
692 EXPECT_TRUE(released == NULL);
693
694 TestUtil::ReflectionTester::SetOneofViaReflection(&from_message1);
695 TestUtil::ReflectionTester::ExpectOneofSetViaReflection(from_message1);
696
697 TestUtil::ReflectionTester::
698 SetAllocatedOptionalMessageFieldsToMessageViaReflection(
699 &from_message1, &to_message);
700 const Message& sub_message = reflection->GetMessage(
701 to_message, descriptor->FindFieldByName("foo_lazy_message"));
702 released = reflection->ReleaseMessage(
703 &to_message, descriptor->FindFieldByName("foo_lazy_message"));
704 EXPECT_TRUE(released != NULL);
705 EXPECT_EQ(&sub_message, released);
706 delete released;
707
708 TestUtil::ReflectionTester::SetOneofViaReflection(&from_message2);
709
710 reflection->MutableMessage(
711 &from_message2, descriptor->FindFieldByName("foo_message"));
712
713 TestUtil::ReflectionTester::
714 SetAllocatedOptionalMessageFieldsToMessageViaReflection(
715 &from_message2, &to_message);
716
717 const Message& sub_message2 = reflection->GetMessage(
718 to_message, descriptor->FindFieldByName("foo_message"));
719 released = reflection->ReleaseMessage(
720 &to_message, descriptor->FindFieldByName("foo_message"));
721 EXPECT_TRUE(released != NULL);
722 EXPECT_EQ(&sub_message2, released);
723 delete released;
724 }
725
TEST(GeneratedMessageReflectionTest,ReleaseMessageTest)726 TEST(GeneratedMessageReflectionTest, ReleaseMessageTest) {
727 unittest::TestAllTypes message;
728 TestUtil::ReflectionTester reflection_tester(
729 unittest::TestAllTypes::descriptor());
730
731 // When nothing is set, we expect all released messages to be NULL.
732 reflection_tester.ExpectMessagesReleasedViaReflection(
733 &message, TestUtil::ReflectionTester::IS_NULL);
734
735 // After fields are set we should get non-NULL releases.
736 reflection_tester.SetAllFieldsViaReflection(&message);
737 reflection_tester.ExpectMessagesReleasedViaReflection(
738 &message, TestUtil::ReflectionTester::NOT_NULL);
739
740 // After Clear() we may or may not get a message from ReleaseMessage().
741 // This is implementation specific.
742 reflection_tester.SetAllFieldsViaReflection(&message);
743 message.Clear();
744 reflection_tester.ExpectMessagesReleasedViaReflection(
745 &message, TestUtil::ReflectionTester::CAN_BE_NULL);
746
747 // Test a different code path for setting after releasing.
748 TestUtil::SetAllFields(&message);
749 TestUtil::ExpectAllFieldsSet(message);
750 }
751
TEST(GeneratedMessageReflectionTest,ReleaseExtensionMessageTest)752 TEST(GeneratedMessageReflectionTest, ReleaseExtensionMessageTest) {
753 unittest::TestAllExtensions message;
754 TestUtil::ReflectionTester reflection_tester(
755 unittest::TestAllExtensions::descriptor());
756
757 // When nothing is set, we expect all released messages to be NULL.
758 reflection_tester.ExpectMessagesReleasedViaReflection(
759 &message, TestUtil::ReflectionTester::IS_NULL);
760
761 // After fields are set we should get non-NULL releases.
762 reflection_tester.SetAllFieldsViaReflection(&message);
763 reflection_tester.ExpectMessagesReleasedViaReflection(
764 &message, TestUtil::ReflectionTester::NOT_NULL);
765
766 // After Clear() we may or may not get a message from ReleaseMessage().
767 // This is implementation specific.
768 reflection_tester.SetAllFieldsViaReflection(&message);
769 message.Clear();
770 reflection_tester.ExpectMessagesReleasedViaReflection(
771 &message, TestUtil::ReflectionTester::CAN_BE_NULL);
772
773 // Test a different code path for setting after releasing.
774 TestUtil::SetAllExtensions(&message);
775 TestUtil::ExpectAllExtensionsSet(message);
776 }
777
TEST(GeneratedMessageReflectionTest,ReleaseOneofMessageTest)778 TEST(GeneratedMessageReflectionTest, ReleaseOneofMessageTest) {
779 unittest::TestOneof2 message;
780 TestUtil::ReflectionTester::SetOneofViaReflection(&message);
781
782 const Descriptor* descriptor = unittest::TestOneof2::descriptor();
783 const Reflection* reflection = message.GetReflection();
784 const Message& sub_message = reflection->GetMessage(
785 message, descriptor->FindFieldByName("foo_lazy_message"));
786 Message* released = reflection->ReleaseMessage(
787 &message, descriptor->FindFieldByName("foo_lazy_message"));
788
789 EXPECT_TRUE(released != NULL);
790 EXPECT_EQ(&sub_message, released);
791 delete released;
792
793 released = reflection->ReleaseMessage(
794 &message, descriptor->FindFieldByName("foo_lazy_message"));
795 EXPECT_TRUE(released == NULL);
796 }
797
798 #ifdef PROTOBUF_HAS_DEATH_TEST
799
TEST(GeneratedMessageReflectionTest,UsageErrors)800 TEST(GeneratedMessageReflectionTest, UsageErrors) {
801 unittest::TestAllTypes message;
802 const Reflection* reflection = message.GetReflection();
803 const Descriptor* descriptor = message.GetDescriptor();
804
805 #define f(NAME) descriptor->FindFieldByName(NAME)
806
807 // Testing every single failure mode would be too much work. Let's just
808 // check a few.
809 EXPECT_DEATH(
810 reflection->GetInt32(
811 message, descriptor->FindFieldByName("optional_int64")),
812 "Protocol Buffer reflection usage error:\n"
813 " Method : google::protobuf::Reflection::GetInt32\n"
814 " Message type: protobuf_unittest\\.TestAllTypes\n"
815 " Field : protobuf_unittest\\.TestAllTypes\\.optional_int64\n"
816 " Problem : Field is not the right type for this message:\n"
817 " Expected : CPPTYPE_INT32\n"
818 " Field type: CPPTYPE_INT64");
819 EXPECT_DEATH(
820 reflection->GetInt32(
821 message, descriptor->FindFieldByName("repeated_int32")),
822 "Protocol Buffer reflection usage error:\n"
823 " Method : google::protobuf::Reflection::GetInt32\n"
824 " Message type: protobuf_unittest.TestAllTypes\n"
825 " Field : protobuf_unittest.TestAllTypes.repeated_int32\n"
826 " Problem : Field is repeated; the method requires a singular field.");
827 EXPECT_DEATH(
828 reflection->GetInt32(
829 message, unittest::ForeignMessage::descriptor()->FindFieldByName("c")),
830 "Protocol Buffer reflection usage error:\n"
831 " Method : google::protobuf::Reflection::GetInt32\n"
832 " Message type: protobuf_unittest.TestAllTypes\n"
833 " Field : protobuf_unittest.ForeignMessage.c\n"
834 " Problem : Field does not match message type.");
835 EXPECT_DEATH(
836 reflection->HasField(
837 message, unittest::ForeignMessage::descriptor()->FindFieldByName("c")),
838 "Protocol Buffer reflection usage error:\n"
839 " Method : google::protobuf::Reflection::HasField\n"
840 " Message type: protobuf_unittest.TestAllTypes\n"
841 " Field : protobuf_unittest.ForeignMessage.c\n"
842 " Problem : Field does not match message type.");
843
844 #undef f
845 }
846
847 #endif // PROTOBUF_HAS_DEATH_TEST
848
849
850 } // namespace
851 } // namespace protobuf
852 } // namespace google
853