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 (at) 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 796
