diff options
Diffstat (limited to 'src/google/protobuf/test_util.cc')
| -rw-r--r-- | src/google/protobuf/test_util.cc | 685 |
1 files changed, 588 insertions, 97 deletions
diff --git a/src/google/protobuf/test_util.cc b/src/google/protobuf/test_util.cc index af8b390..f3cf7a9 100644 --- a/src/google/protobuf/test_util.cc +++ b/src/google/protobuf/test_util.cc @@ -50,6 +50,14 @@ namespace google { namespace protobuf { void TestUtil::SetAllFields(unittest::TestAllTypes* message) { + SetOptionalFields(message); + AddRepeatedFields1(message); + AddRepeatedFields2(message); + SetDefaultFields(message); + SetOneofFields(message); +} + +void TestUtil::SetOptionalFields(unittest::TestAllTypes* message) { message->set_optional_int32 (101); message->set_optional_int64 (102); message->set_optional_uint32 (103); @@ -66,10 +74,12 @@ void TestUtil::SetAllFields(unittest::TestAllTypes* message) { message->set_optional_string ("115"); message->set_optional_bytes ("116"); - message->mutable_optionalgroup ()->set_a(117); - message->mutable_optional_nested_message ()->set_bb(118); - message->mutable_optional_foreign_message()->set_c(119); - message->mutable_optional_import_message ()->set_d(120); + message->mutable_optionalgroup ()->set_a(117); + message->mutable_optional_nested_message ()->set_bb(118); + message->mutable_optional_foreign_message ()->set_c(119); + message->mutable_optional_import_message ()->set_d(120); + message->mutable_optional_public_import_message()->set_e(126); + message->mutable_optional_lazy_message ()->set_bb(127); message->set_optional_nested_enum (unittest::TestAllTypes::BAZ); message->set_optional_foreign_enum(unittest::FOREIGN_BAZ ); @@ -87,9 +97,11 @@ void TestUtil::SetAllFields(unittest::TestAllTypes* message) { message->GetDescriptor()->FindFieldByName("optional_cord"), "125"); #endif // !PROTOBUF_TEST_NO_DESCRIPTORS +} - // ----------------------------------------------------------------- +// ------------------------------------------------------------------- +void TestUtil::AddRepeatedFields1(unittest::TestAllTypes* message) { message->add_repeated_int32 (201); message->add_repeated_int64 (202); message->add_repeated_uint32 (203); @@ -110,6 +122,7 @@ void TestUtil::SetAllFields(unittest::TestAllTypes* message) { message->add_repeated_nested_message ()->set_bb(218); message->add_repeated_foreign_message()->set_c(219); message->add_repeated_import_message ()->set_d(220); + message->add_repeated_lazy_message ()->set_bb(227); message->add_repeated_nested_enum (unittest::TestAllTypes::BAR); message->add_repeated_foreign_enum(unittest::FOREIGN_BAR ); @@ -125,7 +138,9 @@ void TestUtil::SetAllFields(unittest::TestAllTypes* message) { message->GetDescriptor()->FindFieldByName("repeated_cord"), "225"); #endif // !PROTOBUF_TEST_NO_DESCRIPTORS +} +void TestUtil::AddRepeatedFields2(unittest::TestAllTypes* message) { // Add a second one of each field. message->add_repeated_int32 (301); message->add_repeated_int64 (302); @@ -147,6 +162,7 @@ void TestUtil::SetAllFields(unittest::TestAllTypes* message) { message->add_repeated_nested_message ()->set_bb(318); message->add_repeated_foreign_message()->set_c(319); message->add_repeated_import_message ()->set_d(320); + message->add_repeated_lazy_message ()->set_bb(327); message->add_repeated_nested_enum (unittest::TestAllTypes::BAZ); message->add_repeated_foreign_enum(unittest::FOREIGN_BAZ ); @@ -162,9 +178,11 @@ void TestUtil::SetAllFields(unittest::TestAllTypes* message) { message->GetDescriptor()->FindFieldByName("repeated_cord"), "325"); #endif // !PROTOBUF_TEST_NO_DESCRIPTORS +} - // ----------------------------------------------------------------- +// ------------------------------------------------------------------- +void TestUtil::SetDefaultFields(unittest::TestAllTypes* message) { message->set_default_int32 (401); message->set_default_int64 (402); message->set_default_uint32 (403); @@ -220,6 +238,7 @@ void TestUtil::ModifyRepeatedFields(unittest::TestAllTypes* message) { message->mutable_repeated_nested_message (1)->set_bb(518); message->mutable_repeated_foreign_message(1)->set_c(519); message->mutable_repeated_import_message (1)->set_d(520); + message->mutable_repeated_lazy_message (1)->set_bb(527); message->set_repeated_nested_enum (1, unittest::TestAllTypes::FOO); message->set_repeated_foreign_enum(1, unittest::FOREIGN_FOO ); @@ -237,6 +256,14 @@ void TestUtil::ModifyRepeatedFields(unittest::TestAllTypes* message) { #endif // !PROTOBUF_TEST_NO_DESCRIPTORS } +// ------------------------------------------------------------------ +void TestUtil::SetOneofFields(unittest::TestAllTypes* message) { + message->set_oneof_uint32(601); + message->mutable_oneof_nested_message()->set_bb(602); + message->set_oneof_string("603"); + message->set_oneof_bytes("604"); +} + // ------------------------------------------------------------------- void TestUtil::ExpectAllFieldsSet(const unittest::TestAllTypes& message) { @@ -256,15 +283,19 @@ void TestUtil::ExpectAllFieldsSet(const unittest::TestAllTypes& message) { EXPECT_TRUE(message.has_optional_string ()); EXPECT_TRUE(message.has_optional_bytes ()); - EXPECT_TRUE(message.has_optionalgroup ()); - EXPECT_TRUE(message.has_optional_nested_message ()); - EXPECT_TRUE(message.has_optional_foreign_message()); - EXPECT_TRUE(message.has_optional_import_message ()); + EXPECT_TRUE(message.has_optionalgroup ()); + EXPECT_TRUE(message.has_optional_nested_message ()); + EXPECT_TRUE(message.has_optional_foreign_message ()); + EXPECT_TRUE(message.has_optional_import_message ()); + EXPECT_TRUE(message.has_optional_public_import_message()); + EXPECT_TRUE(message.has_optional_lazy_message ()); - EXPECT_TRUE(message.optionalgroup ().has_a()); - EXPECT_TRUE(message.optional_nested_message ().has_bb()); - EXPECT_TRUE(message.optional_foreign_message().has_c()); - EXPECT_TRUE(message.optional_import_message ().has_d()); + EXPECT_TRUE(message.optionalgroup ().has_a()); + EXPECT_TRUE(message.optional_nested_message ().has_bb()); + EXPECT_TRUE(message.optional_foreign_message ().has_c()); + EXPECT_TRUE(message.optional_import_message ().has_d()); + EXPECT_TRUE(message.optional_public_import_message().has_e()); + EXPECT_TRUE(message.optional_lazy_message ().has_bb()); EXPECT_TRUE(message.has_optional_nested_enum ()); EXPECT_TRUE(message.has_optional_foreign_enum()); @@ -287,14 +318,16 @@ void TestUtil::ExpectAllFieldsSet(const unittest::TestAllTypes& message) { EXPECT_EQ(110 , message.optional_sfixed64()); EXPECT_EQ(111 , message.optional_float ()); EXPECT_EQ(112 , message.optional_double ()); - EXPECT_EQ(true , message.optional_bool ()); + EXPECT_TRUE( message.optional_bool ()); EXPECT_EQ("115", message.optional_string ()); EXPECT_EQ("116", message.optional_bytes ()); - EXPECT_EQ(117, message.optionalgroup ().a()); - EXPECT_EQ(118, message.optional_nested_message ().bb()); - EXPECT_EQ(119, message.optional_foreign_message().c()); - EXPECT_EQ(120, message.optional_import_message ().d()); + EXPECT_EQ(117, message.optionalgroup ().a()); + EXPECT_EQ(118, message.optional_nested_message ().bb()); + EXPECT_EQ(119, message.optional_foreign_message ().c()); + EXPECT_EQ(120, message.optional_import_message ().d()); + EXPECT_EQ(126, message.optional_public_import_message ().e()); + EXPECT_EQ(127, message.optional_lazy_message ().bb()); EXPECT_EQ(unittest::TestAllTypes::BAZ, message.optional_nested_enum ()); EXPECT_EQ(unittest::FOREIGN_BAZ , message.optional_foreign_enum()); @@ -323,6 +356,7 @@ void TestUtil::ExpectAllFieldsSet(const unittest::TestAllTypes& message) { ASSERT_EQ(2, message.repeated_nested_message_size ()); ASSERT_EQ(2, message.repeated_foreign_message_size()); ASSERT_EQ(2, message.repeated_import_message_size ()); + ASSERT_EQ(2, message.repeated_lazy_message_size ()); ASSERT_EQ(2, message.repeated_nested_enum_size ()); ASSERT_EQ(2, message.repeated_foreign_enum_size ()); ASSERT_EQ(2, message.repeated_import_enum_size ()); @@ -344,7 +378,7 @@ void TestUtil::ExpectAllFieldsSet(const unittest::TestAllTypes& message) { EXPECT_EQ(210 , message.repeated_sfixed64(0)); EXPECT_EQ(211 , message.repeated_float (0)); EXPECT_EQ(212 , message.repeated_double (0)); - EXPECT_EQ(true , message.repeated_bool (0)); + EXPECT_TRUE( message.repeated_bool (0)); EXPECT_EQ("215", message.repeated_string (0)); EXPECT_EQ("216", message.repeated_bytes (0)); @@ -352,6 +386,7 @@ void TestUtil::ExpectAllFieldsSet(const unittest::TestAllTypes& message) { EXPECT_EQ(218, message.repeated_nested_message (0).bb()); EXPECT_EQ(219, message.repeated_foreign_message(0).c()); EXPECT_EQ(220, message.repeated_import_message (0).d()); + EXPECT_EQ(227, message.repeated_lazy_message (0).bb()); EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (0)); @@ -370,7 +405,7 @@ void TestUtil::ExpectAllFieldsSet(const unittest::TestAllTypes& message) { EXPECT_EQ(310 , message.repeated_sfixed64(1)); EXPECT_EQ(311 , message.repeated_float (1)); EXPECT_EQ(312 , message.repeated_double (1)); - EXPECT_EQ(false, message.repeated_bool (1)); + EXPECT_FALSE( message.repeated_bool (1)); EXPECT_EQ("315", message.repeated_string (1)); EXPECT_EQ("316", message.repeated_bytes (1)); @@ -378,6 +413,7 @@ void TestUtil::ExpectAllFieldsSet(const unittest::TestAllTypes& message) { EXPECT_EQ(318, message.repeated_nested_message (1).bb()); EXPECT_EQ(319, message.repeated_foreign_message(1).c()); EXPECT_EQ(320, message.repeated_import_message (1).d()); + EXPECT_EQ(327, message.repeated_lazy_message (1).bb()); EXPECT_EQ(unittest::TestAllTypes::BAZ, message.repeated_nested_enum (1)); EXPECT_EQ(unittest::FOREIGN_BAZ , message.repeated_foreign_enum(1)); @@ -419,7 +455,7 @@ void TestUtil::ExpectAllFieldsSet(const unittest::TestAllTypes& message) { EXPECT_EQ(410 , message.default_sfixed64()); EXPECT_EQ(411 , message.default_float ()); EXPECT_EQ(412 , message.default_double ()); - EXPECT_EQ(false, message.default_bool ()); + EXPECT_FALSE( message.default_bool ()); EXPECT_EQ("415", message.default_string ()); EXPECT_EQ("416", message.default_bytes ()); @@ -427,6 +463,13 @@ void TestUtil::ExpectAllFieldsSet(const unittest::TestAllTypes& message) { EXPECT_EQ(unittest::FOREIGN_FOO , message.default_foreign_enum()); EXPECT_EQ(unittest_import::IMPORT_FOO, message.default_import_enum ()); + + EXPECT_FALSE(message.has_oneof_uint32 ()); + EXPECT_FALSE(message.has_oneof_nested_message()); + EXPECT_FALSE(message.has_oneof_string ()); + EXPECT_TRUE(message.has_oneof_bytes ()); + + EXPECT_EQ("604", message.oneof_bytes()); } // ------------------------------------------------------------------- @@ -449,10 +492,12 @@ void TestUtil::ExpectClear(const unittest::TestAllTypes& message) { EXPECT_FALSE(message.has_optional_string ()); EXPECT_FALSE(message.has_optional_bytes ()); - EXPECT_FALSE(message.has_optionalgroup ()); - EXPECT_FALSE(message.has_optional_nested_message ()); - EXPECT_FALSE(message.has_optional_foreign_message()); - EXPECT_FALSE(message.has_optional_import_message ()); + EXPECT_FALSE(message.has_optionalgroup ()); + EXPECT_FALSE(message.has_optional_nested_message ()); + EXPECT_FALSE(message.has_optional_foreign_message ()); + EXPECT_FALSE(message.has_optional_import_message ()); + EXPECT_FALSE(message.has_optional_public_import_message()); + EXPECT_FALSE(message.has_optional_lazy_message ()); EXPECT_FALSE(message.has_optional_nested_enum ()); EXPECT_FALSE(message.has_optional_foreign_enum()); @@ -474,20 +519,24 @@ void TestUtil::ExpectClear(const unittest::TestAllTypes& message) { EXPECT_EQ(0 , message.optional_sfixed64()); EXPECT_EQ(0 , message.optional_float ()); EXPECT_EQ(0 , message.optional_double ()); - EXPECT_EQ(false, message.optional_bool ()); + EXPECT_FALSE( message.optional_bool ()); EXPECT_EQ("" , message.optional_string ()); EXPECT_EQ("" , message.optional_bytes ()); // Embedded messages should also be clear. - EXPECT_FALSE(message.optionalgroup ().has_a()); - EXPECT_FALSE(message.optional_nested_message ().has_bb()); - EXPECT_FALSE(message.optional_foreign_message().has_c()); - EXPECT_FALSE(message.optional_import_message ().has_d()); - - EXPECT_EQ(0, message.optionalgroup ().a()); - EXPECT_EQ(0, message.optional_nested_message ().bb()); - EXPECT_EQ(0, message.optional_foreign_message().c()); - EXPECT_EQ(0, message.optional_import_message ().d()); + EXPECT_FALSE(message.optionalgroup ().has_a()); + EXPECT_FALSE(message.optional_nested_message ().has_bb()); + EXPECT_FALSE(message.optional_foreign_message ().has_c()); + EXPECT_FALSE(message.optional_import_message ().has_d()); + EXPECT_FALSE(message.optional_public_import_message().has_e()); + EXPECT_FALSE(message.optional_lazy_message ().has_bb()); + + EXPECT_EQ(0, message.optionalgroup ().a()); + EXPECT_EQ(0, message.optional_nested_message ().bb()); + EXPECT_EQ(0, message.optional_foreign_message ().c()); + EXPECT_EQ(0, message.optional_import_message ().d()); + EXPECT_EQ(0, message.optional_public_import_message().e()); + EXPECT_EQ(0, message.optional_lazy_message ().bb()); // Enums without defaults are set to the first value in the enum. EXPECT_EQ(unittest::TestAllTypes::FOO, message.optional_nested_enum ()); @@ -516,6 +565,7 @@ void TestUtil::ExpectClear(const unittest::TestAllTypes& message) { EXPECT_EQ(0, message.repeated_nested_message_size ()); EXPECT_EQ(0, message.repeated_foreign_message_size()); EXPECT_EQ(0, message.repeated_import_message_size ()); + EXPECT_EQ(0, message.repeated_lazy_message_size ()); EXPECT_EQ(0, message.repeated_nested_enum_size ()); EXPECT_EQ(0, message.repeated_foreign_enum_size ()); EXPECT_EQ(0, message.repeated_import_enum_size ()); @@ -558,7 +608,7 @@ void TestUtil::ExpectClear(const unittest::TestAllTypes& message) { EXPECT_EQ(-50 , message.default_sfixed64()); EXPECT_EQ( 51.5 , message.default_float ()); EXPECT_EQ( 52e3 , message.default_double ()); - EXPECT_EQ(true , message.default_bool ()); + EXPECT_TRUE( message.default_bool ()); EXPECT_EQ("hello", message.default_string ()); EXPECT_EQ("world", message.default_bytes ()); @@ -566,6 +616,11 @@ void TestUtil::ExpectClear(const unittest::TestAllTypes& message) { EXPECT_EQ(unittest::FOREIGN_BAR , message.default_foreign_enum()); EXPECT_EQ(unittest_import::IMPORT_BAR, message.default_import_enum ()); + + EXPECT_FALSE(message.has_oneof_uint32 ()); + EXPECT_FALSE(message.has_oneof_nested_message()); + EXPECT_FALSE(message.has_oneof_string ()); + EXPECT_FALSE(message.has_oneof_bytes ()); } // ------------------------------------------------------------------- @@ -595,6 +650,7 @@ void TestUtil::ExpectRepeatedFieldsModified( ASSERT_EQ(2, message.repeated_nested_message_size ()); ASSERT_EQ(2, message.repeated_foreign_message_size()); ASSERT_EQ(2, message.repeated_import_message_size ()); + ASSERT_EQ(2, message.repeated_lazy_message_size ()); ASSERT_EQ(2, message.repeated_nested_enum_size ()); ASSERT_EQ(2, message.repeated_foreign_enum_size ()); ASSERT_EQ(2, message.repeated_import_enum_size ()); @@ -616,7 +672,7 @@ void TestUtil::ExpectRepeatedFieldsModified( EXPECT_EQ(210 , message.repeated_sfixed64(0)); EXPECT_EQ(211 , message.repeated_float (0)); EXPECT_EQ(212 , message.repeated_double (0)); - EXPECT_EQ(true , message.repeated_bool (0)); + EXPECT_TRUE( message.repeated_bool (0)); EXPECT_EQ("215", message.repeated_string (0)); EXPECT_EQ("216", message.repeated_bytes (0)); @@ -624,6 +680,7 @@ void TestUtil::ExpectRepeatedFieldsModified( EXPECT_EQ(218, message.repeated_nested_message (0).bb()); EXPECT_EQ(219, message.repeated_foreign_message(0).c()); EXPECT_EQ(220, message.repeated_import_message (0).d()); + EXPECT_EQ(227, message.repeated_lazy_message (0).bb()); EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (0)); EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(0)); @@ -643,7 +700,7 @@ void TestUtil::ExpectRepeatedFieldsModified( EXPECT_EQ(510 , message.repeated_sfixed64(1)); EXPECT_EQ(511 , message.repeated_float (1)); EXPECT_EQ(512 , message.repeated_double (1)); - EXPECT_EQ(true , message.repeated_bool (1)); + EXPECT_TRUE( message.repeated_bool (1)); EXPECT_EQ("515", message.repeated_string (1)); EXPECT_EQ("516", message.repeated_bytes (1)); @@ -651,6 +708,7 @@ void TestUtil::ExpectRepeatedFieldsModified( EXPECT_EQ(518, message.repeated_nested_message (1).bb()); EXPECT_EQ(519, message.repeated_foreign_message(1).c()); EXPECT_EQ(520, message.repeated_import_message (1).d()); + EXPECT_EQ(527, message.repeated_lazy_message (1).bb()); EXPECT_EQ(unittest::TestAllTypes::FOO, message.repeated_nested_enum (1)); EXPECT_EQ(unittest::FOREIGN_FOO , message.repeated_foreign_enum(1)); @@ -775,7 +833,7 @@ void TestUtil::ExpectPackedFieldsSet(const unittest::TestPackedTypes& message) { EXPECT_EQ(610 , message.packed_sfixed64(0)); EXPECT_EQ(611 , message.packed_float (0)); EXPECT_EQ(612 , message.packed_double (0)); - EXPECT_EQ(true , message.packed_bool (0)); + EXPECT_TRUE( message.packed_bool (0)); EXPECT_EQ(unittest::FOREIGN_BAR, message.packed_enum(0)); EXPECT_EQ(701 , message.packed_int32 (1)); @@ -790,7 +848,7 @@ void TestUtil::ExpectPackedFieldsSet(const unittest::TestPackedTypes& message) { EXPECT_EQ(710 , message.packed_sfixed64(1)); EXPECT_EQ(711 , message.packed_float (1)); EXPECT_EQ(712 , message.packed_double (1)); - EXPECT_EQ(false, message.packed_bool (1)); + EXPECT_FALSE( message.packed_bool (1)); EXPECT_EQ(unittest::FOREIGN_BAZ, message.packed_enum(1)); } @@ -825,7 +883,7 @@ void TestUtil::ExpectUnpackedFieldsSet( EXPECT_EQ(610 , message.unpacked_sfixed64(0)); EXPECT_EQ(611 , message.unpacked_float (0)); EXPECT_EQ(612 , message.unpacked_double (0)); - EXPECT_EQ(true , message.unpacked_bool (0)); + EXPECT_TRUE( message.unpacked_bool (0)); EXPECT_EQ(unittest::FOREIGN_BAR, message.unpacked_enum(0)); EXPECT_EQ(701 , message.unpacked_int32 (1)); @@ -840,7 +898,7 @@ void TestUtil::ExpectUnpackedFieldsSet( EXPECT_EQ(710 , message.unpacked_sfixed64(1)); EXPECT_EQ(711 , message.unpacked_float (1)); EXPECT_EQ(712 , message.unpacked_double (1)); - EXPECT_EQ(false, message.unpacked_bool (1)); + EXPECT_FALSE( message.unpacked_bool (1)); EXPECT_EQ(unittest::FOREIGN_BAZ, message.unpacked_enum(1)); } @@ -897,7 +955,7 @@ void TestUtil::ExpectPackedFieldsModified( EXPECT_EQ(610 , message.packed_sfixed64(0)); EXPECT_EQ(611 , message.packed_float (0)); EXPECT_EQ(612 , message.packed_double (0)); - EXPECT_EQ(true , message.packed_bool (0)); + EXPECT_TRUE( message.packed_bool (0)); EXPECT_EQ(unittest::FOREIGN_BAR, message.packed_enum(0)); // Actually verify the second (modified) elements now. EXPECT_EQ(801 , message.packed_int32 (1)); @@ -912,7 +970,7 @@ void TestUtil::ExpectPackedFieldsModified( EXPECT_EQ(810 , message.packed_sfixed64(1)); EXPECT_EQ(811 , message.packed_float (1)); EXPECT_EQ(812 , message.packed_double (1)); - EXPECT_EQ(true , message.packed_bool (1)); + EXPECT_TRUE( message.packed_bool (1)); EXPECT_EQ(unittest::FOREIGN_FOO, message.packed_enum(1)); } @@ -953,6 +1011,9 @@ void TestUtil::SetAllExtensions(unittest::TestAllExtensions* message) { message->SetExtension(unittest::optional_string_piece_extension, "124"); message->SetExtension(unittest::optional_cord_extension, "125"); + message->MutableExtension(unittest::optional_public_import_message_extension)->set_e(126); + message->MutableExtension(unittest::optional_lazy_message_extension)->set_bb(127); + // ----------------------------------------------------------------- message->AddExtension(unittest::repeated_int32_extension , 201); @@ -975,6 +1036,7 @@ void TestUtil::SetAllExtensions(unittest::TestAllExtensions* message) { message->AddExtension(unittest::repeated_nested_message_extension )->set_bb(218); message->AddExtension(unittest::repeated_foreign_message_extension)->set_c(219); message->AddExtension(unittest::repeated_import_message_extension )->set_d(220); + message->AddExtension(unittest::repeated_lazy_message_extension )->set_bb(227); message->AddExtension(unittest::repeated_nested_enum_extension , unittest::TestAllTypes::BAR); message->AddExtension(unittest::repeated_foreign_enum_extension, unittest::FOREIGN_BAR ); @@ -1004,6 +1066,7 @@ void TestUtil::SetAllExtensions(unittest::TestAllExtensions* message) { message->AddExtension(unittest::repeated_nested_message_extension )->set_bb(318); message->AddExtension(unittest::repeated_foreign_message_extension)->set_c(319); message->AddExtension(unittest::repeated_import_message_extension )->set_d(320); + message->AddExtension(unittest::repeated_lazy_message_extension )->set_bb(327); message->AddExtension(unittest::repeated_nested_enum_extension , unittest::TestAllTypes::BAZ); message->AddExtension(unittest::repeated_foreign_enum_extension, unittest::FOREIGN_BAZ ); @@ -1036,6 +1099,15 @@ void TestUtil::SetAllExtensions(unittest::TestAllExtensions* message) { message->SetExtension(unittest::default_string_piece_extension, "424"); message->SetExtension(unittest::default_cord_extension, "425"); + + SetOneofFields(message); +} + +void TestUtil::SetOneofFields(unittest::TestAllExtensions* message) { + message->SetExtension(unittest::oneof_uint32_extension, 601); + message->MutableExtension(unittest::oneof_nested_message_extension)->set_bb(602); + message->SetExtension(unittest::oneof_string_extension, "603"); + message->SetExtension(unittest::oneof_bytes_extension, "604"); } // ------------------------------------------------------------------- @@ -1073,6 +1145,7 @@ void TestUtil::ModifyRepeatedExtensions(unittest::TestAllExtensions* message) { message->MutableExtension(unittest::repeated_nested_message_extension , 1)->set_bb(518); message->MutableExtension(unittest::repeated_foreign_message_extension, 1)->set_c(519); message->MutableExtension(unittest::repeated_import_message_extension , 1)->set_d(520); + message->MutableExtension(unittest::repeated_lazy_message_extension , 1)->set_bb(527); message->SetExtension(unittest::repeated_nested_enum_extension , 1, unittest::TestAllTypes::FOO); message->SetExtension(unittest::repeated_foreign_enum_extension, 1, unittest::FOREIGN_FOO ); @@ -1102,15 +1175,19 @@ void TestUtil::ExpectAllExtensionsSet( EXPECT_TRUE(message.HasExtension(unittest::optional_string_extension )); EXPECT_TRUE(message.HasExtension(unittest::optional_bytes_extension )); - EXPECT_TRUE(message.HasExtension(unittest::optionalgroup_extension )); - EXPECT_TRUE(message.HasExtension(unittest::optional_nested_message_extension )); - EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_message_extension)); - EXPECT_TRUE(message.HasExtension(unittest::optional_import_message_extension )); + EXPECT_TRUE(message.HasExtension(unittest::optionalgroup_extension )); + EXPECT_TRUE(message.HasExtension(unittest::optional_nested_message_extension )); + EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_message_extension )); + EXPECT_TRUE(message.HasExtension(unittest::optional_import_message_extension )); + EXPECT_TRUE(message.HasExtension(unittest::optional_public_import_message_extension)); + EXPECT_TRUE(message.HasExtension(unittest::optional_lazy_message_extension )); - EXPECT_TRUE(message.GetExtension(unittest::optionalgroup_extension ).has_a()); - EXPECT_TRUE(message.GetExtension(unittest::optional_nested_message_extension ).has_bb()); - EXPECT_TRUE(message.GetExtension(unittest::optional_foreign_message_extension).has_c()); - EXPECT_TRUE(message.GetExtension(unittest::optional_import_message_extension ).has_d()); + EXPECT_TRUE(message.GetExtension(unittest::optionalgroup_extension ).has_a()); + EXPECT_TRUE(message.GetExtension(unittest::optional_nested_message_extension ).has_bb()); + EXPECT_TRUE(message.GetExtension(unittest::optional_foreign_message_extension ).has_c()); + EXPECT_TRUE(message.GetExtension(unittest::optional_import_message_extension ).has_d()); + EXPECT_TRUE(message.GetExtension(unittest::optional_public_import_message_extension).has_e()); + EXPECT_TRUE(message.GetExtension(unittest::optional_lazy_message_extension ).has_bb()); EXPECT_TRUE(message.HasExtension(unittest::optional_nested_enum_extension )); EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_enum_extension)); @@ -1131,7 +1208,7 @@ void TestUtil::ExpectAllExtensionsSet( EXPECT_EQ(110 , message.GetExtension(unittest::optional_sfixed64_extension)); EXPECT_EQ(111 , message.GetExtension(unittest::optional_float_extension )); EXPECT_EQ(112 , message.GetExtension(unittest::optional_double_extension )); - EXPECT_EQ(true , message.GetExtension(unittest::optional_bool_extension )); + EXPECT_TRUE( message.GetExtension(unittest::optional_bool_extension )); EXPECT_EQ("115", message.GetExtension(unittest::optional_string_extension )); EXPECT_EQ("116", message.GetExtension(unittest::optional_bytes_extension )); @@ -1146,6 +1223,8 @@ void TestUtil::ExpectAllExtensionsSet( EXPECT_EQ("124", message.GetExtension(unittest::optional_string_piece_extension)); EXPECT_EQ("125", message.GetExtension(unittest::optional_cord_extension)); + EXPECT_EQ(126, message.GetExtension(unittest::optional_public_import_message_extension ).e()); + EXPECT_EQ(127, message.GetExtension(unittest::optional_lazy_message_extension).bb()); // ----------------------------------------------------------------- @@ -1169,6 +1248,7 @@ void TestUtil::ExpectAllExtensionsSet( ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension )); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension)); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension )); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension )); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension )); @@ -1188,7 +1268,7 @@ void TestUtil::ExpectAllExtensionsSet( EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 0)); EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 0)); EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 0)); - EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension , 0)); + EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 0)); EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 0)); EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 0)); @@ -1196,6 +1276,7 @@ void TestUtil::ExpectAllExtensionsSet( EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); + EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb()); EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 0)); EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 0)); @@ -1216,7 +1297,7 @@ void TestUtil::ExpectAllExtensionsSet( EXPECT_EQ(310 , message.GetExtension(unittest::repeated_sfixed64_extension, 1)); EXPECT_EQ(311 , message.GetExtension(unittest::repeated_float_extension , 1)); EXPECT_EQ(312 , message.GetExtension(unittest::repeated_double_extension , 1)); - EXPECT_EQ(false, message.GetExtension(unittest::repeated_bool_extension , 1)); + EXPECT_FALSE( message.GetExtension(unittest::repeated_bool_extension , 1)); EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension , 1)); EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension , 1)); @@ -1224,6 +1305,7 @@ void TestUtil::ExpectAllExtensionsSet( EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension , 1).bb()); EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension, 1).c()); EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension , 1).d()); + EXPECT_EQ(327, message.GetExtension(unittest::repeated_lazy_message_extension , 1).bb()); EXPECT_EQ(unittest::TestAllTypes::BAZ, message.GetExtension(unittest::repeated_nested_enum_extension , 1)); EXPECT_EQ(unittest::FOREIGN_BAZ , message.GetExtension(unittest::repeated_foreign_enum_extension, 1)); @@ -1269,7 +1351,7 @@ void TestUtil::ExpectAllExtensionsSet( EXPECT_EQ(410 , message.GetExtension(unittest::default_sfixed64_extension)); EXPECT_EQ(411 , message.GetExtension(unittest::default_float_extension )); EXPECT_EQ(412 , message.GetExtension(unittest::default_double_extension )); - EXPECT_EQ(false, message.GetExtension(unittest::default_bool_extension )); + EXPECT_FALSE( message.GetExtension(unittest::default_bool_extension )); EXPECT_EQ("415", message.GetExtension(unittest::default_string_extension )); EXPECT_EQ("416", message.GetExtension(unittest::default_bytes_extension )); @@ -1279,6 +1361,16 @@ void TestUtil::ExpectAllExtensionsSet( EXPECT_EQ("424", message.GetExtension(unittest::default_string_piece_extension)); EXPECT_EQ("425", message.GetExtension(unittest::default_cord_extension)); + + EXPECT_TRUE(message.HasExtension(unittest::oneof_uint32_extension)); + EXPECT_TRUE(message.GetExtension(unittest::oneof_nested_message_extension).has_bb()); + EXPECT_TRUE(message.HasExtension(unittest::oneof_string_extension)); + EXPECT_TRUE(message.HasExtension(unittest::oneof_bytes_extension)); + + EXPECT_EQ(601, message.GetExtension(unittest::oneof_uint32_extension)); + EXPECT_EQ(602, message.GetExtension(unittest::oneof_nested_message_extension).bb()); + EXPECT_EQ("603", message.GetExtension(unittest::oneof_string_extension)); + EXPECT_EQ("604", message.GetExtension(unittest::oneof_bytes_extension)); } // ------------------------------------------------------------------- @@ -1307,10 +1399,12 @@ void TestUtil::ExpectExtensionsClear( EXPECT_FALSE(message.HasExtension(unittest::optional_string_extension )); EXPECT_FALSE(message.HasExtension(unittest::optional_bytes_extension )); - EXPECT_FALSE(message.HasExtension(unittest::optionalgroup_extension )); - EXPECT_FALSE(message.HasExtension(unittest::optional_nested_message_extension )); - EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_message_extension)); - EXPECT_FALSE(message.HasExtension(unittest::optional_import_message_extension )); + EXPECT_FALSE(message.HasExtension(unittest::optionalgroup_extension )); + EXPECT_FALSE(message.HasExtension(unittest::optional_nested_message_extension )); + EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_message_extension )); + EXPECT_FALSE(message.HasExtension(unittest::optional_import_message_extension )); + EXPECT_FALSE(message.HasExtension(unittest::optional_public_import_message_extension)); + EXPECT_FALSE(message.HasExtension(unittest::optional_lazy_message_extension )); EXPECT_FALSE(message.HasExtension(unittest::optional_nested_enum_extension )); EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_enum_extension)); @@ -1332,20 +1426,24 @@ void TestUtil::ExpectExtensionsClear( EXPECT_EQ(0 , message.GetExtension(unittest::optional_sfixed64_extension)); EXPECT_EQ(0 , message.GetExtension(unittest::optional_float_extension )); EXPECT_EQ(0 , message.GetExtension(unittest::optional_double_extension )); - EXPECT_EQ(false, message.GetExtension(unittest::optional_bool_extension )); + EXPECT_FALSE( message.GetExtension(unittest::optional_bool_extension )); EXPECT_EQ("" , message.GetExtension(unittest::optional_string_extension )); EXPECT_EQ("" , message.GetExtension(unittest::optional_bytes_extension )); // Embedded messages should also be clear. - EXPECT_FALSE(message.GetExtension(unittest::optionalgroup_extension ).has_a()); - EXPECT_FALSE(message.GetExtension(unittest::optional_nested_message_extension ).has_bb()); - EXPECT_FALSE(message.GetExtension(unittest::optional_foreign_message_extension).has_c()); - EXPECT_FALSE(message.GetExtension(unittest::optional_import_message_extension ).has_d()); - - EXPECT_EQ(0, message.GetExtension(unittest::optionalgroup_extension ).a()); - EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension ).bb()); - EXPECT_EQ(0, message.GetExtension(unittest::optional_foreign_message_extension).c()); - EXPECT_EQ(0, message.GetExtension(unittest::optional_import_message_extension ).d()); + EXPECT_FALSE(message.GetExtension(unittest::optionalgroup_extension ).has_a()); + EXPECT_FALSE(message.GetExtension(unittest::optional_nested_message_extension ).has_bb()); + EXPECT_FALSE(message.GetExtension(unittest::optional_foreign_message_extension ).has_c()); + EXPECT_FALSE(message.GetExtension(unittest::optional_import_message_extension ).has_d()); + EXPECT_FALSE(message.GetExtension(unittest::optional_public_import_message_extension).has_e()); + EXPECT_FALSE(message.GetExtension(unittest::optional_lazy_message_extension ).has_bb()); + + EXPECT_EQ(0, message.GetExtension(unittest::optionalgroup_extension ).a()); + EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension ).bb()); + EXPECT_EQ(0, message.GetExtension(unittest::optional_foreign_message_extension ).c()); + EXPECT_EQ(0, message.GetExtension(unittest::optional_import_message_extension ).d()); + EXPECT_EQ(0, message.GetExtension(unittest::optional_public_import_message_extension).e()); + EXPECT_EQ(0, message.GetExtension(unittest::optional_lazy_message_extension ).bb()); // Enums without defaults are set to the first value in the enum. EXPECT_EQ(unittest::TestAllTypes::FOO, message.GetExtension(unittest::optional_nested_enum_extension )); @@ -1376,6 +1474,7 @@ void TestUtil::ExpectExtensionsClear( EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_message_extension )); EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_message_extension)); EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_message_extension )); + EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_lazy_message_extension )); EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_enum_extension )); EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_enum_extension )); @@ -1420,7 +1519,7 @@ void TestUtil::ExpectExtensionsClear( EXPECT_EQ(-50 , message.GetExtension(unittest::default_sfixed64_extension)); EXPECT_EQ( 51.5 , message.GetExtension(unittest::default_float_extension )); EXPECT_EQ( 52e3 , message.GetExtension(unittest::default_double_extension )); - EXPECT_EQ(true , message.GetExtension(unittest::default_bool_extension )); + EXPECT_TRUE( message.GetExtension(unittest::default_bool_extension )); EXPECT_EQ("hello", message.GetExtension(unittest::default_string_extension )); EXPECT_EQ("world", message.GetExtension(unittest::default_bytes_extension )); @@ -1430,6 +1529,11 @@ void TestUtil::ExpectExtensionsClear( EXPECT_EQ("abc", message.GetExtension(unittest::default_string_piece_extension)); EXPECT_EQ("123", message.GetExtension(unittest::default_cord_extension)); + + EXPECT_FALSE(message.HasExtension(unittest::oneof_uint32_extension)); + EXPECT_FALSE(message.GetExtension(unittest::oneof_nested_message_extension).has_bb()); + EXPECT_FALSE(message.HasExtension(unittest::oneof_string_extension)); + EXPECT_FALSE(message.HasExtension(unittest::oneof_bytes_extension)); } // ------------------------------------------------------------------- @@ -1459,6 +1563,7 @@ void TestUtil::ExpectRepeatedExtensionsModified( ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension )); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension)); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension )); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension )); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension )); @@ -1478,7 +1583,7 @@ void TestUtil::ExpectRepeatedExtensionsModified( EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 0)); EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 0)); EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 0)); - EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension , 0)); + EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 0)); EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 0)); EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 0)); @@ -1486,6 +1591,7 @@ void TestUtil::ExpectRepeatedExtensionsModified( EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); + EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb()); EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 0)); EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 0)); @@ -1507,7 +1613,7 @@ void TestUtil::ExpectRepeatedExtensionsModified( EXPECT_EQ(510 , message.GetExtension(unittest::repeated_sfixed64_extension, 1)); EXPECT_EQ(511 , message.GetExtension(unittest::repeated_float_extension , 1)); EXPECT_EQ(512 , message.GetExtension(unittest::repeated_double_extension , 1)); - EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension , 1)); + EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 1)); EXPECT_EQ("515", message.GetExtension(unittest::repeated_string_extension , 1)); EXPECT_EQ("516", message.GetExtension(unittest::repeated_bytes_extension , 1)); @@ -1515,6 +1621,7 @@ void TestUtil::ExpectRepeatedExtensionsModified( EXPECT_EQ(518, message.GetExtension(unittest::repeated_nested_message_extension , 1).bb()); EXPECT_EQ(519, message.GetExtension(unittest::repeated_foreign_message_extension, 1).c()); EXPECT_EQ(520, message.GetExtension(unittest::repeated_import_message_extension , 1).d()); + EXPECT_EQ(527, message.GetExtension(unittest::repeated_lazy_message_extension , 1).bb()); EXPECT_EQ(unittest::TestAllTypes::FOO, message.GetExtension(unittest::repeated_nested_enum_extension , 1)); EXPECT_EQ(unittest::FOREIGN_FOO , message.GetExtension(unittest::repeated_foreign_enum_extension, 1)); @@ -1609,7 +1716,7 @@ void TestUtil::ExpectPackedExtensionsSet( EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension, 0)); EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension , 0)); EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension , 0)); - EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension , 0)); + EXPECT_TRUE( message.GetExtension(unittest::packed_bool_extension , 0)); EXPECT_EQ(unittest::FOREIGN_BAR, message.GetExtension(unittest::packed_enum_extension, 0)); EXPECT_EQ(701 , message.GetExtension(unittest::packed_int32_extension , 1)); @@ -1624,7 +1731,7 @@ void TestUtil::ExpectPackedExtensionsSet( EXPECT_EQ(710 , message.GetExtension(unittest::packed_sfixed64_extension, 1)); EXPECT_EQ(711 , message.GetExtension(unittest::packed_float_extension , 1)); EXPECT_EQ(712 , message.GetExtension(unittest::packed_double_extension , 1)); - EXPECT_EQ(false, message.GetExtension(unittest::packed_bool_extension , 1)); + EXPECT_FALSE( message.GetExtension(unittest::packed_bool_extension , 1)); EXPECT_EQ(unittest::FOREIGN_BAZ, message.GetExtension(unittest::packed_enum_extension, 1)); } @@ -1679,7 +1786,7 @@ void TestUtil::ExpectPackedExtensionsModified( EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension, 0)); EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension , 0)); EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension , 0)); - EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension , 0)); + EXPECT_TRUE( message.GetExtension(unittest::packed_bool_extension , 0)); EXPECT_EQ(unittest::FOREIGN_BAR, message.GetExtension(unittest::packed_enum_extension, 0)); @@ -1696,13 +1803,64 @@ void TestUtil::ExpectPackedExtensionsModified( EXPECT_EQ(810 , message.GetExtension(unittest::packed_sfixed64_extension, 1)); EXPECT_EQ(811 , message.GetExtension(unittest::packed_float_extension , 1)); EXPECT_EQ(812 , message.GetExtension(unittest::packed_double_extension , 1)); - EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension , 1)); + EXPECT_TRUE( message.GetExtension(unittest::packed_bool_extension , 1)); EXPECT_EQ(unittest::FOREIGN_FOO, message.GetExtension(unittest::packed_enum_extension, 1)); } // ------------------------------------------------------------------- +void TestUtil::ExpectUnpackedExtensionsSet( + const unittest::TestUnpackedExtensions& message) { + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_int32_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_int64_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_uint32_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_uint64_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_sint32_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_sint64_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_fixed32_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_fixed64_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_sfixed32_extension)); + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_sfixed64_extension)); + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_float_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_double_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_bool_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::unpacked_enum_extension )); + + EXPECT_EQ(601 , message.GetExtension(unittest::unpacked_int32_extension , 0)); + EXPECT_EQ(602 , message.GetExtension(unittest::unpacked_int64_extension , 0)); + EXPECT_EQ(603 , message.GetExtension(unittest::unpacked_uint32_extension , 0)); + EXPECT_EQ(604 , message.GetExtension(unittest::unpacked_uint64_extension , 0)); + EXPECT_EQ(605 , message.GetExtension(unittest::unpacked_sint32_extension , 0)); + EXPECT_EQ(606 , message.GetExtension(unittest::unpacked_sint64_extension , 0)); + EXPECT_EQ(607 , message.GetExtension(unittest::unpacked_fixed32_extension , 0)); + EXPECT_EQ(608 , message.GetExtension(unittest::unpacked_fixed64_extension , 0)); + EXPECT_EQ(609 , message.GetExtension(unittest::unpacked_sfixed32_extension, 0)); + EXPECT_EQ(610 , message.GetExtension(unittest::unpacked_sfixed64_extension, 0)); + EXPECT_EQ(611 , message.GetExtension(unittest::unpacked_float_extension , 0)); + EXPECT_EQ(612 , message.GetExtension(unittest::unpacked_double_extension , 0)); + EXPECT_EQ(true , message.GetExtension(unittest::unpacked_bool_extension , 0)); + EXPECT_EQ(unittest::FOREIGN_BAR, + message.GetExtension(unittest::unpacked_enum_extension, 0)); + EXPECT_EQ(701 , message.GetExtension(unittest::unpacked_int32_extension , 1)); + EXPECT_EQ(702 , message.GetExtension(unittest::unpacked_int64_extension , 1)); + EXPECT_EQ(703 , message.GetExtension(unittest::unpacked_uint32_extension , 1)); + EXPECT_EQ(704 , message.GetExtension(unittest::unpacked_uint64_extension , 1)); + EXPECT_EQ(705 , message.GetExtension(unittest::unpacked_sint32_extension , 1)); + EXPECT_EQ(706 , message.GetExtension(unittest::unpacked_sint64_extension , 1)); + EXPECT_EQ(707 , message.GetExtension(unittest::unpacked_fixed32_extension , 1)); + EXPECT_EQ(708 , message.GetExtension(unittest::unpacked_fixed64_extension , 1)); + EXPECT_EQ(709 , message.GetExtension(unittest::unpacked_sfixed32_extension, 1)); + EXPECT_EQ(710 , message.GetExtension(unittest::unpacked_sfixed64_extension, 1)); + EXPECT_EQ(711 , message.GetExtension(unittest::unpacked_float_extension , 1)); + EXPECT_EQ(712 , message.GetExtension(unittest::unpacked_double_extension , 1)); + EXPECT_EQ(false, message.GetExtension(unittest::unpacked_bool_extension , 1)); + EXPECT_EQ(unittest::FOREIGN_BAZ, + message.GetExtension(unittest::unpacked_enum_extension, 1)); +} + +// ------------------------------------------------------------------- + void TestUtil::ExpectAllFieldsAndExtensionsInOrder(const string& serialized) { // We set each field individually, serialize separately, and concatenate all // the strings in canonical order to determine the expected serialization. @@ -1750,6 +1908,7 @@ void TestUtil::ExpectLastRepeatedsRemoved( ASSERT_EQ(1, message.repeated_nested_message_size ()); ASSERT_EQ(1, message.repeated_foreign_message_size()); ASSERT_EQ(1, message.repeated_import_message_size ()); + ASSERT_EQ(1, message.repeated_import_message_size ()); ASSERT_EQ(1, message.repeated_nested_enum_size ()); ASSERT_EQ(1, message.repeated_foreign_enum_size ()); ASSERT_EQ(1, message.repeated_import_enum_size ()); @@ -1772,7 +1931,7 @@ void TestUtil::ExpectLastRepeatedsRemoved( EXPECT_EQ(210 , message.repeated_sfixed64(0)); EXPECT_EQ(211 , message.repeated_float (0)); EXPECT_EQ(212 , message.repeated_double (0)); - EXPECT_EQ(true , message.repeated_bool (0)); + EXPECT_TRUE( message.repeated_bool (0)); EXPECT_EQ("215", message.repeated_string (0)); EXPECT_EQ("216", message.repeated_bytes (0)); @@ -1780,6 +1939,7 @@ void TestUtil::ExpectLastRepeatedsRemoved( EXPECT_EQ(218, message.repeated_nested_message (0).bb()); EXPECT_EQ(219, message.repeated_foreign_message(0).c()); EXPECT_EQ(220, message.repeated_import_message (0).d()); + EXPECT_EQ(220, message.repeated_import_message (0).d()); EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (0)); EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(0)); @@ -1810,6 +1970,7 @@ void TestUtil::ExpectLastRepeatedExtensionsRemoved( ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_nested_message_extension )); ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_foreign_message_extension)); ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_import_message_extension )); + ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_lazy_message_extension )); ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_nested_enum_extension )); ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_import_enum_extension )); @@ -1830,7 +1991,7 @@ void TestUtil::ExpectLastRepeatedExtensionsRemoved( EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 0)); EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 0)); EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 0)); - EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension , 0)); + EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 0)); EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 0)); EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 0)); @@ -1838,6 +1999,7 @@ void TestUtil::ExpectLastRepeatedExtensionsRemoved( EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); + EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb()); EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 0)); EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 0)); @@ -1847,6 +2009,36 @@ void TestUtil::ExpectLastRepeatedExtensionsRemoved( EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 0)); } +void TestUtil::ExpectLastRepeatedsReleased( + const unittest::TestAllTypes& message) { + ASSERT_EQ(1, message.repeatedgroup_size ()); + ASSERT_EQ(1, message.repeated_nested_message_size ()); + ASSERT_EQ(1, message.repeated_foreign_message_size()); + ASSERT_EQ(1, message.repeated_import_message_size ()); + ASSERT_EQ(1, message.repeated_import_message_size ()); + + EXPECT_EQ(217, message.repeatedgroup (0).a()); + EXPECT_EQ(218, message.repeated_nested_message (0).bb()); + EXPECT_EQ(219, message.repeated_foreign_message(0).c()); + EXPECT_EQ(220, message.repeated_import_message (0).d()); + EXPECT_EQ(220, message.repeated_import_message (0).d()); +} + +void TestUtil::ExpectLastRepeatedExtensionsReleased( + const unittest::TestAllExtensions& message) { + ASSERT_EQ(1, message.ExtensionSize(unittest::repeatedgroup_extension )); + ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_nested_message_extension )); + ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_foreign_message_extension)); + ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_import_message_extension )); + ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_lazy_message_extension )); + + EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 0).a()); + EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); + EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); + EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); + EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb()); +} + void TestUtil::ExpectRepeatedsSwapped( const unittest::TestAllTypes& message) { ASSERT_EQ(2, message.repeated_int32_size ()); @@ -1869,6 +2061,7 @@ void TestUtil::ExpectRepeatedsSwapped( ASSERT_EQ(2, message.repeated_nested_message_size ()); ASSERT_EQ(2, message.repeated_foreign_message_size()); ASSERT_EQ(2, message.repeated_import_message_size ()); + ASSERT_EQ(2, message.repeated_import_message_size ()); ASSERT_EQ(2, message.repeated_nested_enum_size ()); ASSERT_EQ(2, message.repeated_foreign_enum_size ()); ASSERT_EQ(2, message.repeated_import_enum_size ()); @@ -1891,7 +2084,7 @@ void TestUtil::ExpectRepeatedsSwapped( EXPECT_EQ(210 , message.repeated_sfixed64(1)); EXPECT_EQ(211 , message.repeated_float (1)); EXPECT_EQ(212 , message.repeated_double (1)); - EXPECT_EQ(true , message.repeated_bool (1)); + EXPECT_TRUE( message.repeated_bool (1)); EXPECT_EQ("215", message.repeated_string (1)); EXPECT_EQ("216", message.repeated_bytes (1)); @@ -1899,6 +2092,7 @@ void TestUtil::ExpectRepeatedsSwapped( EXPECT_EQ(218, message.repeated_nested_message (1).bb()); EXPECT_EQ(219, message.repeated_foreign_message(1).c()); EXPECT_EQ(220, message.repeated_import_message (1).d()); + EXPECT_EQ(220, message.repeated_import_message (1).d()); EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (1)); EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(1)); @@ -1916,7 +2110,7 @@ void TestUtil::ExpectRepeatedsSwapped( EXPECT_EQ(310 , message.repeated_sfixed64(0)); EXPECT_EQ(311 , message.repeated_float (0)); EXPECT_EQ(312 , message.repeated_double (0)); - EXPECT_EQ(false, message.repeated_bool (0)); + EXPECT_FALSE( message.repeated_bool (0)); EXPECT_EQ("315", message.repeated_string (0)); EXPECT_EQ("316", message.repeated_bytes (0)); @@ -1924,6 +2118,7 @@ void TestUtil::ExpectRepeatedsSwapped( EXPECT_EQ(318, message.repeated_nested_message (0).bb()); EXPECT_EQ(319, message.repeated_foreign_message(0).c()); EXPECT_EQ(320, message.repeated_import_message (0).d()); + EXPECT_EQ(320, message.repeated_import_message (0).d()); EXPECT_EQ(unittest::TestAllTypes::BAZ, message.repeated_nested_enum (0)); EXPECT_EQ(unittest::FOREIGN_BAZ , message.repeated_foreign_enum(0)); @@ -1953,6 +2148,7 @@ void TestUtil::ExpectRepeatedExtensionsSwapped( ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension )); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension)); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension )); + ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension )); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension )); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension )); @@ -1972,7 +2168,7 @@ void TestUtil::ExpectRepeatedExtensionsSwapped( EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 1)); EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 1)); EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 1)); - EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension , 1)); + EXPECT_TRUE( message.GetExtension(unittest::repeated_bool_extension , 1)); EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 1)); EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 1)); @@ -1980,6 +2176,7 @@ void TestUtil::ExpectRepeatedExtensionsSwapped( EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 1).bb()); EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 1).c()); EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 1).d()); + EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension , 1).bb()); EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 1)); EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 1)); @@ -2000,7 +2197,7 @@ void TestUtil::ExpectRepeatedExtensionsSwapped( EXPECT_EQ(310 , message.GetExtension(unittest::repeated_sfixed64_extension, 0)); EXPECT_EQ(311 , message.GetExtension(unittest::repeated_float_extension , 0)); EXPECT_EQ(312 , message.GetExtension(unittest::repeated_double_extension , 0)); - EXPECT_EQ(false, message.GetExtension(unittest::repeated_bool_extension , 0)); + EXPECT_FALSE( message.GetExtension(unittest::repeated_bool_extension , 0)); EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension , 0)); EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension , 0)); @@ -2008,6 +2205,7 @@ void TestUtil::ExpectRepeatedExtensionsSwapped( EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); + EXPECT_EQ(327, message.GetExtension(unittest::repeated_lazy_message_extension , 0).bb()); EXPECT_EQ(unittest::TestAllTypes::BAZ, message.GetExtension(unittest::repeated_nested_enum_extension , 0)); EXPECT_EQ(unittest::FOREIGN_BAZ , message.GetExtension(unittest::repeated_foreign_enum_extension, 0)); @@ -2017,6 +2215,92 @@ void TestUtil::ExpectRepeatedExtensionsSwapped( EXPECT_EQ("325", message.GetExtension(unittest::repeated_cord_extension, 0)); } +void TestUtil::SetOneof1(unittest::TestOneof2* message) { + message->mutable_foo_lazy_message()->set_qux_int(100); + message->set_bar_string("101"); + message->set_baz_int(102); + message->set_baz_string("103"); +} + +void TestUtil::SetOneof2(unittest::TestOneof2* message) { + message->set_foo_int(200); + message->set_bar_enum(unittest::TestOneof2::BAZ); + message->set_baz_int(202); + message->set_baz_string("203"); +} + +void TestUtil::ExpectOneofSet1(const unittest::TestOneof2& message) { + ExpectAtMostOneFieldSetInOneof(message); + + EXPECT_TRUE(message.has_foo_lazy_message ()); + EXPECT_TRUE(message.foo_lazy_message().has_qux_int()); + + EXPECT_TRUE(message.has_bar_string()); + EXPECT_TRUE(message.has_baz_int ()); + EXPECT_TRUE(message.has_baz_string()); + + ASSERT_EQ(0, message.foo_lazy_message().corge_int_size()); + + EXPECT_EQ(100 , message.foo_lazy_message().qux_int()); + EXPECT_EQ("101", message.bar_string ()); + EXPECT_EQ(102 , message.baz_int ()); + EXPECT_EQ("103", message.baz_string ()); +} + +void TestUtil::ExpectOneofSet2(const unittest::TestOneof2& message) { + ExpectAtMostOneFieldSetInOneof(message); + + EXPECT_TRUE(message.has_foo_int ()); + EXPECT_TRUE(message.has_bar_enum ()); + EXPECT_TRUE(message.has_baz_int ()); + EXPECT_TRUE(message.has_baz_string()); + + EXPECT_EQ(200 , message.foo_int ()); + EXPECT_EQ(unittest::TestOneof2::BAZ, message.bar_enum ()); + EXPECT_EQ(202 , message.baz_int ()); + EXPECT_EQ("203" , message.baz_string()); +} + +void TestUtil::ExpectOneofClear(const unittest::TestOneof2& message) { + EXPECT_FALSE(message.has_foo_int()); + EXPECT_FALSE(message.has_foo_string()); + EXPECT_FALSE(message.has_foo_bytes()); + EXPECT_FALSE(message.has_foo_enum()); + EXPECT_FALSE(message.has_foo_message()); + EXPECT_FALSE(message.has_foogroup()); + EXPECT_FALSE(message.has_foo_lazy_message()); + + EXPECT_FALSE(message.has_bar_int()); + EXPECT_FALSE(message.has_bar_string()); + EXPECT_FALSE(message.has_bar_bytes()); + EXPECT_FALSE(message.has_bar_enum()); + + EXPECT_FALSE(message.has_baz_int()); + EXPECT_FALSE(message.has_baz_string()); + + EXPECT_EQ(unittest::TestOneof2::FOO_NOT_SET, message.foo_case()); + EXPECT_EQ(unittest::TestOneof2::BAR_NOT_SET, message.bar_case()); +} + +void TestUtil::ExpectAtMostOneFieldSetInOneof( + const unittest::TestOneof2& message) { + int count = 0; + if (message.has_foo_int()) count++; + if (message.has_foo_string()) count++; + if (message.has_foo_bytes()) count++; + if (message.has_foo_enum()) count++; + if (message.has_foo_message()) count++; + if (message.has_foogroup()) count++; + if (message.has_foo_lazy_message()) count++; + EXPECT_LE(count, 1); + count = 0; + if (message.has_bar_int()) count++; + if (message.has_bar_string()) count++; + if (message.has_bar_bytes()) count++; + if (message.has_bar_enum()) count++; + EXPECT_TRUE(count == 0 || count == 1); +} + // =================================================================== TestUtil::ReflectionTester::ReflectionTester( @@ -2031,6 +2315,8 @@ TestUtil::ReflectionTester::ReflectionTester( pool->FindFieldByName("protobuf_unittest.ForeignMessage.c"); import_d_ = pool->FindFieldByName("protobuf_unittest_import.ImportMessage.d"); + import_e_ = + pool->FindFieldByName("protobuf_unittest_import.PublicImportMessage.e"); nested_foo_ = pool->FindEnumValueByName("protobuf_unittest.TestAllTypes.FOO"); nested_bar_ = @@ -2067,6 +2353,7 @@ TestUtil::ReflectionTester::ReflectionTester( EXPECT_TRUE(nested_b_ != NULL); EXPECT_TRUE(foreign_c_ != NULL); EXPECT_TRUE(import_d_ != NULL); + EXPECT_TRUE(import_e_ != NULL); EXPECT_TRUE(nested_foo_ != NULL); EXPECT_TRUE(nested_bar_ != NULL); EXPECT_TRUE(nested_baz_ != NULL); @@ -2129,6 +2416,12 @@ void TestUtil::ReflectionTester::SetAllFieldsViaReflection(Message* message) { 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); + // ----------------------------------------------------------------- reflection->AddInt32 (message, F("repeated_int32" ), 201); @@ -2155,6 +2448,8 @@ void TestUtil::ReflectionTester::SetAllFieldsViaReflection(Message* 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_); @@ -2188,6 +2483,8 @@ void TestUtil::ReflectionTester::SetAllFieldsViaReflection(Message* 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_); @@ -2220,6 +2517,69 @@ void TestUtil::ReflectionTester::SetAllFieldsViaReflection(Message* message) { 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"); +} + +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, + descriptor->file()->pool()->FindFieldByName( + "protobuf_unittest.TestOneof2.NestedMessage.qux_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"); +} + +void TestUtil::ReflectionTester::ExpectOneofSetViaReflection( + const Message& message) { + const Descriptor* descriptor = message.GetDescriptor(); + const Reflection* reflection = message.GetReflection(); + 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, + descriptor->file()->pool()->FindFieldByName( + "protobuf_unittest.TestOneof2.NestedMessage.qux_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)); } void TestUtil::ReflectionTester::SetPackedFieldsViaReflection( @@ -2289,10 +2649,12 @@ void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection1( 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("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" ))); sub_message = &reflection->GetMessage(message, F("optionalgroup")); EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, group_a_)); @@ -2302,6 +2664,10 @@ void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection1( 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_)); EXPECT_TRUE(reflection->HasField(message, F("optional_nested_enum" ))); EXPECT_TRUE(reflection->HasField(message, F("optional_foreign_enum"))); @@ -2322,7 +2688,7 @@ void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection1( 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_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" ))); @@ -2337,6 +2703,10 @@ void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection1( 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_)); EXPECT_EQ( nested_baz_, reflection->GetEnum(message, F("optional_nested_enum" ))); EXPECT_EQ(foreign_baz_, reflection->GetEnum(message, F("optional_foreign_enum"))); @@ -2347,6 +2717,21 @@ void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection1( 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_)); + } } void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection2( @@ -2377,6 +2762,7 @@ void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection2( 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" ))); @@ -2396,7 +2782,7 @@ void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection2( 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_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)); @@ -2411,6 +2797,8 @@ void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection2( 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)); @@ -2436,7 +2824,7 @@ void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection2( 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_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)); @@ -2453,6 +2841,8 @@ void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection2( 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)); @@ -2509,7 +2899,7 @@ void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection3( 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_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" ))); @@ -2559,7 +2949,7 @@ void TestUtil::ReflectionTester::ExpectPackedFieldsSetViaReflection( 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_EQ(true , reflection->GetRepeatedBool (message, F("packed_bool" ), 0)); + EXPECT_TRUE( reflection->GetRepeatedBool (message, F("packed_bool" ), 0)); EXPECT_EQ(foreign_bar_, reflection->GetRepeatedEnum(message, F("packed_enum"), 0)); @@ -2575,7 +2965,7 @@ void TestUtil::ReflectionTester::ExpectPackedFieldsSetViaReflection( 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_EQ(false, reflection->GetRepeatedBool (message, F("packed_bool" ), 1)); + EXPECT_FALSE( reflection->GetRepeatedBool (message, F("packed_bool" ), 1)); EXPECT_EQ(foreign_baz_, reflection->GetRepeatedEnum(message, F("packed_enum"), 1)); } @@ -2609,6 +2999,8 @@ void TestUtil::ReflectionTester::ExpectClearViaReflection( 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_nested_enum" ))); EXPECT_FALSE(reflection->HasField(message, F("optional_foreign_enum"))); @@ -2630,7 +3022,7 @@ void TestUtil::ReflectionTester::ExpectClearViaReflection( 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_FALSE( reflection->GetBool (message, F("optional_bool" ))); EXPECT_EQ("" , reflection->GetString(message, F("optional_string" ))); EXPECT_EQ("" , reflection->GetString(message, F("optional_bytes" ))); @@ -2650,6 +3042,12 @@ void TestUtil::ReflectionTester::ExpectClearViaReflection( 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_)); // Enums without defaults are set to the first value in the enum. EXPECT_EQ( nested_foo_, reflection->GetEnum(message, F("optional_nested_enum" ))); @@ -2683,6 +3081,7 @@ void TestUtil::ReflectionTester::ExpectClearViaReflection( 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" ))); @@ -2727,7 +3126,7 @@ void TestUtil::ReflectionTester::ExpectClearViaReflection( 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_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" ))); @@ -2796,6 +3195,8 @@ void TestUtil::ReflectionTester::ModifyRepeatedFieldsViaReflection( 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_); @@ -2824,7 +3225,8 @@ void TestUtil::ReflectionTester::ModifyPackedFieldsViaReflection( reflection->SetRepeatedEnum (message, F("packed_enum" ), 1, foreign_foo_); } -void TestUtil::ReflectionTester::RemoveLastRepeatedsViaReflection(Message* message) { +void TestUtil::ReflectionTester::RemoveLastRepeatedsViaReflection( + Message* message) { const Reflection* reflection = message->GetReflection(); vector<const FieldDescriptor*> output; @@ -2837,6 +3239,26 @@ void TestUtil::ReflectionTester::RemoveLastRepeatedsViaReflection(Message* messa } } +void TestUtil::ReflectionTester::ReleaseLastRepeatedsViaReflection( + Message* message, bool expect_extensions_notnull) { + const Reflection* reflection = message->GetReflection(); + + 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 != NULL) << "ReleaseLast returned NULL for: " + << field->name(); + } + delete released; + } +} + void TestUtil::ReflectionTester::SwapRepeatedsViaReflection(Message* message) { const Reflection* reflection = message->GetReflection(); @@ -2850,5 +3272,74 @@ void TestUtil::ReflectionTester::SwapRepeatedsViaReflection(Message* message) { } } +void TestUtil::ReflectionTester:: +SetAllocatedOptionalMessageFieldsToNullViaReflection( + Message* message) { + const Reflection* reflection = message->GetReflection(); + + 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, NULL, field); + } +} + +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(); + + 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); + } +} + +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 < GOOGLE_ARRAYSIZE(fields); i++) { + const Message& sub_message = reflection->GetMessage(*message, F(fields[i])); + Message* released = reflection->ReleaseMessage(message, F(fields[i])); + switch (expected_release_state) { + case IS_NULL: + EXPECT_TRUE(released == NULL); + break; + case NOT_NULL: + EXPECT_TRUE(released != NULL); + EXPECT_EQ(&sub_message, released); + break; + case CAN_BE_NULL: + break; + } + delete released; + EXPECT_FALSE(reflection->HasField(*message, F(fields[i]))); + } +} + } // namespace protobuf } // namespace google |