src/google/protobuf/generated_message_reflection_unittest.cc

   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.
  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
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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