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
47 #include <memory>
48
49 #include <google/protobuf/stubs/logging.h>
50 #include <google/protobuf/stubs/common.h>
51 #include <google/protobuf/test_util.h>
52 #include <google/protobuf/unittest.pb.h>
53 #include <google/protobuf/arena.h>
54 #include <google/protobuf/descriptor.h>
55 #include <google/protobuf/testing/googletest.h>
56 #include <gtest/gtest.h>
57
58 namespace google {
59 namespace protobuf {
60
61 namespace {
62
63 // Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes.
F(const std::string & name)64 const FieldDescriptor* F(const std::string& name) {
65 const FieldDescriptor* result =
66 unittest::TestAllTypes::descriptor()->FindFieldByName(name);
67 GOOGLE_CHECK(result != NULL);
68 return result;
69 }
70
TEST(GeneratedMessageReflectionTest,Defaults)71 TEST(GeneratedMessageReflectionTest, Defaults) {
72 // Check that all default values are set correctly in the initial message.
73 unittest::TestAllTypes message;
74 TestUtil::ReflectionTester reflection_tester(
75 unittest::TestAllTypes::descriptor());
76
77 reflection_tester.ExpectClearViaReflection(message);
78
79 const Reflection* reflection = message.GetReflection();
80
81 // Messages should return pointers to default instances until first use.
82 // (This is not checked by ExpectClear() since it is not actually true after
83 // the fields have been set and then cleared.)
84 EXPECT_EQ(&unittest::TestAllTypes::OptionalGroup::default_instance(),
85 &reflection->GetMessage(message, F("optionalgroup")));
86 EXPECT_EQ(&unittest::TestAllTypes::NestedMessage::default_instance(),
87 &reflection->GetMessage(message, F("optional_nested_message")));
88 EXPECT_EQ(&unittest::ForeignMessage::default_instance(),
89 &reflection->GetMessage(message, F("optional_foreign_message")));
90 EXPECT_EQ(&unittest_import::ImportMessage::default_instance(),
91 &reflection->GetMessage(message, F("optional_import_message")));
92 }
93
TEST(GeneratedMessageReflectionTest,Accessors)94 TEST(GeneratedMessageReflectionTest, Accessors) {
95 // Set every field to a unique value then go back and check all those
96 // values.
97 unittest::TestAllTypes message;
98 TestUtil::ReflectionTester reflection_tester(
99 unittest::TestAllTypes::descriptor());
100
101 reflection_tester.SetAllFieldsViaReflection(&message);
102 TestUtil::ExpectAllFieldsSet(message);
103 reflection_tester.ExpectAllFieldsSetViaReflection(message);
104
105 reflection_tester.ModifyRepeatedFieldsViaReflection(&message);
106 TestUtil::ExpectRepeatedFieldsModified(message);
107 }
108
TEST(GeneratedMessageReflectionTest,GetStringReference)109 TEST(GeneratedMessageReflectionTest, GetStringReference) {
110 // Test that GetStringReference() returns the underlying string when it
111 // is a normal string field.
112 unittest::TestAllTypes message;
113 message.set_optional_string("foo");
114 message.add_repeated_string("foo");
115
116 const Reflection* reflection = message.GetReflection();
117 std::string scratch;
118
119 EXPECT_EQ(
120 &message.optional_string(),
121 &reflection->GetStringReference(message, F("optional_string"), &scratch))
122 << "For simple string fields, GetStringReference() should return a "
123 "reference to the underlying string.";
124 EXPECT_EQ(&message.repeated_string(0),
125 &reflection->GetRepeatedStringReference(
126 message, F("repeated_string"), 0, &scratch))
127 << "For simple string fields, GetRepeatedStringReference() should "
128 "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
TEST(GeneratedMessageReflectionTest,Swap)155 TEST(GeneratedMessageReflectionTest, Swap) {
156 unittest::TestAllTypes message1;
157 unittest::TestAllTypes message2;
158
159 TestUtil::SetAllFields(&message1);
160
161 const Reflection* reflection = message1.GetReflection();
162 reflection->Swap(&message1, &message2);
163
164 TestUtil::ExpectClear(message1);
165 TestUtil::ExpectAllFieldsSet(message2);
166 }
167
TEST(GeneratedMessageReflectionTest,SwapWithBothSet)168 TEST(GeneratedMessageReflectionTest, SwapWithBothSet) {
169 unittest::TestAllTypes message1;
170 unittest::TestAllTypes message2;
171
172 TestUtil::SetAllFields(&message1);
173 TestUtil::SetAllFields(&message2);
174 TestUtil::ModifyRepeatedFields(&message2);
175
176 const Reflection* reflection = message1.GetReflection();
177 reflection->Swap(&message1, &message2);
178
179 TestUtil::ExpectRepeatedFieldsModified(message1);
180 TestUtil::ExpectAllFieldsSet(message2);
181
182 message1.set_optional_int32(532819);
183
184 reflection->Swap(&message1, &message2);
185
186 EXPECT_EQ(532819, message2.optional_int32());
187 }
188
TEST(GeneratedMessageReflectionTest,SwapExtensions)189 TEST(GeneratedMessageReflectionTest, SwapExtensions) {
190 unittest::TestAllExtensions message1;
191 unittest::TestAllExtensions message2;
192
193 TestUtil::SetAllExtensions(&message1);
194
195 const Reflection* reflection = message1.GetReflection();
196 reflection->Swap(&message1, &message2);
197
198 TestUtil::ExpectExtensionsClear(message1);
199 TestUtil::ExpectAllExtensionsSet(message2);
200 }
201
TEST(GeneratedMessageReflectionTest,SwapUnknown)202 TEST(GeneratedMessageReflectionTest, SwapUnknown) {
203 unittest::TestEmptyMessage message1, message2;
204
205 message1.mutable_unknown_fields()->AddVarint(1234, 1);
206
207 EXPECT_EQ(1, message1.unknown_fields().field_count());
208 EXPECT_EQ(0, message2.unknown_fields().field_count());
209 const Reflection* reflection = message1.GetReflection();
210 reflection->Swap(&message1, &message2);
211 EXPECT_EQ(0, message1.unknown_fields().field_count());
212 EXPECT_EQ(1, message2.unknown_fields().field_count());
213 }
214
TEST(GeneratedMessageReflectionTest,SwapFields)215 TEST(GeneratedMessageReflectionTest, SwapFields) {
216 unittest::TestAllTypes message1, message2;
217 message1.set_optional_double(12.3);
218 message1.mutable_repeated_int32()->Add(10);
219 message1.mutable_repeated_int32()->Add(20);
220
221 message2.set_optional_string("hello");
222 message2.mutable_repeated_int64()->Add(30);
223
224 std::vector<const FieldDescriptor*> fields;
225 const Descriptor* descriptor = message1.GetDescriptor();
226 fields.push_back(descriptor->FindFieldByName("optional_double"));
227 fields.push_back(descriptor->FindFieldByName("repeated_int32"));
228 fields.push_back(descriptor->FindFieldByName("optional_string"));
229 fields.push_back(descriptor->FindFieldByName("optional_uint64"));
230
231 const Reflection* reflection = message1.GetReflection();
232 reflection->SwapFields(&message1, &message2, fields);
233
234 EXPECT_FALSE(message1.has_optional_double());
235 EXPECT_EQ(0, message1.repeated_int32_size());
236 EXPECT_TRUE(message1.has_optional_string());
237 EXPECT_EQ("hello", message1.optional_string());
238 EXPECT_EQ(0, message1.repeated_int64_size());
239 EXPECT_FALSE(message1.has_optional_uint64());
240
241 EXPECT_TRUE(message2.has_optional_double());
242 EXPECT_EQ(12.3, message2.optional_double());
243 EXPECT_EQ(2, message2.repeated_int32_size());
244 EXPECT_EQ(10, message2.repeated_int32(0));
245 EXPECT_EQ(20, message2.repeated_int32(1));
246 EXPECT_FALSE(message2.has_optional_string());
247 EXPECT_EQ(1, message2.repeated_int64_size());
248 EXPECT_FALSE(message2.has_optional_uint64());
249 }
250
TEST(GeneratedMessageReflectionTest,SwapFieldsAll)251 TEST(GeneratedMessageReflectionTest, SwapFieldsAll) {
252 unittest::TestAllTypes message1;
253 unittest::TestAllTypes message2;
254
255 TestUtil::SetAllFields(&message2);
256
257 std::vector<const FieldDescriptor*> fields;
258 const Reflection* reflection = message1.GetReflection();
259 reflection->ListFields(message2, &fields);
260 reflection->SwapFields(&message1, &message2, fields);
261
262 TestUtil::ExpectAllFieldsSet(message1);
263 TestUtil::ExpectClear(message2);
264 }
265
TEST(GeneratedMessageReflectionTest,SwapFieldsAllExtension)266 TEST(GeneratedMessageReflectionTest, SwapFieldsAllExtension) {
267 unittest::TestAllExtensions message1;
268 unittest::TestAllExtensions message2;
269
270 TestUtil::SetAllExtensions(&message1);
271
272 std::vector<const FieldDescriptor*> fields;
273 const Reflection* reflection = message1.GetReflection();
274 reflection->ListFields(message1, &fields);
275 reflection->SwapFields(&message1, &message2, fields);
276
277 TestUtil::ExpectExtensionsClear(message1);
278 TestUtil::ExpectAllExtensionsSet(message2);
279 }
280
TEST(GeneratedMessageReflectionTest,SwapOneof)281 TEST(GeneratedMessageReflectionTest, SwapOneof) {
282 unittest::TestOneof2 message1, message2;
283 TestUtil::SetOneof1(&message1);
284
285 const Reflection* reflection = message1.GetReflection();
286 reflection->Swap(&message1, &message2);
287
288 TestUtil::ExpectOneofClear(message1);
289 TestUtil::ExpectOneofSet1(message2);
290 }
291
TEST(GeneratedMessageReflectionTest,SwapOneofBothSet)292 TEST(GeneratedMessageReflectionTest, SwapOneofBothSet) {
293 unittest::TestOneof2 message1, message2;
294 TestUtil::SetOneof1(&message1);
295 TestUtil::SetOneof2(&message2);
296
297 const Reflection* reflection = message1.GetReflection();
298 reflection->Swap(&message1, &message2);
299
300 TestUtil::ExpectOneofSet2(message1);
301 TestUtil::ExpectOneofSet1(message2);
302 }
303
TEST(GeneratedMessageReflectionTest,SwapFieldsOneof)304 TEST(GeneratedMessageReflectionTest, SwapFieldsOneof) {
305 unittest::TestOneof2 message1, message2;
306 TestUtil::SetOneof1(&message1);
307
308 std::vector<const FieldDescriptor*> fields;
309 const Descriptor* descriptor = message1.GetDescriptor();
310 for (int i = 0; i < descriptor->field_count(); i++) {
311 fields.push_back(descriptor->field(i));
312 }
313 const Reflection* reflection = message1.GetReflection();
314 reflection->SwapFields(&message1, &message2, fields);
315
316 TestUtil::ExpectOneofClear(message1);
317 TestUtil::ExpectOneofSet1(message2);
318 }
319
TEST(GeneratedMessageReflectionTest,RemoveLast)320 TEST(GeneratedMessageReflectionTest, RemoveLast) {
321 unittest::TestAllTypes message;
322 TestUtil::ReflectionTester reflection_tester(
323 unittest::TestAllTypes::descriptor());
324
325 TestUtil::SetAllFields(&message);
326
327 reflection_tester.RemoveLastRepeatedsViaReflection(&message);
328
329 TestUtil::ExpectLastRepeatedsRemoved(message);
330 }
331
TEST(GeneratedMessageReflectionTest,RemoveLastExtensions)332 TEST(GeneratedMessageReflectionTest, RemoveLastExtensions) {
333 unittest::TestAllExtensions message;
334 TestUtil::ReflectionTester reflection_tester(
335 unittest::TestAllExtensions::descriptor());
336
337 TestUtil::SetAllExtensions(&message);
338
339 reflection_tester.RemoveLastRepeatedsViaReflection(&message);
340
341 TestUtil::ExpectLastRepeatedExtensionsRemoved(message);
342 }
343
TEST(GeneratedMessageReflectionTest,ReleaseLast)344 TEST(GeneratedMessageReflectionTest, ReleaseLast) {
345 unittest::TestAllTypes message;
346 const Descriptor* descriptor = message.GetDescriptor();
347 TestUtil::ReflectionTester reflection_tester(descriptor);
348
349 TestUtil::SetAllFields(&message);
350
351 reflection_tester.ReleaseLastRepeatedsViaReflection(&message, false);
352
353 TestUtil::ExpectLastRepeatedsReleased(message);
354
355 // Now test that we actually release the right message.
356 message.Clear();
357 TestUtil::SetAllFields(&message);
358 ASSERT_EQ(2, message.repeated_foreign_message_size());
359 const protobuf_unittest::ForeignMessage* expected =
360 message.mutable_repeated_foreign_message(1);
361 std::unique_ptr<Message> released(message.GetReflection()->ReleaseLast(
362 &message, descriptor->FindFieldByName("repeated_foreign_message")));
363 EXPECT_EQ(expected, released.get());
364 }
365
TEST(GeneratedMessageReflectionTest,ReleaseLastExtensions)366 TEST(GeneratedMessageReflectionTest, ReleaseLastExtensions) {
367 unittest::TestAllExtensions message;
368 const Descriptor* descriptor = message.GetDescriptor();
369 TestUtil::ReflectionTester reflection_tester(descriptor);
370
371 TestUtil::SetAllExtensions(&message);
372
373 reflection_tester.ReleaseLastRepeatedsViaReflection(&message, true);
374
375 TestUtil::ExpectLastRepeatedExtensionsReleased(message);
376
377 // Now test that we actually release the right message.
378 message.Clear();
379 TestUtil::SetAllExtensions(&message);
380 ASSERT_EQ(
381 2, message.ExtensionSize(unittest::repeated_foreign_message_extension));
382 const protobuf_unittest::ForeignMessage* expected =
383 message.MutableExtension(unittest::repeated_foreign_message_extension, 1);
384 std::unique_ptr<Message> released(message.GetReflection()->ReleaseLast(
385 &message, descriptor->file()->FindExtensionByName(
386 "repeated_foreign_message_extension")));
387 EXPECT_EQ(expected, released.get());
388 }
389
TEST(GeneratedMessageReflectionTest,SwapRepeatedElements)390 TEST(GeneratedMessageReflectionTest, SwapRepeatedElements) {
391 unittest::TestAllTypes message;
392 TestUtil::ReflectionTester reflection_tester(
393 unittest::TestAllTypes::descriptor());
394
395 TestUtil::SetAllFields(&message);
396
397 // Swap and test that fields are all swapped.
398 reflection_tester.SwapRepeatedsViaReflection(&message);
399 TestUtil::ExpectRepeatedsSwapped(message);
400
401 // Swap back and test that fields are all back to original values.
402 reflection_tester.SwapRepeatedsViaReflection(&message);
403 TestUtil::ExpectAllFieldsSet(message);
404 }
405
TEST(GeneratedMessageReflectionTest,SwapRepeatedElementsExtension)406 TEST(GeneratedMessageReflectionTest, SwapRepeatedElementsExtension) {
407 unittest::TestAllExtensions message;
408 TestUtil::ReflectionTester reflection_tester(
409 unittest::TestAllExtensions::descriptor());
410
411 TestUtil::SetAllExtensions(&message);
412
413 // Swap and test that fields are all swapped.
414 reflection_tester.SwapRepeatedsViaReflection(&message);
415 TestUtil::ExpectRepeatedExtensionsSwapped(message);
416
417 // Swap back and test that fields are all back to original values.
418 reflection_tester.SwapRepeatedsViaReflection(&message);
419 TestUtil::ExpectAllExtensionsSet(message);
420 }
421
TEST(GeneratedMessageReflectionTest,Extensions)422 TEST(GeneratedMessageReflectionTest, Extensions) {
423 // Set every extension to a unique value then go back and check all those
424 // values.
425 unittest::TestAllExtensions message;
426 TestUtil::ReflectionTester reflection_tester(
427 unittest::TestAllExtensions::descriptor());
428
429 reflection_tester.SetAllFieldsViaReflection(&message);
430 TestUtil::ExpectAllExtensionsSet(message);
431 reflection_tester.ExpectAllFieldsSetViaReflection(message);
432
433 reflection_tester.ModifyRepeatedFieldsViaReflection(&message);
434 TestUtil::ExpectRepeatedExtensionsModified(message);
435 }
436
TEST(GeneratedMessageReflectionTest,FindExtensionTypeByNumber)437 TEST(GeneratedMessageReflectionTest, FindExtensionTypeByNumber) {
438 const Reflection* reflection =
439 unittest::TestAllExtensions::default_instance().GetReflection();
440
441 const FieldDescriptor* extension1 =
442 unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
443 "optional_int32_extension");
444 const FieldDescriptor* extension2 =
445 unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
446 "repeated_string_extension");
447
448 EXPECT_EQ(extension1,
449 reflection->FindKnownExtensionByNumber(extension1->number()));
450 EXPECT_EQ(extension2,
451 reflection->FindKnownExtensionByNumber(extension2->number()));
452
453 // Non-existent extension.
454 EXPECT_TRUE(reflection->FindKnownExtensionByNumber(62341) == NULL);
455
456 // Extensions of TestAllExtensions should not show up as extensions of
457 // other types.
458 EXPECT_TRUE(unittest::TestAllTypes::default_instance()
459 .GetReflection()
460 ->FindKnownExtensionByNumber(extension1->number()) == NULL);
461 }
462
TEST(GeneratedMessageReflectionTest,FindKnownExtensionByName)463 TEST(GeneratedMessageReflectionTest, FindKnownExtensionByName) {
464 const Reflection* reflection =
465 unittest::TestAllExtensions::default_instance().GetReflection();
466
467 const FieldDescriptor* extension1 =
468 unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
469 "optional_int32_extension");
470 const FieldDescriptor* extension2 =
471 unittest::TestAllExtensions::descriptor()->file()->FindExtensionByName(
472 "repeated_string_extension");
473
474 EXPECT_EQ(extension1,
475 reflection->FindKnownExtensionByName(extension1->full_name()));
476 EXPECT_EQ(extension2,
477 reflection->FindKnownExtensionByName(extension2->full_name()));
478
479 // Non-existent extension.
480 EXPECT_TRUE(reflection->FindKnownExtensionByName("no_such_ext") == NULL);
481
482 // Extensions of TestAllExtensions should not show up as extensions of
483 // other types.
484 EXPECT_TRUE(unittest::TestAllTypes::default_instance()
485 .GetReflection()
486 ->FindKnownExtensionByName(extension1->full_name()) == NULL);
487 }
488
489
TEST(GeneratedMessageReflectionTest,SetAllocatedMessageTest)490 TEST(GeneratedMessageReflectionTest, SetAllocatedMessageTest) {
491 unittest::TestAllTypes from_message1;
492 unittest::TestAllTypes from_message2;
493 unittest::TestAllTypes to_message;
494 TestUtil::ReflectionTester reflection_tester(
495 unittest::TestAllTypes::descriptor());
496 reflection_tester.SetAllFieldsViaReflection(&from_message1);
497 reflection_tester.SetAllFieldsViaReflection(&from_message2);
498
499 // Before moving fields, we expect the nested messages to be NULL.
500 reflection_tester.ExpectMessagesReleasedViaReflection(
501 &to_message, TestUtil::ReflectionTester::IS_NULL);
502
503 // After fields are moved we should get non-NULL releases.
504 reflection_tester.SetAllocatedOptionalMessageFieldsToMessageViaReflection(
505 &from_message1, &to_message);
506 reflection_tester.ExpectMessagesReleasedViaReflection(
507 &to_message, TestUtil::ReflectionTester::NOT_NULL);
508
509 // Another move to make sure that we can SetAllocated several times.
510 reflection_tester.SetAllocatedOptionalMessageFieldsToMessageViaReflection(
511 &from_message2, &to_message);
512 reflection_tester.ExpectMessagesReleasedViaReflection(
513 &to_message, TestUtil::ReflectionTester::NOT_NULL);
514
515 // After SetAllocatedOptionalMessageFieldsToNullViaReflection() we expect the
516 // releases to be NULL again.
517 reflection_tester.SetAllocatedOptionalMessageFieldsToNullViaReflection(
518 &to_message);
519 reflection_tester.ExpectMessagesReleasedViaReflection(
520 &to_message, TestUtil::ReflectionTester::IS_NULL);
521 }
522
TEST(GeneratedMessageReflectionTest,SetAllocatedMessageOnArenaTest)523 TEST(GeneratedMessageReflectionTest, SetAllocatedMessageOnArenaTest) {
524 unittest::TestAllTypes from_message1;
525 unittest::TestAllTypes from_message2;
526 Arena arena;
527 unittest::TestAllTypes* to_message =
528 Arena::CreateMessage<unittest::TestAllTypes>(&arena);
529 TestUtil::ReflectionTester reflection_tester(
530 unittest::TestAllTypes::descriptor());
531 reflection_tester.SetAllFieldsViaReflection(&from_message1);
532 reflection_tester.SetAllFieldsViaReflection(&from_message2);
533
534 // Before moving fields, we expect the nested messages to be NULL.
535 reflection_tester.ExpectMessagesReleasedViaReflection(
536 to_message, TestUtil::ReflectionTester::IS_NULL);
537
538 // After fields are moved we should get non-NULL releases.
539 reflection_tester.SetAllocatedOptionalMessageFieldsToMessageViaReflection(
540 &from_message1, to_message);
541 reflection_tester.ExpectMessagesReleasedViaReflection(
542 to_message, TestUtil::ReflectionTester::NOT_NULL);
543
544 // Another move to make sure that we can SetAllocated several times.
545 reflection_tester.SetAllocatedOptionalMessageFieldsToMessageViaReflection(
546 &from_message2, to_message);
547 reflection_tester.ExpectMessagesReleasedViaReflection(
548 to_message, TestUtil::ReflectionTester::NOT_NULL);
549
550 // After SetAllocatedOptionalMessageFieldsToNullViaReflection() we expect the
551 // releases to be NULL again.
552 reflection_tester.SetAllocatedOptionalMessageFieldsToNullViaReflection(
553 to_message);
554 reflection_tester.ExpectMessagesReleasedViaReflection(
555 to_message, TestUtil::ReflectionTester::IS_NULL);
556 }
557
TEST(GeneratedMessageReflectionTest,SetAllocatedExtensionMessageTest)558 TEST(GeneratedMessageReflectionTest, SetAllocatedExtensionMessageTest) {
559 unittest::TestAllExtensions from_message1;
560 unittest::TestAllExtensions from_message2;
561 unittest::TestAllExtensions to_message;
562 TestUtil::ReflectionTester reflection_tester(
563 unittest::TestAllExtensions::descriptor());
564 reflection_tester.SetAllFieldsViaReflection(&from_message1);
565 reflection_tester.SetAllFieldsViaReflection(&from_message2);
566
567 // Before moving fields, we expect the nested messages to be NULL.
568 reflection_tester.ExpectMessagesReleasedViaReflection(
569 &to_message, TestUtil::ReflectionTester::IS_NULL);
570
571 // After fields are moved we should get non-NULL releases.
572 reflection_tester.SetAllocatedOptionalMessageFieldsToMessageViaReflection(
573 &from_message1, &to_message);
574 reflection_tester.ExpectMessagesReleasedViaReflection(
575 &to_message, TestUtil::ReflectionTester::NOT_NULL);
576
577 // Another move to make sure that we can SetAllocated several times.
578 reflection_tester.SetAllocatedOptionalMessageFieldsToMessageViaReflection(
579 &from_message2, &to_message);
580 reflection_tester.ExpectMessagesReleasedViaReflection(
581 &to_message, TestUtil::ReflectionTester::NOT_NULL);
582
583 // After SetAllocatedOptionalMessageFieldsToNullViaReflection() we expect the
584 // releases to be NULL again.
585 reflection_tester.SetAllocatedOptionalMessageFieldsToNullViaReflection(
586 &to_message);
587 reflection_tester.ExpectMessagesReleasedViaReflection(
588 &to_message, TestUtil::ReflectionTester::IS_NULL);
589 }
590
TEST(GeneratedMessageReflectionTest,SetAllocatedExtensionMessageOnArenaTest)591 TEST(GeneratedMessageReflectionTest, SetAllocatedExtensionMessageOnArenaTest) {
592 Arena arena;
593 unittest::TestAllExtensions* to_message =
594 Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
595 unittest::TestAllExtensions from_message1;
596 unittest::TestAllExtensions from_message2;
597 TestUtil::ReflectionTester reflection_tester(
598 unittest::TestAllExtensions::descriptor());
599 reflection_tester.SetAllFieldsViaReflection(&from_message1);
600 reflection_tester.SetAllFieldsViaReflection(&from_message2);
601
602 // Before moving fields, we expect the nested messages to be NULL.
603 reflection_tester.ExpectMessagesReleasedViaReflection(
604 to_message, TestUtil::ReflectionTester::IS_NULL);
605
606 // After fields are moved we should get non-NULL releases.
607 reflection_tester.SetAllocatedOptionalMessageFieldsToMessageViaReflection(
608 &from_message1, to_message);
609 reflection_tester.ExpectMessagesReleasedViaReflection(
610 to_message, TestUtil::ReflectionTester::NOT_NULL);
611
612 // Another move to make sure that we can SetAllocated several times.
613 reflection_tester.SetAllocatedOptionalMessageFieldsToMessageViaReflection(
614 &from_message2, to_message);
615 reflection_tester.ExpectMessagesReleasedViaReflection(
616 to_message, TestUtil::ReflectionTester::NOT_NULL);
617
618 // After SetAllocatedOptionalMessageFieldsToNullViaReflection() we expect the
619 // releases to be NULL again.
620 reflection_tester.SetAllocatedOptionalMessageFieldsToNullViaReflection(
621 to_message);
622 reflection_tester.ExpectMessagesReleasedViaReflection(
623 to_message, TestUtil::ReflectionTester::IS_NULL);
624 }
625
TEST(GeneratedMessageReflectionTest,AddRepeatedMessage)626 TEST(GeneratedMessageReflectionTest, AddRepeatedMessage) {
627 unittest::TestAllTypes message;
628
629 const Reflection* reflection = message.GetReflection();
630 const Reflection* nested_reflection =
631 unittest::TestAllTypes::NestedMessage::default_instance().GetReflection();
632
633 const FieldDescriptor* nested_bb =
634 unittest::TestAllTypes::NestedMessage::descriptor()->FindFieldByName(
635 "bb");
636
637 Message* nested =
638 reflection->AddMessage(&message, F("repeated_nested_message"));
639 nested_reflection->SetInt32(nested, nested_bb, 11);
640
641 EXPECT_EQ(11, message.repeated_nested_message(0).bb());
642 }
643
TEST(GeneratedMessageReflectionTest,MutableRepeatedMessage)644 TEST(GeneratedMessageReflectionTest, MutableRepeatedMessage) {
645 unittest::TestAllTypes message;
646
647 const Reflection* reflection = message.GetReflection();
648 const Reflection* nested_reflection =
649 unittest::TestAllTypes::NestedMessage::default_instance().GetReflection();
650
651 const FieldDescriptor* nested_bb =
652 unittest::TestAllTypes::NestedMessage::descriptor()->FindFieldByName(
653 "bb");
654
655 message.add_repeated_nested_message()->set_bb(12);
656
657 Message* nested = reflection->MutableRepeatedMessage(
658 &message, F("repeated_nested_message"), 0);
659 EXPECT_EQ(12, nested_reflection->GetInt32(*nested, nested_bb));
660 nested_reflection->SetInt32(nested, nested_bb, 13);
661 EXPECT_EQ(13, message.repeated_nested_message(0).bb());
662 }
663
TEST(GeneratedMessageReflectionTest,AddAllocatedMessage)664 TEST(GeneratedMessageReflectionTest, AddAllocatedMessage) {
665 unittest::TestAllTypes message;
666
667 const Reflection* reflection = message.GetReflection();
668
669 unittest::TestAllTypes::NestedMessage* nested =
670 new unittest::TestAllTypes::NestedMessage();
671 nested->set_bb(11);
672 reflection->AddAllocatedMessage(&message, F("repeated_nested_message"),
673 nested);
674 EXPECT_EQ(1, message.repeated_nested_message_size());
675 EXPECT_EQ(11, message.repeated_nested_message(0).bb());
676 }
677
TEST(GeneratedMessageReflectionTest,ListFieldsOneOf)678 TEST(GeneratedMessageReflectionTest, ListFieldsOneOf) {
679 unittest::TestOneof2 message;
680 TestUtil::SetOneof1(&message);
681
682 const Reflection* reflection = message.GetReflection();
683 std::vector<const FieldDescriptor*> fields;
684 reflection->ListFields(message, &fields);
685 EXPECT_EQ(4, fields.size());
686 }
687
TEST(GeneratedMessageReflectionTest,Oneof)688 TEST(GeneratedMessageReflectionTest, Oneof) {
689 unittest::TestOneof2 message;
690 const Descriptor* descriptor = message.GetDescriptor();
691 const Reflection* reflection = message.GetReflection();
692
693 // Check default values.
694 EXPECT_EQ(
695 0, reflection->GetInt32(message, descriptor->FindFieldByName("foo_int")));
696 EXPECT_EQ("", reflection->GetString(
697 message, descriptor->FindFieldByName("foo_string")));
698 EXPECT_EQ("", reflection->GetString(message,
699 descriptor->FindFieldByName("foo_cord")));
700 EXPECT_EQ("", reflection->GetString(
701 message, descriptor->FindFieldByName("foo_string_piece")));
702 EXPECT_EQ("", reflection->GetString(
703 message, descriptor->FindFieldByName("foo_bytes")));
704 EXPECT_EQ(
705 unittest::TestOneof2::FOO,
706 reflection->GetEnum(message, descriptor->FindFieldByName("foo_enum"))
707 ->number());
708 EXPECT_EQ(&unittest::TestOneof2::NestedMessage::default_instance(),
709 &reflection->GetMessage(
710 message, descriptor->FindFieldByName("foo_message")));
711 EXPECT_EQ(&unittest::TestOneof2::FooGroup::default_instance(),
712 &reflection->GetMessage(message,
713 descriptor->FindFieldByName("foogroup")));
714 EXPECT_NE(&unittest::TestOneof2::FooGroup::default_instance(),
715 &reflection->GetMessage(
716 message, descriptor->FindFieldByName("foo_lazy_message")));
717 EXPECT_EQ(
718 5, reflection->GetInt32(message, descriptor->FindFieldByName("bar_int")));
719 EXPECT_EQ("STRING", reflection->GetString(
720 message, descriptor->FindFieldByName("bar_string")));
721 EXPECT_EQ("CORD", reflection->GetString(
722 message, descriptor->FindFieldByName("bar_cord")));
723 EXPECT_EQ("SPIECE",
724 reflection->GetString(
725 message, descriptor->FindFieldByName("bar_string_piece")));
726 EXPECT_EQ("BYTES", reflection->GetString(
727 message, descriptor->FindFieldByName("bar_bytes")));
728 EXPECT_EQ(
729 unittest::TestOneof2::BAR,
730 reflection->GetEnum(message, descriptor->FindFieldByName("bar_enum"))
731 ->number());
732
733 // Check Set functions.
734 reflection->SetInt32(&message, descriptor->FindFieldByName("foo_int"), 123);
735 EXPECT_EQ(123, reflection->GetInt32(message,
736 descriptor->FindFieldByName("foo_int")));
737 reflection->SetString(&message, descriptor->FindFieldByName("foo_string"),
738 "abc");
739 EXPECT_EQ("abc", reflection->GetString(
740 message, descriptor->FindFieldByName("foo_string")));
741 reflection->SetString(&message, descriptor->FindFieldByName("foo_bytes"),
742 "bytes");
743 EXPECT_EQ("bytes", reflection->GetString(
744 message, descriptor->FindFieldByName("foo_bytes")));
745 reflection->SetString(&message, descriptor->FindFieldByName("bar_cord"),
746 "change_cord");
747 EXPECT_EQ(
748 "change_cord",
749 reflection->GetString(message, descriptor->FindFieldByName("bar_cord")));
750 reflection->SetString(&message,
751 descriptor->FindFieldByName("bar_string_piece"),
752 "change_spiece");
753 EXPECT_EQ("change_spiece",
754 reflection->GetString(
755 message, descriptor->FindFieldByName("bar_string_piece")));
756
757 message.clear_foo();
758 message.clear_bar();
759 TestUtil::ExpectOneofClear(message);
760 }
761
TEST(GeneratedMessageReflectionTest,SetAllocatedOneofMessageTest)762 TEST(GeneratedMessageReflectionTest, SetAllocatedOneofMessageTest) {
763 unittest::TestOneof2 from_message1;
764 unittest::TestOneof2 from_message2;
765 unittest::TestOneof2 to_message;
766 const Descriptor* descriptor = unittest::TestOneof2::descriptor();
767 const Reflection* reflection = to_message.GetReflection();
768
769 Message* released = reflection->ReleaseMessage(
770 &to_message, descriptor->FindFieldByName("foo_lazy_message"));
771 EXPECT_TRUE(released == NULL);
772 released = reflection->ReleaseMessage(
773 &to_message, descriptor->FindFieldByName("foo_message"));
774 EXPECT_TRUE(released == NULL);
775
776 TestUtil::ReflectionTester::SetOneofViaReflection(&from_message1);
777 TestUtil::ReflectionTester::ExpectOneofSetViaReflection(from_message1);
778
779 TestUtil::ReflectionTester::
780 SetAllocatedOptionalMessageFieldsToMessageViaReflection(&from_message1,
781 &to_message);
782 const Message& sub_message = reflection->GetMessage(
783 to_message, descriptor->FindFieldByName("foo_lazy_message"));
784 released = reflection->ReleaseMessage(
785 &to_message, descriptor->FindFieldByName("foo_lazy_message"));
786 EXPECT_TRUE(released != NULL);
787 EXPECT_EQ(&sub_message, released);
788 delete released;
789
790 TestUtil::ReflectionTester::SetOneofViaReflection(&from_message2);
791
792 reflection->MutableMessage(&from_message2,
793 descriptor->FindFieldByName("foo_message"));
794
795 TestUtil::ReflectionTester::
796 SetAllocatedOptionalMessageFieldsToMessageViaReflection(&from_message2,
797 &to_message);
798
799 const Message& sub_message2 = reflection->GetMessage(
800 to_message, descriptor->FindFieldByName("foo_message"));
801 released = reflection->ReleaseMessage(
802 &to_message, descriptor->FindFieldByName("foo_message"));
803 EXPECT_TRUE(released != NULL);
804 EXPECT_EQ(&sub_message2, released);
805 delete released;
806 }
807
TEST(GeneratedMessageReflectionTest,SetAllocatedOneofMessageOnArenaTest)808 TEST(GeneratedMessageReflectionTest, SetAllocatedOneofMessageOnArenaTest) {
809 unittest::TestOneof2 from_message1;
810 unittest::TestOneof2 from_message2;
811 Arena arena;
812 unittest::TestOneof2* to_message =
813 Arena::CreateMessage<unittest::TestOneof2>(&arena);
814 const Descriptor* descriptor = unittest::TestOneof2::descriptor();
815 const Reflection* reflection = to_message->GetReflection();
816
817 Message* released = reflection->ReleaseMessage(
818 to_message, descriptor->FindFieldByName("foo_lazy_message"));
819 EXPECT_TRUE(released == NULL);
820 released = reflection->ReleaseMessage(
821 to_message, descriptor->FindFieldByName("foo_message"));
822 EXPECT_TRUE(released == NULL);
823
824 TestUtil::ReflectionTester::SetOneofViaReflection(&from_message1);
825 TestUtil::ReflectionTester::ExpectOneofSetViaReflection(from_message1);
826
827 TestUtil::ReflectionTester::
828 SetAllocatedOptionalMessageFieldsToMessageViaReflection(&from_message1,
829 to_message);
830 const Message& sub_message = reflection->GetMessage(
831 *to_message, descriptor->FindFieldByName("foo_lazy_message"));
832 released = reflection->ReleaseMessage(
833 to_message, descriptor->FindFieldByName("foo_lazy_message"));
834 EXPECT_TRUE(released != NULL);
835 // Since sub_message is arena allocated, releasing it results in copying it
836 // into new heap-allocated memory.
837 EXPECT_NE(&sub_message, released);
838 delete released;
839
840 TestUtil::ReflectionTester::SetOneofViaReflection(&from_message2);
841
842 reflection->MutableMessage(&from_message2,
843 descriptor->FindFieldByName("foo_message"));
844
845 TestUtil::ReflectionTester::
846 SetAllocatedOptionalMessageFieldsToMessageViaReflection(&from_message2,
847 to_message);
848
849 const Message& sub_message2 = reflection->GetMessage(
850 *to_message, descriptor->FindFieldByName("foo_message"));
851 released = reflection->ReleaseMessage(
852 to_message, descriptor->FindFieldByName("foo_message"));
853 EXPECT_TRUE(released != NULL);
854 // Since sub_message2 is arena allocated, releasing it results in copying it
855 // into new heap-allocated memory.
856 EXPECT_NE(&sub_message2, released);
857 delete released;
858 }
859
TEST(GeneratedMessageReflectionTest,ReleaseMessageTest)860 TEST(GeneratedMessageReflectionTest, ReleaseMessageTest) {
861 unittest::TestAllTypes message;
862 TestUtil::ReflectionTester reflection_tester(
863 unittest::TestAllTypes::descriptor());
864
865 // When nothing is set, we expect all released messages to be NULL.
866 reflection_tester.ExpectMessagesReleasedViaReflection(
867 &message, TestUtil::ReflectionTester::IS_NULL);
868
869 // After fields are set we should get non-NULL releases.
870 reflection_tester.SetAllFieldsViaReflection(&message);
871 reflection_tester.ExpectMessagesReleasedViaReflection(
872 &message, TestUtil::ReflectionTester::NOT_NULL);
873
874 // After Clear() we may or may not get a message from ReleaseMessage().
875 // This is implementation specific.
876 reflection_tester.SetAllFieldsViaReflection(&message);
877 message.Clear();
878 reflection_tester.ExpectMessagesReleasedViaReflection(
879 &message, TestUtil::ReflectionTester::CAN_BE_NULL);
880
881 // Test a different code path for setting after releasing.
882 TestUtil::SetAllFields(&message);
883 TestUtil::ExpectAllFieldsSet(message);
884 }
885
TEST(GeneratedMessageReflectionTest,ReleaseExtensionMessageTest)886 TEST(GeneratedMessageReflectionTest, ReleaseExtensionMessageTest) {
887 unittest::TestAllExtensions message;
888 TestUtil::ReflectionTester reflection_tester(
889 unittest::TestAllExtensions::descriptor());
890
891 // When nothing is set, we expect all released messages to be NULL.
892 reflection_tester.ExpectMessagesReleasedViaReflection(
893 &message, TestUtil::ReflectionTester::IS_NULL);
894
895 // After fields are set we should get non-NULL releases.
896 reflection_tester.SetAllFieldsViaReflection(&message);
897 reflection_tester.ExpectMessagesReleasedViaReflection(
898 &message, TestUtil::ReflectionTester::NOT_NULL);
899
900 // After Clear() we may or may not get a message from ReleaseMessage().
901 // This is implementation specific.
902 reflection_tester.SetAllFieldsViaReflection(&message);
903 message.Clear();
904 reflection_tester.ExpectMessagesReleasedViaReflection(
905 &message, TestUtil::ReflectionTester::CAN_BE_NULL);
906
907 // Test a different code path for setting after releasing.
908 TestUtil::SetAllExtensions(&message);
909 TestUtil::ExpectAllExtensionsSet(message);
910 }
911
TEST(GeneratedMessageReflectionTest,ReleaseOneofMessageTest)912 TEST(GeneratedMessageReflectionTest, ReleaseOneofMessageTest) {
913 unittest::TestOneof2 message;
914 TestUtil::ReflectionTester::SetOneofViaReflection(&message);
915
916 const Descriptor* descriptor = unittest::TestOneof2::descriptor();
917 const Reflection* reflection = message.GetReflection();
918 const Message& sub_message = reflection->GetMessage(
919 message, descriptor->FindFieldByName("foo_lazy_message"));
920 Message* released = reflection->ReleaseMessage(
921 &message, descriptor->FindFieldByName("foo_lazy_message"));
922
923 EXPECT_TRUE(released != NULL);
924 EXPECT_EQ(&sub_message, released);
925 delete released;
926
927 released = reflection->ReleaseMessage(
928 &message, descriptor->FindFieldByName("foo_lazy_message"));
929 EXPECT_TRUE(released == NULL);
930 }
931
TEST(GeneratedMessageReflectionTest,ArenaReleaseMessageTest)932 TEST(GeneratedMessageReflectionTest, ArenaReleaseMessageTest) {
933 Arena arena;
934 unittest::TestAllTypes* message =
935 Arena::CreateMessage<unittest::TestAllTypes>(&arena);
936 TestUtil::ReflectionTester reflection_tester(
937 unittest::TestAllTypes::descriptor());
938
939 // When nothing is set, we expect all released messages to be NULL.
940 reflection_tester.ExpectMessagesReleasedViaReflection(
941 message, TestUtil::ReflectionTester::IS_NULL);
942
943 // After fields are set we should get non-NULL releases.
944 reflection_tester.SetAllFieldsViaReflection(message);
945 reflection_tester.ExpectMessagesReleasedViaReflection(
946 message, TestUtil::ReflectionTester::NOT_NULL);
947
948 // After Clear() we may or may not get a message from ReleaseMessage().
949 // This is implementation specific.
950 reflection_tester.SetAllFieldsViaReflection(message);
951 message->Clear();
952 reflection_tester.ExpectMessagesReleasedViaReflection(
953 message, TestUtil::ReflectionTester::CAN_BE_NULL);
954 }
955
TEST(GeneratedMessageReflectionTest,ArenaReleaseExtensionMessageTest)956 TEST(GeneratedMessageReflectionTest, ArenaReleaseExtensionMessageTest) {
957 Arena arena;
958 unittest::TestAllExtensions* message =
959 Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
960 TestUtil::ReflectionTester reflection_tester(
961 unittest::TestAllExtensions::descriptor());
962
963 // When nothing is set, we expect all released messages to be NULL.
964 reflection_tester.ExpectMessagesReleasedViaReflection(
965 message, TestUtil::ReflectionTester::IS_NULL);
966
967 // After fields are set we should get non-NULL releases.
968 reflection_tester.SetAllFieldsViaReflection(message);
969 reflection_tester.ExpectMessagesReleasedViaReflection(
970 message, TestUtil::ReflectionTester::NOT_NULL);
971
972 // After Clear() we may or may not get a message from ReleaseMessage().
973 // This is implementation specific.
974 reflection_tester.SetAllFieldsViaReflection(message);
975 message->Clear();
976 reflection_tester.ExpectMessagesReleasedViaReflection(
977 message, TestUtil::ReflectionTester::CAN_BE_NULL);
978 }
979
TEST(GeneratedMessageReflectionTest,ArenaReleaseOneofMessageTest)980 TEST(GeneratedMessageReflectionTest, ArenaReleaseOneofMessageTest) {
981 Arena arena;
982 unittest::TestOneof2* message =
983 Arena::CreateMessage<unittest::TestOneof2>(&arena);
984 TestUtil::ReflectionTester::SetOneofViaReflection(message);
985
986 const Descriptor* descriptor = unittest::TestOneof2::descriptor();
987 const Reflection* reflection = message->GetReflection();
988 Message* released = reflection->ReleaseMessage(
989 message, descriptor->FindFieldByName("foo_lazy_message"));
990
991 EXPECT_TRUE(released != NULL);
992 delete released;
993
994 released = reflection->ReleaseMessage(
995 message, descriptor->FindFieldByName("foo_lazy_message"));
996 EXPECT_TRUE(released == NULL);
997 }
998
999 #ifdef PROTOBUF_HAS_DEATH_TEST
1000
TEST(GeneratedMessageReflectionTest,UsageErrors)1001 TEST(GeneratedMessageReflectionTest, UsageErrors) {
1002 unittest::TestAllTypes message;
1003 const Reflection* reflection = message.GetReflection();
1004 const Descriptor* descriptor = message.GetDescriptor();
1005
1006 #define f(NAME) descriptor->FindFieldByName(NAME)
1007
1008 // Testing every single failure mode would be too much work. Let's just
1009 // check a few.
1010 EXPECT_DEATH(
1011 reflection->GetInt32(message,
1012 descriptor->FindFieldByName("optional_int64")),
1013 "Protocol Buffer reflection usage error:\n"
1014 " Method : google::protobuf::Reflection::GetInt32\n"
1015 " Message type: protobuf_unittest\\.TestAllTypes\n"
1016 " Field : protobuf_unittest\\.TestAllTypes\\.optional_int64\n"
1017 " Problem : Field is not the right type for this message:\n"
1018 " Expected : CPPTYPE_INT32\n"
1019 " Field type: CPPTYPE_INT64");
1020 EXPECT_DEATH(reflection->GetInt32(
1021 message, descriptor->FindFieldByName("repeated_int32")),
1022 "Protocol Buffer reflection usage error:\n"
1023 " Method : google::protobuf::Reflection::GetInt32\n"
1024 " Message type: protobuf_unittest.TestAllTypes\n"
1025 " Field : protobuf_unittest.TestAllTypes.repeated_int32\n"
1026 " Problem : Field is repeated; the method requires a "
1027 "singular field.");
1028 EXPECT_DEATH(
1029 reflection->GetInt32(
1030 message,
1031 unittest::ForeignMessage::descriptor()->FindFieldByName("c")),
1032 "Protocol Buffer reflection usage error:\n"
1033 " Method : google::protobuf::Reflection::GetInt32\n"
1034 " Message type: protobuf_unittest.TestAllTypes\n"
1035 " Field : protobuf_unittest.ForeignMessage.c\n"
1036 " Problem : Field does not match message type.");
1037 EXPECT_DEATH(
1038 reflection->HasField(
1039 message,
1040 unittest::ForeignMessage::descriptor()->FindFieldByName("c")),
1041 "Protocol Buffer reflection usage error:\n"
1042 " Method : google::protobuf::Reflection::HasField\n"
1043 " Message type: protobuf_unittest.TestAllTypes\n"
1044 " Field : protobuf_unittest.ForeignMessage.c\n"
1045 " Problem : Field does not match message type.");
1046
1047 #undef f
1048 }
1049
1050 #endif // PROTOBUF_HAS_DEATH_TEST
1051
1052
1053 } // namespace
1054 } // namespace protobuf
1055 } // namespace google
1056