add proto2 supported for cpp,python,nodejs,ruby,php

19 files changed, 496 insertions, 32 deletions

diff --git a/conformance/ConformanceJava$1.class b/conformance/ConformanceJava$1.class
new file mode 100644
index 00000000..823d4374
--- /dev/null
+++ b/conformance/ConformanceJava$1.class
diff --git a/conformance/ConformanceJava$BinaryDecoder$1.class b/conformance/ConformanceJava$BinaryDecoder$1.class
new file mode 100644
index 00000000..940e39f0
--- /dev/null
+++ b/conformance/ConformanceJava$BinaryDecoder$1.class
diff --git a/conformance/ConformanceJava$BinaryDecoder$2.class b/conformance/ConformanceJava$BinaryDecoder$2.class
new file mode 100644
index 00000000..64553b6f
--- /dev/null
+++ b/conformance/ConformanceJava$BinaryDecoder$2.class
diff --git a/conformance/ConformanceJava$BinaryDecoder$3.class b/conformance/ConformanceJava$BinaryDecoder$3.class
new file mode 100644
index 00000000..104336d5
--- /dev/null
+++ b/conformance/ConformanceJava$BinaryDecoder$3.class
diff --git a/conformance/ConformanceJava$BinaryDecoder$4.class b/conformance/ConformanceJava$BinaryDecoder$4.class
new file mode 100644
index 00000000..2bfeda92
--- /dev/null
+++ b/conformance/ConformanceJava$BinaryDecoder$4.class
diff --git a/conformance/ConformanceJava$BinaryDecoder$5.class b/conformance/ConformanceJava$BinaryDecoder$5.class
new file mode 100644
index 00000000..c5dea858
--- /dev/null
+++ b/conformance/ConformanceJava$BinaryDecoder$5.class
diff --git a/conformance/ConformanceJava$BinaryDecoder$6.class b/conformance/ConformanceJava$BinaryDecoder$6.class
new file mode 100644
index 00000000..d617cce5
--- /dev/null
+++ b/conformance/ConformanceJava$BinaryDecoder$6.class
diff --git a/conformance/ConformanceJava$BinaryDecoder$7.class b/conformance/ConformanceJava$BinaryDecoder$7.class
new file mode 100644
index 00000000..6522a5e6
--- /dev/null
+++ b/conformance/ConformanceJava$BinaryDecoder$7.class
diff --git a/conformance/ConformanceJava$BinaryDecoder.class b/conformance/ConformanceJava$BinaryDecoder.class
new file mode 100644
index 00000000..3dd7ba07
--- /dev/null
+++ b/conformance/ConformanceJava$BinaryDecoder.class
diff --git a/conformance/ConformanceJava.class b/conformance/ConformanceJava.class
new file mode 100644
index 00000000..74fc5e84
--- /dev/null
+++ b/conformance/ConformanceJava.class
diff --git a/conformance/conformance_cpp.cc b/conformance/conformance_cpp.cc
index b865cd93..9c590702 100644
--- a/conformance/conformance_cpp.cc
+++ b/conformance/conformance_cpp.cc
@@ -34,6 +34,7 @@
 
 #include "conformance.pb.h"
 #include <google/protobuf/test_messages_proto3.pb.h>
+#include <google/protobuf/test_messages_proto2.pb.h>
 #include <google/protobuf/util/json_util.h>
 #include <google/protobuf/util/type_resolver_util.h>
 
@@ -48,6 +49,7 @@ using google::protobuf::util::NewTypeResolverForDescriptorPool;
 using google::protobuf::util::Status;
 using google::protobuf::util::TypeResolver;
 using protobuf_test_messages::proto3::TestAllTypes;
+using protobuf_test_messages::proto2::TestAllTypesProto2;
 using std::string;
 
 static const char kTypeUrlPrefix[] = "type.googleapis.com";
