diff options
Diffstat (limited to 'third_party/protobuf/3.2.0/src/google/protobuf/lite_unittest.cc')
| -rw-r--r-- | third_party/protobuf/3.2.0/src/google/protobuf/lite_unittest.cc | 239 |
1 files changed, 192 insertions, 47 deletions
diff --git a/third_party/protobuf/3.2.0/src/google/protobuf/lite_unittest.cc b/third_party/protobuf/3.2.0/src/google/protobuf/lite_unittest.cc index 3ca3fbaf6e..2f5268af15 100644 --- a/third_party/protobuf/3.2.0/src/google/protobuf/lite_unittest.cc +++ b/third_party/protobuf/3.2.0/src/google/protobuf/lite_unittest.cc @@ -36,24 +36,24 @@ #include <google/protobuf/stubs/logging.h> #include <google/protobuf/stubs/common.h> #include <google/protobuf/arena_test_util.h> -#include <google/protobuf/map_lite_unittest.pb.h> #include <google/protobuf/map_lite_test_util.h> +#include <google/protobuf/map_lite_unittest.pb.h> #include <google/protobuf/test_util_lite.h> #include <google/protobuf/unittest_lite.pb.h> #include <google/protobuf/io/coded_stream.h> #include <google/protobuf/io/zero_copy_stream_impl_lite.h> #include <google/protobuf/wire_format_lite.h> #include <google/protobuf/wire_format_lite_inl.h> -#include <google/protobuf/stubs/strutil.h> +#include <gtest/gtest.h> -using namespace std; +#include <google/protobuf/stubs/strutil.h> namespace { // Helper methods to test parsing merge behavior. void ExpectMessageMerged(const google::protobuf::unittest::TestAllTypesLite& message) { - GOOGLE_CHECK(message.optional_int32() == 3); - GOOGLE_CHECK(message.optional_int64() == 2); - GOOGLE_CHECK(message.optional_string() == "hello"); + EXPECT_EQ(message.optional_int32(), 3); + EXPECT_EQ(message.optional_int64(), 2); + EXPECT_EQ(message.optional_string(), "hello"); } void AssignParsingMergeMessages( @@ -71,7 +71,7 @@ void SetAllTypesInEmptyMessageUnknownFields( protobuf_unittest::TestAllTypesLite message; google::protobuf::TestUtilLite::ExpectClear(message); google::protobuf::TestUtilLite::SetAllFields(&message); - string data = message.SerializeAsString(); + std::string data = message.SerializeAsString(); empty_message->ParseFromString(data); } @@ -83,20 +83,14 @@ void SetSomeTypesInEmptyMessageUnknownFields( message.set_optional_int64(102); message.set_optional_uint32(103); message.set_optional_uint64(104); - string data = message.SerializeAsString(); + std::string data = message.SerializeAsString(); empty_message->ParseFromString(data); } } // namespace -#define EXPECT_TRUE GOOGLE_CHECK -#define ASSERT_TRUE GOOGLE_CHECK -#define EXPECT_FALSE(COND) GOOGLE_CHECK(!(COND)) -#define EXPECT_EQ GOOGLE_CHECK_EQ -#define ASSERT_EQ GOOGLE_CHECK_EQ - -int main(int argc, char* argv[]) { - string data, data2, packed_data; +TEST(Lite, AllLite1) { + std::string data; { protobuf_unittest::TestAllTypesLite message, message2, message3; @@ -113,13 +107,16 @@ int main(int argc, char* argv[]) { message.Clear(); google::protobuf::TestUtilLite::ExpectClear(message); } +} +TEST(Lite, AllLite2) { + std::string data; { protobuf_unittest::TestAllExtensionsLite message, message2, message3; google::protobuf::TestUtilLite::ExpectExtensionsClear(message); google::protobuf::TestUtilLite::SetAllExtensions(&message); message2.CopyFrom(message); - string extensions_data = message.SerializeAsString(); + std::string extensions_data = message.SerializeAsString(); message3.ParseFromString(extensions_data); google::protobuf::TestUtilLite::ExpectAllExtensionsSet(message); google::protobuf::TestUtilLite::ExpectAllExtensionsSet(message2); @@ -129,6 +126,10 @@ int main(int argc, char* argv[]) { message.Clear(); google::protobuf::TestUtilLite::ExpectExtensionsClear(message); } +} + +TEST(Lite, AllLite3) { + std::string data, packed_data; { protobuf_unittest::TestPackedTypesLite message, message2, message3; @@ -151,8 +152,8 @@ int main(int argc, char* argv[]) { google::protobuf::TestUtilLite::ExpectPackedExtensionsClear(message); google::protobuf::TestUtilLite::SetPackedExtensions(&message); message2.CopyFrom(message); - string packed_extensions_data = message.SerializeAsString(); - GOOGLE_CHECK(packed_extensions_data == packed_data); + std::string packed_extensions_data = message.SerializeAsString(); + EXPECT_EQ(packed_extensions_data, packed_data); message3.ParseFromString(packed_extensions_data); google::protobuf::TestUtilLite::ExpectPackedExtensionsSet(message); google::protobuf::TestUtilLite::ExpectPackedExtensionsSet(message2); @@ -162,6 +163,10 @@ int main(int argc, char* argv[]) { message.Clear(); google::protobuf::TestUtilLite::ExpectPackedExtensionsClear(message); } +} + +TEST(Lite, AllLite5) { + std::string data; { // Test that if an optional or required message/group field appears multiple @@ -195,7 +200,7 @@ int main(int argc, char* argv[]) { #undef ASSIGN_REPEATED_GROUP - string buffer; + std::string buffer; generator.SerializeToString(&buffer); google::protobuf::unittest::TestParsingMergeLite parsing_merge; parsing_merge.ParseFromString(buffer); @@ -209,11 +214,16 @@ int main(int argc, char* argv[]) { google::protobuf::unittest::TestParsingMergeLite::optional_ext)); // Repeated fields should not be merged. - GOOGLE_CHECK(parsing_merge.repeated_all_types_size() == 3); - GOOGLE_CHECK(parsing_merge.repeatedgroup_size() == 3); - GOOGLE_CHECK(parsing_merge.ExtensionSize( - google::protobuf::unittest::TestParsingMergeLite::repeated_ext) == 3); + EXPECT_EQ(parsing_merge.repeated_all_types_size(), 3); + EXPECT_EQ(parsing_merge.repeatedgroup_size(), 3); + EXPECT_EQ(parsing_merge.ExtensionSize( + google::protobuf::unittest::TestParsingMergeLite::repeated_ext), + 3); } +} + +TEST(Lite, AllLite6) { + std::string data; // Test unknown fields support for lite messages. { @@ -231,6 +241,10 @@ int main(int argc, char* argv[]) { message.Clear(); google::protobuf::TestUtilLite::ExpectClear(message); } +} + +TEST(Lite, AllLite7) { + std::string data; { protobuf_unittest::TestAllExtensionsLite message, message2; @@ -247,6 +261,10 @@ int main(int argc, char* argv[]) { message.Clear(); google::protobuf::TestUtilLite::ExpectExtensionsClear(message); } +} + +TEST(Lite, AllLite8) { + std::string data; { protobuf_unittest::TestPackedTypesLite message, message2; @@ -263,6 +281,10 @@ int main(int argc, char* argv[]) { message.Clear(); google::protobuf::TestUtilLite::ExpectPackedClear(message); } +} + +TEST(Lite, AllLite9) { + std::string data; { protobuf_unittest::TestPackedExtensionsLite message, message2; @@ -279,6 +301,10 @@ int main(int argc, char* argv[]) { message.Clear(); google::protobuf::TestUtilLite::ExpectPackedExtensionsClear(message); } +} + +TEST(Lite, AllLite10) { + std::string data; { // Test Unknown fields swap @@ -286,11 +312,15 @@ int main(int argc, char* argv[]) { SetAllTypesInEmptyMessageUnknownFields(&empty_message); SetSomeTypesInEmptyMessageUnknownFields(&empty_message2); data = empty_message.SerializeAsString(); - data2 = empty_message2.SerializeAsString(); + std::string data2 = empty_message2.SerializeAsString(); empty_message.Swap(&empty_message2); - GOOGLE_CHECK_EQ(data, empty_message2.SerializeAsString()); - GOOGLE_CHECK_EQ(data2, empty_message.SerializeAsString()); + EXPECT_EQ(data, empty_message2.SerializeAsString()); + EXPECT_EQ(data2, empty_message.SerializeAsString()); } +} + +TEST(Lite, AllLite11) { + std::string data; { // Test unknown fields swap with self @@ -298,8 +328,12 @@ int main(int argc, char* argv[]) { SetAllTypesInEmptyMessageUnknownFields(&empty_message); data = empty_message.SerializeAsString(); empty_message.Swap(&empty_message); - GOOGLE_CHECK_EQ(data, empty_message.SerializeAsString()); + EXPECT_EQ(data, empty_message.SerializeAsString()); } +} + +TEST(Lite, AllLite12) { + std::string data; { // Test MergeFrom with unknown fields @@ -324,13 +358,17 @@ int main(int argc, char* argv[]) { // We do not compare the serialized output of a normal message and a lite // message because the order of fields do not match. We convert lite message // back into normal message, then compare. - GOOGLE_CHECK_EQ(message.SerializeAsString(), message2.SerializeAsString()); + EXPECT_EQ(message.SerializeAsString(), message2.SerializeAsString()); } +} + +TEST(Lite, AllLite13) { + std::string data; { // Test unknown enum value protobuf_unittest::TestAllTypesLite message; - string buffer; + std::string buffer; { google::protobuf::io::StringOutputStream output_stream(&buffer); google::protobuf::io::CodedOutputStream coded_output(&output_stream); @@ -345,18 +383,26 @@ int main(int argc, char* argv[]) { } message.ParseFromString(buffer); data = message.SerializeAsString(); - GOOGLE_CHECK_EQ(data, buffer); + EXPECT_EQ(data, buffer); } +} + +TEST(Lite, AllLite14) { + std::string data; { // Test Clear with unknown fields protobuf_unittest::TestEmptyMessageLite empty_message; SetAllTypesInEmptyMessageUnknownFields(&empty_message); empty_message.Clear(); - GOOGLE_CHECK_EQ(0, empty_message.unknown_fields().size()); + EXPECT_EQ(0, empty_message.unknown_fields().size()); } +} + +// Tests for map lite ============================================= - // Tests for map lite ============================================= +TEST(Lite, AllLite15) { + std::string data; { // Accessors @@ -368,6 +414,10 @@ int main(int argc, char* argv[]) { google::protobuf::MapLiteTestUtil::ModifyMapFields(&message); google::protobuf::MapLiteTestUtil::ExpectMapFieldsModified(message); } +} + +TEST(Lite, AllLite16) { + std::string data; { // SetMapFieldsInitialized @@ -376,6 +426,10 @@ int main(int argc, char* argv[]) { google::protobuf::MapLiteTestUtil::SetMapFieldsInitialized(&message); google::protobuf::MapLiteTestUtil::ExpectMapFieldsSetInitialized(message); } +} + +TEST(Lite, AllLite17) { + std::string data; { // Clear @@ -385,6 +439,10 @@ int main(int argc, char* argv[]) { message.Clear(); google::protobuf::MapLiteTestUtil::ExpectClear(message); } +} + +TEST(Lite, AllLite18) { + std::string data; { // ClearMessageMap @@ -394,6 +452,10 @@ int main(int argc, char* argv[]) { google::protobuf::TestUtilLite::ExpectClear( (*message.mutable_map_int32_message())[0]); } +} + +TEST(Lite, AllLite19) { + std::string data; { // CopyFrom @@ -407,6 +469,10 @@ int main(int argc, char* argv[]) { message2.CopyFrom(message2); google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); } +} + +TEST(Lite, AllLite20) { + std::string data; { // CopyFromMessageMap @@ -421,6 +487,10 @@ int main(int argc, char* argv[]) { EXPECT_EQ(1, message1.map_int32_message().at(0).repeated_int32_size()); EXPECT_EQ(101, message1.map_int32_message().at(0).repeated_int32(0)); } +} + +TEST(Lite, AllLite21) { + std::string data; { // SwapWithEmpty @@ -434,6 +504,10 @@ int main(int argc, char* argv[]) { google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); google::protobuf::MapLiteTestUtil::ExpectClear(message1); } +} + +TEST(Lite, AllLite22) { + std::string data; { // SwapWithSelf @@ -445,6 +519,10 @@ int main(int argc, char* argv[]) { message.Swap(&message); google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message); } +} + +TEST(Lite, AllLite23) { + std::string data; { // SwapWithOther @@ -458,6 +536,10 @@ int main(int argc, char* argv[]) { google::protobuf::MapLiteTestUtil::ExpectMapFieldsModified(message1); google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); } +} + +TEST(Lite, AllLite24) { + std::string data; { // CopyConstructor @@ -467,6 +549,10 @@ int main(int argc, char* argv[]) { protobuf_unittest::TestMapLite message2(message1); google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); } +} + +TEST(Lite, AllLite25) { + std::string data; { // CopyAssignmentOperator @@ -481,6 +567,10 @@ int main(int argc, char* argv[]) { message2.operator=(message2); google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); } +} + +TEST(Lite, AllLite26) { + std::string data; { // NonEmptyMergeFrom @@ -499,6 +589,10 @@ int main(int argc, char* argv[]) { message1.MergeFrom(message2); google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message1); } +} + +TEST(Lite, AllLite27) { + std::string data; { // MergeFromMessageMap @@ -513,11 +607,15 @@ int main(int argc, char* argv[]) { EXPECT_EQ(1, message1.map_int32_message().at(0).repeated_int32_size()); EXPECT_EQ(101, message1.map_int32_message().at(0).repeated_int32(0)); } +} + +TEST(Lite, AllLite28) { + std::string data; { // Test the generated SerializeWithCachedSizesToArray() protobuf_unittest::TestMapLite message1, message2; - string data; + std::string data; google::protobuf::MapLiteTestUtil::SetMapFields(&message1); int size = message1.ByteSize(); data.resize(size); @@ -527,13 +625,17 @@ int main(int argc, char* argv[]) { EXPECT_TRUE(message2.ParseFromString(data)); google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); } +} + +TEST(Lite, AllLite29) { + std::string data; { // Test the generated SerializeWithCachedSizes() protobuf_unittest::TestMapLite message1, message2; google::protobuf::MapLiteTestUtil::SetMapFields(&message1); int size = message1.ByteSize(); - string data; + std::string data; data.resize(size); { // Allow the output stream to buffer only one byte at a time. @@ -547,7 +649,11 @@ int main(int argc, char* argv[]) { EXPECT_TRUE(message2.ParseFromString(data)); google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); } +} + +TEST(Lite, AllLite32) { + std::string data; { // Proto2UnknownEnum @@ -556,7 +662,7 @@ int main(int argc, char* argv[]) { protobuf_unittest::E_PROTO2_MAP_ENUM_FOO_LITE; (*from.mutable_unknown_map_field())[0] = protobuf_unittest::E_PROTO2_MAP_ENUM_EXTRA_LITE; - string data; + std::string data; from.SerializeToString(&data); protobuf_unittest::TestEnumMapLite to; @@ -578,98 +684,134 @@ int main(int argc, char* argv[]) { EXPECT_EQ(protobuf_unittest::E_PROTO2_MAP_ENUM_EXTRA_LITE, from.unknown_map_field().at(0)); } +} + +TEST(Lite, AllLite33) { + std::string data; { // StandardWireFormat protobuf_unittest::TestMapLite message; - string data = "\x0A\x04\x08\x01\x10\x01"; + std::string data = "\x0A\x04\x08\x01\x10\x01"; EXPECT_TRUE(message.ParseFromString(data)); EXPECT_EQ(1, message.map_int32_int32().size()); EXPECT_EQ(1, message.map_int32_int32().at(1)); } +} + +TEST(Lite, AllLite34) { + std::string data; { // UnorderedWireFormat protobuf_unittest::TestMapLite message; // put value before key in wire format - string data = "\x0A\x04\x10\x01\x08\x02"; + std::string data = "\x0A\x04\x10\x01\x08\x02"; EXPECT_TRUE(message.ParseFromString(data)); EXPECT_EQ(1, message.map_int32_int32().size()); EXPECT_EQ(1, message.map_int32_int32().at(2)); } +} + +TEST(Lite, AllLite35) { + std::string data; { // DuplicatedKeyWireFormat protobuf_unittest::TestMapLite message; // Two key fields in wire format - string data = "\x0A\x06\x08\x01\x08\x02\x10\x01"; + std::string data = "\x0A\x06\x08\x01\x08\x02\x10\x01"; EXPECT_TRUE(message.ParseFromString(data)); EXPECT_EQ(1, message.map_int32_int32().size()); EXPECT_EQ(1, message.map_int32_int32().at(2)); } +} + +TEST(Lite, AllLite36) { + std::string data; { // DuplicatedValueWireFormat protobuf_unittest::TestMapLite message; // Two value fields in wire format - string data = "\x0A\x06\x08\x01\x10\x01\x10\x02"; + std::string data = "\x0A\x06\x08\x01\x10\x01\x10\x02"; EXPECT_TRUE(message.ParseFromString(data)); EXPECT_EQ(1, message.map_int32_int32().size()); EXPECT_EQ(2, message.map_int32_int32().at(1)); } +} + +TEST(Lite, AllLite37) { + std::string data; { // MissedKeyWireFormat protobuf_unittest::TestMapLite message; // No key field in wire format - string data = "\x0A\x02\x10\x01"; + std::string data = "\x0A\x02\x10\x01"; EXPECT_TRUE(message.ParseFromString(data)); EXPECT_EQ(1, message.map_int32_int32().size()); EXPECT_EQ(1, message.map_int32_int32().at(0)); } +} + +TEST(Lite, AllLite38) { + std::string data; { // MissedValueWireFormat protobuf_unittest::TestMapLite message; // No value field in wire format - string data = "\x0A\x02\x08\x01"; + std::string data = "\x0A\x02\x08\x01"; EXPECT_TRUE(message.ParseFromString(data)); EXPECT_EQ(1, message.map_int32_int32().size()); EXPECT_EQ(0, message.map_int32_int32().at(1)); } +} + +TEST(Lite, AllLite39) { + std::string data; { // UnknownFieldWireFormat protobuf_unittest::TestMapLite message; // Unknown field in wire format - string data = "\x0A\x06\x08\x02\x10\x03\x18\x01"; + std::string data = "\x0A\x06\x08\x02\x10\x03\x18\x01"; EXPECT_TRUE(message.ParseFromString(data)); EXPECT_EQ(1, message.map_int32_int32().size()); EXPECT_EQ(3, message.map_int32_int32().at(2)); } +} + +TEST(Lite, AllLite40) { + std::string data; { // CorruptedWireFormat protobuf_unittest::TestMapLite message; // corrupted data in wire format - string data = "\x0A\x06\x08\x02\x11\x03"; + std::string data = "\x0A\x06\x08\x02\x11\x03"; EXPECT_FALSE(message.ParseFromString(data)); } +} + +TEST(Lite, AllLite41) { + std::string data; { // IsInitialized @@ -685,6 +827,10 @@ int main(int argc, char* argv[]) { (*map_message.mutable_map_field())[0].set_c(0); EXPECT_TRUE(map_message.IsInitialized()); } +} + +TEST(Lite, AllLite42) { + std::string data; { // Check that adding more values to enum does not corrupt message @@ -693,7 +839,7 @@ int main(int argc, char* argv[]) { v2_message.set_int_field(800); // Set enum field to the value not understood by the old client. v2_message.set_enum_field(protobuf_unittest::V2_SECOND); - string v2_bytes = v2_message.SerializeAsString(); + std::string v2_bytes = v2_message.SerializeAsString(); protobuf_unittest::V1MessageLite v1_message; v1_message.ParseFromString(v2_bytes); @@ -704,7 +850,7 @@ int main(int argc, char* argv[]) { EXPECT_EQ(v1_message.enum_field(), protobuf_unittest::V1_FIRST); // However, when re-serialized, it should preserve enum value. - string v1_bytes = v1_message.SerializeAsString(); + std::string v1_bytes = v1_message.SerializeAsString(); protobuf_unittest::V2MessageLite same_v2_message; same_v2_message.ParseFromString(v1_bytes); @@ -714,5 +860,4 @@ int main(int argc, char* argv[]) { } std::cout << "PASS" << std::endl; - return 0; } |