1// Protocol Buffers - Google's data interchange format 2// Copyright 2008 Google Inc. All rights reserved. 3// https://developers.google.com/protocol-buffers/ 4// 5// Redistribution and use in source and binary forms, with or without 6// modification, are permitted provided that the following conditions are 7// met: 8// 9// * Redistributions of source code must retain the above copyright 10// notice, this list of conditions and the following disclaimer. 11// * Redistributions in binary form must reproduce the above 12// copyright notice, this list of conditions and the following disclaimer 13// in the documentation and/or other materials provided with the 14// distribution. 15// * Neither the name of Google Inc. nor the names of its 16// contributors may be used to endorse or promote products derived from 17// this software without specific prior written permission. 18// 19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31#include <stdarg.h> 32#include <string> 33 34#include "conformance.pb.h" 35#include "conformance_test.h" 36#include <google/protobuf/stubs/common.h> 37#include <google/protobuf/stubs/stringprintf.h> 38#include <google/protobuf/text_format.h> 39#include <google/protobuf/util/json_util.h> 40#include <google/protobuf/util/field_comparator.h> 41#include <google/protobuf/util/message_differencer.h> 42#include <google/protobuf/util/type_resolver_util.h> 43#include <google/protobuf/wire_format_lite.h> 44 45#include "third_party/jsoncpp/json.h" 46 47using conformance::ConformanceRequest; 48using conformance::ConformanceResponse; 49using conformance::TestAllTypes; 50using conformance::WireFormat; 51using google::protobuf::Descriptor; 52using google::protobuf::FieldDescriptor; 53using google::protobuf::internal::WireFormatLite; 54using google::protobuf::TextFormat; 55using google::protobuf::util::DefaultFieldComparator; 56using google::protobuf::util::JsonToBinaryString; 57using google::protobuf::util::MessageDifferencer; 58using google::protobuf::util::NewTypeResolverForDescriptorPool; 59using google::protobuf::util::Status; 60using std::string; 61 62namespace { 63 64static const char kTypeUrlPrefix[] = "type.googleapis.com"; 65 66static string GetTypeUrl(const Descriptor* message) { 67 return string(kTypeUrlPrefix) + "/" + message->full_name(); 68} 69 70/* Routines for building arbitrary protos *************************************/ 71 72// We would use CodedOutputStream except that we want more freedom to build 73// arbitrary protos (even invalid ones). 74 75const string empty; 76 77string cat(const string& a, const string& b, 78 const string& c = empty, 79 const string& d = empty, 80 const string& e = empty, 81 const string& f = empty, 82 const string& g = empty, 83 const string& h = empty, 84 const string& i = empty, 85 const string& j = empty, 86 const string& k = empty, 87 const string& l = empty) { 88 string ret; 89 ret.reserve(a.size() + b.size() + c.size() + d.size() + e.size() + f.size() + 90 g.size() + h.size() + i.size() + j.size() + k.size() + l.size()); 91 ret.append(a); 92 ret.append(b); 93 ret.append(c); 94 ret.append(d); 95 ret.append(e); 96 ret.append(f); 97 ret.append(g); 98 ret.append(h); 99 ret.append(i); 100 ret.append(j); 101 ret.append(k); 102 ret.append(l); 103 return ret; 104} 105 106// The maximum number of bytes that it takes to encode a 64-bit varint. 107#define VARINT_MAX_LEN 10 108 109size_t vencode64(uint64_t val, char *buf) { 110 if (val == 0) { buf[0] = 0; return 1; } 111 size_t i = 0; 112 while (val) { 113 uint8_t byte = val & 0x7fU; 114 val >>= 7; 115 if (val) byte |= 0x80U; 116 buf[i++] = byte; 117 } 118 return i; 119} 120 121string varint(uint64_t x) { 122 char buf[VARINT_MAX_LEN]; 123 size_t len = vencode64(x, buf); 124 return string(buf, len); 125} 126 127// TODO: proper byte-swapping for big-endian machines. 128string fixed32(void *data) { return string(static_cast<char*>(data), 4); } 129string fixed64(void *data) { return string(static_cast<char*>(data), 8); } 130 131string delim(const string& buf) { return cat(varint(buf.size()), buf); } 132string uint32(uint32_t u32) { return fixed32(&u32); } 133string uint64(uint64_t u64) { return fixed64(&u64); } 134string flt(float f) { return fixed32(&f); } 135string dbl(double d) { return fixed64(&d); } 136string zz32(int32_t x) { return varint(WireFormatLite::ZigZagEncode32(x)); } 137string zz64(int64_t x) { return varint(WireFormatLite::ZigZagEncode64(x)); } 138 139string tag(uint32_t fieldnum, char wire_type) { 140 return varint((fieldnum << 3) | wire_type); 141} 142 143string submsg(uint32_t fn, const string& buf) { 144 return cat( tag(fn, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), delim(buf) ); 145} 146 147#define UNKNOWN_FIELD 666 148 149uint32_t GetFieldNumberForType(FieldDescriptor::Type type, bool repeated) { 150 const Descriptor* d = TestAllTypes().GetDescriptor(); 151 for (int i = 0; i < d->field_count(); i++) { 152 const FieldDescriptor* f = d->field(i); 153 if (f->type() == type && f->is_repeated() == repeated) { 154 return f->number(); 155 } 156 } 157 GOOGLE_LOG(FATAL) << "Couldn't find field with type " << (int)type; 158 return 0; 159} 160 161string UpperCase(string str) { 162 for (int i = 0; i < str.size(); i++) { 163 str[i] = toupper(str[i]); 164 } 165 return str; 166} 167 168} // anonymous namespace 169 170namespace google { 171namespace protobuf { 172 173void ConformanceTestSuite::ReportSuccess(const string& test_name) { 174 if (expected_to_fail_.erase(test_name) != 0) { 175 StringAppendF(&output_, 176 "ERROR: test %s is in the failure list, but test succeeded. " 177 "Remove it from the failure list.\n", 178 test_name.c_str()); 179 unexpected_succeeding_tests_.insert(test_name); 180 } 181 successes_++; 182} 183 184void ConformanceTestSuite::ReportFailure(const string& test_name, 185 const ConformanceRequest& request, 186 const ConformanceResponse& response, 187 const char* fmt, ...) { 188 if (expected_to_fail_.erase(test_name) == 1) { 189 expected_failures_++; 190 if (!verbose_) 191 return; 192 } else { 193 StringAppendF(&output_, "ERROR, test=%s: ", test_name.c_str()); 194 unexpected_failing_tests_.insert(test_name); 195 } 196 va_list args; 197 va_start(args, fmt); 198 StringAppendV(&output_, fmt, args); 199 va_end(args); 200 StringAppendF(&output_, " request=%s, response=%s\n", 201 request.ShortDebugString().c_str(), 202 response.ShortDebugString().c_str()); 203} 204 205void ConformanceTestSuite::ReportSkip(const string& test_name, 206 const ConformanceRequest& request, 207 const ConformanceResponse& response) { 208 if (verbose_) { 209 StringAppendF(&output_, "SKIPPED, test=%s request=%s, response=%s\n", 210 test_name.c_str(), request.ShortDebugString().c_str(), 211 response.ShortDebugString().c_str()); 212 } 213 skipped_.insert(test_name); 214} 215 216void ConformanceTestSuite::RunTest(const string& test_name, 217 const ConformanceRequest& request, 218 ConformanceResponse* response) { 219 if (test_names_.insert(test_name).second == false) { 220 GOOGLE_LOG(FATAL) << "Duplicated test name: " << test_name; 221 } 222 223 string serialized_request; 224 string serialized_response; 225 request.SerializeToString(&serialized_request); 226 227 runner_->RunTest(test_name, serialized_request, &serialized_response); 228 229 if (!response->ParseFromString(serialized_response)) { 230 response->Clear(); 231 response->set_runtime_error("response proto could not be parsed."); 232 } 233 234 if (verbose_) { 235 StringAppendF(&output_, "conformance test: name=%s, request=%s, response=%s\n", 236 test_name.c_str(), 237 request.ShortDebugString().c_str(), 238 response->ShortDebugString().c_str()); 239 } 240} 241 242void ConformanceTestSuite::RunValidInputTest( 243 const string& test_name, const string& input, WireFormat input_format, 244 const string& equivalent_text_format, WireFormat requested_output) { 245 TestAllTypes reference_message; 246 GOOGLE_CHECK( 247 TextFormat::ParseFromString(equivalent_text_format, &reference_message)) 248 << "Failed to parse data for test case: " << test_name 249 << ", data: " << equivalent_text_format; 250 251 ConformanceRequest request; 252 ConformanceResponse response; 253 254 switch (input_format) { 255 case conformance::PROTOBUF: 256 request.set_protobuf_payload(input); 257 break; 258 259 case conformance::JSON: 260 request.set_json_payload(input); 261 break; 262 263 default: 264 GOOGLE_LOG(FATAL) << "Unspecified input format"; 265 } 266 267 request.set_requested_output_format(requested_output); 268 269 RunTest(test_name, request, &response); 270 271 TestAllTypes test_message; 272 273 switch (response.result_case()) { 274 case ConformanceResponse::kParseError: 275 case ConformanceResponse::kRuntimeError: 276 case ConformanceResponse::kSerializeError: 277 ReportFailure(test_name, request, response, 278 "Failed to parse JSON input or produce JSON output."); 279 return; 280 281 case ConformanceResponse::kSkipped: 282 ReportSkip(test_name, request, response); 283 return; 284 285 case ConformanceResponse::kJsonPayload: { 286 if (requested_output != conformance::JSON) { 287 ReportFailure( 288 test_name, request, response, 289 "Test was asked for protobuf output but provided JSON instead."); 290 return; 291 } 292 string binary_protobuf; 293 Status status = 294 JsonToBinaryString(type_resolver_.get(), type_url_, 295 response.json_payload(), &binary_protobuf); 296 if (!status.ok()) { 297 ReportFailure(test_name, request, response, 298 "JSON output we received from test was unparseable."); 299 return; 300 } 301 302 if (!test_message.ParseFromString(binary_protobuf)) { 303 ReportFailure(test_name, request, response, 304 "INTERNAL ERROR: internal JSON->protobuf transcode " 305 "yielded unparseable proto."); 306 return; 307 } 308 309 break; 310 } 311 312 case ConformanceResponse::kProtobufPayload: { 313 if (requested_output != conformance::PROTOBUF) { 314 ReportFailure( 315 test_name, request, response, 316 "Test was asked for JSON output but provided protobuf instead."); 317 return; 318 } 319 320 if (!test_message.ParseFromString(response.protobuf_payload())) { 321 ReportFailure(test_name, request, response, 322 "Protobuf output we received from test was unparseable."); 323 return; 324 } 325 326 break; 327 } 328 329 default: 330 GOOGLE_LOG(FATAL) << test_name << ": unknown payload type: " 331 << response.result_case(); 332 } 333 334 MessageDifferencer differencer; 335 DefaultFieldComparator field_comparator; 336 field_comparator.set_treat_nan_as_equal(true); 337 differencer.set_field_comparator(&field_comparator); 338 string differences; 339 differencer.ReportDifferencesToString(&differences); 340 341 if (differencer.Compare(reference_message, test_message)) { 342 ReportSuccess(test_name); 343 } else { 344 ReportFailure(test_name, request, response, 345 "Output was not equivalent to reference message: %s.", 346 differences.c_str()); 347 } 348} 349 350// Expect that this precise protobuf will cause a parse error. 351void ConformanceTestSuite::ExpectParseFailureForProto( 352 const string& proto, const string& test_name) { 353 ConformanceRequest request; 354 ConformanceResponse response; 355 request.set_protobuf_payload(proto); 356 string effective_test_name = "ProtobufInput." + test_name; 357 358 // We don't expect output, but if the program erroneously accepts the protobuf 359 // we let it send its response as this. We must not leave it unspecified. 360 request.set_requested_output_format(conformance::PROTOBUF); 361 362 RunTest(effective_test_name, request, &response); 363 if (response.result_case() == ConformanceResponse::kParseError) { 364 ReportSuccess(effective_test_name); 365 } else if (response.result_case() == ConformanceResponse::kSkipped) { 366 ReportSkip(effective_test_name, request, response); 367 } else { 368 ReportFailure(effective_test_name, request, response, 369 "Should have failed to parse, but didn't."); 370 } 371} 372 373// Expect that this protobuf will cause a parse error, even if it is followed 374// by valid protobuf data. We can try running this twice: once with this 375// data verbatim and once with this data followed by some valid data. 376// 377// TODO(haberman): implement the second of these. 378void ConformanceTestSuite::ExpectHardParseFailureForProto( 379 const string& proto, const string& test_name) { 380 return ExpectParseFailureForProto(proto, test_name); 381} 382 383void ConformanceTestSuite::RunValidJsonTest( 384 const string& test_name, const string& input_json, 385 const string& equivalent_text_format) { 386 RunValidInputTest("JsonInput." + test_name + ".ProtobufOutput", input_json, 387 conformance::JSON, equivalent_text_format, 388 conformance::PROTOBUF); 389 RunValidInputTest("JsonInput." + test_name + ".JsonOutput", input_json, 390 conformance::JSON, equivalent_text_format, 391 conformance::JSON); 392} 393 394void ConformanceTestSuite::RunValidJsonTestWithProtobufInput( 395 const string& test_name, const TestAllTypes& input, 396 const string& equivalent_text_format) { 397 RunValidInputTest("ProtobufInput." + test_name + ".JsonOutput", 398 input.SerializeAsString(), conformance::PROTOBUF, 399 equivalent_text_format, conformance::JSON); 400} 401 402// According to proto3 JSON specification, JSON serializers follow more strict 403// rules than parsers (e.g., a serializer must serialize int32 values as JSON 404// numbers while the parser is allowed to accept them as JSON strings). This 405// method allows strict checking on a proto3 JSON serializer by inspecting 406// the JSON output directly. 407void ConformanceTestSuite::RunValidJsonTestWithValidator( 408 const string& test_name, const string& input_json, 409 const Validator& validator) { 410 ConformanceRequest request; 411 ConformanceResponse response; 412 request.set_json_payload(input_json); 413 request.set_requested_output_format(conformance::JSON); 414 415 string effective_test_name = "JsonInput." + test_name + ".Validator"; 416 417 RunTest(effective_test_name, request, &response); 418 419 if (response.result_case() == ConformanceResponse::kSkipped) { 420 ReportSkip(effective_test_name, request, response); 421 return; 422 } 423 424 if (response.result_case() != ConformanceResponse::kJsonPayload) { 425 ReportFailure(effective_test_name, request, response, 426 "Expected JSON payload but got type %d.", 427 response.result_case()); 428 return; 429 } 430 Json::Reader reader; 431 Json::Value value; 432 if (!reader.parse(response.json_payload(), value)) { 433 ReportFailure(effective_test_name, request, response, 434 "JSON payload cannot be parsed as valid JSON: %s", 435 reader.getFormattedErrorMessages().c_str()); 436 return; 437 } 438 if (!validator(value)) { 439 ReportFailure(effective_test_name, request, response, 440 "JSON payload validation failed."); 441 return; 442 } 443 ReportSuccess(effective_test_name); 444} 445 446void ConformanceTestSuite::ExpectParseFailureForJson( 447 const string& test_name, const string& input_json) { 448 ConformanceRequest request; 449 ConformanceResponse response; 450 request.set_json_payload(input_json); 451 string effective_test_name = "JsonInput." + test_name; 452 453 // We don't expect output, but if the program erroneously accepts the protobuf 454 // we let it send its response as this. We must not leave it unspecified. 455 request.set_requested_output_format(conformance::JSON); 456 457 RunTest(effective_test_name, request, &response); 458 if (response.result_case() == ConformanceResponse::kParseError) { 459 ReportSuccess(effective_test_name); 460 } else if (response.result_case() == ConformanceResponse::kSkipped) { 461 ReportSkip(effective_test_name, request, response); 462 } else { 463 ReportFailure(effective_test_name, request, response, 464 "Should have failed to parse, but didn't."); 465 } 466} 467 468void ConformanceTestSuite::ExpectSerializeFailureForJson( 469 const string& test_name, const string& text_format) { 470 TestAllTypes payload_message; 471 GOOGLE_CHECK( 472 TextFormat::ParseFromString(text_format, &payload_message)) 473 << "Failed to parse: " << text_format; 474 475 ConformanceRequest request; 476 ConformanceResponse response; 477 request.set_protobuf_payload(payload_message.SerializeAsString()); 478 string effective_test_name = test_name + ".JsonOutput"; 479 request.set_requested_output_format(conformance::JSON); 480 481 RunTest(effective_test_name, request, &response); 482 if (response.result_case() == ConformanceResponse::kSerializeError) { 483 ReportSuccess(effective_test_name); 484 } else if (response.result_case() == ConformanceResponse::kSkipped) { 485 ReportSkip(effective_test_name, request, response); 486 } else { 487 ReportFailure(effective_test_name, request, response, 488 "Should have failed to serialize, but didn't."); 489 } 490} 491 492void ConformanceTestSuite::TestPrematureEOFForType(FieldDescriptor::Type type) { 493 // Incomplete values for each wire type. 494 static const string incompletes[6] = { 495 string("\x80"), // VARINT 496 string("abcdefg"), // 64BIT 497 string("\x80"), // DELIMITED (partial length) 498 string(), // START_GROUP (no value required) 499 string(), // END_GROUP (no value required) 500 string("abc") // 32BIT 501 }; 502 503 uint32_t fieldnum = GetFieldNumberForType(type, false); 504 uint32_t rep_fieldnum = GetFieldNumberForType(type, true); 505 WireFormatLite::WireType wire_type = WireFormatLite::WireTypeForFieldType( 506 static_cast<WireFormatLite::FieldType>(type)); 507 const string& incomplete = incompletes[wire_type]; 508 const string type_name = 509 UpperCase(string(".") + FieldDescriptor::TypeName(type)); 510 511 ExpectParseFailureForProto( 512 tag(fieldnum, wire_type), 513 "PrematureEofBeforeKnownNonRepeatedValue" + type_name); 514 515 ExpectParseFailureForProto( 516 tag(rep_fieldnum, wire_type), 517 "PrematureEofBeforeKnownRepeatedValue" + type_name); 518 519 ExpectParseFailureForProto( 520 tag(UNKNOWN_FIELD, wire_type), 521 "PrematureEofBeforeUnknownValue" + type_name); 522 523 ExpectParseFailureForProto( 524 cat( tag(fieldnum, wire_type), incomplete ), 525 "PrematureEofInsideKnownNonRepeatedValue" + type_name); 526 527 ExpectParseFailureForProto( 528 cat( tag(rep_fieldnum, wire_type), incomplete ), 529 "PrematureEofInsideKnownRepeatedValue" + type_name); 530 531 ExpectParseFailureForProto( 532 cat( tag(UNKNOWN_FIELD, wire_type), incomplete ), 533 "PrematureEofInsideUnknownValue" + type_name); 534 535 if (wire_type == WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { 536 ExpectParseFailureForProto( 537 cat( tag(fieldnum, wire_type), varint(1) ), 538 "PrematureEofInDelimitedDataForKnownNonRepeatedValue" + type_name); 539 540 ExpectParseFailureForProto( 541 cat( tag(rep_fieldnum, wire_type), varint(1) ), 542 "PrematureEofInDelimitedDataForKnownRepeatedValue" + type_name); 543 544 // EOF in the middle of delimited data for unknown value. 545 ExpectParseFailureForProto( 546 cat( tag(UNKNOWN_FIELD, wire_type), varint(1) ), 547 "PrematureEofInDelimitedDataForUnknownValue" + type_name); 548 549 if (type == FieldDescriptor::TYPE_MESSAGE) { 550 // Submessage ends in the middle of a value. 551 string incomplete_submsg = 552 cat( tag(WireFormatLite::TYPE_INT32, WireFormatLite::WIRETYPE_VARINT), 553 incompletes[WireFormatLite::WIRETYPE_VARINT] ); 554 ExpectHardParseFailureForProto( 555 cat( tag(fieldnum, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), 556 varint(incomplete_submsg.size()), 557 incomplete_submsg ), 558 "PrematureEofInSubmessageValue" + type_name); 559 } 560 } else if (type != FieldDescriptor::TYPE_GROUP) { 561 // Non-delimited, non-group: eligible for packing. 562 563 // Packed region ends in the middle of a value. 564 ExpectHardParseFailureForProto( 565 cat( tag(rep_fieldnum, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), 566 varint(incomplete.size()), 567 incomplete ), 568 "PrematureEofInPackedFieldValue" + type_name); 569 570 // EOF in the middle of packed region. 571 ExpectParseFailureForProto( 572 cat( tag(rep_fieldnum, WireFormatLite::WIRETYPE_LENGTH_DELIMITED), 573 varint(1) ), 574 "PrematureEofInPackedField" + type_name); 575 } 576} 577 578void ConformanceTestSuite::SetFailureList(const vector<string>& failure_list) { 579 expected_to_fail_.clear(); 580 std::copy(failure_list.begin(), failure_list.end(), 581 std::inserter(expected_to_fail_, expected_to_fail_.end())); 582} 583 584bool ConformanceTestSuite::CheckSetEmpty(const set<string>& set_to_check, 585 const char* msg) { 586 if (set_to_check.empty()) { 587 return true; 588 } else { 589 StringAppendF(&output_, "\n"); 590 StringAppendF(&output_, "%s:\n", msg); 591 for (set<string>::const_iterator iter = set_to_check.begin(); 592 iter != set_to_check.end(); ++iter) { 593 StringAppendF(&output_, " %s\n", iter->c_str()); 594 } 595 StringAppendF(&output_, "\n"); 596 return false; 597 } 598} 599 600bool ConformanceTestSuite::RunSuite(ConformanceTestRunner* runner, 601 std::string* output) { 602 runner_ = runner; 603 successes_ = 0; 604 expected_failures_ = 0; 605 skipped_.clear(); 606 test_names_.clear(); 607 unexpected_failing_tests_.clear(); 608 unexpected_succeeding_tests_.clear(); 609 type_resolver_.reset(NewTypeResolverForDescriptorPool( 610 kTypeUrlPrefix, DescriptorPool::generated_pool())); 611 type_url_ = GetTypeUrl(TestAllTypes::descriptor()); 612 613 output_ = "\nCONFORMANCE TEST BEGIN ====================================\n\n"; 614 615 for (int i = 1; i <= FieldDescriptor::MAX_TYPE; i++) { 616 if (i == FieldDescriptor::TYPE_GROUP) continue; 617 TestPrematureEOFForType(static_cast<FieldDescriptor::Type>(i)); 618 } 619 620 RunValidJsonTest("HelloWorld", "{\"optionalString\":\"Hello, World!\"}", 621 "optional_string: 'Hello, World!'"); 622 623 // Test field name conventions. 624 RunValidJsonTest( 625 "FieldNameInSnakeCase", 626 R"({ 627 "fieldname1": 1, 628 "fieldName2": 2, 629 "FieldName3": 3 630 })", 631 R"( 632 fieldname1: 1 633 field_name2: 2 634 _field_name3: 3 635 )"); 636 RunValidJsonTest( 637 "FieldNameWithNumbers", 638 R"({ 639 "field0name5": 5, 640 "field0Name6": 6 641 })", 642 R"( 643 field0name5: 5 644 field_0_name6: 6 645 )"); 646 RunValidJsonTest( 647 "FieldNameWithMixedCases", 648 R"({ 649 "fieldName7": 7, 650 "fieldName8": 8, 651 "fieldName9": 9, 652 "fieldName10": 10, 653 "fIELDNAME11": 11, 654 "fIELDName12": 12 655 })", 656 R"( 657 fieldName7: 7 658 FieldName8: 8 659 field_Name9: 9 660 Field_Name10: 10 661 FIELD_NAME11: 11 662 FIELD_name12: 12 663 )"); 664 // Using the original proto field name in JSON is also allowed. 665 RunValidJsonTest( 666 "OriginalProtoFieldName", 667 R"({ 668 "fieldname1": 1, 669 "field_name2": 2, 670 "_field_name3": 3, 671 "field0name5": 5, 672 "field_0_name6": 6, 673 "fieldName7": 7, 674 "FieldName8": 8, 675 "field_Name9": 9, 676 "Field_Name10": 10, 677 "FIELD_NAME11": 11, 678 "FIELD_name12": 12 679 })", 680 R"( 681 fieldname1: 1 682 field_name2: 2 683 _field_name3: 3 684 field0name5: 5 685 field_0_name6: 6 686 fieldName7: 7 687 FieldName8: 8 688 field_Name9: 9 689 Field_Name10: 10 690 FIELD_NAME11: 11 691 FIELD_name12: 12 692 )"); 693 // Field names can be escaped. 694 RunValidJsonTest( 695 "FieldNameEscaped", 696 R"({"fieldn\u0061me1": 1})", 697 "fieldname1: 1"); 698 // Field names must be quoted (or it's not valid JSON). 699 ExpectParseFailureForJson( 700 "FieldNameNotQuoted", 701 "{fieldname1: 1}"); 702 // Trailing comma is not allowed (not valid JSON). 703 ExpectParseFailureForJson( 704 "TrailingCommaInAnObject", 705 R"({"fieldname1":1,})"); 706 // JSON doesn't support comments. 707 ExpectParseFailureForJson( 708 "JsonWithComments", 709 R"({ 710 // This is a comment. 711 "fieldname1": 1 712 })"); 713 // Duplicated field names are not allowed. 714 ExpectParseFailureForJson( 715 "FieldNameDuplicate", 716 R"({ 717 "optionalNestedMessage": {a: 1}, 718 "optionalNestedMessage": {} 719 })"); 720 ExpectParseFailureForJson( 721 "FieldNameDuplicateDifferentCasing1", 722 R"({ 723 "optional_nested_message": {a: 1}, 724 "optionalNestedMessage": {} 725 })"); 726 ExpectParseFailureForJson( 727 "FieldNameDuplicateDifferentCasing2", 728 R"({ 729 "optionalNestedMessage": {a: 1}, 730 "optional_nested_message": {} 731 })"); 732 // Serializers should use lowerCamelCase by default. 733 RunValidJsonTestWithValidator( 734 "FieldNameInLowerCamelCase", 735 R"({ 736 "fieldname1": 1, 737 "fieldName2": 2, 738 "FieldName3": 3 739 })", 740 [](const Json::Value& value) { 741 return value.isMember("fieldname1") && 742 value.isMember("fieldName2") && 743 value.isMember("FieldName3"); 744 }); 745 RunValidJsonTestWithValidator( 746 "FieldNameWithNumbers", 747 R"({ 748 "field0name5": 5, 749 "field0Name6": 6 750 })", 751 [](const Json::Value& value) { 752 return value.isMember("field0name5") && 753 value.isMember("field0Name6"); 754 }); 755 RunValidJsonTestWithValidator( 756 "FieldNameWithMixedCases", 757 R"({ 758 "fieldName7": 7, 759 "fieldName8": 8, 760 "fieldName9": 9, 761 "fieldName10": 10, 762 "fIELDNAME11": 11, 763 "fIELDName12": 12 764 })", 765 [](const Json::Value& value) { 766 return value.isMember("fieldName7") && 767 value.isMember("fieldName8") && 768 value.isMember("fieldName9") && 769 value.isMember("fieldName10") && 770 value.isMember("fIELDNAME11") && 771 value.isMember("fIELDName12"); 772 }); 773 774 // Integer fields. 775 RunValidJsonTest( 776 "Int32FieldMaxValue", 777 R"({"optionalInt32": 2147483647})", 778 "optional_int32: 2147483647"); 779 RunValidJsonTest( 780 "Int32FieldMinValue", 781 R"({"optionalInt32": -2147483648})", 782 "optional_int32: -2147483648"); 783 RunValidJsonTest( 784 "Uint32FieldMaxValue", 785 R"({"optionalUint32": 4294967295})", 786 "optional_uint32: 4294967295"); 787 RunValidJsonTest( 788 "Int64FieldMaxValue", 789 R"({"optionalInt64": "9223372036854775807"})", 790 "optional_int64: 9223372036854775807"); 791 RunValidJsonTest( 792 "Int64FieldMinValue", 793 R"({"optionalInt64": "-9223372036854775808"})", 794 "optional_int64: -9223372036854775808"); 795 RunValidJsonTest( 796 "Uint64FieldMaxValue", 797 R"({"optionalUint64": "18446744073709551615"})", 798 "optional_uint64: 18446744073709551615"); 799 RunValidJsonTest( 800 "Int64FieldMaxValueNotQuoted", 801 R"({"optionalInt64": 9223372036854775807})", 802 "optional_int64: 9223372036854775807"); 803 RunValidJsonTest( 804 "Int64FieldMinValueNotQuoted", 805 R"({"optionalInt64": -9223372036854775808})", 806 "optional_int64: -9223372036854775808"); 807 RunValidJsonTest( 808 "Uint64FieldMaxValueNotQuoted", 809 R"({"optionalUint64": 18446744073709551615})", 810 "optional_uint64: 18446744073709551615"); 811 // Values can be represented as JSON strings. 812 RunValidJsonTest( 813 "Int32FieldStringValue", 814 R"({"optionalInt32": "2147483647"})", 815 "optional_int32: 2147483647"); 816 RunValidJsonTest( 817 "Int32FieldStringValueEscaped", 818 R"({"optionalInt32": "2\u003147483647"})", 819 "optional_int32: 2147483647"); 820 821 // Parsers reject out-of-bound integer values. 822 ExpectParseFailureForJson( 823 "Int32FieldTooLarge", 824 R"({"optionalInt32": 2147483648})"); 825 ExpectParseFailureForJson( 826 "Int32FieldTooSmall", 827 R"({"optionalInt32": -2147483649})"); 828 ExpectParseFailureForJson( 829 "Uint32FieldTooLarge", 830 R"({"optionalUint32": 4294967296})"); 831 ExpectParseFailureForJson( 832 "Int64FieldTooLarge", 833 R"({"optionalInt64": "9223372036854775808"})"); 834 ExpectParseFailureForJson( 835 "Int64FieldTooSmall", 836 R"({"optionalInt64": "-9223372036854775809"})"); 837 ExpectParseFailureForJson( 838 "Uint64FieldTooLarge", 839 R"({"optionalUint64": "18446744073709551616"})"); 840 // Parser reject non-integer numeric values as well. 841 ExpectParseFailureForJson( 842 "Int32FieldNotInteger", 843 R"({"optionalInt32": 0.5})"); 844 ExpectParseFailureForJson( 845 "Uint32FieldNotInteger", 846 R"({"optionalUint32": 0.5})"); 847 ExpectParseFailureForJson( 848 "Int64FieldNotInteger", 849 R"({"optionalInt64": "0.5"})"); 850 ExpectParseFailureForJson( 851 "Uint64FieldNotInteger", 852 R"({"optionalUint64": "0.5"})"); 853 854 // Integers but represented as float values are accepted. 855 RunValidJsonTest( 856 "Int32FieldFloatTrailingZero", 857 R"({"optionalInt32": 100000.000})", 858 "optional_int32: 100000"); 859 RunValidJsonTest( 860 "Int32FieldExponentialFormat", 861 R"({"optionalInt32": 1e5})", 862 "optional_int32: 100000"); 863 RunValidJsonTest( 864 "Int32FieldMaxFloatValue", 865 R"({"optionalInt32": 2.147483647e9})", 866 "optional_int32: 2147483647"); 867 RunValidJsonTest( 868 "Int32FieldMinFloatValue", 869 R"({"optionalInt32": -2.147483648e9})", 870 "optional_int32: -2147483648"); 871 RunValidJsonTest( 872 "Uint32FieldMaxFloatValue", 873 R"({"optionalUint32": 4.294967295e9})", 874 "optional_uint32: 4294967295"); 875 876 // Parser reject non-numeric values. 877 ExpectParseFailureForJson( 878 "Int32FieldNotNumber", 879 R"({"optionalInt32": "3x3"})"); 880 ExpectParseFailureForJson( 881 "Uint32FieldNotNumber", 882 R"({"optionalUint32": "3x3"})"); 883 ExpectParseFailureForJson( 884 "Int64FieldNotNumber", 885 R"({"optionalInt64": "3x3"})"); 886 ExpectParseFailureForJson( 887 "Uint64FieldNotNumber", 888 R"({"optionalUint64": "3x3"})"); 889 // JSON does not allow "+" on numric values. 890 ExpectParseFailureForJson( 891 "Int32FieldPlusSign", 892 R"({"optionalInt32": +1})"); 893 // JSON doesn't allow leading 0s. 894 ExpectParseFailureForJson( 895 "Int32FieldLeadingZero", 896 R"({"optionalInt32": 01})"); 897 ExpectParseFailureForJson( 898 "Int32FieldNegativeWithLeadingZero", 899 R"({"optionalInt32": -01})"); 900 // String values must follow the same syntax rule. Specifically leading 901 // or traling spaces are not allowed. 902 ExpectParseFailureForJson( 903 "Int32FieldLeadingSpace", 904 R"({"optionalInt32": " 1"})"); 905 ExpectParseFailureForJson( 906 "Int32FieldTrailingSpace", 907 R"({"optionalInt32": "1 "})"); 908 909 // 64-bit values are serialized as strings. 910 RunValidJsonTestWithValidator( 911 "Int64FieldBeString", 912 R"({"optionalInt64": 1})", 913 [](const Json::Value& value) { 914 return value["optionalInt64"].type() == Json::stringValue && 915 value["optionalInt64"].asString() == "1"; 916 }); 917 RunValidJsonTestWithValidator( 918 "Uint64FieldBeString", 919 R"({"optionalUint64": 1})", 920 [](const Json::Value& value) { 921 return value["optionalUint64"].type() == Json::stringValue && 922 value["optionalUint64"].asString() == "1"; 923 }); 924 925 // Bool fields. 926 RunValidJsonTest( 927 "BoolFieldTrue", 928 R"({"optionalBool":true})", 929 "optional_bool: true"); 930 RunValidJsonTest( 931 "BoolFieldFalse", 932 R"({"optionalBool":false})", 933 "optional_bool: false"); 934 935 // Other forms are not allowed. 936 ExpectParseFailureForJson( 937 "BoolFieldIntegerZero", 938 R"({"optionalBool":0})"); 939 ExpectParseFailureForJson( 940 "BoolFieldIntegerOne", 941 R"({"optionalBool":1})"); 942 ExpectParseFailureForJson( 943 "BoolFieldCamelCaseTrue", 944 R"({"optionalBool":True})"); 945 ExpectParseFailureForJson( 946 "BoolFieldCamelCaseFalse", 947 R"({"optionalBool":False})"); 948 ExpectParseFailureForJson( 949 "BoolFieldAllCapitalTrue", 950 R"({"optionalBool":TRUE})"); 951 ExpectParseFailureForJson( 952 "BoolFieldAllCapitalFalse", 953 R"({"optionalBool":FALSE})"); 954 ExpectParseFailureForJson( 955 "BoolFieldDoubleQuotedTrue", 956 R"({"optionalBool":"true"})"); 957 ExpectParseFailureForJson( 958 "BoolFieldDoubleQuotedFalse", 959 R"({"optionalBool":"false"})"); 960 961 // Float fields. 962 RunValidJsonTest( 963 "FloatFieldMinPositiveValue", 964 R"({"optionalFloat": 1.175494e-38})", 965 "optional_float: 1.175494e-38"); 966 RunValidJsonTest( 967 "FloatFieldMaxNegativeValue", 968 R"({"optionalFloat": -1.175494e-38})", 969 "optional_float: -1.175494e-38"); 970 RunValidJsonTest( 971 "FloatFieldMaxPositiveValue", 972 R"({"optionalFloat": 3.402823e+38})", 973 "optional_float: 3.402823e+38"); 974 RunValidJsonTest( 975 "FloatFieldMinNegativeValue", 976 R"({"optionalFloat": 3.402823e+38})", 977 "optional_float: 3.402823e+38"); 978 // Values can be quoted. 979 RunValidJsonTest( 980 "FloatFieldQuotedValue", 981 R"({"optionalFloat": "1"})", 982 "optional_float: 1"); 983 // Special values. 984 RunValidJsonTest( 985 "FloatFieldNan", 986 R"({"optionalFloat": "NaN"})", 987 "optional_float: nan"); 988 RunValidJsonTest( 989 "FloatFieldInfinity", 990 R"({"optionalFloat": "Infinity"})", 991 "optional_float: inf"); 992 RunValidJsonTest( 993 "FloatFieldNegativeInfinity", 994 R"({"optionalFloat": "-Infinity"})", 995 "optional_float: -inf"); 996 // Non-cannonical Nan will be correctly normalized. 997 { 998 TestAllTypes message; 999 // IEEE floating-point standard 32-bit quiet NaN: 1000 // 0111 1111 1xxx xxxx xxxx xxxx xxxx xxxx 1001 message.set_optional_float( 1002 WireFormatLite::DecodeFloat(0x7FA12345)); 1003 RunValidJsonTestWithProtobufInput( 1004 "FloatFieldNormalizeQuietNan", message, 1005 "optional_float: nan"); 1006 // IEEE floating-point standard 64-bit signaling NaN: 1007 // 1111 1111 1xxx xxxx xxxx xxxx xxxx xxxx 1008 message.set_optional_float( 1009 WireFormatLite::DecodeFloat(0xFFB54321)); 1010 RunValidJsonTestWithProtobufInput( 1011 "FloatFieldNormalizeSignalingNan", message, 1012 "optional_float: nan"); 1013 } 1014 1015 // Special values must be quoted. 1016 ExpectParseFailureForJson( 1017 "FloatFieldNanNotQuoted", 1018 R"({"optionalFloat": NaN})"); 1019 ExpectParseFailureForJson( 1020 "FloatFieldInfinityNotQuoted", 1021 R"({"optionalFloat": Infinity})"); 1022 ExpectParseFailureForJson( 1023 "FloatFieldNegativeInfinityNotQuoted", 1024 R"({"optionalFloat": -Infinity})"); 1025 // Parsers should reject out-of-bound values. 1026 ExpectParseFailureForJson( 1027 "FloatFieldTooSmall", 1028 R"({"optionalFloat": -3.502823e+38})"); 1029 ExpectParseFailureForJson( 1030 "FloatFieldTooLarge", 1031 R"({"optionalFloat": 3.502823e+38})"); 1032 1033 // Double fields. 1034 RunValidJsonTest( 1035 "DoubleFieldMinPositiveValue", 1036 R"({"optionalDouble": 2.22507e-308})", 1037 "optional_double: 2.22507e-308"); 1038 RunValidJsonTest( 1039 "DoubleFieldMaxNegativeValue", 1040 R"({"optionalDouble": -2.22507e-308})", 1041 "optional_double: -2.22507e-308"); 1042 RunValidJsonTest( 1043 "DoubleFieldMaxPositiveValue", 1044 R"({"optionalDouble": 1.79769e+308})", 1045 "optional_double: 1.79769e+308"); 1046 RunValidJsonTest( 1047 "DoubleFieldMinNegativeValue", 1048 R"({"optionalDouble": -1.79769e+308})", 1049 "optional_double: -1.79769e+308"); 1050 // Values can be quoted. 1051 RunValidJsonTest( 1052 "DoubleFieldQuotedValue", 1053 R"({"optionalDouble": "1"})", 1054 "optional_double: 1"); 1055 // Speical values. 1056 RunValidJsonTest( 1057 "DoubleFieldNan", 1058 R"({"optionalDouble": "NaN"})", 1059 "optional_double: nan"); 1060 RunValidJsonTest( 1061 "DoubleFieldInfinity", 1062 R"({"optionalDouble": "Infinity"})", 1063 "optional_double: inf"); 1064 RunValidJsonTest( 1065 "DoubleFieldNegativeInfinity", 1066 R"({"optionalDouble": "-Infinity"})", 1067 "optional_double: -inf"); 1068 // Non-cannonical Nan will be correctly normalized. 1069 { 1070 TestAllTypes message; 1071 message.set_optional_double( 1072 WireFormatLite::DecodeDouble(0x7FFA123456789ABCLL)); 1073 RunValidJsonTestWithProtobufInput( 1074 "DoubleFieldNormalizeQuietNan", message, 1075 "optional_double: nan"); 1076 message.set_optional_double( 1077 WireFormatLite::DecodeDouble(0xFFFBCBA987654321LL)); 1078 RunValidJsonTestWithProtobufInput( 1079 "DoubleFieldNormalizeSignalingNan", message, 1080 "optional_double: nan"); 1081 } 1082 1083 // Special values must be quoted. 1084 ExpectParseFailureForJson( 1085 "DoubleFieldNanNotQuoted", 1086 R"({"optionalDouble": NaN})"); 1087 ExpectParseFailureForJson( 1088 "DoubleFieldInfinityNotQuoted", 1089 R"({"optionalDouble": Infinity})"); 1090 ExpectParseFailureForJson( 1091 "DoubleFieldNegativeInfinityNotQuoted", 1092 R"({"optionalDouble": -Infinity})"); 1093 1094 // Parsers should reject out-of-bound values. 1095 ExpectParseFailureForJson( 1096 "DoubleFieldTooSmall", 1097 R"({"optionalDouble": -1.89769e+308})"); 1098 ExpectParseFailureForJson( 1099 "DoubleFieldTooLarge", 1100 R"({"optionalDouble": +1.89769e+308})"); 1101 1102 // Enum fields. 1103 RunValidJsonTest( 1104 "EnumField", 1105 R"({"optionalNestedEnum": "FOO"})", 1106 "optional_nested_enum: FOO"); 1107 // Enum values must be represented as strings. 1108 ExpectParseFailureForJson( 1109 "EnumFieldNotQuoted", 1110 R"({"optionalNestedEnum": FOO})"); 1111 // Numeric values are allowed. 1112 RunValidJsonTest( 1113 "EnumFieldNumericValueZero", 1114 R"({"optionalNestedEnum": 0})", 1115 "optional_nested_enum: FOO"); 1116 RunValidJsonTest( 1117 "EnumFieldNumericValueNonZero", 1118 R"({"optionalNestedEnum": 1})", 1119 "optional_nested_enum: BAR"); 1120 // Unknown enum values are represented as numeric values. 1121 RunValidJsonTestWithValidator( 1122 "EnumFieldUnknownValue", 1123 R"({"optionalNestedEnum": 123})", 1124 [](const Json::Value& value) { 1125 return value["optionalNestedEnum"].type() == Json::intValue && 1126 value["optionalNestedEnum"].asInt() == 123; 1127 }); 1128 1129 // String fields. 1130 RunValidJsonTest( 1131 "StringField", 1132 R"({"optionalString": "Hello world!"})", 1133 "optional_string: \"Hello world!\""); 1134 RunValidJsonTest( 1135 "StringFieldUnicode", 1136 // Google in Chinese. 1137 R"({"optionalString": "谷歌"})", 1138 R"(optional_string: "谷歌")"); 1139 RunValidJsonTest( 1140 "StringFieldEscape", 1141 R"({"optionalString": "\"\\\/\b\f\n\r\t"})", 1142 R"(optional_string: "\"\\/\b\f\n\r\t")"); 1143 RunValidJsonTest( 1144 "StringFieldUnicodeEscape", 1145 R"({"optionalString": "\u8C37\u6B4C"})", 1146 R"(optional_string: "谷歌")"); 1147 RunValidJsonTest( 1148 "StringFieldUnicodeEscapeWithLowercaseHexLetters", 1149 R"({"optionalString": "\u8c37\u6b4c"})", 1150 R"(optional_string: "谷歌")"); 1151 RunValidJsonTest( 1152 "StringFieldSurrogatePair", 1153 // The character is an emoji: grinning face with smiling eyes. 1154 R"({"optionalString": "\uD83D\uDE01"})", 1155 R"(optional_string: "\xF0\x9F\x98\x81")"); 1156 1157 // Unicode escapes must start with "\u" (lowercase u). 1158 ExpectParseFailureForJson( 1159 "StringFieldUppercaseEscapeLetter", 1160 R"({"optionalString": "\U8C37\U6b4C"})"); 1161 ExpectParseFailureForJson( 1162 "StringFieldInvalidEscape", 1163 R"({"optionalString": "\uXXXX\u6B4C"})"); 1164 ExpectParseFailureForJson( 1165 "StringFieldUnterminatedEscape", 1166 R"({"optionalString": "\u8C3"})"); 1167 ExpectParseFailureForJson( 1168 "StringFieldUnpairedHighSurrogate", 1169 R"({"optionalString": "\uD800"})"); 1170 ExpectParseFailureForJson( 1171 "StringFieldUnpairedLowSurrogate", 1172 R"({"optionalString": "\uDC00"})"); 1173 ExpectParseFailureForJson( 1174 "StringFieldSurrogateInWrongOrder", 1175 R"({"optionalString": "\uDE01\uD83D"})"); 1176 ExpectParseFailureForJson( 1177 "StringFieldNotAString", 1178 R"({"optionalString": 12345})"); 1179 1180 // Bytes fields. 1181 RunValidJsonTest( 1182 "BytesField", 1183 R"({"optionalBytes": "AQI="})", 1184 R"(optional_bytes: "\x01\x02")"); 1185 ExpectParseFailureForJson( 1186 "BytesFieldNoPadding", 1187 R"({"optionalBytes": "AQI"})"); 1188 ExpectParseFailureForJson( 1189 "BytesFieldInvalidBase64Characters", 1190 R"({"optionalBytes": "-_=="})"); 1191 1192 // Message fields. 1193 RunValidJsonTest( 1194 "MessageField", 1195 R"({"optionalNestedMessage": {"a": 1234}})", 1196 "optional_nested_message: {a: 1234}"); 1197 1198 // Oneof fields. 1199 ExpectParseFailureForJson( 1200 "OneofFieldDuplicate", 1201 R"({"oneofUint32": 1, "oneofString": "test"})"); 1202 1203 // Repeated fields. 1204 RunValidJsonTest( 1205 "PrimitiveRepeatedField", 1206 R"({"repeatedInt32": [1, 2, 3, 4]})", 1207 "repeated_int32: [1, 2, 3, 4]"); 1208 RunValidJsonTest( 1209 "EnumRepeatedField", 1210 R"({"repeatedNestedEnum": ["FOO", "BAR", "BAZ"]})", 1211 "repeated_nested_enum: [FOO, BAR, BAZ]"); 1212 RunValidJsonTest( 1213 "StringRepeatedField", 1214 R"({"repeatedString": ["Hello", "world"]})", 1215 R"(repeated_string: ["Hello", "world"])"); 1216 RunValidJsonTest( 1217 "BytesRepeatedField", 1218 R"({"repeatedBytes": ["AAEC", "AQI="]})", 1219 R"(repeated_bytes: ["\x00\x01\x02", "\x01\x02"])"); 1220 RunValidJsonTest( 1221 "MessageRepeatedField", 1222 R"({"repeatedNestedMessage": [{"a": 1234}, {"a": 5678}]})", 1223 "repeated_nested_message: {a: 1234}" 1224 "repeated_nested_message: {a: 5678}"); 1225 1226 // Repeated field elements are of incorrect type. 1227 ExpectParseFailureForJson( 1228 "RepeatedFieldWrongElementTypeExpectingIntegersGotBool", 1229 R"({"repeatedInt32": [1, false, 3, 4]})"); 1230 ExpectParseFailureForJson( 1231 "RepeatedFieldWrongElementTypeExpectingIntegersGotString", 1232 R"({"repeatedInt32": [1, 2, "name", 4]})"); 1233 ExpectParseFailureForJson( 1234 "RepeatedFieldWrongElementTypeExpectingIntegersGotMessage", 1235 R"({"repeatedInt32": [1, 2, 3, {"a": 4}]})"); 1236 ExpectParseFailureForJson( 1237 "RepeatedFieldWrongElementTypeExpectingStringsGotInt", 1238 R"({"repeatedString": ["1", 2, "3", "4"]})"); 1239 ExpectParseFailureForJson( 1240 "RepeatedFieldWrongElementTypeExpectingStringsGotBool", 1241 R"({"repeatedString": ["1", "2", false, "4"]})"); 1242 ExpectParseFailureForJson( 1243 "RepeatedFieldWrongElementTypeExpectingStringsGotMessage", 1244 R"({"repeatedString": ["1", 2, "3", {"a": 4}]})"); 1245 ExpectParseFailureForJson( 1246 "RepeatedFieldWrongElementTypeExpectingMessagesGotInt", 1247 R"({"repeatedNestedMessage": [{"a": 1}, 2]})"); 1248 ExpectParseFailureForJson( 1249 "RepeatedFieldWrongElementTypeExpectingMessagesGotBool", 1250 R"({"repeatedNestedMessage": [{"a": 1}, false]})"); 1251 ExpectParseFailureForJson( 1252 "RepeatedFieldWrongElementTypeExpectingMessagesGotString", 1253 R"({"repeatedNestedMessage": [{"a": 1}, "2"]})"); 1254 // Trailing comma in the repeated field is not allowed. 1255 ExpectParseFailureForJson( 1256 "RepeatedFieldTrailingComma", 1257 R"({"repeatedInt32": [1, 2, 3, 4,]})"); 1258 1259 // Map fields. 1260 RunValidJsonTest( 1261 "Int32MapField", 1262 R"({"mapInt32Int32": {"1": 2, "3": 4}})", 1263 "map_int32_int32: {key: 1 value: 2}" 1264 "map_int32_int32: {key: 3 value: 4}"); 1265 ExpectParseFailureForJson( 1266 "Int32MapFieldKeyNotQuoted", 1267 R"({"mapInt32Int32": {1: 2, 3: 4}})"); 1268 RunValidJsonTest( 1269 "Uint32MapField", 1270 R"({"mapUint32Uint32": {"1": 2, "3": 4}})", 1271 "map_uint32_uint32: {key: 1 value: 2}" 1272 "map_uint32_uint32: {key: 3 value: 4}"); 1273 ExpectParseFailureForJson( 1274 "Uint32MapFieldKeyNotQuoted", 1275 R"({"mapUint32Uint32": {1: 2, 3: 4}})"); 1276 RunValidJsonTest( 1277 "Int64MapField", 1278 R"({"mapInt64Int64": {"1": 2, "3": 4}})", 1279 "map_int64_int64: {key: 1 value: 2}" 1280 "map_int64_int64: {key: 3 value: 4}"); 1281 ExpectParseFailureForJson( 1282 "Int64MapFieldKeyNotQuoted", 1283 R"({"mapInt64Int64": {1: 2, 3: 4}})"); 1284 RunValidJsonTest( 1285 "Uint64MapField", 1286 R"({"mapUint64Uint64": {"1": 2, "3": 4}})", 1287 "map_uint64_uint64: {key: 1 value: 2}" 1288 "map_uint64_uint64: {key: 3 value: 4}"); 1289 ExpectParseFailureForJson( 1290 "Uint64MapFieldKeyNotQuoted", 1291 R"({"mapUint64Uint64": {1: 2, 3: 4}})"); 1292 RunValidJsonTest( 1293 "BoolMapField", 1294 R"({"mapBoolBool": {"true": true, "false": false}})", 1295 "map_bool_bool: {key: true value: true}" 1296 "map_bool_bool: {key: false value: false}"); 1297 ExpectParseFailureForJson( 1298 "BoolMapFieldKeyNotQuoted", 1299 R"({"mapBoolBool": {true: true, false: false}})"); 1300 RunValidJsonTest( 1301 "MessageMapField", 1302 R"({ 1303 "mapStringNestedMessage": { 1304 "hello": {"a": 1234}, 1305 "world": {"a": 5678} 1306 } 1307 })", 1308 R"( 1309 map_string_nested_message: { 1310 key: "hello" 1311 value: {a: 1234} 1312 } 1313 map_string_nested_message: { 1314 key: "world" 1315 value: {a: 5678} 1316 } 1317 )"); 1318 // Since Map keys are represented as JSON strings, escaping should be allowed. 1319 RunValidJsonTest( 1320 "Int32MapEscapedKey", 1321 R"({"mapInt32Int32": {"\u0031": 2}})", 1322 "map_int32_int32: {key: 1 value: 2}"); 1323 RunValidJsonTest( 1324 "Int64MapEscapedKey", 1325 R"({"mapInt64Int64": {"\u0031": 2}})", 1326 "map_int64_int64: {key: 1 value: 2}"); 1327 RunValidJsonTest( 1328 "BoolMapEscapedKey", 1329 R"({"mapBoolBool": {"tr\u0075e": true}})", 1330 "map_bool_bool: {key: true value: true}"); 1331 1332 // "null" is accepted for all fields types. 1333 RunValidJsonTest( 1334 "AllFieldAcceptNull", 1335 R"({ 1336 "optionalInt32": null, 1337 "optionalInt64": null, 1338 "optionalUint32": null, 1339 "optionalUint64": null, 1340 "optionalBool": null, 1341 "optionalString": null, 1342 "optionalBytes": null, 1343 "optionalNestedEnum": null, 1344 "optionalNestedMessage": null, 1345 "repeatedInt32": null, 1346 "repeatedInt64": null, 1347 "repeatedUint32": null, 1348 "repeatedUint64": null, 1349 "repeatedBool": null, 1350 "repeatedString": null, 1351 "repeatedBytes": null, 1352 "repeatedNestedEnum": null, 1353 "repeatedNestedMessage": null, 1354 "mapInt32Int32": null, 1355 "mapBoolBool": null, 1356 "mapStringNestedMessage": null 1357 })", 1358 ""); 1359 1360 // Repeated field elements cannot be null. 1361 ExpectParseFailureForJson( 1362 "RepeatedFieldPrimitiveElementIsNull", 1363 R"({"repeatedInt32": [1, null, 2]})"); 1364 ExpectParseFailureForJson( 1365 "RepeatedFieldMessageElementIsNull", 1366 R"({"repeatedNestedMessage": [{"a":1}, null, {"a":2}]})"); 1367 // Map field keys cannot be null. 1368 ExpectParseFailureForJson( 1369 "MapFieldKeyIsNull", 1370 R"({"mapInt32Int32": {null: 1}})"); 1371 // Map field values cannot be null. 1372 ExpectParseFailureForJson( 1373 "MapFieldValueIsNull", 1374 R"({"mapInt32Int32": {"0": null}})"); 1375 1376 // Wrapper types. 1377 RunValidJsonTest( 1378 "OptionalBoolWrapper", 1379 R"({"optionalBoolWrapper": false})", 1380 "optional_bool_wrapper: {value: false}"); 1381 RunValidJsonTest( 1382 "OptionalInt32Wrapper", 1383 R"({"optionalInt32Wrapper": 0})", 1384 "optional_int32_wrapper: {value: 0}"); 1385 RunValidJsonTest( 1386 "OptionalUint32Wrapper", 1387 R"({"optionalUint32Wrapper": 0})", 1388 "optional_uint32_wrapper: {value: 0}"); 1389 RunValidJsonTest( 1390 "OptionalInt64Wrapper", 1391 R"({"optionalInt64Wrapper": 0})", 1392 "optional_int64_wrapper: {value: 0}"); 1393 RunValidJsonTest( 1394 "OptionalUint64Wrapper", 1395 R"({"optionalUint64Wrapper": 0})", 1396 "optional_uint64_wrapper: {value: 0}"); 1397 RunValidJsonTest( 1398 "OptionalFloatWrapper", 1399 R"({"optionalFloatWrapper": 0})", 1400 "optional_float_wrapper: {value: 0}"); 1401 RunValidJsonTest( 1402 "OptionalDoubleWrapper", 1403 R"({"optionalDoubleWrapper": 0})", 1404 "optional_double_wrapper: {value: 0}"); 1405 RunValidJsonTest( 1406 "OptionalStringWrapper", 1407 R"({"optionalStringWrapper": ""})", 1408 R"(optional_string_wrapper: {value: ""})"); 1409 RunValidJsonTest( 1410 "OptionalBytesWrapper", 1411 R"({"optionalBytesWrapper": ""})", 1412 R"(optional_bytes_wrapper: {value: ""})"); 1413 RunValidJsonTest( 1414 "OptionalWrapperTypesWithNonDefaultValue", 1415 R"({ 1416 "optionalBoolWrapper": true, 1417 "optionalInt32Wrapper": 1, 1418 "optionalUint32Wrapper": 1, 1419 "optionalInt64Wrapper": "1", 1420 "optionalUint64Wrapper": "1", 1421 "optionalFloatWrapper": 1, 1422 "optionalDoubleWrapper": 1, 1423 "optionalStringWrapper": "1", 1424 "optionalBytesWrapper": "AQI=" 1425 })", 1426 R"( 1427 optional_bool_wrapper: {value: true} 1428 optional_int32_wrapper: {value: 1} 1429 optional_uint32_wrapper: {value: 1} 1430 optional_int64_wrapper: {value: 1} 1431 optional_uint64_wrapper: {value: 1} 1432 optional_float_wrapper: {value: 1} 1433 optional_double_wrapper: {value: 1} 1434 optional_string_wrapper: {value: "1"} 1435 optional_bytes_wrapper: {value: "\x01\x02"} 1436 )"); 1437 RunValidJsonTest( 1438 "RepeatedBoolWrapper", 1439 R"({"repeatedBoolWrapper": [true, false]})", 1440 "repeated_bool_wrapper: {value: true}" 1441 "repeated_bool_wrapper: {value: false}"); 1442 RunValidJsonTest( 1443 "RepeatedInt32Wrapper", 1444 R"({"repeatedInt32Wrapper": [0, 1]})", 1445 "repeated_int32_wrapper: {value: 0}" 1446 "repeated_int32_wrapper: {value: 1}"); 1447 RunValidJsonTest( 1448 "RepeatedUint32Wrapper", 1449 R"({"repeatedUint32Wrapper": [0, 1]})", 1450 "repeated_uint32_wrapper: {value: 0}" 1451 "repeated_uint32_wrapper: {value: 1}"); 1452 RunValidJsonTest( 1453 "RepeatedInt64Wrapper", 1454 R"({"repeatedInt64Wrapper": [0, 1]})", 1455 "repeated_int64_wrapper: {value: 0}" 1456 "repeated_int64_wrapper: {value: 1}"); 1457 RunValidJsonTest( 1458 "RepeatedUint64Wrapper", 1459 R"({"repeatedUint64Wrapper": [0, 1]})", 1460 "repeated_uint64_wrapper: {value: 0}" 1461 "repeated_uint64_wrapper: {value: 1}"); 1462 RunValidJsonTest( 1463 "RepeatedFloatWrapper", 1464 R"({"repeatedFloatWrapper": [0, 1]})", 1465 "repeated_float_wrapper: {value: 0}" 1466 "repeated_float_wrapper: {value: 1}"); 1467 RunValidJsonTest( 1468 "RepeatedDoubleWrapper", 1469 R"({"repeatedDoubleWrapper": [0, 1]})", 1470 "repeated_double_wrapper: {value: 0}" 1471 "repeated_double_wrapper: {value: 1}"); 1472 RunValidJsonTest( 1473 "RepeatedStringWrapper", 1474 R"({"repeatedStringWrapper": ["", "AQI="]})", 1475 R"( 1476 repeated_string_wrapper: {value: ""} 1477 repeated_string_wrapper: {value: "AQI="} 1478 )"); 1479 RunValidJsonTest( 1480 "RepeatedBytesWrapper", 1481 R"({"repeatedBytesWrapper": ["", "AQI="]})", 1482 R"( 1483 repeated_bytes_wrapper: {value: ""} 1484 repeated_bytes_wrapper: {value: "\x01\x02"} 1485 )"); 1486 RunValidJsonTest( 1487 "WrapperTypesWithNullValue", 1488 R"({ 1489 "optionalBoolWrapper": null, 1490 "optionalInt32Wrapper": null, 1491 "optionalUint32Wrapper": null, 1492 "optionalInt64Wrapper": null, 1493 "optionalUint64Wrapper": null, 1494 "optionalFloatWrapper": null, 1495 "optionalDoubleWrapper": null, 1496 "optionalStringWrapper": null, 1497 "optionalBytesWrapper": null, 1498 "repeatedBoolWrapper": null, 1499 "repeatedInt32Wrapper": null, 1500 "repeatedUint32Wrapper": null, 1501 "repeatedInt64Wrapper": null, 1502 "repeatedUint64Wrapper": null, 1503 "repeatedFloatWrapper": null, 1504 "repeatedDoubleWrapper": null, 1505 "repeatedStringWrapper": null, 1506 "repeatedBytesWrapper": null 1507 })", 1508 ""); 1509 1510 // Duration 1511 RunValidJsonTest( 1512 "DurationMinValue", 1513 R"({"optionalDuration": "-315576000000.999999999s"})", 1514 "optional_duration: {seconds: -315576000000 nanos: -999999999}"); 1515 RunValidJsonTest( 1516 "DurationMaxValue", 1517 R"({"optionalDuration": "315576000000.999999999s"})", 1518 "optional_duration: {seconds: 315576000000 nanos: 999999999}"); 1519 RunValidJsonTest( 1520 "DurationRepeatedValue", 1521 R"({"repeatedDuration": ["1.5s", "-1.5s"]})", 1522 "repeated_duration: {seconds: 1 nanos: 500000000}" 1523 "repeated_duration: {seconds: -1 nanos: -500000000}"); 1524 1525 ExpectParseFailureForJson( 1526 "DurationMissingS", 1527 R"({"optionalDuration": "1"})"); 1528 ExpectParseFailureForJson( 1529 "DurationJsonInputTooSmall", 1530 R"({"optionalDuration": "-315576000001.000000000s"})"); 1531 ExpectParseFailureForJson( 1532 "DurationJsonInputTooLarge", 1533 R"({"optionalDuration": "315576000001.000000000s"})"); 1534 ExpectSerializeFailureForJson( 1535 "DurationProtoInputTooSmall", 1536 "optional_duration: {seconds: -315576000001 nanos: 0}"); 1537 ExpectSerializeFailureForJson( 1538 "DurationProtoInputTooLarge", 1539 "optional_duration: {seconds: 315576000001 nanos: 0}"); 1540 1541 RunValidJsonTestWithValidator( 1542 "DurationHasZeroFractionalDigit", 1543 R"({"optionalDuration": "1.000000000s"})", 1544 [](const Json::Value& value) { 1545 return value["optionalDuration"].asString() == "1s"; 1546 }); 1547 RunValidJsonTestWithValidator( 1548 "DurationHas3FractionalDigits", 1549 R"({"optionalDuration": "1.010000000s"})", 1550 [](const Json::Value& value) { 1551 return value["optionalDuration"].asString() == "1.010s"; 1552 }); 1553 RunValidJsonTestWithValidator( 1554 "DurationHas6FractionalDigits", 1555 R"({"optionalDuration": "1.000010000s"})", 1556 [](const Json::Value& value) { 1557 return value["optionalDuration"].asString() == "1.000010s"; 1558 }); 1559 RunValidJsonTestWithValidator( 1560 "DurationHas9FractionalDigits", 1561 R"({"optionalDuration": "1.000000010s"})", 1562 [](const Json::Value& value) { 1563 return value["optionalDuration"].asString() == "1.000000010s"; 1564 }); 1565 1566 // Timestamp 1567 RunValidJsonTest( 1568 "TimestampMinValue", 1569 R"({"optionalTimestamp": "0001-01-01T00:00:00Z"})", 1570 "optional_timestamp: {seconds: -62135596800}"); 1571 RunValidJsonTest( 1572 "TimestampMaxValue", 1573 R"({"optionalTimestamp": "9999-12-31T23:59:59.999999999Z"})", 1574 "optional_timestamp: {seconds: 253402300799 nanos: 999999999}"); 1575 RunValidJsonTest( 1576 "TimestampRepeatedValue", 1577 R"({ 1578 "repeatedTimestamp": [ 1579 "0001-01-01T00:00:00Z", 1580 "9999-12-31T23:59:59.999999999Z" 1581 ] 1582 })", 1583 "repeated_timestamp: {seconds: -62135596800}" 1584 "repeated_timestamp: {seconds: 253402300799 nanos: 999999999}"); 1585 RunValidJsonTest( 1586 "TimestampWithPositiveOffset", 1587 R"({"optionalTimestamp": "1970-01-01T08:00:00+08:00"})", 1588 "optional_timestamp: {seconds: 0}"); 1589 RunValidJsonTest( 1590 "TimestampWithNegativeOffset", 1591 R"({"optionalTimestamp": "1969-12-31T16:00:00-08:00"})", 1592 "optional_timestamp: {seconds: 0}"); 1593 1594 ExpectParseFailureForJson( 1595 "TimestampJsonInputTooSmall", 1596 R"({"optionalTimestamp": "0000-01-01T00:00:00Z"})"); 1597 ExpectParseFailureForJson( 1598 "TimestampJsonInputTooLarge", 1599 R"({"optionalTimestamp": "10000-01-01T00:00:00Z"})"); 1600 ExpectParseFailureForJson( 1601 "TimestampJsonInputMissingZ", 1602 R"({"optionalTimestamp": "0001-01-01T00:00:00"})"); 1603 ExpectParseFailureForJson( 1604 "TimestampJsonInputMissingT", 1605 R"({"optionalTimestamp": "0001-01-01 00:00:00Z"})"); 1606 ExpectParseFailureForJson( 1607 "TimestampJsonInputLowercaseZ", 1608 R"({"optionalTimestamp": "0001-01-01T00:00:00z"})"); 1609 ExpectParseFailureForJson( 1610 "TimestampJsonInputLowercaseT", 1611 R"({"optionalTimestamp": "0001-01-01t00:00:00Z"})"); 1612 ExpectSerializeFailureForJson( 1613 "TimestampProtoInputTooSmall", 1614 "optional_timestamp: {seconds: -62135596801}"); 1615 ExpectSerializeFailureForJson( 1616 "TimestampProtoInputTooLarge", 1617 "optional_timestamp: {seconds: 253402300800}"); 1618 RunValidJsonTestWithValidator( 1619 "TimestampZeroNormalized", 1620 R"({"optionalTimestamp": "1969-12-31T16:00:00-08:00"})", 1621 [](const Json::Value& value) { 1622 return value["optionalTimestamp"].asString() == 1623 "1970-01-01T00:00:00Z"; 1624 }); 1625 RunValidJsonTestWithValidator( 1626 "TimestampHasZeroFractionalDigit", 1627 R"({"optionalTimestamp": "1970-01-01T00:00:00.000000000Z"})", 1628 [](const Json::Value& value) { 1629 return value["optionalTimestamp"].asString() == 1630 "1970-01-01T00:00:00Z"; 1631 }); 1632 RunValidJsonTestWithValidator( 1633 "TimestampHas3FractionalDigits", 1634 R"({"optionalTimestamp": "1970-01-01T00:00:00.010000000Z"})", 1635 [](const Json::Value& value) { 1636 return value["optionalTimestamp"].asString() == 1637 "1970-01-01T00:00:00.010Z"; 1638 }); 1639 RunValidJsonTestWithValidator( 1640 "TimestampHas6FractionalDigits", 1641 R"({"optionalTimestamp": "1970-01-01T00:00:00.000010000Z"})", 1642 [](const Json::Value& value) { 1643 return value["optionalTimestamp"].asString() == 1644 "1970-01-01T00:00:00.000010Z"; 1645 }); 1646 RunValidJsonTestWithValidator( 1647 "TimestampHas9FractionalDigits", 1648 R"({"optionalTimestamp": "1970-01-01T00:00:00.000000010Z"})", 1649 [](const Json::Value& value) { 1650 return value["optionalTimestamp"].asString() == 1651 "1970-01-01T00:00:00.000000010Z"; 1652 }); 1653 1654 // FieldMask 1655 RunValidJsonTest( 1656 "FieldMask", 1657 R"({"optionalFieldMask": "foo,barBaz"})", 1658 R"(optional_field_mask: {paths: "foo" paths: "bar_baz"})"); 1659 ExpectParseFailureForJson( 1660 "FieldMaskInvalidCharacter", 1661 R"({"optionalFieldMask": "foo,bar_bar"})"); 1662 ExpectSerializeFailureForJson( 1663 "FieldMaskPathsDontRoundTrip", 1664 R"(optional_field_mask: {paths: "fooBar"})"); 1665 ExpectSerializeFailureForJson( 1666 "FieldMaskNumbersDontRoundTrip", 1667 R"(optional_field_mask: {paths: "foo_3_bar"})"); 1668 ExpectSerializeFailureForJson( 1669 "FieldMaskTooManyUnderscore", 1670 R"(optional_field_mask: {paths: "foo__bar"})"); 1671 1672 // Struct 1673 RunValidJsonTest( 1674 "Struct", 1675 R"({ 1676 "optionalStruct": { 1677 "nullValue": null, 1678 "intValue": 1234, 1679 "boolValue": true, 1680 "doubleValue": 1234.5678, 1681 "stringValue": "Hello world!", 1682 "listValue": [1234, "5678"], 1683 "objectValue": { 1684 "value": 0 1685 } 1686 } 1687 })", 1688 R"( 1689 optional_struct: { 1690 fields: { 1691 key: "nullValue" 1692 value: {null_value: NULL_VALUE} 1693 } 1694 fields: { 1695 key: "intValue" 1696 value: {number_value: 1234} 1697 } 1698 fields: { 1699 key: "boolValue" 1700 value: {bool_value: true} 1701 } 1702 fields: { 1703 key: "doubleValue" 1704 value: {number_value: 1234.5678} 1705 } 1706 fields: { 1707 key: "stringValue" 1708 value: {string_value: "Hello world!"} 1709 } 1710 fields: { 1711 key: "listValue" 1712 value: { 1713 list_value: { 1714 values: { 1715 number_value: 1234 1716 } 1717 values: { 1718 string_value: "5678" 1719 } 1720 } 1721 } 1722 } 1723 fields: { 1724 key: "objectValue" 1725 value: { 1726 struct_value: { 1727 fields: { 1728 key: "value" 1729 value: { 1730 number_value: 0 1731 } 1732 } 1733 } 1734 } 1735 } 1736 } 1737 )"); 1738 // Value 1739 RunValidJsonTest( 1740 "ValueAcceptInteger", 1741 R"({"optionalValue": 1})", 1742 "optional_value: { number_value: 1}"); 1743 RunValidJsonTest( 1744 "ValueAcceptFloat", 1745 R"({"optionalValue": 1.5})", 1746 "optional_value: { number_value: 1.5}"); 1747 RunValidJsonTest( 1748 "ValueAcceptBool", 1749 R"({"optionalValue": false})", 1750 "optional_value: { bool_value: false}"); 1751 RunValidJsonTest( 1752 "ValueAcceptNull", 1753 R"({"optionalValue": null})", 1754 "optional_value: { null_value: NULL_VALUE}"); 1755 RunValidJsonTest( 1756 "ValueAcceptString", 1757 R"({"optionalValue": "hello"})", 1758 R"(optional_value: { string_value: "hello"})"); 1759 RunValidJsonTest( 1760 "ValueAcceptList", 1761 R"({"optionalValue": [0, "hello"]})", 1762 R"( 1763 optional_value: { 1764 list_value: { 1765 values: { 1766 number_value: 0 1767 } 1768 values: { 1769 string_value: "hello" 1770 } 1771 } 1772 } 1773 )"); 1774 RunValidJsonTest( 1775 "ValueAcceptObject", 1776 R"({"optionalValue": {"value": 1}})", 1777 R"( 1778 optional_value: { 1779 struct_value: { 1780 fields: { 1781 key: "value" 1782 value: { 1783 number_value: 1 1784 } 1785 } 1786 } 1787 } 1788 )"); 1789 1790 // Any 1791 RunValidJsonTest( 1792 "Any", 1793 R"({ 1794 "optionalAny": { 1795 "@type": "type.googleapis.com/conformance.TestAllTypes", 1796 "optionalInt32": 12345 1797 } 1798 })", 1799 R"( 1800 optional_any: { 1801 [type.googleapis.com/conformance.TestAllTypes] { 1802 optional_int32: 12345 1803 } 1804 } 1805 )"); 1806 RunValidJsonTest( 1807 "AnyNested", 1808 R"({ 1809 "optionalAny": { 1810 "@type": "type.googleapis.com/google.protobuf.Any", 1811 "value": { 1812 "@type": "type.googleapis.com/conformance.TestAllTypes", 1813 "optionalInt32": 12345 1814 } 1815 } 1816 })", 1817 R"( 1818 optional_any: { 1819 [type.googleapis.com/google.protobuf.Any] { 1820 [type.googleapis.com/conformance.TestAllTypes] { 1821 optional_int32: 12345 1822 } 1823 } 1824 } 1825 )"); 1826 // The special "@type" tag is not required to appear first. 1827 RunValidJsonTest( 1828 "AnyUnorderedTypeTag", 1829 R"({ 1830 "optionalAny": { 1831 "optionalInt32": 12345, 1832 "@type": "type.googleapis.com/conformance.TestAllTypes" 1833 } 1834 })", 1835 R"( 1836 optional_any: { 1837 [type.googleapis.com/conformance.TestAllTypes] { 1838 optional_int32: 12345 1839 } 1840 } 1841 )"); 1842 // Well-known types in Any. 1843 RunValidJsonTest( 1844 "AnyWithInt32ValueWrapper", 1845 R"({ 1846 "optionalAny": { 1847 "@type": "type.googleapis.com/google.protobuf.Int32Value", 1848 "value": 12345 1849 } 1850 })", 1851 R"( 1852 optional_any: { 1853 [type.googleapis.com/google.protobuf.Int32Value] { 1854 value: 12345 1855 } 1856 } 1857 )"); 1858 RunValidJsonTest( 1859 "AnyWithDuration", 1860 R"({ 1861 "optionalAny": { 1862 "@type": "type.googleapis.com/google.protobuf.Duration", 1863 "value": "1.5s" 1864 } 1865 })", 1866 R"( 1867 optional_any: { 1868 [type.googleapis.com/google.protobuf.Duration] { 1869 seconds: 1 1870 nanos: 500000000 1871 } 1872 } 1873 )"); 1874 RunValidJsonTest( 1875 "AnyWithTimestamp", 1876 R"({ 1877 "optionalAny": { 1878 "@type": "type.googleapis.com/google.protobuf.Timestamp", 1879 "value": "1970-01-01T00:00:00Z" 1880 } 1881 })", 1882 R"( 1883 optional_any: { 1884 [type.googleapis.com/google.protobuf.Timestamp] { 1885 seconds: 0 1886 nanos: 0 1887 } 1888 } 1889 )"); 1890 RunValidJsonTest( 1891 "AnyWithFieldMask", 1892 R"({ 1893 "optionalAny": { 1894 "@type": "type.googleapis.com/google.protobuf.FieldMask", 1895 "value": "foo,barBaz" 1896 } 1897 })", 1898 R"( 1899 optional_any: { 1900 [type.googleapis.com/google.protobuf.FieldMask] { 1901 paths: ["foo", "bar_baz"] 1902 } 1903 } 1904 )"); 1905 RunValidJsonTest( 1906 "AnyWithStruct", 1907 R"({ 1908 "optionalAny": { 1909 "@type": "type.googleapis.com/google.protobuf.Struct", 1910 "value": { 1911 "foo": 1 1912 } 1913 } 1914 })", 1915 R"( 1916 optional_any: { 1917 [type.googleapis.com/google.protobuf.Struct] { 1918 fields: { 1919 key: "foo" 1920 value: { 1921 number_value: 1 1922 } 1923 } 1924 } 1925 } 1926 )"); 1927 RunValidJsonTest( 1928 "AnyWithValueForJsonObject", 1929 R"({ 1930 "optionalAny": { 1931 "@type": "type.googleapis.com/google.protobuf.Value", 1932 "value": { 1933 "foo": 1 1934 } 1935 } 1936 })", 1937 R"( 1938 optional_any: { 1939 [type.googleapis.com/google.protobuf.Value] { 1940 struct_value: { 1941 fields: { 1942 key: "foo" 1943 value: { 1944 number_value: 1 1945 } 1946 } 1947 } 1948 } 1949 } 1950 )"); 1951 RunValidJsonTest( 1952 "AnyWithValueForInteger", 1953 R"({ 1954 "optionalAny": { 1955 "@type": "type.googleapis.com/google.protobuf.Value", 1956 "value": 1 1957 } 1958 })", 1959 R"( 1960 optional_any: { 1961 [type.googleapis.com/google.protobuf.Value] { 1962 number_value: 1 1963 } 1964 } 1965 )"); 1966 1967 bool ok = true; 1968 if (!CheckSetEmpty(expected_to_fail_, 1969 "These tests were listed in the failure list, but they " 1970 "don't exist. Remove them from the failure list")) { 1971 ok = false; 1972 } 1973 if (!CheckSetEmpty(unexpected_failing_tests_, 1974 "These tests failed. If they can't be fixed right now, " 1975 "you can add them to the failure list so the overall " 1976 "suite can succeed")) { 1977 ok = false; 1978 } 1979 1980 // Sometimes the testee may be fixed before we update the failure list (e.g., 1981 // the testee is from a different component). We warn about this case but 1982 // don't consider it an overall test failure. 1983 CheckSetEmpty(unexpected_succeeding_tests_, 1984 "These tests succeeded, even though they were listed in " 1985 "the failure list. Remove them from the failure list"); 1986 1987 if (verbose_) { 1988 CheckSetEmpty(skipped_, 1989 "These tests were skipped (probably because support for some " 1990 "features is not implemented)"); 1991 } 1992 1993 StringAppendF(&output_, 1994 "CONFORMANCE SUITE %s: %d successes, %d skipped, " 1995 "%d expected failures, %d unexpected failures.\n", 1996 ok ? "PASSED" : "FAILED", successes_, skipped_.size(), 1997 expected_failures_, unexpected_failing_tests_.size()); 1998 StringAppendF(&output_, "\n"); 1999 2000 output->assign(output_); 2001 2002 return ok; 2003} 2004 2005} // namespace protobuf 2006} // namespace google 2007