From 779f61c6a3ce02a119e28e802f229e61b69b9046 Mon Sep 17 00:00:00 2001 From: temporal Date: Wed, 13 Aug 2008 03:15:00 +0000 Subject: Integrate recent changes from google3. protoc - New flags --encode and --decode can be used to convert between protobuf text format and binary format from the command-line. - New flag --descriptor_set_out can be used to write FileDescriptorProtos for all parsed files directly into a single output file. This is particularly useful if you wish to parse .proto files from programs written in languages other than C++: just run protoc as a background process and have it output a FileDescriptorList, then parse that natively. C++ - Reflection objects are now per-class rather than per-instance. To make this possible, the Reflection interface had to be changed such that all methods take the Message instance as a parameter. This change improves performance significantly in memory-bandwidth-limited use cases, since it makes the message objects smaller. Note that source-incompatible interface changes like this will not be made again after the library leaves beta. Python - MergeFrom(message) and CopyFrom(message) are now implemented. - SerializeToString() raises an exception if the message is missing required fields. - Code organization improvements. - Fixed doc comments for RpcController and RpcChannel, which had somehow been swapped. --- src/google/protobuf/test_util.cc | 1082 +++++++++++++++++++------------------- 1 file changed, 545 insertions(+), 537 deletions(-) (limited to 'src/google/protobuf/test_util.cc') diff --git a/src/google/protobuf/test_util.cc b/src/google/protobuf/test_util.cc index 1525e94f..59d98736 100644 --- a/src/google/protobuf/test_util.cc +++ b/src/google/protobuf/test_util.cc @@ -58,9 +58,11 @@ void TestUtil::SetAllFields(unittest::TestAllTypes* message) { // StringPiece and Cord fields are only accessible via reflection in the // open source release; see comments in compiler/cpp/string_field.cc. message->GetReflection()->SetString( + message, message->GetDescriptor()->FindFieldByName("optional_string_piece"), "124"); message->GetReflection()->SetString( + message, message->GetDescriptor()->FindFieldByName("optional_cord"), "125"); @@ -92,9 +94,11 @@ void TestUtil::SetAllFields(unittest::TestAllTypes* message) { message->add_repeated_import_enum (unittest_import::IMPORT_BAR); message->GetReflection()->AddString( + message, message->GetDescriptor()->FindFieldByName("repeated_string_piece"), "224"); message->GetReflection()->AddString( + message, message->GetDescriptor()->FindFieldByName("repeated_cord"), "225"); @@ -125,9 +129,11 @@ void TestUtil::SetAllFields(unittest::TestAllTypes* message) { message->add_repeated_import_enum (unittest_import::IMPORT_BAZ); message->GetReflection()->AddString( + message, message->GetDescriptor()->FindFieldByName("repeated_string_piece"), "324"); message->GetReflection()->AddString( + message, message->GetDescriptor()->FindFieldByName("repeated_cord"), "325"); @@ -154,9 +160,11 @@ void TestUtil::SetAllFields(unittest::TestAllTypes* message) { message->set_default_import_enum (unittest_import::IMPORT_FOO); message->GetReflection()->SetString( + message, message->GetDescriptor()->FindFieldByName("default_string_piece"), "424"); message->GetReflection()->SetString( + message, message->GetDescriptor()->FindFieldByName("default_cord"), "425"); } @@ -190,9 +198,11 @@ void TestUtil::ModifyRepeatedFields(unittest::TestAllTypes* message) { message->set_repeated_import_enum (1, unittest_import::IMPORT_FOO); message->GetReflection()->SetRepeatedString( + message, message->GetDescriptor()->FindFieldByName("repeated_string_piece"), 1, "424"); message->GetReflection()->SetRepeatedString( + message, message->GetDescriptor()->FindFieldByName("repeated_cord"), 1, "425"); } @@ -1322,590 +1332,588 @@ const FieldDescriptor* TestUtil::ReflectionTester::F(const string& name) { // ------------------------------------------------------------------- -void TestUtil::ReflectionTester::SetAllFieldsViaReflection( - Message::Reflection* message) { - message->SetInt32 (F("optional_int32" ), 101); - message->SetInt64 (F("optional_int64" ), 102); - message->SetUInt32(F("optional_uint32" ), 103); - message->SetUInt64(F("optional_uint64" ), 104); - message->SetInt32 (F("optional_sint32" ), 105); - message->SetInt64 (F("optional_sint64" ), 106); - message->SetUInt32(F("optional_fixed32" ), 107); - message->SetUInt64(F("optional_fixed64" ), 108); - message->SetInt32 (F("optional_sfixed32"), 109); - message->SetInt64 (F("optional_sfixed64"), 110); - message->SetFloat (F("optional_float" ), 111); - message->SetDouble(F("optional_double" ), 112); - message->SetBool (F("optional_bool" ), true); - message->SetString(F("optional_string" ), "115"); - message->SetString(F("optional_bytes" ), "116"); - - message->MutableMessage(F("optionalgroup")) - ->GetReflection()->SetInt32(group_a_, 117); - message->MutableMessage(F("optional_nested_message")) - ->GetReflection()->SetInt32(nested_b_, 118); - message->MutableMessage(F("optional_foreign_message")) - ->GetReflection()->SetInt32(foreign_c_, 119); - message->MutableMessage(F("optional_import_message")) - ->GetReflection()->SetInt32(import_d_, 120); - - message->SetEnum(F("optional_nested_enum" ), nested_baz_); - message->SetEnum(F("optional_foreign_enum"), foreign_baz_); - message->SetEnum(F("optional_import_enum" ), import_baz_); - - message->SetString(F("optional_string_piece"), "124"); - message->SetString(F("optional_cord"), "125"); +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"); // ----------------------------------------------------------------- - message->AddInt32 (F("repeated_int32" ), 201); - message->AddInt64 (F("repeated_int64" ), 202); - message->AddUInt32(F("repeated_uint32" ), 203); - message->AddUInt64(F("repeated_uint64" ), 204); - message->AddInt32 (F("repeated_sint32" ), 205); - message->AddInt64 (F("repeated_sint64" ), 206); - message->AddUInt32(F("repeated_fixed32" ), 207); - message->AddUInt64(F("repeated_fixed64" ), 208); - message->AddInt32 (F("repeated_sfixed32"), 209); - message->AddInt64 (F("repeated_sfixed64"), 210); - message->AddFloat (F("repeated_float" ), 211); - message->AddDouble(F("repeated_double" ), 212); - message->AddBool (F("repeated_bool" ), true); - message->AddString(F("repeated_string" ), "215"); - message->AddString(F("repeated_bytes" ), "216"); - - message->AddMessage(F("repeatedgroup")) - ->GetReflection()->SetInt32(repeated_group_a_, 217); - message->AddMessage(F("repeated_nested_message")) - ->GetReflection()->SetInt32(nested_b_, 218); - message->AddMessage(F("repeated_foreign_message")) - ->GetReflection()->SetInt32(foreign_c_, 219); - message->AddMessage(F("repeated_import_message")) - ->GetReflection()->SetInt32(import_d_, 220); - - message->AddEnum(F("repeated_nested_enum" ), nested_bar_); - message->AddEnum(F("repeated_foreign_enum"), foreign_bar_); - message->AddEnum(F("repeated_import_enum" ), import_bar_); - - message->AddString(F("repeated_string_piece"), "224"); - message->AddString(F("repeated_cord"), "225"); + 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); + + 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. - message->AddInt32 (F("repeated_int32" ), 301); - message->AddInt64 (F("repeated_int64" ), 302); - message->AddUInt32(F("repeated_uint32" ), 303); - message->AddUInt64(F("repeated_uint64" ), 304); - message->AddInt32 (F("repeated_sint32" ), 305); - message->AddInt64 (F("repeated_sint64" ), 306); - message->AddUInt32(F("repeated_fixed32" ), 307); - message->AddUInt64(F("repeated_fixed64" ), 308); - message->AddInt32 (F("repeated_sfixed32"), 309); - message->AddInt64 (F("repeated_sfixed64"), 310); - message->AddFloat (F("repeated_float" ), 311); - message->AddDouble(F("repeated_double" ), 312); - message->AddBool (F("repeated_bool" ), false); - message->AddString(F("repeated_string" ), "315"); - message->AddString(F("repeated_bytes" ), "316"); - - message->AddMessage(F("repeatedgroup")) - ->GetReflection()->SetInt32(repeated_group_a_, 317); - message->AddMessage(F("repeated_nested_message")) - ->GetReflection()->SetInt32(nested_b_, 318); - message->AddMessage(F("repeated_foreign_message")) - ->GetReflection()->SetInt32(foreign_c_, 319); - message->AddMessage(F("repeated_import_message")) - ->GetReflection()->SetInt32(import_d_, 320); - - message->AddEnum(F("repeated_nested_enum" ), nested_baz_); - message->AddEnum(F("repeated_foreign_enum"), foreign_baz_); - message->AddEnum(F("repeated_import_enum" ), import_baz_); - - message->AddString(F("repeated_string_piece"), "324"); - message->AddString(F("repeated_cord"), "325"); + 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); + + 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"); // ----------------------------------------------------------------- - message->SetInt32 (F("default_int32" ), 401); - message->SetInt64 (F("default_int64" ), 402); - message->SetUInt32(F("default_uint32" ), 403); - message->SetUInt64(F("default_uint64" ), 404); - message->SetInt32 (F("default_sint32" ), 405); - message->SetInt64 (F("default_sint64" ), 406); - message->SetUInt32(F("default_fixed32" ), 407); - message->SetUInt64(F("default_fixed64" ), 408); - message->SetInt32 (F("default_sfixed32"), 409); - message->SetInt64 (F("default_sfixed64"), 410); - message->SetFloat (F("default_float" ), 411); - message->SetDouble(F("default_double" ), 412); - message->SetBool (F("default_bool" ), false); - message->SetString(F("default_string" ), "415"); - message->SetString(F("default_bytes" ), "416"); - - message->SetEnum(F("default_nested_enum" ), nested_foo_); - message->SetEnum(F("default_foreign_enum"), foreign_foo_); - message->SetEnum(F("default_import_enum" ), import_foo_); - - message->SetString(F("default_string_piece"), "424"); - message->SetString(F("default_cord"), "425"); + 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"); } // ------------------------------------------------------------------- void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection( - const Message::Reflection& message) { + const Message& message) { + const Reflection* reflection = message.GetReflection(); string scratch; - - EXPECT_TRUE(message.HasField(F("optional_int32" ))); - EXPECT_TRUE(message.HasField(F("optional_int64" ))); - EXPECT_TRUE(message.HasField(F("optional_uint32" ))); - EXPECT_TRUE(message.HasField(F("optional_uint64" ))); - EXPECT_TRUE(message.HasField(F("optional_sint32" ))); - EXPECT_TRUE(message.HasField(F("optional_sint64" ))); - EXPECT_TRUE(message.HasField(F("optional_fixed32" ))); - EXPECT_TRUE(message.HasField(F("optional_fixed64" ))); - EXPECT_TRUE(message.HasField(F("optional_sfixed32"))); - EXPECT_TRUE(message.HasField(F("optional_sfixed64"))); - EXPECT_TRUE(message.HasField(F("optional_float" ))); - EXPECT_TRUE(message.HasField(F("optional_double" ))); - EXPECT_TRUE(message.HasField(F("optional_bool" ))); - EXPECT_TRUE(message.HasField(F("optional_string" ))); - EXPECT_TRUE(message.HasField(F("optional_bytes" ))); - - EXPECT_TRUE(message.HasField(F("optionalgroup" ))); - EXPECT_TRUE(message.HasField(F("optional_nested_message" ))); - EXPECT_TRUE(message.HasField(F("optional_foreign_message"))); - EXPECT_TRUE(message.HasField(F("optional_import_message" ))); - - EXPECT_TRUE(message.GetMessage(F("optionalgroup")) - .GetReflection()->HasField(group_a_)); - EXPECT_TRUE(message.GetMessage(F("optional_nested_message")) - .GetReflection()->HasField(nested_b_)); - EXPECT_TRUE(message.GetMessage(F("optional_foreign_message")) - .GetReflection()->HasField(foreign_c_)); - EXPECT_TRUE(message.GetMessage(F("optional_import_message")) - .GetReflection()->HasField(import_d_)); - - EXPECT_TRUE(message.HasField(F("optional_nested_enum" ))); - EXPECT_TRUE(message.HasField(F("optional_foreign_enum"))); - EXPECT_TRUE(message.HasField(F("optional_import_enum" ))); - - EXPECT_TRUE(message.HasField(F("optional_string_piece"))); - EXPECT_TRUE(message.HasField(F("optional_cord"))); - - EXPECT_EQ(101 , message.GetInt32 (F("optional_int32" ))); - EXPECT_EQ(102 , message.GetInt64 (F("optional_int64" ))); - EXPECT_EQ(103 , message.GetUInt32(F("optional_uint32" ))); - EXPECT_EQ(104 , message.GetUInt64(F("optional_uint64" ))); - EXPECT_EQ(105 , message.GetInt32 (F("optional_sint32" ))); - EXPECT_EQ(106 , message.GetInt64 (F("optional_sint64" ))); - EXPECT_EQ(107 , message.GetUInt32(F("optional_fixed32" ))); - EXPECT_EQ(108 , message.GetUInt64(F("optional_fixed64" ))); - EXPECT_EQ(109 , message.GetInt32 (F("optional_sfixed32"))); - EXPECT_EQ(110 , message.GetInt64 (F("optional_sfixed64"))); - EXPECT_EQ(111 , message.GetFloat (F("optional_float" ))); - EXPECT_EQ(112 , message.GetDouble(F("optional_double" ))); - EXPECT_EQ(true , message.GetBool (F("optional_bool" ))); - EXPECT_EQ("115", message.GetString(F("optional_string" ))); - EXPECT_EQ("116", message.GetString(F("optional_bytes" ))); - - EXPECT_EQ("115", message.GetStringReference(F("optional_string"), &scratch)); - EXPECT_EQ("116", message.GetStringReference(F("optional_bytes" ), &scratch)); - - EXPECT_EQ(117, message.GetMessage(F("optionalgroup")) - .GetReflection()->GetInt32(group_a_)); - EXPECT_EQ(118, message.GetMessage(F("optional_nested_message")) - .GetReflection()->GetInt32(nested_b_)); - EXPECT_EQ(119, message.GetMessage(F("optional_foreign_message")) - .GetReflection()->GetInt32(foreign_c_)); - EXPECT_EQ(120, message.GetMessage(F("optional_import_message")) - .GetReflection()->GetInt32(import_d_)); - - EXPECT_EQ( nested_baz_, message.GetEnum(F("optional_nested_enum" ))); - EXPECT_EQ(foreign_baz_, message.GetEnum(F("optional_foreign_enum"))); - EXPECT_EQ( import_baz_, message.GetEnum(F("optional_import_enum" ))); - - EXPECT_EQ("124", message.GetString(F("optional_string_piece"))); - EXPECT_EQ("124", message.GetStringReference(F("optional_string_piece"), - &scratch)); - - EXPECT_EQ("125", message.GetString(F("optional_cord"))); - EXPECT_EQ("125", message.GetStringReference(F("optional_cord"), - &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" ))); + + 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_)); + + 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_EQ(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_)); + + 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)); // ----------------------------------------------------------------- - ASSERT_EQ(2, message.FieldSize(F("repeated_int32" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_int64" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_uint32" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_uint64" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_sint32" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_sint64" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_fixed32" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_fixed64" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_sfixed32"))); - ASSERT_EQ(2, message.FieldSize(F("repeated_sfixed64"))); - ASSERT_EQ(2, message.FieldSize(F("repeated_float" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_double" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_bool" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_string" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_bytes" ))); - - ASSERT_EQ(2, message.FieldSize(F("repeatedgroup" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_nested_message" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_foreign_message"))); - ASSERT_EQ(2, message.FieldSize(F("repeated_import_message" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_nested_enum" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_foreign_enum" ))); - ASSERT_EQ(2, message.FieldSize(F("repeated_import_enum" ))); - - ASSERT_EQ(2, message.FieldSize(F("repeated_string_piece"))); - ASSERT_EQ(2, message.FieldSize(F("repeated_cord"))); - - EXPECT_EQ(201 , message.GetRepeatedInt32 (F("repeated_int32" ), 0)); - EXPECT_EQ(202 , message.GetRepeatedInt64 (F("repeated_int64" ), 0)); - EXPECT_EQ(203 , message.GetRepeatedUInt32(F("repeated_uint32" ), 0)); - EXPECT_EQ(204 , message.GetRepeatedUInt64(F("repeated_uint64" ), 0)); - EXPECT_EQ(205 , message.GetRepeatedInt32 (F("repeated_sint32" ), 0)); - EXPECT_EQ(206 , message.GetRepeatedInt64 (F("repeated_sint64" ), 0)); - EXPECT_EQ(207 , message.GetRepeatedUInt32(F("repeated_fixed32" ), 0)); - EXPECT_EQ(208 , message.GetRepeatedUInt64(F("repeated_fixed64" ), 0)); - EXPECT_EQ(209 , message.GetRepeatedInt32 (F("repeated_sfixed32"), 0)); - EXPECT_EQ(210 , message.GetRepeatedInt64 (F("repeated_sfixed64"), 0)); - EXPECT_EQ(211 , message.GetRepeatedFloat (F("repeated_float" ), 0)); - EXPECT_EQ(212 , message.GetRepeatedDouble(F("repeated_double" ), 0)); - EXPECT_EQ(true , message.GetRepeatedBool (F("repeated_bool" ), 0)); - EXPECT_EQ("215", message.GetRepeatedString(F("repeated_string" ), 0)); - EXPECT_EQ("216", message.GetRepeatedString(F("repeated_bytes" ), 0)); - - EXPECT_EQ("215", message.GetRepeatedStringReference(F("repeated_string"), - 0, &scratch)); - EXPECT_EQ("216", message.GetRepeatedStringReference(F("repeated_bytes"), - 0, &scratch)); - - EXPECT_EQ(217, message.GetRepeatedMessage(F("repeatedgroup"), 0) - .GetReflection()->GetInt32(repeated_group_a_)); - EXPECT_EQ(218, message.GetRepeatedMessage(F("repeated_nested_message"), 0) - .GetReflection()->GetInt32(nested_b_)); - EXPECT_EQ(219, message.GetRepeatedMessage(F("repeated_foreign_message"), 0) - .GetReflection()->GetInt32(foreign_c_)); - EXPECT_EQ(220, message.GetRepeatedMessage(F("repeated_import_message"), 0) - .GetReflection()->GetInt32(import_d_)); - - EXPECT_EQ( nested_bar_, message.GetRepeatedEnum(F("repeated_nested_enum" ),0)); - EXPECT_EQ(foreign_bar_, message.GetRepeatedEnum(F("repeated_foreign_enum"),0)); - EXPECT_EQ( import_bar_, message.GetRepeatedEnum(F("repeated_import_enum" ),0)); - - EXPECT_EQ("224", message.GetRepeatedString(F("repeated_string_piece"), 0)); - EXPECT_EQ("224", message.GetRepeatedStringReference( - F("repeated_string_piece"), 0, &scratch)); - - EXPECT_EQ("225", message.GetRepeatedString(F("repeated_cord"), 0)); - EXPECT_EQ("225", message.GetRepeatedStringReference( - F("repeated_cord"), 0, &scratch)); - - EXPECT_EQ(301 , message.GetRepeatedInt32 (F("repeated_int32" ), 1)); - EXPECT_EQ(302 , message.GetRepeatedInt64 (F("repeated_int64" ), 1)); - EXPECT_EQ(303 , message.GetRepeatedUInt32(F("repeated_uint32" ), 1)); - EXPECT_EQ(304 , message.GetRepeatedUInt64(F("repeated_uint64" ), 1)); - EXPECT_EQ(305 , message.GetRepeatedInt32 (F("repeated_sint32" ), 1)); - EXPECT_EQ(306 , message.GetRepeatedInt64 (F("repeated_sint64" ), 1)); - EXPECT_EQ(307 , message.GetRepeatedUInt32(F("repeated_fixed32" ), 1)); - EXPECT_EQ(308 , message.GetRepeatedUInt64(F("repeated_fixed64" ), 1)); - EXPECT_EQ(309 , message.GetRepeatedInt32 (F("repeated_sfixed32"), 1)); - EXPECT_EQ(310 , message.GetRepeatedInt64 (F("repeated_sfixed64"), 1)); - EXPECT_EQ(311 , message.GetRepeatedFloat (F("repeated_float" ), 1)); - EXPECT_EQ(312 , message.GetRepeatedDouble(F("repeated_double" ), 1)); - EXPECT_EQ(false, message.GetRepeatedBool (F("repeated_bool" ), 1)); - EXPECT_EQ("315", message.GetRepeatedString(F("repeated_string" ), 1)); - EXPECT_EQ("316", message.GetRepeatedString(F("repeated_bytes" ), 1)); - - EXPECT_EQ("315", message.GetRepeatedStringReference(F("repeated_string"), - 1, &scratch)); - EXPECT_EQ("316", message.GetRepeatedStringReference(F("repeated_bytes"), - 1, &scratch)); - - EXPECT_EQ(317, message.GetRepeatedMessage(F("repeatedgroup"), 1) - .GetReflection()->GetInt32(repeated_group_a_)); - EXPECT_EQ(318, message.GetRepeatedMessage(F("repeated_nested_message"), 1) - .GetReflection()->GetInt32(nested_b_)); - EXPECT_EQ(319, message.GetRepeatedMessage(F("repeated_foreign_message"), 1) - .GetReflection()->GetInt32(foreign_c_)); - EXPECT_EQ(320, message.GetRepeatedMessage(F("repeated_import_message"), 1) - .GetReflection()->GetInt32(import_d_)); - - EXPECT_EQ( nested_baz_, message.GetRepeatedEnum(F("repeated_nested_enum" ),1)); - EXPECT_EQ(foreign_baz_, message.GetRepeatedEnum(F("repeated_foreign_enum"),1)); - EXPECT_EQ( import_baz_, message.GetRepeatedEnum(F("repeated_import_enum" ),1)); - - EXPECT_EQ("324", message.GetRepeatedString(F("repeated_string_piece"), 1)); - EXPECT_EQ("324", message.GetRepeatedStringReference( - F("repeated_string_piece"), 1, &scratch)); - - EXPECT_EQ("325", message.GetRepeatedString(F("repeated_cord"), 1)); - EXPECT_EQ("325", message.GetRepeatedStringReference( - F("repeated_cord"), 1, &scratch)); + 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_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_EQ(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_)); + + 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_EQ(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_)); + + 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)); // ----------------------------------------------------------------- - EXPECT_TRUE(message.HasField(F("default_int32" ))); - EXPECT_TRUE(message.HasField(F("default_int64" ))); - EXPECT_TRUE(message.HasField(F("default_uint32" ))); - EXPECT_TRUE(message.HasField(F("default_uint64" ))); - EXPECT_TRUE(message.HasField(F("default_sint32" ))); - EXPECT_TRUE(message.HasField(F("default_sint64" ))); - EXPECT_TRUE(message.HasField(F("default_fixed32" ))); - EXPECT_TRUE(message.HasField(F("default_fixed64" ))); - EXPECT_TRUE(message.HasField(F("default_sfixed32"))); - EXPECT_TRUE(message.HasField(F("default_sfixed64"))); - EXPECT_TRUE(message.HasField(F("default_float" ))); - EXPECT_TRUE(message.HasField(F("default_double" ))); - EXPECT_TRUE(message.HasField(F("default_bool" ))); - EXPECT_TRUE(message.HasField(F("default_string" ))); - EXPECT_TRUE(message.HasField(F("default_bytes" ))); - - EXPECT_TRUE(message.HasField(F("default_nested_enum" ))); - EXPECT_TRUE(message.HasField(F("default_foreign_enum"))); - EXPECT_TRUE(message.HasField(F("default_import_enum" ))); - - EXPECT_TRUE(message.HasField(F("default_string_piece"))); - EXPECT_TRUE(message.HasField(F("default_cord"))); - - EXPECT_EQ(401 , message.GetInt32 (F("default_int32" ))); - EXPECT_EQ(402 , message.GetInt64 (F("default_int64" ))); - EXPECT_EQ(403 , message.GetUInt32(F("default_uint32" ))); - EXPECT_EQ(404 , message.GetUInt64(F("default_uint64" ))); - EXPECT_EQ(405 , message.GetInt32 (F("default_sint32" ))); - EXPECT_EQ(406 , message.GetInt64 (F("default_sint64" ))); - EXPECT_EQ(407 , message.GetUInt32(F("default_fixed32" ))); - EXPECT_EQ(408 , message.GetUInt64(F("default_fixed64" ))); - EXPECT_EQ(409 , message.GetInt32 (F("default_sfixed32"))); - EXPECT_EQ(410 , message.GetInt64 (F("default_sfixed64"))); - EXPECT_EQ(411 , message.GetFloat (F("default_float" ))); - EXPECT_EQ(412 , message.GetDouble(F("default_double" ))); - EXPECT_EQ(false, message.GetBool (F("default_bool" ))); - EXPECT_EQ("415", message.GetString(F("default_string" ))); - EXPECT_EQ("416", message.GetString(F("default_bytes" ))); - - EXPECT_EQ("415", message.GetStringReference(F("default_string"), &scratch)); - EXPECT_EQ("416", message.GetStringReference(F("default_bytes" ), &scratch)); - - EXPECT_EQ( nested_foo_, message.GetEnum(F("default_nested_enum" ))); - EXPECT_EQ(foreign_foo_, message.GetEnum(F("default_foreign_enum"))); - EXPECT_EQ( import_foo_, message.GetEnum(F("default_import_enum" ))); - - EXPECT_EQ("424", message.GetString(F("default_string_piece"))); - EXPECT_EQ("424", message.GetStringReference(F("default_string_piece"), - &scratch)); - - EXPECT_EQ("425", message.GetString(F("default_cord"))); - EXPECT_EQ("425", message.GetStringReference(F("default_cord"), &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_EQ(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)); } // ------------------------------------------------------------------- void TestUtil::ReflectionTester::ExpectClearViaReflection( - const Message::Reflection& message) { + const Message& message) { + const Reflection* reflection = message.GetReflection(); string scratch; + const Message* sub_message; // has_blah() should initially be false for all optional fields. - EXPECT_FALSE(message.HasField(F("optional_int32" ))); - EXPECT_FALSE(message.HasField(F("optional_int64" ))); - EXPECT_FALSE(message.HasField(F("optional_uint32" ))); - EXPECT_FALSE(message.HasField(F("optional_uint64" ))); - EXPECT_FALSE(message.HasField(F("optional_sint32" ))); - EXPECT_FALSE(message.HasField(F("optional_sint64" ))); - EXPECT_FALSE(message.HasField(F("optional_fixed32" ))); - EXPECT_FALSE(message.HasField(F("optional_fixed64" ))); - EXPECT_FALSE(message.HasField(F("optional_sfixed32"))); - EXPECT_FALSE(message.HasField(F("optional_sfixed64"))); - EXPECT_FALSE(message.HasField(F("optional_float" ))); - EXPECT_FALSE(message.HasField(F("optional_double" ))); - EXPECT_FALSE(message.HasField(F("optional_bool" ))); - EXPECT_FALSE(message.HasField(F("optional_string" ))); - EXPECT_FALSE(message.HasField(F("optional_bytes" ))); - - EXPECT_FALSE(message.HasField(F("optionalgroup" ))); - EXPECT_FALSE(message.HasField(F("optional_nested_message" ))); - EXPECT_FALSE(message.HasField(F("optional_foreign_message"))); - EXPECT_FALSE(message.HasField(F("optional_import_message" ))); - - EXPECT_FALSE(message.HasField(F("optional_nested_enum" ))); - EXPECT_FALSE(message.HasField(F("optional_foreign_enum"))); - EXPECT_FALSE(message.HasField(F("optional_import_enum" ))); - - EXPECT_FALSE(message.HasField(F("optional_string_piece"))); - EXPECT_FALSE(message.HasField(F("optional_cord"))); + 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_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 , message.GetInt32 (F("optional_int32" ))); - EXPECT_EQ(0 , message.GetInt64 (F("optional_int64" ))); - EXPECT_EQ(0 , message.GetUInt32(F("optional_uint32" ))); - EXPECT_EQ(0 , message.GetUInt64(F("optional_uint64" ))); - EXPECT_EQ(0 , message.GetInt32 (F("optional_sint32" ))); - EXPECT_EQ(0 , message.GetInt64 (F("optional_sint64" ))); - EXPECT_EQ(0 , message.GetUInt32(F("optional_fixed32" ))); - EXPECT_EQ(0 , message.GetUInt64(F("optional_fixed64" ))); - EXPECT_EQ(0 , message.GetInt32 (F("optional_sfixed32"))); - EXPECT_EQ(0 , message.GetInt64 (F("optional_sfixed64"))); - EXPECT_EQ(0 , message.GetFloat (F("optional_float" ))); - EXPECT_EQ(0 , message.GetDouble(F("optional_double" ))); - EXPECT_EQ(false, message.GetBool (F("optional_bool" ))); - EXPECT_EQ("" , message.GetString(F("optional_string" ))); - EXPECT_EQ("" , message.GetString(F("optional_bytes" ))); - - EXPECT_EQ("", message.GetStringReference(F("optional_string"), &scratch)); - EXPECT_EQ("", message.GetStringReference(F("optional_bytes" ), &scratch)); + 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_EQ(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. - EXPECT_FALSE(message.GetMessage(F("optionalgroup")) - .GetReflection()->HasField(group_a_)); - EXPECT_FALSE(message.GetMessage(F("optional_nested_message")) - .GetReflection()->HasField(nested_b_)); - EXPECT_FALSE(message.GetMessage(F("optional_foreign_message")) - .GetReflection()->HasField(foreign_c_)); - EXPECT_FALSE(message.GetMessage(F("optional_import_message")) - .GetReflection()->HasField(import_d_)); - - EXPECT_EQ(0, message.GetMessage(F("optionalgroup")) - .GetReflection()->GetInt32(group_a_)); - EXPECT_EQ(0, message.GetMessage(F("optional_nested_message")) - .GetReflection()->GetInt32(nested_b_)); - EXPECT_EQ(0, message.GetMessage(F("optional_foreign_message")) - .GetReflection()->GetInt32(foreign_c_)); - EXPECT_EQ(0, message.GetMessage(F("optional_import_message")) - .GetReflection()->GetInt32(import_d_)); + 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_)); // Enums without defaults are set to the first value in the enum. - EXPECT_EQ( nested_foo_, message.GetEnum(F("optional_nested_enum" ))); - EXPECT_EQ(foreign_foo_, message.GetEnum(F("optional_foreign_enum"))); - EXPECT_EQ( import_foo_, message.GetEnum(F("optional_import_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("", message.GetString(F("optional_string_piece"))); - EXPECT_EQ("", message.GetStringReference(F("optional_string_piece"), - &scratch)); + EXPECT_EQ("", reflection->GetString(message, F("optional_string_piece"))); + EXPECT_EQ("", reflection->GetStringReference(message, F("optional_string_piece"), &scratch)); - EXPECT_EQ("", message.GetString(F("optional_cord"))); - EXPECT_EQ("", message.GetStringReference(F("optional_cord"), &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, message.FieldSize(F("repeated_int32" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_int64" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_uint32" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_uint64" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_sint32" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_sint64" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_fixed32" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_fixed64" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_sfixed32"))); - EXPECT_EQ(0, message.FieldSize(F("repeated_sfixed64"))); - EXPECT_EQ(0, message.FieldSize(F("repeated_float" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_double" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_bool" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_string" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_bytes" ))); - - EXPECT_EQ(0, message.FieldSize(F("repeatedgroup" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_nested_message" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_foreign_message"))); - EXPECT_EQ(0, message.FieldSize(F("repeated_import_message" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_nested_enum" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_foreign_enum" ))); - EXPECT_EQ(0, message.FieldSize(F("repeated_import_enum" ))); - - EXPECT_EQ(0, message.FieldSize(F("repeated_string_piece"))); - EXPECT_EQ(0, message.FieldSize(F("repeated_cord"))); + 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_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(message.HasField(F("default_int32" ))); - EXPECT_FALSE(message.HasField(F("default_int64" ))); - EXPECT_FALSE(message.HasField(F("default_uint32" ))); - EXPECT_FALSE(message.HasField(F("default_uint64" ))); - EXPECT_FALSE(message.HasField(F("default_sint32" ))); - EXPECT_FALSE(message.HasField(F("default_sint64" ))); - EXPECT_FALSE(message.HasField(F("default_fixed32" ))); - EXPECT_FALSE(message.HasField(F("default_fixed64" ))); - EXPECT_FALSE(message.HasField(F("default_sfixed32"))); - EXPECT_FALSE(message.HasField(F("default_sfixed64"))); - EXPECT_FALSE(message.HasField(F("default_float" ))); - EXPECT_FALSE(message.HasField(F("default_double" ))); - EXPECT_FALSE(message.HasField(F("default_bool" ))); - EXPECT_FALSE(message.HasField(F("default_string" ))); - EXPECT_FALSE(message.HasField(F("default_bytes" ))); - - EXPECT_FALSE(message.HasField(F("default_nested_enum" ))); - EXPECT_FALSE(message.HasField(F("default_foreign_enum"))); - EXPECT_FALSE(message.HasField(F("default_import_enum" ))); - - EXPECT_FALSE(message.HasField(F("default_string_piece"))); - EXPECT_FALSE(message.HasField(F("default_cord"))); + 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 , message.GetInt32 (F("default_int32" ))); - EXPECT_EQ( 42 , message.GetInt64 (F("default_int64" ))); - EXPECT_EQ( 43 , message.GetUInt32(F("default_uint32" ))); - EXPECT_EQ( 44 , message.GetUInt64(F("default_uint64" ))); - EXPECT_EQ(-45 , message.GetInt32 (F("default_sint32" ))); - EXPECT_EQ( 46 , message.GetInt64 (F("default_sint64" ))); - EXPECT_EQ( 47 , message.GetUInt32(F("default_fixed32" ))); - EXPECT_EQ( 48 , message.GetUInt64(F("default_fixed64" ))); - EXPECT_EQ( 49 , message.GetInt32 (F("default_sfixed32"))); - EXPECT_EQ(-50 , message.GetInt64 (F("default_sfixed64"))); - EXPECT_EQ( 51.5 , message.GetFloat (F("default_float" ))); - EXPECT_EQ( 52e3 , message.GetDouble(F("default_double" ))); - EXPECT_EQ(true , message.GetBool (F("default_bool" ))); - EXPECT_EQ("hello", message.GetString(F("default_string" ))); - EXPECT_EQ("world", message.GetString(F("default_bytes" ))); - - EXPECT_EQ("hello", message.GetStringReference(F("default_string"), &scratch)); - EXPECT_EQ("world", message.GetStringReference(F("default_bytes" ), &scratch)); - - EXPECT_EQ( nested_bar_, message.GetEnum(F("default_nested_enum" ))); - EXPECT_EQ(foreign_bar_, message.GetEnum(F("default_foreign_enum"))); - EXPECT_EQ( import_bar_, message.GetEnum(F("default_import_enum" ))); - - EXPECT_EQ("abc", message.GetString(F("default_string_piece"))); - EXPECT_EQ("abc", message.GetStringReference(F("default_string_piece"), - &scratch)); - - EXPECT_EQ("123", message.GetString(F("default_cord"))); - EXPECT_EQ("123", message.GetStringReference(F("default_cord"), &scratch)); + 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_EQ(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)); } // ------------------------------------------------------------------- void TestUtil::ReflectionTester::ModifyRepeatedFieldsViaReflection( - Message::Reflection* message) { - message->SetRepeatedInt32 (F("repeated_int32" ), 1, 501); - message->SetRepeatedInt64 (F("repeated_int64" ), 1, 502); - message->SetRepeatedUInt32(F("repeated_uint32" ), 1, 503); - message->SetRepeatedUInt64(F("repeated_uint64" ), 1, 504); - message->SetRepeatedInt32 (F("repeated_sint32" ), 1, 505); - message->SetRepeatedInt64 (F("repeated_sint64" ), 1, 506); - message->SetRepeatedUInt32(F("repeated_fixed32" ), 1, 507); - message->SetRepeatedUInt64(F("repeated_fixed64" ), 1, 508); - message->SetRepeatedInt32 (F("repeated_sfixed32"), 1, 509); - message->SetRepeatedInt64 (F("repeated_sfixed64"), 1, 510); - message->SetRepeatedFloat (F("repeated_float" ), 1, 511); - message->SetRepeatedDouble(F("repeated_double" ), 1, 512); - message->SetRepeatedBool (F("repeated_bool" ), 1, true); - message->SetRepeatedString(F("repeated_string" ), 1, "515"); - message->SetRepeatedString(F("repeated_bytes" ), 1, "516"); - - message->MutableRepeatedMessage(F("repeatedgroup"), 1) - ->GetReflection()->SetInt32(repeated_group_a_, 517); - message->MutableRepeatedMessage(F("repeated_nested_message"), 1) - ->GetReflection()->SetInt32(nested_b_, 518); - message->MutableRepeatedMessage(F("repeated_foreign_message"), 1) - ->GetReflection()->SetInt32(foreign_c_, 519); - message->MutableRepeatedMessage(F("repeated_import_message"), 1) - ->GetReflection()->SetInt32(import_d_, 520); - - message->SetRepeatedEnum(F("repeated_nested_enum" ), 1, nested_foo_); - message->SetRepeatedEnum(F("repeated_foreign_enum"), 1, foreign_foo_); - message->SetRepeatedEnum(F("repeated_import_enum" ), 1, import_foo_); - - message->SetRepeatedString(F("repeated_string_piece"), 1, "524"); - message->SetRepeatedString(F("repeated_cord"), 1, "525"); + 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); + + 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"); } } // namespace protobuf -- cgit v1.2.3