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 45namespace google { 46namespace protobuf { 47namespace internal { 48namespace { 49 50TEST(ReflectionOpsTest, SanityCheck) { 51 unittest::TestAllTypes message; 52 53 TestUtil::SetAllFields(&message); 54 TestUtil::ExpectAllFieldsSet(message); 55} 56 57TEST(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 71TEST(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 81TEST(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 93TEST(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 120TEST(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 150TEST(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 167TEST(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 187TEST(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 200TEST(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 221TEST(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 243TEST(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 253TEST(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 270TEST(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 301TEST(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 336TEST(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 348TEST(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 376TEST(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 404TEST(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 420static string FindInitializationErrors(const Message& message) { 421 vector<string> errors; 422 ReflectionOps::FindInitializationErrors(message, "", &errors); 423 return Join(errors, ","); 424} 425 426TEST(ReflectionOpsTest, FindInitializationErrors) { 427 unittest::TestRequired message; 428 EXPECT_EQ("a,b,c", FindInitializationErrors(message)); 429} 430 431TEST(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 448TEST(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 465TEST(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 476