// 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 "binary_json_conformance_suite.h" #include #include #include #include #include #include #include #include #include #include "absl/log/absl_check.h" #include "absl/log/absl_log.h" #include "absl/log/die_if_null.h" #include "absl/status/status.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" #include "absl/strings/substitute.h" #include "conformance/conformance.pb.h" #include "conformance_test.h" #include "google/protobuf/editions/golden/test_messages_proto2_editions.pb.h" #include "google/protobuf/editions/golden/test_messages_proto3_editions.pb.h" #include "google/protobuf/endian.h" #include "google/protobuf/json/json.h" #include "google/protobuf/test_messages_proto2.pb.h" #include "google/protobuf/test_messages_proto2.pb.h" #include "google/protobuf/test_messages_proto3.pb.h" #include "google/protobuf/test_messages_proto3.pb.h" #include "google/protobuf/text_format.h" #include "google/protobuf/unknown_field_set.h" #include "google/protobuf/util/type_resolver_util.h" #include "google/protobuf/wire_format_lite.h" using conformance::ConformanceRequest; using conformance::ConformanceResponse; using conformance::WireFormat; using google::protobuf::Descriptor; using google::protobuf::FieldDescriptor; using google::protobuf::internal::WireFormatLite; using google::protobuf::internal::little_endian::FromHost; using google::protobuf::util::NewTypeResolverForDescriptorPool; using protobuf_test_messages::proto2::TestAllTypesProto2; using protobuf_test_messages::proto3::TestAllTypesProto3; using TestAllTypesProto2Editions = protobuf_test_messages::editions::proto2::TestAllTypesProto2; using TestAllTypesProto3Editions = protobuf_test_messages::editions::proto3::TestAllTypesProto3; namespace { constexpr absl::string_view kTypeUrlPrefix = "type.googleapis.com"; // The number of repetitions to use for performance tests. // Corresponds approx to 500KB wireformat bytes. const size_t kPerformanceRepeatCount = 50000; std::string GetTypeUrl(const Descriptor* message) { return absl::StrCat(kTypeUrlPrefix, "/", message->full_name()); } /* Routines for building arbitrary protos *************************************/ // We would use CodedOutputStream except that we want more freedom to build // arbitrary protos (even invalid ones). // The maximum number of bytes that it takes to encode a 64-bit varint. #define VARINT_MAX_LEN 10 size_t vencode64(uint64_t val, int over_encoded_bytes, char* buf) { if (val == 0) { buf[0] = 0; return 1; } size_t i = 0; while (val) { uint8_t byte = val & 0x7fU; val >>= 7; if (val || over_encoded_bytes) byte |= 0x80U; buf[i++] = byte; } while (over_encoded_bytes--) { assert(i < 10); uint8_t byte = over_encoded_bytes ? 0x80 : 0; buf[i++] = byte; } return i; } std::string varint(uint64_t x) { char buf[VARINT_MAX_LEN]; size_t len = vencode64(x, 0, buf); return std::string(buf, len); } // Encodes a varint that is |extra| bytes longer than it needs to be, but still // valid. std::string longvarint(uint64_t x, int extra) { char buf[VARINT_MAX_LEN]; size_t len = vencode64(x, extra, buf); return std::string(buf, len); } std::string fixed32(void* data) { uint32_t data_le; std::memcpy(&data_le, data, 4); data_le = FromHost(data_le); return std::string(reinterpret_cast(&data_le), 4); } std::string fixed64(void* data) { uint64_t data_le; std::memcpy(&data_le, data, 8); data_le = FromHost(data_le); return std::string(reinterpret_cast(&data_le), 8); } std::string delim(const std::string& buf) { return absl::StrCat(varint(buf.size()), buf); } std::string u32(uint32_t u32) { return fixed32(&u32); } std::string u64(uint64_t u64) { return fixed64(&u64); } std::string flt(float f) { return fixed32(&f); } std::string dbl(double d) { return fixed64(&d); } std::string zz32(int32_t x) { return varint(WireFormatLite::ZigZagEncode32(x)); } std::string zz64(int64_t x) { return varint(WireFormatLite::ZigZagEncode64(x)); } std::string tag(uint32_t fieldnum, char wire_type) { return varint((fieldnum << 3) | wire_type); } std::string tag(int fieldnum, char wire_type) { return tag(static_cast(fieldnum), wire_type); } std::string GetDefaultValue(FieldDescriptor::Type type) { switch (type) { case FieldDescriptor::TYPE_INT32: case FieldDescriptor::TYPE_INT64: case FieldDescriptor::TYPE_UINT32: case FieldDescriptor::TYPE_UINT64: case FieldDescriptor::TYPE_ENUM: case FieldDescriptor::TYPE_BOOL: return varint(0); case FieldDescriptor::TYPE_SINT32: return zz32(0); case FieldDescriptor::TYPE_SINT64: return zz64(0); case FieldDescriptor::TYPE_FIXED32: case FieldDescriptor::TYPE_SFIXED32: return u32(0); case FieldDescriptor::TYPE_FIXED64: case FieldDescriptor::TYPE_SFIXED64: return u64(0); case FieldDescriptor::TYPE_FLOAT: return flt(0); case FieldDescriptor::TYPE_DOUBLE: return dbl(0); case FieldDescriptor::TYPE_STRING: case FieldDescriptor::TYPE_BYTES: case FieldDescriptor::TYPE_MESSAGE: return delim(""); default: return ""; } return ""; } std::string GetNonDefaultValue(FieldDescriptor::Type type) { switch (type) { case FieldDescriptor::TYPE_INT32: case FieldDescriptor::TYPE_INT64: case FieldDescriptor::TYPE_UINT32: case FieldDescriptor::TYPE_UINT64: case FieldDescriptor::TYPE_ENUM: case FieldDescriptor::TYPE_BOOL: return varint(1); case FieldDescriptor::TYPE_SINT32: return zz32(1); case FieldDescriptor::TYPE_SINT64: return zz64(1); case FieldDescriptor::TYPE_FIXED32: case FieldDescriptor::TYPE_SFIXED32: return u32(1); case FieldDescriptor::TYPE_FIXED64: case FieldDescriptor::TYPE_SFIXED64: return u64(1); case FieldDescriptor::TYPE_FLOAT: return flt(1); case FieldDescriptor::TYPE_DOUBLE: return dbl(1); case FieldDescriptor::TYPE_STRING: case FieldDescriptor::TYPE_BYTES: return delim("a"); case FieldDescriptor::TYPE_MESSAGE: return delim( absl::StrCat(tag(1, WireFormatLite::WIRETYPE_VARINT), varint(1234))); default: return ""; } return ""; } #define UNKNOWN_FIELD 666 std::string UpperCase(std::string str) { for (size_t i = 0; i < str.size(); i++) { str[i] = toupper(str[i]); } return str; } bool IsProto3Default(FieldDescriptor::Type type, const std::string& binary_data) { switch (type) { case FieldDescriptor::TYPE_DOUBLE: return binary_data == dbl(0); case FieldDescriptor::TYPE_FLOAT: return binary_data == flt(0); case FieldDescriptor::TYPE_BOOL: case FieldDescriptor::TYPE_INT64: case FieldDescriptor::TYPE_UINT64: case FieldDescriptor::TYPE_INT32: case FieldDescriptor::TYPE_UINT32: case FieldDescriptor::TYPE_SINT32: case FieldDescriptor::TYPE_SINT64: case FieldDescriptor::TYPE_ENUM: return binary_data == varint(0); case FieldDescriptor::TYPE_FIXED64: case FieldDescriptor::TYPE_SFIXED64: return binary_data == u64(0); case FieldDescriptor::TYPE_FIXED32: case FieldDescriptor::TYPE_SFIXED32: return binary_data == u32(0); case FieldDescriptor::TYPE_STRING: case FieldDescriptor::TYPE_BYTES: return binary_data == delim(""); default: return false; } } } // anonymous namespace namespace google { namespace protobuf { bool BinaryAndJsonConformanceSuite::ParseJsonResponse( const ConformanceResponse& response, Message* test_message) { std::string binary_protobuf; absl::Status status = json::JsonToBinaryString(type_resolver_.get(), type_url_, response.json_payload(), &binary_protobuf); if (!status.ok()) { return false; } if (!test_message->ParseFromString(binary_protobuf)) { ABSL_LOG(FATAL) << "INTERNAL ERROR: internal JSON->protobuf transcode " << "yielded unparseable proto."; return false; } return true; } bool BinaryAndJsonConformanceSuite::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(); switch (response.result_case()) { case ConformanceResponse::kProtobufPayload: { if (requested_output != conformance::PROTOBUF) { ReportFailure(test_name, level, request, response, absl::StrCat("Test was asked for ", WireFormatToString(requested_output), " output but provided PROTOBUF instead.")); return false; } if (!test_message->ParseFromString(response.protobuf_payload())) { ReportFailure(test_name, level, request, response, "Protobuf output we received from test was unparseable."); return false; } break; } case ConformanceResponse::kJsonPayload: { if (requested_output != conformance::JSON) { ReportFailure(test_name, level, request, response, absl::StrCat("Test was asked for ", WireFormatToString(requested_output), " output but provided JSON instead.")); return false; } if (!ParseJsonResponse(response, test_message)) { ReportFailure(test_name, level, request, response, "JSON output we received from test was unparseable."); return false; } break; } default: ABSL_LOG(FATAL) << test_name << ": unknown payload type: " << response.result_case() << ", response: " << response; } return true; } void BinaryAndJsonConformanceSuite::RunSuiteImpl() { type_resolver_.reset(NewTypeResolverForDescriptorPool( kTypeUrlPrefix, DescriptorPool::generated_pool())); BinaryAndJsonConformanceSuiteImpl( this, /*run_proto3_tests=*/true); BinaryAndJsonConformanceSuiteImpl( this, /*run_proto3_tests=*/false); if (maximum_edition_ >= Edition::EDITION_2023) { BinaryAndJsonConformanceSuiteImpl( this, /*run_proto3_tests=*/true); BinaryAndJsonConformanceSuiteImpl( this, /*run_proto3_tests=*/false); } } template void BinaryAndJsonConformanceSuiteImpl:: ExpectParseFailureForProtoWithProtoVersion(const std::string& proto, const std::string& test_name, ConformanceLevel level) { 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::PROTOBUF, conformance::PROTOBUF, conformance::BINARY_TEST, prototype, test_name, proto); const ConformanceRequest& request = setting.GetRequest(); ConformanceResponse response; std::string effective_test_name = absl::StrCat(setting.ConformanceLevelToString(level), ".", setting.GetSyntaxIdentifier(), ".ProtobufInput.", test_name); suite_.RunTest(effective_test_name, request, &response); if (response.result_case() == ConformanceResponse::kParseError) { suite_.ReportSuccess(effective_test_name); } else if (response.result_case() == ConformanceResponse::kSkipped) { suite_.ReportSkip(effective_test_name, request, response); } else { suite_.ReportFailure(effective_test_name, level, request, response, "Should have failed to parse, but didn't."); } } // Expect that this precise protobuf will cause a parse error. template void BinaryAndJsonConformanceSuiteImpl::ExpectParseFailureForProto( const std::string& proto, const std::string& test_name, ConformanceLevel level) { ExpectParseFailureForProtoWithProtoVersion(proto, test_name, level); } // Expect that this protobuf will cause a parse error, even if it is followed // by valid protobuf data. We can try running this twice: once with this // data verbatim and once with this data followed by some valid data. // // TODO: implement the second of these. template void BinaryAndJsonConformanceSuiteImpl< MessageType>::ExpectHardParseFailureForProto(const std::string& proto, const std::string& test_name, ConformanceLevel level) { return ExpectParseFailureForProto(proto, test_name, level); } template void BinaryAndJsonConformanceSuiteImpl::RunValidJsonTest( const std::string& test_name, ConformanceLevel level, const std::string& input_json, const std::string& equivalent_text_format) { MessageType prototype; RunValidJsonTestWithMessage(test_name, level, input_json, equivalent_text_format, prototype); } template void BinaryAndJsonConformanceSuiteImpl:: RunValidJsonTestWithMessage(const std::string& test_name, ConformanceLevel level, const std::string& input_json, const std::string& equivalent_text_format, const Message& prototype) { ConformanceRequestSetting setting1( level, conformance::JSON, conformance::PROTOBUF, conformance::JSON_TEST, prototype, test_name, input_json); suite_.RunValidInputTest(setting1, equivalent_text_format); ConformanceRequestSetting setting2(level, conformance::JSON, conformance::JSON, conformance::JSON_TEST, prototype, test_name, input_json); suite_.RunValidInputTest(setting2, equivalent_text_format); } template void BinaryAndJsonConformanceSuiteImpl:: RunValidJsonTestWithProtobufInput( const std::string& test_name, ConformanceLevel level, const MessageType& input, const std::string& equivalent_text_format) { ConformanceRequestSetting setting( level, conformance::PROTOBUF, conformance::JSON, conformance::JSON_TEST, input, test_name, input.SerializeAsString()); suite_.RunValidInputTest(setting, equivalent_text_format); } template void BinaryAndJsonConformanceSuiteImpl:: RunValidJsonIgnoreUnknownTest(const std::string& test_name, ConformanceLevel level, const std::string& input_json, const std::string& equivalent_text_format) { MessageType prototype; ConformanceRequestSetting setting( level, conformance::JSON, conformance::PROTOBUF, conformance::JSON_IGNORE_UNKNOWN_PARSING_TEST, prototype, test_name, input_json); suite_.RunValidInputTest(setting, equivalent_text_format); } template void BinaryAndJsonConformanceSuiteImpl::RunValidProtobufTest( const std::string& test_name, ConformanceLevel level, const std::string& input_protobuf, const std::string& equivalent_text_format) { MessageType prototype; ConformanceRequestSetting binary_to_binary( level, conformance::PROTOBUF, conformance::PROTOBUF, conformance::BINARY_TEST, prototype, test_name, input_protobuf); suite_.RunValidInputTest(binary_to_binary, equivalent_text_format); ConformanceRequestSetting binary_to_json( level, conformance::PROTOBUF, conformance::JSON, conformance::BINARY_TEST, prototype, test_name, input_protobuf); suite_.RunValidInputTest(binary_to_json, equivalent_text_format); } template void BinaryAndJsonConformanceSuiteImpl::RunValidBinaryProtobufTest( const std::string& test_name, ConformanceLevel level, const std::string& input_protobuf) { RunValidBinaryProtobufTest(test_name, level, input_protobuf, input_protobuf); } template void BinaryAndJsonConformanceSuiteImpl::RunValidBinaryProtobufTest( const std::string& test_name, ConformanceLevel level, const std::string& input_protobuf, const std::string& expected_protobuf) { MessageType prototype; ConformanceRequestSetting setting( level, conformance::PROTOBUF, conformance::PROTOBUF, conformance::BINARY_TEST, prototype, test_name, input_protobuf); suite_.RunValidBinaryInputTest(setting, expected_protobuf, true); } template void BinaryAndJsonConformanceSuiteImpl:: RunBinaryPerformanceMergeMessageWithField(const std::string& test_name, const std::string& field_proto) { std::string message_tag = tag(27, WireFormatLite::WIRETYPE_LENGTH_DELIMITED); std::string message_proto = absl::StrCat(message_tag, delim(field_proto)); std::string proto; for (size_t i = 0; i < kPerformanceRepeatCount; i++) { proto.append(message_proto); } std::string multiple_repeated_field_proto; for (size_t i = 0; i < kPerformanceRepeatCount; i++) { multiple_repeated_field_proto.append(field_proto); } std::string expected_proto = absl::StrCat(message_tag, delim(multiple_repeated_field_proto)); RunValidBinaryProtobufTest(test_name, RECOMMENDED, proto, expected_proto); } template void BinaryAndJsonConformanceSuiteImpl:: RunValidProtobufTestWithMessage(const std::string& test_name, ConformanceLevel level, const Message* input, const std::string& equivalent_text_format) { RunValidProtobufTest(test_name, level, input->SerializeAsString(), equivalent_text_format); } // According to proto JSON specification, JSON serializers follow more strict // rules than parsers (e.g., a serializer must serialize int32 values as JSON // numbers while the parser is allowed to accept them as JSON strings). This // method allows strict checking on a proto JSON serializer by inspecting template // the JSON output directly. void BinaryAndJsonConformanceSuiteImpl< MessageType>::RunValidJsonTestWithValidator(const std::string& test_name, ConformanceLevel level, const std::string& input_json, const Validator& validator) { MessageType prototype; ConformanceRequestSetting setting(level, conformance::JSON, conformance::JSON, conformance::JSON_TEST, prototype, test_name, input_json); const ConformanceRequest& request = setting.GetRequest(); ConformanceResponse response; std::string effective_test_name = absl::StrCat( setting.ConformanceLevelToString(level), ".", setting.GetSyntaxIdentifier(), ".JsonInput.", test_name, ".Validator"); suite_.RunTest(effective_test_name, request, &response); if (response.result_case() == ConformanceResponse::kSkipped) { suite_.ReportSkip(effective_test_name, request, response); return; } if (response.result_case() != ConformanceResponse::kJsonPayload) { suite_.ReportFailure(effective_test_name, level, request, response, absl::StrCat("Expected JSON payload but got type ", response.result_case())); return; } Json::Reader reader; Json::Value value; if (!reader.parse(response.json_payload(), value)) { suite_.ReportFailure( effective_test_name, level, request, response, absl::StrCat("JSON payload cannot be parsed as valid JSON: ", reader.getFormattedErrorMessages())); return; } if (!validator(value)) { suite_.ReportFailure(effective_test_name, level, request, response, "JSON payload validation failed."); return; } suite_.ReportSuccess(effective_test_name); } template void BinaryAndJsonConformanceSuiteImpl::ExpectParseFailureForJson( const std::string& test_name, ConformanceLevel level, const std::string& input_json) { 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::JSON, conformance::JSON, conformance::JSON_TEST, prototype, test_name, input_json); const ConformanceRequest& request = setting.GetRequest(); ConformanceResponse response; std::string effective_test_name = absl::StrCat(setting.ConformanceLevelToString(level), ".", SyntaxIdentifier(), ".JsonInput.", test_name); suite_.RunTest(effective_test_name, request, &response); if (response.result_case() == ConformanceResponse::kParseError) { suite_.ReportSuccess(effective_test_name); } else if (response.result_case() == ConformanceResponse::kSkipped) { suite_.ReportSkip(effective_test_name, request, response); } else { suite_.ReportFailure(effective_test_name, level, request, response, "Should have failed to parse, but didn't."); } } template void BinaryAndJsonConformanceSuiteImpl:: ExpectSerializeFailureForJson(const std::string& test_name, ConformanceLevel level, const std::string& text_format) { MessageType payload_message; ABSL_CHECK(TextFormat::ParseFromString(text_format, &payload_message)) << "Failed to parse: " << text_format; MessageType prototype; ConformanceRequestSetting setting( level, conformance::PROTOBUF, conformance::JSON, conformance::JSON_TEST, prototype, test_name, payload_message.SerializeAsString()); const ConformanceRequest& request = setting.GetRequest(); ConformanceResponse response; std::string effective_test_name = absl::StrCat(setting.ConformanceLevelToString(level), ".", SyntaxIdentifier(), ".", test_name, ".JsonOutput"); suite_.RunTest(effective_test_name, request, &response); if (response.result_case() == ConformanceResponse::kSerializeError) { suite_.ReportSuccess(effective_test_name); } else if (response.result_case() == ConformanceResponse::kSkipped) { suite_.ReportSkip(effective_test_name, request, response); } else { suite_.ReportFailure(effective_test_name, level, request, response, "Should have failed to serialize, but didn't."); } } template void BinaryAndJsonConformanceSuiteImpl::TestPrematureEOFForType( FieldDescriptor::Type type) { // Incomplete values for each wire type. static constexpr absl::string_view incompletes[6] = { "\x80", // VARINT "abcdefg", // 64BIT "\x80", // DELIMITED (partial length) "", // START_GROUP (no value required) "", // END_GROUP (no value required) "abc" // 32BIT }; const FieldDescriptor* field = GetFieldForType(type, false); const FieldDescriptor* rep_field = GetFieldForType(type, true); WireFormatLite::WireType wire_type = WireFormatLite::WireTypeForFieldType( static_cast(type)); absl::string_view incomplete = incompletes[wire_type]; const std::string type_name = UpperCase(absl::StrCat(".", FieldDescriptor::TypeName(type))); ExpectParseFailureForProto( tag(field->number(), wire_type), absl::StrCat("PrematureEofBeforeKnownNonRepeatedValue", type_name), REQUIRED); ExpectParseFailureForProto( tag(rep_field->number(), wire_type), absl::StrCat("PrematureEofBeforeKnownRepeatedValue", type_name), REQUIRED); ExpectParseFailureForProto( tag(UNKNOWN_FIELD, wire_type), absl::StrCat("PrematureEofBeforeUnknownValue", type_name), REQUIRED); ExpectParseFailureForProto( absl::StrCat(tag(field->number(), wire_type), incomplete), absl::StrCat("PrematureEofInsideKnownNonRepeatedValue", type_name), REQUIRED); ExpectParseFailureForProto( absl::StrCat(tag(rep_field->number(), wire_type), incomplete), absl::StrCat("PrematureEofInsideKnownRepeatedValue", type_name), REQUIRED); ExpectParseFailureForProto( absl::StrCat(tag(UNKNOWN_FIELD, wire_type), incomplete), absl::StrCat("PrematureEofInsideUnknownValue", type_name), REQUIRED); if (wire_type == WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { ExpectParseFailureForProto( absl::StrCat(tag(field->number(), wire_type), varint(1)), absl::StrCat("PrematureEofInDelimitedDataForKnownNonRepeatedValue", type_name), REQUIRED); ExpectParseFailureForProto( absl::StrCat(tag(rep_field->number(), wire_type), varint(1)), absl::StrCat("PrematureEofInDelimitedDataForKnownRepeatedValue", type_name), REQUIRED); // EOF in the middle of delimited data for unknown value. ExpectParseFailureForProto( absl::StrCat(tag(UNKNOWN_FIELD, wire_type), varint(1)), absl::StrCat("PrematureEofInDelimitedDataForUnknownValue", type_name), REQUIRED); if (type == FieldDescriptor::TYPE_MESSAGE) { // Submessage ends in the middle of a value. std::string incomplete_submsg = absl::StrCat( tag(WireFormatLite::TYPE_INT32, WireFormatLite::WIRETYPE_VARINT), incompletes[WireFormatLite::WIRETYPE_VARINT]); ExpectHardParseFailureForProto( absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), varint(incomplete_submsg.size()), incomplete_submsg), absl::StrCat("PrematureEofInSubmessageValue", type_name), REQUIRED); } } else if (type != FieldDescriptor::TYPE_GROUP) { // Non-delimited, non-group: eligible for packing. // Packed region ends in the middle of a value. ExpectHardParseFailureForProto( absl::StrCat( tag(rep_field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), varint(incomplete.size()), incomplete), absl::StrCat("PrematureEofInPackedFieldValue", type_name), REQUIRED); // EOF in the middle of packed region. ExpectParseFailureForProto( absl::StrCat( tag(rep_field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), varint(1)), absl::StrCat("PrematureEofInPackedField", type_name), REQUIRED); } } template void BinaryAndJsonConformanceSuiteImpl::TestValidDataForType( FieldDescriptor::Type type, std::vector> values) { const std::string type_name = UpperCase(absl::StrCat(".", FieldDescriptor::TypeName(type))); WireFormatLite::WireType wire_type = WireFormatLite::WireTypeForFieldType( static_cast(type)); const FieldDescriptor* field = GetFieldForType(type, false); const FieldDescriptor* rep_field = GetFieldForType(type, true); // Test singular data for singular fields. for (size_t i = 0; i < values.size(); i++) { std::string proto = absl::StrCat(tag(field->number(), wire_type), values[i].first); // In proto3, default primitive fields should not be encoded. std::string expected_proto = run_proto3_tests_ && IsProto3Default(field->type(), values[i].second) ? "" : absl::StrCat(tag(field->number(), wire_type), values[i].second); MessageType test_message; test_message.MergeFromString(expected_proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest( absl::StrCat("ValidDataScalar", type_name, "[", i, "]"), REQUIRED, proto, text); RunValidBinaryProtobufTest( absl::StrCat("ValidDataScalarBinary", type_name, "[", i, "]"), RECOMMENDED, proto, expected_proto); } // Test repeated data for singular fields. // For scalar message fields, repeated values are merged, which is tested // separately. if (type != FieldDescriptor::TYPE_MESSAGE) { std::string proto; for (size_t i = 0; i < values.size(); i++) { proto += absl::StrCat(tag(field->number(), wire_type), values[i].first); } std::string expected_proto = absl::StrCat(tag(field->number(), wire_type), values.back().second); MessageType test_message; test_message.MergeFromString(expected_proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest(absl::StrCat("RepeatedScalarSelectsLast", type_name), REQUIRED, proto, text); } // Test repeated fields. if (FieldDescriptor::IsTypePackable(type)) { const FieldDescriptor* packed_field = GetFieldForType(type, true, Packed::kTrue); const FieldDescriptor* unpacked_field = GetFieldForType(type, true, Packed::kFalse); std::string default_proto_packed; std::string default_proto_unpacked; std::string default_proto_packed_expected; std::string default_proto_unpacked_expected; std::string packed_proto_packed; std::string packed_proto_unpacked; std::string packed_proto_expected; std::string unpacked_proto_packed; std::string unpacked_proto_unpacked; std::string unpacked_proto_expected; for (size_t i = 0; i < values.size(); i++) { default_proto_unpacked += absl::StrCat(tag(rep_field->number(), wire_type), values[i].first); default_proto_unpacked_expected += absl::StrCat(tag(rep_field->number(), wire_type), values[i].second); default_proto_packed += values[i].first; default_proto_packed_expected += values[i].second; packed_proto_unpacked += absl::StrCat(tag(packed_field->number(), wire_type), values[i].first); packed_proto_packed += values[i].first; packed_proto_expected += values[i].second; unpacked_proto_unpacked += absl::StrCat( tag(unpacked_field->number(), wire_type), values[i].first); unpacked_proto_packed += values[i].first; unpacked_proto_expected += absl::StrCat( tag(unpacked_field->number(), wire_type), values[i].second); } default_proto_packed = absl::StrCat( tag(rep_field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(default_proto_packed)); default_proto_packed_expected = absl::StrCat( tag(rep_field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(default_proto_packed_expected)); packed_proto_packed = absl::StrCat( tag(packed_field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(packed_proto_packed)); packed_proto_expected = absl::StrCat( tag(packed_field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(packed_proto_expected)); unpacked_proto_packed = absl::StrCat(tag(unpacked_field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(unpacked_proto_packed)); MessageType test_message; test_message.MergeFromString(default_proto_packed_expected); std::string text; TextFormat::PrintToString(test_message, &text); // Ensures both packed and unpacked data can be parsed. RunValidProtobufTest( absl::StrCat("ValidDataRepeated", type_name, ".UnpackedInput"), REQUIRED, default_proto_unpacked, text); RunValidProtobufTest( absl::StrCat("ValidDataRepeated", type_name, ".PackedInput"), REQUIRED, default_proto_packed, text); // proto2 should encode as unpacked by default and proto3 should encode as // packed by default. std::string expected_proto = rep_field->is_packed() ? default_proto_packed_expected : default_proto_unpacked_expected; RunValidBinaryProtobufTest(absl::StrCat("ValidDataRepeated", type_name, ".UnpackedInput.DefaultOutput"), RECOMMENDED, default_proto_unpacked, expected_proto); RunValidBinaryProtobufTest(absl::StrCat("ValidDataRepeated", type_name, ".PackedInput.DefaultOutput"), RECOMMENDED, default_proto_packed, expected_proto); RunValidBinaryProtobufTest(absl::StrCat("ValidDataRepeated", type_name, ".UnpackedInput.PackedOutput"), RECOMMENDED, packed_proto_unpacked, packed_proto_expected); RunValidBinaryProtobufTest(absl::StrCat("ValidDataRepeated", type_name, ".PackedInput.PackedOutput"), RECOMMENDED, packed_proto_packed, packed_proto_expected); RunValidBinaryProtobufTest(absl::StrCat("ValidDataRepeated", type_name, ".UnpackedInput.UnpackedOutput"), RECOMMENDED, unpacked_proto_unpacked, unpacked_proto_expected); RunValidBinaryProtobufTest(absl::StrCat("ValidDataRepeated", type_name, ".PackedInput.UnpackedOutput"), RECOMMENDED, unpacked_proto_packed, unpacked_proto_expected); } else { std::string proto; std::string expected_proto; for (size_t i = 0; i < values.size(); i++) { proto += absl::StrCat(tag(rep_field->number(), wire_type), values[i].first); expected_proto += absl::StrCat(tag(rep_field->number(), wire_type), values[i].second); } MessageType test_message; test_message.MergeFromString(expected_proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest(absl::StrCat("ValidDataRepeated", type_name), REQUIRED, proto, text); } } template void BinaryAndJsonConformanceSuiteImpl< MessageType>::TestValidDataForRepeatedScalarMessage() { std::vector values = { delim(absl::StrCat( tag(2, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat( tag(1, WireFormatLite::WIRETYPE_VARINT), varint(1234), tag(2, WireFormatLite::WIRETYPE_VARINT), varint(1234), tag(31, WireFormatLite::WIRETYPE_VARINT), varint(1234))))), delim(absl::StrCat( tag(2, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat( tag(1, WireFormatLite::WIRETYPE_VARINT), varint(4321), tag(3, WireFormatLite::WIRETYPE_VARINT), varint(4321), tag(31, WireFormatLite::WIRETYPE_VARINT), varint(4321))))), }; const std::string expected = R"({ corecursive: { optional_int32: 4321, optional_int64: 1234, optional_uint32: 4321, repeated_int32: [1234, 4321], } })"; std::string proto; const FieldDescriptor* field = GetFieldForType(FieldDescriptor::TYPE_MESSAGE, false); for (size_t i = 0; i < values.size(); i++) { proto += absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), values[i]); } RunValidProtobufTest("RepeatedScalarMessageMerge", REQUIRED, proto, absl::StrCat(field->name(), ": ", expected)); } template void BinaryAndJsonConformanceSuiteImpl::TestValidDataForMapType( FieldDescriptor::Type key_type, FieldDescriptor::Type value_type) { const std::string key_type_name = UpperCase(absl::StrCat(".", FieldDescriptor::TypeName(key_type))); const std::string value_type_name = UpperCase(absl::StrCat(".", FieldDescriptor::TypeName(value_type))); WireFormatLite::WireType key_wire_type = WireFormatLite::WireTypeForFieldType( static_cast(key_type)); WireFormatLite::WireType value_wire_type = WireFormatLite::WireTypeForFieldType( static_cast(value_type)); std::string key1_data = absl::StrCat(tag(1, key_wire_type), GetDefaultValue(key_type)); std::string value1_data = absl::StrCat(tag(2, value_wire_type), GetDefaultValue(value_type)); std::string key2_data = absl::StrCat(tag(1, key_wire_type), GetNonDefaultValue(key_type)); std::string value2_data = absl::StrCat(tag(2, value_wire_type), GetNonDefaultValue(value_type)); const FieldDescriptor* field = GetFieldForMapType(key_type, value_type); { // Tests map with default key and value. std::string proto = absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(key1_data, value1_data))); MessageType test_message; test_message.MergeFromString(proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest(absl::StrCat("ValidDataMap", key_type_name, value_type_name, ".Default"), REQUIRED, proto, text); } { // Tests map with missing default key and value. std::string proto = absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim("")); MessageType test_message; test_message.MergeFromString(proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest(absl::StrCat("ValidDataMap", key_type_name, value_type_name, ".MissingDefault"), REQUIRED, proto, text); } { // Tests map with non-default key and value. std::string proto = absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(key2_data, value2_data))); MessageType test_message; test_message.MergeFromString(proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest(absl::StrCat("ValidDataMap", key_type_name, value_type_name, ".NonDefault"), REQUIRED, proto, text); } { // Tests map with unordered key and value. std::string proto = absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(value2_data, key2_data))); MessageType test_message; test_message.MergeFromString(proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest(absl::StrCat("ValidDataMap", key_type_name, value_type_name, ".Unordered"), REQUIRED, proto, text); } { // Tests map with duplicate key. std::string proto1 = absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(key2_data, value1_data))); std::string proto2 = absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(key2_data, value2_data))); std::string proto = absl::StrCat(proto1, proto2); MessageType test_message; test_message.MergeFromString(proto2); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest(absl::StrCat("ValidDataMap", key_type_name, value_type_name, ".DuplicateKey"), REQUIRED, proto, text); } { // Tests map with duplicate key in map entry. std::string proto = absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(key1_data, key2_data, value2_data))); MessageType test_message; test_message.MergeFromString(proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest( absl::StrCat("ValidDataMap", key_type_name, value_type_name, ".DuplicateKeyInMapEntry"), REQUIRED, proto, text); } { // Tests map with duplicate value in map entry. std::string proto = absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(key2_data, value1_data, value2_data))); MessageType test_message; test_message.MergeFromString(proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest( absl::StrCat("ValidDataMap", key_type_name, value_type_name, ".DuplicateValueInMapEntry"), REQUIRED, proto, text); } } template void BinaryAndJsonConformanceSuiteImpl< MessageType>::TestOverwriteMessageValueMap() { std::string key_data = absl::StrCat( tag(1, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim("")); std::string field1_data = absl::StrCat(tag(1, WireFormatLite::WIRETYPE_VARINT), varint(1)); std::string field2_data = absl::StrCat(tag(2, WireFormatLite::WIRETYPE_VARINT), varint(1)); std::string field31_data = absl::StrCat(tag(31, WireFormatLite::WIRETYPE_VARINT), varint(1)); std::string submsg1_data = delim(absl::StrCat(field1_data, field31_data)); std::string submsg2_data = delim(absl::StrCat(field2_data, field31_data)); std::string value1_data = absl::StrCat( tag(2, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(tag(2, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), submsg1_data))); std::string value2_data = absl::StrCat( tag(2, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(tag(2, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), submsg2_data))); const FieldDescriptor* field = GetFieldForMapType( FieldDescriptor::TYPE_STRING, FieldDescriptor::TYPE_MESSAGE); std::string proto1 = absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(key_data, value1_data))); std::string proto2 = absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(key_data, value2_data))); std::string proto = absl::StrCat(proto1, proto2); MessageType test_message; test_message.MergeFromString(proto2); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest("ValidDataMap.STRING.MESSAGE.MergeValue", REQUIRED, proto, text); } template void BinaryAndJsonConformanceSuiteImpl::TestValidDataForOneofType( FieldDescriptor::Type type) { const std::string type_name = UpperCase(absl::StrCat(".", FieldDescriptor::TypeName(type))); WireFormatLite::WireType wire_type = WireFormatLite::WireTypeForFieldType( static_cast(type)); const FieldDescriptor* field = GetFieldForOneofType(type); const std::string default_value = absl::StrCat(tag(field->number(), wire_type), GetDefaultValue(type)); const std::string non_default_value = absl::StrCat(tag(field->number(), wire_type), GetNonDefaultValue(type)); { // Tests oneof with default value. const std::string proto = default_value; MessageType test_message; test_message.MergeFromString(proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest( absl::StrCat("ValidDataOneof", type_name, ".DefaultValue"), REQUIRED, proto, text); RunValidBinaryProtobufTest( absl::StrCat("ValidDataOneofBinary", type_name, ".DefaultValue"), RECOMMENDED, proto, proto); } { // Tests oneof with non-default value. const std::string proto = non_default_value; MessageType test_message; test_message.MergeFromString(proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest( absl::StrCat("ValidDataOneof", type_name, ".NonDefaultValue"), REQUIRED, proto, text); RunValidBinaryProtobufTest( absl::StrCat("ValidDataOneofBinary", type_name, ".NonDefaultValue"), RECOMMENDED, proto, proto); } { // Tests oneof with multiple values of the same field. const std::string proto = absl::StrCat(default_value, non_default_value); const std::string expected_proto = non_default_value; MessageType test_message; test_message.MergeFromString(expected_proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest(absl::StrCat("ValidDataOneof", type_name, ".MultipleValuesForSameField"), REQUIRED, proto, text); RunValidBinaryProtobufTest(absl::StrCat("ValidDataOneofBinary", type_name, ".MultipleValuesForSameField"), RECOMMENDED, proto, expected_proto); } { // Tests oneof with multiple values of the different fields. const FieldDescriptor* other_field = GetFieldForOneofType(type, true); FieldDescriptor::Type other_type = other_field->type(); WireFormatLite::WireType other_wire_type = WireFormatLite::WireTypeForFieldType( static_cast(other_type)); const std::string other_value = absl::StrCat(tag(other_field->number(), other_wire_type), GetDefaultValue(other_type)); const std::string proto = absl::StrCat(other_value, non_default_value); const std::string expected_proto = non_default_value; MessageType test_message; test_message.MergeFromString(expected_proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest(absl::StrCat("ValidDataOneof", type_name, ".MultipleValuesForDifferentField"), REQUIRED, proto, text); RunValidBinaryProtobufTest(absl::StrCat("ValidDataOneofBinary", type_name, ".MultipleValuesForDifferentField"), RECOMMENDED, proto, expected_proto); } } template void BinaryAndJsonConformanceSuiteImpl::TestMergeOneofMessage() { std::string field1_data = absl::StrCat(tag(1, WireFormatLite::WIRETYPE_VARINT), varint(1)); std::string field2a_data = absl::StrCat(tag(2, WireFormatLite::WIRETYPE_VARINT), varint(1)); std::string field2b_data = absl::StrCat(tag(2, WireFormatLite::WIRETYPE_VARINT), varint(1)); std::string field89_data = absl::StrCat(tag(89, WireFormatLite::WIRETYPE_VARINT), varint(1)); std::string submsg1_data = absl::StrCat( tag(2, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(field1_data, field2a_data, field89_data))); std::string submsg2_data = absl::StrCat(tag(2, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(field2b_data, field89_data))); std::string merged_data = absl::StrCat(tag(2, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(absl::StrCat(field1_data, field2b_data, field89_data, field89_data))); const FieldDescriptor* field = GetFieldForOneofType(FieldDescriptor::TYPE_MESSAGE); std::string proto1 = absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(submsg1_data)); std::string proto2 = absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(submsg2_data)); std::string proto = absl::StrCat(proto1, proto2); std::string expected_proto = absl::StrCat( tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(merged_data)); MessageType test_message; test_message.MergeFromString(expected_proto); std::string text; TextFormat::PrintToString(test_message, &text); RunValidProtobufTest("ValidDataOneof.MESSAGE.Merge", REQUIRED, proto, text); RunValidBinaryProtobufTest("ValidDataOneofBinary.MESSAGE.Merge", RECOMMENDED, proto, expected_proto); } template void BinaryAndJsonConformanceSuiteImpl::TestIllegalTags() { // field num 0 is illegal std::string nullfield[] = {"\1DEADBEEF", "\2\1\1", "\3\4", "\5DEAD"}; for (int i = 0; i < 4; i++) { std::string name = "IllegalZeroFieldNum_Case_0"; name.back() += i; ExpectParseFailureForProto(nullfield[i], name, REQUIRED); } } template void BinaryAndJsonConformanceSuiteImpl::TestOneofMessage() { MessageType message; message.set_oneof_uint32(0); RunValidProtobufTestWithMessage("OneofZeroUint32", RECOMMENDED, &message, "oneof_uint32: 0"); message.mutable_oneof_nested_message()->set_a(0); RunValidProtobufTestWithMessage("OneofZeroMessage", RECOMMENDED, &message, run_proto3_tests_ ? "oneof_nested_message: {}" : "oneof_nested_message: {a: 0}"); message.mutable_oneof_nested_message()->set_a(1); RunValidProtobufTestWithMessage("OneofZeroMessageSetTwice", RECOMMENDED, &message, "oneof_nested_message: {a: 1}"); message.set_oneof_string(""); RunValidProtobufTestWithMessage("OneofZeroString", RECOMMENDED, &message, "oneof_string: \"\""); message.set_oneof_bytes(""); RunValidProtobufTestWithMessage("OneofZeroBytes", RECOMMENDED, &message, "oneof_bytes: \"\""); message.set_oneof_bool(false); RunValidProtobufTestWithMessage("OneofZeroBool", RECOMMENDED, &message, "oneof_bool: false"); message.set_oneof_uint64(0); RunValidProtobufTestWithMessage("OneofZeroUint64", RECOMMENDED, &message, "oneof_uint64: 0"); message.set_oneof_float(0.0f); RunValidProtobufTestWithMessage("OneofZeroFloat", RECOMMENDED, &message, "oneof_float: 0"); message.set_oneof_double(0.0); RunValidProtobufTestWithMessage("OneofZeroDouble", RECOMMENDED, &message, "oneof_double: 0"); message.set_oneof_enum(MessageType::FOO); RunValidProtobufTestWithMessage("OneofZeroEnum", RECOMMENDED, &message, "oneof_enum: FOO"); } template void BinaryAndJsonConformanceSuiteImpl::TestUnknownMessage() { MessageType message; message.ParseFromString("\xA8\x1F\x01"); RunValidBinaryProtobufTest("UnknownVarint", REQUIRED, message.SerializeAsString()); } template void BinaryAndJsonConformanceSuiteImpl::TestUnknownOrdering() { // Implementations must preserve the ordering of different unknown fields for // the same field number. This is because some field types will accept // multiple wire types for the same field. For example, repeated primitive // fields will accept both length-delimited (packed) and // varint/fixed32/fixed64 (unpacked) wire types, and reordering these could // reorder the elements of the repeated field. MessageType message; MessageType prototype; message.mutable_unknown_fields()->AddLengthDelimited(UNKNOWN_FIELD, "abc"); message.mutable_unknown_fields()->AddVarint(UNKNOWN_FIELD, 123); message.mutable_unknown_fields()->AddLengthDelimited(UNKNOWN_FIELD, "def"); message.mutable_unknown_fields()->AddVarint(UNKNOWN_FIELD, 456); std::string serialized = message.SerializeAsString(); ConformanceRequestSetting setting( REQUIRED, conformance::PROTOBUF, conformance::PROTOBUF, conformance::BINARY_TEST, prototype, "UnknownOrdering", serialized); const ConformanceRequest& request = setting.GetRequest(); ConformanceResponse response; suite_.RunTest(setting.GetTestName(), request, &response); MessageType response_message; if (response.result_case() == ConformanceResponse::kSkipped) { suite_.ReportSkip(setting.GetTestName(), request, response); return; } suite_.ParseResponse(response, setting, &response_message); const UnknownFieldSet& ufs = response_message.unknown_fields(); if (ufs.field_count() != 4 || ufs.field(0).number() != UNKNOWN_FIELD || ufs.field(1).number() != UNKNOWN_FIELD || ufs.field(2).number() != UNKNOWN_FIELD || ufs.field(3).number() != UNKNOWN_FIELD || ufs.field(0).type() != UnknownField::Type::TYPE_LENGTH_DELIMITED || ufs.field(1).type() != UnknownField::Type::TYPE_VARINT || ufs.field(2).type() != UnknownField::Type::TYPE_LENGTH_DELIMITED || ufs.field(3).type() != UnknownField::Type::TYPE_VARINT || ufs.field(0).length_delimited() != "abc" || ufs.field(1).varint() != 123 || ufs.field(2).length_delimited() != "def" || ufs.field(3).varint() != 456) { suite_.ReportFailure(setting.GetTestName(), setting.GetLevel(), request, response, "Unknown field mismatch"); } else { suite_.ReportSuccess(setting.GetTestName()); } } template void BinaryAndJsonConformanceSuiteImpl< MessageType>::TestBinaryPerformanceForAlternatingUnknownFields() { std::string unknown_field_1 = absl::StrCat( tag(UNKNOWN_FIELD, WireFormatLite::WIRETYPE_VARINT), varint(1234)); std::string unknown_field_2 = absl::StrCat( tag(UNKNOWN_FIELD + 1, WireFormatLite::WIRETYPE_VARINT), varint(5678)); std::string proto; for (size_t i = 0; i < kPerformanceRepeatCount; i++) { proto.append(unknown_field_1); proto.append(unknown_field_2); } RunValidBinaryProtobufTest("TestBinaryPerformanceForAlternatingUnknownFields", RECOMMENDED, proto); } template void BinaryAndJsonConformanceSuiteImpl:: TestBinaryPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::Type type) { const std::string type_name = UpperCase(absl::StrCat(".", FieldDescriptor::TypeName(type))); int field_number = GetFieldForType(type, true, Packed::kFalse)->number(); std::string rep_field_proto = absl::StrCat( tag(field_number, WireFormatLite::WireTypeForFieldType( static_cast(type))), GetNonDefaultValue(type)); RunBinaryPerformanceMergeMessageWithField( absl::StrCat("TestBinaryPerformanceMergeMessageWithRepeatedFieldForType", type_name), rep_field_proto); } template void BinaryAndJsonConformanceSuiteImpl:: TestBinaryPerformanceMergeMessageWithUnknownFieldForType( FieldDescriptor::Type type) { const std::string type_name = UpperCase(absl::StrCat(".", FieldDescriptor::TypeName(type))); std::string unknown_field_proto = absl::StrCat( tag(UNKNOWN_FIELD, WireFormatLite::WireTypeForFieldType( static_cast(type))), GetNonDefaultValue(type)); RunBinaryPerformanceMergeMessageWithField( absl::StrCat("TestBinaryPerformanceMergeMessageWithUnknownFieldForType", type_name), unknown_field_proto); } template BinaryAndJsonConformanceSuiteImpl:: BinaryAndJsonConformanceSuiteImpl(BinaryAndJsonConformanceSuite* suite, bool run_proto3_tests) : suite_(*ABSL_DIE_IF_NULL(suite)), run_proto3_tests_(run_proto3_tests) { suite_.SetTypeUrl(GetTypeUrl(MessageType::GetDescriptor())); RunAllTests(); } template void BinaryAndJsonConformanceSuiteImpl::RunAllTests() { if (!suite_.performance_) { for (int i = 1; i <= FieldDescriptor::MAX_TYPE; i++) { if (i == FieldDescriptor::TYPE_GROUP) continue; TestPrematureEOFForType(static_cast(i)); } TestIllegalTags(); int64_t kInt64Min = -9223372036854775808ULL; int64_t kInt64Max = 9223372036854775807ULL; uint64_t kUint64Max = 18446744073709551615ULL; int32_t kInt32Max = 2147483647; int32_t kInt32Min = -2147483648; uint32_t kUint32Max = 4294967295UL; TestValidDataForType( FieldDescriptor::TYPE_DOUBLE, { {dbl(0), dbl(0)}, {dbl(0.1), dbl(0.1)}, {dbl(1.7976931348623157e+308), dbl(1.7976931348623157e+308)}, {dbl(2.22507385850720138309e-308), dbl(2.22507385850720138309e-308)}, }); TestValidDataForType( FieldDescriptor::TYPE_FLOAT, { {flt(0), flt(0)}, {flt(0.1), flt(0.1)}, {flt(1.00000075e-36), flt(1.00000075e-36)}, {flt(3.402823e+38), flt(3.402823e+38)}, // 3.40282347e+38 {flt(1.17549435e-38f), flt(1.17549435e-38)}, }); TestValidDataForType(FieldDescriptor::TYPE_INT64, { {varint(0), varint(0)}, {varint(12345), varint(12345)}, {varint(kInt64Max), varint(kInt64Max)}, {varint(kInt64Min), varint(kInt64Min)}, }); TestValidDataForType(FieldDescriptor::TYPE_UINT64, { {varint(0), varint(0)}, {varint(12345), varint(12345)}, {varint(kUint64Max), varint(kUint64Max)}, }); TestValidDataForType(FieldDescriptor::TYPE_INT32, { {varint(0), varint(0)}, {varint(12345), varint(12345)}, {longvarint(12345, 2), varint(12345)}, {longvarint(12345, 7), varint(12345)}, {varint(kInt32Max), varint(kInt32Max)}, {varint(kInt32Min), varint(kInt32Min)}, {varint(1LL << 33), varint(0)}, {varint((1LL << 33) - 1), varint(-1)}, {varint(kInt64Max), varint(-1)}, {varint(kInt64Min + 1), varint(1)}, }); TestValidDataForType( FieldDescriptor::TYPE_UINT32, { {varint(0), varint(0)}, {varint(12345), varint(12345)}, {longvarint(12345, 2), varint(12345)}, {longvarint(12345, 7), varint(12345)}, {varint(kUint32Max), varint(kUint32Max)}, // UINT32_MAX {varint(1LL << 33), varint(0)}, {varint((1LL << 33) + 1), varint(1)}, {varint((1LL << 33) - 1), varint((1LL << 32) - 1)}, {varint(kInt64Max), varint((1LL << 32) - 1)}, {varint(kInt64Min + 1), varint(1)}, }); TestValidDataForType(FieldDescriptor::TYPE_FIXED64, { {u64(0), u64(0)}, {u64(12345), u64(12345)}, {u64(kUint64Max), u64(kUint64Max)}, }); TestValidDataForType(FieldDescriptor::TYPE_FIXED32, { {u32(0), u32(0)}, {u32(12345), u32(12345)}, {u32(kUint32Max), u32(kUint32Max)}, // UINT32_MAX }); TestValidDataForType(FieldDescriptor::TYPE_SFIXED64, { {u64(0), u64(0)}, {u64(12345), u64(12345)}, {u64(kInt64Max), u64(kInt64Max)}, {u64(kInt64Min), u64(kInt64Min)}, }); TestValidDataForType(FieldDescriptor::TYPE_SFIXED32, { {u32(0), u32(0)}, {u32(12345), u32(12345)}, {u32(kInt32Max), u32(kInt32Max)}, {u32(kInt32Min), u32(kInt32Min)}, }); // Bools should be serialized as 0 for false and 1 for true. Parsers should // also interpret any nonzero value as true. TestValidDataForType(FieldDescriptor::TYPE_BOOL, { {varint(0), varint(0)}, {varint(1), varint(1)}, {varint(-1), varint(1)}, {varint(12345678), varint(1)}, {varint(1LL << 33), varint(1)}, {varint(kInt64Max), varint(1)}, {varint(kInt64Min), varint(1)}, }); TestValidDataForType(FieldDescriptor::TYPE_SINT32, { {zz32(0), zz32(0)}, {zz32(12345), zz32(12345)}, {zz32(kInt32Max), zz32(kInt32Max)}, {zz32(kInt32Min), zz32(kInt32Min)}, {zz64(kInt32Max + 2LL), zz32(1)}, }); TestValidDataForType(FieldDescriptor::TYPE_SINT64, { {zz64(0), zz64(0)}, {zz64(12345), zz64(12345)}, {zz64(kInt64Max), zz64(kInt64Max)}, {zz64(kInt64Min), zz64(kInt64Min)}, }); TestValidDataForType( FieldDescriptor::TYPE_STRING, { {delim(""), delim("")}, {delim("Hello world!"), delim("Hello world!")}, {delim("\'\"\?\\\a\b\f\n\r\t\v"), delim("\'\"\?\\\a\b\f\n\r\t\v")}, // escape {delim("谷歌"), delim("谷歌")}, // Google in Chinese {delim("\u8C37\u6B4C"), delim("谷歌")}, // unicode escape {delim("\u8c37\u6b4c"), delim("谷歌")}, // lowercase unicode {delim("\xF0\x9F\x98\x81"), delim("\xF0\x9F\x98\x81")}, // emoji: 😁 }); TestValidDataForType(FieldDescriptor::TYPE_BYTES, { {delim(""), delim("")}, {delim("Hello world!"), delim("Hello world!")}, {delim("\x01\x02"), delim("\x01\x02")}, {delim("\xfb"), delim("\xfb")}, }); TestValidDataForType(FieldDescriptor::TYPE_ENUM, { {varint(0), varint(0)}, {varint(1), varint(1)}, {varint(2), varint(2)}, {varint(-1), varint(-1)}, {varint(kInt64Max), varint(-1)}, {varint(kInt64Min + 1), varint(1)}, }); TestValidDataForRepeatedScalarMessage(); TestValidDataForType( FieldDescriptor::TYPE_MESSAGE, { {delim(""), delim("")}, {delim(absl::StrCat(tag(1, WireFormatLite::WIRETYPE_VARINT), varint(1234))), delim(absl::StrCat(tag(1, WireFormatLite::WIRETYPE_VARINT), varint(1234)))}, }); TestValidDataForMapType(FieldDescriptor::TYPE_INT32, FieldDescriptor::TYPE_INT32); TestValidDataForMapType(FieldDescriptor::TYPE_INT64, FieldDescriptor::TYPE_INT64); TestValidDataForMapType(FieldDescriptor::TYPE_UINT32, FieldDescriptor::TYPE_UINT32); TestValidDataForMapType(FieldDescriptor::TYPE_UINT64, FieldDescriptor::TYPE_UINT64); TestValidDataForMapType(FieldDescriptor::TYPE_SINT32, FieldDescriptor::TYPE_SINT32); TestValidDataForMapType(FieldDescriptor::TYPE_SINT64, FieldDescriptor::TYPE_SINT64); TestValidDataForMapType(FieldDescriptor::TYPE_FIXED32, FieldDescriptor::TYPE_FIXED32); TestValidDataForMapType(FieldDescriptor::TYPE_FIXED64, FieldDescriptor::TYPE_FIXED64); TestValidDataForMapType(FieldDescriptor::TYPE_SFIXED32, FieldDescriptor::TYPE_SFIXED32); TestValidDataForMapType(FieldDescriptor::TYPE_SFIXED64, FieldDescriptor::TYPE_SFIXED64); TestValidDataForMapType(FieldDescriptor::TYPE_INT32, FieldDescriptor::TYPE_FLOAT); TestValidDataForMapType(FieldDescriptor::TYPE_INT32, FieldDescriptor::TYPE_DOUBLE); TestValidDataForMapType(FieldDescriptor::TYPE_BOOL, FieldDescriptor::TYPE_BOOL); TestValidDataForMapType(FieldDescriptor::TYPE_STRING, FieldDescriptor::TYPE_STRING); TestValidDataForMapType(FieldDescriptor::TYPE_STRING, FieldDescriptor::TYPE_BYTES); TestValidDataForMapType(FieldDescriptor::TYPE_STRING, FieldDescriptor::TYPE_ENUM); TestValidDataForMapType(FieldDescriptor::TYPE_STRING, FieldDescriptor::TYPE_MESSAGE); // Additional test to check overwriting message value map. TestOverwriteMessageValueMap(); TestValidDataForOneofType(FieldDescriptor::TYPE_UINT32); TestValidDataForOneofType(FieldDescriptor::TYPE_BOOL); TestValidDataForOneofType(FieldDescriptor::TYPE_UINT64); TestValidDataForOneofType(FieldDescriptor::TYPE_FLOAT); TestValidDataForOneofType(FieldDescriptor::TYPE_DOUBLE); TestValidDataForOneofType(FieldDescriptor::TYPE_STRING); TestValidDataForOneofType(FieldDescriptor::TYPE_BYTES); TestValidDataForOneofType(FieldDescriptor::TYPE_ENUM); TestValidDataForOneofType(FieldDescriptor::TYPE_MESSAGE); // Additional test to check merging oneof message. TestMergeOneofMessage(); // TODO: // TestValidDataForType(FieldDescriptor::TYPE_GROUP // Unknown fields. // TODO: update this behavior when unknown field's behavior // changed in open source. Also delete // Required.Proto3.ProtobufInput.UnknownVarint.ProtobufOutput // from failure list of python_cpp python java TestUnknownMessage(); TestUnknownOrdering(); TestOneofMessage(); RunJsonTests(); } // Flag control performance tests to keep them internal and opt-in only if (suite_.performance_) { RunBinaryPerformanceTests(); RunJsonPerformanceTests(); } } template void BinaryAndJsonConformanceSuiteImpl< MessageType>::RunBinaryPerformanceTests() { TestBinaryPerformanceForAlternatingUnknownFields(); TestBinaryPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_BOOL); TestBinaryPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_DOUBLE); TestBinaryPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_FLOAT); TestBinaryPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_UINT32); TestBinaryPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_UINT64); TestBinaryPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_STRING); TestBinaryPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_BYTES); TestBinaryPerformanceMergeMessageWithUnknownFieldForType( FieldDescriptor::TYPE_BOOL); TestBinaryPerformanceMergeMessageWithUnknownFieldForType( FieldDescriptor::TYPE_DOUBLE); TestBinaryPerformanceMergeMessageWithUnknownFieldForType( FieldDescriptor::TYPE_FLOAT); TestBinaryPerformanceMergeMessageWithUnknownFieldForType( FieldDescriptor::TYPE_UINT32); TestBinaryPerformanceMergeMessageWithUnknownFieldForType( FieldDescriptor::TYPE_UINT64); TestBinaryPerformanceMergeMessageWithUnknownFieldForType( FieldDescriptor::TYPE_STRING); TestBinaryPerformanceMergeMessageWithUnknownFieldForType( FieldDescriptor::TYPE_BYTES); } template void BinaryAndJsonConformanceSuiteImpl::RunJsonPerformanceTests() { TestJsonPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_BOOL, "true"); TestJsonPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_DOUBLE, "123"); TestJsonPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_FLOAT, "123"); TestJsonPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_UINT32, "123"); TestJsonPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_UINT64, "123"); TestJsonPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_STRING, "\"foo\""); TestJsonPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::TYPE_BYTES, "\"foo\""); } // This is currently considered valid input by some languages but not others template void BinaryAndJsonConformanceSuiteImpl:: TestJsonPerformanceMergeMessageWithRepeatedFieldForType( FieldDescriptor::Type type, std::string field_value) { const std::string type_name = UpperCase(absl::StrCat(".", FieldDescriptor::TypeName(type))); const FieldDescriptor* field = GetFieldForType(type, true, Packed::kFalse); std::string field_name = field->name(); std::string message_field = absl::StrCat("\"", field_name, "\": [", field_value, "]"); std::string recursive_message = absl::StrCat("\"recursive_message\": { ", message_field, "}"); std::string input = absl::StrCat("{", recursive_message); for (size_t i = 1; i < kPerformanceRepeatCount; i++) { absl::StrAppend(&input, ",", recursive_message); } absl::StrAppend(&input, "}"); std::string textproto_message_field = absl::StrCat(field_name, ": ", field_value); std::string expected_textproto = "recursive_message { "; for (size_t i = 0; i < kPerformanceRepeatCount; i++) { absl::StrAppend(&expected_textproto, textproto_message_field, " "); } absl::StrAppend(&expected_textproto, "}"); RunValidJsonTest( absl::StrCat("TestJsonPerformanceMergeMessageWithRepeatedFieldForType", type_name), RECOMMENDED, input, expected_textproto); } template void BinaryAndJsonConformanceSuiteImpl::RunJsonTests() { RunValidJsonTest("HelloWorld", REQUIRED, "{\"optionalString\":\"Hello, World!\"}", "optional_string: 'Hello, World!'"); // NOTE: The spec for JSON support is still being sorted out, these may not // all be correct. RunJsonTestsForFieldNameConvention(); RunJsonTestsForNonRepeatedTypes(); RunJsonTestsForRepeatedTypes(); RunJsonTestsForNullTypes(); if (run_proto3_tests_) { RunJsonTestsForWrapperTypes(); RunJsonTestsForFieldMask(); RunJsonTestsForStruct(); RunJsonTestsForValue(); RunJsonTestsForAny(); } else { // Currently Proto2 only, but should also be run on Proto3-optional. RunJsonTestsForStoresDefaultPrimitive(); } RunJsonTestsForUnknownEnumStringValues(); RunValidJsonIgnoreUnknownTest("IgnoreUnknownJsonNumber", REQUIRED, R"({"unknown": 1})", ""); RunValidJsonIgnoreUnknownTest("IgnoreUnknownJsonString", REQUIRED, R"({"unknown": "a"})", ""); RunValidJsonIgnoreUnknownTest("IgnoreUnknownJsonTrue", REQUIRED, R"({"unknown": true})", ""); RunValidJsonIgnoreUnknownTest("IgnoreUnknownJsonFalse", REQUIRED, R"({"unknown": false})", ""); RunValidJsonIgnoreUnknownTest("IgnoreUnknownJsonNull", REQUIRED, R"({"unknown": null})", ""); RunValidJsonIgnoreUnknownTest("IgnoreUnknownJsonObject", REQUIRED, R"({"unknown": {"a": 1}})", ""); ExpectParseFailureForJson("RejectTopLevelNull", REQUIRED, "null"); } template void BinaryAndJsonConformanceSuiteImpl< MessageType>::RunJsonTestsForStoresDefaultPrimitive() { RunValidJsonTestWithValidator( "StoresDefaultPrimitive", REQUIRED, R"({ "FieldName13": 0 })", [](const Json::Value& value) { return value.isMember("FieldName13"); }); std::vector extensions; MessageType::GetDescriptor()->file()->pool()->FindAllExtensions( MessageType::GetDescriptor(), &extensions); RunValidJsonTestWithValidator("FieldNameExtension", RECOMMENDED, absl::Substitute(R"({ "[$0]": 1 })", extensions[0]->full_name()), [&](const Json::Value& value) { return value.isMember(absl::StrCat( "[", extensions[0]->full_name(), "]")); }); } template void BinaryAndJsonConformanceSuiteImpl< MessageType>::RunJsonTestsForUnknownEnumStringValues() { // Tests the handling of unknown enum values when encoded as string labels. // The expected behavior depends on whether unknown fields are ignored: // * when ignored, the parser should ignore the unknown enum string value. // * when not ignored, the parser should fail. struct TestCase { // Used in the test name. std::string enum_location; // JSON input which will contain the unknown field. std::string input_json; }; const std::vector test_cases = { {"InOptionalField", R"json({ "optional_nested_enum": "UNKNOWN_ENUM_VALUE" })json"}, {"InRepeatedField", R"json({ "repeated_nested_enum": ["UNKNOWN_ENUM_VALUE"] })json"}, {"InMapValue", R"json({ "map_string_nested_enum": {"key": "UNKNOWN_ENUM_VALUE"} })json"}, }; for (const TestCase& test_case : test_cases) { // Unknown enum string value is a parse failure when not ignoring unknown // fields. ExpectParseFailureForJson( absl::StrCat("RejectUnknownEnumStringValue", test_case.enum_location), RECOMMENDED, test_case.input_json); // Unknown enum string value is ignored when ignoring unknown fields. RunValidJsonIgnoreUnknownTest( absl::StrCat("IgnoreUnknownEnumStringValue", test_case.enum_location), RECOMMENDED, test_case.input_json, ""); } // This test is similar to "InRepeatedField" from above, but it highlights the // potentially unexpected behavior in an array with mixed known and unknown // enum string values. RunValidJsonIgnoreUnknownTest("IgnoreUnknownEnumStringValueInRepeatedPart", RECOMMENDED, R"json({ "repeated_nested_enum": [ "FOO", "UNKNOWN_ENUM_VALUE", "FOO" ]})json", R"( repeated_nested_enum: FOO repeated_nested_enum: FOO )"); // This test is similar to "InMapValue" from above with mixture of known and // unknown enum string values in the map. RunValidJsonIgnoreUnknownTest("IgnoreUnknownEnumStringValueInMapPart", RECOMMENDED, R"json({ "map_string_nested_enum": { "key1": "FOO", "key2": "UNKNOWN_ENUM_VALUE" }})json", R"( map_string_nested_enum: { key: "key1" value: FOO } )"); } template void BinaryAndJsonConformanceSuiteImpl< MessageType>::RunJsonTestsForFieldNameConvention() { RunValidJsonTest("FieldNameInSnakeCase", REQUIRED, R"({ "fieldname1": 1, "fieldName2": 2, "FieldName3": 3, "fieldName4": 4 })", R"( fieldname1: 1 field_name2: 2 _field_name3: 3 field__name4_: 4 )"); RunValidJsonTest("FieldNameWithNumbers", REQUIRED, R"({ "field0name5": 5, "field0Name6": 6 })", R"( field0name5: 5 field_0_name6: 6 )"); RunValidJsonTest("FieldNameWithMixedCases", REQUIRED, R"({ "fieldName7": 7, "FieldName8": 8, "fieldName9": 9, "FieldName10": 10, "FIELDNAME11": 11, "FIELDName12": 12 })", R"( fieldName7: 7 FieldName8: 8 field_Name9: 9 Field_Name10: 10 FIELD_NAME11: 11 FIELD_name12: 12 )"); RunValidJsonTest("FieldNameWithDoubleUnderscores", RECOMMENDED, R"({ "FieldName13": 13, "FieldName14": 14, "fieldName15": 15, "fieldName16": 16, "fieldName17": 17, "FieldName18": 18 })", R"( __field_name13: 13 __Field_name14: 14 field__name15: 15 field__Name16: 16 field_name17__: 17 Field_name18__: 18 )"); // Using the original proto field name in JSON is also allowed. RunValidJsonTest("OriginalProtoFieldName", REQUIRED, R"({ "fieldname1": 1, "field_name2": 2, "_field_name3": 3, "field__name4_": 4, "field0name5": 5, "field_0_name6": 6, "fieldName7": 7, "FieldName8": 8, "field_Name9": 9, "Field_Name10": 10, "FIELD_NAME11": 11, "FIELD_name12": 12, "__field_name13": 13, "__Field_name14": 14, "field__name15": 15, "field__Name16": 16, "field_name17__": 17, "Field_name18__": 18 })", R"( fieldname1: 1 field_name2: 2 _field_name3: 3 field__name4_: 4 field0name5: 5 field_0_name6: 6 fieldName7: 7 FieldName8: 8 field_Name9: 9 Field_Name10: 10 FIELD_NAME11: 11 FIELD_name12: 12 __field_name13: 13 __Field_name14: 14 field__name15: 15 field__Name16: 16 field_name17__: 17 Field_name18__: 18 )"); // Field names can be escaped. RunValidJsonTest("FieldNameEscaped", REQUIRED, R"({"fieldn\u0061me1": 1})", "fieldname1: 1"); // String ends with escape character. ExpectParseFailureForJson("StringEndsWithEscapeChar", RECOMMENDED, "{\"optionalString\": \"abc\\"); // Field names must be quoted (or it's not valid JSON). ExpectParseFailureForJson("FieldNameNotQuoted", RECOMMENDED, "{fieldname1: 1}"); // Trailing comma is not allowed (not valid JSON). ExpectParseFailureForJson("TrailingCommaInAnObject", RECOMMENDED, R"({"fieldname1":1,})"); ExpectParseFailureForJson("TrailingCommaInAnObjectWithSpace", RECOMMENDED, R"({"fieldname1":1 ,})"); ExpectParseFailureForJson("TrailingCommaInAnObjectWithSpaceCommaSpace", RECOMMENDED, R"({"fieldname1":1 , })"); ExpectParseFailureForJson("TrailingCommaInAnObjectWithNewlines", RECOMMENDED, R"({ "fieldname1":1, })"); // JSON doesn't support comments. ExpectParseFailureForJson("JsonWithComments", RECOMMENDED, R"({ // This is a comment. "fieldname1": 1 })"); // JSON spec says whitespace doesn't matter, so try a few spacings to be sure. RunValidJsonTest("OneLineNoSpaces", RECOMMENDED, "{\"optionalInt32\":1,\"optionalInt64\":2}", R"( optional_int32: 1 optional_int64: 2 )"); RunValidJsonTest("OneLineWithSpaces", RECOMMENDED, "{ \"optionalInt32\" : 1 , \"optionalInt64\" : 2 }", R"( optional_int32: 1 optional_int64: 2 )"); RunValidJsonTest("MultilineNoSpaces", RECOMMENDED, "{\n\"optionalInt32\"\n:\n1\n,\n\"optionalInt64\"\n:\n2\n}", R"( optional_int32: 1 optional_int64: 2 )"); RunValidJsonTest( "MultilineWithSpaces", RECOMMENDED, "{\n \"optionalInt32\" : 1\n ,\n \"optionalInt64\" : 2\n}\n", R"( optional_int32: 1 optional_int64: 2 )"); // Missing comma between key/value pairs. ExpectParseFailureForJson("MissingCommaOneLine", RECOMMENDED, "{ \"optionalInt32\": 1 \"optionalInt64\": 2 }"); ExpectParseFailureForJson( "MissingCommaMultiline", RECOMMENDED, "{\n \"optionalInt32\": 1\n \"optionalInt64\": 2\n}"); // Duplicated field names are not allowed. ExpectParseFailureForJson("FieldNameDuplicate", RECOMMENDED, R"({ "optionalNestedMessage": {a: 1}, "optionalNestedMessage": {} })"); ExpectParseFailureForJson("FieldNameDuplicateDifferentCasing1", RECOMMENDED, R"({ "optional_nested_message": {a: 1}, "optionalNestedMessage": {} })"); ExpectParseFailureForJson("FieldNameDuplicateDifferentCasing2", RECOMMENDED, R"({ "optionalNestedMessage": {a: 1}, "optional_nested_message": {} })"); // Serializers should use lowerCamelCase by default. RunValidJsonTestWithValidator("FieldNameInLowerCamelCase", REQUIRED, R"({ "fieldname1": 1, "fieldName2": 2, "FieldName3": 3, "fieldName4": 4 })", [](const Json::Value& value) { return value.isMember("fieldname1") && value.isMember("fieldName2") && value.isMember("FieldName3") && value.isMember("fieldName4"); }); RunValidJsonTestWithValidator("FieldNameWithNumbers", REQUIRED, R"({ "field0name5": 5, "field0Name6": 6 })", [](const Json::Value& value) { return value.isMember("field0name5") && value.isMember("field0Name6"); }); RunValidJsonTestWithValidator( "FieldNameWithMixedCases", REQUIRED, R"({ "fieldName7": 7, "FieldName8": 8, "fieldName9": 9, "FieldName10": 10, "FIELDNAME11": 11, "FIELDName12": 12 })", [](const Json::Value& value) { return value.isMember("fieldName7") && value.isMember("FieldName8") && value.isMember("fieldName9") && value.isMember("FieldName10") && value.isMember("FIELDNAME11") && value.isMember("FIELDName12"); }); RunValidJsonTestWithValidator( "FieldNameWithDoubleUnderscores", RECOMMENDED, R"({ "FieldName13": 13, "FieldName14": 14, "fieldName15": 15, "fieldName16": 16, "fieldName17": 17, "FieldName18": 18 })", [](const Json::Value& value) { return value.isMember("FieldName13") && value.isMember("FieldName14") && value.isMember("fieldName15") && value.isMember("fieldName16") && value.isMember("fieldName17") && value.isMember("FieldName18"); }); if (run_proto3_tests_) { RunValidJsonTestWithValidator("SkipsDefaultPrimitive", REQUIRED, R"({"FieldName13": 0})", [](const Json::Value& value) { return !value.isMember("FieldName13"); }); } } template void BinaryAndJsonConformanceSuiteImpl< MessageType>::RunJsonTestsForNonRepeatedTypes() { // Integer fields. RunValidJsonTest("Int32FieldMaxValue", REQUIRED, R"({"optionalInt32": 2147483647})", "optional_int32: 2147483647"); RunValidJsonTest("Int32FieldMinValue", REQUIRED, R"({"optionalInt32": -2147483648})", "optional_int32: -2147483648"); RunValidJsonTest("Uint32FieldMaxValue", REQUIRED, R"({"optionalUint32": 4294967295})", "optional_uint32: 4294967295"); RunValidJsonTest("Int64FieldMaxValue", REQUIRED, R"({"optionalInt64": "9223372036854775807"})", "optional_int64: 9223372036854775807"); RunValidJsonTest("Int64FieldMinValue", REQUIRED, R"({"optionalInt64": "-9223372036854775808"})", "optional_int64: -9223372036854775808"); RunValidJsonTest("Uint64FieldMaxValue", REQUIRED, R"({"optionalUint64": "18446744073709551615"})", "optional_uint64: 18446744073709551615"); // While not the largest Int64, this is the largest // Int64 which can be exactly represented within an // IEEE-754 64-bit float, which is the expected level // of interoperability guarantee. Larger values may // work in some implementations, but should not be // relied upon. RunValidJsonTest("Int64FieldMaxValueNotQuoted", REQUIRED, R"({"optionalInt64": 9223372036854774784})", "optional_int64: 9223372036854774784"); RunValidJsonTest("Int64FieldMinValueNotQuoted", REQUIRED, R"({"optionalInt64": -9223372036854775808})", "optional_int64: -9223372036854775808"); // Largest interoperable Uint64; see comment above // for Int64FieldMaxValueNotQuoted. RunValidJsonTest("Uint64FieldMaxValueNotQuoted", REQUIRED, R"({"optionalUint64": 18446744073709549568})", "optional_uint64: 18446744073709549568"); // Values can be represented as JSON strings. RunValidJsonTest("Int32FieldStringValue", REQUIRED, R"({"optionalInt32": "2147483647"})", "optional_int32: 2147483647"); RunValidJsonTest("Int32FieldStringValueEscaped", REQUIRED, R"({"optionalInt32": "2\u003147483647"})", "optional_int32: 2147483647"); // Parsers reject out-of-bound integer values. ExpectParseFailureForJson("Int32FieldTooLarge", REQUIRED, R"({"optionalInt32": 2147483648})"); ExpectParseFailureForJson("Int32FieldTooSmall", REQUIRED, R"({"optionalInt32": -2147483649})"); ExpectParseFailureForJson("Uint32FieldTooLarge", REQUIRED, R"({"optionalUint32": 4294967296})"); ExpectParseFailureForJson("Int64FieldTooLarge", REQUIRED, R"({"optionalInt64": "9223372036854775808"})"); ExpectParseFailureForJson("Int64FieldTooSmall", REQUIRED, R"({"optionalInt64": "-9223372036854775809"})"); ExpectParseFailureForJson("Uint64FieldTooLarge", REQUIRED, R"({"optionalUint64": "18446744073709551616"})"); // Parser reject non-integer numeric values as well. ExpectParseFailureForJson("Int32FieldNotInteger", REQUIRED, R"({"optionalInt32": 0.5})"); ExpectParseFailureForJson("Uint32FieldNotInteger", REQUIRED, R"({"optionalUint32": 0.5})"); ExpectParseFailureForJson("Int64FieldNotInteger", REQUIRED, R"({"optionalInt64": "0.5"})"); ExpectParseFailureForJson("Uint64FieldNotInteger", REQUIRED, R"({"optionalUint64": "0.5"})"); // Integers but represented as float values are accepted. RunValidJsonTest("Int32FieldFloatTrailingZero", REQUIRED, R"({"optionalInt32": 100000.000})", "optional_int32: 100000"); RunValidJsonTest("Int32FieldExponentialFormat", REQUIRED, R"({"optionalInt32": 1e5})", "optional_int32: 100000"); RunValidJsonTest("Int32FieldMaxFloatValue", REQUIRED, R"({"optionalInt32": 2.147483647e9})", "optional_int32: 2147483647"); RunValidJsonTest("Int32FieldMinFloatValue", REQUIRED, R"({"optionalInt32": -2.147483648e9})", "optional_int32: -2147483648"); RunValidJsonTest("Uint32FieldMaxFloatValue", REQUIRED, R"({"optionalUint32": 4.294967295e9})", "optional_uint32: 4294967295"); // Parser reject non-numeric values. ExpectParseFailureForJson("Int32FieldNotNumber", REQUIRED, R"({"optionalInt32": "3x3"})"); ExpectParseFailureForJson("Uint32FieldNotNumber", REQUIRED, R"({"optionalUint32": "3x3"})"); ExpectParseFailureForJson("Int64FieldNotNumber", REQUIRED, R"({"optionalInt64": "3x3"})"); ExpectParseFailureForJson("Uint64FieldNotNumber", REQUIRED, R"({"optionalUint64": "3x3"})"); // JSON does not allow "+" on numeric values. ExpectParseFailureForJson("Int32FieldPlusSign", REQUIRED, R"({"optionalInt32": +1})"); // JSON doesn't allow leading 0s. ExpectParseFailureForJson("Int32FieldLeadingZero", REQUIRED, R"({"optionalInt32": 01})"); ExpectParseFailureForJson("Int32FieldNegativeWithLeadingZero", REQUIRED, R"({"optionalInt32": -01})"); // String values must follow the same syntax rule. Specifically leading // or trailing spaces are not allowed. ExpectParseFailureForJson("Int32FieldLeadingSpace", REQUIRED, R"({"optionalInt32": " 1"})"); ExpectParseFailureForJson("Int32FieldTrailingSpace", REQUIRED, R"({"optionalInt32": "1 "})"); // 64-bit values are serialized as strings. RunValidJsonTestWithValidator( "Int64FieldBeString", RECOMMENDED, R"({"optionalInt64": 1})", [](const Json::Value& value) { return value["optionalInt64"].type() == Json::stringValue && value["optionalInt64"].asString() == "1"; }); RunValidJsonTestWithValidator( "Uint64FieldBeString", RECOMMENDED, R"({"optionalUint64": 1})", [](const Json::Value& value) { return value["optionalUint64"].type() == Json::stringValue && value["optionalUint64"].asString() == "1"; }); // Bool fields. RunValidJsonTest("BoolFieldTrue", REQUIRED, R"({"optionalBool":true})", "optional_bool: true"); RunValidJsonTest("BoolFieldFalse", REQUIRED, R"({"optionalBool":false})", "optional_bool: false"); // Other forms are not allowed. ExpectParseFailureForJson("BoolFieldIntegerZero", RECOMMENDED, R"({"optionalBool":0})"); ExpectParseFailureForJson("BoolFieldIntegerOne", RECOMMENDED, R"({"optionalBool":1})"); ExpectParseFailureForJson("BoolFieldCamelCaseTrue", RECOMMENDED, R"({"optionalBool":True})"); ExpectParseFailureForJson("BoolFieldCamelCaseFalse", RECOMMENDED, R"({"optionalBool":False})"); ExpectParseFailureForJson("BoolFieldAllCapitalTrue", RECOMMENDED, R"({"optionalBool":TRUE})"); ExpectParseFailureForJson("BoolFieldAllCapitalFalse", RECOMMENDED, R"({"optionalBool":FALSE})"); ExpectParseFailureForJson("BoolFieldDoubleQuotedTrue", RECOMMENDED, R"({"optionalBool":"true"})"); ExpectParseFailureForJson("BoolFieldDoubleQuotedFalse", RECOMMENDED, R"({"optionalBool":"false"})"); // Float fields. RunValidJsonTest("FloatFieldMinPositiveValue", REQUIRED, R"({"optionalFloat": 1.175494e-38})", "optional_float: 1.175494e-38"); RunValidJsonTest("FloatFieldMaxNegativeValue", REQUIRED, R"({"optionalFloat": -1.175494e-38})", "optional_float: -1.175494e-38"); RunValidJsonTest("FloatFieldMaxPositiveValue", REQUIRED, R"({"optionalFloat": 3.402823e+38})", "optional_float: 3.402823e+38"); RunValidJsonTest("FloatFieldMinNegativeValue", REQUIRED, R"({"optionalFloat": 3.402823e+38})", "optional_float: 3.402823e+38"); // Values can be quoted. RunValidJsonTest("FloatFieldQuotedValue", REQUIRED, R"({"optionalFloat": "1"})", "optional_float: 1"); // Special values. RunValidJsonTest("FloatFieldNan", REQUIRED, R"({"optionalFloat": "NaN"})", "optional_float: nan"); RunValidJsonTest("FloatFieldInfinity", REQUIRED, R"({"optionalFloat": "Infinity"})", "optional_float: inf"); RunValidJsonTest("FloatFieldNegativeInfinity", REQUIRED, R"({"optionalFloat": "-Infinity"})", "optional_float: -inf"); // Non-canonical Nan will be correctly normalized. { MessageType message; // IEEE floating-point standard 32-bit quiet NaN: // 0111 1111 1xxx xxxx xxxx xxxx xxxx xxxx message.set_optional_float(WireFormatLite::DecodeFloat(0x7FA12345)); RunValidJsonTestWithProtobufInput("FloatFieldNormalizeQuietNan", REQUIRED, message, "optional_float: nan"); // IEEE floating-point standard 64-bit signaling NaN: // 1111 1111 1xxx xxxx xxxx xxxx xxxx xxxx message.set_optional_float(WireFormatLite::DecodeFloat(0xFFB54321)); RunValidJsonTestWithProtobufInput("FloatFieldNormalizeSignalingNan", REQUIRED, message, "optional_float: nan"); } // Special values must be quoted. ExpectParseFailureForJson("FloatFieldNanNotQuoted", RECOMMENDED, R"({"optionalFloat": NaN})"); ExpectParseFailureForJson("FloatFieldInfinityNotQuoted", RECOMMENDED, R"({"optionalFloat": Infinity})"); ExpectParseFailureForJson("FloatFieldNegativeInfinityNotQuoted", RECOMMENDED, R"({"optionalFloat": -Infinity})"); // Parsers should reject out-of-bound values. ExpectParseFailureForJson("FloatFieldTooSmall", REQUIRED, R"({"optionalFloat": -3.502823e+38})"); ExpectParseFailureForJson("FloatFieldTooLarge", REQUIRED, R"({"optionalFloat": 3.502823e+38})"); // Double fields. RunValidJsonTest("DoubleFieldMinPositiveValue", REQUIRED, R"({"optionalDouble": 2.22507e-308})", "optional_double: 2.22507e-308"); RunValidJsonTest("DoubleFieldMaxNegativeValue", REQUIRED, R"({"optionalDouble": -2.22507e-308})", "optional_double: -2.22507e-308"); RunValidJsonTest("DoubleFieldMaxPositiveValue", REQUIRED, R"({"optionalDouble": 1.79769e+308})", "optional_double: 1.79769e+308"); RunValidJsonTest("DoubleFieldMinNegativeValue", REQUIRED, R"({"optionalDouble": -1.79769e+308})", "optional_double: -1.79769e+308"); // Values can be quoted. RunValidJsonTest("DoubleFieldQuotedValue", REQUIRED, R"({"optionalDouble": "1"})", "optional_double: 1"); // Special values. RunValidJsonTest("DoubleFieldNan", REQUIRED, R"({"optionalDouble": "NaN"})", "optional_double: nan"); RunValidJsonTest("DoubleFieldInfinity", REQUIRED, R"({"optionalDouble": "Infinity"})", "optional_double: inf"); RunValidJsonTest("DoubleFieldNegativeInfinity", REQUIRED, R"({"optionalDouble": "-Infinity"})", "optional_double: -inf"); // Non-canonical Nan will be correctly normalized. { MessageType message; message.set_optional_double( WireFormatLite::DecodeDouble(int64_t{0x7FFA123456789ABC})); RunValidJsonTestWithProtobufInput("DoubleFieldNormalizeQuietNan", REQUIRED, message, "optional_double: nan"); message.set_optional_double( WireFormatLite::DecodeDouble(uint64_t{0xFFFBCBA987654321})); RunValidJsonTestWithProtobufInput("DoubleFieldNormalizeSignalingNan", REQUIRED, message, "optional_double: nan"); } // Special values must be quoted. ExpectParseFailureForJson("DoubleFieldNanNotQuoted", RECOMMENDED, R"({"optionalDouble": NaN})"); ExpectParseFailureForJson("DoubleFieldInfinityNotQuoted", RECOMMENDED, R"({"optionalDouble": Infinity})"); ExpectParseFailureForJson("DoubleFieldNegativeInfinityNotQuoted", RECOMMENDED, R"({"optionalDouble": -Infinity})"); // Parsers should reject out-of-bound values. ExpectParseFailureForJson("DoubleFieldTooSmall", REQUIRED, R"({"optionalDouble": -1.89769e+308})"); ExpectParseFailureForJson("DoubleFieldTooLarge", REQUIRED, R"({"optionalDouble": +1.89769e+308})"); // Enum fields. RunValidJsonTest("EnumField", REQUIRED, R"({"optionalNestedEnum": "FOO"})", "optional_nested_enum: FOO"); // Enum fields with alias if (run_proto3_tests_) { RunValidJsonTest("EnumFieldWithAlias", REQUIRED, R"({"optionalAliasedEnum": "ALIAS_BAZ"})", "optional_aliased_enum: ALIAS_BAZ"); RunValidJsonTest("EnumFieldWithAliasUseAlias", REQUIRED, R"({"optionalAliasedEnum": "MOO"})", "optional_aliased_enum: ALIAS_BAZ"); RunValidJsonTest("EnumFieldWithAliasLowerCase", REQUIRED, R"({"optionalAliasedEnum": "moo"})", "optional_aliased_enum: ALIAS_BAZ"); RunValidJsonTest("EnumFieldWithAliasDifferentCase", REQUIRED, R"({"optionalAliasedEnum": "bAz"})", "optional_aliased_enum: ALIAS_BAZ"); } // Enum values must be represented as strings. ExpectParseFailureForJson("EnumFieldNotQuoted", REQUIRED, R"({"optionalNestedEnum": FOO})"); // Numeric values are allowed. RunValidJsonTest("EnumFieldNumericValueZero", REQUIRED, R"({"optionalNestedEnum": 0})", "optional_nested_enum: FOO"); RunValidJsonTest("EnumFieldNumericValueNonZero", REQUIRED, R"({"optionalNestedEnum": 1})", "optional_nested_enum: BAR"); if (run_proto3_tests_) { // Unknown enum values are represented as numeric values. RunValidJsonTestWithValidator( "EnumFieldUnknownValue", REQUIRED, R"({"optionalNestedEnum": 123})", [](const Json::Value& value) { return value["optionalNestedEnum"].type() == Json::intValue && value["optionalNestedEnum"].asInt() == 123; }); } // String fields. RunValidJsonTest("StringField", REQUIRED, R"({"optionalString": "Hello world!"})", R"(optional_string: "Hello world!")"); RunValidJsonTest("StringFieldUnicode", REQUIRED, // Google in Chinese. R"({"optionalString": "谷歌"})", R"(optional_string: "谷歌")"); RunValidJsonTest("StringFieldEscape", REQUIRED, R"({"optionalString": "\"\\\/\b\f\n\r\t"})", R"(optional_string: "\"\\/\b\f\n\r\t")"); RunValidJsonTest("StringFieldUnicodeEscape", REQUIRED, R"({"optionalString": "\u8C37\u6B4C"})", R"(optional_string: "谷歌")"); RunValidJsonTest("StringFieldUnicodeEscapeWithLowercaseHexLetters", REQUIRED, R"({"optionalString": "\u8c37\u6b4c"})", R"(optional_string: "谷歌")"); RunValidJsonTest( "StringFieldSurrogatePair", REQUIRED, // The character is an emoji: grinning face with smiling eyes. 😁 R"({"optionalString": "\uD83D\uDE01"})", R"(optional_string: "\xF0\x9F\x98\x81")"); RunValidJsonTest("StringFieldEmbeddedNull", REQUIRED, R"({"optionalString": "Hello\u0000world!"})", R"(optional_string: "Hello\000world!")"); // Unicode escapes must start with "\u" (lowercase u). ExpectParseFailureForJson("StringFieldUppercaseEscapeLetter", RECOMMENDED, R"({"optionalString": "\U8C37\U6b4C"})"); ExpectParseFailureForJson("StringFieldInvalidEscape", RECOMMENDED, R"({"optionalString": "\uXXXX\u6B4C"})"); ExpectParseFailureForJson("StringFieldUnterminatedEscape", RECOMMENDED, R"({"optionalString": "\u8C3"})"); ExpectParseFailureForJson("StringFieldUnpairedHighSurrogate", RECOMMENDED, R"({"optionalString": "\uD800"})"); ExpectParseFailureForJson("StringFieldUnpairedLowSurrogate", RECOMMENDED, R"({"optionalString": "\uDC00"})"); ExpectParseFailureForJson("StringFieldSurrogateInWrongOrder", RECOMMENDED, R"({"optionalString": "\uDE01\uD83D"})"); ExpectParseFailureForJson("StringFieldNotAString", REQUIRED, R"({"optionalString": 12345})"); // Bytes fields. RunValidJsonTest("BytesField", REQUIRED, R"({"optionalBytes": "AQI="})", R"(optional_bytes: "\x01\x02")"); RunValidJsonTest("BytesFieldBase64Url", RECOMMENDED, R"({"optionalBytes": "-_"})", R"(optional_bytes: "\xfb")"); // Message fields. RunValidJsonTest("MessageField", REQUIRED, R"({"optionalNestedMessage": {"a": 1234}})", "optional_nested_message: {a: 1234}"); // Oneof fields. ExpectParseFailureForJson("OneofFieldDuplicate", REQUIRED, R"({"oneofUint32": 1, "oneofString": "test"})"); RunValidJsonTest("OneofFieldNullFirst", REQUIRED, R"({"oneofUint32": null, "oneofString": "test"})", "oneof_string: \"test\""); RunValidJsonTest("OneofFieldNullSecond", REQUIRED, R"({"oneofString": "test", "oneofUint32": null})", "oneof_string: \"test\""); RunValidJsonTest("OneofZeroUint32", RECOMMENDED, R"({"oneofUint32": 0})", "oneof_uint32: 0"); RunValidJsonTest("OneofZeroMessage", RECOMMENDED, R"({"oneofNestedMessage": {}})", "oneof_nested_message: {}"); RunValidJsonTest("OneofZeroString", RECOMMENDED, R"({"oneofString": ""})", "oneof_string: \"\""); RunValidJsonTest("OneofZeroBytes", RECOMMENDED, R"({"oneofBytes": ""})", "oneof_bytes: \"\""); RunValidJsonTest("OneofZeroBool", RECOMMENDED, R"({"oneofBool": false})", "oneof_bool: false"); RunValidJsonTest("OneofZeroUint64", RECOMMENDED, R"({"oneofUint64": 0})", "oneof_uint64: 0"); RunValidJsonTest("OneofZeroFloat", RECOMMENDED, R"({"oneofFloat": 0.0})", "oneof_float: 0"); RunValidJsonTest("OneofZeroDouble", RECOMMENDED, R"({"oneofDouble": 0.0})", "oneof_double: 0"); RunValidJsonTest("OneofZeroEnum", RECOMMENDED, R"({"oneofEnum":"FOO"})", "oneof_enum: FOO"); // Map fields. RunValidJsonTest("Int32MapField", REQUIRED, R"({"mapInt32Int32": {"1": 2, "3": 4}})", "map_int32_int32: {key: 1 value: 2}" "map_int32_int32: {key: 3 value: 4}"); ExpectParseFailureForJson("Int32MapFieldKeyNotQuoted", RECOMMENDED, R"({"mapInt32Int32": {1: 2, 3: 4}})"); RunValidJsonTest("Uint32MapField", REQUIRED, R"({"mapUint32Uint32": {"1": 2, "3": 4}})", "map_uint32_uint32: {key: 1 value: 2}" "map_uint32_uint32: {key: 3 value: 4}"); ExpectParseFailureForJson("Uint32MapFieldKeyNotQuoted", RECOMMENDED, R"({"mapUint32Uint32": {1: 2, 3: 4}})"); RunValidJsonTest("Int64MapField", REQUIRED, R"({"mapInt64Int64": {"1": 2, "3": 4}})", "map_int64_int64: {key: 1 value: 2}" "map_int64_int64: {key: 3 value: 4}"); ExpectParseFailureForJson("Int64MapFieldKeyNotQuoted", RECOMMENDED, R"({"mapInt64Int64": {1: 2, 3: 4}})"); RunValidJsonTest("Uint64MapField", REQUIRED, R"({"mapUint64Uint64": {"1": 2, "3": 4}})", "map_uint64_uint64: {key: 1 value: 2}" "map_uint64_uint64: {key: 3 value: 4}"); ExpectParseFailureForJson("Uint64MapFieldKeyNotQuoted", RECOMMENDED, R"({"mapUint64Uint64": {1: 2, 3: 4}})"); RunValidJsonTest("BoolMapField", REQUIRED, R"({"mapBoolBool": {"true": true, "false": false}})", "map_bool_bool: {key: true value: true}" "map_bool_bool: {key: false value: false}"); ExpectParseFailureForJson("BoolMapFieldKeyNotQuoted", RECOMMENDED, R"({"mapBoolBool": {true: true, false: false}})"); RunValidJsonTest("MessageMapField", REQUIRED, R"({ "mapStringNestedMessage": { "hello": {"a": 1234}, "world": {"a": 5678} } })", R"( map_string_nested_message: { key: "hello" value: {a: 1234} } map_string_nested_message: { key: "world" value: {a: 5678} } )"); // Since Map keys are represented as JSON strings, escaping should be allowed. RunValidJsonTest("Int32MapEscapedKey", REQUIRED, R"({"mapInt32Int32": {"\u0031": 2}})", "map_int32_int32: {key: 1 value: 2}"); RunValidJsonTest("Int64MapEscapedKey", REQUIRED, R"({"mapInt64Int64": {"\u0031": 2}})", "map_int64_int64: {key: 1 value: 2}"); RunValidJsonTest("BoolMapEscapedKey", REQUIRED, R"({"mapBoolBool": {"tr\u0075e": true}})", "map_bool_bool: {key: true value: true}"); // http://www.rfc-editor.org/rfc/rfc7159.txt says strings have to use double // quotes. ExpectParseFailureForJson("StringFieldSingleQuoteKey", RECOMMENDED, R"({'optionalString': "Hello world!"})"); ExpectParseFailureForJson("StringFieldSingleQuoteValue", RECOMMENDED, R"({"optionalString": 'Hello world!'})"); ExpectParseFailureForJson("StringFieldSingleQuoteBoth", RECOMMENDED, R"({'optionalString': 'Hello world!'})"); } template void BinaryAndJsonConformanceSuiteImpl< MessageType>::RunJsonTestsForRepeatedTypes() { // Repeated fields. RunValidJsonTest("PrimitiveRepeatedField", REQUIRED, R"({"repeatedInt32": [1, 2, 3, 4]})", "repeated_int32: [1, 2, 3, 4]"); RunValidJsonTest("EnumRepeatedField", REQUIRED, R"({"repeatedNestedEnum": ["FOO", "BAR", "BAZ"]})", "repeated_nested_enum: [FOO, BAR, BAZ]"); RunValidJsonTest("StringRepeatedField", REQUIRED, R"({"repeatedString": ["Hello", "world"]})", R"(repeated_string: ["Hello", "world"])"); RunValidJsonTest("BytesRepeatedField", REQUIRED, R"({"repeatedBytes": ["AAEC", "AQI="]})", R"(repeated_bytes: ["\x00\x01\x02", "\x01\x02"])"); RunValidJsonTest("MessageRepeatedField", REQUIRED, R"({"repeatedNestedMessage": [{"a": 1234}, {"a": 5678}]})", "repeated_nested_message: {a: 1234}" "repeated_nested_message: {a: 5678}"); // Repeated field elements are of incorrect type. ExpectParseFailureForJson( "RepeatedFieldWrongElementTypeExpectingIntegersGotBool", REQUIRED, R"({"repeatedInt32": [1, false, 3, 4]})"); ExpectParseFailureForJson( "RepeatedFieldWrongElementTypeExpectingIntegersGotString", REQUIRED, R"({"repeatedInt32": [1, 2, "name", 4]})"); ExpectParseFailureForJson( "RepeatedFieldWrongElementTypeExpectingIntegersGotMessage", REQUIRED, R"({"repeatedInt32": [1, 2, 3, {"a": 4}]})"); ExpectParseFailureForJson( "RepeatedFieldWrongElementTypeExpectingStringsGotInt", REQUIRED, R"({"repeatedString": ["1", 2, "3", "4"]})"); ExpectParseFailureForJson( "RepeatedFieldWrongElementTypeExpectingStringsGotBool", REQUIRED, R"({"repeatedString": ["1", "2", false, "4"]})"); ExpectParseFailureForJson( "RepeatedFieldWrongElementTypeExpectingStringsGotMessage", REQUIRED, R"({"repeatedString": ["1", 2, "3", {"a": 4}]})"); ExpectParseFailureForJson( "RepeatedFieldWrongElementTypeExpectingMessagesGotInt", REQUIRED, R"({"repeatedNestedMessage": [{"a": 1}, 2]})"); ExpectParseFailureForJson( "RepeatedFieldWrongElementTypeExpectingMessagesGotBool", REQUIRED, R"({"repeatedNestedMessage": [{"a": 1}, false]})"); ExpectParseFailureForJson( "RepeatedFieldWrongElementTypeExpectingMessagesGotString", REQUIRED, R"({"repeatedNestedMessage": [{"a": 1}, "2"]})"); // Trailing comma in the repeated field is not allowed. ExpectParseFailureForJson("RepeatedFieldTrailingComma", RECOMMENDED, R"({"repeatedInt32": [1, 2, 3, 4,]})"); ExpectParseFailureForJson("RepeatedFieldTrailingCommaWithSpace", RECOMMENDED, "{\"repeatedInt32\": [1, 2, 3, 4 ,]}"); ExpectParseFailureForJson("RepeatedFieldTrailingCommaWithSpaceCommaSpace", RECOMMENDED, "{\"repeatedInt32\": [1, 2, 3, 4 , ]}"); ExpectParseFailureForJson( "RepeatedFieldTrailingCommaWithNewlines", RECOMMENDED, "{\"repeatedInt32\": [\n 1,\n 2,\n 3,\n 4,\n]}"); } template void BinaryAndJsonConformanceSuiteImpl< MessageType>::RunJsonTestsForNullTypes() { // "null" is accepted for all fields types. RunValidJsonTest("AllFieldAcceptNull", REQUIRED, R"({ "optionalInt32": null, "optionalInt64": null, "optionalUint32": null, "optionalUint64": null, "optionalSint32": null, "optionalSint64": null, "optionalFixed32": null, "optionalFixed64": null, "optionalSfixed32": null, "optionalSfixed64": null, "optionalFloat": null, "optionalDouble": null, "optionalBool": null, "optionalString": null, "optionalBytes": null, "optionalNestedEnum": null, "optionalNestedMessage": null, "repeatedInt32": null, "repeatedInt64": null, "repeatedUint32": null, "repeatedUint64": null, "repeatedSint32": null, "repeatedSint64": null, "repeatedFixed32": null, "repeatedFixed64": null, "repeatedSfixed32": null, "repeatedSfixed64": null, "repeatedFloat": null, "repeatedDouble": null, "repeatedBool": null, "repeatedString": null, "repeatedBytes": null, "repeatedNestedEnum": null, "repeatedNestedMessage": null, "mapInt32Int32": null, "mapBoolBool": null, "mapStringNestedMessage": null })", ""); // Repeated field elements cannot be null. ExpectParseFailureForJson("RepeatedFieldPrimitiveElementIsNull", RECOMMENDED, R"({"repeatedInt32": [1, null, 2]})"); ExpectParseFailureForJson( "RepeatedFieldMessageElementIsNull", RECOMMENDED, R"({"repeatedNestedMessage": [{"a":1}, null, {"a":2}]})"); // Map field keys cannot be null. ExpectParseFailureForJson("MapFieldKeyIsNull", RECOMMENDED, R"({"mapInt32Int32": {null: 1}})"); // Map field values cannot be null. ExpectParseFailureForJson("MapFieldValueIsNull", RECOMMENDED, R"({"mapInt32Int32": {"0": null}})"); } template void BinaryAndJsonConformanceSuiteImpl< MessageType>::RunJsonTestsForWrapperTypes() { RunValidJsonTest("OptionalBoolWrapper", REQUIRED, R"({"optionalBoolWrapper": false})", "optional_bool_wrapper: {value: false}"); RunValidJsonTest("OptionalInt32Wrapper", REQUIRED, R"({"optionalInt32Wrapper": 0})", "optional_int32_wrapper: {value: 0}"); RunValidJsonTest("OptionalUint32Wrapper", REQUIRED, R"({"optionalUint32Wrapper": 0})", "optional_uint32_wrapper: {value: 0}"); RunValidJsonTest("OptionalInt64Wrapper", REQUIRED, R"({"optionalInt64Wrapper": 0})", "optional_int64_wrapper: {value: 0}"); RunValidJsonTest("OptionalUint64Wrapper", REQUIRED, R"({"optionalUint64Wrapper": 0})", "optional_uint64_wrapper: {value: 0}"); RunValidJsonTest("OptionalFloatWrapper", REQUIRED, R"({"optionalFloatWrapper": 0})", "optional_float_wrapper: {value: 0}"); RunValidJsonTest("OptionalDoubleWrapper", REQUIRED, R"({"optionalDoubleWrapper": 0})", "optional_double_wrapper: {value: 0}"); RunValidJsonTest("OptionalStringWrapper", REQUIRED, R"({"optionalStringWrapper": ""})", R"(optional_string_wrapper: {value: ""})"); RunValidJsonTest("OptionalBytesWrapper", REQUIRED, R"({"optionalBytesWrapper": ""})", R"(optional_bytes_wrapper: {value: ""})"); RunValidJsonTest("OptionalWrapperTypesWithNonDefaultValue", REQUIRED, R"({ "optionalBoolWrapper": true, "optionalInt32Wrapper": 1, "optionalUint32Wrapper": 1, "optionalInt64Wrapper": "1", "optionalUint64Wrapper": "1", "optionalFloatWrapper": 1, "optionalDoubleWrapper": 1, "optionalStringWrapper": "1", "optionalBytesWrapper": "AQI=" })", R"( optional_bool_wrapper: {value: true} optional_int32_wrapper: {value: 1} optional_uint32_wrapper: {value: 1} optional_int64_wrapper: {value: 1} optional_uint64_wrapper: {value: 1} optional_float_wrapper: {value: 1} optional_double_wrapper: {value: 1} optional_string_wrapper: {value: "1"} optional_bytes_wrapper: {value: "\x01\x02"} )"); RunValidJsonTest("RepeatedBoolWrapper", REQUIRED, R"({"repeatedBoolWrapper": [true, false]})", "repeated_bool_wrapper: {value: true}" "repeated_bool_wrapper: {value: false}"); RunValidJsonTest("RepeatedInt32Wrapper", REQUIRED, R"({"repeatedInt32Wrapper": [0, 1]})", "repeated_int32_wrapper: {value: 0}" "repeated_int32_wrapper: {value: 1}"); RunValidJsonTest("RepeatedUint32Wrapper", REQUIRED, R"({"repeatedUint32Wrapper": [0, 1]})", "repeated_uint32_wrapper: {value: 0}" "repeated_uint32_wrapper: {value: 1}"); RunValidJsonTest("RepeatedInt64Wrapper", REQUIRED, R"({"repeatedInt64Wrapper": [0, 1]})", "repeated_int64_wrapper: {value: 0}" "repeated_int64_wrapper: {value: 1}"); RunValidJsonTest("RepeatedUint64Wrapper", REQUIRED, R"({"repeatedUint64Wrapper": [0, 1]})", "repeated_uint64_wrapper: {value: 0}" "repeated_uint64_wrapper: {value: 1}"); RunValidJsonTest("RepeatedFloatWrapper", REQUIRED, R"({"repeatedFloatWrapper": [0, 1]})", "repeated_float_wrapper: {value: 0}" "repeated_float_wrapper: {value: 1}"); RunValidJsonTest("RepeatedDoubleWrapper", REQUIRED, R"({"repeatedDoubleWrapper": [0, 1]})", "repeated_double_wrapper: {value: 0}" "repeated_double_wrapper: {value: 1}"); RunValidJsonTest("RepeatedStringWrapper", REQUIRED, R"({"repeatedStringWrapper": ["", "AQI="]})", R"( repeated_string_wrapper: {value: ""} repeated_string_wrapper: {value: "AQI="} )"); RunValidJsonTest("RepeatedBytesWrapper", REQUIRED, R"({"repeatedBytesWrapper": ["", "AQI="]})", R"( repeated_bytes_wrapper: {value: ""} repeated_bytes_wrapper: {value: "\x01\x02"} )"); RunValidJsonTest("WrapperTypesWithNullValue", REQUIRED, R"({ "optionalBoolWrapper": null, "optionalInt32Wrapper": null, "optionalUint32Wrapper": null, "optionalInt64Wrapper": null, "optionalUint64Wrapper": null, "optionalFloatWrapper": null, "optionalDoubleWrapper": null, "optionalStringWrapper": null, "optionalBytesWrapper": null, "repeatedBoolWrapper": null, "repeatedInt32Wrapper": null, "repeatedUint32Wrapper": null, "repeatedInt64Wrapper": null, "repeatedUint64Wrapper": null, "repeatedFloatWrapper": null, "repeatedDoubleWrapper": null, "repeatedStringWrapper": null, "repeatedBytesWrapper": null })", ""); // Duration RunValidJsonTest( "DurationMinValue", REQUIRED, R"({"optionalDuration": "-315576000000.999999999s"})", "optional_duration: {seconds: -315576000000 nanos: -999999999}"); RunValidJsonTest( "DurationMaxValue", REQUIRED, R"({"optionalDuration": "315576000000.999999999s"})", "optional_duration: {seconds: 315576000000 nanos: 999999999}"); RunValidJsonTest("DurationRepeatedValue", REQUIRED, R"({"repeatedDuration": ["1.5s", "-1.5s"]})", "repeated_duration: {seconds: 1 nanos: 500000000}" "repeated_duration: {seconds: -1 nanos: -500000000}"); RunValidJsonTest("DurationNull", REQUIRED, R"({"optionalDuration": null})", ""); RunValidJsonTest("DurationNegativeSeconds", REQUIRED, R"({"optionalDuration": "-5s"})", "optional_duration: {seconds: -5 nanos: 0}"); RunValidJsonTest("DurationNegativeNanos", REQUIRED, R"({"optionalDuration": "-0.5s"})", "optional_duration: {seconds: 0 nanos: -500000000}"); ExpectParseFailureForJson("DurationMissingS", REQUIRED, R"({"optionalDuration": "1"})"); ExpectParseFailureForJson( "DurationJsonInputTooSmall", REQUIRED, R"({"optionalDuration": "-315576000001.000000000s"})"); ExpectParseFailureForJson( "DurationJsonInputTooLarge", REQUIRED, R"({"optionalDuration": "315576000001.000000000s"})"); ExpectSerializeFailureForJson( "DurationProtoInputTooSmall", REQUIRED, "optional_duration: {seconds: -315576000001 nanos: 0}"); ExpectSerializeFailureForJson( "DurationProtoInputTooLarge", REQUIRED, "optional_duration: {seconds: 315576000001 nanos: 0}"); RunValidJsonTestWithValidator( "DurationHasZeroFractionalDigit", RECOMMENDED, R"({"optionalDuration": "1.000000000s"})", [](const Json::Value& value) { return value["optionalDuration"].asString() == "1s"; }); RunValidJsonTestWithValidator( "DurationHas3FractionalDigits", RECOMMENDED, R"({"optionalDuration": "1.010000000s"})", [](const Json::Value& value) { return value["optionalDuration"].asString() == "1.010s"; }); RunValidJsonTestWithValidator( "DurationHas6FractionalDigits", RECOMMENDED, R"({"optionalDuration": "1.000010000s"})", [](const Json::Value& value) { return value["optionalDuration"].asString() == "1.000010s"; }); RunValidJsonTestWithValidator( "DurationHas9FractionalDigits", RECOMMENDED, R"({"optionalDuration": "1.000000010s"})", [](const Json::Value& value) { return value["optionalDuration"].asString() == "1.000000010s"; }); // Timestamp RunValidJsonTest("TimestampMinValue", REQUIRED, R"({"optionalTimestamp": "0001-01-01T00:00:00Z"})", "optional_timestamp: {seconds: -62135596800}"); RunValidJsonTest( "TimestampMaxValue", REQUIRED, R"({"optionalTimestamp": "9999-12-31T23:59:59.999999999Z"})", "optional_timestamp: {seconds: 253402300799 nanos: 999999999}"); RunValidJsonTest( "TimestampRepeatedValue", REQUIRED, R"({ "repeatedTimestamp": [ "0001-01-01T00:00:00Z", "9999-12-31T23:59:59.999999999Z" ] })", "repeated_timestamp: {seconds: -62135596800}" "repeated_timestamp: {seconds: 253402300799 nanos: 999999999}"); RunValidJsonTest("TimestampLeap", REQUIRED, R"({"optionalTimestamp": "1993-02-10T00:00:00.000Z"})", "optional_timestamp: {seconds: 729302400}"); RunValidJsonTest("TimestampWithPositiveOffset", REQUIRED, R"({"optionalTimestamp": "1970-01-01T08:00:01+08:00"})", "optional_timestamp: {seconds: 1}"); RunValidJsonTest("TimestampWithNegativeOffset", REQUIRED, R"({"optionalTimestamp": "1969-12-31T16:00:01-08:00"})", "optional_timestamp: {seconds: 1}"); RunValidJsonTest("TimestampNull", REQUIRED, R"({"optionalTimestamp": null})", ""); ExpectParseFailureForJson("TimestampJsonInputTooSmall", REQUIRED, R"({"optionalTimestamp": "0000-01-01T00:00:00Z"})"); ExpectParseFailureForJson( "TimestampJsonInputTooLarge", REQUIRED, R"({"optionalTimestamp": "10000-01-01T00:00:00Z"})"); ExpectParseFailureForJson("TimestampJsonInputMissingZ", REQUIRED, R"({"optionalTimestamp": "0001-01-01T00:00:00"})"); ExpectParseFailureForJson("TimestampJsonInputMissingT", REQUIRED, R"({"optionalTimestamp": "0001-01-01 00:00:00Z"})"); ExpectParseFailureForJson("TimestampJsonInputLowercaseZ", REQUIRED, R"({"optionalTimestamp": "0001-01-01T00:00:00z"})"); ExpectParseFailureForJson("TimestampJsonInputLowercaseT", REQUIRED, R"({"optionalTimestamp": "0001-01-01t00:00:00Z"})"); ExpectSerializeFailureForJson("TimestampProtoInputTooSmall", REQUIRED, "optional_timestamp: {seconds: -62135596801}"); ExpectSerializeFailureForJson("TimestampProtoInputTooLarge", REQUIRED, "optional_timestamp: {seconds: 253402300800}"); RunValidJsonTestWithValidator( "TimestampZeroNormalized", RECOMMENDED, R"({"optionalTimestamp": "1969-12-31T16:00:00-08:00"})", [](const Json::Value& value) { return value["optionalTimestamp"].asString() == "1970-01-01T00:00:00Z"; }); RunValidJsonTestWithValidator( "TimestampHasZeroFractionalDigit", RECOMMENDED, R"({"optionalTimestamp": "1970-01-01T00:00:00.000000000Z"})", [](const Json::Value& value) { return value["optionalTimestamp"].asString() == "1970-01-01T00:00:00Z"; }); RunValidJsonTestWithValidator( "TimestampHas3FractionalDigits", RECOMMENDED, R"({"optionalTimestamp": "1970-01-01T00:00:00.010000000Z"})", [](const Json::Value& value) { return value["optionalTimestamp"].asString() == "1970-01-01T00:00:00.010Z"; }); RunValidJsonTestWithValidator( "TimestampHas6FractionalDigits", RECOMMENDED, R"({"optionalTimestamp": "1970-01-01T00:00:00.000010000Z"})", [](const Json::Value& value) { return value["optionalTimestamp"].asString() == "1970-01-01T00:00:00.000010Z"; }); RunValidJsonTestWithValidator( "TimestampHas9FractionalDigits", RECOMMENDED, R"({"optionalTimestamp": "1970-01-01T00:00:00.000000010Z"})", [](const Json::Value& value) { return value["optionalTimestamp"].asString() == "1970-01-01T00:00:00.000000010Z"; }); } template void BinaryAndJsonConformanceSuiteImpl< MessageType>::RunJsonTestsForFieldMask() { RunValidJsonTest("FieldMask", REQUIRED, R"({"optionalFieldMask": "foo,barBaz"})", R"(optional_field_mask: {paths: "foo" paths: "bar_baz"})"); RunValidJsonTest("EmptyFieldMask", REQUIRED, R"({"optionalFieldMask": ""})", R"(optional_field_mask: {})"); ExpectParseFailureForJson("FieldMaskInvalidCharacter", RECOMMENDED, R"({"optionalFieldMask": "foo,bar_bar"})"); ExpectSerializeFailureForJson("FieldMaskPathsDontRoundTrip", RECOMMENDED, R"(optional_field_mask: {paths: "fooBar"})"); ExpectSerializeFailureForJson("FieldMaskNumbersDontRoundTrip", RECOMMENDED, R"(optional_field_mask: {paths: "foo_3_bar"})"); ExpectSerializeFailureForJson("FieldMaskTooManyUnderscore", RECOMMENDED, R"(optional_field_mask: {paths: "foo__bar"})"); } template void BinaryAndJsonConformanceSuiteImpl::RunJsonTestsForStruct() { RunValidJsonTest("Struct", REQUIRED, R"({ "optionalStruct": { "nullValue": null, "intValue": 1234, "boolValue": true, "doubleValue": 1234.5678, "stringValue": "Hello world!", "listValue": [1234, "5678"], "objectValue": { "value": 0 } } })", R"( optional_struct: { fields: { key: "nullValue" value: {null_value: NULL_VALUE} } fields: { key: "intValue" value: {number_value: 1234} } fields: { key: "boolValue" value: {bool_value: true} } fields: { key: "doubleValue" value: {number_value: 1234.5678} } fields: { key: "stringValue" value: {string_value: "Hello world!"} } fields: { key: "listValue" value: { list_value: { values: { number_value: 1234 } values: { string_value: "5678" } } } } fields: { key: "objectValue" value: { struct_value: { fields: { key: "value" value: { number_value: 0 } } } } } } )"); RunValidJsonTest("StructWithEmptyListValue", REQUIRED, R"({ "optionalStruct": { "listValue": [] } })", R"( optional_struct: { fields: { key: "listValue" value: { list_value: { } } } } )"); } template void BinaryAndJsonConformanceSuiteImpl::RunJsonTestsForValue() { RunValidJsonTest("ValueAcceptInteger", REQUIRED, R"({"optionalValue": 1})", "optional_value: { number_value: 1}"); RunValidJsonTest("ValueAcceptFloat", REQUIRED, R"({"optionalValue": 1.5})", "optional_value: { number_value: 1.5}"); RunValidJsonTest("ValueAcceptBool", REQUIRED, R"({"optionalValue": false})", "optional_value: { bool_value: false}"); RunValidJsonTest("ValueAcceptNull", REQUIRED, R"({"optionalValue": null})", "optional_value: { null_value: NULL_VALUE}"); RunValidJsonTest("ValueAcceptString", REQUIRED, R"({"optionalValue": "hello"})", R"(optional_value: { string_value: "hello"})"); RunValidJsonTest("ValueAcceptList", REQUIRED, R"({"optionalValue": [0, "hello"]})", R"( optional_value: { list_value: { values: { number_value: 0 } values: { string_value: "hello" } } } )"); RunValidJsonTest("ValueAcceptObject", REQUIRED, R"({"optionalValue": {"value": 1}})", R"( optional_value: { struct_value: { fields: { key: "value" value: { number_value: 1 } } } } )"); RunValidJsonTest("RepeatedValue", REQUIRED, R"({ "repeatedValue": [["a"]] })", R"( repeated_value: [ { list_value: { values: [ { string_value: "a"} ] } } ] )"); RunValidJsonTest("RepeatedListValue", REQUIRED, R"({ "repeatedListValue": [["a"]] })", R"( repeated_list_value: [ { values: [ { string_value: "a"} ] } ] )"); RunValidJsonTestWithValidator("NullValueInOtherOneofOldFormat", RECOMMENDED, R"({"oneofNullValue": "NULL_VALUE"})", [](const Json::Value& value) { return (value.isMember("oneofNullValue") && value["oneofNullValue"].isNull()); }); RunValidJsonTestWithValidator("NullValueInOtherOneofNewFormat", RECOMMENDED, R"({"oneofNullValue": null})", [](const Json::Value& value) { return (value.isMember("oneofNullValue") && value["oneofNullValue"].isNull()); }); RunValidJsonTestWithValidator( "NullValueInNormalMessage", RECOMMENDED, R"({"optionalNullValue": null})", [](const Json::Value& value) { return value.empty(); }); ExpectSerializeFailureForJson("ValueRejectNanNumberValue", RECOMMENDED, "optional_value: { number_value: nan}"); ExpectSerializeFailureForJson("ValueRejectInfNumberValue", RECOMMENDED, "optional_value: { number_value: inf}"); } template void BinaryAndJsonConformanceSuiteImpl::RunJsonTestsForAny() { std::string type_url = GetTypeUrl(MessageType::GetDescriptor()); RunValidJsonTest("Any", REQUIRED, absl::Substitute(R"({ "optionalAny": { "@type": "$0", "optionalInt32": 12345 } })", GetTypeUrl(MessageType::GetDescriptor())), absl::Substitute(R"( optional_any: { [$0] { optional_int32: 12345 } } )", type_url)); RunValidJsonTest("AnyNested", REQUIRED, absl::Substitute(R"({ "optionalAny": { "@type": "type.googleapis.com/google.protobuf.Any", "value": { "@type": "$0", "optionalInt32": 12345 } } })", type_url), absl::Substitute(R"( optional_any: { [type.googleapis.com/google.protobuf.Any] { [$0] { optional_int32: 12345 } } } )", type_url)); // The special "@type" tag is not required to appear first. RunValidJsonTest("AnyUnorderedTypeTag", REQUIRED, absl::Substitute(R"({ "optionalAny": { "optionalInt32": 12345, "@type": "$0" } })", type_url), absl::Substitute(R"( optional_any: { [$0] { optional_int32: 12345 } } )", type_url)); // Well-known types in Any. RunValidJsonTest("AnyWithInt32ValueWrapper", REQUIRED, R"({ "optionalAny": { "@type": "type.googleapis.com/google.protobuf.Int32Value", "value": 12345 } })", R"( optional_any: { [type.googleapis.com/google.protobuf.Int32Value] { value: 12345 } } )"); RunValidJsonTest("AnyWithDuration", REQUIRED, R"({ "optionalAny": { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.5s" } })", R"( optional_any: { [type.googleapis.com/google.protobuf.Duration] { seconds: 1 nanos: 500000000 } } )"); RunValidJsonTest("AnyWithTimestamp", REQUIRED, R"({ "optionalAny": { "@type": "type.googleapis.com/google.protobuf.Timestamp", "value": "1970-01-01T00:00:00Z" } })", R"( optional_any: { [type.googleapis.com/google.protobuf.Timestamp] { seconds: 0 nanos: 0 } } )"); RunValidJsonTest("AnyWithFieldMask", REQUIRED, R"({ "optionalAny": { "@type": "type.googleapis.com/google.protobuf.FieldMask", "value": "foo,barBaz" } })", R"( optional_any: { [type.googleapis.com/google.protobuf.FieldMask] { paths: ["foo", "bar_baz"] } } )"); RunValidJsonTest("AnyWithStruct", REQUIRED, R"({ "optionalAny": { "@type": "type.googleapis.com/google.protobuf.Struct", "value": { "foo": 1 } } })", R"( optional_any: { [type.googleapis.com/google.protobuf.Struct] { fields: { key: "foo" value: { number_value: 1 } } } } )"); RunValidJsonTest("AnyWithValueForJsonObject", REQUIRED, R"({ "optionalAny": { "@type": "type.googleapis.com/google.protobuf.Value", "value": { "foo": 1 } } })", R"( optional_any: { [type.googleapis.com/google.protobuf.Value] { struct_value: { fields: { key: "foo" value: { number_value: 1 } } } } } )"); RunValidJsonTest("AnyWithValueForInteger", REQUIRED, R"({ "optionalAny": { "@type": "type.googleapis.com/google.protobuf.Value", "value": 1 } })", R"( optional_any: { [type.googleapis.com/google.protobuf.Value] { number_value: 1 } } )"); } template const FieldDescriptor* BinaryAndJsonConformanceSuiteImpl::GetFieldForType( FieldDescriptor::Type type, bool repeated, Packed packed) const { const Descriptor* d = MessageType::GetDescriptor(); for (int i = 0; i < d->field_count(); i++) { const FieldDescriptor* f = d->field(i); if (f->type() == type && f->is_repeated() == repeated) { if ((packed == Packed::kTrue && !f->is_packed()) || (packed == Packed::kFalse && f->is_packed())) { continue; } return f; } } absl::string_view packed_string = ""; const absl::string_view repeated_string = repeated ? "Repeated " : "Singular "; if (packed == Packed::kTrue) { packed_string = "Packed "; } if (packed == Packed::kFalse) { packed_string = "Unpacked "; } ABSL_LOG(FATAL) << "Couldn't find field with type: " << repeated_string << packed_string << FieldDescriptor::TypeName(type) << " for " << d->full_name(); return nullptr; } template const FieldDescriptor* BinaryAndJsonConformanceSuiteImpl::GetFieldForMapType( FieldDescriptor::Type key_type, FieldDescriptor::Type value_type) const { const Descriptor* d = MessageType::GetDescriptor(); for (int i = 0; i < d->field_count(); i++) { const FieldDescriptor* f = d->field(i); if (f->is_map()) { const Descriptor* map_entry = f->message_type(); const FieldDescriptor* key = map_entry->field(0); const FieldDescriptor* value = map_entry->field(1); if (key->type() == key_type && value->type() == value_type) { return f; } } } ABSL_LOG(FATAL) << "Couldn't find map field with type: " << FieldDescriptor::TypeName(key_type) << " and " << FieldDescriptor::TypeName(key_type) << " for " << d->full_name(); return nullptr; } template const FieldDescriptor* BinaryAndJsonConformanceSuiteImpl::GetFieldForOneofType( FieldDescriptor::Type type, bool exclusive) const { const Descriptor* d = MessageType::GetDescriptor(); for (int i = 0; i < d->field_count(); i++) { const FieldDescriptor* f = d->field(i); if (f->containing_oneof() && ((f->type() == type) ^ exclusive)) { return f; } } ABSL_LOG(FATAL) << "Couldn't find oneof field with type: " << FieldDescriptor::TypeName(type) << " for " << d->full_name(); return nullptr; } template std::string BinaryAndJsonConformanceSuiteImpl::SyntaxIdentifier() const { if constexpr (std::is_same::value) { return "Proto2"; } else if constexpr (std::is_same::value) { return "Proto3"; } else if constexpr (std::is_same::value) { return "Editions_Proto2"; } else { return "Editions_Proto3"; } } } // namespace protobuf } // namespace google