third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/java/core/src/test/java/com/google/protobuf/CodedOutputStreamTest.java

 // 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 17 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 package com.google.protobuf;
 
 import com.google.protobuf.CodedOutputStream.OutOfSpaceException;
 import protobuf_unittest.UnittestProto.SparseEnumMessage;
 import protobuf_unittest.UnittestProto.TestAllTypes;
 import protobuf_unittest.UnittestProto.TestPackedTypes;
 import protobuf_unittest.UnittestProto.TestSparseEnum;
-
-import junit.framework.TestCase;
-
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import junit.framework.TestCase;
 
 /**
  * Unit test for {@link CodedOutputStream}.
  *
  * @author kenton@google.com Kenton Varda
  */
 public class CodedOutputStreamTest extends TestCase {
   private interface Coder {
     CodedOutputStream stream();
 
@@ skipping 87 matching lines @@
     @Override
     public OutputType getOutputType() {
       return OutputType.NIO_HEAP;
     }
   }
 
   private static final class NioDirectCoder implements Coder {
     private final int initialPosition;
     private final CodedOutputStream stream;
     private final ByteBuffer buffer;
+    private final boolean unsafe;
 
-    NioDirectCoder(int size) {
-      this(size, 0);
+    NioDirectCoder(int size, boolean unsafe) {
+      this(size, 0, unsafe);
     }
 
-    NioDirectCoder(int size, int initialPosition) {
+    NioDirectCoder(int size, int initialPosition, boolean unsafe) {
+      this.unsafe = unsafe;
       this.initialPosition = initialPosition;
       buffer = ByteBuffer.allocateDirect(size);
       buffer.position(initialPosition);
-      stream = CodedOutputStream.newInstance(buffer);
+      stream =
+          unsafe
+              ? CodedOutputStream.newUnsafeInstance(buffer)
+              : CodedOutputStream.newSafeInstance(buffer);
     }
 
     @Override
     public CodedOutputStream stream() {
       return stream;
     }
 
     @Override
     public byte[] toByteArray() {
       ByteBuffer dup = buffer.duplicate();
       dup.position(initialPosition);
       dup.limit(buffer.position());
 
       byte[] bytes = new byte[dup.remaining()];
       dup.get(bytes);
       return bytes;
     }
 
     @Override
     public OutputType getOutputType() {
-      return OutputType.NIO_DIRECT;
+      return unsafe ? OutputType.NIO_DIRECT_SAFE : OutputType.NIO_DIRECT_UNSAFE;
     }
   }
 
   private enum OutputType {
     ARRAY() {
       @Override
       Coder newCoder(int size) {
         return new ArrayCoder(size);
       }
     },
     NIO_HEAP() {
       @Override
       Coder newCoder(int size) {
         return new NioHeapCoder(size);
       }
     },
-    NIO_DIRECT() {
+    NIO_DIRECT_SAFE() {
       @Override
       Coder newCoder(int size) {
-        return new NioDirectCoder(size);
+        return new NioDirectCoder(size, false);
+      }
+    },
+    NIO_DIRECT_UNSAFE() {
+      @Override
+      Coder newCoder(int size) {
+        return new NioDirectCoder(size, true);
       }
     },
     STREAM() {
       @Override
       Coder newCoder(int size) {
         return new OutputStreamCoder(size);
       }
     };
 
     abstract Coder newCoder(int size);
@@ skipping 167 matching lines @@
     assertEquals(value.length * 1024, coder.stream().getTotalBytesWritten());
 
     // Now write an encoded string.
     String string =
         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
     // Ensure we take the slower fast path.
     assertTrue(CodedOutputStream.computeUInt32SizeNoTag(string.length())
         != CodedOutputStream.computeUInt32SizeNoTag(string.length() * Utf8.MAX_BYTES_PER_CHAR));
 
     coder.stream().writeStringNoTag(string);
+    coder.stream().flush();
     int stringSize = CodedOutputStream.computeStringSizeNoTag(string);
 
     // Verify that the total bytes written is correct
     assertEquals((value.length * 1024) + stringSize, coder.stream().getTotalBytesWritten());
   }
 
   // TODO(dweis): Write a comprehensive test suite for CodedOutputStream that covers more than just
   //    this case.
   public void testWriteStringNoTag_fastpath() throws Exception {
     int bufferSize = 153;
@@ skipping 69 matching lines @@
     byte[] result = outputStream.toByteArray();
     assertEquals(6, result.length);
     for (int i = 0; i < 5; i++) {
       assertEquals(value[i], result[i]);
     }
     assertEquals(value[2], result[5]);
   }
 
   public void testWriteByteArrayWithOffsets() throws Exception {
     byte[] fullArray = bytes(0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88);
-    byte[] destination = new byte[4];
-    CodedOutputStream codedStream = CodedOutputStream.newInstance(destination);
-    codedStream.writeByteArrayNoTag(fullArray, 2, 2);
-    assertEqualBytes(OutputType.ARRAY, bytes(0x02, 0x33, 0x44, 0x00), destination);
-    assertEquals(3, codedStream.getTotalBytesWritten());
+    for (OutputType type : new OutputType[] {OutputType.ARRAY}) {
+      Coder coder = type.newCoder(4);
+      coder.stream().writeByteArrayNoTag(fullArray, 2, 2);
+      assertEqualBytes(type, bytes(0x02, 0x33, 0x44), coder.toByteArray());
+      assertEquals(3, coder.stream().getTotalBytesWritten());
+    }
   }
 
   public void testSerializeUtf8_MultipleSmallWrites() throws Exception {
     final String source = "abcdefghijklmnopqrstuvwxyz";
 
     // Generate the expected output if the source string is written 2 bytes at a time.
     ByteArrayOutputStream expectedBytesStream = new ByteArrayOutputStream();
     for (int pos = 0; pos < source.length(); pos += 2) {
       String substr = source.substring(pos, pos + 2);
       expectedBytesStream.write(2);
@@ skipping 58 matching lines @@
   /** Regression test for https://github.com/google/protobuf/issues/292 */
   public void testCorrectExceptionThrowWhenEncodingStringsWithoutEnoughSpace() throws Exception {
     String testCase = "Foooooooo";
     assertEquals(
         CodedOutputStream.computeUInt32SizeNoTag(testCase.length()),
         CodedOutputStream.computeUInt32SizeNoTag(testCase.length() * 3));
     assertEquals(11, CodedOutputStream.computeStringSize(1, testCase));
     // Tag is one byte, varint describing string length is 1 byte, string length is 9 bytes.
     // An array of size 1 will cause a failure when trying to write the varint.
     for (OutputType outputType :
-        new OutputType[] {OutputType.ARRAY, OutputType.NIO_HEAP, OutputType.NIO_DIRECT}) {
+        new OutputType[] {
+          OutputType.ARRAY,
+          OutputType.NIO_HEAP,
+          OutputType.NIO_DIRECT_SAFE,
+          OutputType.NIO_DIRECT_UNSAFE
+        }) {
       for (int i = 0; i < 11; i++) {
         Coder coder = outputType.newCoder(i);
         try {
           coder.stream().writeString(1, testCase);
           fail("Should have thrown an out of space exception");
         } catch (CodedOutputStream.OutOfSpaceException expected) {
         }
       }
     }
   }
@@ skipping 17 matching lines @@
       for (int i : lengths) {
         testEncodingOfString(outputType, 'q', i); // 1 byte per char
         testEncodingOfString(outputType, '\u07FF', i); // 2 bytes per char
         testEncodingOfString(outputType, '\u0981', i); // 3 bytes per char
       }
     }
   }
 
   public void testNioEncodersWithInitialOffsets() throws Exception {
     String value = "abc";
-    for (Coder coder : new Coder[] {new NioHeapCoder(10, 2), new NioDirectCoder(10, 2)}) {
+    for (Coder coder :
+        new Coder[] {
+          new NioHeapCoder(10, 2), new NioDirectCoder(10, 2, false), new NioDirectCoder(10, 2, true)
+        }) {
       coder.stream().writeStringNoTag(value);
       coder.stream().flush();
-      assertEqualBytes(coder.getOutputType(), new byte[]{3, 'a', 'b', 'c'}, coder.toByteArray());
+      assertEqualBytes(coder.getOutputType(), new byte[] {3, 'a', 'b', 'c'}, coder.toByteArray());
     }
   }
 
   /**
    * Parses the given bytes using writeRawLittleEndian32() and checks
    * that the result matches the given value.
    */
   private static void assertWriteLittleEndian32(byte[] data, int value) throws Exception {
     for (OutputType outputType : OutputType.values()) {
       Coder coder = outputType.newCoder(data.length);
@@ skipping 151 matching lines @@
       coder.stream().writeUInt32NoTag((int) value);
       coder.stream().flush();
       byte[] bytes = coder.toByteArray();
       assertEquals(
           outputType.name(), bytes.length, CodedOutputStream.computeUInt32SizeNoTag((int) value));
       CodedInputStream input = CodedInputStream.newInstance(new ByteArrayInputStream(bytes));
       assertEquals(outputType.name(), value, input.readRawVarint32());
     }
   }
 }