| // Protocol Buffers - Google's data interchange format |
| // Copyright 2008 Google Inc. All rights reserved. |
| // https://developers.google.com/protocol-buffers/ |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| // Author: kenton@google.com (Kenton Varda) |
| // Based on original Protocol Buffers design by |
| // Sanjay Ghemawat, Jeff Dean, and others. |
| |
| #ifndef GOOGLE_PROTOBUF_TEST_UTIL_H__ |
| #define GOOGLE_PROTOBUF_TEST_UTIL_H__ |
| |
| #include "google/protobuf/unittest.pb.h" |
| |
| #define UNITTEST ::protobuf_unittest |
| #define UNITTEST_IMPORT ::protobuf_unittest_import |
| // Must be included when the preprocessor symbols above are defined. |
| #include "google/protobuf/test_util.inc" |
| #undef UNITTEST |
| #undef UNITTEST_IMPORT |
| |
| // Must be included last. |
| #include "google/protobuf/port_def.inc" |
| |
| namespace google { |
| namespace protobuf { |
| // This file doesn't use these declarations, but some .cc files do. |
| namespace unittest = ::protobuf_unittest; |
| namespace unittest_import = ::protobuf_unittest_import; |
| |
| namespace TestUtil { |
| |
| class ReflectionTester { |
| public: |
| // base_descriptor must be a descriptor for TestAllTypes or |
| // TestAllExtensions. In the former case, ReflectionTester fetches from |
| // it the FieldDescriptors needed to use the reflection interface. In |
| // the latter case, ReflectionTester searches for extension fields in |
| // its file. |
| explicit ReflectionTester(const Descriptor* base_descriptor); |
| ReflectionTester(const ReflectionTester&) = delete; |
| ReflectionTester& operator=(const ReflectionTester&) = delete; |
| |
| void SetAllFieldsViaReflection(Message* message); |
| void ModifyRepeatedFieldsViaReflection(Message* message); |
| void ExpectAllFieldsSetViaReflection(const Message& message); |
| void ExpectClearViaReflection(const Message& message); |
| |
| void SetPackedFieldsViaReflection(Message* message); |
| void ExpectPackedFieldsSetViaReflection(const Message& message); |
| |
| void RemoveLastRepeatedsViaReflection(Message* message); |
| void ReleaseLastRepeatedsViaReflection(Message* message, |
| bool expect_extensions_notnull); |
| void SwapRepeatedsViaReflection(Message* message); |
| void SetAllocatedOptionalMessageFieldsToNullViaReflection(Message* message); |
| static void SetAllocatedOptionalMessageFieldsToMessageViaReflection( |
| Message* from_message, Message* to_message); |
| |
| enum MessageReleaseState { |
| IS_NULL, |
| CAN_BE_NULL, |
| NOT_NULL, |
| }; |
| void ExpectMessagesReleasedViaReflection( |
| Message* message, MessageReleaseState expected_release_state); |
| |
| // Set and check functions for TestOneof2 messages. No need to construct |
| // the ReflectionTester by TestAllTypes nor TestAllExtensions. |
| static void SetOneofViaReflection(Message* message); |
| static void ExpectOneofSetViaReflection(const Message& message); |
| |
| private: |
| const FieldDescriptor* F(const std::string& name); |
| |
| const Descriptor* base_descriptor_; |
| |
| const FieldDescriptor* group_a_; |
| const FieldDescriptor* repeated_group_a_; |
| const FieldDescriptor* nested_b_; |
| const FieldDescriptor* foreign_c_; |
| const FieldDescriptor* import_d_; |
| const FieldDescriptor* import_e_; |
| |
| const EnumValueDescriptor* nested_foo_; |
| const EnumValueDescriptor* nested_bar_; |
| const EnumValueDescriptor* nested_baz_; |
| const EnumValueDescriptor* foreign_foo_; |
| const EnumValueDescriptor* foreign_bar_; |
| const EnumValueDescriptor* foreign_baz_; |
| const EnumValueDescriptor* import_foo_; |
| const EnumValueDescriptor* import_bar_; |
| const EnumValueDescriptor* import_baz_; |
| |
| // We have to split this into three function otherwise it creates a stack |
| // frame so large that it triggers a warning. |
| void ExpectAllFieldsSetViaReflection1(const Message& message); |
| void ExpectAllFieldsSetViaReflection2(const Message& message); |
| void ExpectAllFieldsSetViaReflection3(const Message& message); |
| }; |
| |
| inline TestUtil::ReflectionTester::ReflectionTester( |
| const Descriptor* base_descriptor) |
| : base_descriptor_(base_descriptor) { |
| const DescriptorPool* pool = base_descriptor->file()->pool(); |
| std::string package = base_descriptor->file()->package(); |
| const FieldDescriptor* import_descriptor = |
| pool->FindFieldByName(package + ".TestAllTypes.optional_import_message"); |
| std::string import_package = |
| import_descriptor->message_type()->file()->package(); |
| |
| nested_b_ = pool->FindFieldByName(package + ".TestAllTypes.NestedMessage.bb"); |
| foreign_c_ = pool->FindFieldByName(package + ".ForeignMessage.c"); |
| import_d_ = pool->FindFieldByName(import_package + ".ImportMessage.d"); |
| import_e_ = pool->FindFieldByName(import_package + ".PublicImportMessage.e"); |
| nested_foo_ = pool->FindEnumValueByName(package + ".TestAllTypes.FOO"); |
| nested_bar_ = pool->FindEnumValueByName(package + ".TestAllTypes.BAR"); |
| nested_baz_ = pool->FindEnumValueByName(package + ".TestAllTypes.BAZ"); |
| foreign_foo_ = pool->FindEnumValueByName(package + ".FOREIGN_FOO"); |
| foreign_bar_ = pool->FindEnumValueByName(package + ".FOREIGN_BAR"); |
| foreign_baz_ = pool->FindEnumValueByName(package + ".FOREIGN_BAZ"); |
| import_foo_ = pool->FindEnumValueByName(import_package + ".IMPORT_FOO"); |
| import_bar_ = pool->FindEnumValueByName(import_package + ".IMPORT_BAR"); |
| import_baz_ = pool->FindEnumValueByName(import_package + ".IMPORT_BAZ"); |
| |
| if (base_descriptor_->name() == "TestAllExtensions") { |
| group_a_ = pool->FindFieldByName(package + ".OptionalGroup_extension.a"); |
| repeated_group_a_ = |
| pool->FindFieldByName(package + ".RepeatedGroup_extension.a"); |
| } else { |
| group_a_ = pool->FindFieldByName(package + ".TestAllTypes.OptionalGroup.a"); |
| repeated_group_a_ = |
| pool->FindFieldByName(package + ".TestAllTypes.RepeatedGroup.a"); |
| } |
| |
| EXPECT_TRUE(group_a_ != nullptr); |
| EXPECT_TRUE(repeated_group_a_ != nullptr); |
| EXPECT_TRUE(nested_b_ != nullptr); |
| EXPECT_TRUE(foreign_c_ != nullptr); |
| EXPECT_TRUE(import_d_ != nullptr); |
| EXPECT_TRUE(import_e_ != nullptr); |
| EXPECT_TRUE(nested_foo_ != nullptr); |
| EXPECT_TRUE(nested_bar_ != nullptr); |
| EXPECT_TRUE(nested_baz_ != nullptr); |
| EXPECT_TRUE(foreign_foo_ != nullptr); |
| EXPECT_TRUE(foreign_bar_ != nullptr); |
| EXPECT_TRUE(foreign_baz_ != nullptr); |
| EXPECT_TRUE(import_foo_ != nullptr); |
| EXPECT_TRUE(import_bar_ != nullptr); |
| EXPECT_TRUE(import_baz_ != nullptr); |
| } |
| |
| // Shorthand to get a FieldDescriptor for a field of TestAllTypes. |
| inline const FieldDescriptor* TestUtil::ReflectionTester::F( |
| const std::string& name) { |
| const FieldDescriptor* result = nullptr; |
| if (base_descriptor_->name() == "TestAllExtensions" || |
| base_descriptor_->name() == "TestPackedExtensions") { |
| result = base_descriptor_->file()->FindExtensionByName(name + "_extension"); |
| } else { |
| result = base_descriptor_->FindFieldByName(name); |
| } |
| GOOGLE_ABSL_CHECK(result != nullptr); |
| return result; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| inline void TestUtil::ReflectionTester::SetAllFieldsViaReflection( |
| Message* message) { |
| const Reflection* reflection = message->GetReflection(); |
| Message* sub_message; |
| |
| reflection->SetInt32(message, F("optional_int32"), 101); |
| reflection->SetInt64(message, F("optional_int64"), 102); |
| reflection->SetUInt32(message, F("optional_uint32"), 103); |
| reflection->SetUInt64(message, F("optional_uint64"), 104); |
| reflection->SetInt32(message, F("optional_sint32"), 105); |
| reflection->SetInt64(message, F("optional_sint64"), 106); |
| reflection->SetUInt32(message, F("optional_fixed32"), 107); |
| reflection->SetUInt64(message, F("optional_fixed64"), 108); |
| reflection->SetInt32(message, F("optional_sfixed32"), 109); |
| reflection->SetInt64(message, F("optional_sfixed64"), 110); |
| reflection->SetFloat(message, F("optional_float"), 111); |
| reflection->SetDouble(message, F("optional_double"), 112); |
| reflection->SetBool(message, F("optional_bool"), true); |
| reflection->SetString(message, F("optional_string"), "115"); |
| reflection->SetString(message, F("optional_bytes"), "116"); |
| |
| sub_message = reflection->MutableMessage(message, F("optionalgroup")); |
| sub_message->GetReflection()->SetInt32(sub_message, group_a_, 117); |
| sub_message = |
| reflection->MutableMessage(message, F("optional_nested_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 118); |
| sub_message = |
| reflection->MutableMessage(message, F("optional_foreign_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 119); |
| sub_message = |
| reflection->MutableMessage(message, F("optional_import_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, import_d_, 120); |
| |
| reflection->SetEnum(message, F("optional_nested_enum"), nested_baz_); |
| reflection->SetEnum(message, F("optional_foreign_enum"), foreign_baz_); |
| reflection->SetEnum(message, F("optional_import_enum"), import_baz_); |
| |
| reflection->SetString(message, F("optional_string_piece"), "124"); |
| reflection->SetString(message, F("optional_cord"), "125"); |
| |
| sub_message = |
| reflection->MutableMessage(message, F("optional_public_import_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, import_e_, 126); |
| |
| sub_message = reflection->MutableMessage(message, F("optional_lazy_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 127); |
| |
| sub_message = reflection->MutableMessage( |
| message, F("optional_unverified_lazy_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 128); |
| |
| // ----------------------------------------------------------------- |
| |
| reflection->AddInt32(message, F("repeated_int32"), 201); |
| reflection->AddInt64(message, F("repeated_int64"), 202); |
| reflection->AddUInt32(message, F("repeated_uint32"), 203); |
| reflection->AddUInt64(message, F("repeated_uint64"), 204); |
| reflection->AddInt32(message, F("repeated_sint32"), 205); |
| reflection->AddInt64(message, F("repeated_sint64"), 206); |
| reflection->AddUInt32(message, F("repeated_fixed32"), 207); |
| reflection->AddUInt64(message, F("repeated_fixed64"), 208); |
| reflection->AddInt32(message, F("repeated_sfixed32"), 209); |
| reflection->AddInt64(message, F("repeated_sfixed64"), 210); |
| reflection->AddFloat(message, F("repeated_float"), 211); |
| reflection->AddDouble(message, F("repeated_double"), 212); |
| reflection->AddBool(message, F("repeated_bool"), true); |
| reflection->AddString(message, F("repeated_string"), "215"); |
| reflection->AddString(message, F("repeated_bytes"), "216"); |
| |
| sub_message = reflection->AddMessage(message, F("repeatedgroup")); |
| sub_message->GetReflection()->SetInt32(sub_message, repeated_group_a_, 217); |
| sub_message = reflection->AddMessage(message, F("repeated_nested_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 218); |
| sub_message = reflection->AddMessage(message, F("repeated_foreign_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 219); |
| sub_message = reflection->AddMessage(message, F("repeated_import_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, import_d_, 220); |
| sub_message = reflection->AddMessage(message, F("repeated_lazy_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 227); |
| |
| reflection->AddEnum(message, F("repeated_nested_enum"), nested_bar_); |
| reflection->AddEnum(message, F("repeated_foreign_enum"), foreign_bar_); |
| reflection->AddEnum(message, F("repeated_import_enum"), import_bar_); |
| |
| reflection->AddString(message, F("repeated_string_piece"), "224"); |
| reflection->AddString(message, F("repeated_cord"), "225"); |
| |
| // Add a second one of each field. |
| reflection->AddInt32(message, F("repeated_int32"), 301); |
| reflection->AddInt64(message, F("repeated_int64"), 302); |
| reflection->AddUInt32(message, F("repeated_uint32"), 303); |
| reflection->AddUInt64(message, F("repeated_uint64"), 304); |
| reflection->AddInt32(message, F("repeated_sint32"), 305); |
| reflection->AddInt64(message, F("repeated_sint64"), 306); |
| reflection->AddUInt32(message, F("repeated_fixed32"), 307); |
| reflection->AddUInt64(message, F("repeated_fixed64"), 308); |
| reflection->AddInt32(message, F("repeated_sfixed32"), 309); |
| reflection->AddInt64(message, F("repeated_sfixed64"), 310); |
| reflection->AddFloat(message, F("repeated_float"), 311); |
| reflection->AddDouble(message, F("repeated_double"), 312); |
| reflection->AddBool(message, F("repeated_bool"), false); |
| reflection->AddString(message, F("repeated_string"), "315"); |
| reflection->AddString(message, F("repeated_bytes"), "316"); |
| |
| sub_message = reflection->AddMessage(message, F("repeatedgroup")); |
| sub_message->GetReflection()->SetInt32(sub_message, repeated_group_a_, 317); |
| sub_message = reflection->AddMessage(message, F("repeated_nested_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 318); |
| sub_message = reflection->AddMessage(message, F("repeated_foreign_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 319); |
| sub_message = reflection->AddMessage(message, F("repeated_import_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, import_d_, 320); |
| sub_message = reflection->AddMessage(message, F("repeated_lazy_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 327); |
| |
| reflection->AddEnum(message, F("repeated_nested_enum"), nested_baz_); |
| reflection->AddEnum(message, F("repeated_foreign_enum"), foreign_baz_); |
| reflection->AddEnum(message, F("repeated_import_enum"), import_baz_); |
| |
| reflection->AddString(message, F("repeated_string_piece"), "324"); |
| reflection->AddString(message, F("repeated_cord"), "325"); |
| |
| // ----------------------------------------------------------------- |
| |
| reflection->SetInt32(message, F("default_int32"), 401); |
| reflection->SetInt64(message, F("default_int64"), 402); |
| reflection->SetUInt32(message, F("default_uint32"), 403); |
| reflection->SetUInt64(message, F("default_uint64"), 404); |
| reflection->SetInt32(message, F("default_sint32"), 405); |
| reflection->SetInt64(message, F("default_sint64"), 406); |
| reflection->SetUInt32(message, F("default_fixed32"), 407); |
| reflection->SetUInt64(message, F("default_fixed64"), 408); |
| reflection->SetInt32(message, F("default_sfixed32"), 409); |
| reflection->SetInt64(message, F("default_sfixed64"), 410); |
| reflection->SetFloat(message, F("default_float"), 411); |
| reflection->SetDouble(message, F("default_double"), 412); |
| reflection->SetBool(message, F("default_bool"), false); |
| reflection->SetString(message, F("default_string"), "415"); |
| reflection->SetString(message, F("default_bytes"), "416"); |
| |
| reflection->SetEnum(message, F("default_nested_enum"), nested_foo_); |
| reflection->SetEnum(message, F("default_foreign_enum"), foreign_foo_); |
| reflection->SetEnum(message, F("default_import_enum"), import_foo_); |
| |
| reflection->SetString(message, F("default_string_piece"), "424"); |
| reflection->SetString(message, F("default_cord"), "425"); |
| |
| reflection->SetUInt32(message, F("oneof_uint32"), 601); |
| sub_message = reflection->MutableMessage(message, F("oneof_nested_message")); |
| sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 602); |
| reflection->SetString(message, F("oneof_string"), "603"); |
| reflection->SetString(message, F("oneof_bytes"), "604"); |
| } |
| |
| inline void TestUtil::ReflectionTester::SetOneofViaReflection( |
| Message* message) { |
| const Descriptor* descriptor = message->GetDescriptor(); |
| const Reflection* reflection = message->GetReflection(); |
| Message* sub_message = reflection->MutableMessage( |
| message, descriptor->FindFieldByName("foo_lazy_message")); |
| sub_message->GetReflection()->SetInt64( |
| sub_message, sub_message->GetDescriptor()->FindFieldByName("moo_int"), |
| 100); |
| |
| reflection->SetString(message, descriptor->FindFieldByName("bar_cord"), |
| "101"); |
| reflection->SetInt32(message, descriptor->FindFieldByName("baz_int"), 102); |
| reflection->SetString(message, descriptor->FindFieldByName("baz_string"), |
| "103"); |
| } |
| |
| inline void TestUtil::ReflectionTester::ExpectOneofSetViaReflection( |
| const Message& message) { |
| const Descriptor* descriptor = message.GetDescriptor(); |
| const Reflection* reflection = message.GetReflection(); |
| std::string scratch; |
| EXPECT_TRUE(reflection->HasField( |
| message, descriptor->FindFieldByName("foo_lazy_message"))); |
| EXPECT_TRUE( |
| reflection->HasField(message, descriptor->FindFieldByName("bar_cord"))); |
| EXPECT_TRUE( |
| reflection->HasField(message, descriptor->FindFieldByName("baz_int"))); |
| EXPECT_TRUE( |
| reflection->HasField(message, descriptor->FindFieldByName("baz_string"))); |
| |
| const Message* sub_message = &reflection->GetMessage( |
| message, descriptor->FindFieldByName("foo_lazy_message")); |
| EXPECT_EQ(100, sub_message->GetReflection()->GetInt64( |
| *sub_message, |
| sub_message->GetDescriptor()->FindFieldByName("moo_int"))); |
| |
| EXPECT_EQ("101", reflection->GetString( |
| message, descriptor->FindFieldByName("bar_cord"))); |
| EXPECT_EQ("101", |
| reflection->GetStringReference( |
| message, descriptor->FindFieldByName("bar_cord"), &scratch)); |
| |
| EXPECT_EQ(102, reflection->GetInt32(message, |
| descriptor->FindFieldByName("baz_int"))); |
| |
| EXPECT_EQ("103", reflection->GetString( |
| message, descriptor->FindFieldByName("baz_string"))); |
| EXPECT_EQ("103", |
| reflection->GetStringReference( |
| message, descriptor->FindFieldByName("baz_string"), &scratch)); |
| } |
| |
| inline void TestUtil::ReflectionTester::SetPackedFieldsViaReflection( |
| Message* message) { |
| const Reflection* reflection = message->GetReflection(); |
| reflection->AddInt32(message, F("packed_int32"), 601); |
| reflection->AddInt64(message, F("packed_int64"), 602); |
| reflection->AddUInt32(message, F("packed_uint32"), 603); |
| reflection->AddUInt64(message, F("packed_uint64"), 604); |
| reflection->AddInt32(message, F("packed_sint32"), 605); |
| reflection->AddInt64(message, F("packed_sint64"), 606); |
| reflection->AddUInt32(message, F("packed_fixed32"), 607); |
| reflection->AddUInt64(message, F("packed_fixed64"), 608); |
| reflection->AddInt32(message, F("packed_sfixed32"), 609); |
| reflection->AddInt64(message, F("packed_sfixed64"), 610); |
| reflection->AddFloat(message, F("packed_float"), 611); |
| reflection->AddDouble(message, F("packed_double"), 612); |
| reflection->AddBool(message, F("packed_bool"), true); |
| reflection->AddEnum(message, F("packed_enum"), foreign_bar_); |
| |
| reflection->AddInt32(message, F("packed_int32"), 701); |
| reflection->AddInt64(message, F("packed_int64"), 702); |
| reflection->AddUInt32(message, F("packed_uint32"), 703); |
| reflection->AddUInt64(message, F("packed_uint64"), 704); |
| reflection->AddInt32(message, F("packed_sint32"), 705); |
| reflection->AddInt64(message, F("packed_sint64"), 706); |
| reflection->AddUInt32(message, F("packed_fixed32"), 707); |
| reflection->AddUInt64(message, F("packed_fixed64"), 708); |
| reflection->AddInt32(message, F("packed_sfixed32"), 709); |
| reflection->AddInt64(message, F("packed_sfixed64"), 710); |
| reflection->AddFloat(message, F("packed_float"), 711); |
| reflection->AddDouble(message, F("packed_double"), 712); |
| reflection->AddBool(message, F("packed_bool"), false); |
| reflection->AddEnum(message, F("packed_enum"), foreign_baz_); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| inline void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection( |
| const Message& message) { |
| // We have to split this into three function otherwise it creates a stack |
| // frame so large that it triggers a warning. |
| ExpectAllFieldsSetViaReflection1(message); |
| ExpectAllFieldsSetViaReflection2(message); |
| ExpectAllFieldsSetViaReflection3(message); |
| } |
| |
| inline void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection1( |
| const Message& message) { |
| const Reflection* reflection = message.GetReflection(); |
| std::string scratch; |
| const Message* sub_message; |
| |
| EXPECT_TRUE(reflection->HasField(message, F("optional_int32"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_int64"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_uint32"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_uint64"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_sint32"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_sint64"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_fixed32"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_fixed64"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_sfixed32"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_sfixed64"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_float"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_double"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_bool"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_string"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_bytes"))); |
| |
| EXPECT_TRUE(reflection->HasField(message, F("optionalgroup"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_nested_message"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_foreign_message"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_import_message"))); |
| EXPECT_TRUE( |
| reflection->HasField(message, F("optional_public_import_message"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_lazy_message"))); |
| EXPECT_TRUE( |
| reflection->HasField(message, F("optional_unverified_lazy_message"))); |
| |
| sub_message = &reflection->GetMessage(message, F("optionalgroup")); |
| EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, group_a_)); |
| sub_message = &reflection->GetMessage(message, F("optional_nested_message")); |
| EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, nested_b_)); |
| sub_message = &reflection->GetMessage(message, F("optional_foreign_message")); |
| EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, foreign_c_)); |
| sub_message = &reflection->GetMessage(message, F("optional_import_message")); |
| EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, import_d_)); |
| sub_message = |
| &reflection->GetMessage(message, F("optional_public_import_message")); |
| EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, import_e_)); |
| sub_message = &reflection->GetMessage(message, F("optional_lazy_message")); |
| EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, nested_b_)); |
| sub_message = |
| &reflection->GetMessage(message, F("optional_unverified_lazy_message")); |
| EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, nested_b_)); |
| |
| EXPECT_TRUE(reflection->HasField(message, F("optional_nested_enum"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_foreign_enum"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_import_enum"))); |
| |
| EXPECT_TRUE(reflection->HasField(message, F("optional_string_piece"))); |
| EXPECT_TRUE(reflection->HasField(message, F("optional_cord"))); |
| |
| EXPECT_EQ(101, reflection->GetInt32(message, F("optional_int32"))); |
| EXPECT_EQ(102, reflection->GetInt64(message, F("optional_int64"))); |
| EXPECT_EQ(103, reflection->GetUInt32(message, F("optional_uint32"))); |
| EXPECT_EQ(104, reflection->GetUInt64(message, F("optional_uint64"))); |
| EXPECT_EQ(105, reflection->GetInt32(message, F("optional_sint32"))); |
| EXPECT_EQ(106, reflection->GetInt64(message, F("optional_sint64"))); |
| EXPECT_EQ(107, reflection->GetUInt32(message, F("optional_fixed32"))); |
| EXPECT_EQ(108, reflection->GetUInt64(message, F("optional_fixed64"))); |
| EXPECT_EQ(109, reflection->GetInt32(message, F("optional_sfixed32"))); |
| EXPECT_EQ(110, reflection->GetInt64(message, F("optional_sfixed64"))); |
| EXPECT_EQ(111, reflection->GetFloat(message, F("optional_float"))); |
| EXPECT_EQ(112, reflection->GetDouble(message, F("optional_double"))); |
| EXPECT_TRUE(reflection->GetBool(message, F("optional_bool"))); |
| EXPECT_EQ("115", reflection->GetString(message, F("optional_string"))); |
| EXPECT_EQ("116", reflection->GetString(message, F("optional_bytes"))); |
| |
| EXPECT_EQ("115", reflection->GetStringReference(message, F("optional_string"), |
| &scratch)); |
| EXPECT_EQ("116", reflection->GetStringReference(message, F("optional_bytes"), |
| &scratch)); |
| |
| sub_message = &reflection->GetMessage(message, F("optionalgroup")); |
| EXPECT_EQ(117, |
| sub_message->GetReflection()->GetInt32(*sub_message, group_a_)); |
| sub_message = &reflection->GetMessage(message, F("optional_nested_message")); |
| EXPECT_EQ(118, |
| sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); |
| sub_message = &reflection->GetMessage(message, F("optional_foreign_message")); |
| EXPECT_EQ(119, |
| sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_)); |
| sub_message = &reflection->GetMessage(message, F("optional_import_message")); |
| EXPECT_EQ(120, |
| sub_message->GetReflection()->GetInt32(*sub_message, import_d_)); |
| sub_message = |
| &reflection->GetMessage(message, F("optional_public_import_message")); |
| EXPECT_EQ(126, |
| sub_message->GetReflection()->GetInt32(*sub_message, import_e_)); |
| sub_message = &reflection->GetMessage(message, F("optional_lazy_message")); |
| EXPECT_EQ(127, |
| sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); |
| sub_message = |
| &reflection->GetMessage(message, F("optional_unverified_lazy_message")); |
| EXPECT_EQ(128, |
| sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); |
| |
| EXPECT_EQ(nested_baz_, |
| reflection->GetEnum(message, F("optional_nested_enum"))); |
| EXPECT_EQ(foreign_baz_, |
| reflection->GetEnum(message, F("optional_foreign_enum"))); |
| EXPECT_EQ(import_baz_, |
| reflection->GetEnum(message, F("optional_import_enum"))); |
| |
| EXPECT_EQ("124", reflection->GetString(message, F("optional_string_piece"))); |
| EXPECT_EQ("124", reflection->GetStringReference( |
| message, F("optional_string_piece"), &scratch)); |
| |
| EXPECT_EQ("125", reflection->GetString(message, F("optional_cord"))); |
| EXPECT_EQ("125", reflection->GetStringReference(message, F("optional_cord"), |
| &scratch)); |
| |
| EXPECT_TRUE(reflection->HasField(message, F("oneof_bytes"))); |
| EXPECT_EQ("604", reflection->GetString(message, F("oneof_bytes"))); |
| |
| if (base_descriptor_->name() == "TestAllTypes") { |
| EXPECT_FALSE(reflection->HasField(message, F("oneof_uint32"))); |
| EXPECT_FALSE(reflection->HasField(message, F("oneof_string"))); |
| } else { |
| EXPECT_TRUE(reflection->HasField(message, F("oneof_uint32"))); |
| EXPECT_TRUE(reflection->HasField(message, F("oneof_string"))); |
| EXPECT_EQ(601, reflection->GetUInt32(message, F("oneof_uint32"))); |
| EXPECT_EQ("603", reflection->GetString(message, F("oneof_string"))); |
| sub_message = &reflection->GetMessage(message, F("oneof_nested_message")); |
| EXPECT_EQ(602, |
| sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); |
| } |
| } |
| |
| inline void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection2( |
| const Message& message) { |
| const Reflection* reflection = message.GetReflection(); |
| std::string scratch; |
| const Message* sub_message; |
| |
| // ----------------------------------------------------------------- |
| |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_int32"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_int64"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_uint32"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_uint64"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sint32"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sint64"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_fixed32"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_fixed64"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sfixed32"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sfixed64"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_float"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_double"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_bool"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_string"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_bytes"))); |
| |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeatedgroup"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_nested_message"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_foreign_message"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_import_message"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_lazy_message"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_nested_enum"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_foreign_enum"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_import_enum"))); |
| |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_string_piece"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_cord"))); |
| |
| EXPECT_EQ(201, reflection->GetRepeatedInt32(message, F("repeated_int32"), 0)); |
| EXPECT_EQ(202, reflection->GetRepeatedInt64(message, F("repeated_int64"), 0)); |
| EXPECT_EQ(203, |
| reflection->GetRepeatedUInt32(message, F("repeated_uint32"), 0)); |
| EXPECT_EQ(204, |
| reflection->GetRepeatedUInt64(message, F("repeated_uint64"), 0)); |
| EXPECT_EQ(205, |
| reflection->GetRepeatedInt32(message, F("repeated_sint32"), 0)); |
| EXPECT_EQ(206, |
| reflection->GetRepeatedInt64(message, F("repeated_sint64"), 0)); |
| EXPECT_EQ(207, |
| reflection->GetRepeatedUInt32(message, F("repeated_fixed32"), 0)); |
| EXPECT_EQ(208, |
| reflection->GetRepeatedUInt64(message, F("repeated_fixed64"), 0)); |
| EXPECT_EQ(209, |
| reflection->GetRepeatedInt32(message, F("repeated_sfixed32"), 0)); |
| EXPECT_EQ(210, |
| reflection->GetRepeatedInt64(message, F("repeated_sfixed64"), 0)); |
| EXPECT_EQ(211, reflection->GetRepeatedFloat(message, F("repeated_float"), 0)); |
| EXPECT_EQ(212, |
| reflection->GetRepeatedDouble(message, F("repeated_double"), 0)); |
| EXPECT_TRUE(reflection->GetRepeatedBool(message, F("repeated_bool"), 0)); |
| EXPECT_EQ("215", |
| reflection->GetRepeatedString(message, F("repeated_string"), 0)); |
| EXPECT_EQ("216", |
| reflection->GetRepeatedString(message, F("repeated_bytes"), 0)); |
| |
| EXPECT_EQ("215", reflection->GetRepeatedStringReference( |
| message, F("repeated_string"), 0, &scratch)); |
| EXPECT_EQ("216", reflection->GetRepeatedStringReference( |
| message, F("repeated_bytes"), 0, &scratch)); |
| |
| sub_message = &reflection->GetRepeatedMessage(message, F("repeatedgroup"), 0); |
| EXPECT_EQ(217, sub_message->GetReflection()->GetInt32(*sub_message, |
| repeated_group_a_)); |
| sub_message = |
| &reflection->GetRepeatedMessage(message, F("repeated_nested_message"), 0); |
| EXPECT_EQ(218, |
| sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); |
| sub_message = &reflection->GetRepeatedMessage( |
| message, F("repeated_foreign_message"), 0); |
| EXPECT_EQ(219, |
| sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_)); |
| sub_message = |
| &reflection->GetRepeatedMessage(message, F("repeated_import_message"), 0); |
| EXPECT_EQ(220, |
| sub_message->GetReflection()->GetInt32(*sub_message, import_d_)); |
| sub_message = |
| &reflection->GetRepeatedMessage(message, F("repeated_lazy_message"), 0); |
| EXPECT_EQ(227, |
| sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); |
| |
| EXPECT_EQ(nested_bar_, |
| reflection->GetRepeatedEnum(message, F("repeated_nested_enum"), 0)); |
| EXPECT_EQ(foreign_bar_, reflection->GetRepeatedEnum( |
| message, F("repeated_foreign_enum"), 0)); |
| EXPECT_EQ(import_bar_, |
| reflection->GetRepeatedEnum(message, F("repeated_import_enum"), 0)); |
| |
| EXPECT_EQ("224", reflection->GetRepeatedString( |
| message, F("repeated_string_piece"), 0)); |
| EXPECT_EQ("224", reflection->GetRepeatedStringReference( |
| message, F("repeated_string_piece"), 0, &scratch)); |
| |
| EXPECT_EQ("225", |
| reflection->GetRepeatedString(message, F("repeated_cord"), 0)); |
| EXPECT_EQ("225", reflection->GetRepeatedStringReference( |
| message, F("repeated_cord"), 0, &scratch)); |
| |
| EXPECT_EQ(301, reflection->GetRepeatedInt32(message, F("repeated_int32"), 1)); |
| EXPECT_EQ(302, reflection->GetRepeatedInt64(message, F("repeated_int64"), 1)); |
| EXPECT_EQ(303, |
| reflection->GetRepeatedUInt32(message, F("repeated_uint32"), 1)); |
| EXPECT_EQ(304, |
| reflection->GetRepeatedUInt64(message, F("repeated_uint64"), 1)); |
| EXPECT_EQ(305, |
| reflection->GetRepeatedInt32(message, F("repeated_sint32"), 1)); |
| EXPECT_EQ(306, |
| reflection->GetRepeatedInt64(message, F("repeated_sint64"), 1)); |
| EXPECT_EQ(307, |
| reflection->GetRepeatedUInt32(message, F("repeated_fixed32"), 1)); |
| EXPECT_EQ(308, |
| reflection->GetRepeatedUInt64(message, F("repeated_fixed64"), 1)); |
| EXPECT_EQ(309, |
| reflection->GetRepeatedInt32(message, F("repeated_sfixed32"), 1)); |
| EXPECT_EQ(310, |
| reflection->GetRepeatedInt64(message, F("repeated_sfixed64"), 1)); |
| EXPECT_EQ(311, reflection->GetRepeatedFloat(message, F("repeated_float"), 1)); |
| EXPECT_EQ(312, |
| reflection->GetRepeatedDouble(message, F("repeated_double"), 1)); |
| EXPECT_FALSE(reflection->GetRepeatedBool(message, F("repeated_bool"), 1)); |
| EXPECT_EQ("315", |
| reflection->GetRepeatedString(message, F("repeated_string"), 1)); |
| EXPECT_EQ("316", |
| reflection->GetRepeatedString(message, F("repeated_bytes"), 1)); |
| |
| EXPECT_EQ("315", reflection->GetRepeatedStringReference( |
| message, F("repeated_string"), 1, &scratch)); |
| EXPECT_EQ("316", reflection->GetRepeatedStringReference( |
| message, F("repeated_bytes"), 1, &scratch)); |
| |
| sub_message = &reflection->GetRepeatedMessage(message, F("repeatedgroup"), 1); |
| EXPECT_EQ(317, sub_message->GetReflection()->GetInt32(*sub_message, |
| repeated_group_a_)); |
| sub_message = |
| &reflection->GetRepeatedMessage(message, F("repeated_nested_message"), 1); |
| EXPECT_EQ(318, |
| sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); |
| sub_message = &reflection->GetRepeatedMessage( |
| message, F("repeated_foreign_message"), 1); |
| EXPECT_EQ(319, |
| sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_)); |
| sub_message = |
| &reflection->GetRepeatedMessage(message, F("repeated_import_message"), 1); |
| EXPECT_EQ(320, |
| sub_message->GetReflection()->GetInt32(*sub_message, import_d_)); |
| sub_message = |
| &reflection->GetRepeatedMessage(message, F("repeated_lazy_message"), 1); |
| EXPECT_EQ(327, |
| sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); |
| |
| EXPECT_EQ(nested_baz_, |
| reflection->GetRepeatedEnum(message, F("repeated_nested_enum"), 1)); |
| EXPECT_EQ(foreign_baz_, reflection->GetRepeatedEnum( |
| message, F("repeated_foreign_enum"), 1)); |
| EXPECT_EQ(import_baz_, |
| reflection->GetRepeatedEnum(message, F("repeated_import_enum"), 1)); |
| |
| EXPECT_EQ("324", reflection->GetRepeatedString( |
| message, F("repeated_string_piece"), 1)); |
| EXPECT_EQ("324", reflection->GetRepeatedStringReference( |
| message, F("repeated_string_piece"), 1, &scratch)); |
| |
| EXPECT_EQ("325", |
| reflection->GetRepeatedString(message, F("repeated_cord"), 1)); |
| EXPECT_EQ("325", reflection->GetRepeatedStringReference( |
| message, F("repeated_cord"), 1, &scratch)); |
| } |
| |
| inline void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection3( |
| const Message& message) { |
| const Reflection* reflection = message.GetReflection(); |
| std::string scratch; |
| |
| // ----------------------------------------------------------------- |
| |
| EXPECT_TRUE(reflection->HasField(message, F("default_int32"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_int64"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_uint32"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_uint64"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_sint32"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_sint64"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_fixed32"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_fixed64"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_sfixed32"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_sfixed64"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_float"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_double"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_bool"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_string"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_bytes"))); |
| |
| EXPECT_TRUE(reflection->HasField(message, F("default_nested_enum"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_foreign_enum"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_import_enum"))); |
| |
| EXPECT_TRUE(reflection->HasField(message, F("default_string_piece"))); |
| EXPECT_TRUE(reflection->HasField(message, F("default_cord"))); |
| |
| EXPECT_EQ(401, reflection->GetInt32(message, F("default_int32"))); |
| EXPECT_EQ(402, reflection->GetInt64(message, F("default_int64"))); |
| EXPECT_EQ(403, reflection->GetUInt32(message, F("default_uint32"))); |
| EXPECT_EQ(404, reflection->GetUInt64(message, F("default_uint64"))); |
| EXPECT_EQ(405, reflection->GetInt32(message, F("default_sint32"))); |
| EXPECT_EQ(406, reflection->GetInt64(message, F("default_sint64"))); |
| EXPECT_EQ(407, reflection->GetUInt32(message, F("default_fixed32"))); |
| EXPECT_EQ(408, reflection->GetUInt64(message, F("default_fixed64"))); |
| EXPECT_EQ(409, reflection->GetInt32(message, F("default_sfixed32"))); |
| EXPECT_EQ(410, reflection->GetInt64(message, F("default_sfixed64"))); |
| EXPECT_EQ(411, reflection->GetFloat(message, F("default_float"))); |
| EXPECT_EQ(412, reflection->GetDouble(message, F("default_double"))); |
| EXPECT_FALSE(reflection->GetBool(message, F("default_bool"))); |
| EXPECT_EQ("415", reflection->GetString(message, F("default_string"))); |
| EXPECT_EQ("416", reflection->GetString(message, F("default_bytes"))); |
| |
| EXPECT_EQ("415", reflection->GetStringReference(message, F("default_string"), |
| &scratch)); |
| EXPECT_EQ("416", reflection->GetStringReference(message, F("default_bytes"), |
| &scratch)); |
| |
| EXPECT_EQ(nested_foo_, |
| reflection->GetEnum(message, F("default_nested_enum"))); |
| EXPECT_EQ(foreign_foo_, |
| reflection->GetEnum(message, F("default_foreign_enum"))); |
| EXPECT_EQ(import_foo_, |
| reflection->GetEnum(message, F("default_import_enum"))); |
| |
| EXPECT_EQ("424", reflection->GetString(message, F("default_string_piece"))); |
| EXPECT_EQ("424", reflection->GetStringReference( |
| message, F("default_string_piece"), &scratch)); |
| |
| EXPECT_EQ("425", reflection->GetString(message, F("default_cord"))); |
| EXPECT_EQ("425", reflection->GetStringReference(message, F("default_cord"), |
| &scratch)); |
| } |
| |
| inline void TestUtil::ReflectionTester::ExpectPackedFieldsSetViaReflection( |
| const Message& message) { |
| const Reflection* reflection = message.GetReflection(); |
| |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_int32"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_int64"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_uint32"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_uint64"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sint32"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sint64"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_fixed32"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_fixed64"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sfixed32"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sfixed64"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_float"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_double"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_bool"))); |
| ASSERT_EQ(2, reflection->FieldSize(message, F("packed_enum"))); |
| |
| EXPECT_EQ(601, reflection->GetRepeatedInt32(message, F("packed_int32"), 0)); |
| EXPECT_EQ(602, reflection->GetRepeatedInt64(message, F("packed_int64"), 0)); |
| EXPECT_EQ(603, reflection->GetRepeatedUInt32(message, F("packed_uint32"), 0)); |
| EXPECT_EQ(604, reflection->GetRepeatedUInt64(message, F("packed_uint64"), 0)); |
| EXPECT_EQ(605, reflection->GetRepeatedInt32(message, F("packed_sint32"), 0)); |
| EXPECT_EQ(606, reflection->GetRepeatedInt64(message, F("packed_sint64"), 0)); |
| EXPECT_EQ(607, |
| reflection->GetRepeatedUInt32(message, F("packed_fixed32"), 0)); |
| EXPECT_EQ(608, |
| reflection->GetRepeatedUInt64(message, F("packed_fixed64"), 0)); |
| EXPECT_EQ(609, |
| reflection->GetRepeatedInt32(message, F("packed_sfixed32"), 0)); |
| EXPECT_EQ(610, |
| reflection->GetRepeatedInt64(message, F("packed_sfixed64"), 0)); |
| EXPECT_EQ(611, reflection->GetRepeatedFloat(message, F("packed_float"), 0)); |
| EXPECT_EQ(612, reflection->GetRepeatedDouble(message, F("packed_double"), 0)); |
| EXPECT_TRUE(reflection->GetRepeatedBool(message, F("packed_bool"), 0)); |
| EXPECT_EQ(foreign_bar_, |
| reflection->GetRepeatedEnum(message, F("packed_enum"), 0)); |
| |
| EXPECT_EQ(701, reflection->GetRepeatedInt32(message, F("packed_int32"), 1)); |
| EXPECT_EQ(702, reflection->GetRepeatedInt64(message, F("packed_int64"), 1)); |
| EXPECT_EQ(703, reflection->GetRepeatedUInt32(message, F("packed_uint32"), 1)); |
| EXPECT_EQ(704, reflection->GetRepeatedUInt64(message, F("packed_uint64"), 1)); |
| EXPECT_EQ(705, reflection->GetRepeatedInt32(message, F("packed_sint32"), 1)); |
| EXPECT_EQ(706, reflection->GetRepeatedInt64(message, F("packed_sint64"), 1)); |
| EXPECT_EQ(707, |
| reflection->GetRepeatedUInt32(message, F("packed_fixed32"), 1)); |
| EXPECT_EQ(708, |
| reflection->GetRepeatedUInt64(message, F("packed_fixed64"), 1)); |
| EXPECT_EQ(709, |
| reflection->GetRepeatedInt32(message, F("packed_sfixed32"), 1)); |
| EXPECT_EQ(710, |
| reflection->GetRepeatedInt64(message, F("packed_sfixed64"), 1)); |
| EXPECT_EQ(711, reflection->GetRepeatedFloat(message, F("packed_float"), 1)); |
| EXPECT_EQ(712, reflection->GetRepeatedDouble(message, F("packed_double"), 1)); |
| EXPECT_FALSE(reflection->GetRepeatedBool(message, F("packed_bool"), 1)); |
| EXPECT_EQ(foreign_baz_, |
| reflection->GetRepeatedEnum(message, F("packed_enum"), 1)); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| inline void TestUtil::ReflectionTester::ExpectClearViaReflection( |
| const Message& message) { |
| const Reflection* reflection = message.GetReflection(); |
| std::string scratch; |
| const Message* sub_message; |
| |
| // has_blah() should initially be false for all optional fields. |
| EXPECT_FALSE(reflection->HasField(message, F("optional_int32"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_int64"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_uint32"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_uint64"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_sint32"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_sint64"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_fixed32"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_fixed64"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_sfixed32"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_sfixed64"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_float"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_double"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_bool"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_string"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_bytes"))); |
| |
| EXPECT_FALSE(reflection->HasField(message, F("optionalgroup"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_nested_message"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_foreign_message"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_import_message"))); |
| EXPECT_FALSE( |
| reflection->HasField(message, F("optional_public_import_message"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_lazy_message"))); |
| EXPECT_FALSE( |
| reflection->HasField(message, F("optional_unverified_lazy_message"))); |
| |
| EXPECT_FALSE(reflection->HasField(message, F("optional_nested_enum"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_foreign_enum"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_import_enum"))); |
| |
| EXPECT_FALSE(reflection->HasField(message, F("optional_string_piece"))); |
| EXPECT_FALSE(reflection->HasField(message, F("optional_cord"))); |
| |
| // Optional fields without defaults are set to zero or something like it. |
| EXPECT_EQ(0, reflection->GetInt32(message, F("optional_int32"))); |
| EXPECT_EQ(0, reflection->GetInt64(message, F("optional_int64"))); |
| EXPECT_EQ(0, reflection->GetUInt32(message, F("optional_uint32"))); |
| EXPECT_EQ(0, reflection->GetUInt64(message, F("optional_uint64"))); |
| EXPECT_EQ(0, reflection->GetInt32(message, F("optional_sint32"))); |
| EXPECT_EQ(0, reflection->GetInt64(message, F("optional_sint64"))); |
| EXPECT_EQ(0, reflection->GetUInt32(message, F("optional_fixed32"))); |
| EXPECT_EQ(0, reflection->GetUInt64(message, F("optional_fixed64"))); |
| EXPECT_EQ(0, reflection->GetInt32(message, F("optional_sfixed32"))); |
| EXPECT_EQ(0, reflection->GetInt64(message, F("optional_sfixed64"))); |
| EXPECT_EQ(0, reflection->GetFloat(message, F("optional_float"))); |
| EXPECT_EQ(0, reflection->GetDouble(message, F("optional_double"))); |
| EXPECT_FALSE(reflection->GetBool(message, F("optional_bool"))); |
| EXPECT_EQ("", reflection->GetString(message, F("optional_string"))); |
| EXPECT_EQ("", reflection->GetString(message, F("optional_bytes"))); |
| |
| EXPECT_EQ("", reflection->GetStringReference(message, F("optional_string"), |
| &scratch)); |
| EXPECT_EQ("", reflection->GetStringReference(message, F("optional_bytes"), |
| &scratch)); |
| |
| // Embedded messages should also be clear. |
| sub_message = &reflection->GetMessage(message, F("optionalgroup")); |
| EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, group_a_)); |
| EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, group_a_)); |
| sub_message = &reflection->GetMessage(message, F("optional_nested_message")); |
| EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, nested_b_)); |
| EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); |
| sub_message = &reflection->GetMessage(message, F("optional_foreign_message")); |
| EXPECT_FALSE( |
| sub_message->GetReflection()->HasField(*sub_message, foreign_c_)); |
| EXPECT_EQ(0, |
| sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_)); |
| sub_message = &reflection->GetMessage(message, F("optional_import_message")); |
| EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, import_d_)); |
| EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, import_d_)); |
| sub_message = |
| &reflection->GetMessage(message, F("optional_public_import_message")); |
| EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, import_e_)); |
| EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, import_e_)); |
| sub_message = &reflection->GetMessage(message, F("optional_lazy_message")); |
| EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, nested_b_)); |
| EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); |
| sub_message = |
| &reflection->GetMessage(message, F("optional_unverified_lazy_message")); |
| EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, nested_b_)); |
| EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); |
| |
| // Enums without defaults are set to the first value in the enum. |
| EXPECT_EQ(nested_foo_, |
| reflection->GetEnum(message, F("optional_nested_enum"))); |
| EXPECT_EQ(foreign_foo_, |
| reflection->GetEnum(message, F("optional_foreign_enum"))); |
| EXPECT_EQ(import_foo_, |
| reflection->GetEnum(message, F("optional_import_enum"))); |
| |
| EXPECT_EQ("", reflection->GetString(message, F("optional_string_piece"))); |
| EXPECT_EQ("", reflection->GetStringReference( |
| message, F("optional_string_piece"), &scratch)); |
| |
| EXPECT_EQ("", reflection->GetString(message, F("optional_cord"))); |
| EXPECT_EQ("", reflection->GetStringReference(message, F("optional_cord"), |
| &scratch)); |
| |
| // Repeated fields are empty. |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_int32"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_int64"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_uint32"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_uint64"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sint32"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sint64"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_fixed32"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_fixed64"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sfixed32"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sfixed64"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_float"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_double"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_bool"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_string"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_bytes"))); |
| |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeatedgroup"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_nested_message"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_foreign_message"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_import_message"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_lazy_message"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_nested_enum"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_foreign_enum"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_import_enum"))); |
| |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_string_piece"))); |
| EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_cord"))); |
| |
| // has_blah() should also be false for all default fields. |
| EXPECT_FALSE(reflection->HasField(message, F("default_int32"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_int64"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_uint32"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_uint64"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_sint32"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_sint64"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_fixed32"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_fixed64"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_sfixed32"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_sfixed64"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_float"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_double"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_bool"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_string"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_bytes"))); |
| |
| EXPECT_FALSE(reflection->HasField(message, F("default_nested_enum"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_foreign_enum"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_import_enum"))); |
| |
| EXPECT_FALSE(reflection->HasField(message, F("default_string_piece"))); |
| EXPECT_FALSE(reflection->HasField(message, F("default_cord"))); |
| |
| // Fields with defaults have their default values (duh). |
| EXPECT_EQ(41, reflection->GetInt32(message, F("default_int32"))); |
| EXPECT_EQ(42, reflection->GetInt64(message, F("default_int64"))); |
| EXPECT_EQ(43, reflection->GetUInt32(message, F("default_uint32"))); |
| EXPECT_EQ(44, reflection->GetUInt64(message, F("default_uint64"))); |
| EXPECT_EQ(-45, reflection->GetInt32(message, F("default_sint32"))); |
| EXPECT_EQ(46, reflection->GetInt64(message, F("default_sint64"))); |
| EXPECT_EQ(47, reflection->GetUInt32(message, F("default_fixed32"))); |
| EXPECT_EQ(48, reflection->GetUInt64(message, F("default_fixed64"))); |
| EXPECT_EQ(49, reflection->GetInt32(message, F("default_sfixed32"))); |
| EXPECT_EQ(-50, reflection->GetInt64(message, F("default_sfixed64"))); |
| EXPECT_EQ(51.5, reflection->GetFloat(message, F("default_float"))); |
| EXPECT_EQ(52e3, reflection->GetDouble(message, F("default_double"))); |
| EXPECT_TRUE(reflection->GetBool(message, F("default_bool"))); |
| EXPECT_EQ("hello", reflection->GetString(message, F("default_string"))); |
| EXPECT_EQ("world", reflection->GetString(message, F("default_bytes"))); |
| |
| EXPECT_EQ("hello", reflection->GetStringReference( |
| message, F("default_string"), &scratch)); |
| EXPECT_EQ("world", reflection->GetStringReference(message, F("default_bytes"), |
| &scratch)); |
| |
| EXPECT_EQ(nested_bar_, |
| reflection->GetEnum(message, F("default_nested_enum"))); |
| EXPECT_EQ(foreign_bar_, |
| reflection->GetEnum(message, F("default_foreign_enum"))); |
| EXPECT_EQ(import_bar_, |
| reflection->GetEnum(message, F("default_import_enum"))); |
| |
| EXPECT_EQ("abc", reflection->GetString(message, F("default_string_piece"))); |
| EXPECT_EQ("abc", reflection->GetStringReference( |
| message, F("default_string_piece"), &scratch)); |
| |
| EXPECT_EQ("123", reflection->GetString(message, F("default_cord"))); |
| EXPECT_EQ("123", reflection->GetStringReference(message, F("default_cord"), |
| &scratch)); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| inline void TestUtil::ReflectionTester::ModifyRepeatedFieldsViaReflection( |
| Message* message) { |
| const Reflection* reflection = message->GetReflection(); |
| Message* sub_message; |
| |
| reflection->SetRepeatedInt32(message, F("repeated_int32"), 1, 501); |
| reflection->SetRepeatedInt64(message, F("repeated_int64"), 1, 502); |
| reflection->SetRepeatedUInt32(message, F("repeated_uint32"), 1, 503); |
| reflection->SetRepeatedUInt64(message, F("repeated_uint64"), 1, 504); |
| reflection->SetRepeatedInt32(message, F("repeated_sint32"), 1, 505); |
| reflection->SetRepeatedInt64(message, F("repeated_sint64"), 1, 506); |
| reflection->SetRepeatedUInt32(message, F("repeated_fixed32"), 1, 507); |
| reflection->SetRepeatedUInt64(message, F("repeated_fixed64"), 1, 508); |
| reflection->SetRepeatedInt32(message, F("repeated_sfixed32"), 1, 509); |
| reflection->SetRepeatedInt64(message, F("repeated_sfixed64"), 1, 510); |
| reflection->SetRepeatedFloat(message, F("repeated_float"), 1, 511); |
| reflection->SetRepeatedDouble(message, F("repeated_double"), 1, 512); |
| reflection->SetRepeatedBool(message, F("repeated_bool"), 1, true); |
| reflection->SetRepeatedString(message, F("repeated_string"), 1, "515"); |
| reflection->SetRepeatedString(message, F("repeated_bytes"), 1, "516"); |
| |
| sub_message = |
| reflection->MutableRepeatedMessage(message, F("repeatedgroup"), 1); |
| sub_message->GetReflection()->SetInt32(sub_message, repeated_group_a_, 517); |
| sub_message = reflection->MutableRepeatedMessage( |
| message, F("repeated_nested_message"), 1); |
| sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 518); |
| sub_message = reflection->MutableRepeatedMessage( |
| message, F("repeated_foreign_message"), 1); |
| sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 519); |
| sub_message = reflection->MutableRepeatedMessage( |
| message, F("repeated_import_message"), 1); |
| sub_message->GetReflection()->SetInt32(sub_message, import_d_, 520); |
| sub_message = reflection->MutableRepeatedMessage( |
| message, F("repeated_lazy_message"), 1); |
| sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 527); |
| |
| reflection->SetRepeatedEnum(message, F("repeated_nested_enum"), 1, |
| nested_foo_); |
| reflection->SetRepeatedEnum(message, F("repeated_foreign_enum"), 1, |
| foreign_foo_); |
| reflection->SetRepeatedEnum(message, F("repeated_import_enum"), 1, |
| import_foo_); |
| |
| reflection->SetRepeatedString(message, F("repeated_string_piece"), 1, "524"); |
| reflection->SetRepeatedString(message, F("repeated_cord"), 1, "525"); |
| } |
| |
| inline void TestUtil::ReflectionTester::RemoveLastRepeatedsViaReflection( |
| Message* message) { |
| const Reflection* reflection = message->GetReflection(); |
| |
| std::vector<const FieldDescriptor*> output; |
| reflection->ListFields(*message, &output); |
| for (int i = 0; i < output.size(); ++i) { |
| const FieldDescriptor* field = output[i]; |
| if (!field->is_repeated()) continue; |
| |
| reflection->RemoveLast(message, field); |
| } |
| } |
| |
| inline void TestUtil::ReflectionTester::ReleaseLastRepeatedsViaReflection( |
| Message* message, bool expect_extensions_notnull) { |
| const Reflection* reflection = message->GetReflection(); |
| |
| std::vector<const FieldDescriptor*> output; |
| reflection->ListFields(*message, &output); |
| for (int i = 0; i < output.size(); ++i) { |
| const FieldDescriptor* field = output[i]; |
| if (!field->is_repeated()) continue; |
| if (field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) continue; |
| |
| Message* released = reflection->ReleaseLast(message, field); |
| if (!field->is_extension() || expect_extensions_notnull) { |
| ASSERT_TRUE(released != nullptr) |
| << "ReleaseLast returned nullptr for: " << field->name(); |
| } |
| delete released; |
| } |
| } |
| |
| inline void TestUtil::ReflectionTester::SwapRepeatedsViaReflection( |
| Message* message) { |
| const Reflection* reflection = message->GetReflection(); |
| |
| std::vector<const FieldDescriptor*> output; |
| reflection->ListFields(*message, &output); |
| for (int i = 0; i < output.size(); ++i) { |
| const FieldDescriptor* field = output[i]; |
| if (!field->is_repeated()) continue; |
| |
| reflection->SwapElements(message, field, 0, 1); |
| } |
| } |
| |
| inline void TestUtil::ReflectionTester:: |
| SetAllocatedOptionalMessageFieldsToNullViaReflection(Message* message) { |
| const Reflection* reflection = message->GetReflection(); |
| |
| std::vector<const FieldDescriptor*> fields; |
| reflection->ListFields(*message, &fields); |
| |
| for (int i = 0; i < fields.size(); ++i) { |
| const FieldDescriptor* field = fields[i]; |
| if (!field->is_optional() || |
| field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) |
| continue; |
| |
| reflection->SetAllocatedMessage(message, nullptr, field); |
| } |
| } |
| |
| inline void TestUtil::ReflectionTester:: |
| SetAllocatedOptionalMessageFieldsToMessageViaReflection( |
| Message* from_message, Message* to_message) { |
| EXPECT_EQ(from_message->GetDescriptor(), to_message->GetDescriptor()); |
| const Reflection* from_reflection = from_message->GetReflection(); |
| const Reflection* to_reflection = to_message->GetReflection(); |
| |
| std::vector<const FieldDescriptor*> fields; |
| from_reflection->ListFields(*from_message, &fields); |
| |
| for (int i = 0; i < fields.size(); ++i) { |
| const FieldDescriptor* field = fields[i]; |
| if (!field->is_optional() || |
| field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) |
| continue; |
| |
| Message* sub_message = from_reflection->ReleaseMessage(from_message, field); |
| to_reflection->SetAllocatedMessage(to_message, sub_message, field); |
| } |
| } |
| |
| inline void TestUtil::ReflectionTester::ExpectMessagesReleasedViaReflection( |
| Message* message, |
| TestUtil::ReflectionTester::MessageReleaseState expected_release_state) { |
| const Reflection* reflection = message->GetReflection(); |
| |
| static const char* fields[] = { |
| "optionalgroup", |
| "optional_nested_message", |
| "optional_foreign_message", |
| "optional_import_message", |
| }; |
| for (int i = 0; i < ABSL_ARRAYSIZE(fields); i++) { |
| Message* released = reflection->ReleaseMessage(message, F(fields[i])); |
| switch (expected_release_state) { |
| case IS_NULL: |
| EXPECT_TRUE(released == nullptr); |
| break; |
| case NOT_NULL: |
| EXPECT_TRUE(released != nullptr); |
| break; |
| case CAN_BE_NULL: |
| break; |
| } |
| delete released; |
| EXPECT_FALSE(reflection->HasField(*message, F(fields[i]))); |
| } |
| } |
| |
| // Check that the passed-in serialization is the canonical serialization we |
| // expect for a TestFieldOrderings message filled in by |
| // SetAllFieldsAndExtensions(). |
| inline void ExpectAllFieldsAndExtensionsInOrder(const std::string& serialized) { |
| // We set each field individually, serialize separately, and concatenate all |
| // the strings in canonical order to determine the expected serialization. |
| std::string expected; |
| unittest::TestFieldOrderings message; |
| message.set_my_int(1); // Field 1. |
| message.AppendToString(&expected); |
| message.Clear(); |
| message.SetExtension(unittest::my_extension_int, 23); // Field 5. |
| message.AppendToString(&expected); |
| message.Clear(); |
| message.set_my_string("foo"); // Field 11. |
| message.AppendToString(&expected); |
| message.Clear(); |
| message.SetExtension(unittest::my_extension_string, "bar"); // Field 50. |
| message.AppendToString(&expected); |
| message.Clear(); |
| message.set_my_float(1.0); // Field 101. |
| message.AppendToString(&expected); |
| message.Clear(); |
| |
| // We don't EXPECT_EQ() since we don't want to print raw bytes to stdout. |
| EXPECT_TRUE(serialized == expected); |
| } |
| |
| } // namespace TestUtil |
| } // namespace protobuf |
| } // namespace google |
| |
| #include "google/protobuf/port_undef.inc" |
| |
| #endif // GOOGLE_PROTOBUF_TEST_UTIL_H__ |
