80f65d2df8
Add note about JSON tests maybe being wrong. - Add note about the JSON test maybe not being correct yet. - Add test to checks the generated names for double underscores to be sure they are what is expected.
2244 lines
73 KiB
C++
2244 lines
73 KiB
C++
// Protocol Buffers - Google's data interchange format
|
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
// https://developers.google.com/protocol-buffers/
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following disclaimer
|
|
// in the documentation and/or other materials provided with the
|
|
// distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived from
|
|
// this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#include <stdarg.h>
|
|
#include <string>
|
|
#include <fstream>
|
|
|
|
#include "conformance.pb.h"
|
|
#include "conformance_test.h"
|
|
#include <google/protobuf/stubs/common.h>
|
|
#include <google/protobuf/stubs/stringprintf.h>
|
|
#include <google/protobuf/text_format.h>
|
|
#include <google/protobuf/util/json_util.h>
|
|
#include <google/protobuf/util/field_comparator.h>
|
|
#include <google/protobuf/util/message_differencer.h>
|
|
#include <google/protobuf/util/type_resolver_util.h>
|
|
#include <google/protobuf/wire_format_lite.h>
|
|
|
|
#include "third_party/jsoncpp/json.h"
|
|
|
|
using conformance::ConformanceRequest;
|
|
using conformance::ConformanceResponse;
|
|
using conformance::TestAllTypes;
|
|
using conformance::WireFormat;
|
|
using google::protobuf::Descriptor;
|
|
using google::protobuf::FieldDescriptor;
|
|
using google::protobuf::internal::WireFormatLite;
|
|
using google::protobuf::TextFormat;
|
|
using google::protobuf::util::DefaultFieldComparator;
|
|
using google::protobuf::util::JsonToBinaryString;
|
|
using google::protobuf::util::MessageDifferencer;
|
|
using google::protobuf::util::NewTypeResolverForDescriptorPool;
|
|
using google::protobuf::util::Status;
|
|
using std::string;
|
|
|
|
namespace {
|
|
|
|
static const char kTypeUrlPrefix[] = "type.googleapis.com";
|
|
|
|
static string GetTypeUrl(const Descriptor* message) {
|
|
return string(kTypeUrlPrefix) + "/" + message->full_name();
|
|
}
|
|
|
|
/* Routines for building arbitrary protos *************************************/
|
|
|
|
// We would use CodedOutputStream except that we want more freedom to build
|
|
// arbitrary protos (even invalid ones).
|
|
|
|
const string empty;
|
|
|
|
string cat(const string& a, const string& b,
|
|
const string& c = empty,
|
|
const string& d = empty,
|
|
const string& e = empty,
|
|
const string& f = empty,
|
|
const string& g = empty,
|
|
const string& h = empty,
|
|
const string& i = empty,
|
|
const string& j = empty,
|
|
const string& k = empty,
|
|
const string& l = empty) {
|
|
string ret;
|
|
ret.reserve(a.size() + b.size() + c.size() + d.size() + e.size() + f.size() +
|
|
g.size() + h.size() + i.size() + j.size() + k.size() + l.size());
|
|
ret.append(a);
|
|
ret.append(b);
|
|
ret.append(c);
|
|
ret.append(d);
|
|
ret.append(e);
|
|
ret.append(f);
|
|
ret.append(g);
|
|
ret.append(h);
|
|
ret.append(i);
|
|
ret.append(j);
|
|
ret.append(k);
|
|
ret.append(l);
|
|
return ret;
|
|
}
|
|
|
|
// The maximum number of bytes that it takes to encode a 64-bit varint.
|
|
#define VARINT_MAX_LEN 10
|
|
|
|
size_t vencode64(uint64_t val, char *buf) {
|
|
if (val == 0) { buf[0] = 0; return 1; }
|
|
size_t i = 0;
|
|
while (val) {
|
|
uint8_t byte = val & 0x7fU;
|
|
val >>= 7;
|
|
if (val) byte |= 0x80U;
|
|
buf[i++] = byte;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
string varint(uint64_t x) {
|
|
char buf[VARINT_MAX_LEN];
|
|
size_t len = vencode64(x, buf);
|
|
return string(buf, len);
|
|
}
|
|
|
|
// TODO: proper byte-swapping for big-endian machines.
|
|
string fixed32(void *data) { return string(static_cast<char*>(data), 4); }
|
|
string fixed64(void *data) { return string(static_cast<char*>(data), 8); }
|
|
|
|
string delim(const string& buf) { return cat(varint(buf.size()), buf); }
|
|
string uint32(uint32_t u32) { return fixed32(&u32); }
|
|
string uint64(uint64_t u64) { return fixed64(&u64); }
|
|
string flt(float f) { return fixed32(&f); }
|
|
string dbl(double d) { return fixed64(&d); }
|
|
string zz32(int32_t x) { return varint(WireFormatLite::ZigZagEncode32(x)); }
|
|
string zz64(int64_t x) { return varint(WireFormatLite::ZigZagEncode64(x)); }
|
|
|
|
string tag(uint32_t fieldnum, char wire_type) {
|
|
return varint((fieldnum << 3) | wire_type);
|
|
}
|
|
|
|
string submsg(uint32_t fn, const string& buf) {
|
|
return cat( tag(fn, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(buf) );
|
|
}
|
|
|
|
#define UNKNOWN_FIELD 666
|
|
|
|
uint32_t GetFieldNumberForType(FieldDescriptor::Type type, bool repeated) {
|
|
const Descriptor* d = TestAllTypes().GetDescriptor();
|
|
for (int i = 0; i < d->field_count(); i++) {
|
|
const FieldDescriptor* f = d->field(i);
|
|
if (f->type() == type && f->is_repeated() == repeated) {
|
|
return f->number();
|
|
}
|
|
}
|
|
GOOGLE_LOG(FATAL) << "Couldn't find field with type " << (int)type;
|
|
return 0;
|
|
}
|
|
|
|
string UpperCase(string str) {
|
|
for (int i = 0; i < str.size(); i++) {
|
|
str[i] = toupper(str[i]);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
namespace google {
|
|
namespace protobuf {
|
|
|
|
void ConformanceTestSuite::ReportSuccess(const string& test_name) {
|
|
if (expected_to_fail_.erase(test_name) != 0) {
|
|
StringAppendF(&output_,
|
|
"ERROR: test %s is in the failure list, but test succeeded. "
|
|
"Remove it from the failure list.\n",
|
|
test_name.c_str());
|
|
unexpected_succeeding_tests_.insert(test_name);
|
|
}
|
|
successes_++;
|
|
}
|
|
|
|
void ConformanceTestSuite::ReportFailure(const string& test_name,
|
|
const ConformanceRequest& request,
|
|
const ConformanceResponse& response,
|
|
const char* fmt, ...) {
|
|
if (expected_to_fail_.erase(test_name) == 1) {
|
|
expected_failures_++;
|
|
if (!verbose_)
|
|
return;
|
|
} else {
|
|
StringAppendF(&output_, "ERROR, test=%s: ", test_name.c_str());
|
|
unexpected_failing_tests_.insert(test_name);
|
|
}
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
StringAppendV(&output_, fmt, args);
|
|
va_end(args);
|
|
StringAppendF(&output_, " request=%s, response=%s\n",
|
|
request.ShortDebugString().c_str(),
|
|
response.ShortDebugString().c_str());
|
|
}
|
|
|
|
void ConformanceTestSuite::ReportSkip(const string& test_name,
|
|
const ConformanceRequest& request,
|
|
const ConformanceResponse& response) {
|
|
if (verbose_) {
|
|
StringAppendF(&output_, "SKIPPED, test=%s request=%s, response=%s\n",
|
|
test_name.c_str(), request.ShortDebugString().c_str(),
|
|
response.ShortDebugString().c_str());
|
|
}
|
|
skipped_.insert(test_name);
|
|
}
|
|
|
|
void ConformanceTestSuite::RunTest(const string& test_name,
|
|
const ConformanceRequest& request,
|
|
ConformanceResponse* response) {
|
|
if (test_names_.insert(test_name).second == false) {
|
|
GOOGLE_LOG(FATAL) << "Duplicated test name: " << test_name;
|
|
}
|
|
|
|
string serialized_request;
|
|
string serialized_response;
|
|
request.SerializeToString(&serialized_request);
|
|
|
|
runner_->RunTest(test_name, serialized_request, &serialized_response);
|
|
|
|
if (!response->ParseFromString(serialized_response)) {
|
|
response->Clear();
|
|
response->set_runtime_error("response proto could not be parsed.");
|
|
}
|
|
|
|
if (verbose_) {
|
|
StringAppendF(&output_, "conformance test: name=%s, request=%s, response=%s\n",
|
|
test_name.c_str(),
|
|
request.ShortDebugString().c_str(),
|
|
response->ShortDebugString().c_str());
|
|
}
|
|
}
|
|
|
|
void ConformanceTestSuite::RunValidInputTest(
|
|
const string& test_name, const string& input, WireFormat input_format,
|
|
const string& equivalent_text_format, WireFormat requested_output) {
|
|
TestAllTypes reference_message;
|
|
GOOGLE_CHECK(
|
|
TextFormat::ParseFromString(equivalent_text_format, &reference_message))
|
|
<< "Failed to parse data for test case: " << test_name
|
|
<< ", data: " << equivalent_text_format;
|
|
|
|
ConformanceRequest request;
|
|
ConformanceResponse response;
|
|
|
|
switch (input_format) {
|
|
case conformance::PROTOBUF:
|
|
request.set_protobuf_payload(input);
|
|
break;
|
|
|
|
case conformance::JSON:
|
|
request.set_json_payload(input);
|
|
break;
|
|
|
|
default:
|
|
GOOGLE_LOG(FATAL) << "Unspecified input format";
|
|
}
|
|
|
|
request.set_requested_output_format(requested_output);
|
|
|
|
RunTest(test_name, request, &response);
|
|
|
|
TestAllTypes test_message;
|
|
|
|
switch (response.result_case()) {
|
|
case ConformanceResponse::RESULT_NOT_SET:
|
|
ReportFailure(test_name, request, response,
|
|
"Response didn't have any field in the Response.");
|
|
return;
|
|
|
|
case ConformanceResponse::kParseError:
|
|
case ConformanceResponse::kRuntimeError:
|
|
case ConformanceResponse::kSerializeError:
|
|
ReportFailure(test_name, request, response,
|
|
"Failed to parse input or produce output.");
|
|
return;
|
|
|
|
case ConformanceResponse::kSkipped:
|
|
ReportSkip(test_name, request, response);
|
|
return;
|
|
|
|
case ConformanceResponse::kJsonPayload: {
|
|
if (requested_output != conformance::JSON) {
|
|
ReportFailure(
|
|
test_name, request, response,
|
|
"Test was asked for protobuf output but provided JSON instead.");
|
|
return;
|
|
}
|
|
string binary_protobuf;
|
|
Status status =
|
|
JsonToBinaryString(type_resolver_.get(), type_url_,
|
|
response.json_payload(), &binary_protobuf);
|
|
if (!status.ok()) {
|
|
ReportFailure(test_name, request, response,
|
|
"JSON output we received from test was unparseable.");
|
|
return;
|
|
}
|
|
|
|
if (!test_message.ParseFromString(binary_protobuf)) {
|
|
ReportFailure(test_name, request, response,
|
|
"INTERNAL ERROR: internal JSON->protobuf transcode "
|
|
"yielded unparseable proto.");
|
|
return;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case ConformanceResponse::kProtobufPayload: {
|
|
if (requested_output != conformance::PROTOBUF) {
|
|
ReportFailure(
|
|
test_name, request, response,
|
|
"Test was asked for JSON output but provided protobuf instead.");
|
|
return;
|
|
}
|
|
|
|
if (!test_message.ParseFromString(response.protobuf_payload())) {
|
|
ReportFailure(test_name, request, response,
|
|
"Protobuf output we received from test was unparseable.");
|
|
return;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
GOOGLE_LOG(FATAL) << test_name << ": unknown payload type: "
|
|
<< response.result_case();
|
|
}
|
|
|
|
MessageDifferencer differencer;
|
|
DefaultFieldComparator field_comparator;
|
|
field_comparator.set_treat_nan_as_equal(true);
|
|
differencer.set_field_comparator(&field_comparator);
|
|
string differences;
|
|
differencer.ReportDifferencesToString(&differences);
|
|
|
|
if (differencer.Compare(reference_message, test_message)) {
|
|
ReportSuccess(test_name);
|
|
} else {
|
|
ReportFailure(test_name, request, response,
|
|
"Output was not equivalent to reference message: %s.",
|
|
differences.c_str());
|
|
}
|
|
}
|
|
|
|
// Expect that this precise protobuf will cause a parse error.
|
|
void ConformanceTestSuite::ExpectParseFailureForProto(
|
|
const string& proto, const string& test_name) {
|
|
ConformanceRequest request;
|
|
ConformanceResponse response;
|
|
request.set_protobuf_payload(proto);
|
|
string effective_test_name = "ProtobufInput." + test_name;
|
|
|
|
// 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.
|
|
request.set_requested_output_format(conformance::PROTOBUF);
|
|
|
|
RunTest(effective_test_name, request, &response);
|
|
if (response.result_case() == ConformanceResponse::kParseError) {
|
|
ReportSuccess(effective_test_name);
|
|
} else if (response.result_case() == ConformanceResponse::kSkipped) {
|
|
ReportSkip(effective_test_name, request, response);
|
|
} else {
|
|
ReportFailure(effective_test_name, request, response,
|
|
"Should have failed to parse, but didn't.");
|
|
}
|
|
}
|
|
|
|
// 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(haberman): implement the second of these.
|
|
void ConformanceTestSuite::ExpectHardParseFailureForProto(
|
|
const string& proto, const string& test_name) {
|
|
return ExpectParseFailureForProto(proto, test_name);
|
|
}
|
|
|
|
void ConformanceTestSuite::RunValidJsonTest(
|
|
const string& test_name, const string& input_json,
|
|
const string& equivalent_text_format) {
|
|
RunValidInputTest("JsonInput." + test_name + ".ProtobufOutput", input_json,
|
|
conformance::JSON, equivalent_text_format,
|
|
conformance::PROTOBUF);
|
|
RunValidInputTest("JsonInput." + test_name + ".JsonOutput", input_json,
|
|
conformance::JSON, equivalent_text_format,
|
|
conformance::JSON);
|
|
}
|
|
|
|
void ConformanceTestSuite::RunValidJsonTestWithProtobufInput(
|
|
const string& test_name, const TestAllTypes& input,
|
|
const string& equivalent_text_format) {
|
|
RunValidInputTest("ProtobufInput." + test_name + ".JsonOutput",
|
|
input.SerializeAsString(), conformance::PROTOBUF,
|
|
equivalent_text_format, conformance::JSON);
|
|
}
|
|
|
|
void ConformanceTestSuite::RunValidProtobufTest(
|
|
const string& test_name, const TestAllTypes& input,
|
|
const string& equivalent_text_format) {
|
|
RunValidInputTest("ProtobufInput." + test_name + ".ProtobufOutput",
|
|
input.SerializeAsString(), conformance::PROTOBUF,
|
|
equivalent_text_format, conformance::PROTOBUF);
|
|
RunValidInputTest("ProtobufInput." + test_name + ".JsonOutput",
|
|
input.SerializeAsString(), conformance::PROTOBUF,
|
|
equivalent_text_format, conformance::JSON);
|
|
}
|
|
|
|
// According to proto3 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 proto3 JSON serializer by inspecting
|
|
// the JSON output directly.
|
|
void ConformanceTestSuite::RunValidJsonTestWithValidator(
|
|
const string& test_name, const string& input_json,
|
|
const Validator& validator) {
|
|
ConformanceRequest request;
|
|
ConformanceResponse response;
|
|
request.set_json_payload(input_json);
|
|
request.set_requested_output_format(conformance::JSON);
|
|
|
|
string effective_test_name = "JsonInput." + test_name + ".Validator";
|
|
|
|
RunTest(effective_test_name, request, &response);
|
|
|
|
if (response.result_case() == ConformanceResponse::kSkipped) {
|
|
ReportSkip(effective_test_name, request, response);
|
|
return;
|
|
}
|
|
|
|
if (response.result_case() != ConformanceResponse::kJsonPayload) {
|
|
ReportFailure(effective_test_name, request, response,
|
|
"Expected JSON payload but got type %d.",
|
|
response.result_case());
|
|
return;
|
|
}
|
|
Json::Reader reader;
|
|
Json::Value value;
|
|
if (!reader.parse(response.json_payload(), value)) {
|
|
ReportFailure(effective_test_name, request, response,
|
|
"JSON payload cannot be parsed as valid JSON: %s",
|
|
reader.getFormattedErrorMessages().c_str());
|
|
return;
|
|
}
|
|
if (!validator(value)) {
|
|
ReportFailure(effective_test_name, request, response,
|
|
"JSON payload validation failed.");
|
|
return;
|
|
}
|
|
ReportSuccess(effective_test_name);
|
|
}
|
|
|
|
void ConformanceTestSuite::ExpectParseFailureForJson(
|
|
const string& test_name, const string& input_json) {
|
|
ConformanceRequest request;
|
|
ConformanceResponse response;
|
|
request.set_json_payload(input_json);
|
|
string effective_test_name = "JsonInput." + test_name;
|
|
|
|
// 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.
|
|
request.set_requested_output_format(conformance::JSON);
|
|
|
|
RunTest(effective_test_name, request, &response);
|
|
if (response.result_case() == ConformanceResponse::kParseError) {
|
|
ReportSuccess(effective_test_name);
|
|
} else if (response.result_case() == ConformanceResponse::kSkipped) {
|
|
ReportSkip(effective_test_name, request, response);
|
|
} else {
|
|
ReportFailure(effective_test_name, request, response,
|
|
"Should have failed to parse, but didn't.");
|
|
}
|
|
}
|
|
|
|
void ConformanceTestSuite::ExpectSerializeFailureForJson(
|
|
const string& test_name, const string& text_format) {
|
|
TestAllTypes payload_message;
|
|
GOOGLE_CHECK(
|
|
TextFormat::ParseFromString(text_format, &payload_message))
|
|
<< "Failed to parse: " << text_format;
|
|
|
|
ConformanceRequest request;
|
|
ConformanceResponse response;
|
|
request.set_protobuf_payload(payload_message.SerializeAsString());
|
|
string effective_test_name = test_name + ".JsonOutput";
|
|
request.set_requested_output_format(conformance::JSON);
|
|
|
|
RunTest(effective_test_name, request, &response);
|
|
if (response.result_case() == ConformanceResponse::kSerializeError) {
|
|
ReportSuccess(effective_test_name);
|
|
} else if (response.result_case() == ConformanceResponse::kSkipped) {
|
|
ReportSkip(effective_test_name, request, response);
|
|
} else {
|
|
ReportFailure(effective_test_name, request, response,
|
|
"Should have failed to serialize, but didn't.");
|
|
}
|
|
}
|
|
|
|
void ConformanceTestSuite::TestPrematureEOFForType(FieldDescriptor::Type type) {
|
|
// Incomplete values for each wire type.
|
|
static const string incompletes[6] = {
|
|
string("\x80"), // VARINT
|
|
string("abcdefg"), // 64BIT
|
|
string("\x80"), // DELIMITED (partial length)
|
|
string(), // START_GROUP (no value required)
|
|
string(), // END_GROUP (no value required)
|
|
string("abc") // 32BIT
|
|
};
|
|
|
|
uint32_t fieldnum = GetFieldNumberForType(type, false);
|
|
uint32_t rep_fieldnum = GetFieldNumberForType(type, true);
|
|
WireFormatLite::WireType wire_type = WireFormatLite::WireTypeForFieldType(
|
|
static_cast<WireFormatLite::FieldType>(type));
|
|
const string& incomplete = incompletes[wire_type];
|
|
const string type_name =
|
|
UpperCase(string(".") + FieldDescriptor::TypeName(type));
|
|
|
|
ExpectParseFailureForProto(
|
|
tag(fieldnum, wire_type),
|
|
"PrematureEofBeforeKnownNonRepeatedValue" + type_name);
|
|
|
|
ExpectParseFailureForProto(
|
|
tag(rep_fieldnum, wire_type),
|
|
"PrematureEofBeforeKnownRepeatedValue" + type_name);
|
|
|
|
ExpectParseFailureForProto(
|
|
tag(UNKNOWN_FIELD, wire_type),
|
|
"PrematureEofBeforeUnknownValue" + type_name);
|
|
|
|
ExpectParseFailureForProto(
|
|
cat( tag(fieldnum, wire_type), incomplete ),
|
|
"PrematureEofInsideKnownNonRepeatedValue" + type_name);
|
|
|
|
ExpectParseFailureForProto(
|
|
cat( tag(rep_fieldnum, wire_type), incomplete ),
|
|
"PrematureEofInsideKnownRepeatedValue" + type_name);
|
|
|
|
ExpectParseFailureForProto(
|
|
cat( tag(UNKNOWN_FIELD, wire_type), incomplete ),
|
|
"PrematureEofInsideUnknownValue" + type_name);
|
|
|
|
if (wire_type == WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
ExpectParseFailureForProto(
|
|
cat( tag(fieldnum, wire_type), varint(1) ),
|
|
"PrematureEofInDelimitedDataForKnownNonRepeatedValue" + type_name);
|
|
|
|
ExpectParseFailureForProto(
|
|
cat( tag(rep_fieldnum, wire_type), varint(1) ),
|
|
"PrematureEofInDelimitedDataForKnownRepeatedValue" + type_name);
|
|
|
|
// EOF in the middle of delimited data for unknown value.
|
|
ExpectParseFailureForProto(
|
|
cat( tag(UNKNOWN_FIELD, wire_type), varint(1) ),
|
|
"PrematureEofInDelimitedDataForUnknownValue" + type_name);
|
|
|
|
if (type == FieldDescriptor::TYPE_MESSAGE) {
|
|
// Submessage ends in the middle of a value.
|
|
string incomplete_submsg =
|
|
cat( tag(WireFormatLite::TYPE_INT32, WireFormatLite::WIRETYPE_VARINT),
|
|
incompletes[WireFormatLite::WIRETYPE_VARINT] );
|
|
ExpectHardParseFailureForProto(
|
|
cat( tag(fieldnum, WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
|
|
varint(incomplete_submsg.size()),
|
|
incomplete_submsg ),
|
|
"PrematureEofInSubmessageValue" + type_name);
|
|
}
|
|
} else if (type != FieldDescriptor::TYPE_GROUP) {
|
|
// Non-delimited, non-group: eligible for packing.
|
|
|
|
// Packed region ends in the middle of a value.
|
|
ExpectHardParseFailureForProto(
|
|
cat( tag(rep_fieldnum, WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
|
|
varint(incomplete.size()),
|
|
incomplete ),
|
|
"PrematureEofInPackedFieldValue" + type_name);
|
|
|
|
// EOF in the middle of packed region.
|
|
ExpectParseFailureForProto(
|
|
cat( tag(rep_fieldnum, WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
|
|
varint(1) ),
|
|
"PrematureEofInPackedField" + type_name);
|
|
}
|
|
}
|
|
|
|
void ConformanceTestSuite::SetFailureList(const string& filename,
|
|
const vector<string>& failure_list) {
|
|
failure_list_filename_ = filename;
|
|
expected_to_fail_.clear();
|
|
std::copy(failure_list.begin(), failure_list.end(),
|
|
std::inserter(expected_to_fail_, expected_to_fail_.end()));
|
|
}
|
|
|
|
bool ConformanceTestSuite::CheckSetEmpty(const set<string>& set_to_check,
|
|
const std::string& write_to_file,
|
|
const std::string& msg) {
|
|
if (set_to_check.empty()) {
|
|
return true;
|
|
} else {
|
|
StringAppendF(&output_, "\n");
|
|
StringAppendF(&output_, "%s\n\n", msg.c_str());
|
|
for (set<string>::const_iterator iter = set_to_check.begin();
|
|
iter != set_to_check.end(); ++iter) {
|
|
StringAppendF(&output_, " %s\n", iter->c_str());
|
|
}
|
|
StringAppendF(&output_, "\n");
|
|
|
|
if (!write_to_file.empty()) {
|
|
std::ofstream os(write_to_file);
|
|
if (os) {
|
|
for (set<string>::const_iterator iter = set_to_check.begin();
|
|
iter != set_to_check.end(); ++iter) {
|
|
os << *iter << "\n";
|
|
}
|
|
} else {
|
|
StringAppendF(&output_, "Failed to open file: %s\n",
|
|
write_to_file.c_str());
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ConformanceTestSuite::RunSuite(ConformanceTestRunner* runner,
|
|
std::string* output) {
|
|
runner_ = runner;
|
|
successes_ = 0;
|
|
expected_failures_ = 0;
|
|
skipped_.clear();
|
|
test_names_.clear();
|
|
unexpected_failing_tests_.clear();
|
|
unexpected_succeeding_tests_.clear();
|
|
type_resolver_.reset(NewTypeResolverForDescriptorPool(
|
|
kTypeUrlPrefix, DescriptorPool::generated_pool()));
|
|
type_url_ = GetTypeUrl(TestAllTypes::descriptor());
|
|
|
|
output_ = "\nCONFORMANCE TEST BEGIN ====================================\n\n";
|
|
|
|
for (int i = 1; i <= FieldDescriptor::MAX_TYPE; i++) {
|
|
if (i == FieldDescriptor::TYPE_GROUP) continue;
|
|
TestPrematureEOFForType(static_cast<FieldDescriptor::Type>(i));
|
|
}
|
|
|
|
RunValidJsonTest("HelloWorld", "{\"optionalString\":\"Hello, World!\"}",
|
|
"optional_string: 'Hello, World!'");
|
|
|
|
// NOTE: The spec for JSON support is still being sorted out, these may not
|
|
// all be correct.
|
|
// Test field name conventions.
|
|
RunValidJsonTest(
|
|
"FieldNameInSnakeCase",
|
|
R"({
|
|
"fieldname1": 1,
|
|
"fieldName2": 2,
|
|
"fieldName3": 3,
|
|
"fieldName4": 4
|
|
})",
|
|
R"(
|
|
fieldname1: 1
|
|
field_name2: 2
|
|
_field_name3: 3
|
|
field__name4_: 4
|
|
)");
|
|
RunValidJsonTest(
|
|
"FieldNameWithNumbers",
|
|
R"({
|
|
"field0name5": 5,
|
|
"field0Name6": 6
|
|
})",
|
|
R"(
|
|
field0name5: 5
|
|
field_0_name6: 6
|
|
)");
|
|
RunValidJsonTest(
|
|
"FieldNameWithMixedCases",
|
|
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",
|
|
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",
|
|
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",
|
|
R"({"fieldn\u0061me1": 1})",
|
|
"fieldname1: 1");
|
|
// String ends with escape character.
|
|
ExpectParseFailureForJson(
|
|
"StringEndsWithEscapeChar",
|
|
"{\"optionalString\": \"abc\\");
|
|
// Field names must be quoted (or it's not valid JSON).
|
|
ExpectParseFailureForJson(
|
|
"FieldNameNotQuoted",
|
|
"{fieldname1: 1}");
|
|
// Trailing comma is not allowed (not valid JSON).
|
|
ExpectParseFailureForJson(
|
|
"TrailingCommaInAnObject",
|
|
R"({"fieldname1":1,})");
|
|
ExpectParseFailureForJson(
|
|
"TrailingCommaInAnObjectWithSpace",
|
|
R"({"fieldname1":1 ,})");
|
|
ExpectParseFailureForJson(
|
|
"TrailingCommaInAnObjectWithSpaceCommaSpace",
|
|
R"({"fieldname1":1 , })");
|
|
ExpectParseFailureForJson(
|
|
"TrailingCommaInAnObjectWithNewlines",
|
|
R"({
|
|
"fieldname1":1,
|
|
})");
|
|
// JSON doesn't support comments.
|
|
ExpectParseFailureForJson(
|
|
"JsonWithComments",
|
|
R"({
|
|
// This is a comment.
|
|
"fieldname1": 1
|
|
})");
|
|
// JSON spec says whitespace doesn't matter, so try a few spacings to be sure.
|
|
RunValidJsonTest(
|
|
"OneLineNoSpaces",
|
|
"{\"optionalInt32\":1,\"optionalInt64\":2}",
|
|
R"(
|
|
optional_int32: 1
|
|
optional_int64: 2
|
|
)");
|
|
RunValidJsonTest(
|
|
"OneLineWithSpaces",
|
|
"{ \"optionalInt32\" : 1 , \"optionalInt64\" : 2 }",
|
|
R"(
|
|
optional_int32: 1
|
|
optional_int64: 2
|
|
)");
|
|
RunValidJsonTest(
|
|
"MultilineNoSpaces",
|
|
"{\n\"optionalInt32\"\n:\n1\n,\n\"optionalInt64\"\n:\n2\n}",
|
|
R"(
|
|
optional_int32: 1
|
|
optional_int64: 2
|
|
)");
|
|
RunValidJsonTest(
|
|
"MultilineWithSpaces",
|
|
"{\n \"optionalInt32\" : 1\n ,\n \"optionalInt64\" : 2\n}\n",
|
|
R"(
|
|
optional_int32: 1
|
|
optional_int64: 2
|
|
)");
|
|
// Missing comma between key/value pairs.
|
|
ExpectParseFailureForJson(
|
|
"MissingCommaOneLine",
|
|
"{ \"optionalInt32\": 1 \"optionalInt64\": 2 }");
|
|
ExpectParseFailureForJson(
|
|
"MissingCommaMultiline",
|
|
"{\n \"optionalInt32\": 1\n \"optionalInt64\": 2\n}");
|
|
// Duplicated field names are not allowed.
|
|
ExpectParseFailureForJson(
|
|
"FieldNameDuplicate",
|
|
R"({
|
|
"optionalNestedMessage": {a: 1},
|
|
"optionalNestedMessage": {}
|
|
})");
|
|
ExpectParseFailureForJson(
|
|
"FieldNameDuplicateDifferentCasing1",
|
|
R"({
|
|
"optional_nested_message": {a: 1},
|
|
"optionalNestedMessage": {}
|
|
})");
|
|
ExpectParseFailureForJson(
|
|
"FieldNameDuplicateDifferentCasing2",
|
|
R"({
|
|
"optionalNestedMessage": {a: 1},
|
|
"optional_nested_message": {}
|
|
})");
|
|
// NOTE: The spec for JSON support is still being sorted out, these may not
|
|
// all be correct.
|
|
// Serializers should use lowerCamelCase by default.
|
|
RunValidJsonTestWithValidator(
|
|
"FieldNameInLowerCamelCase",
|
|
R"({
|
|
"fieldname1": 1,
|
|
"fieldName2": 2,
|
|
"fieldName3": 3,
|
|
"fieldName4": 4
|
|
})",
|
|
[](const Json::Value& value) {
|
|
return value.isMember("fieldname1") &&
|
|
value.isMember("fieldName2") &&
|
|
value.isMember("fieldName3") &&
|
|
value.isMember("fieldName4");
|
|
});
|
|
RunValidJsonTestWithValidator(
|
|
"FieldNameWithNumbers",
|
|
R"({
|
|
"field0name5": 5,
|
|
"field0Name6": 6
|
|
})",
|
|
[](const Json::Value& value) {
|
|
return value.isMember("field0name5") &&
|
|
value.isMember("field0Name6");
|
|
});
|
|
RunValidJsonTestWithValidator(
|
|
"FieldNameWithMixedCases",
|
|
R"({
|
|
"fieldName7": 7,
|
|
"fieldName8": 8,
|
|
"fieldName9": 9,
|
|
"fieldName10": 10,
|
|
"fIELDNAME11": 11,
|
|
"fIELDName12": 12
|
|
})",
|
|
[](const Json::Value& value) {
|
|
return value.isMember("fieldName7") &&
|
|
value.isMember("fieldName8") &&
|
|
value.isMember("fieldName9") &&
|
|
value.isMember("fieldName10") &&
|
|
value.isMember("fIELDNAME11") &&
|
|
value.isMember("fIELDName12");
|
|
});
|
|
RunValidJsonTestWithValidator(
|
|
"FieldNameWithDoubleUnderscores",
|
|
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");
|
|
});
|
|
|
|
// Integer fields.
|
|
RunValidJsonTest(
|
|
"Int32FieldMaxValue",
|
|
R"({"optionalInt32": 2147483647})",
|
|
"optional_int32: 2147483647");
|
|
RunValidJsonTest(
|
|
"Int32FieldMinValue",
|
|
R"({"optionalInt32": -2147483648})",
|
|
"optional_int32: -2147483648");
|
|
RunValidJsonTest(
|
|
"Uint32FieldMaxValue",
|
|
R"({"optionalUint32": 4294967295})",
|
|
"optional_uint32: 4294967295");
|
|
RunValidJsonTest(
|
|
"Int64FieldMaxValue",
|
|
R"({"optionalInt64": "9223372036854775807"})",
|
|
"optional_int64: 9223372036854775807");
|
|
RunValidJsonTest(
|
|
"Int64FieldMinValue",
|
|
R"({"optionalInt64": "-9223372036854775808"})",
|
|
"optional_int64: -9223372036854775808");
|
|
RunValidJsonTest(
|
|
"Uint64FieldMaxValue",
|
|
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",
|
|
R"({"optionalInt64": 9223372036854774784})",
|
|
"optional_int64: 9223372036854774784");
|
|
RunValidJsonTest(
|
|
"Int64FieldMinValueNotQuoted",
|
|
R"({"optionalInt64": -9223372036854775808})",
|
|
"optional_int64: -9223372036854775808");
|
|
// Largest interoperable Uint64; see comment above
|
|
// for Int64FieldMaxValueNotQuoted.
|
|
RunValidJsonTest(
|
|
"Uint64FieldMaxValueNotQuoted",
|
|
R"({"optionalUint64": 18446744073709549568})",
|
|
"optional_uint64: 18446744073709549568");
|
|
// Values can be represented as JSON strings.
|
|
RunValidJsonTest(
|
|
"Int32FieldStringValue",
|
|
R"({"optionalInt32": "2147483647"})",
|
|
"optional_int32: 2147483647");
|
|
RunValidJsonTest(
|
|
"Int32FieldStringValueEscaped",
|
|
R"({"optionalInt32": "2\u003147483647"})",
|
|
"optional_int32: 2147483647");
|
|
|
|
// Parsers reject out-of-bound integer values.
|
|
ExpectParseFailureForJson(
|
|
"Int32FieldTooLarge",
|
|
R"({"optionalInt32": 2147483648})");
|
|
ExpectParseFailureForJson(
|
|
"Int32FieldTooSmall",
|
|
R"({"optionalInt32": -2147483649})");
|
|
ExpectParseFailureForJson(
|
|
"Uint32FieldTooLarge",
|
|
R"({"optionalUint32": 4294967296})");
|
|
ExpectParseFailureForJson(
|
|
"Int64FieldTooLarge",
|
|
R"({"optionalInt64": "9223372036854775808"})");
|
|
ExpectParseFailureForJson(
|
|
"Int64FieldTooSmall",
|
|
R"({"optionalInt64": "-9223372036854775809"})");
|
|
ExpectParseFailureForJson(
|
|
"Uint64FieldTooLarge",
|
|
R"({"optionalUint64": "18446744073709551616"})");
|
|
// Parser reject non-integer numeric values as well.
|
|
ExpectParseFailureForJson(
|
|
"Int32FieldNotInteger",
|
|
R"({"optionalInt32": 0.5})");
|
|
ExpectParseFailureForJson(
|
|
"Uint32FieldNotInteger",
|
|
R"({"optionalUint32": 0.5})");
|
|
ExpectParseFailureForJson(
|
|
"Int64FieldNotInteger",
|
|
R"({"optionalInt64": "0.5"})");
|
|
ExpectParseFailureForJson(
|
|
"Uint64FieldNotInteger",
|
|
R"({"optionalUint64": "0.5"})");
|
|
|
|
// Integers but represented as float values are accepted.
|
|
RunValidJsonTest(
|
|
"Int32FieldFloatTrailingZero",
|
|
R"({"optionalInt32": 100000.000})",
|
|
"optional_int32: 100000");
|
|
RunValidJsonTest(
|
|
"Int32FieldExponentialFormat",
|
|
R"({"optionalInt32": 1e5})",
|
|
"optional_int32: 100000");
|
|
RunValidJsonTest(
|
|
"Int32FieldMaxFloatValue",
|
|
R"({"optionalInt32": 2.147483647e9})",
|
|
"optional_int32: 2147483647");
|
|
RunValidJsonTest(
|
|
"Int32FieldMinFloatValue",
|
|
R"({"optionalInt32": -2.147483648e9})",
|
|
"optional_int32: -2147483648");
|
|
RunValidJsonTest(
|
|
"Uint32FieldMaxFloatValue",
|
|
R"({"optionalUint32": 4.294967295e9})",
|
|
"optional_uint32: 4294967295");
|
|
|
|
// Parser reject non-numeric values.
|
|
ExpectParseFailureForJson(
|
|
"Int32FieldNotNumber",
|
|
R"({"optionalInt32": "3x3"})");
|
|
ExpectParseFailureForJson(
|
|
"Uint32FieldNotNumber",
|
|
R"({"optionalUint32": "3x3"})");
|
|
ExpectParseFailureForJson(
|
|
"Int64FieldNotNumber",
|
|
R"({"optionalInt64": "3x3"})");
|
|
ExpectParseFailureForJson(
|
|
"Uint64FieldNotNumber",
|
|
R"({"optionalUint64": "3x3"})");
|
|
// JSON does not allow "+" on numric values.
|
|
ExpectParseFailureForJson(
|
|
"Int32FieldPlusSign",
|
|
R"({"optionalInt32": +1})");
|
|
// JSON doesn't allow leading 0s.
|
|
ExpectParseFailureForJson(
|
|
"Int32FieldLeadingZero",
|
|
R"({"optionalInt32": 01})");
|
|
ExpectParseFailureForJson(
|
|
"Int32FieldNegativeWithLeadingZero",
|
|
R"({"optionalInt32": -01})");
|
|
// String values must follow the same syntax rule. Specifically leading
|
|
// or traling spaces are not allowed.
|
|
ExpectParseFailureForJson(
|
|
"Int32FieldLeadingSpace",
|
|
R"({"optionalInt32": " 1"})");
|
|
ExpectParseFailureForJson(
|
|
"Int32FieldTrailingSpace",
|
|
R"({"optionalInt32": "1 "})");
|
|
|
|
// 64-bit values are serialized as strings.
|
|
RunValidJsonTestWithValidator(
|
|
"Int64FieldBeString",
|
|
R"({"optionalInt64": 1})",
|
|
[](const Json::Value& value) {
|
|
return value["optionalInt64"].type() == Json::stringValue &&
|
|
value["optionalInt64"].asString() == "1";
|
|
});
|
|
RunValidJsonTestWithValidator(
|
|
"Uint64FieldBeString",
|
|
R"({"optionalUint64": 1})",
|
|
[](const Json::Value& value) {
|
|
return value["optionalUint64"].type() == Json::stringValue &&
|
|
value["optionalUint64"].asString() == "1";
|
|
});
|
|
|
|
// Bool fields.
|
|
RunValidJsonTest(
|
|
"BoolFieldTrue",
|
|
R"({"optionalBool":true})",
|
|
"optional_bool: true");
|
|
RunValidJsonTest(
|
|
"BoolFieldFalse",
|
|
R"({"optionalBool":false})",
|
|
"optional_bool: false");
|
|
|
|
// Other forms are not allowed.
|
|
ExpectParseFailureForJson(
|
|
"BoolFieldIntegerZero",
|
|
R"({"optionalBool":0})");
|
|
ExpectParseFailureForJson(
|
|
"BoolFieldIntegerOne",
|
|
R"({"optionalBool":1})");
|
|
ExpectParseFailureForJson(
|
|
"BoolFieldCamelCaseTrue",
|
|
R"({"optionalBool":True})");
|
|
ExpectParseFailureForJson(
|
|
"BoolFieldCamelCaseFalse",
|
|
R"({"optionalBool":False})");
|
|
ExpectParseFailureForJson(
|
|
"BoolFieldAllCapitalTrue",
|
|
R"({"optionalBool":TRUE})");
|
|
ExpectParseFailureForJson(
|
|
"BoolFieldAllCapitalFalse",
|
|
R"({"optionalBool":FALSE})");
|
|
ExpectParseFailureForJson(
|
|
"BoolFieldDoubleQuotedTrue",
|
|
R"({"optionalBool":"true"})");
|
|
ExpectParseFailureForJson(
|
|
"BoolFieldDoubleQuotedFalse",
|
|
R"({"optionalBool":"false"})");
|
|
|
|
// Float fields.
|
|
RunValidJsonTest(
|
|
"FloatFieldMinPositiveValue",
|
|
R"({"optionalFloat": 1.175494e-38})",
|
|
"optional_float: 1.175494e-38");
|
|
RunValidJsonTest(
|
|
"FloatFieldMaxNegativeValue",
|
|
R"({"optionalFloat": -1.175494e-38})",
|
|
"optional_float: -1.175494e-38");
|
|
RunValidJsonTest(
|
|
"FloatFieldMaxPositiveValue",
|
|
R"({"optionalFloat": 3.402823e+38})",
|
|
"optional_float: 3.402823e+38");
|
|
RunValidJsonTest(
|
|
"FloatFieldMinNegativeValue",
|
|
R"({"optionalFloat": 3.402823e+38})",
|
|
"optional_float: 3.402823e+38");
|
|
// Values can be quoted.
|
|
RunValidJsonTest(
|
|
"FloatFieldQuotedValue",
|
|
R"({"optionalFloat": "1"})",
|
|
"optional_float: 1");
|
|
// Special values.
|
|
RunValidJsonTest(
|
|
"FloatFieldNan",
|
|
R"({"optionalFloat": "NaN"})",
|
|
"optional_float: nan");
|
|
RunValidJsonTest(
|
|
"FloatFieldInfinity",
|
|
R"({"optionalFloat": "Infinity"})",
|
|
"optional_float: inf");
|
|
RunValidJsonTest(
|
|
"FloatFieldNegativeInfinity",
|
|
R"({"optionalFloat": "-Infinity"})",
|
|
"optional_float: -inf");
|
|
// Non-cannonical Nan will be correctly normalized.
|
|
{
|
|
TestAllTypes 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", 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", message,
|
|
"optional_float: nan");
|
|
}
|
|
|
|
// Special values must be quoted.
|
|
ExpectParseFailureForJson(
|
|
"FloatFieldNanNotQuoted",
|
|
R"({"optionalFloat": NaN})");
|
|
ExpectParseFailureForJson(
|
|
"FloatFieldInfinityNotQuoted",
|
|
R"({"optionalFloat": Infinity})");
|
|
ExpectParseFailureForJson(
|
|
"FloatFieldNegativeInfinityNotQuoted",
|
|
R"({"optionalFloat": -Infinity})");
|
|
// Parsers should reject out-of-bound values.
|
|
ExpectParseFailureForJson(
|
|
"FloatFieldTooSmall",
|
|
R"({"optionalFloat": -3.502823e+38})");
|
|
ExpectParseFailureForJson(
|
|
"FloatFieldTooLarge",
|
|
R"({"optionalFloat": 3.502823e+38})");
|
|
|
|
// Double fields.
|
|
RunValidJsonTest(
|
|
"DoubleFieldMinPositiveValue",
|
|
R"({"optionalDouble": 2.22507e-308})",
|
|
"optional_double: 2.22507e-308");
|
|
RunValidJsonTest(
|
|
"DoubleFieldMaxNegativeValue",
|
|
R"({"optionalDouble": -2.22507e-308})",
|
|
"optional_double: -2.22507e-308");
|
|
RunValidJsonTest(
|
|
"DoubleFieldMaxPositiveValue",
|
|
R"({"optionalDouble": 1.79769e+308})",
|
|
"optional_double: 1.79769e+308");
|
|
RunValidJsonTest(
|
|
"DoubleFieldMinNegativeValue",
|
|
R"({"optionalDouble": -1.79769e+308})",
|
|
"optional_double: -1.79769e+308");
|
|
// Values can be quoted.
|
|
RunValidJsonTest(
|
|
"DoubleFieldQuotedValue",
|
|
R"({"optionalDouble": "1"})",
|
|
"optional_double: 1");
|
|
// Speical values.
|
|
RunValidJsonTest(
|
|
"DoubleFieldNan",
|
|
R"({"optionalDouble": "NaN"})",
|
|
"optional_double: nan");
|
|
RunValidJsonTest(
|
|
"DoubleFieldInfinity",
|
|
R"({"optionalDouble": "Infinity"})",
|
|
"optional_double: inf");
|
|
RunValidJsonTest(
|
|
"DoubleFieldNegativeInfinity",
|
|
R"({"optionalDouble": "-Infinity"})",
|
|
"optional_double: -inf");
|
|
// Non-cannonical Nan will be correctly normalized.
|
|
{
|
|
TestAllTypes message;
|
|
message.set_optional_double(
|
|
WireFormatLite::DecodeDouble(0x7FFA123456789ABCLL));
|
|
RunValidJsonTestWithProtobufInput(
|
|
"DoubleFieldNormalizeQuietNan", message,
|
|
"optional_double: nan");
|
|
message.set_optional_double(
|
|
WireFormatLite::DecodeDouble(0xFFFBCBA987654321LL));
|
|
RunValidJsonTestWithProtobufInput(
|
|
"DoubleFieldNormalizeSignalingNan", message,
|
|
"optional_double: nan");
|
|
}
|
|
|
|
// Special values must be quoted.
|
|
ExpectParseFailureForJson(
|
|
"DoubleFieldNanNotQuoted",
|
|
R"({"optionalDouble": NaN})");
|
|
ExpectParseFailureForJson(
|
|
"DoubleFieldInfinityNotQuoted",
|
|
R"({"optionalDouble": Infinity})");
|
|
ExpectParseFailureForJson(
|
|
"DoubleFieldNegativeInfinityNotQuoted",
|
|
R"({"optionalDouble": -Infinity})");
|
|
|
|
// Parsers should reject out-of-bound values.
|
|
ExpectParseFailureForJson(
|
|
"DoubleFieldTooSmall",
|
|
R"({"optionalDouble": -1.89769e+308})");
|
|
ExpectParseFailureForJson(
|
|
"DoubleFieldTooLarge",
|
|
R"({"optionalDouble": +1.89769e+308})");
|
|
|
|
// Enum fields.
|
|
RunValidJsonTest(
|
|
"EnumField",
|
|
R"({"optionalNestedEnum": "FOO"})",
|
|
"optional_nested_enum: FOO");
|
|
// Enum values must be represented as strings.
|
|
ExpectParseFailureForJson(
|
|
"EnumFieldNotQuoted",
|
|
R"({"optionalNestedEnum": FOO})");
|
|
// Numeric values are allowed.
|
|
RunValidJsonTest(
|
|
"EnumFieldNumericValueZero",
|
|
R"({"optionalNestedEnum": 0})",
|
|
"optional_nested_enum: FOO");
|
|
RunValidJsonTest(
|
|
"EnumFieldNumericValueNonZero",
|
|
R"({"optionalNestedEnum": 1})",
|
|
"optional_nested_enum: BAR");
|
|
// Unknown enum values are represented as numeric values.
|
|
RunValidJsonTestWithValidator(
|
|
"EnumFieldUnknownValue",
|
|
R"({"optionalNestedEnum": 123})",
|
|
[](const Json::Value& value) {
|
|
return value["optionalNestedEnum"].type() == Json::intValue &&
|
|
value["optionalNestedEnum"].asInt() == 123;
|
|
});
|
|
|
|
// String fields.
|
|
RunValidJsonTest(
|
|
"StringField",
|
|
R"({"optionalString": "Hello world!"})",
|
|
"optional_string: \"Hello world!\"");
|
|
RunValidJsonTest(
|
|
"StringFieldUnicode",
|
|
// Google in Chinese.
|
|
R"({"optionalString": "谷歌"})",
|
|
R"(optional_string: "谷歌")");
|
|
RunValidJsonTest(
|
|
"StringFieldEscape",
|
|
R"({"optionalString": "\"\\\/\b\f\n\r\t"})",
|
|
R"(optional_string: "\"\\/\b\f\n\r\t")");
|
|
RunValidJsonTest(
|
|
"StringFieldUnicodeEscape",
|
|
R"({"optionalString": "\u8C37\u6B4C"})",
|
|
R"(optional_string: "谷歌")");
|
|
RunValidJsonTest(
|
|
"StringFieldUnicodeEscapeWithLowercaseHexLetters",
|
|
R"({"optionalString": "\u8c37\u6b4c"})",
|
|
R"(optional_string: "谷歌")");
|
|
RunValidJsonTest(
|
|
"StringFieldSurrogatePair",
|
|
// The character is an emoji: grinning face with smiling eyes. 😁
|
|
R"({"optionalString": "\uD83D\uDE01"})",
|
|
R"(optional_string: "\xF0\x9F\x98\x81")");
|
|
|
|
// Unicode escapes must start with "\u" (lowercase u).
|
|
ExpectParseFailureForJson(
|
|
"StringFieldUppercaseEscapeLetter",
|
|
R"({"optionalString": "\U8C37\U6b4C"})");
|
|
ExpectParseFailureForJson(
|
|
"StringFieldInvalidEscape",
|
|
R"({"optionalString": "\uXXXX\u6B4C"})");
|
|
ExpectParseFailureForJson(
|
|
"StringFieldUnterminatedEscape",
|
|
R"({"optionalString": "\u8C3"})");
|
|
ExpectParseFailureForJson(
|
|
"StringFieldUnpairedHighSurrogate",
|
|
R"({"optionalString": "\uD800"})");
|
|
ExpectParseFailureForJson(
|
|
"StringFieldUnpairedLowSurrogate",
|
|
R"({"optionalString": "\uDC00"})");
|
|
ExpectParseFailureForJson(
|
|
"StringFieldSurrogateInWrongOrder",
|
|
R"({"optionalString": "\uDE01\uD83D"})");
|
|
ExpectParseFailureForJson(
|
|
"StringFieldNotAString",
|
|
R"({"optionalString": 12345})");
|
|
|
|
// Bytes fields.
|
|
RunValidJsonTest(
|
|
"BytesField",
|
|
R"({"optionalBytes": "AQI="})",
|
|
R"(optional_bytes: "\x01\x02")");
|
|
ExpectParseFailureForJson(
|
|
"BytesFieldNoPadding",
|
|
R"({"optionalBytes": "AQI"})");
|
|
ExpectParseFailureForJson(
|
|
"BytesFieldInvalidBase64Characters",
|
|
R"({"optionalBytes": "-_=="})");
|
|
|
|
// Message fields.
|
|
RunValidJsonTest(
|
|
"MessageField",
|
|
R"({"optionalNestedMessage": {"a": 1234}})",
|
|
"optional_nested_message: {a: 1234}");
|
|
|
|
// Oneof fields.
|
|
ExpectParseFailureForJson(
|
|
"OneofFieldDuplicate",
|
|
R"({"oneofUint32": 1, "oneofString": "test"})");
|
|
// Ensure zero values for oneof make it out/backs.
|
|
{
|
|
TestAllTypes message;
|
|
message.set_oneof_uint32(0);
|
|
RunValidProtobufTest(
|
|
"OneofZeroUint32", message, "oneof_uint32: 0");
|
|
message.mutable_oneof_nested_message()->set_a(0);
|
|
RunValidProtobufTest(
|
|
"OneofZeroMessage", message, "oneof_nested_message: {}");
|
|
message.set_oneof_string("");
|
|
RunValidProtobufTest(
|
|
"OneofZeroString", message, "oneof_string: \"\"");
|
|
message.set_oneof_bytes("");
|
|
RunValidProtobufTest(
|
|
"OneofZeroBytes", message, "oneof_bytes: \"\"");
|
|
message.set_oneof_bool(false);
|
|
RunValidProtobufTest(
|
|
"OneofZeroBool", message, "oneof_bool: false");
|
|
message.set_oneof_uint64(0);
|
|
RunValidProtobufTest(
|
|
"OneofZeroUint64", message, "oneof_uint64: 0");
|
|
message.set_oneof_float(0.0f);
|
|
RunValidProtobufTest(
|
|
"OneofZeroFloat", message, "oneof_float: 0");
|
|
message.set_oneof_double(0.0);
|
|
RunValidProtobufTest(
|
|
"OneofZeroDouble", message, "oneof_double: 0");
|
|
message.set_oneof_enum(TestAllTypes::FOO);
|
|
RunValidProtobufTest(
|
|
"OneofZeroEnum", message, "oneof_enum: FOO");
|
|
}
|
|
RunValidJsonTest(
|
|
"OneofZeroUint32",
|
|
R"({"oneofUint32": 0})", "oneof_uint32: 0");
|
|
RunValidJsonTest(
|
|
"OneofZeroMessage",
|
|
R"({"oneofNestedMessage": {}})", "oneof_nested_message: {}");
|
|
RunValidJsonTest(
|
|
"OneofZeroString",
|
|
R"({"oneofString": ""})", "oneof_string: \"\"");
|
|
RunValidJsonTest(
|
|
"OneofZeroBytes",
|
|
R"({"oneofBytes": ""})", "oneof_bytes: \"\"");
|
|
RunValidJsonTest(
|
|
"OneofZeroBool",
|
|
R"({"oneofBool": false})", "oneof_bool: false");
|
|
RunValidJsonTest(
|
|
"OneofZeroUint64",
|
|
R"({"oneofUint64": 0})", "oneof_uint64: 0");
|
|
RunValidJsonTest(
|
|
"OneofZeroFloat",
|
|
R"({"oneofFloat": 0.0})", "oneof_float: 0");
|
|
RunValidJsonTest(
|
|
"OneofZeroDouble",
|
|
R"({"oneofDouble": 0.0})", "oneof_double: 0");
|
|
RunValidJsonTest(
|
|
"OneofZeroEnum",
|
|
R"({"oneofEnum":"FOO"})", "oneof_enum: FOO");
|
|
|
|
// Repeated fields.
|
|
RunValidJsonTest(
|
|
"PrimitiveRepeatedField",
|
|
R"({"repeatedInt32": [1, 2, 3, 4]})",
|
|
"repeated_int32: [1, 2, 3, 4]");
|
|
RunValidJsonTest(
|
|
"EnumRepeatedField",
|
|
R"({"repeatedNestedEnum": ["FOO", "BAR", "BAZ"]})",
|
|
"repeated_nested_enum: [FOO, BAR, BAZ]");
|
|
RunValidJsonTest(
|
|
"StringRepeatedField",
|
|
R"({"repeatedString": ["Hello", "world"]})",
|
|
R"(repeated_string: ["Hello", "world"])");
|
|
RunValidJsonTest(
|
|
"BytesRepeatedField",
|
|
R"({"repeatedBytes": ["AAEC", "AQI="]})",
|
|
R"(repeated_bytes: ["\x00\x01\x02", "\x01\x02"])");
|
|
RunValidJsonTest(
|
|
"MessageRepeatedField",
|
|
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",
|
|
R"({"repeatedInt32": [1, false, 3, 4]})");
|
|
ExpectParseFailureForJson(
|
|
"RepeatedFieldWrongElementTypeExpectingIntegersGotString",
|
|
R"({"repeatedInt32": [1, 2, "name", 4]})");
|
|
ExpectParseFailureForJson(
|
|
"RepeatedFieldWrongElementTypeExpectingIntegersGotMessage",
|
|
R"({"repeatedInt32": [1, 2, 3, {"a": 4}]})");
|
|
ExpectParseFailureForJson(
|
|
"RepeatedFieldWrongElementTypeExpectingStringsGotInt",
|
|
R"({"repeatedString": ["1", 2, "3", "4"]})");
|
|
ExpectParseFailureForJson(
|
|
"RepeatedFieldWrongElementTypeExpectingStringsGotBool",
|
|
R"({"repeatedString": ["1", "2", false, "4"]})");
|
|
ExpectParseFailureForJson(
|
|
"RepeatedFieldWrongElementTypeExpectingStringsGotMessage",
|
|
R"({"repeatedString": ["1", 2, "3", {"a": 4}]})");
|
|
ExpectParseFailureForJson(
|
|
"RepeatedFieldWrongElementTypeExpectingMessagesGotInt",
|
|
R"({"repeatedNestedMessage": [{"a": 1}, 2]})");
|
|
ExpectParseFailureForJson(
|
|
"RepeatedFieldWrongElementTypeExpectingMessagesGotBool",
|
|
R"({"repeatedNestedMessage": [{"a": 1}, false]})");
|
|
ExpectParseFailureForJson(
|
|
"RepeatedFieldWrongElementTypeExpectingMessagesGotString",
|
|
R"({"repeatedNestedMessage": [{"a": 1}, "2"]})");
|
|
// Trailing comma in the repeated field is not allowed.
|
|
ExpectParseFailureForJson(
|
|
"RepeatedFieldTrailingComma",
|
|
R"({"repeatedInt32": [1, 2, 3, 4,]})");
|
|
ExpectParseFailureForJson(
|
|
"RepeatedFieldTrailingCommaWithSpace",
|
|
"{\"repeatedInt32\": [1, 2, 3, 4 ,]}");
|
|
ExpectParseFailureForJson(
|
|
"RepeatedFieldTrailingCommaWithSpaceCommaSpace",
|
|
"{\"repeatedInt32\": [1, 2, 3, 4 , ]}");
|
|
ExpectParseFailureForJson(
|
|
"RepeatedFieldTrailingCommaWithNewlines",
|
|
"{\"repeatedInt32\": [\n 1,\n 2,\n 3,\n 4,\n]}");
|
|
|
|
// Map fields.
|
|
RunValidJsonTest(
|
|
"Int32MapField",
|
|
R"({"mapInt32Int32": {"1": 2, "3": 4}})",
|
|
"map_int32_int32: {key: 1 value: 2}"
|
|
"map_int32_int32: {key: 3 value: 4}");
|
|
ExpectParseFailureForJson(
|
|
"Int32MapFieldKeyNotQuoted",
|
|
R"({"mapInt32Int32": {1: 2, 3: 4}})");
|
|
RunValidJsonTest(
|
|
"Uint32MapField",
|
|
R"({"mapUint32Uint32": {"1": 2, "3": 4}})",
|
|
"map_uint32_uint32: {key: 1 value: 2}"
|
|
"map_uint32_uint32: {key: 3 value: 4}");
|
|
ExpectParseFailureForJson(
|
|
"Uint32MapFieldKeyNotQuoted",
|
|
R"({"mapUint32Uint32": {1: 2, 3: 4}})");
|
|
RunValidJsonTest(
|
|
"Int64MapField",
|
|
R"({"mapInt64Int64": {"1": 2, "3": 4}})",
|
|
"map_int64_int64: {key: 1 value: 2}"
|
|
"map_int64_int64: {key: 3 value: 4}");
|
|
ExpectParseFailureForJson(
|
|
"Int64MapFieldKeyNotQuoted",
|
|
R"({"mapInt64Int64": {1: 2, 3: 4}})");
|
|
RunValidJsonTest(
|
|
"Uint64MapField",
|
|
R"({"mapUint64Uint64": {"1": 2, "3": 4}})",
|
|
"map_uint64_uint64: {key: 1 value: 2}"
|
|
"map_uint64_uint64: {key: 3 value: 4}");
|
|
ExpectParseFailureForJson(
|
|
"Uint64MapFieldKeyNotQuoted",
|
|
R"({"mapUint64Uint64": {1: 2, 3: 4}})");
|
|
RunValidJsonTest(
|
|
"BoolMapField",
|
|
R"({"mapBoolBool": {"true": true, "false": false}})",
|
|
"map_bool_bool: {key: true value: true}"
|
|
"map_bool_bool: {key: false value: false}");
|
|
ExpectParseFailureForJson(
|
|
"BoolMapFieldKeyNotQuoted",
|
|
R"({"mapBoolBool": {true: true, false: false}})");
|
|
RunValidJsonTest(
|
|
"MessageMapField",
|
|
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",
|
|
R"({"mapInt32Int32": {"\u0031": 2}})",
|
|
"map_int32_int32: {key: 1 value: 2}");
|
|
RunValidJsonTest(
|
|
"Int64MapEscapedKey",
|
|
R"({"mapInt64Int64": {"\u0031": 2}})",
|
|
"map_int64_int64: {key: 1 value: 2}");
|
|
RunValidJsonTest(
|
|
"BoolMapEscapedKey",
|
|
R"({"mapBoolBool": {"tr\u0075e": true}})",
|
|
"map_bool_bool: {key: true value: true}");
|
|
|
|
// "null" is accepted for all fields types.
|
|
RunValidJsonTest(
|
|
"AllFieldAcceptNull",
|
|
R"({
|
|
"optionalInt32": null,
|
|
"optionalInt64": null,
|
|
"optionalUint32": null,
|
|
"optionalUint64": null,
|
|
"optionalBool": null,
|
|
"optionalString": null,
|
|
"optionalBytes": null,
|
|
"optionalNestedEnum": null,
|
|
"optionalNestedMessage": null,
|
|
"repeatedInt32": null,
|
|
"repeatedInt64": null,
|
|
"repeatedUint32": null,
|
|
"repeatedUint64": 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",
|
|
R"({"repeatedInt32": [1, null, 2]})");
|
|
ExpectParseFailureForJson(
|
|
"RepeatedFieldMessageElementIsNull",
|
|
R"({"repeatedNestedMessage": [{"a":1}, null, {"a":2}]})");
|
|
// Map field keys cannot be null.
|
|
ExpectParseFailureForJson(
|
|
"MapFieldKeyIsNull",
|
|
R"({"mapInt32Int32": {null: 1}})");
|
|
// Map field values cannot be null.
|
|
ExpectParseFailureForJson(
|
|
"MapFieldValueIsNull",
|
|
R"({"mapInt32Int32": {"0": null}})");
|
|
|
|
// http://www.rfc-editor.org/rfc/rfc7159.txt says strings have to use double
|
|
// quotes.
|
|
ExpectParseFailureForJson(
|
|
"StringFieldSingleQuoteKey",
|
|
R"({'optionalString': "Hello world!"})");
|
|
ExpectParseFailureForJson(
|
|
"StringFieldSingleQuoteValue",
|
|
R"({"optionalString": 'Hello world!'})");
|
|
ExpectParseFailureForJson(
|
|
"StringFieldSingleQuoteBoth",
|
|
R"({'optionalString': 'Hello world!'})");
|
|
|
|
// Wrapper types.
|
|
RunValidJsonTest(
|
|
"OptionalBoolWrapper",
|
|
R"({"optionalBoolWrapper": false})",
|
|
"optional_bool_wrapper: {value: false}");
|
|
RunValidJsonTest(
|
|
"OptionalInt32Wrapper",
|
|
R"({"optionalInt32Wrapper": 0})",
|
|
"optional_int32_wrapper: {value: 0}");
|
|
RunValidJsonTest(
|
|
"OptionalUint32Wrapper",
|
|
R"({"optionalUint32Wrapper": 0})",
|
|
"optional_uint32_wrapper: {value: 0}");
|
|
RunValidJsonTest(
|
|
"OptionalInt64Wrapper",
|
|
R"({"optionalInt64Wrapper": 0})",
|
|
"optional_int64_wrapper: {value: 0}");
|
|
RunValidJsonTest(
|
|
"OptionalUint64Wrapper",
|
|
R"({"optionalUint64Wrapper": 0})",
|
|
"optional_uint64_wrapper: {value: 0}");
|
|
RunValidJsonTest(
|
|
"OptionalFloatWrapper",
|
|
R"({"optionalFloatWrapper": 0})",
|
|
"optional_float_wrapper: {value: 0}");
|
|
RunValidJsonTest(
|
|
"OptionalDoubleWrapper",
|
|
R"({"optionalDoubleWrapper": 0})",
|
|
"optional_double_wrapper: {value: 0}");
|
|
RunValidJsonTest(
|
|
"OptionalStringWrapper",
|
|
R"({"optionalStringWrapper": ""})",
|
|
R"(optional_string_wrapper: {value: ""})");
|
|
RunValidJsonTest(
|
|
"OptionalBytesWrapper",
|
|
R"({"optionalBytesWrapper": ""})",
|
|
R"(optional_bytes_wrapper: {value: ""})");
|
|
RunValidJsonTest(
|
|
"OptionalWrapperTypesWithNonDefaultValue",
|
|
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",
|
|
R"({"repeatedBoolWrapper": [true, false]})",
|
|
"repeated_bool_wrapper: {value: true}"
|
|
"repeated_bool_wrapper: {value: false}");
|
|
RunValidJsonTest(
|
|
"RepeatedInt32Wrapper",
|
|
R"({"repeatedInt32Wrapper": [0, 1]})",
|
|
"repeated_int32_wrapper: {value: 0}"
|
|
"repeated_int32_wrapper: {value: 1}");
|
|
RunValidJsonTest(
|
|
"RepeatedUint32Wrapper",
|
|
R"({"repeatedUint32Wrapper": [0, 1]})",
|
|
"repeated_uint32_wrapper: {value: 0}"
|
|
"repeated_uint32_wrapper: {value: 1}");
|
|
RunValidJsonTest(
|
|
"RepeatedInt64Wrapper",
|
|
R"({"repeatedInt64Wrapper": [0, 1]})",
|
|
"repeated_int64_wrapper: {value: 0}"
|
|
"repeated_int64_wrapper: {value: 1}");
|
|
RunValidJsonTest(
|
|
"RepeatedUint64Wrapper",
|
|
R"({"repeatedUint64Wrapper": [0, 1]})",
|
|
"repeated_uint64_wrapper: {value: 0}"
|
|
"repeated_uint64_wrapper: {value: 1}");
|
|
RunValidJsonTest(
|
|
"RepeatedFloatWrapper",
|
|
R"({"repeatedFloatWrapper": [0, 1]})",
|
|
"repeated_float_wrapper: {value: 0}"
|
|
"repeated_float_wrapper: {value: 1}");
|
|
RunValidJsonTest(
|
|
"RepeatedDoubleWrapper",
|
|
R"({"repeatedDoubleWrapper": [0, 1]})",
|
|
"repeated_double_wrapper: {value: 0}"
|
|
"repeated_double_wrapper: {value: 1}");
|
|
RunValidJsonTest(
|
|
"RepeatedStringWrapper",
|
|
R"({"repeatedStringWrapper": ["", "AQI="]})",
|
|
R"(
|
|
repeated_string_wrapper: {value: ""}
|
|
repeated_string_wrapper: {value: "AQI="}
|
|
)");
|
|
RunValidJsonTest(
|
|
"RepeatedBytesWrapper",
|
|
R"({"repeatedBytesWrapper": ["", "AQI="]})",
|
|
R"(
|
|
repeated_bytes_wrapper: {value: ""}
|
|
repeated_bytes_wrapper: {value: "\x01\x02"}
|
|
)");
|
|
RunValidJsonTest(
|
|
"WrapperTypesWithNullValue",
|
|
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",
|
|
R"({"optionalDuration": "-315576000000.999999999s"})",
|
|
"optional_duration: {seconds: -315576000000 nanos: -999999999}");
|
|
RunValidJsonTest(
|
|
"DurationMaxValue",
|
|
R"({"optionalDuration": "315576000000.999999999s"})",
|
|
"optional_duration: {seconds: 315576000000 nanos: 999999999}");
|
|
RunValidJsonTest(
|
|
"DurationRepeatedValue",
|
|
R"({"repeatedDuration": ["1.5s", "-1.5s"]})",
|
|
"repeated_duration: {seconds: 1 nanos: 500000000}"
|
|
"repeated_duration: {seconds: -1 nanos: -500000000}");
|
|
|
|
ExpectParseFailureForJson(
|
|
"DurationMissingS",
|
|
R"({"optionalDuration": "1"})");
|
|
ExpectParseFailureForJson(
|
|
"DurationJsonInputTooSmall",
|
|
R"({"optionalDuration": "-315576000001.000000000s"})");
|
|
ExpectParseFailureForJson(
|
|
"DurationJsonInputTooLarge",
|
|
R"({"optionalDuration": "315576000001.000000000s"})");
|
|
ExpectSerializeFailureForJson(
|
|
"DurationProtoInputTooSmall",
|
|
"optional_duration: {seconds: -315576000001 nanos: 0}");
|
|
ExpectSerializeFailureForJson(
|
|
"DurationProtoInputTooLarge",
|
|
"optional_duration: {seconds: 315576000001 nanos: 0}");
|
|
|
|
RunValidJsonTestWithValidator(
|
|
"DurationHasZeroFractionalDigit",
|
|
R"({"optionalDuration": "1.000000000s"})",
|
|
[](const Json::Value& value) {
|
|
return value["optionalDuration"].asString() == "1s";
|
|
});
|
|
RunValidJsonTestWithValidator(
|
|
"DurationHas3FractionalDigits",
|
|
R"({"optionalDuration": "1.010000000s"})",
|
|
[](const Json::Value& value) {
|
|
return value["optionalDuration"].asString() == "1.010s";
|
|
});
|
|
RunValidJsonTestWithValidator(
|
|
"DurationHas6FractionalDigits",
|
|
R"({"optionalDuration": "1.000010000s"})",
|
|
[](const Json::Value& value) {
|
|
return value["optionalDuration"].asString() == "1.000010s";
|
|
});
|
|
RunValidJsonTestWithValidator(
|
|
"DurationHas9FractionalDigits",
|
|
R"({"optionalDuration": "1.000000010s"})",
|
|
[](const Json::Value& value) {
|
|
return value["optionalDuration"].asString() == "1.000000010s";
|
|
});
|
|
|
|
// Timestamp
|
|
RunValidJsonTest(
|
|
"TimestampMinValue",
|
|
R"({"optionalTimestamp": "0001-01-01T00:00:00Z"})",
|
|
"optional_timestamp: {seconds: -62135596800}");
|
|
RunValidJsonTest(
|
|
"TimestampMaxValue",
|
|
R"({"optionalTimestamp": "9999-12-31T23:59:59.999999999Z"})",
|
|
"optional_timestamp: {seconds: 253402300799 nanos: 999999999}");
|
|
RunValidJsonTest(
|
|
"TimestampRepeatedValue",
|
|
R"({
|
|
"repeatedTimestamp": [
|
|
"0001-01-01T00:00:00Z",
|
|
"9999-12-31T23:59:59.999999999Z"
|
|
]
|
|
})",
|
|
"repeated_timestamp: {seconds: -62135596800}"
|
|
"repeated_timestamp: {seconds: 253402300799 nanos: 999999999}");
|
|
RunValidJsonTest(
|
|
"TimestampWithPositiveOffset",
|
|
R"({"optionalTimestamp": "1970-01-01T08:00:00+08:00"})",
|
|
"optional_timestamp: {seconds: 0}");
|
|
RunValidJsonTest(
|
|
"TimestampWithNegativeOffset",
|
|
R"({"optionalTimestamp": "1969-12-31T16:00:00-08:00"})",
|
|
"optional_timestamp: {seconds: 0}");
|
|
|
|
ExpectParseFailureForJson(
|
|
"TimestampJsonInputTooSmall",
|
|
R"({"optionalTimestamp": "0000-01-01T00:00:00Z"})");
|
|
ExpectParseFailureForJson(
|
|
"TimestampJsonInputTooLarge",
|
|
R"({"optionalTimestamp": "10000-01-01T00:00:00Z"})");
|
|
ExpectParseFailureForJson(
|
|
"TimestampJsonInputMissingZ",
|
|
R"({"optionalTimestamp": "0001-01-01T00:00:00"})");
|
|
ExpectParseFailureForJson(
|
|
"TimestampJsonInputMissingT",
|
|
R"({"optionalTimestamp": "0001-01-01 00:00:00Z"})");
|
|
ExpectParseFailureForJson(
|
|
"TimestampJsonInputLowercaseZ",
|
|
R"({"optionalTimestamp": "0001-01-01T00:00:00z"})");
|
|
ExpectParseFailureForJson(
|
|
"TimestampJsonInputLowercaseT",
|
|
R"({"optionalTimestamp": "0001-01-01t00:00:00Z"})");
|
|
ExpectSerializeFailureForJson(
|
|
"TimestampProtoInputTooSmall",
|
|
"optional_timestamp: {seconds: -62135596801}");
|
|
ExpectSerializeFailureForJson(
|
|
"TimestampProtoInputTooLarge",
|
|
"optional_timestamp: {seconds: 253402300800}");
|
|
RunValidJsonTestWithValidator(
|
|
"TimestampZeroNormalized",
|
|
R"({"optionalTimestamp": "1969-12-31T16:00:00-08:00"})",
|
|
[](const Json::Value& value) {
|
|
return value["optionalTimestamp"].asString() ==
|
|
"1970-01-01T00:00:00Z";
|
|
});
|
|
RunValidJsonTestWithValidator(
|
|
"TimestampHasZeroFractionalDigit",
|
|
R"({"optionalTimestamp": "1970-01-01T00:00:00.000000000Z"})",
|
|
[](const Json::Value& value) {
|
|
return value["optionalTimestamp"].asString() ==
|
|
"1970-01-01T00:00:00Z";
|
|
});
|
|
RunValidJsonTestWithValidator(
|
|
"TimestampHas3FractionalDigits",
|
|
R"({"optionalTimestamp": "1970-01-01T00:00:00.010000000Z"})",
|
|
[](const Json::Value& value) {
|
|
return value["optionalTimestamp"].asString() ==
|
|
"1970-01-01T00:00:00.010Z";
|
|
});
|
|
RunValidJsonTestWithValidator(
|
|
"TimestampHas6FractionalDigits",
|
|
R"({"optionalTimestamp": "1970-01-01T00:00:00.000010000Z"})",
|
|
[](const Json::Value& value) {
|
|
return value["optionalTimestamp"].asString() ==
|
|
"1970-01-01T00:00:00.000010Z";
|
|
});
|
|
RunValidJsonTestWithValidator(
|
|
"TimestampHas9FractionalDigits",
|
|
R"({"optionalTimestamp": "1970-01-01T00:00:00.000000010Z"})",
|
|
[](const Json::Value& value) {
|
|
return value["optionalTimestamp"].asString() ==
|
|
"1970-01-01T00:00:00.000000010Z";
|
|
});
|
|
|
|
// FieldMask
|
|
RunValidJsonTest(
|
|
"FieldMask",
|
|
R"({"optionalFieldMask": "foo,barBaz"})",
|
|
R"(optional_field_mask: {paths: "foo" paths: "bar_baz"})");
|
|
ExpectParseFailureForJson(
|
|
"FieldMaskInvalidCharacter",
|
|
R"({"optionalFieldMask": "foo,bar_bar"})");
|
|
ExpectSerializeFailureForJson(
|
|
"FieldMaskPathsDontRoundTrip",
|
|
R"(optional_field_mask: {paths: "fooBar"})");
|
|
ExpectSerializeFailureForJson(
|
|
"FieldMaskNumbersDontRoundTrip",
|
|
R"(optional_field_mask: {paths: "foo_3_bar"})");
|
|
ExpectSerializeFailureForJson(
|
|
"FieldMaskTooManyUnderscore",
|
|
R"(optional_field_mask: {paths: "foo__bar"})");
|
|
|
|
// Struct
|
|
RunValidJsonTest(
|
|
"Struct",
|
|
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
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
)");
|
|
// Value
|
|
RunValidJsonTest(
|
|
"ValueAcceptInteger",
|
|
R"({"optionalValue": 1})",
|
|
"optional_value: { number_value: 1}");
|
|
RunValidJsonTest(
|
|
"ValueAcceptFloat",
|
|
R"({"optionalValue": 1.5})",
|
|
"optional_value: { number_value: 1.5}");
|
|
RunValidJsonTest(
|
|
"ValueAcceptBool",
|
|
R"({"optionalValue": false})",
|
|
"optional_value: { bool_value: false}");
|
|
RunValidJsonTest(
|
|
"ValueAcceptNull",
|
|
R"({"optionalValue": null})",
|
|
"optional_value: { null_value: NULL_VALUE}");
|
|
RunValidJsonTest(
|
|
"ValueAcceptString",
|
|
R"({"optionalValue": "hello"})",
|
|
R"(optional_value: { string_value: "hello"})");
|
|
RunValidJsonTest(
|
|
"ValueAcceptList",
|
|
R"({"optionalValue": [0, "hello"]})",
|
|
R"(
|
|
optional_value: {
|
|
list_value: {
|
|
values: {
|
|
number_value: 0
|
|
}
|
|
values: {
|
|
string_value: "hello"
|
|
}
|
|
}
|
|
}
|
|
)");
|
|
RunValidJsonTest(
|
|
"ValueAcceptObject",
|
|
R"({"optionalValue": {"value": 1}})",
|
|
R"(
|
|
optional_value: {
|
|
struct_value: {
|
|
fields: {
|
|
key: "value"
|
|
value: {
|
|
number_value: 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
)");
|
|
|
|
// Any
|
|
RunValidJsonTest(
|
|
"Any",
|
|
R"({
|
|
"optionalAny": {
|
|
"@type": "type.googleapis.com/conformance.TestAllTypes",
|
|
"optionalInt32": 12345
|
|
}
|
|
})",
|
|
R"(
|
|
optional_any: {
|
|
[type.googleapis.com/conformance.TestAllTypes] {
|
|
optional_int32: 12345
|
|
}
|
|
}
|
|
)");
|
|
RunValidJsonTest(
|
|
"AnyNested",
|
|
R"({
|
|
"optionalAny": {
|
|
"@type": "type.googleapis.com/google.protobuf.Any",
|
|
"value": {
|
|
"@type": "type.googleapis.com/conformance.TestAllTypes",
|
|
"optionalInt32": 12345
|
|
}
|
|
}
|
|
})",
|
|
R"(
|
|
optional_any: {
|
|
[type.googleapis.com/google.protobuf.Any] {
|
|
[type.googleapis.com/conformance.TestAllTypes] {
|
|
optional_int32: 12345
|
|
}
|
|
}
|
|
}
|
|
)");
|
|
// The special "@type" tag is not required to appear first.
|
|
RunValidJsonTest(
|
|
"AnyUnorderedTypeTag",
|
|
R"({
|
|
"optionalAny": {
|
|
"optionalInt32": 12345,
|
|
"@type": "type.googleapis.com/conformance.TestAllTypes"
|
|
}
|
|
})",
|
|
R"(
|
|
optional_any: {
|
|
[type.googleapis.com/conformance.TestAllTypes] {
|
|
optional_int32: 12345
|
|
}
|
|
}
|
|
)");
|
|
// Well-known types in Any.
|
|
RunValidJsonTest(
|
|
"AnyWithInt32ValueWrapper",
|
|
R"({
|
|
"optionalAny": {
|
|
"@type": "type.googleapis.com/google.protobuf.Int32Value",
|
|
"value": 12345
|
|
}
|
|
})",
|
|
R"(
|
|
optional_any: {
|
|
[type.googleapis.com/google.protobuf.Int32Value] {
|
|
value: 12345
|
|
}
|
|
}
|
|
)");
|
|
RunValidJsonTest(
|
|
"AnyWithDuration",
|
|
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",
|
|
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",
|
|
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",
|
|
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",
|
|
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",
|
|
R"({
|
|
"optionalAny": {
|
|
"@type": "type.googleapis.com/google.protobuf.Value",
|
|
"value": 1
|
|
}
|
|
})",
|
|
R"(
|
|
optional_any: {
|
|
[type.googleapis.com/google.protobuf.Value] {
|
|
number_value: 1
|
|
}
|
|
}
|
|
)");
|
|
|
|
bool ok = true;
|
|
if (!CheckSetEmpty(expected_to_fail_, "nonexistent_tests.txt",
|
|
"These tests were listed in the failure list, but they "
|
|
"don't exist. Remove them from the failure list by "
|
|
"running:\n"
|
|
" ./update_failure_list.py " + failure_list_filename_ +
|
|
" --remove nonexistent_tests.txt")) {
|
|
ok = false;
|
|
}
|
|
if (!CheckSetEmpty(unexpected_failing_tests_, "failing_tests.txt",
|
|
"These tests failed. If they can't be fixed right now, "
|
|
"you can add them to the failure list so the overall "
|
|
"suite can succeed. Add them to the failure list by "
|
|
"running:\n"
|
|
" ./update_failure_list.py " + failure_list_filename_ +
|
|
" --add failing_tests.txt")) {
|
|
ok = false;
|
|
}
|
|
if (!CheckSetEmpty(unexpected_succeeding_tests_, "succeeding_tests.txt",
|
|
"These tests succeeded, even though they were listed in "
|
|
"the failure list. Remove them from the failure list "
|
|
"by running:\n"
|
|
" ./update_failure_list.py " + failure_list_filename_ +
|
|
" --remove succeeding_tests.txt")) {
|
|
ok = false;
|
|
}
|
|
|
|
if (verbose_) {
|
|
CheckSetEmpty(skipped_, "",
|
|
"These tests were skipped (probably because support for some "
|
|
"features is not implemented)");
|
|
}
|
|
|
|
StringAppendF(&output_,
|
|
"CONFORMANCE SUITE %s: %d successes, %d skipped, "
|
|
"%d expected failures, %d unexpected failures.\n",
|
|
ok ? "PASSED" : "FAILED", successes_, skipped_.size(),
|
|
expected_failures_, unexpected_failing_tests_.size());
|
|
StringAppendF(&output_, "\n");
|
|
|
|
output->assign(output_);
|
|
|
|
return ok;
|
|
}
|
|
|
|
} // namespace protobuf
|
|
} // namespace google
|