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 54namespace google { 55namespace protobuf { 56 57namespace { 58 59// Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes. 60const 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 67TEST(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 90TEST(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 105TEST(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 127TEST(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 150TEST(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 163TEST(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 184TEST(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 197TEST(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 210TEST(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 246TEST(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 261TEST(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 276TEST(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 287TEST(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 299TEST(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 315TEST(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 327TEST(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 339TEST(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 361TEST(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 386TEST(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 402TEST(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 418TEST(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 433TEST(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 458TEST(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 483TEST(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 516TEST(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 549TEST(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 559TEST(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 623TEST(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 669TEST(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 695TEST(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 721TEST(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 743TEST(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