| // Protocol Buffers - Google's data interchange format |
| // Copyright 2008 Google Inc. All rights reserved. |
| // |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file or at |
| // https://developers.google.com/open-source/licenses/bsd |
| |
| #include "text_format_conformance_suite.h" |
| |
| #include <cstddef> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "absl/log/absl_log.h" |
| #include "absl/log/die_if_null.h" |
| #include "absl/strings/str_cat.h" |
| #include "absl/strings/str_format.h" |
| #include "conformance_test.h" |
| #include "conformance/test_protos/test_messages_edition2023.pb.h" |
| #include "editions/golden/test_messages_proto2_editions.pb.h" |
| #include "editions/golden/test_messages_proto3_editions.pb.h" |
| #include "google/protobuf/test_messages_proto2.pb.h" |
| #include "google/protobuf/test_messages_proto3.pb.h" |
| #include "google/protobuf/text_format.h" |
| |
| using conformance::ConformanceRequest; |
| using conformance::ConformanceResponse; |
| using conformance::TestStatus; |
| using conformance::WireFormat; |
| using protobuf_test_messages::editions::TestAllTypesEdition2023; |
| using protobuf_test_messages::proto2::TestAllTypesProto2; |
| using protobuf_test_messages::proto2::UnknownToTestAllTypes; |
| using protobuf_test_messages::proto3::TestAllTypesProto3; |
| using TestAllTypesProto2Editions = |
| protobuf_test_messages::editions::proto2::TestAllTypesProto2; |
| using TestAllTypesProto3Editions = |
| protobuf_test_messages::editions::proto3::TestAllTypesProto3; |
| |
| namespace google { |
| namespace protobuf { |
| |
| // The number of repetitions to use for performance tests. |
| // Corresponds approx to 500KB wireformat bytes. |
| static const size_t kPerformanceRepeatCount = 50000; |
| |
| TextFormatConformanceTestSuite::TextFormatConformanceTestSuite() { |
| SetFailureListFlagName("--text_format_failure_list"); |
| } |
| |
| bool TextFormatConformanceTestSuite::ParseTextFormatResponse( |
| const ConformanceResponse& response, |
| const ConformanceRequestSetting& setting, Message* test_message) { |
| TextFormat::Parser parser; |
| const ConformanceRequest& request = setting.GetRequest(); |
| if (request.print_unknown_fields()) { |
| parser.AllowFieldNumber(true); |
| } |
| if (!parser.ParseFromString(response.text_payload(), test_message)) { |
| ABSL_LOG(ERROR) << "INTERNAL ERROR: internal text->protobuf transcode " |
| << "yielded unparseable proto. Text payload: " |
| << response.text_payload(); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool TextFormatConformanceTestSuite::ParseResponse( |
| const ConformanceResponse& response, |
| const ConformanceRequestSetting& setting, Message* test_message) { |
| const ConformanceRequest& request = setting.GetRequest(); |
| WireFormat requested_output = request.requested_output_format(); |
| const std::string& test_name = setting.GetTestName(); |
| ConformanceLevel level = setting.GetLevel(); |
| |
| TestStatus test; |
| test.set_name(test_name); |
| switch (response.result_case()) { |
| case ConformanceResponse::kProtobufPayload: { |
| if (requested_output != conformance::PROTOBUF) { |
| test.set_failure_message(absl::StrCat( |
| "Test was asked for ", WireFormatToString(requested_output), |
| " output but provided PROTOBUF instead.")); |
| ReportFailure(test, level, request, response); |
| return false; |
| } |
| |
| if (!test_message->ParseFromString(response.protobuf_payload())) { |
| test.set_failure_message( |
| "Protobuf output we received from test was unparseable."); |
| ReportFailure(test, level, request, response); |
| return false; |
| } |
| |
| break; |
| } |
| |
| case ConformanceResponse::kTextPayload: { |
| if (requested_output != conformance::TEXT_FORMAT) { |
| test.set_failure_message(absl::StrCat( |
| "Test was asked for ", WireFormatToString(requested_output), |
| " output but provided TEXT_FORMAT instead.")); |
| ReportFailure(test, level, request, response); |
| return false; |
| } |
| |
| if (!ParseTextFormatResponse(response, setting, test_message)) { |
| test.set_failure_message( |
| "TEXT_FORMAT output we received from test was unparseable."); |
| ReportFailure(test, level, request, response); |
| return false; |
| } |
| |
| break; |
| } |
| |
| default: |
| ABSL_LOG(FATAL) << test_name |
| << ": unknown payload type: " << response.result_case(); |
| } |
| |
| return true; |
| } |
| |
| void TextFormatConformanceTestSuite::RunSuiteImpl() { |
| TextFormatConformanceTestSuiteImpl<TestAllTypesProto2>(this); |
| TextFormatConformanceTestSuiteImpl<TestAllTypesProto3>(this); |
| if (maximum_edition_ >= Edition::EDITION_2023) { |
| TextFormatConformanceTestSuiteImpl<TestAllTypesProto2Editions>(this); |
| TextFormatConformanceTestSuiteImpl<TestAllTypesProto3Editions>(this); |
| TextFormatConformanceTestSuiteImpl<TestAllTypesEdition2023>(this); |
| } |
| } |
| |
| template <typename MessageType> |
| TextFormatConformanceTestSuiteImpl<MessageType>:: |
| TextFormatConformanceTestSuiteImpl(TextFormatConformanceTestSuite* suite) |
| : suite_(*ABSL_DIE_IF_NULL(suite)) { |
| // Flag control performance tests to keep them internal and opt-in only |
| if (suite_.performance_) { |
| if (MessageType::GetDescriptor()->name() == "TestAllTypesEdition2023") { |
| // There are no editions-sensitive performance tests. |
| return; |
| } |
| RunTextFormatPerformanceTests(); |
| } else { |
| if (MessageType::GetDescriptor()->name() == "TestAllTypesProto2") { |
| RunGroupTests(); |
| RunClosedEnumTests(); |
| } |
| if (MessageType::GetDescriptor()->name() == "TestAllTypesEdition2023") { |
| RunDelimitedTests(); |
| } |
| if (MessageType::GetDescriptor()->name() == "TestAllTypesProto3") { |
| RunAnyTests(); |
| RunOpenEnumTests(); |
| // TODO Run these over proto2 also. |
| RunAllTests(); |
| } |
| } |
| } |
| |
| template <typename MessageType> |
| void TextFormatConformanceTestSuiteImpl<MessageType>::ExpectParseFailure( |
| const std::string& test_name, ConformanceLevel level, |
| const std::string& input) { |
| MessageType prototype; |
| // We don't expect output, but if the program erroneously accepts the protobuf |
| // we let it send its response as this. We must not leave it unspecified. |
| ConformanceRequestSetting setting( |
| level, conformance::TEXT_FORMAT, conformance::TEXT_FORMAT, |
| conformance::TEXT_FORMAT_TEST, prototype, test_name, input); |
| const ConformanceRequest& request = setting.GetRequest(); |
| ConformanceResponse response; |
| std::string effective_test_name = absl::StrCat( |
| setting.ConformanceLevelToString(level), ".", |
| setting.GetSyntaxIdentifier(), ".TextFormatInput.", test_name); |
| |
| if (!suite_.RunTest(effective_test_name, request, &response)) { |
| return; |
| } |
| |
| TestStatus test; |
| test.set_name(effective_test_name); |
| if (response.result_case() == ConformanceResponse::kParseError) { |
| suite_.ReportSuccess(test); |
| } else if (response.result_case() == ConformanceResponse::kSkipped) { |
| suite_.ReportSkip(test, request, response); |
| } else { |
| test.set_failure_message("Should have failed to parse, but didn't."); |
| suite_.ReportFailure(test, level, request, response); |
| } |
| } |
| |
| template <typename MessageType> |
| void TextFormatConformanceTestSuiteImpl<MessageType>::RunValidTextFormatTest( |
| const std::string& test_name, ConformanceLevel level, |
| const std::string& input_text) { |
| MessageType prototype; |
| RunValidTextFormatTestWithMessage(test_name, level, input_text, prototype); |
| } |
| |
| template <typename MessageType> |
| void TextFormatConformanceTestSuiteImpl<MessageType>:: |
| RunValidTextFormatTestWithMessage(const std::string& test_name, |
| ConformanceLevel level, |
| const std::string& input_text, |
| const Message& message) { |
| ConformanceRequestSetting setting1( |
| level, conformance::TEXT_FORMAT, conformance::PROTOBUF, |
| conformance::TEXT_FORMAT_TEST, message, test_name, input_text); |
| suite_.RunValidInputTest(setting1, input_text); |
| ConformanceRequestSetting setting2( |
| level, conformance::TEXT_FORMAT, conformance::TEXT_FORMAT, |
| conformance::TEXT_FORMAT_TEST, message, test_name, input_text); |
| suite_.RunValidInputTest(setting2, input_text); |
| } |
| |
| template <typename MessageType> |
| void TextFormatConformanceTestSuiteImpl<MessageType>:: |
| RunValidTextFormatTestWithExpected(const std::string& test_name, |
| ConformanceLevel level, |
| const std::string& input_text, |
| const std::string& expected_text) { |
| MessageType prototype; |
| ConformanceRequestSetting setting1( |
| level, conformance::TEXT_FORMAT, conformance::PROTOBUF, |
| conformance::TEXT_FORMAT_TEST, prototype, test_name, input_text); |
| suite_.RunValidInputTest(setting1, expected_text); |
| ConformanceRequestSetting setting2( |
| level, conformance::TEXT_FORMAT, conformance::TEXT_FORMAT, |
| conformance::TEXT_FORMAT_TEST, prototype, test_name, input_text); |
| suite_.RunValidInputTest(setting2, expected_text); |
| } |
| |
| template <typename MessageType> |
| void TextFormatConformanceTestSuiteImpl< |
| MessageType>::RunValidUnknownTextFormatTest(const std::string& test_name, |
| const Message& message) { |
| std::string serialized_input; |
| message.SerializeToString(&serialized_input); |
| MessageType prototype; |
| ConformanceRequestSetting setting1( |
| RECOMMENDED, conformance::PROTOBUF, conformance::TEXT_FORMAT, |
| conformance::TEXT_FORMAT_TEST, prototype, |
| absl::StrCat(test_name, "_Drop"), serialized_input); |
| setting1.SetPrototypeMessageForCompare(message); |
| suite_.RunValidBinaryInputTest(setting1, ""); |
| |
| ConformanceRequestSetting setting2( |
| RECOMMENDED, conformance::PROTOBUF, conformance::TEXT_FORMAT, |
| conformance::TEXT_FORMAT_TEST, prototype, |
| absl::StrCat(test_name, "_Print"), serialized_input); |
| setting2.SetPrototypeMessageForCompare(message); |
| setting2.SetPrintUnknownFields(true); |
| suite_.RunValidBinaryInputTest(setting2, serialized_input); |
| } |
| |
| template <typename MessageType> |
| void TextFormatConformanceTestSuiteImpl<MessageType>::RunDelimitedTests() { |
| RunValidTextFormatTest("GroupFieldNoColon", REQUIRED, |
| "GroupLikeType { group_int32: 1 }"); |
| RunValidTextFormatTest("GroupFieldWithColon", REQUIRED, |
| "GroupLikeType: { group_int32: 1 }"); |
| RunValidTextFormatTest("GroupFieldEmpty", REQUIRED, "GroupLikeType {}"); |
| RunValidTextFormatTest( |
| "GroupFieldExtension", REQUIRED, |
| "[protobuf_test_messages.editions.groupliketype] { c: 1 }"); |
| RunValidTextFormatTest( |
| "DelimitedFieldExtension", REQUIRED, |
| "[protobuf_test_messages.editions.delimited_ext] { c: 1 }"); |
| |
| |
| // Test that lower-cased group name (i.e. implicit field name) are accepted. |
| RunValidTextFormatTest("DelimitedFieldLowercased", REQUIRED, |
| "groupliketype { group_int32: 1 }"); |
| RunValidTextFormatTest("DelimitedFieldLowercasedDifferent", REQUIRED, |
| "delimited_field { group_int32: 1 }"); |
| |
| // Extensions always used the field name, and should never accept the message |
| // name. |
| ExpectParseFailure( |
| "DelimitedFieldExtensionMessageName", REQUIRED, |
| "[protobuf_test_messages.editions.GroupLikeType] { group_int32: 1 }"); |
| } |
| |
| template <typename MessageType> |
| void TextFormatConformanceTestSuiteImpl<MessageType>::RunGroupTests() { |
| RunValidTextFormatTest("GroupFieldNoColon", REQUIRED, |
| "Data { group_int32: 1 }"); |
| RunValidTextFormatTest("GroupFieldWithColon", REQUIRED, |
| "Data: { group_int32: 1 }"); |
| RunValidTextFormatTest("GroupFieldEmpty", REQUIRED, "Data {}"); |
| RunValidTextFormatTest("GroupFieldMultiWord", REQUIRED, |
| "MultiWordGroupField { group_int32: 1 }"); |
| |
| // Test that lower-cased group name (i.e. implicit field name) is accepted |
| RunValidTextFormatTest("GroupFieldLowercased", REQUIRED, |
| "data { group_int32: 1 }"); |
| RunValidTextFormatTest("GroupFieldLowercasedMultiWord", REQUIRED, |
| "multiwordgroupfield { group_int32: 1 }"); |
| |
| // Test extensions of group type |
| RunValidTextFormatTest("GroupFieldExtension", REQUIRED, |
| absl::StrFormat("[%s] { group_int32: 1 }", |
| MessageType::GetDescriptor() |
| ->file() |
| ->FindExtensionByName("groupfield") |
| ->PrintableNameForExtension())); |
| ExpectParseFailure("GroupFieldExtensionGroupName", REQUIRED, |
| absl::StrFormat("[%s] { group_int32: 1 }", |
| MessageType::GetDescriptor() |
| ->file() |
| ->FindMessageTypeByName("GroupField") |
| ->full_name())); |
| } |
| |
| template <typename MessageType> |
| void TextFormatConformanceTestSuiteImpl<MessageType>::RunAllTests() { |
| RunValidTextFormatTest("HelloWorld", REQUIRED, |
| "optional_string: 'Hello, World!'"); |
| // Integer fields. |
| RunValidTextFormatTest("Int32FieldMaxValue", REQUIRED, |
| "optional_int32: 2147483647"); |
| RunValidTextFormatTest("Int32FieldMinValue", REQUIRED, |
| "optional_int32: -2147483648"); |
| RunValidTextFormatTest("Uint32FieldMaxValue", REQUIRED, |
| "optional_uint32: 4294967295"); |
| RunValidTextFormatTest("Int64FieldMaxValue", REQUIRED, |
| "optional_int64: 9223372036854775807"); |
| RunValidTextFormatTest("Int64FieldMinValue", REQUIRED, |
| "optional_int64: -9223372036854775808"); |
| RunValidTextFormatTest("Uint64FieldMaxValue", REQUIRED, |
| "optional_uint64: 18446744073709551615"); |
| // Integer fields - Hex |
| RunValidTextFormatTestWithExpected("Int32FieldMaxValueHex", REQUIRED, |
| "optional_int32: 0x7FFFFFFF", |
| "optional_int32: 2147483647"); |
| RunValidTextFormatTestWithExpected("Int32FieldMinValueHex", REQUIRED, |
| "optional_int32: -0x80000000", |
| "optional_int32: -2147483648"); |
| RunValidTextFormatTestWithExpected("Uint32FieldMaxValueHex", REQUIRED, |
| "optional_uint32: 0xFFFFFFFF", |
| "optional_uint32: 4294967295"); |
| RunValidTextFormatTestWithExpected("Int64FieldMaxValueHex", REQUIRED, |
| "optional_int64: 0x7FFFFFFFFFFFFFFF", |
| "optional_int64: 9223372036854775807"); |
| RunValidTextFormatTestWithExpected("Int64FieldMinValueHex", REQUIRED, |
| "optional_int64: -0x8000000000000000", |
| "optional_int64: -9223372036854775808"); |
| RunValidTextFormatTestWithExpected("Uint64FieldMaxValueHex", REQUIRED, |
| "optional_uint64: 0xFFFFFFFFFFFFFFFF", |
| "optional_uint64: 18446744073709551615"); |
| // Integer fields - Octal |
| RunValidTextFormatTestWithExpected("Int32FieldMaxValueOctal", REQUIRED, |
| "optional_int32: 017777777777", |
| "optional_int32: 2147483647"); |
| RunValidTextFormatTestWithExpected("Int32FieldMinValueOctal", REQUIRED, |
| "optional_int32: -020000000000", |
| "optional_int32: -2147483648"); |
| RunValidTextFormatTestWithExpected("Uint32FieldMaxValueOctal", REQUIRED, |
| "optional_uint32: 037777777777", |
| "optional_uint32: 4294967295"); |
| RunValidTextFormatTestWithExpected("Int64FieldMaxValueOctal", REQUIRED, |
| "optional_int64: 0777777777777777777777", |
| "optional_int64: 9223372036854775807"); |
| RunValidTextFormatTestWithExpected("Int64FieldMinValueOctal", REQUIRED, |
| "optional_int64: -01000000000000000000000", |
| "optional_int64: -9223372036854775808"); |
| RunValidTextFormatTestWithExpected("Uint64FieldMaxValueOctal", REQUIRED, |
| "optional_uint64: 01777777777777777777777", |
| "optional_uint64: 18446744073709551615"); |
| |
| // Parsers reject out-of-bound integer values. |
| ExpectParseFailure("Int32FieldTooLarge", REQUIRED, |
| "optional_int32: 2147483648"); |
| ExpectParseFailure("Int32FieldTooSmall", REQUIRED, |
| "optional_int32: -2147483649"); |
| ExpectParseFailure("Uint32FieldTooLarge", REQUIRED, |
| "optional_uint32: 4294967296"); |
| ExpectParseFailure("Int64FieldTooLarge", REQUIRED, |
| "optional_int64: 9223372036854775808"); |
| ExpectParseFailure("Int64FieldTooSmall", REQUIRED, |
| "optional_int64: -9223372036854775809"); |
| ExpectParseFailure("Uint64FieldTooLarge", REQUIRED, |
| "optional_uint64: 18446744073709551616"); |
| // Parsers reject out-of-bound integer values - Hex |
| ExpectParseFailure("Int32FieldTooLargeHex", REQUIRED, |
| "optional_int32: 0x80000000"); |
| ExpectParseFailure("Int32FieldTooSmallHex", REQUIRED, |
| "optional_int32: -0x80000001"); |
| ExpectParseFailure("Uint32FieldTooLargeHex", REQUIRED, |
| "optional_uint32: 0x100000000"); |
| ExpectParseFailure("Int64FieldTooLargeHex", REQUIRED, |
| "optional_int64: 0x8000000000000000"); |
| ExpectParseFailure("Int64FieldTooSmallHex", REQUIRED, |
| "optional_int64: -0x8000000000000001"); |
| ExpectParseFailure("Uint64FieldTooLargeHex", REQUIRED, |
| "optional_uint64: 0x10000000000000000"); |
| // Parsers reject out-of-bound integer values - Octal |
| ExpectParseFailure("Int32FieldTooLargeOctal", REQUIRED, |
| "optional_int32: 020000000000"); |
| ExpectParseFailure("Int32FieldTooSmallOctal", REQUIRED, |
| "optional_int32: -020000000001"); |
| ExpectParseFailure("Uint32FieldTooLargeOctal", REQUIRED, |
| "optional_uint32: 040000000000"); |
| ExpectParseFailure("Int64FieldTooLargeOctal", REQUIRED, |
| "optional_int64: 01000000000000000000000"); |
| ExpectParseFailure("Int64FieldTooSmallOctal", REQUIRED, |
| "optional_int64: -01000000000000000000001"); |
| ExpectParseFailure("Uint64FieldTooLargeOctal", REQUIRED, |
| "optional_uint64: 02000000000000000000000"); |
| |
| // Floating point fields |
| for (const auto& suffix : std::vector<std::string>{"", "f", "F"}) { |
| const std::string name_suffix = |
| suffix.empty() ? "" : absl::StrCat("_", suffix); |
| |
| RunValidTextFormatTest(absl::StrCat("FloatField", name_suffix), REQUIRED, |
| absl::StrCat("optional_float: 3.192837", suffix)); |
| RunValidTextFormatTestWithExpected( |
| absl::StrCat("FloatFieldZero", name_suffix), REQUIRED, |
| absl::StrCat("optional_float: 0", suffix), |
| "" /* implicit presence, so zero means unset*/); |
| RunValidTextFormatTest(absl::StrCat("FloatFieldNegative", name_suffix), |
| REQUIRED, |
| absl::StrCat("optional_float: -3.192837", suffix)); |
| RunValidTextFormatTest( |
| absl::StrCat("FloatFieldWithVeryPreciseNumber", name_suffix), REQUIRED, |
| absl::StrCat("optional_float: 3.123456789123456789", suffix)); |
| RunValidTextFormatTest( |
| absl::StrCat("FloatFieldMaxValue", name_suffix), REQUIRED, |
| absl::StrCat("optional_float: 3.4028235e+38", suffix)); |
| RunValidTextFormatTest(absl::StrCat("FloatFieldMinValue", name_suffix), |
| REQUIRED, |
| absl::StrCat("optional_float: 1.17549e-38", suffix)); |
| RunValidTextFormatTest(absl::StrCat("FloatFieldWithInt32Max", name_suffix), |
| REQUIRED, |
| absl::StrCat("optional_float: 4294967296", suffix)); |
| RunValidTextFormatTest( |
| absl::StrCat("FloatFieldLargerThanInt64", name_suffix), REQUIRED, |
| absl::StrCat("optional_float: 9223372036854775808", suffix)); |
| RunValidTextFormatTest( |
| absl::StrCat("FloatFieldTooLarge", name_suffix), REQUIRED, |
| absl::StrCat("optional_float: 3.4028235e+39", suffix)); |
| RunValidTextFormatTest(absl::StrCat("FloatFieldTooSmall", name_suffix), |
| REQUIRED, |
| absl::StrCat("optional_float: 1.17549e-39", suffix)); |
| RunValidTextFormatTest( |
| absl::StrCat("FloatFieldLargerThanUint64", name_suffix), REQUIRED, |
| absl::StrCat("optional_float: 18446744073709551616", suffix)); |
| // https://protobuf.dev/reference/protobuf/textformat-spec/#literals says |
| // "-0" is a valid float literal. -0 should be considered not the same as 0 |
| // when considering implicit presence, and so should round trip. |
| RunValidTextFormatTest(absl::StrCat("FloatFieldNegativeZero", name_suffix), |
| REQUIRED, |
| absl::StrCat("optional_float: -0", suffix)); |
| // https://protobuf.dev/reference/protobuf/textformat-spec/#literals says |
| // ".123", "-.123", ".123e2" are a valid float literal. |
| RunValidTextFormatTest(absl::StrCat("FloatFieldNoLeadingZero", name_suffix), |
| REQUIRED, |
| absl::StrCat("optional_float: .123", suffix)); |
| RunValidTextFormatTest( |
| absl::StrCat("FloatFieldNegativeNoLeadingZero", name_suffix), REQUIRED, |
| absl::StrCat("optional_float: -.123", suffix)); |
| RunValidTextFormatTest( |
| absl::StrCat("FloatFieldNoLeadingZeroWithExponent", name_suffix), |
| REQUIRED, absl::StrCat("optional_float: .123e2", suffix)); |
| } |
| // https://protobuf.dev/reference/protobuf/textformat-spec/#value say case |
| // doesn't matter for special values, test a few |
| for (const auto& value : std::vector<std::string>{"nan", "NaN", "nAn"}) { |
| RunValidTextFormatTest(absl::StrCat("FloatFieldValue_", value), REQUIRED, |
| absl::StrCat("optional_float: ", value)); |
| } |
| for (const auto& value : std::vector<std::string>{ |
| "inf", "infinity", "INF", "INFINITY", "iNF", "inFINITY"}) { |
| RunValidTextFormatTest(absl::StrCat("FloatFieldValue_Pos", value), REQUIRED, |
| absl::StrCat("optional_float: ", value)); |
| RunValidTextFormatTest(absl::StrCat("FloatFieldValue_Neg", value), REQUIRED, |
| absl::StrCat("optional_float: -", value)); |
| } |
| // https://protobuf.dev/reference/protobuf/textformat-spec/#numeric and |
| // https://protobuf.dev/reference/protobuf/textformat-spec/#value says |
| // hex or octal float literals are invalid. |
| ExpectParseFailure("FloatFieldNoHex", REQUIRED, "optional_float: 0x1"); |
| ExpectParseFailure("FloatFieldNoNegativeHex", REQUIRED, |
| "optional_float: -0x1"); |
| ExpectParseFailure("FloatFieldNoOctal", REQUIRED, "optional_float: 012"); |
| ExpectParseFailure("FloatFieldNoNegativeOctal", REQUIRED, |
| "optional_float: -012"); |
| // https://protobuf.dev/reference/protobuf/textformat-spec/#value says |
| // overflows are mapped to infinity/-infinity. |
| RunValidTextFormatTestWithExpected("FloatFieldOverflowInfinity", REQUIRED, |
| "optional_float: 1e50", |
| "optional_float: inf"); |
| RunValidTextFormatTestWithExpected("FloatFieldOverflowNegativeInfinity", |
| REQUIRED, "optional_float: -1e50", |
| "optional_float: -inf"); |
| RunValidTextFormatTestWithExpected("DoubleFieldOverflowInfinity", REQUIRED, |
| "optional_double: 1e9999", |
| "optional_double: inf"); |
| RunValidTextFormatTestWithExpected("DoubleFieldOverflowNegativeInfinity", |
| REQUIRED, "optional_double: -1e9999", |
| "optional_double: -inf"); |
| // Exponent is one more than uint64 max. |
| RunValidTextFormatTestWithExpected( |
| "FloatFieldOverflowInfinityHugeExponent", REQUIRED, |
| "optional_float: 1e18446744073709551616", "optional_float: inf"); |
| RunValidTextFormatTestWithExpected( |
| "DoubleFieldOverflowInfinityHugeExponent", REQUIRED, |
| "optional_double: 1e18446744073709551616", "optional_double: inf"); |
| RunValidTextFormatTestWithExpected( |
| "DoubleFieldLargeNegativeExponentParsesAsZero", REQUIRED, |
| "optional_double: 1e-18446744073709551616", ""); |
| RunValidTextFormatTestWithExpected( |
| "NegDoubleFieldLargeNegativeExponentParsesAsNegZero", REQUIRED, |
| "optional_double: -1e-18446744073709551616", "optional_double: -0"); |
| |
| RunValidTextFormatTestWithExpected( |
| "FloatFieldLargeNegativeExponentParsesAsZero", REQUIRED, |
| "optional_float: 1e-50", ""); |
| RunValidTextFormatTestWithExpected( |
| "NegFloatFieldLargeNegativeExponentParsesAsNegZero", REQUIRED, |
| "optional_float: -1e-50", "optional_float: -0"); |
| |
| // String literals x {Strings, Bytes} |
| for (const auto& field_type : std::vector<std::string>{"String", "Bytes"}) { |
| const std::string field_name = |
| field_type == "String" ? "optional_string" : "optional_bytes"; |
| RunValidTextFormatTest( |
| absl::StrCat("StringLiteralConcat", field_type), REQUIRED, |
| absl::StrCat(field_name, ": 'first' \"second\"\n'third'")); |
| RunValidTextFormatTest( |
| absl::StrCat("StringLiteralBasicEscapes", field_type), REQUIRED, |
| absl::StrCat(field_name, ": '\\a\\b\\f\\n\\r\\t\\v\\?\\\\\\'\\\"'")); |
| RunValidTextFormatTest( |
| absl::StrCat("StringLiteralOctalEscapes", field_type), REQUIRED, |
| absl::StrCat(field_name, ": '\\341\\210\\264'")); |
| RunValidTextFormatTest(absl::StrCat("StringLiteralHexEscapes", field_type), |
| REQUIRED, |
| absl::StrCat(field_name, ": '\\xe1\\x88\\xb4'")); |
| RunValidTextFormatTest( |
| absl::StrCat("StringLiteralShortUnicodeEscape", field_type), |
| RECOMMENDED, absl::StrCat(field_name, ": '\\u1234'")); |
| RunValidTextFormatTest( |
| absl::StrCat("StringLiteralLongUnicodeEscapes", field_type), |
| RECOMMENDED, absl::StrCat(field_name, ": '\\U00001234\\U00010437'")); |
| // String literals don't include line feeds. |
| ExpectParseFailure(absl::StrCat("StringLiteralIncludesLF", field_type), |
| REQUIRED, |
| absl::StrCat(field_name, ": 'first line\nsecond line'")); |
| // Unicode escapes don't include code points that lie beyond the planes |
| // (> 0x10ffff). |
| ExpectParseFailure( |
| absl::StrCat("StringLiteralLongUnicodeEscapeTooLarge", field_type), |
| REQUIRED, absl::StrCat(field_name, ": '\\U00110000'")); |
| // Unicode escapes don't include surrogates. |
| ExpectParseFailure( |
| absl::StrCat("StringLiteralShortUnicodeEscapeSurrogatePair", |
| field_type), |
| RECOMMENDED, absl::StrCat(field_name, ": '\\ud801\\udc37'")); |
| ExpectParseFailure( |
| absl::StrCat("StringLiteralShortUnicodeEscapeSurrogateFirstOnly", |
| field_type), |
| RECOMMENDED, absl::StrCat(field_name, ": '\\ud800'")); |
| ExpectParseFailure( |
| absl::StrCat("StringLiteralShortUnicodeEscapeSurrogateSecondOnly", |
| field_type), |
| RECOMMENDED, absl::StrCat(field_name, ": '\\udc00'")); |
| ExpectParseFailure( |
| absl::StrCat("StringLiteralLongUnicodeEscapeSurrogateFirstOnly", |
| field_type), |
| RECOMMENDED, absl::StrCat(field_name, ": '\\U0000d800'")); |
| ExpectParseFailure( |
| absl::StrCat("StringLiteralLongUnicodeEscapeSurrogateSecondOnly", |
| field_type), |
| RECOMMENDED, absl::StrCat(field_name, ": '\\U0000dc00'")); |
| ExpectParseFailure( |
| absl::StrCat("StringLiteralLongUnicodeEscapeSurrogatePair", field_type), |
| RECOMMENDED, absl::StrCat(field_name, ": '\\U0000d801\\U00000dc37'")); |
| ExpectParseFailure( |
| absl::StrCat("StringLiteralUnicodeEscapeSurrogatePairLongShort", |
| field_type), |
| RECOMMENDED, absl::StrCat(field_name, ": '\\U0000d801\\udc37'")); |
| ExpectParseFailure( |
| absl::StrCat("StringLiteralUnicodeEscapeSurrogatePairShortLong", |
| field_type), |
| RECOMMENDED, absl::StrCat(field_name, ": '\\ud801\\U0000dc37'")); |
| |
| // The following method depend on the type of field, as strings have extra |
| // validation. |
| const auto test_method = |
| field_type == "String" |
| ? &TextFormatConformanceTestSuiteImpl::ExpectParseFailure |
| : &TextFormatConformanceTestSuiteImpl::RunValidTextFormatTest; |
| |
| // String fields reject invalid UTF-8 byte sequences; bytes fields don't. |
| (this->*test_method)(absl::StrCat(field_type, "FieldBadUTF8Octal"), |
| REQUIRED, absl::StrCat(field_name, ": '\\300'")); |
| (this->*test_method)(absl::StrCat(field_type, "FieldBadUTF8Hex"), REQUIRED, |
| absl::StrCat(field_name, ": '\\xc0'")); |
| } |
| |
| // Separators |
| for (const auto& test_case : std::vector<std::pair<std::string, std::string>>{ |
| {"string", "\"abc\""}, |
| {"bytes", "\"abc\""}, |
| {"int32", "123"}, |
| {"bool", "true"}, |
| {"double", "1.23"}, |
| {"fixed32", "0x123"}, |
| }) { |
| // Optional Field Separators |
| for (const auto& field_type : |
| std::vector<std::string>{"Single", "Repeated"}) { |
| std::string field_name, field_value; |
| if (field_type == "Single") { |
| field_name = absl::StrCat("optional_", test_case.first); |
| field_value = test_case.second; |
| } else { |
| field_name = absl::StrCat("repeated_", test_case.first); |
| field_value = absl::StrCat("[", test_case.second, "]"); |
| } |
| |
| RunValidTextFormatTest(absl::StrCat("FieldSeparatorCommaTopLevel", |
| field_type, "_", test_case.first), |
| REQUIRED, |
| absl::StrCat(field_name, ": ", field_value, ",")); |
| RunValidTextFormatTest(absl::StrCat("FieldSeparatorSemiTopLevelSingle", |
| field_type, "_", test_case.first), |
| REQUIRED, |
| absl::StrCat(field_name, ": ", field_value, ";")); |
| |
| ExpectParseFailure( |
| absl::StrCat("FieldSeparatorCommaTopLevelDuplicatesFails", field_type, |
| "_", test_case.first), |
| REQUIRED, absl::StrCat(field_name, ": ", field_value, ",,")); |
| ExpectParseFailure( |
| absl::StrCat("FieldSeparatorSemiTopLevelDuplicateFails", field_type, |
| "_", test_case.first), |
| REQUIRED, absl::StrCat(field_name, ": ", field_value, ";;")); |
| } |
| |
| // Required List Separators |
| RunValidTextFormatTest( |
| absl::StrCat("ListSeparator_", test_case.first), REQUIRED, |
| absl::StrCat("repeated_", test_case.first, ": [", test_case.second, ",", |
| test_case.second, "]")); |
| ExpectParseFailure( |
| absl::StrCat("ListSeparatorSemiFails_", test_case.first), REQUIRED, |
| absl::StrCat("repeated_", test_case.first, ": [", test_case.second, ";", |
| test_case.second, "]")); |
| // For string and bytes, if we skip the separator, the parser will treat |
| // the two values as a single value. |
| if (test_case.first == "string" || test_case.first == "bytes") { |
| RunValidTextFormatTest( |
| absl::StrCat("ListSeparatorMissingIsOneValue_", test_case.first), |
| REQUIRED, |
| absl::StrCat("repeated_", test_case.first, ": [", test_case.second, |
| " ", test_case.second, "]")); |
| } else { |
| ExpectParseFailure( |
| absl::StrCat("ListSeparatorMissingFails_", test_case.first), REQUIRED, |
| absl::StrCat("repeated_", test_case.first, ": [", test_case.second, |
| " ", test_case.second, "]")); |
| } |
| ExpectParseFailure( |
| absl::StrCat("ListSeparatorDuplicateFails_", test_case.first), REQUIRED, |
| absl::StrCat("repeated_", test_case.first, ": [", test_case.second, |
| ",,", test_case.second, "]")); |
| ExpectParseFailure( |
| absl::StrCat("ListSeparatorSingleTrailingFails_", test_case.first), |
| REQUIRED, |
| absl::StrCat("repeated_", test_case.first, ": [", test_case.second, |
| ",]")); |
| ExpectParseFailure( |
| absl::StrCat("ListSeparatorTwoValuesTrailingFails_", test_case.first), |
| REQUIRED, |
| absl::StrCat("repeated_", test_case.first, ": [", test_case.second, ",", |
| test_case.second, ",]")); |
| } |
| // The test message don't really have all types nested, so just check one |
| // data type for the nested field separator support |
| RunValidTextFormatTest("FieldSeparatorCommaNested", REQUIRED, |
| "optional_nested_message: { a: 123, }"); |
| RunValidTextFormatTest("FieldSeparatorSemiNested", REQUIRED, |
| "optional_nested_message: { a: 123; }"); |
| ExpectParseFailure("FieldSeparatorCommaNestedDuplicates", REQUIRED, |
| "optional_nested_message: { a: 123,, }"); |
| ExpectParseFailure("FieldSeparatorSemiNestedDuplicates", REQUIRED, |
| "optional_nested_message: { a: 123;; }"); |
| |
| // Unknown Fields |
| UnknownToTestAllTypes message; |
| // Unable to print unknown Fixed32/Fixed64 fields as if they are known. |
| // Fixed32/Fixed64 fields are not added in the tests. |
| message.set_optional_int32(123); |
| message.set_optional_string("hello"); |
| message.set_optional_bool(true); |
| RunValidUnknownTextFormatTest("ScalarUnknownFields", message); |
| |
| message.Clear(); |
| message.mutable_nested_message()->set_c(111); |
| RunValidUnknownTextFormatTest("MessageUnknownFields", message); |
| |
| message.Clear(); |
| message.mutable_optionalgroup()->set_a(321); |
| RunValidUnknownTextFormatTest("GroupUnknownFields", message); |
| |
| message.add_repeated_int32(1); |
| message.add_repeated_int32(2); |
| message.add_repeated_int32(3); |
| RunValidUnknownTextFormatTest("RepeatedUnknownFields", message); |
| |
| // Reserved field names |
| for (const auto& test_case : std::vector<std::pair<std::string, std::string>>{ |
| {"Boolean", "true"}, |
| {"Integer", "-123"}, |
| {"Float", "0.123"}, |
| {"Enum", "ENUM_VALUE"}, |
| {"String", "\"hello\""}, |
| {"Message", "{ a: 123 }"}, |
| {"MessageAngleBrackets", "< a: 123 >"}, |
| {"RepeatedInteger", "[-123, 456]"}, |
| {"RepeatedFloat", "[0.123, 1e-10] "}, |
| {"RepeatedString", R"pb(["hello", "world"])pb"}, |
| }) { |
| RunValidTextFormatTest(absl::StrCat("ReservedFieldName.", test_case.first), |
| REQUIRED, |
| absl::StrCat("reserved_field: ", test_case.second)); |
| // TODO: Add a test for reserved field numbers on 999999. |
| } |
| |
| // Map fields |
| MessageType prototype; |
| (*prototype.mutable_map_string_string())["c"] = "value"; |
| (*prototype.mutable_map_string_string())["b"] = "value"; |
| (*prototype.mutable_map_string_string())["a"] = "value"; |
| RunValidTextFormatTestWithMessage("AlphabeticallySortedMapStringKeys", |
| REQUIRED, |
| R"( |
| map_string_string { |
| key: "a" |
| value: "value" |
| } |
| map_string_string { |
| key: "b" |
| value: "value" |
| } |
| map_string_string { |
| key: "c" |
| value: "value" |
| } |
| )", |
| prototype); |
| |
| prototype.Clear(); |
| (*prototype.mutable_map_int32_int32())[3] = 0; |
| (*prototype.mutable_map_int32_int32())[2] = 0; |
| (*prototype.mutable_map_int32_int32())[1] = 0; |
| RunValidTextFormatTestWithMessage("AlphabeticallySortedMapIntKeys", REQUIRED, |
| R"( |
| map_int32_int32 { |
| key: 1 |
| value: 0 |
| } |
| map_int32_int32 { |
| key: 2 |
| value: 0 |
| } |
| map_int32_int32 { |
| key: 3 |
| value: 0 |
| } |
| )", |
| prototype); |
| |
| prototype.Clear(); |
| (*prototype.mutable_map_bool_bool())[true] = false; |
| (*prototype.mutable_map_bool_bool())[false] = false; |
| RunValidTextFormatTestWithMessage("AlphabeticallySortedMapBoolKeys", REQUIRED, |
| R"( |
| map_bool_bool { |
| key: false |
| value: false |
| } |
| map_bool_bool { |
| key: true |
| value: false |
| } |
| )", |
| prototype); |
| |
| prototype.Clear(); |
| ConformanceRequestSetting setting_map( |
| REQUIRED, conformance::TEXT_FORMAT, conformance::PROTOBUF, |
| conformance::TEXT_FORMAT_TEST, prototype, "DuplicateMapKey", R"( |
| map_string_nested_message { |
| key: "duplicate" |
| value: { a: 123 } |
| } |
| map_string_nested_message { |
| key: "duplicate" |
| value: { corecursive: {} } |
| } |
| )"); |
| // The last-specified value will be retained in a parsed map |
| suite_.RunValidInputTest(setting_map, R"( |
| map_string_nested_message { |
| key: "duplicate" |
| value: { corecursive: {} } |
| } |
| )"); |
| } |
| |
| template <typename MessageType> |
| void TextFormatConformanceTestSuiteImpl<MessageType>::RunAnyTests() { |
| // Any fields |
| RunValidTextFormatTest("AnyField", REQUIRED, |
| R"( |
| optional_any: { |
| [type.googleapis.com/protobuf_test_messages.proto3.TestAllTypesProto3] |
| { optional_int32: 12345 |
| } |
| } |
| )"); |
| RunValidTextFormatTest("AnyFieldWithRawBytes", REQUIRED, |
| R"( |
| optional_any: { |
| type_url: |
| "type.googleapis.com/protobuf_test_messages.proto3.TestAllTypesProto3" value: |
| "\b\271`" |
| } |
| )"); |
| ExpectParseFailure("AnyFieldWithInvalidType", REQUIRED, |
| R"( |
| optional_any: { |
| [type.googleapis.com/unknown] { |
| optional_int32: 12345 |
| } |
| } |
| )"); |
| } |
| |
| template <typename MessageType> |
| void TextFormatConformanceTestSuiteImpl< |
| MessageType>::RunTextFormatPerformanceTests() { |
| TestTextFormatPerformanceMergeMessageWithRepeatedField("Bool", |
| "repeated_bool: true"); |
| TestTextFormatPerformanceMergeMessageWithRepeatedField( |
| "Double", "repeated_double: 123"); |
| TestTextFormatPerformanceMergeMessageWithRepeatedField( |
| "Int32", "repeated_uint32: 123"); |
| TestTextFormatPerformanceMergeMessageWithRepeatedField( |
| "Int64", "repeated_uint64: 123"); |
| TestTextFormatPerformanceMergeMessageWithRepeatedField( |
| "String", R"(repeated_string: "foo")"); |
| TestTextFormatPerformanceMergeMessageWithRepeatedField( |
| "Bytes", R"(repeated_bytes: "foo")"); |
| } |
| |
| // This is currently considered valid input by some languages but not others |
| template <typename MessageType> |
| void TextFormatConformanceTestSuiteImpl<MessageType>:: |
| TestTextFormatPerformanceMergeMessageWithRepeatedField( |
| const std::string& test_type_name, const std::string& message_field) { |
| std::string recursive_message = |
| absl::StrCat("recursive_message { ", message_field, " }"); |
| |
| std::string input; |
| for (size_t i = 0; i < kPerformanceRepeatCount; i++) { |
| absl::StrAppend(&input, recursive_message); |
| } |
| |
| std::string expected = "recursive_message { "; |
| for (size_t i = 0; i < kPerformanceRepeatCount; i++) { |
| absl::StrAppend(&expected, message_field, " "); |
| } |
| absl::StrAppend(&expected, "}"); |
| |
| RunValidTextFormatTestWithExpected( |
| absl::StrCat("TestTextFormatPerformanceMergeMessageWithRepeatedField", |
| test_type_name), |
| RECOMMENDED, input, expected); |
| } |
| |
| template <typename MessageType> |
| void TextFormatConformanceTestSuiteImpl<MessageType>::RunOpenEnumTests() { |
| RunValidTextFormatTest("ClosedEnumFieldByNumber", REQUIRED, |
| R"( |
| optional_nested_enum: 1 |
| )"); |
| RunValidTextFormatTest("ClosedEnumFieldWithUnknownNumber", REQUIRED, |
| R"( |
| optional_nested_enum: 42 |
| )"); |
| } |
| |
| template <typename MessageType> |
| void TextFormatConformanceTestSuiteImpl<MessageType>::RunClosedEnumTests() { |
| RunValidTextFormatTest("ClosedEnumFieldByNumber", REQUIRED, |
| R"( |
| optional_nested_enum: 1 |
| )"); |
| ExpectParseFailure("ClosedEnumFieldWithUnknownNumber", REQUIRED, |
| R"( |
| optional_nested_enum: 42 |
| )"); |
| } |
| |
| } // namespace protobuf |
| } // namespace google |
