Google Git Google Git
Sign in
flutter/third_party/protobuf/ad2fa52bbe37b304279e38f4567f3eaadc62eb49/./conformance/binary_json_conformance_suite.cc
blob: 24a9a521183a78a8ddb1d15dcec18351a27349c8 [file]
// 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 "conformance/binary_json_conformance_suite.h"
#include <cassert>
#include <cctype>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
#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/str_format.h"
#include "absl/strings/string_view.h"
#include "absl/strings/substitute.h"
#include "json/config.h"
#include "json/reader.h"
#include "json/value.h"
#include "conformance/binary_wireformat.h"
#include "conformance/conformance.pb.h"
#include "conformance/conformance_test.h"
#include "conformance/test_protos/test_messages_edition2023.pb.h"
#include "conformance/test_protos/test_messages_edition2026.pb.h"
#include "conformance/test_protos/test_messages_edition_unstable.pb.h"
#include "editions/golden/test_messages_proto2_editions.pb.h"
#include "editions/golden/test_messages_proto3_editions.pb.h"
#include "google/protobuf/json/json.h"
#include "google/protobuf/test_messages_proto2.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/message_differencer.h"
#include "google/protobuf/util/type_resolver_util.h"
#include "google/protobuf/wire_format_lite.h"
using ::conformance::ConformanceRequest;
using ::conformance::ConformanceResponse;
using ::conformance::TestStatus;
using ::conformance::WireFormat;
using google::protobuf::Descriptor;
using google::protobuf::FieldDescriptor;
using google::protobuf::internal::WireFormatLite;
using google::protobuf::util::NewTypeResolverForDescriptorPool;
using protobuf_test_messages::edition_unstable::TestAllTypesEditionUnstable;
using protobuf_test_messages::editions::TestAllTypesEdition2023;
using protobuf_test_messages::editions::TestAllTypesEdition2026;
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());
}
std::string str_repeat(absl::string_view s, int count) {
std::string result;
for (int i = 0; i < count; ++i) {
absl::StrAppend(&result, s);
}
return result;
}
/* Routines for building arbitrary protos *************************************/
// We would use CodedOutputStream except that we want more freedom to build
// arbitrary protos (even invalid ones).
std::string varint(uint64_t x) { return google::protobuf::conformance::Varint(x).str(); }
std::string longvarint(uint64_t x, int extra) {
return google::protobuf::conformance::LongVarint(x, extra).str();
}
std::string delim(const std::string& buf) {
return google::protobuf::conformance::LengthPrefixed(buf).str();
}
std::string u32(uint32_t u32) {
return google::protobuf::conformance::Fixed32(u32).str();
}
std::string u64(uint64_t u64) {
return google::protobuf::conformance::Fixed64(u64).str();
}
std::string flt(float f) { return google::protobuf::conformance::Float(f).str(); }
std::string dbl(double d) { return google::protobuf::conformance::Double(d).str(); }
std::string zz32(int32_t x) { return google::protobuf::conformance::SInt32(x).str(); }
std::string zz64(int64_t x) { return google::protobuf::conformance::SInt64(x).str(); }
std::string tag(uint32_t fieldnum, char wire_type) {
return google::protobuf::conformance::Tag(
fieldnum, static_cast<google::protobuf::conformance::WireType>(wire_type))
.str();
}
std::string tag(int fieldnum, char wire_type) {
return tag(static_cast<uint32_t>(fieldnum), wire_type);
}
std::string field(uint32_t fieldnum, char wire_type, std::string content) {
return absl::StrCat(tag(fieldnum, wire_type), content);
}
std::string group(uint32_t fieldnum, absl::string_view content) {
return google::protobuf::conformance::DelimitedField(fieldnum,
google::protobuf::conformance::Wire(content))
.str();
}
std::string len(uint32_t fieldnum, std::string content) {
return google::protobuf::conformance::LengthPrefixedField(fieldnum, std::move(content))
.str();
}
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;
}
std::string MismatchedWireTypeField(
int field_number, WireFormatLite::WireType correct_wire_type) {
if (correct_wire_type == WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
return absl::StrCat(tag(field_number, WireFormatLite::WIRETYPE_VARINT),
varint(1));
}
return absl::StrCat(
tag(field_number, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim("a"));
}
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 {
namespace conformance {
bool BinaryAndJsonConformanceSuite::ParseJsonResponse(
const ConformanceResponse& response, Message* test_message) {
json::ParseOptions options;
options.allow_legacy_nonconformant_behavior = false;
absl::Status status =
json::JsonStringToMessage(response.json_payload(), test_message);
if (!status.ok()) {
ABSL_LOG(ERROR) << status;
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();
TestStatus test;
test.set_name(test_name);
switch (response.result_case()) {
case ConformanceResponse::kProtobufPayload: {
if (requested_output != ::conformance::PROTOBUF) {
test.set_failure_message(absl::StrCat(
"Test was asked for ", WireFormatToString(requested_output),
" output but provided PROTOBUF instead."));
ReportFailure(test, level, request, response);
return false;
}
if (!test_message->ParseFromString(response.protobuf_payload())) {
test.set_failure_message(
"Protobuf output we received from test was unparseable.");
ReportFailure(test, level, request, response);
return false;
}
break;
}
case ConformanceResponse::kJsonPayload: {
if (requested_output != ::conformance::JSON) {
test.set_failure_message(absl::StrCat(
"Test was asked for ", WireFormatToString(requested_output),
" output but provided JSON instead."));
ReportFailure(test, level, request, response);
return false;
}
if (!ParseJsonResponse(response, test_message)) {
test.set_failure_message(
"JSON output we received from test was unparseable.");
ReportFailure(test, level, request, response);
return false;
}
break;
}
default:
ABSL_LOG(FATAL) << test_name
<< ": unknown payload type: " << response.result_case()
<< ", response: " << response;
}
return true;
}
void BinaryAndJsonConformanceSuite::RunSuiteImpl() {
type_resolver_.reset(NewTypeResolverForDescriptorPool(
kTypeUrlPrefix, DescriptorPool::generated_pool()));
BinaryAndJsonConformanceSuiteImpl<TestAllTypesProto3>(
this, /*run_proto3_tests=*/true);
BinaryAndJsonConformanceSuiteImpl<TestAllTypesProto2>(
this, /*run_proto3_tests=*/false);
if (!this->performance_) {
RunMessageSetTests();
} else {
RunRecursionLimitTests();
}
if (maximum_edition_ >= Edition::EDITION_2023) {
BinaryAndJsonConformanceSuiteImpl<TestAllTypesProto3Editions>(
this, /*run_proto3_tests=*/true);
BinaryAndJsonConformanceSuiteImpl<TestAllTypesProto2Editions>(
this, /*run_proto3_tests=*/false);
if (!this->performance_) {
RunDelimitedFieldTests();
RunUnstableTests();
if (maximum_edition_ >= Edition::EDITION_2026) {
RunEdition2026Tests();
}
RunUtf8ValidationTests();
}
}
}
void BinaryAndJsonConformanceSuite::RunDelimitedFieldTests() {
SetTypeUrl(GetTypeUrl(TestAllTypesEdition2023::GetDescriptor()));
RunValidProtobufTest<TestAllTypesEdition2023>(
absl::StrCat("ValidNonMessage"), REQUIRED,
field(1, WireFormatLite::WIRETYPE_VARINT, varint(99)),
R"pb(optional_int32: 99)pb");
RunValidProtobufTest<TestAllTypesEdition2023>(
absl::StrCat("ValidLengthPrefixedField"), REQUIRED,
len(18, field(1, WireFormatLite::WIRETYPE_VARINT, varint(99))),
R"pb(optional_nested_message { a: 99 })pb");
RunValidProtobufTest<TestAllTypesEdition2023>(
absl::StrCat("ValidMap.Integer"), REQUIRED,
len(56,
absl::StrCat(field(1, WireFormatLite::WIRETYPE_VARINT, varint(99)),
field(2, WireFormatLite::WIRETYPE_VARINT, varint(87)))),
R"pb(map_int32_int32 { key: 99 value: 87 })pb");
RunValidProtobufTest<TestAllTypesEdition2023>(
absl::StrCat("ValidMap.LengthPrefixed"), REQUIRED,
len(71, absl::StrCat(len(1, "a"),
len(2, field(1, WireFormatLite::WIRETYPE_VARINT,
varint(87))))),
R"pb(map_string_nested_message {
key: "a"
value: { a: 87 }
})pb");
RunValidProtobufTest<TestAllTypesEdition2023>(
absl::StrCat("ValidDelimitedField.GroupLike"), REQUIRED,
group(201, field(202, WireFormatLite::WIRETYPE_VARINT, varint(99))),
R"pb(groupliketype { group_int32: 99 })pb");
RunValidProtobufTest<TestAllTypesEdition2023>(
absl::StrCat("ValidDelimitedField.NotGroupLike"), REQUIRED,
group(202, field(202, WireFormatLite::WIRETYPE_VARINT, varint(99))),
R"pb(delimited_field { group_int32: 99 })pb");
// Note: extensions don't work with TypeResolver, which is used by
// binary->JSON tests.
RunValidBinaryProtobufTest<TestAllTypesEdition2023>(
absl::StrCat("ValidDelimitedExtension.GroupLike"), REQUIRED,
group(121, field(1, WireFormatLite::WIRETYPE_VARINT, varint(99))),
R"pb([protobuf_test_messages.editions.groupliketype] { c: 99 })pb");
RunValidBinaryProtobufTest<TestAllTypesEdition2023>(
absl::StrCat("ValidDelimitedExtension.NotGroupLike"), REQUIRED,
group(122, field(1, WireFormatLite::WIRETYPE_VARINT, varint(99))),
R"pb([protobuf_test_messages.editions.delimited_ext] { c: 99 })pb");
}
void BinaryAndJsonConformanceSuite::RunUnstableTests() {
SetTypeUrl(GetTypeUrl(TestAllTypesEditionUnstable::GetDescriptor()));
RunValidProtobufTest<TestAllTypesEditionUnstable>(
absl::StrCat("ValidBytes"), REQUIRED, len(13, "foo"),
R"pb(optional_bytes: "foo")pb");
RunValidProtobufTest<TestAllTypesEditionUnstable>(
absl::StrCat("ValidMap.Bytes"), REQUIRED,
len(15, absl::StrCat(len(1, "foo"), len(2, "barbaz"))),
R"pb(map_string_bytes { key: "foo" value: "barbaz" })pb");
}
void BinaryAndJsonConformanceSuite::RunEdition2026Tests() {
SetTypeUrl(GetTypeUrl(TestAllTypesEdition2026::GetDescriptor()));
RunValidProtobufTest<TestAllTypesEdition2026>(
absl::StrCat("ValidInt32"), REQUIRED,
field(1, WireFormatLite::WIRETYPE_VARINT, varint(99)),
R"pb(optional_int32: 99)pb");
// The (pb.enumvalue.json) option overrides the name used for an enum value
// in JSON.
RunValidJsonTest<TestAllTypesEdition2026>(
"EnumValueCustomJsonName", REQUIRED,
R"({"optionalForeignEnum": "customBar"})",
"optional_foreign_enum: FOREIGN_ENUM_EDITION2026_BAR");
// Using the original enum value name in JSON is also allowed.
RunValidJsonTest<TestAllTypesEdition2026>(
"EnumValueCustomJsonNameOriginalName", REQUIRED,
R"({"optionalForeignEnum": "FOREIGN_ENUM_EDITION2026_BAR"})",
"optional_foreign_enum: FOREIGN_ENUM_EDITION2026_BAR");
RunValidJsonTest<TestAllTypesEdition2026>(
"EnumValueCustomJsonNameNumericValue", REQUIRED,
R"({"optionalForeignEnum": 1})",
"optional_foreign_enum: FOREIGN_ENUM_EDITION2026_BAR");
RunValidJsonTest<TestAllTypesEdition2026>(
"RepeatedEnumValueCustomJsonName", REQUIRED,
R"({"repeatedForeignEnum": ["customBar", "FOREIGN_ENUM_EDITION2026_BAZ", "customBaz"]})",
R"(
repeated_foreign_enum: FOREIGN_ENUM_EDITION2026_BAR
repeated_foreign_enum: FOREIGN_ENUM_EDITION2026_BAZ
repeated_foreign_enum: FOREIGN_ENUM_EDITION2026_BAZ
)");
RunValidJsonTest<TestAllTypesEdition2026>(
"MapEnumValueCustomJsonName", REQUIRED,
R"({"mapStringForeignEnum": {"a": "customBar", "b": "FOREIGN_ENUM_EDITION2026_BAZ"}})",
R"(
map_string_foreign_enum { key: "a" value: FOREIGN_ENUM_EDITION2026_BAR }
map_string_foreign_enum { key: "b" value: FOREIGN_ENUM_EDITION2026_BAZ }
)");
// Unknown names that are neither a declared name nor a custom JSON name.
ExpectParseFailureForJson<TestAllTypesEdition2026>(
"EnumValueUnknownCustomJsonName", REQUIRED,
R"({"optionalForeignEnum": "customQux"})");
ExpectParseFailureForJson<TestAllTypesEdition2026>(
"EnumValueUnknownOriginalName", REQUIRED,
R"({"optionalForeignEnum": "FOREIGN_ENUM_EDITION2026_QUX"})");
// Empty custom JSON name.
RunValidJsonTest<TestAllTypesEdition2026>(
"EnumValueEmptyCustomJsonName", REQUIRED,
R"({"optionalForeignEnum": ""})",
"optional_foreign_enum: FOREIGN_ENUM_EDITION2026_EMPTY");
RunValidJsonTestWithValidator<TestAllTypesEdition2026>(
"EnumValueEmptyCustomJsonNameOutput", REQUIRED,
R"({"optionalForeignEnum": "FOREIGN_ENUM_EDITION2026_EMPTY"})",
[](const Json::Value& value) {
return value["optionalForeignEnum"].isString() &&
value["optionalForeignEnum"].asString().empty();
});
// Custom JSON name with characters that require escaping in JSON.
RunValidJsonTest<TestAllTypesEdition2026>(
"EnumValueEscapedCustomJsonName", REQUIRED,
R"({"optionalForeignEnum": "e\"sc\tap\ne"})",
"optional_foreign_enum: FOREIGN_ENUM_EDITION2026_ESCAPES");
RunValidJsonTestWithValidator<TestAllTypesEdition2026>(
"EnumValueEscapedCustomJsonNameOutput", REQUIRED,
R"({"optionalForeignEnum": "FOREIGN_ENUM_EDITION2026_ESCAPES"})",
[](const Json::Value& value) {
return value["optionalForeignEnum"].asString() == "e\"sc\tap\ne";
});
// Aliased values share a custom JSON name, and their declared names both
// still parse.
RunValidJsonTest<TestAllTypesEdition2026>(
"EnumValueAliasCustomJsonName", REQUIRED,
R"({"optionalForeignEnum": "customAlias"})",
"optional_foreign_enum: FOREIGN_ENUM_EDITION2026_ALIAS");
RunValidJsonTest<TestAllTypesEdition2026>(
"EnumValueAliasCustomJsonNameOriginalName", REQUIRED,
R"({"optionalForeignEnum": "FOREIGN_ENUM_EDITION2026_ALIAS_TOO"})",
"optional_foreign_enum: FOREIGN_ENUM_EDITION2026_ALIAS");
RunValidJsonTestWithValidator<TestAllTypesEdition2026>(
"EnumValueAliasCustomJsonNameOutput", REQUIRED,
R"({"optionalForeignEnum": "FOREIGN_ENUM_EDITION2026_ALIAS"})",
[](const Json::Value& value) {
return value["optionalForeignEnum"].asString() == "customAlias";
});
// A numeric-looking custom JSON name serializes as a JSON string, and both
// the string and the integer forms parse.
RunValidJsonTest<TestAllTypesEdition2026>(
"EnumValueNumericCustomJsonName", REQUIRED,
R"({"optionalForeignEnum": "6"})",
"optional_foreign_enum: FOREIGN_ENUM_EDITION2026_NUMERIC");
RunValidJsonTest<TestAllTypesEdition2026>(
"EnumValueNumericCustomJsonNameIntegerValue", REQUIRED,
R"({"optionalForeignEnum": 6})",
"optional_foreign_enum: FOREIGN_ENUM_EDITION2026_NUMERIC");
RunValidJsonTestWithValidator<TestAllTypesEdition2026>(
"EnumValueNumericCustomJsonNameOutput", REQUIRED,
R"({"optionalForeignEnum": "FOREIGN_ENUM_EDITION2026_NUMERIC"})",
[](const Json::Value& value) {
return value["optionalForeignEnum"].isString() &&
value["optionalForeignEnum"].asString() == "6";
});
RunValidJsonTestWithValidator<TestAllTypesEdition2026>(
"EnumValueCustomJsonNameOutput", REQUIRED,
R"({"optionalForeignEnum": "FOREIGN_ENUM_EDITION2026_BAR"})",
[](const Json::Value& value) {
return value["optionalForeignEnum"].asString() == "customBar";
});
// A value without the option keeps using its declared name in JSON.
RunValidJsonTestWithValidator<TestAllTypesEdition2026>(
"EnumValueWithoutCustomJsonNameOutput", REQUIRED,
R"({"repeatedForeignEnum": ["FOREIGN_ENUM_EDITION2026_FOO"]})",
[](const Json::Value& value) {
return value["repeatedForeignEnum"][0].asString() ==
"FOREIGN_ENUM_EDITION2026_FOO";
});
}
void BinaryAndJsonConformanceSuite::RunUtf8ValidationTests() {
ExpectParseFailureForProto<TestAllTypesEdition2023>(
len(133, "\xA0\xB0\xC0\xD0"), "RejectInvalidUtf8.String.Extension",
RECOMMENDED);
RunValidBinaryProtobufTest<
TestAllTypesEdition2023>(absl::StrCat(
"AcceptInvalidUtf8.Bytes.Extension"),
REQUIRED, len(134, "\xA0\xB0\xC0\xD0"),
R"pb([protobuf_test_messages.editions
.extension_bytes]: "\xA0\xB0\xC0\xD0")pb");
}
void BinaryAndJsonConformanceSuite::RunMessageSetTests() {
RunValidBinaryProtobufTest<TestAllTypesProto2>(
absl::StrCat("ValidMessageSetEncoding"), REQUIRED,
len(500,
group(1, absl::StrCat(field(2, WireFormatLite::WIRETYPE_VARINT,
varint(4135312)),
len(3, field(9, WireFormatLite::WIRETYPE_VARINT,
varint(99)))))),
// clang-format off
R"pb(message_set_correct: {
[protobuf_test_messages.proto2
.TestAllTypesProto2.MessageSetCorrectExtension2]: { i: 99 }
})pb"
// clang-format on
);
RunValidBinaryProtobufTest<TestAllTypesProto2>(
absl::StrCat("ValidMessageSetEncoding.OutOfOrderGroupsEntries"), REQUIRED,
len(500,
group(1, absl::StrCat(len(3, field(9, WireFormatLite::WIRETYPE_VARINT,
varint(99))),
field(2, WireFormatLite::WIRETYPE_VARINT,
varint(4135312))))),
// clang-format off
R"pb(message_set_correct: {
[protobuf_test_messages.proto2
.TestAllTypesProto2.MessageSetCorrectExtension2]: { i: 99 }
})pb"
// clang-format on
);
// Test that an unknown message set extension always goes to unknown fields.
// This is done by poisoning the extension payload with an entry for field 0.
RunValidRoundtripProtobufTest<TestAllTypesProto2>(
"MessageSetEncoding.UnknownExtension", REQUIRED,
len(500,
group(1, absl::StrCat(field(2, WireFormatLite::WIRETYPE_VARINT,
varint(4135300)),
len(3, field(0, WireFormatLite::WIRETYPE_VARINT,
varint(99)))))));
// If an encoder is unaware of the message_set_wire_format option it will be
// encoded like any other extension submessage. Decoders should be able to
// tolerate this format as well.
RunValidBinaryProtobufTest<TestAllTypesProto2>(
absl::StrCat("ValidMessageSetEncoding.SubmessageEncoding"), RECOMMENDED,
len(500,
len(4135312, field(9, WireFormatLite::WIRETYPE_VARINT, varint(99)))),
// clang-format off
R"pb(message_set_correct: {
[protobuf_test_messages.proto2
.TestAllTypesProto2.MessageSetCorrectExtension2]: { i: 99 }
})pb"
// clang-format on
);
// Test again, but this time we'll try to detect if the implementation put the
// submessage encoded entry into the unknown field set. We'll do this by using
// conflicting oneof entries where order matters when the messages are merged.
//
// In a non-compliant implementation submessage encoded messageset entry will
// be moved to unknown fields and then tacked onto the end of the payload.
// Thus we'll see field b set first, and then field a.
//
// In a compliant implementation we expect the submessage encoded messageset
// to be read first with field a set, and then the normal message set entry
// will be read with field b will be set -- thus field b will win.
RunValidBinaryProtobufTest<TestAllTypesProto2>(
absl::StrCat("ValidMessageSetEncoding.SubmessageEncoding.NotUnknown"),
RECOMMENDED,
len(500, absl::StrCat(
len(123456789,
field(1, WireFormatLite::WIRETYPE_VARINT, varint(42))),
group(1, absl::StrCat(
field(2, WireFormatLite::WIRETYPE_VARINT,
varint(123456789)),
len(3, field(2, WireFormatLite::WIRETYPE_VARINT,
varint(99))))))),
// clang-format off
R"pb(message_set_correct: {
[protobuf_test_messages.proto2
.TestAllTypesProto2.ExtensionWithOneof]: { b: 99 }
})pb"
// clang-format on
);
// [type_id, value, type_id (different)] -> first type_id and value honored.
RunValidBinaryProtobufTest<TestAllTypesProto2>(
absl::StrCat("ValidMessageSetEncoding.DuplicateDifferentTypeId"),
RECOMMENDED,
len(500,
group(
1,
absl::StrCat(
field(2, WireFormatLite::WIRETYPE_VARINT, varint(4135312)),
len(3, field(9, WireFormatLite::WIRETYPE_VARINT, varint(99))),
field(2, WireFormatLite::WIRETYPE_VARINT, varint(1547769))))),
// clang-format off
R"pb(message_set_correct: {
[protobuf_test_messages.proto2
.TestAllTypesProto2.MessageSetCorrectExtension2]: { i: 99 }
})pb"
// clang-format on
);
// [type_id, value, value] -> first value honored, no merge.
RunValidBinaryProtobufTest<TestAllTypesProto2>(
absl::StrCat("ValidMessageSetEncoding.DuplicateValue"), RECOMMENDED,
len(500,
group(
1,
absl::StrCat(
field(2, WireFormatLite::WIRETYPE_VARINT, varint(4135312)),
len(3, field(9, WireFormatLite::WIRETYPE_VARINT, varint(99))),
len(3,
field(9, WireFormatLite::WIRETYPE_VARINT, varint(88)))))),
// clang-format off
R"pb(message_set_correct: {
[protobuf_test_messages.proto2
.TestAllTypesProto2.MessageSetCorrectExtension2]: { i: 99 }
})pb"
// clang-format on
);
// [value, type_id, value] -> first value honored, no merge.
RunValidBinaryProtobufTest<TestAllTypesProto2>(
absl::StrCat("ValidMessageSetEncoding.DuplicateValueOutOfOrder"),
RECOMMENDED,
len(500,
group(
1,
absl::StrCat(
len(3, field(9, WireFormatLite::WIRETYPE_VARINT, varint(99))),
field(2, WireFormatLite::WIRETYPE_VARINT, varint(4135312)),
len(3,
field(9, WireFormatLite::WIRETYPE_VARINT, varint(88)))))),
// clang-format off
R"pb(message_set_correct: {
[protobuf_test_messages.proto2
.TestAllTypesProto2.MessageSetCorrectExtension2]: { i: 99 }
})pb"
// clang-format on
);
}
void BinaryAndJsonConformanceSuite::RunRecursionLimitTests() {
{
TestAllTypesEdition2023 message;
TestAllTypesEdition2023* sub = &message;
// The default recursion limit is 100 for most languages. 10,000 for
// golang. We use a larger number here for test.
for (int i = 0; i < 20000; i++) {
sub = &(*sub->mutable_map_recursive())[0];
sub->set_optional_int32(123);
}
ExpectParseFailureForProto<TestAllTypesEdition2023>(
message.SerializeAsString(), "EnforceDepthLimit.Map", RECOMMENDED);
}
{
TestAllTypesEdition2023 message;
TestAllTypesEdition2023* sub = &message;
for (int i = 0; i < 10000; i++) {
sub =
(*sub->mutable_map_string_nested_message())[""].mutable_corecursive();
sub->set_optional_int32(123);
}
ExpectParseFailureForProto<TestAllTypesEdition2023>(
message.SerializeAsString(), "EnforceDepthLimit.MapStringKey",
RECOMMENDED);
}
{
TestAllTypesProto2 proto2_msg;
auto sub = proto2_msg.mutable_message_set_correct();
// The default recursion limit is 100 for most languages. 10,000 for
// golang. We use a larger number here for test.
for (int i = 0; i < 20000; i++) {
sub = sub->MutableExtension(
TestAllTypesProto2::MessageSetCorrectExtension2::
message_set_extension)
->mutable_sub_msg();
}
sub->MutableExtension(TestAllTypesProto2::MessageSetCorrectExtension2::
message_set_extension)
->set_i(123);
ExpectParseFailureForProto<TestAllTypesProto2>(
proto2_msg.SerializeAsString(), "EnforceDepthLimit.MessageSetExtension",
RECOMMENDED);
}
}
template <typename MessageType>
void BinaryAndJsonConformanceSuite::ExpectParseFailureForProto(
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);
if (!RunTest(effective_test_name, request, &response)) {
return;
}
TestStatus test;
test.set_name(effective_test_name);
if (response.result_case() == ConformanceResponse::kParseError) {
ReportSuccess(test);
} else if (response.result_case() == ConformanceResponse::kSkipped) {
ReportSkip(test, request, response);
} else if (response.result_case() == ConformanceResponse::kRuntimeError) {
test.set_failure_message(
"Should have failed to parse, but raised an error instead.");
ReportFailure(test, level, request, response);
} else {
test.set_failure_message("Should have failed to parse, but didn't.");
ReportFailure(test, level, request, response);
}
}
template <typename MessageType>
void BinaryAndJsonConformanceSuite::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);
}
void BinaryAndJsonConformanceSuite::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);
RunValidInputTest(setting1, equivalent_text_format);
ConformanceRequestSetting setting2(
level, ::conformance::JSON, ::conformance::JSON, ::conformance::JSON_TEST,
prototype, test_name, input_json);
RunValidInputTest(setting2, equivalent_text_format);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuite::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 JSON
// 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), ".",
setting.GetSyntaxIdentifier(), ".JsonInput.", test_name);
if (!RunTest(effective_test_name, request, &response)) {
return;
}
TestStatus test;
test.set_name(effective_test_name);
if (response.result_case() == ConformanceResponse::kParseError) {
ReportSuccess(test);
} else if (response.result_case() == ConformanceResponse::kSkipped) {
ReportSkip(test, request, response);
} else if (response.result_case() == ConformanceResponse::kRuntimeError) {
test.set_failure_message(
"Should have failed to parse, but raised an error instead.");
ReportFailure(test, level, request, response);
} else {
test.set_failure_message("Should have failed to parse, but didn't.");
ReportFailure(test, level, request, response);
}
}
template <typename MessageType>
void BinaryAndJsonConformanceSuite::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;
const std::string& effective_test_name = setting.GetTestName();
if (!RunTest(effective_test_name, request, &response)) {
return;
}
TestStatus test;
test.set_name(effective_test_name);
if (response.result_case() == ConformanceResponse::kSkipped) {
ReportSkip(test, request, response);
return;
}
if (response.result_case() != ConformanceResponse::kJsonPayload) {
test.set_failure_message(absl::StrCat("Expected JSON payload but got type ",
response.result_case()));
ReportFailure(test, level, request, response);
return;
}
Json::CharReaderBuilder builder;
Json::Value value;
Json::String err;
const std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
if (!reader->parse(
response.json_payload().c_str(),
response.json_payload().c_str() + response.json_payload().length(),
&value, &err)) {
test.set_failure_message(
absl::StrCat("JSON payload cannot be parsed as valid JSON: ", err));
ReportFailure(test, level, request, response);
return;
}
if (!validator(value)) {
test.set_failure_message("JSON payload validation failed.");
ReportFailure(test, level, request, response);
return;
}
ReportSuccess(test);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::
ExpectParseFailureForProtoWithProtoVersion(const std::string& proto,
const std::string& test_name,
ConformanceLevel level) {
suite_.ExpectParseFailureForProto<MessageType>(proto, test_name, level);
}
// Expect that this precise protobuf will cause a parse error.
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<
MessageType>::ExpectHardParseFailureForProto(const std::string& proto,
const std::string& test_name,
ConformanceLevel level) {
return ExpectParseFailureForProto(proto, test_name, level);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::
RunValidJsonTestWithMessage(const std::string& test_name,
ConformanceLevel level,
const std::string& input_json,
const std::string& equivalent_text_format,
const Message& prototype) {
suite_.RunValidJsonTestWithMessage(test_name, level, input_json,
equivalent_text_format, prototype);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::
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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::
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 <typename MessageType>
void BinaryAndJsonConformanceSuite::RunValidBinaryProtobufTest(
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);
RunValidInputTest(binary_to_binary, equivalent_text_format);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuite::RunValidRoundtripProtobufTest(
const std::string& test_name, ConformanceLevel level,
const std::string& input_protobuf) {
MessageType prototype;
ConformanceRequestSetting binary_to_binary(
level, ::conformance::PROTOBUF, ::conformance::PROTOBUF,
::conformance::BINARY_TEST, prototype, test_name, input_protobuf);
RunValidBinaryInputTest(binary_to_binary, input_protobuf);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuite::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);
RunValidInputTest(binary_to_binary, equivalent_text_format);
ConformanceRequestSetting binary_to_json(
level, ::conformance::PROTOBUF, ::conformance::JSON,
::conformance::BINARY_TEST, prototype, test_name, input_protobuf);
RunValidInputTest(binary_to_json, equivalent_text_format);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::RunValidProtobufTest(
const std::string& test_name, ConformanceLevel level,
const std::string& input_protobuf,
const std::string& equivalent_text_format) {
suite_.RunValidProtobufTest<MessageType>(test_name, level, input_protobuf,
equivalent_text_format);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::RunValidBinaryProtobufTest(
const std::string& test_name, ConformanceLevel level,
const std::string& input_protobuf) {
RunValidBinaryProtobufTest(test_name, level, input_protobuf, input_protobuf);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::
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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::
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
// the JSON output directly.
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<
MessageType>::RunValidJsonTestWithValidator(const std::string& test_name,
ConformanceLevel level,
const std::string& input_json,
const Validator& validator) {
suite_.RunValidJsonTestWithValidator<MessageType>(test_name, level,
input_json, validator);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::ExpectParseFailureForJson(
const std::string& test_name, ConformanceLevel level,
const std::string& input_json) {
suite_.ExpectParseFailureForJson<MessageType>(test_name, level, input_json);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::
RunValidJsonTestOrParseFailure(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_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);
if (!suite_.RunTest(effective_test_name, request, &response)) {
return;
}
TestStatus test;
test.set_name(effective_test_name);
if (response.result_case() == ConformanceResponse::kParseError) {
suite_.ReportSuccess(test);
} else if (response.result_case() == ConformanceResponse::kSkipped) {
suite_.ReportSkip(test, request, response);
} else {
std::unique_ptr<Message> reference_message(setting.NewTestMessage());
ABSL_CHECK(TextFormat::ParseFromString(equivalent_text_format,
reference_message.get()))
<< "Failed to parse data for test case: " << setting.GetTestName()
<< ", data: " << equivalent_text_format;
std::unique_ptr<Message> test_message(setting.NewTestMessage());
bool parsed = false;
if (response.result_case() == ConformanceResponse::kProtobufPayload) {
parsed = test_message->ParseFromString(response.protobuf_payload());
}
if (!parsed) {
test.set_failure_message("Malformed protobuf response");
suite_.ReportFailure(test, level, request, response);
return;
}
util::MessageDifferencer differencer;
util::DefaultFieldComparator field_comparator;
field_comparator.set_treat_nan_as_equal(true);
differencer.set_field_comparator(&field_comparator);
std::string differences;
differencer.ReportDifferencesToString(&differences);
if (differencer.Compare(*reference_message, *test_message)) {
suite_.ReportSuccess(test);
} else {
test.set_failure_message(
"Should have failed to parse or matched expected output but did "
"not.");
suite_.ReportFailure(test, level, request, response);
}
}
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::
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;
const std::string& effective_test_name = setting.GetTestName();
if (!suite_.RunTest(effective_test_name, request, &response)) {
return;
}
TestStatus test;
test.set_name(effective_test_name);
if (response.result_case() == ConformanceResponse::kSerializeError) {
suite_.ReportSuccess(test);
} else if (response.result_case() == ConformanceResponse::kSkipped) {
suite_.ReportSkip(test, request, response);
} else if (response.result_case() == ConformanceResponse::kRuntimeError) {
test.set_failure_message(
"Should have failed to serialize, but raised an error instead.");
suite_.ReportFailure(test, level, request, response);
} else {
test.set_failure_message("Should have failed to serialize, but didn't.");
suite_.ReportFailure(test, level, request, response);
}
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::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<WireFormatLite::FieldType>(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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::TestValidDataForType(
FieldDescriptor::Type type,
std::vector<std::pair<std::string, std::string>> values) {
const std::string type_name =
UpperCase(absl::StrCat(".", FieldDescriptor::TypeName(type)));
WireFormatLite::WireType wire_type = WireFormatLite::WireTypeForFieldType(
static_cast<WireFormatLite::FieldType>(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;
ABSL_CHECK(test_message.MergeFromString(expected_proto));
std::string text;
ABSL_CHECK(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++) {
absl::StrAppend(&proto, 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;
ABSL_CHECK(test_message.MergeFromString(expected_proto));
std::string text;
ABSL_CHECK(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++) {
absl::StrAppend(&default_proto_unpacked,
tag(rep_field->number(), wire_type), values[i].first);
absl::StrAppend(&default_proto_unpacked_expected,
tag(rep_field->number(), wire_type), values[i].second);
default_proto_packed += values[i].first;
default_proto_packed_expected += values[i].second;
absl::StrAppend(&packed_proto_unpacked,
tag(packed_field->number(), wire_type), values[i].first);
packed_proto_packed += values[i].first;
packed_proto_expected += values[i].second;
absl::StrAppend(&unpacked_proto_unpacked,
tag(unpacked_field->number(), wire_type),
values[i].first);
unpacked_proto_packed += values[i].first;
absl::StrAppend(&unpacked_proto_expected,
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;
ABSL_CHECK(test_message.MergeFromString(default_proto_packed_expected));
std::string text;
ABSL_CHECK(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;
ABSL_CHECK(test_message.MergeFromString(expected_proto));
std::string text;
ABSL_CHECK(TextFormat::PrintToString(test_message, &text));
RunValidProtobufTest(absl::StrCat("ValidDataRepeated", type_name), REQUIRED,
proto, text);
}
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<
MessageType>::TestValidDataForRepeatedScalarMessage() {
std::vector<std::string> 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++) {
absl::StrAppend(
&proto, tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
values[i]);
}
RunValidProtobufTest("RepeatedScalarMessageMerge", REQUIRED, proto,
absl::StrCat(field->name(), ": ", expected));
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::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<WireFormatLite::FieldType>(key_type));
WireFormatLite::WireType value_wire_type =
WireFormatLite::WireTypeForFieldType(
static_cast<WireFormatLite::FieldType>(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;
ABSL_CHECK(test_message.MergeFromString(proto));
std::string text;
ABSL_CHECK(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;
ABSL_CHECK(test_message.MergeFromString(proto));
std::string text;
ABSL_CHECK(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;
ABSL_CHECK(test_message.MergeFromString(proto));
std::string text;
ABSL_CHECK(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;
ABSL_CHECK(test_message.MergeFromString(proto));
std::string text;
ABSL_CHECK(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;
ABSL_CHECK(test_message.MergeFromString(proto2));
std::string text;
ABSL_CHECK(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;
ABSL_CHECK(test_message.MergeFromString(proto));
std::string text;
ABSL_CHECK(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;
ABSL_CHECK(test_message.MergeFromString(proto));
std::string text;
ABSL_CHECK(TextFormat::PrintToString(test_message, &text));
RunValidProtobufTest(
absl::StrCat("ValidDataMap", key_type_name, value_type_name,
".DuplicateValueInMapEntry"),
REQUIRED, proto, text);
}
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<
MessageType>::RunMapEntryWireTypeMismatchTest(const std::string& test_name,
const std::string& proto) {
MessageType prototype;
ConformanceRequestSetting setting(
RECOMMENDED, ::conformance::PROTOBUF, ::conformance::PROTOBUF,
::conformance::BINARY_TEST, prototype, test_name, proto);
const ConformanceRequest& request = setting.GetRequest();
ConformanceResponse response;
if (!suite_.RunTest(setting.GetTestName(), request, &response)) {
return;
}
TestStatus test;
test.set_name(setting.GetTestName());
if (response.result_case() == ConformanceResponse::kSkipped) {
suite_.ReportSkip(test, request, response);
} else if (response.result_case() == ConformanceResponse::kParseError) {
suite_.ReportSuccess(test);
} else if (response.result_case() == ConformanceResponse::kProtobufPayload) {
MessageType reference;
ABSL_CHECK(reference.MergeFromString(proto));
MessageType response_message;
if (suite_.ParseResponse(response, setting, &response_message)) {
if (google::protobuf::util::MessageDifferencer::Equals(reference,
response_message)) {
suite_.ReportSuccess(test);
} else {
test.set_failure_message(
"Output was not equivalent to reference message; the mismatched "
"field appears to have been decoded as a value.");
suite_.ReportFailure(test, setting.GetLevel(), request, response);
}
}
} else {
test.set_failure_message(
"Should have failed to parse or matched expected output but did "
"not.");
suite_.ReportFailure(test, setting.GetLevel(), request, response);
}
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::
TestMapEntryWireTypeMismatch(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)));
const WireFormatLite::WireType key_wire_type =
WireFormatLite::WireTypeForFieldType(
static_cast<WireFormatLite::FieldType>(key_type));
const WireFormatLite::WireType value_wire_type =
WireFormatLite::WireTypeForFieldType(
static_cast<WireFormatLite::FieldType>(value_type));
const std::string good_key_data =
absl::StrCat(tag(1, key_wire_type), GetNonDefaultValue(key_type));
const std::string good_value_data =
absl::StrCat(tag(2, value_wire_type), GetNonDefaultValue(value_type));
const FieldDescriptor* field = GetFieldForMapType(key_type, value_type);
// A map entry whose key is encoded with the wrong wire type; the value is
// still well formed.
RunMapEntryWireTypeMismatchTest(
absl::StrCat("ValidDataMap", key_type_name, value_type_name,
".KeyWireTypeMismatch"),
absl::StrCat(
tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
delim(absl::StrCat(MismatchedWireTypeField(1, key_wire_type),
good_value_data))));
// A map entry whose value is encoded with the wrong wire type; the key is
// still well formed.
RunMapEntryWireTypeMismatchTest(
absl::StrCat("ValidDataMap", key_type_name, value_type_name,
".ValueWireTypeMismatch"),
absl::StrCat(
tag(field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
delim(absl::StrCat(good_key_data,
MismatchedWireTypeField(2, value_wire_type)))));
}
template <typename MessageType>
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;
ABSL_CHECK(test_message.MergeFromString(proto2));
std::string text;
ABSL_CHECK(TextFormat::PrintToString(test_message, &text));
RunValidProtobufTest("ValidDataMap.STRING.MESSAGE.MergeValue", REQUIRED,
proto, text);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::TestValidDataForOneofType(
FieldDescriptor::Type type) {
const std::string type_name =
UpperCase(absl::StrCat(".", FieldDescriptor::TypeName(type)));
WireFormatLite::WireType wire_type = WireFormatLite::WireTypeForFieldType(
static_cast<WireFormatLite::FieldType>(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;
ABSL_CHECK(test_message.MergeFromString(proto));
std::string text;
ABSL_CHECK(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;
ABSL_CHECK(test_message.MergeFromString(proto));
std::string text;
ABSL_CHECK(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;
ABSL_CHECK(test_message.MergeFromString(expected_proto));
std::string text;
ABSL_CHECK(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<WireFormatLite::FieldType>(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;
ABSL_CHECK(test_message.MergeFromString(expected_proto));
std::string text;
ABSL_CHECK(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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::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;
ABSL_CHECK(test_message.MergeFromString(expected_proto));
std::string text;
ABSL_CHECK(TextFormat::PrintToString(test_message, &text));
RunValidProtobufTest("ValidDataOneof.MESSAGE.Merge", REQUIRED, proto, text);
RunValidBinaryProtobufTest("ValidDataOneofBinary.MESSAGE.Merge", RECOMMENDED,
proto, expected_proto);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::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);
}
// Reused for a few cases: this is a single byte tag for a field number 1
// varint but where the byte has the continuation bit set, so that we can
// easily construct longer tags.
std::string tag_with_continuation_bit =
tag(1, WireFormatLite::WIRETYPE_VARINT);
assert(tag_with_continuation_bit.size() == 1);
tag_with_continuation_bit[0] |= 0b10000000;
// A varint where field number is far out of range of
// maximum legal field number. The lower 5 bytes of the varint do look like a
// well-formed tag for field number 1.
ExpectParseFailureForProto(
absl::StrCat(tag_with_continuation_bit, "\x80\x80\x80\x80\x80\x0F",
varint(1234)),
"BadTag_FieldNumberTooHigh", REQUIRED);
// A 5-byte tag varint where the value is above UINT32_MAX (bit 35 is set)
ExpectParseFailureForProto(
absl::StrCat(tag_with_continuation_bit, "\x80\x80\x80\x40", varint(1234)),
"BadTag_FieldNumberSlightlyTooHigh", REQUIRED);
// A tag where the varint is more than 5 bytes but only because it is an
// overlong varint, so the decoded value is still below UINT32_MAX.
ExpectParseFailureForProto(
absl::StrCat(tag_with_continuation_bit, "\x80\x80\x80\x80\x80\x80\x80",
std::string("\0", 1), varint(1234)),
"BadTag_OverlongVarint", REQUIRED);
// An overlong varint that is even more than 10 bytes.
ExpectParseFailureForProto(
absl::StrCat(tag_with_continuation_bit,
"\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80",
std::string("\0", 1), varint(1234)),
"BadTag_VarintMoreThanTenBytes", REQUIRED);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::TestIllegalLengths() {
const FieldDescriptor* string_field =
GetFieldForType(FieldDescriptor::TYPE_STRING, false);
// A 5-byte varint length where bits 32-34 are set (e.g. bit 32 = 0x10), which
// overflows 32-bit arithmetic and wraps to 0 modulo 2^32. Parsers must not
// overflow and must reject this invalid wire format.
ExpectParseFailureForProto(
absl::StrCat(tag(string_field->number(),
WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
"\x80\x80\x80\x80\x10"),
"BadLength_Varint32BitOverflow", REQUIRED);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::TestUnmatchedGroup() {
ExpectParseFailureForProto(tag(201, WireFormatLite::WIRETYPE_END_GROUP),
"UnmatchedEndGroup", REQUIRED);
ExpectParseFailureForProto(tag(1234, WireFormatLite::WIRETYPE_END_GROUP),
"UnmatchedEndGroupUnknown", REQUIRED);
ExpectParseFailureForProto(tag(1, WireFormatLite::WIRETYPE_END_GROUP),
"UnmatchedEndGroupWrongType", REQUIRED);
ExpectParseFailureForProto(
len(18, tag(1234, WireFormatLite::WIRETYPE_END_GROUP)),
"UnmatchedEndGroupNestedLen", REQUIRED);
ExpectParseFailureForProto(
group(201, tag(202, WireFormatLite::WIRETYPE_END_GROUP)),
"UnmatchedEndGroupNested", REQUIRED);
ExpectParseFailureForProto(
absl::StrCat(tag(1, WireFormatLite::WIRETYPE_END_GROUP),
len(2, "hello world")),
"UnmatchedEndGroupWithData", REQUIRED);
ExpectParseFailureForProto(tag(201, WireFormatLite::WIRETYPE_START_GROUP),
"UnmatchedStartGroup", REQUIRED);
ExpectParseFailureForProto(tag(1234, WireFormatLite::WIRETYPE_START_GROUP),
"UnmatchedStartGroupUnknown", REQUIRED);
ExpectParseFailureForProto(tag(1, WireFormatLite::WIRETYPE_START_GROUP),
"UnmatchedStartGroupWrongType", REQUIRED);
ExpectParseFailureForProto(
len(18, tag(1234, WireFormatLite::WIRETYPE_START_GROUP)),
"UnmatchedStartGroupNestedLen", REQUIRED);
ExpectParseFailureForProto(
group(201, tag(202, WireFormatLite::WIRETYPE_START_GROUP)),
"UnmatchedStartGroupNested", REQUIRED);
ExpectParseFailureForProto(
absl::StrCat(tag(1, WireFormatLite::WIRETYPE_START_GROUP),
len(2, "hello world")),
"UnmatchedStartGroupWithData", REQUIRED);
ExpectParseFailureForProto(
absl::StrCat(tag(201, WireFormatLite::WIRETYPE_START_GROUP),
len(2, "hello world"),
tag(202, WireFormatLite::WIRETYPE_END_GROUP)),
"MismatchedGroupTags", REQUIRED);
ExpectParseFailureForProto(
group(201, absl::StrCat(tag(202, WireFormatLite::WIRETYPE_START_GROUP),
len(2, "hello world"),
tag(203, WireFormatLite::WIRETYPE_END_GROUP))),
"MismatchedNestedGroupTags", REQUIRED);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::TestUnknownWireType() {
for (uint8_t type : {0x6, 0x7}) {
for (uint8_t field = 0; field < 4; ++field) {
for (uint8_t value = 0; value < 4; ++value) {
std::string name = absl::StrFormat(
"UnknownWireType%d_Field%d_Version%d", type, field, value);
char data[2];
data[0] = (field << 3) | type; // unknown wire type.
data[1] = value;
std::string proto = {data, 2};
ExpectParseFailureForProto(proto, name, REQUIRED);
}
}
}
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::TestInvalidUtf8String() {
if (run_proto3_tests_) {
ExpectParseFailureForProto(len(14, "\xA0\xB0\xC0\xD0"),
"RejectInvalidUtf8.String.Singular",
RECOMMENDED);
ExpectParseFailureForProto(len(44, "\xA0\xB0\xC0\xD0"),
"RejectInvalidUtf8.String.Repeated",
RECOMMENDED);
ExpectParseFailureForProto(len(113, "\xA0\xB0\xC0\xD0"),
"RejectInvalidUtf8.String.Oneof", RECOMMENDED);
ExpectParseFailureForProto(
len(69, absl::StrCat(len(1, "\xA0\xB0\xC0\xD0"), len(2, "foo"))),
"RejectInvalidUtf8.String.MapKey", RECOMMENDED);
ExpectParseFailureForProto(
len(69, absl::StrCat(len(1, "foo"), len(2, "\xA0\xB0\xC0\xD0"))),
"RejectInvalidUtf8.String.MapValue", RECOMMENDED);
} else {
// TODO - Once conformance tests can express failures that are
// not expected to be fixed, add proto2 coverage here.
}
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::TestUnknownMessage() {
MessageType message;
ABSL_CHECK(message.ParseFromString("\xA8\x1F\x01"));
RunValidBinaryProtobufTest("UnknownVarint", REQUIRED,
message.SerializeAsString());
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::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-prefixed (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;
if (!suite_.RunTest(setting.GetTestName(), request, &response)) {
return;
}
MessageType response_message;
TestStatus test;
test.set_name(setting.GetTestName());
if (response.result_case() == ConformanceResponse::kSkipped) {
suite_.ReportSkip(test, 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) {
test.set_failure_message("Unknown field mismatch");
suite_.ReportFailure(test, setting.GetLevel(), request, response);
} else {
suite_.ReportSuccess(test);
}
}
template <typename MessageType>
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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::
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<WireFormatLite::FieldType>(type))),
GetNonDefaultValue(type));
RunBinaryPerformanceMergeMessageWithField(
absl::StrCat("TestBinaryPerformanceMergeMessageWithRepeatedFieldForType",
type_name),
rep_field_proto);
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::
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<WireFormatLite::FieldType>(type))),
GetNonDefaultValue(type));
RunBinaryPerformanceMergeMessageWithField(
absl::StrCat("TestBinaryPerformanceMergeMessageWithUnknownFieldForType",
type_name),
unknown_field_proto);
}
template <typename MessageType>
BinaryAndJsonConformanceSuiteImpl<MessageType>::
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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::RunAllTests() {
if (!suite_.performance_) {
for (int i = 1; i <= FieldDescriptor::MAX_TYPE; i++) {
if (i == FieldDescriptor::TYPE_GROUP) continue;
TestPrematureEOFForType(static_cast<FieldDescriptor::Type>(i));
}
TestIllegalTags();
TestIllegalLengths();
TestUnmatchedGroup();
TestUnknownWireType();
TestInvalidUtf8String();
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
// U+8C37 U+6B4C ("Google" in Chinese), as UTF-8.
{delim("\xE8\xB0\xB7\xE6\xAD\x8C"),
delim("\xE8\xB0\xB7\xE6\xAD\x8C")},
// U+1F601 (grinning face with smiling eyes), as UTF-8.
{delim("\xF0\x9F\x98\x81"), delim("\xF0\x9F\x98\x81")},
});
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();
TestMapEntryWireTypeMismatch(FieldDescriptor::TYPE_INT32,
FieldDescriptor::TYPE_INT32);
TestMapEntryWireTypeMismatch(FieldDescriptor::TYPE_FIXED32,
FieldDescriptor::TYPE_FIXED32);
TestMapEntryWireTypeMismatch(FieldDescriptor::TYPE_BOOL,
FieldDescriptor::TYPE_BOOL);
TestMapEntryWireTypeMismatch(FieldDescriptor::TYPE_STRING,
FieldDescriptor::TYPE_STRING);
TestMapEntryWireTypeMismatch(FieldDescriptor::TYPE_STRING,
FieldDescriptor::TYPE_MESSAGE);
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();
}
}
template <typename MessageType>
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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::RunJsonTests() {
RunValidJsonTest("HelloWorld", REQUIRED,
"{\"optionalString\":\"Hello, World!\"}",
"optional_string: 'Hello, World!'");
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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<
MessageType>::RunJsonTestsForStoresDefaultPrimitive() {
RunValidJsonTestWithValidator(
"StoresDefaultPrimitive", REQUIRED,
R"({
"FieldName13": 0
})",
[](const Json::Value& value) { return value.isMember("FieldName13"); });
std::vector<const FieldDescriptor*> 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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<
MessageType>::RunJsonTestsForReservedFields() {
for (const auto& test_case : std::vector<std::pair<std::string, std::string>>{
{"Boolean", "true"},
{"Number", "1"},
{"String", "\"hello\""},
{"Message", R"json({ "a": 1 })json"},
}) {
ExpectParseFailureForJson(
absl::StrCat("RejectReservedFieldName.", test_case.first), REQUIRED,
absl::Substitute(R"json({
"reserved_field": $0
})json",
test_case.second));
}
}
template <typename MessageType>
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<TestCase> 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 <typename MessageType>
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 have either last-wins or parse failure.
RunValidJsonTestOrParseFailure("FieldNameDuplicate", RECOMMENDED,
R"({
"optionalNestedMessage": {"a": 1},
"optionalNestedMessage": {}
})",
"optional_nested_message: {}");
RunValidJsonTestOrParseFailure("FieldNameDuplicateDifferentCasing1",
RECOMMENDED,
R"({
"optional_nested_message": {"a": 1},
"optionalNestedMessage": {}
})",
"optional_nested_message: {}");
RunValidJsonTestOrParseFailure("FieldNameDuplicateDifferentCasing2",
RECOMMENDED,
R"({
"optionalNestedMessage": {"a": 1},
"optional_nested_message": {}
})",
"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("FieldNameWithNumbersValidator", REQUIRED,
R"({
"field0name5": 5,
"field0Name6": 6
})",
[](const Json::Value& value) {
return value.isMember("field0name5") &&
value.isMember("field0Name6");
});
RunValidJsonTestWithValidator(
"FieldNameWithMixedCasesValidator", 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(
"FieldNameWithDoubleUnderscoresValidator", 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 <typename MessageType>
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");
RunValidJsonTest("Int32FieldStringValueZero", REQUIRED,
R"({"optionalInt32": "0"})", "optional_int32: 0");
RunValidJsonTest("Int32FieldQuotedExponentialValue", REQUIRED,
R"({"optionalInt32": "1e5"})", "optional_int32: 100000");
// 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"})");
ExpectParseFailureForJson("Uint64QuotedExponentFieldTooLarge", REQUIRED,
R"({"optionalUint64": "1e536870000"})");
// Parser reject non-integer numeric values.
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"})");
// Parser reject boolean values for integer fields.
ExpectParseFailureForJson("Int32FieldTrueValue", REQUIRED,
R"({"optionalInt32": true})");
ExpectParseFailureForJson("Int32FieldFalseValue", REQUIRED,
R"({"optionalInt32": false})");
// Parser reject non-numeric string values.
ExpectParseFailureForJson("Int32FieldStringValuePartiallyNumeric", REQUIRED,
R"({"optionalInt32": "12abc"})");
ExpectParseFailureForJson("Int32FieldStringValuePartiallyNumericSpace",
REQUIRED, R"({"optionalInt32": "12 34"})");
ExpectParseFailureForJson("Int32FieldStringValuePartiallyNumericComma",
REQUIRED, R"({"optionalInt32": "12,34"})");
// Not a raw string literal: the payload holds the UTF-8 bytes of U+8C37
// U+6B4C between the digits.
ExpectParseFailureForJson("Int32FieldStringValuePartiallyNumericUnicode",
REQUIRED,
"{\"optionalInt32\": \"12\xE8\xB0\xB7\xE6\xAD\x8C"
"34\"}");
ExpectParseFailureForJson("Int32FieldStringValueNonNumeric", REQUIRED,
R"({"optionalInt32": "abc"})");
// Only ASCII digits 0-9 are digits; other Unicode decimal digits (Nd) are
// rejected. Not raw string literals: the payloads hold UTF-8 bytes of
// Arabic-Indic digits (U+0660-U+0669) and fullwidth digits (U+FF10-U+FF19).
// "١٢٣"
ExpectParseFailureForJson(
"Int32FieldStringValueArabicIndicDigits", REQUIRED,
"{\"optionalInt32\": \"\xD9\xA1\xD9\xA2\xD9\xA3\"}");
ExpectParseFailureForJson(
"Int64FieldStringValueFullwidthDigits", REQUIRED,
"{\"optionalInt64\": \"\xEF\xBC\x91\xEF\xBC\x92\xEF\xBC\x93\"}");
// Parser reject empty string values.
ExpectParseFailureForJson("Int32FieldEmptyString", REQUIRED,
R"({"optionalInt32": ""})");
ExpectParseFailureForJson("Uint32FieldEmptyString", REQUIRED,
R"({"optionalUint32": ""})");
ExpectParseFailureForJson("Int64FieldEmptyString", REQUIRED,
R"({"optionalInt64": ""})");
ExpectParseFailureForJson("Uint64FieldEmptyString", REQUIRED,
R"({"optionalUint64": ""})");
// 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");
RunValidJsonTest("FloatFieldQuotedExponentialValue", REQUIRED,
R"({"optionalFloat": "1.175494e-38"})",
"optional_float: 1.175494e-38");
// 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})");
// Parsers should reject empty string values.
ExpectParseFailureForJson("FloatFieldEmptyString", REQUIRED,
R"({"optionalFloat": ""})");
// Parser reject non-numeric string values.
ExpectParseFailureForJson("FloatFieldStringValuePartiallyNumeric", REQUIRED,
R"({"optionalFloat": "12abc"})");
ExpectParseFailureForJson("FloatFieldStringValueNonNumeric", REQUIRED,
R"({"optionalFloat": "abc"})");
ExpectParseFailureForJson("FloatFieldStringValuePartiallyNumericSpace",
REQUIRED, R"({"optionalFloat": "12 34"})");
ExpectParseFailureForJson("FloatFieldStringValuePartiallyNumericComma",
REQUIRED, R"({"optionalFloat": "12,34"})");
// Not a raw string literal: the payload holds the UTF-8 bytes of U+8C37
// U+6B4C between the digits.
ExpectParseFailureForJson("FloatFieldStringValuePartiallyNumericUnicode",
REQUIRED,
"{\"optionalFloat\": \"12\xE8\xB0\xB7\xE6\xAD\x8C"
"34\"}");
// Non-ASCII Unicode decimal digits: "١٢٣" (Arabic-Indic) and "１２３"
// (fullwidth).
ExpectParseFailureForJson(
"FloatFieldStringValueArabicIndicDigits", REQUIRED,
"{\"optionalFloat\": \"\xD9\xA1\xD9\xA2\xD9\xA3\"}");
ExpectParseFailureForJson(
"FloatFieldStringValueFullwidthDigits", REQUIRED,
"{\"optionalFloat\": \"\xEF\xBC\x91\xEF\xBC\x92\xEF\xBC\x93\"}");
// Parser reject boolean values for float fields.
ExpectParseFailureForJson("FloatFieldTrueValue", REQUIRED,
R"({"optionalFloat": true})");
ExpectParseFailureForJson("FloatFieldFalseValue", REQUIRED,
R"({"optionalFloat": false})");
// 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");
RunValidJsonTest("DoubleFieldQuotedExponentialValue", REQUIRED,
R"({"optionalDouble": "2.22507e-308"})",
"optional_double: 2.22507e-308");
// 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})");
// Parsers should reject empty string values.
ExpectParseFailureForJson("DoubleFieldEmptyString", REQUIRED,
R"({"optionalDouble": ""})");
// Parser reject non-numeric string values.
ExpectParseFailureForJson("DoubleFieldStringValuePartiallyNumeric", REQUIRED,
R"({"optionalDouble": "12abc"})");
ExpectParseFailureForJson("DoubleFieldStringValueNonNumeric", REQUIRED,
R"({"optionalDouble": "abc"})");
// Non-ASCII Unicode decimal digits: "١٢٣" (Arabic-Indic) and "１２３"
// (fullwidth).
ExpectParseFailureForJson(
"DoubleFieldStringValueArabicIndicDigits", REQUIRED,
"{\"optionalDouble\": \"\xD9\xA1\xD9\xA2\xD9\xA3\"}");
ExpectParseFailureForJson(
"DoubleFieldStringValueFullwidthDigits", REQUIRED,
"{\"optionalDouble\": \"\xEF\xBC\x91\xEF\xBC\x92\xEF\xBC\x93\"}");
// Parser reject boolean values for double fields.
ExpectParseFailureForJson("DoubleFieldTrueValue", REQUIRED,
R"({"optionalDouble": true})");
ExpectParseFailureForJson("DoubleFieldFalseValue", REQUIRED,
R"({"optionalDouble": false})");
// 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");
// Arrays are not allowed for non-repeated enum fields.
ExpectParseFailureForJson("EnumFieldSingleElementArrayEnumName", REQUIRED,
R"({"optionalNestedEnum": ["FOO"]})");
ExpectParseFailureForJson("EnumFieldSingleElementArrayNumericValue", REQUIRED,
R"({"optionalNestedEnum": [2]})");
// Booleans are not allowed for enum fields.
ExpectParseFailureForJson("EnumFieldTrueValue", REQUIRED,
R"({"optionalNestedEnum": true})");
ExpectParseFailureForJson("EnumFieldFalseValue", REQUIRED,
R"({"optionalNestedEnum": false})");
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!")");
// Non-ASCII characters in the JSON text itself, as opposed to the \uXXXX
// escapes tested below. Note that this is deliberately not a raw string
// literal: the compiler resolves the \x escapes, so the payload holds the
// UTF-8 bytes of U+8C37 U+6B4C ("Google" in Chinese). In the raw string
// literals below, the \u escapes reach the testee's JSON parser verbatim.
RunValidJsonTest("StringFieldUnicode", REQUIRED,
"{\"optionalString\": \"\xE8\xB0\xB7\xE6\xAD\x8C\"}",
R"(optional_string: "\xE8\xB0\xB7\xE6\xAD\x8C")");
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: "\xE8\xB0\xB7\xE6\xAD\x8C")");
RunValidJsonTest("StringFieldSurrogatePair", REQUIRED,
// U+1F601 (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.
RunValidJsonTestOrParseFailure("OneofFieldDuplicate", REQUIRED,
R"({"oneofUint32": 1, "oneofString": "test"})",
"oneof_string: \"test\"");
RunValidJsonTestOrParseFailure("OneofFieldDuplicate2", REQUIRED,
R"({"oneofString": "test", "oneofUint32": 1})",
"oneof_uint32: 1");
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 <typename MessageType>
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"]})");
// A singular field where a repeated field was expected is not allowed, even
// if it is the right type.
ExpectParseFailureForJson("SingleValueForRepeatedFieldInt32", REQUIRED,
R"({"repeatedInt32": 1})");
ExpectParseFailureForJson("SingleValueForRepeatedFieldMessage", REQUIRED,
R"({"repeatedNestedMessage": {"a": 1}})");
// 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 <typename MessageType>
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 <typename MessageType>
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}");
ExpectSerializeFailureForJson("DurationProtoNanosWrongSign", REQUIRED,
"optional_duration: {seconds: 1 nanos: -1}");
ExpectSerializeFailureForJson("DurationProtoNanosWrongSignNegativeSecs",
REQUIRED,
"optional_duration: {seconds: -1 nanos: 1}");
ExpectSerializeFailureForJson(
"DurationProtoNanosTooSmall", REQUIRED,
"optional_duration: {seconds: -1 nanos: -1000000000}");
ExpectSerializeFailureForJson(
"DurationProtoNanosTooLarge", REQUIRED,
"optional_duration: {seconds: 1 nanos: 1000000000}");
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("TimestampEpochValue", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T00:00:00.000Z"})",
"optional_timestamp: {seconds: 0}");
RunValidJsonTest("TimestampNanoAfterEpochlValue", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T00:00:00.000000001Z"})",
"optional_timestamp: {seconds: 0 nanos: 1}");
RunValidJsonTest("TimestampNanoBeforeEpochValue", REQUIRED,
R"({"optionalTimestamp": "1969-12-31T23:59:59.999999999Z"})",
"optional_timestamp: {seconds: -1 nanos: 999999999}");
RunValidJsonTest("TimestampLittleAfterEpochlValue", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T00:00:01.000000001Z"})",
"optional_timestamp: {seconds: 1 nanos: 1}");
RunValidJsonTest("TimestampLittleBeforeEpochValue", REQUIRED,
R"({"optionalTimestamp": "1969-12-31T23:59:58.999999999Z"})",
"optional_timestamp: {seconds: -2 nanos: 999999999}");
RunValidJsonTest("TimestampTenAndHalfSecondsAfterEpochValue", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T00:00:10.500Z"})",
"optional_timestamp: {seconds: 10 nanos: 500000000}");
RunValidJsonTest("TimestampTenAndHalfSecondsBeforeEpochValue", REQUIRED,
R"({"optionalTimestamp": "1969-12-31T23:59:49.500Z"})",
"optional_timestamp: {seconds: -11 nanos: 500000000}");
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"})");
ExpectParseFailureForJson(
"TimestampWithMissingColonInOffset", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T08:00:01+0800"})");
ExpectSerializeFailureForJson("TimestampProtoInputTooSmall", REQUIRED,
"optional_timestamp: {seconds: -62135596801}");
ExpectSerializeFailureForJson("TimestampProtoInputTooLarge", REQUIRED,
"optional_timestamp: {seconds: 253402300800}");
ExpectSerializeFailureForJson(
"TimestampProtoNegativeNanos", REQUIRED,
"optional_timestamp: {seconds: 5000 nanos: -1}");
ExpectSerializeFailureForJson(
"TimestampProtoNanoTooLarge", REQUIRED,
"optional_timestamp: {seconds: 5000 nanos: 1000000000}");
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";
});
// Out of bounds / invalid components should JSON parse fail
ExpectParseFailureForJson("TimestampJsonInputMonthTooLarge", REQUIRED,
R"({"optionalTimestamp": "1970-13-01T00:00:00Z"})");
ExpectParseFailureForJson("TimestampJsonInputMonthZero", REQUIRED,
R"({"optionalTimestamp": "1970-00-01T00:00:00Z"})");
ExpectParseFailureForJson("TimestampJsonInputDayTooLarge", REQUIRED,
R"({"optionalTimestamp": "1970-01-32T00:00:00Z"})");
ExpectParseFailureForJson("TimestampJsonInputDayZero", REQUIRED,
R"({"optionalTimestamp": "1970-01-00T00:00:00Z"})");
ExpectParseFailureForJson("TimestampJsonInputHourTooLarge", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T24:00:00Z"})");
ExpectParseFailureForJson("TimestampJsonInputHourTooLarge25", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T25:00:00Z"})");
ExpectParseFailureForJson("TimestampJsonInputMinuteTooLarge", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T00:60:00Z"})");
ExpectParseFailureForJson("TimestampJsonInputSecondTooLarge", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T00:00:60Z"})");
ExpectParseFailureForJson(
"TimestampJsonInputInvalidOffsetHour", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T00:00:00+24:00"})");
ExpectParseFailureForJson(
"TimestampJsonInputInvalidOffsetMinute", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T00:00:00+00:60"})");
ExpectParseFailureForJson(
"TimestampJsonInputOffsetBoundaryUnderflow", REQUIRED,
R"({"optionalTimestamp": "0001-01-01T00:00:00+00:01"})");
ExpectParseFailureForJson(
"TimestampJsonInputOffsetBoundaryOverflow", REQUIRED,
R"({"optionalTimestamp": "9999-12-31T23:59:59-00:01"})");
ExpectParseFailureForJson(
"TimestampJsonInputInvalidNanos", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T00:00:00.1234567890Z"})");
ExpectParseFailureForJson(
"TimestampJsonInputInvalidCharsInNanos", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T00:00:00.123aZ"})");
ExpectParseFailureForJson("TimestampJsonInputYearTooShort", REQUIRED,
R"({"optionalTimestamp": "999-01-01T00:00:00Z"})");
ExpectParseFailureForJson(
"TimestampJsonInputYearTooLong", REQUIRED,
R"({"optionalTimestamp": "00001-01-01T00:00:00Z"})");
ExpectParseFailureForJson("TimestampJsonInputMonthTooShort", REQUIRED,
R"({"optionalTimestamp": "1970-1-01T00:00:00Z"})");
ExpectParseFailureForJson("TimestampJsonInputDayTooShort", REQUIRED,
R"({"optionalTimestamp": "1970-01-1T00:00:00Z"})");
ExpectParseFailureForJson("TimestampJsonInputNonLeapFeb29", REQUIRED,
R"({"optionalTimestamp": "2001-02-29T00:00:00Z"})");
// Honoring time zones correctly
RunValidJsonTest("TimestampJsonInputLeapFeb29", REQUIRED,
R"({"optionalTimestamp": "2000-02-29T00:00:00Z"})",
"optional_timestamp: {seconds: 951782400}");
RunValidJsonTest("TimestampWithOffsetShiftsDay", REQUIRED,
R"({"optionalTimestamp": "1970-01-02T01:00:00+02:00"})",
"optional_timestamp: {seconds: 82800}");
RunValidJsonTest("TimestampWithOffsetBoundaryInBoundsMin", REQUIRED,
R"({"optionalTimestamp": "0001-01-01T00:00:00-00:01"})",
"optional_timestamp: {seconds: -62135596740}");
RunValidJsonTest("TimestampWithOffsetBoundaryInBoundsMax", REQUIRED,
R"({"optionalTimestamp": "9999-12-31T23:59:59+00:01"})",
"optional_timestamp: {seconds: 253402300739}");
RunValidJsonTest("TimestampWithComplexOffset", REQUIRED,
R"({"optionalTimestamp": "1970-01-01T00:00:00-11:30"})",
"optional_timestamp: {seconds: 41400}");
}
template <typename MessageType>
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 <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::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: {
}
}
}
}
)");
RunValidJsonTest(
"StructDeepNesting25", RECOMMENDED,
absl::StrCat(R"({"optionalStruct": {)", str_repeat(R"("n": {)", 25),
R"("value": 1)", std::string(25, '}'), "}}"),
absl::StrCat("optional_struct: {\n",
str_repeat(" fields: {\n"
" key: \"n\"\n"
" value: {\n"
" struct_value: {\n",
25),
" fields: {\n"
" key: \"value\"\n"
" value: { number_value: 1 }\n"
" }\n",
str_repeat(" }\n"
" }\n"
" }\n",
25),
"}\n"));
ExpectParseFailureForJson(
"StructDeepNesting200", RECOMMENDED,
absl::StrCat(R"({"optionalStruct": {)", str_repeat(R"("n": {)", 200),
R"("value": 1)", std::string(200, '}'), "}}"));
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::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}");
RunValidJsonTest("ListValueDeepNesting25", RECOMMENDED,
absl::StrCat(R"({"optionalValue": )", std::string(25, '['),
"1", std::string(25, ']'), "}"),
absl::StrCat("optional_value: {\n",
str_repeat(" list_value: {\n"
" values: {\n",
25),
" number_value: 1\n",
str_repeat(" }\n"
" }\n",
25),
"}\n"));
ExpectParseFailureForJson(
"ListValueDeepNesting200", RECOMMENDED,
absl::StrCat(R"({"optionalValue": )", std::string(200, '['), "1",
std::string(200, ']'), "}"));
RunValidJsonTest(
"ValueDeepNesting25", RECOMMENDED,
absl::StrCat(R"({"optionalValue": {)", str_repeat(R"("n": {)", 25),
R"("value": 1)", std::string(25, '}'), "}}"),
absl::StrCat("optional_value: {\n", " struct_value: {\n",
str_repeat(" fields: {\n"
" key: \"n\"\n"
" value: {\n"
" struct_value: {\n",
25),
" fields: {\n"
" key: \"value\"\n"
" value: { number_value: 1 }\n"
" }\n",
str_repeat(" }\n"
" }\n"
" }\n",
25),
" }\n", "}\n"));
ExpectParseFailureForJson(
"ValueDeepNesting200", RECOMMENDED,
absl::StrCat(R"({"optionalValue": {)", str_repeat(R"("n": {)", 200),
R"("value": 1)", std::string(200, '}'), "}}"));
}
template <typename MessageType>
void BinaryAndJsonConformanceSuiteImpl<MessageType>::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
}
}
)");
// When the Any is in WKT form (with "@type"), the type_url must be present
// and URL shaped, otherwise it should be a parse error (because it can't be
// parsed into the Any schema).
ExpectParseFailureForJson("AnyWktRepresentationWithEmptyTypeAndValue",
REQUIRED,
R"({
"optionalAny": {
"@type": "",
"value": ""
}
})");
ExpectParseFailureForJson("AnyWktRepresentationWithBadType", REQUIRED,
R"({
"optionalAny": {
"@type": "not_a_url",
"value": ""
}
})");
// When the Any can be parsed as non-WKT form, the type_url could be missing
// or invalid, since that can still be parsed into the Any schema.
RunValidJsonTest("AnyWithNoType", REQUIRED,
R"({
"optionalAny": {}
})",
R"(
optional_any: {}
)");
// `null` where an Any exists should just result in the field being unset.
RunValidJsonTest("AnyNull", REQUIRED,
R"({
"optionalAny": null
})",
R"(
)");
// google.protobuf.Empty packed into an Any, implementations must accept it
// without the "value" field set. This also confirms that what they round trip
// does not have `"value":{}` set on it, since the test harness uses the C++
// JSON parser which will reject it.
RunValidJsonTest("AnyEmpty", REQUIRED,
R"({
"optionalAny": {
"@type": "type.googleapis.com/google.protobuf.Empty"
}
})",
R"(
optional_any: {
[type.googleapis.com/google.protobuf.Empty] {}
}
)");
}
template <typename MessageType>
const FieldDescriptor*
BinaryAndJsonConformanceSuiteImpl<MessageType>::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 <typename MessageType>
const FieldDescriptor*
BinaryAndJsonConformanceSuiteImpl<MessageType>::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 <typename MessageType>
const FieldDescriptor*
BinaryAndJsonConformanceSuiteImpl<MessageType>::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 <typename MessageType>
std::string BinaryAndJsonConformanceSuiteImpl<MessageType>::SyntaxIdentifier()
const {
if (std::is_same_v<MessageType, TestAllTypesProto2>) {
return "Proto2";
} else if (std::is_same_v<MessageType, TestAllTypesProto3>) {
return "Proto3";
} else if (std::is_same_v<MessageType, TestAllTypesProto2Editions>) {
return "Editions_Proto2";
} else {
return "Editions_Proto3";
}
}
} // namespace conformance
} // namespace protobuf
} // namespace google