@@ -88,16 +90,29 @@ void CheckedWrite(int fd, const void *buf, size_t len) {
 
 void DoTest(const ConformanceRequest& request, ConformanceResponse* response) {
   TestAllTypes test_message;
+  TestAllTypesProto2 test_message_proto2;
+  bool isProto3 = request.message_type() == "proto3";
+  bool isJson = request.payload_case() == ConformanceRequest::kJsonPayload;
 
   switch (request.payload_case()) {
-    case ConformanceRequest::kProtobufPayload:
-      if (!test_message.ParseFromString(request.protobuf_payload())) {
-        // Getting parse details would involve something like:
-        //   http://stackoverflow.com/questions/22121922/how-can-i-get-more-details-about-errors-generated-during-protobuf-parsing-c
-        response->set_parse_error("Parse error (no more details available).");
-        return;
+    case ConformanceRequest::kProtobufPayload: {
+      if (isProto3) {
+        if (!test_message.ParseFromString(request.protobuf_payload())) {
+          // Getting parse details would involve something like:
+          //   http://stackoverflow.com/questions/22121922/how-can-i-get-more-details-about-errors-generated-during-protobuf-parsing-c
+          response->set_parse_error("Parse error (no more details available).");
+          return;
+        }
+      } else if (request.message_type() == "proto2") {
+        if (!test_message_proto2.ParseFromString(request.protobuf_payload())) {
+          response->set_parse_error("Parse error (no more details available).");
+          return;
+        }
+      } else {
+        GOOGLE_LOG(FATAL) << "Protobuf request doesn't have specific payload type";
       }
       break;
+    }
 
     case ConformanceRequest::kJsonPayload: {
       string proto_binary;
@@ -127,14 +142,22 @@ void DoTest(const ConformanceRequest& request, ConformanceResponse* response) {
       GOOGLE_LOG(FATAL) << "Unspecified output format";
       break;
 
-    case conformance::PROTOBUF:
-      GOOGLE_CHECK(
-          test_message.SerializeToString(response->mutable_protobuf_payload()));
+    case conformance::PROTOBUF: {
+      (isProto3 || isJson) ?
+        GOOGLE_CHECK(
+              test_message.SerializeToString(response->mutable_protobuf_payload()))
+              :
+        GOOGLE_CHECK(
+              test_message_proto2.SerializeToString(response->mutable_protobuf_payload()));
       break;
+    }
 
     case conformance::JSON: {
       string proto_binary;
-      GOOGLE_CHECK(test_message.SerializeToString(&proto_binary));
+      (isProto3 || isJson) ?
+          GOOGLE_CHECK(test_message.SerializeToString(&proto_binary))
+               :
+          GOOGLE_CHECK(test_message_proto2.SerializeToString(&proto_binary));
       Status status = BinaryToJsonString(type_resolver, *type_url, proto_binary,
                                          response->mutable_json_payload());
       if (!status.ok()) {
diff --git a/conformance/conformance_nodejs.js b/conformance/conformance_nodejs.js
index 5ee37269..30294bf6 100755
--- a/conformance/conformance_nodejs.js
+++ b/conformance/conformance_nodejs.js
@@ -49,14 +49,22 @@ function doTest(request) {
     }
 
     switch (request.getPayloadCase()) {
-      case conformance.ConformanceRequest.PayloadCase.PROTOBUF_PAYLOAD:
-        try {
-          testMessage = test_messages_proto3.TestAllTypes.deserializeBinary(
-              request.getProtobufPayload());
-        } catch (err) {
-          response.setParseError(err.toString());
+      case conformance.ConformanceRequest.PayloadCase.PROTOBUF_PAYLOAD: {
+        if (request.getMessageType() == "proto3") {
+          try {
+            testMessage = test_messages_proto3.TestAllTypes.deserializeBinary(
+                request.getProtobufPayload());
+          } catch (err) {
+            response.setParseError(err.toString());
+            return response;
+          }
+        } else if (request.getMessageType() == "proto2"){
+          response.setSkipped("NodeJS doesn\'t support proto2");
           return response;
+        } else {
+          throw "Protobuf request doesn\'t have specific payload type";
         }
+      }
 
       case conformance.ConformanceRequest.PayloadCase.JSON_PAYLOAD:
         response.setSkipped("JSON not supported.");
diff --git a/conformance/conformance_php.php b/conformance/conformance_php.php
index 20fb5082..848cb4c7 100755
--- a/conformance/conformance_php.php
+++ b/conformance/conformance_php.php
@@ -45,11 +45,18 @@ function doTest($request)
     $test_message = new \Protobuf_test_messages\Proto3\TestAllTypes();
     $response = new \Conformance\ConformanceResponse();
     if ($request->getPayload() == "protobuf_payload") {
-      try {
+      if ($request->getMessageType() == "proto3") {
+        try {
           $test_message->mergeFromString($request->getProtobufPayload());
-      } catch (Exception $e) {
+        } catch (Exception $e) {
           $response->setParseError($e->getMessage());
           return $response;
+        }
+      } elseif ($request->getMessageType() == "proto2") {
+	$response->setSkipped("PHP doesn't support proto2");
+	return $response;
+      } else {
+	trigger_error("Protobuf request doesn't have specific payload type", E_USER_ERROR);
       }
     } elseif ($request->getPayload() == "json_payload") {
       try {
diff --git a/conformance/conformance_php.php~ b/conformance/conformance_php.php~
new file mode 100755
index 00000000..848cb4c7
--- /dev/null
+++ b/conformance/conformance_php.php~
@@ -0,0 +1,119 @@
+<?php
+
+require_once("Conformance/WireFormat.php");
+require_once("Conformance/ConformanceResponse.php");
+require_once("Conformance/ConformanceRequest.php");
+require_once("Google/Protobuf/Any.php");
+require_once("Google/Protobuf/Duration.php");
+require_once("Google/Protobuf/FieldMask.php");
+require_once("Google/Protobuf/Struct.php");
+require_once("Google/Protobuf/Value.php");
+require_once("Google/Protobuf/ListValue.php");
+require_once("Google/Protobuf/NullValue.php");
+require_once("Google/Protobuf/Timestamp.php");
+require_once("Google/Protobuf/DoubleValue.php");
+require_once("Google/Protobuf/BytesValue.php");
+require_once("Google/Protobuf/FloatValue.php");
+require_once("Google/Protobuf/Int64Value.php");
+require_once("Google/Protobuf/UInt32Value.php");
+require_once("Google/Protobuf/BoolValue.php");
+require_once("Google/Protobuf/DoubleValue.php");
+require_once("Google/Protobuf/Int32Value.php");
+require_once("Google/Protobuf/StringValue.php");
+require_once("Google/Protobuf/UInt64Value.php");
+require_once("Protobuf_test_messages/Proto3/ForeignMessage.php");
+require_once("Protobuf_test_messages/Proto3/ForeignEnum.php");
+require_once("Protobuf_test_messages/Proto3/TestAllTypes.php");
+require_once("Protobuf_test_messages/Proto3/TestAllTypes_NestedMessage.php");
+require_once("Protobuf_test_messages/Proto3/TestAllTypes_NestedEnum.php");
+
+require_once("GPBMetadata/Conformance.php");
+require_once("GPBMetadata/Google/Protobuf/Any.php");
+require_once("GPBMetadata/Google/Protobuf/Duration.php");
+require_once("GPBMetadata/Google/Protobuf/FieldMask.php");
+require_once("GPBMetadata/Google/Protobuf/Struct.php");
+require_once("GPBMetadata/Google/Protobuf/Timestamp.php");
+require_once("GPBMetadata/Google/Protobuf/Wrappers.php");
+require_once("GPBMetadata/Google/Protobuf/TestMessagesProto3.php");
+
+use  \Conformance\WireFormat;
+
+$test_count = 0;
+
+function doTest($request)
+{
+    $test_message = new \Protobuf_test_messages\Proto3\TestAllTypes();
+    $response = new \Conformance\ConformanceResponse();
+    if ($request->getPayload() == "protobuf_payload") {
+      if ($request->getMessageType() == "proto3") {
+        try {
+          $test_message->mergeFromString($request->getProtobufPayload());
+        } catch (Exception $e) {
+          $response->setParseError($e->getMessage());
+          return $response;
+        }
+      } elseif ($request->getMessageType() == "proto2") {
+	$response->setSkipped("PHP doesn't support proto2");
+	return $response;
+      } else {
+	trigger_error("Protobuf request doesn't have specific payload type", E_USER_ERROR);
+      }
+    } elseif ($request->getPayload() == "json_payload") {
+      try {
+          $test_message->jsonDecode($request->getJsonPayload());
+      } catch (Exception $e) {
+          $response->setParseError($e->getMessage());
+          return $response;
+      }
+    } else {
+      trigger_error("Request didn't have payload.", E_USER_ERROR);
+    }
+
+    if ($request->getRequestedOutputFormat() == WireFormat::UNSPECIFIED) {
+      trigger_error("Unspecified output format.", E_USER_ERROR);
+    } elseif ($request->getRequestedOutputFormat() == WireFormat::PROTOBUF) {
+      $response->setProtobufPayload($test_message->serializeToString());
+    } elseif ($request->getRequestedOutputFormat() == WireFormat::JSON) {
+      $response->setJsonPayload($test_message->jsonEncode());
+    }
+
+    return $response;
+}
+
+function doTestIO()
+{
+    $length_bytes = fread(STDIN, 4);
+    if (strlen($length_bytes) == 0) {
+      return false;   # EOF
+    } elseif (strlen($length_bytes) != 4) {
+      trigger_error("I/O error", E_USER_ERROR);
+    }
+
+    $length = unpack("V", $length_bytes)[1];
+    $serialized_request = fread(STDIN, $length);
+    if (strlen($serialized_request) != $length) {
+      trigger_error("I/O error", E_USER_ERROR);
+    }
+
+    $request = new \Conformance\ConformanceRequest();
+    $request->mergeFromString($serialized_request);
+
+    $response = doTest($request);
+
+    $serialized_response = $response->serializeToString();
+    fwrite(STDOUT, pack("V", strlen($serialized_response)));
+    fwrite(STDOUT, $serialized_response);
+
+    $GLOBALS['test_count'] += 1;
+
+    return true;
+}
+
+while(true){
+  if (!doTestIO()) {
+      fprintf(STDERR,
+             "conformance_php: received EOF from test runner " +
+             "after %d tests, exiting\n", $test_count);
+      exit;
+  }
+}
diff --git a/conformance/conformance_python.py b/conformance/conformance_python.py
index 7ace9b16..846ccbc6 100755
--- a/conformance/conformance_python.py
+++ b/conformance/conformance_python.py
@@ -41,6 +41,7 @@ import os
 from google.protobuf import json_format
 from google.protobuf import message
 from google.protobuf import test_messages_proto3_pb2
+from google.protobuf import test_messages_proto2_pb2
 import conformance_pb2
 
 sys.stdout = os.fdopen(sys.stdout.fileno(), 'wb', 0)
@@ -56,14 +57,26 @@ def do_test(request):
   test_message = test_messages_proto3_pb2.TestAllTypes()
   response = conformance_pb2.ConformanceResponse()
   test_message = test_messages_proto3_pb2.TestAllTypes()
+  test_message_proto2 = test_messages_proto2_pb2.TestAllTypesProto2()
+  isProto3 = (request.message_type == "proto3")
+  isJson = (request.WhichOneof('payload') == 'json_payload')
 
   try:
     if request.WhichOneof('payload') == 'protobuf_payload':
-      try:
-        test_message.ParseFromString(request.protobuf_payload)
-      except message.DecodeError as e:
-        response.parse_error = str(e)
-        return response
+      if isProto3:
+        try:
+          test_message.ParseFromString(request.protobuf_payload)
+        except message.DecodeError as e:
+          response.parse_error = str(e)
+          return response
+      elif request.message_type == "proto2":
+        try:
+          test_message_proto2.ParseFromString(request.protobuf_payload)
+        except message.DecodeError as e:
+          response.parse_error = str(e)
+          return response
+      else:
+        raise ProtocolError("Protobuf request doesn't have specific payload type")
 
     elif request.WhichOneof('payload') == 'json_payload':
       try:
@@ -79,11 +92,17 @@ def do_test(request):
       raise ProtocolError("Unspecified output format")
 
     elif request.requested_output_format == conformance_pb2.PROTOBUF:
-      response.protobuf_payload = test_message.SerializeToString()
+      if isProto3 or isJson:
+        response.protobuf_payload = test_message.SerializeToString()
+      else:
+        response.protobuf_payload = test_message_proto2.SerializeToString()
 
     elif request.requested_output_format == conformance_pb2.JSON:
       try:
-        response.json_payload = json_format.MessageToJson(test_message)
+        if isProto3 or isJson:        
+          response.json_payload = json_format.MessageToJson(test_message)
+        else:
+          response.json_payload = json_format.MessageToJson(test_message_proto2)
       except Exception as e:
         response.serialize_error = str(e)
         return response
diff --git a/conformance/conformance_ruby.rb b/conformance/conformance_ruby.rb
index a1170e4c..552344b4 100755
--- a/conformance/conformance_ruby.rb
+++ b/conformance/conformance_ruby.rb
@@ -53,9 +53,9 @@ def do_test(request)
         end
       elsif request.message_type.eql?('proto2')
         response.skipped = "Ruby doesn't support proto2"
-        return respons
+        return response
       else 
-        fail "Protobuf request doesn't have specific type"
+        fail "Protobuf request doesn't have specific payload type"
       end
 
     when :json_payload
diff --git a/conformance/conformance_ruby.rb~ b/conformance/conformance_ruby.rb~
new file mode 100755
index 00000000..7e756d18
--- /dev/null
+++ b/conformance/conformance_ruby.rb~
@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+#
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'conformance_pb'
+require 'google/protobuf/test_messages_proto3_pb'
+
+$test_count = 0
+$verbose = false
+
+def do_test(request)
+  test_message = ProtobufTestMessages::Proto3::TestAllTypes.new
+  response = Conformance::ConformanceResponse.new
+
+  begin
+    case request.payload
+    when :protobuf_payload
+      if request.message_type.eql?('proto3')
+        begin
+          test_message = ProtobufTestMessages::Proto3::TestAllTypes.decode(
+              request.protobuf_payload)
+        rescue Google::Protobuf::ParseError => err
+          response.parse_error = err.message.encode('utf-8')
+          return response
+        end
+      elsif request.message_type.eql?('proto2')
+        response.skipped = "Ruby doesn't support proto2"
+        return response
+      else 
+        fail "Protobuf request doesn't have specific type"
+      end
+
+    when :json_payload
+      begin
+        test_message = ProtobufTestMessages::Proto3::TestAllTypes.decode_json(
+            request.json_payload)
+      rescue Google::Protobuf::ParseError => err
+        response.parse_error = err.message.encode('utf-8')
+        return response
+      end
+
+    when nil
+      fail "Request didn't have payload"
+    end
+
+    case request.requested_output_format
+    when :UNSPECIFIED
+      fail 'Unspecified output format'
+
+    when :PROTOBUF
+      response.protobuf_payload = test_message.to_proto
+
+    when :JSON
+      response.json_payload = test_message.to_json
+
+    when nil
+      fail "Request didn't have requested output format"
+    end
+  rescue StandardError => err
+    response.runtime_error = err.message.encode('utf-8')
+  end
+
+  response
+end
+
+# Returns true if the test ran successfully, false on legitimate EOF.
+# If EOF is encountered in an unexpected place, raises IOError.
+def do_test_io
+  length_bytes = STDIN.read(4)
+  return false if length_bytes.nil?
+
+  length = length_bytes.unpack('V').first
+  serialized_request = STDIN.read(length)
+  if serialized_request.nil? || serialized_request.length != length
+    fail IOError
+  end
+
+  request = Conformance::ConformanceRequest.decode(serialized_request)
+
+  response = do_test(request)
+
+  serialized_response = Conformance::ConformanceResponse.encode(response)
+  STDOUT.write([serialized_response.length].pack('V'))
+  STDOUT.write(serialized_response)
+  STDOUT.flush
+
+  if $verbose
+    STDERR.puts("conformance_ruby: request=#{request.to_json}, " \
+                                 "response=#{response.to_json}\n")
+  end
+
+  $test_count += 1
+
+  true
+end
+
+loop do
+  unless do_test_io
+    STDERR.puts('conformance_ruby: received EOF from test runner ' \
+                "after #{$test_count} tests, exiting")
+    break
+  end
+end
diff --git a/conformance/conformance_test.cc b/conformance/conformance_test.cc
index 9b153fdb..f44fe8a1 100644
--- a/conformance/conformance_test.cc
+++ b/conformance/conformance_test.cc
@@ -277,8 +277,13 @@ void ConformanceTestSuite::RunValidInputTest(
     WireFormat input_format, const string& equivalent_text_format,
     WireFormat requested_output, bool isProto3) {
   TestAllTypes reference_message;
+  TestAllTypesProto2 reference_message_proto2;
   GOOGLE_CHECK(
-      TextFormat::ParseFromString(equivalent_text_format, &reference_message))
+      isProto3 ?
+          TextFormat::ParseFromString(equivalent_text_format, &reference_message)
+          :
+          TextFormat::ParseFromString(equivalent_text_format, &reference_message_proto2)
+  )
           << "Failed to parse data for test case: " << test_name
           << ", data: " << equivalent_text_format;
 
@@ -401,7 +406,13 @@ void ConformanceTestSuite::RunValidInputTest(
   string differences;
   differencer.ReportDifferencesToString(&differences);
 
-  if (differencer.Compare(reference_message, test_message)) {
+  bool check;
+  if (isProto3) {
+    check = differencer.Compare(reference_message, test_message);
+  } else {
+    check = differencer.Compare(reference_message_proto2, test_message_proto2);
+  }
+  if (check) {
     ReportSuccess(test_name);
   } else {
     ReportFailure(test_name, level, request, response,
@@ -477,12 +488,16 @@ void ConformanceTestSuite::RunValidProtobufTest(
     const string& test_name, ConformanceLevel level,
     const string& input_protobuf, const string& equivalent_text_format,
     bool isProto3) {
+  string rname = ".ProtobufInput.";
+  if (!isProto3) {
+    rname = ".Protobuf2Input.";
+  }
   RunValidInputTest(
-      ConformanceLevelToString(level) + ".ProtobufInput." + test_name +
+      ConformanceLevelToString(level) + rname + test_name +
       ".ProtobufOutput", level, input_protobuf, conformance::PROTOBUF,
       equivalent_text_format, conformance::PROTOBUF, isProto3);
   RunValidInputTest(
-      ConformanceLevelToString(level) + ".ProtobufInput." + test_name +
+      ConformanceLevelToString(level) + rname +  test_name +
       ".JsonOutput", level, input_protobuf, conformance::PROTOBUF,
       equivalent_text_format, conformance::JSON, isProto3);
 }
@@ -704,7 +719,8 @@ void ConformanceTestSuite::TestValidDataForType(
     proto += cat(tag(rep_field->number(), wire_type), values[i].first);
     text += rep_field->name() + ": " + values[i].second + " ";
   }
-  RunValidProtobufTest("ValidDataRepeated" + type_name, REQUIRED, proto, text, true);
+  RunValidProtobufTest("ValidDataRepeated" + type_name, REQUIRED,
+                       proto, text, isProto3);
 }
 
 void ConformanceTestSuite::SetFailureList(const string& filename,
@@ -796,6 +812,12 @@ bool ConformanceTestSuite::RunSuite(ConformanceTestRunner* runner,
     {dbl(1.7976931348623157e+308), "1.7976931348623157e+308"},
     {dbl(2.22507385850720138309e-308), "2.22507385850720138309e-308"}
   }, true);
+  TestValidDataForType(FieldDescriptor::TYPE_DOUBLE, {
+    {dbl(0.1), "0.1"},
+    {dbl(1.7976931348623157e+308), "1.7976931348623157e+308"},
+    {dbl(2.22507385850720138309e-308), "2.22507385850720138309e-308"}
+  }, false);
+
   TestValidDataForType(FieldDescriptor::TYPE_FLOAT, {
     {flt(0.1), "0.1"},
     {flt(1.00000075e-36), "1.00000075e-36"},
diff --git a/conformance/failure_list_ruby.txt~ b/conformance/failure_list_ruby.txt~
new file mode 100644
index 00000000..b0d2fe58
--- /dev/null
+++ b/conformance/failure_list_ruby.txt~
@@ -0,0 +1,135 @@
+Recommended.FieldMaskNumbersDontRoundTrip.JsonOutput
+Recommended.FieldMaskPathsDontRoundTrip.JsonOutput
+Recommended.FieldMaskTooManyUnderscore.JsonOutput
+Recommended.JsonInput.DurationHas3FractionalDigits.Validator
+Recommended.JsonInput.DurationHas6FractionalDigits.Validator
+Recommended.JsonInput.DurationHas9FractionalDigits.Validator
+Recommended.JsonInput.DurationHasZeroFractionalDigit.Validator
+Recommended.JsonInput.Int64FieldBeString.Validator
+Recommended.JsonInput.MapFieldValueIsNull
+Recommended.JsonInput.RepeatedFieldMessageElementIsNull
+Recommended.JsonInput.RepeatedFieldPrimitiveElementIsNull
+Recommended.JsonInput.StringEndsWithEscapeChar
+Recommended.JsonInput.StringFieldSurrogateInWrongOrder
+Recommended.JsonInput.StringFieldUnpairedHighSurrogate
+Recommended.JsonInput.StringFieldUnpairedLowSurrogate
+Recommended.JsonInput.TimestampHas3FractionalDigits.Validator
+Recommended.JsonInput.TimestampHas6FractionalDigits.Validator
+Recommended.JsonInput.TimestampHas9FractionalDigits.Validator
+Recommended.JsonInput.TimestampHasZeroFractionalDigit.Validator
+Recommended.JsonInput.TimestampZeroNormalized.Validator
+Recommended.JsonInput.Uint64FieldBeString.Validator
+Required.DurationProtoInputTooLarge.JsonOutput
+Required.DurationProtoInputTooSmall.JsonOutput
+Required.JsonInput.Any.JsonOutput
+Required.JsonInput.Any.ProtobufOutput
+Required.JsonInput.AnyNested.JsonOutput
+Required.JsonInput.AnyNested.ProtobufOutput
+Required.JsonInput.AnyUnorderedTypeTag.JsonOutput
+Required.JsonInput.AnyUnorderedTypeTag.ProtobufOutput
+Required.JsonInput.AnyWithDuration.JsonOutput
+Required.JsonInput.AnyWithDuration.ProtobufOutput
+Required.JsonInput.AnyWithFieldMask.JsonOutput
+Required.JsonInput.AnyWithFieldMask.ProtobufOutput
+Required.JsonInput.AnyWithInt32ValueWrapper.JsonOutput
+Required.JsonInput.AnyWithInt32ValueWrapper.ProtobufOutput
+Required.JsonInput.AnyWithStruct.JsonOutput
+Required.JsonInput.AnyWithStruct.ProtobufOutput
+Required.JsonInput.AnyWithTimestamp.JsonOutput
+Required.JsonInput.AnyWithTimestamp.ProtobufOutput
+Required.JsonInput.AnyWithValueForInteger.JsonOutput
+Required.JsonInput.AnyWithValueForInteger.ProtobufOutput
+Required.JsonInput.AnyWithValueForJsonObject.JsonOutput
+Required.JsonInput.AnyWithValueForJsonObject.ProtobufOutput
+Required.JsonInput.DoubleFieldMaxNegativeValue.JsonOutput
+Required.JsonInput.DoubleFieldMaxNegativeValue.ProtobufOutput
+Required.JsonInput.DoubleFieldMinPositiveValue.JsonOutput
+Required.JsonInput.DoubleFieldMinPositiveValue.ProtobufOutput
+Required.JsonInput.DoubleFieldNan.JsonOutput
+Required.JsonInput.DurationMaxValue.JsonOutput
+Required.JsonInput.DurationMaxValue.ProtobufOutput
+Required.JsonInput.DurationMinValue.JsonOutput
+Required.JsonInput.DurationMinValue.ProtobufOutput
+Required.JsonInput.DurationRepeatedValue.JsonOutput
+Required.JsonInput.DurationRepeatedValue.ProtobufOutput
+Required.JsonInput.FieldMask.JsonOutput
+Required.JsonInput.FieldMask.ProtobufOutput
+Required.JsonInput.FloatFieldInfinity.JsonOutput
+Required.JsonInput.FloatFieldNan.JsonOutput
+Required.JsonInput.FloatFieldNegativeInfinity.JsonOutput
+Required.JsonInput.FloatFieldTooLarge
+Required.JsonInput.FloatFieldTooSmall
+Required.JsonInput.OneofFieldDuplicate
+Required.JsonInput.OptionalBoolWrapper.JsonOutput
+Required.JsonInput.OptionalBoolWrapper.ProtobufOutput
+Required.JsonInput.OptionalBytesWrapper.JsonOutput
+Required.JsonInput.OptionalBytesWrapper.ProtobufOutput
+Required.JsonInput.OptionalDoubleWrapper.JsonOutput
+Required.JsonInput.OptionalDoubleWrapper.ProtobufOutput
+Required.JsonInput.OptionalFloatWrapper.JsonOutput
+Required.JsonInput.OptionalFloatWrapper.ProtobufOutput
+Required.JsonInput.OptionalInt32Wrapper.JsonOutput
+Required.JsonInput.OptionalInt32Wrapper.ProtobufOutput
+Required.JsonInput.OptionalInt64Wrapper.JsonOutput
+Required.JsonInput.OptionalInt64Wrapper.ProtobufOutput
+Required.JsonInput.OptionalStringWrapper.JsonOutput
+Required.JsonInput.OptionalStringWrapper.ProtobufOutput
+Required.JsonInput.OptionalUint32Wrapper.JsonOutput
+Required.JsonInput.OptionalUint32Wrapper.ProtobufOutput
+Required.JsonInput.OptionalUint64Wrapper.JsonOutput
+Required.JsonInput.OptionalUint64Wrapper.ProtobufOutput
+Required.JsonInput.OptionalWrapperTypesWithNonDefaultValue.JsonOutput
+Required.JsonInput.OptionalWrapperTypesWithNonDefaultValue.ProtobufOutput
+Required.JsonInput.RepeatedBoolWrapper.JsonOutput
+Required.JsonInput.RepeatedBoolWrapper.ProtobufOutput
+Required.JsonInput.RepeatedBytesWrapper.JsonOutput
+Required.JsonInput.RepeatedBytesWrapper.ProtobufOutput
+Required.JsonInput.RepeatedDoubleWrapper.JsonOutput
+Required.JsonInput.RepeatedDoubleWrapper.ProtobufOutput
+Required.JsonInput.RepeatedFloatWrapper.JsonOutput
+Required.JsonInput.RepeatedFloatWrapper.ProtobufOutput
+Required.JsonInput.RepeatedInt32Wrapper.JsonOutput
+Required.JsonInput.RepeatedInt32Wrapper.ProtobufOutput
+Required.JsonInput.RepeatedInt64Wrapper.JsonOutput
+Required.JsonInput.RepeatedInt64Wrapper.ProtobufOutput
+Required.JsonInput.RepeatedStringWrapper.JsonOutput
+Required.JsonInput.RepeatedStringWrapper.ProtobufOutput
+Required.JsonInput.RepeatedUint32Wrapper.JsonOutput
+Required.JsonInput.RepeatedUint32Wrapper.ProtobufOutput
+Required.JsonInput.RepeatedUint64Wrapper.JsonOutput
+Required.JsonInput.RepeatedUint64Wrapper.ProtobufOutput
+Required.JsonInput.StringFieldSurrogatePair.JsonOutput
+Required.JsonInput.StringFieldSurrogatePair.ProtobufOutput
+Required.JsonInput.Struct.JsonOutput
+Required.JsonInput.Struct.ProtobufOutput
+Required.JsonInput.TimestampMaxValue.JsonOutput
+Required.JsonInput.TimestampMaxValue.ProtobufOutput
+Required.JsonInput.TimestampMinValue.JsonOutput
+Required.JsonInput.TimestampMinValue.ProtobufOutput
+Required.JsonInput.TimestampRepeatedValue.JsonOutput
+Required.JsonInput.TimestampRepeatedValue.ProtobufOutput
+Required.JsonInput.TimestampWithNegativeOffset.JsonOutput
+Required.JsonInput.TimestampWithNegativeOffset.ProtobufOutput
+Required.JsonInput.TimestampWithPositiveOffset.JsonOutput
+Required.JsonInput.TimestampWithPositiveOffset.ProtobufOutput
+Required.JsonInput.ValueAcceptBool.JsonOutput
+Required.JsonInput.ValueAcceptBool.ProtobufOutput
+Required.JsonInput.ValueAcceptFloat.JsonOutput
+Required.JsonInput.ValueAcceptFloat.ProtobufOutput
+Required.JsonInput.ValueAcceptInteger.JsonOutput
+Required.JsonInput.ValueAcceptInteger.ProtobufOutput
+Required.JsonInput.ValueAcceptList.JsonOutput
+Required.JsonInput.ValueAcceptList.ProtobufOutput
+Required.JsonInput.ValueAcceptNull.JsonOutput
+Required.JsonInput.ValueAcceptNull.ProtobufOutput
+Required.JsonInput.ValueAcceptObject.JsonOutput
+Required.JsonInput.ValueAcceptObject.ProtobufOutput
+Required.JsonInput.ValueAcceptString.JsonOutput
+Required.JsonInput.ValueAcceptString.ProtobufOutput
+Required.Protobuf3Input.DoubleFieldNormalizeQuietNan.JsonOutput
+Required.Protobuf3Input.DoubleFieldNormalizeSignalingNan.JsonOutput
+Required.Protobuf3Input.FloatFieldNormalizeQuietNan.JsonOutput
+Required.Protobuf3Input.FloatFieldNormalizeSignalingNan.JsonOutput
+Required.Protobuf3Input.ValidDataRepeated.FLOAT.JsonOutput
+Required.TimestampProtoInputTooLarge.JsonOutput
+Required.TimestampProtoInputTooSmall.JsonOutput