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