third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/conformance/ConformanceJava.java

Index: third_party/protobuf/conformance/ConformanceJava.java
diff --git a/third_party/protobuf/conformance/ConformanceJava.java b/third_party/protobuf/conformance/ConformanceJava.java
index 43787ffcb274033008a8c020565f71dd0a4693e4..7badf2a5f54236d4b4ca1c008ef1f55123253433 100644
--- a/third_party/protobuf/conformance/ConformanceJava.java
+++ b/third_party/protobuf/conformance/ConformanceJava.java
@@ -1,8 +1,12 @@
-
+import com.google.protobuf.ByteString;
+import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.conformance.Conformance;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf_test_messages.proto3.TestMessagesProto3;
 import com.google.protobuf.util.JsonFormat;
 import com.google.protobuf.util.JsonFormat.TypeRegistry;
-import com.google.protobuf.InvalidProtocolBufferException;
+import java.io.IOException;
+import java.nio.ByteBuffer;
 
 class ConformanceJava {
   private int testCount = 0;
@@ -47,13 +51,182 @@ class ConformanceJava {
     writeToStdout(buf);
   }
 
+  private enum BinaryDecoder {
+    BYTE_STRING_DECODER() {
+      @Override
+      public TestMessagesProto3.TestAllTypes parse(ByteString bytes)
+          throws InvalidProtocolBufferException {
+        return TestMessagesProto3.TestAllTypes.parseFrom(bytes);
+      }
+    },
+    BYTE_ARRAY_DECODER() {
+      @Override
+      public TestMessagesProto3.TestAllTypes parse(ByteString bytes)
+          throws InvalidProtocolBufferException {
+        return TestMessagesProto3.TestAllTypes.parseFrom(bytes.toByteArray());
+      }
+    },
+    ARRAY_BYTE_BUFFER_DECODER() {
+      @Override
+      public TestMessagesProto3.TestAllTypes parse(ByteString bytes)
+          throws InvalidProtocolBufferException {
+        ByteBuffer buffer = ByteBuffer.allocate(bytes.size());
+        bytes.copyTo(buffer);
+        buffer.flip();
+        try {
+          return TestMessagesProto3.TestAllTypes.parseFrom(CodedInputStream.newInstance(buffer));
+        } catch (InvalidProtocolBufferException e) {
+          throw e;
+        } catch (IOException e) {
+          throw new RuntimeException(
+              "ByteString based ByteBuffer should not throw IOException.", e);
+        }
+      }
+    },
+    READONLY_ARRAY_BYTE_BUFFER_DECODER() {
+      @Override
+      public TestMessagesProto3.TestAllTypes parse(ByteString bytes)
+          throws InvalidProtocolBufferException {
+        try {
+          return TestMessagesProto3.TestAllTypes.parseFrom(
+              CodedInputStream.newInstance(bytes.asReadOnlyByteBuffer()));
+        } catch (InvalidProtocolBufferException e) {
+          throw e;
+        } catch (IOException e) {
+          throw new RuntimeException(
+              "ByteString based ByteBuffer should not throw IOException.", e);
+        }
+      }
+    },
+    DIRECT_BYTE_BUFFER_DECODER() {
+      @Override
+      public TestMessagesProto3.TestAllTypes parse(ByteString bytes)
+          throws InvalidProtocolBufferException {
+        ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.size());
+        bytes.copyTo(buffer);
+        buffer.flip();
+        try {
+          return TestMessagesProto3.TestAllTypes.parseFrom(CodedInputStream.newInstance(buffer));
+        } catch (InvalidProtocolBufferException e) {
+          throw e;
+        } catch (IOException e) {
+          throw new RuntimeException(
+              "ByteString based ByteBuffer should not throw IOException.", e);
+        }
+      }
+    },
+    READONLY_DIRECT_BYTE_BUFFER_DECODER() {
+      @Override
+      public TestMessagesProto3.TestAllTypes parse(ByteString bytes)
+          throws InvalidProtocolBufferException {
+        ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.size());
+        bytes.copyTo(buffer);
+        buffer.flip();
+        try {
+          return TestMessagesProto3.TestAllTypes.parseFrom(
+              CodedInputStream.newInstance(buffer.asReadOnlyBuffer()));
+        } catch (InvalidProtocolBufferException e) {
+          throw e;
+        } catch (IOException e) {
+          throw new RuntimeException(
+              "ByteString based ByteBuffer should not throw IOException.", e);
+        }
+      }
+    },
+    INPUT_STREAM_DECODER() {
+      @Override
+      public TestMessagesProto3.TestAllTypes parse(ByteString bytes)
+          throws InvalidProtocolBufferException {
+        try {
+          return TestMessagesProto3.TestAllTypes.parseFrom(bytes.newInput());
+        } catch (InvalidProtocolBufferException e) {
+          throw e;
+        } catch (IOException e) {
+          throw new RuntimeException(
+              "ByteString based InputStream should not throw IOException.", e);
+        }
+      }
+    };
+
+    public abstract TestMessagesProto3.TestAllTypes parse(ByteString bytes)
+        throws InvalidProtocolBufferException;
+  }
+
+  private TestMessagesProto3.TestAllTypes parseBinary(ByteString bytes)
+      throws InvalidProtocolBufferException {
+    TestMessagesProto3.TestAllTypes[] messages =
+        new TestMessagesProto3.TestAllTypes[BinaryDecoder.values().length];
+    InvalidProtocolBufferException[] exceptions =
+        new InvalidProtocolBufferException[BinaryDecoder.values().length];
+
+    boolean hasMessage = false;
+    boolean hasException = false;
+    for (int i = 0; i < BinaryDecoder.values().length; ++i) {
+      try {
+        messages[i] = BinaryDecoder.values()[i].parse(bytes);
+        hasMessage = true;
+      } catch (InvalidProtocolBufferException e) {
+        exceptions[i] = e;
+        hasException = true;
+      }
+    }
+
+    if (hasMessage && hasException) {
+      StringBuilder sb =
+          new StringBuilder("Binary decoders disagreed on whether the payload was valid.\n");
+      for (int i = 0; i < BinaryDecoder.values().length; ++i) {
+        sb.append(BinaryDecoder.values()[i].name());
+        if (messages[i] != null) {
+          sb.append(" accepted the payload.\n");
+        } else {
+          sb.append(" rejected the payload.\n");
+        }
+      }
+      throw new RuntimeException(sb.toString());
+    }
+
+    if (hasException) {
+      // We do not check if exceptions are equal. Different implementations may return different
+      // exception messages. Throw an arbitrary one out instead.
+      throw exceptions[0];
+    }
+
+    // Fast path comparing all the messages with the first message, assuming equality being
+    // symmetric and transitive.
+    boolean allEqual = true;
+    for (int i = 1; i < messages.length; ++i) {
+      if (!messages[0].equals(messages[i])) {
+        allEqual = false;
+        break;
+      }
+    }
+
+    // Slow path: compare and find out all unequal pairs.
+    if (!allEqual) {
+      StringBuilder sb = new StringBuilder();
+      for (int i = 0; i < messages.length - 1; ++i) {
+        for (int j = i + 1; j < messages.length; ++j) {
+          if (!messages[i].equals(messages[j])) {
+            sb.append(BinaryDecoder.values()[i].name())
+                .append(" and ")
+                .append(BinaryDecoder.values()[j].name())
+                .append(" parsed the payload differently.\n");
+          }
+        }
+      }
+      throw new RuntimeException(sb.toString());
+    }
+
+    return messages[0];
+  }
+
   private Conformance.ConformanceResponse doTest(Conformance.ConformanceRequest request) {
-    Conformance.TestAllTypes testMessage;
+    TestMessagesProto3.TestAllTypes testMessage;
 
     switch (request.getPayloadCase()) {
       case PROTOBUF_PAYLOAD: {
         try {
-          testMessage = Conformance.TestAllTypes.parseFrom(request.getProtobufPayload());
+          testMessage = parseBinary(request.getProtobufPayload());
         } catch (InvalidProtocolBufferException e) {
           return Conformance.ConformanceResponse.newBuilder().setParseError(e.getMessage()).build();
         }
@@ -61,7 +234,7 @@ class ConformanceJava {
       }
       case JSON_PAYLOAD: {
         try {
-          Conformance.TestAllTypes.Builder builder = Conformance.TestAllTypes.newBuilder();
+          TestMessagesProto3.TestAllTypes.Builder builder = TestMessagesProto3.TestAllTypes.newBuilder();
           JsonFormat.parser().usingTypeRegistry(typeRegistry)
               .merge(request.getJsonPayload(), builder);
           testMessage = builder.build();
@@ -127,7 +300,7 @@ class ConformanceJava {
 
   public void run() throws Exception {
     typeRegistry = TypeRegistry.newBuilder().add(
-        Conformance.TestAllTypes.getDescriptor()).build();
+        TestMessagesProto3.TestAllTypes.getDescriptor()).build();
     while (doTestIo()) {
       this.testCount++;
     }