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