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