Update third_party/protobuf to protobuf-v3.0.0-beta-3

third_party/protobuf/conformance/conformance_test.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 281 matching lines @@
       string binary_protobuf;
       Status status =
           JsonToBinaryString(type_resolver_.get(), type_url_,
                              response.json_payload(), &binary_protobuf);
       if (!status.ok()) {
         ReportFailure(test_name, request, response,
                       "JSON output we received from test was unparseable.");
         return;
       }
 
-      GOOGLE_CHECK(test_message.ParseFromString(binary_protobuf));
+      if (!test_message.ParseFromString(binary_protobuf)) {
+        ReportFailure(test_name, request, response,
+                      "INTERNAL ERROR: internal JSON->protobuf transcode "
+                      "yielded unparseable proto.");
+        return;
+      }
+
       break;
     }
 
     case ConformanceResponse::kProtobufPayload: {
       if (requested_output != conformance::PROTOBUF) {
         ReportFailure(
             test_name, request, response,
             "Test was asked for JSON output but provided protobuf instead.");
         return;
       }
@@ skipping 36 matching lines @@
   request.set_protobuf_payload(proto);
   string effective_test_name = "ProtobufInput." + test_name;
 
   // We don't expect output, but if the program erroneously accepts the protobuf
   // we let it send its response as this.  We must not leave it unspecified.
   request.set_requested_output_format(conformance::PROTOBUF);
 
   RunTest(effective_test_name, request, &response);
   if (response.result_case() == ConformanceResponse::kParseError) {
     ReportSuccess(effective_test_name);
+  } else if (response.result_case() == ConformanceResponse::kSkipped) {
+    ReportSkip(effective_test_name, request, response);
   } else {
     ReportFailure(effective_test_name, request, response,
                   "Should have failed to parse, but didn't.");
   }
 }
 
 // Expect that this protobuf will cause a parse error, even if it is followed
 // by valid protobuf data.  We can try running this twice: once with this
 // data verbatim and once with this data followed by some valid data.
 //
@@ skipping 32 matching lines @@
     const Validator& validator) {
   ConformanceRequest request;
   ConformanceResponse response;
   request.set_json_payload(input_json);
   request.set_requested_output_format(conformance::JSON);
 
   string effective_test_name = "JsonInput." + test_name + ".Validator";
 
   RunTest(effective_test_name, request, &response);
 
+  if (response.result_case() == ConformanceResponse::kSkipped) {
+    ReportSkip(effective_test_name, request, response);
+    return;
+  }
+
   if (response.result_case() != ConformanceResponse::kJsonPayload) {
     ReportFailure(effective_test_name, request, response,
                   "Expected JSON payload but got type %d.",
                   response.result_case());
     return;
   }
   Json::Reader reader;
   Json::Value value;
   if (!reader.parse(response.json_payload(), value)) {
     ReportFailure(effective_test_name, request, response,
@@ skipping 16 matching lines @@
   request.set_json_payload(input_json);
   string effective_test_name = "JsonInput." + test_name;
 
   // We don't expect output, but if the program erroneously accepts the protobuf
   // we let it send its response as this.  We must not leave it unspecified.
   request.set_requested_output_format(conformance::JSON);
 
   RunTest(effective_test_name, request, &response);
   if (response.result_case() == ConformanceResponse::kParseError) {
     ReportSuccess(effective_test_name);
+  } else if (response.result_case() == ConformanceResponse::kSkipped) {
+    ReportSkip(effective_test_name, request, response);
   } else {
     ReportFailure(effective_test_name, request, response,
                   "Should have failed to parse, but didn't.");
   }
 }
 
 void ConformanceTestSuite::ExpectSerializeFailureForJson(
     const string& test_name, const string& text_format) {
   TestAllTypes payload_message;
   GOOGLE_CHECK(
       TextFormat::ParseFromString(text_format, &payload_message))
           << "Failed to parse: " << text_format;
 
   ConformanceRequest request;
   ConformanceResponse response;
   request.set_protobuf_payload(payload_message.SerializeAsString());
   string effective_test_name = test_name + ".JsonOutput";
   request.set_requested_output_format(conformance::JSON);
 
   RunTest(effective_test_name, request, &response);
   if (response.result_case() == ConformanceResponse::kSerializeError) {
     ReportSuccess(effective_test_name);
+  } else if (response.result_case() == ConformanceResponse::kSkipped) {
+    ReportSkip(effective_test_name, request, response);
   } else {
     ReportFailure(effective_test_name, request, response,
                   "Should have failed to serialize, but didn't.");
   }
 }
 
 void ConformanceTestSuite::TestPrematureEOFForType(FieldDescriptor::Type type) {
   // Incomplete values for each wire type.
   static const string incompletes[6] = {
     string("\x80"),     // VARINT
@@ skipping 1481 matching lines @@
     ok = false;
   }
 
   // Sometimes the testee may be fixed before we update the failure list (e.g.,
   // the testee is from a different component). We warn about this case but
   // don't consider it an overall test failure.
   CheckSetEmpty(unexpected_succeeding_tests_,
                 "These tests succeeded, even though they were listed in "
                 "the failure list.  Remove them from the failure list");
 
-  CheckSetEmpty(skipped_,
-                "These tests were skipped (probably because support for some "
-                "features is not implemented)");
   if (verbose_) {
     CheckSetEmpty(skipped_,
                   "These tests were skipped (probably because support for some "
                   "features is not implemented)");
   }
 
   StringAppendF(&output_,
                 "CONFORMANCE SUITE %s: %d successes, %d skipped, "
                 "%d expected failures, %d unexpected failures.\n",
                 ok ? "PASSED" : "FAILED", successes_, skipped_.size(),
                 expected_failures_, unexpected_failing_tests_.size());
   StringAppendF(&output_, "\n");
 
   output->assign(output_);
 
   return ok;
 }
 
 }  // namespace protobuf
 }  // namespace google