third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/java/compatibility_tests/v2.5.0/tests/src/main/java/com/google/protobuf/test/LiteralByteStringTest.java

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
+// http://code.google.com/p/protobuf/
 //
 // 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.
 
-package com.google.protobuf;
+package com.google.protobuf.test;
+import com.google.protobuf.*;
 
 import junit.framework.TestCase;
 
-import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
-import java.io.EOFException;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
 import java.io.OutputStream;
 import java.io.UnsupportedEncodingException;
 import java.nio.ByteBuffer;
 import java.util.Arrays;
 import java.util.List;
 import java.util.NoSuchElementException;
 
 /**
- * Test {@code LiteralByteString} by setting up a reference string in {@link #setUp()}.
- * This class is designed to be extended for testing extensions of {@code LiteralByteString}
- * such as {@code BoundedByteString}, see {@link BoundedByteStringTest}.
+ * Test {@link LiteralByteString} by setting up a reference string in {@link #setUp()}.
+ * This class is designed to be extended for testing extensions of {@link LiteralByteString}
+ * such as {@link BoundedByteString}, see {@link BoundedByteStringTest}.
  *
  * @author carlanton@google.com (Carl Haverl)
  */
 public class LiteralByteStringTest extends TestCase {
   protected static final String UTF_8 = "UTF-8";
 
   protected String classUnderTest;
   protected byte[] referenceBytes;
   protected ByteString stringUnderTest;
   protected int expectedHashCode;
 
   @Override
   protected void setUp() throws Exception {
     classUnderTest = "LiteralByteString";
     referenceBytes = ByteStringTest.getTestBytes(1234, 11337766L);
     stringUnderTest = ByteString.copyFrom(referenceBytes);
     expectedHashCode = 331161852;
   }
 
-  public void testExpectedType() {
-    String actualClassName = getActualClassName(stringUnderTest);
-    assertEquals(classUnderTest + " should match type exactly", classUnderTest, actualClassName);
-  }
-
   protected String getActualClassName(Object object) {
-    return object.getClass().getSimpleName();
+    String actualClassName = object.getClass().getName();
+    actualClassName = actualClassName.substring(actualClassName.lastIndexOf('.') + 1);
+    return actualClassName;
   }
 
   public void testByteAt() {
     boolean stillEqual = true;
     for (int i = 0; stillEqual && i < referenceBytes.length; ++i) {
       stillEqual = (referenceBytes[i] == stringUnderTest.byteAt(i));
     }
     assertTrue(classUnderTest + " must capture the right bytes", stillEqual);
   }
 
@@ skipping 23 matching lines @@
     }
     assertTrue(classUnderTest + " must capture the right bytes as Bytes", stillEqual);
     assertEquals(classUnderTest + " iterable character count", referenceBytes.length, j);
   }
 
   public void testSize() {
     assertEquals(classUnderTest + " must have the expected size", referenceBytes.length,
         stringUnderTest.size());
   }
 
-  public void testGetTreeDepth() {
-    assertEquals(classUnderTest + " must have depth 0", 0, stringUnderTest.getTreeDepth());
-  }
-
-  public void testIsBalanced() {
-    assertTrue(classUnderTest + " is technically balanced", stringUnderTest.isBalanced());
-  }
-
   public void testCopyTo_ByteArrayOffsetLength() {
     int destinationOffset = 50;
     int length = 100;
     byte[] destination = new byte[destinationOffset + length];
     int sourceOffset = 213;
     stringUnderTest.copyTo(destination, sourceOffset, destinationOffset, length);
     boolean stillEqual = true;
     for (int i = 0; stillEqual && i < length; ++i) {
       stillEqual = referenceBytes[i + sourceOffset] == destination[i + destinationOffset];
     }
@@ skipping 61 matching lines @@
     }
   }
 
   public void testCopyTo_ByteBuffer() {
     ByteBuffer myBuffer = ByteBuffer.allocate(referenceBytes.length);
     stringUnderTest.copyTo(myBuffer);
     assertTrue(classUnderTest + ".copyTo(ByteBuffer) must give back the same bytes",
         Arrays.equals(referenceBytes, myBuffer.array()));
   }
 
-  public void testMarkSupported() {
-    InputStream stream = stringUnderTest.newInput();
-    assertTrue(classUnderTest + ".newInput() must support marking", stream.markSupported());
-  }
-
-  public void testMarkAndReset() throws IOException {
-    int fraction = stringUnderTest.size() / 3;
-
-    InputStream stream = stringUnderTest.newInput();
-    stream.mark(stringUnderTest.size()); // First, mark() the end.
-
-    skipFully(stream, fraction); // Skip a large fraction, but not all.
-    int available = stream.available();
-    assertTrue(
-        classUnderTest + ": after skipping to the 'middle', half the bytes are available",
-        (stringUnderTest.size() - fraction) == available);
-    stream.reset();
-
-    skipFully(stream, stringUnderTest.size()); // Skip to the end.
-    available = stream.available();
-    assertTrue(
-        classUnderTest + ": after skipping to the end, no more bytes are available",
-        0 == available);
-  }
-
-  /**
-   * Discards {@code n} bytes of data from the input stream. This method
-   * will block until the full amount has been skipped. Does not close the
-   * stream.
-   * <p>Copied from com.google.common.io.ByteStreams to avoid adding dependency.
-   *
-   * @param in the input stream to read from
-   * @param n the number of bytes to skip
-   * @throws EOFException if this stream reaches the end before skipping all
-   *     the bytes
-   * @throws IOException if an I/O error occurs, or the stream does not
-   *     support skipping
-   */
-  static void skipFully(InputStream in, long n) throws IOException {
-    long toSkip = n;
-    while (n > 0) {
-      long amt = in.skip(n);
-      if (amt == 0) {
-        // Force a blocking read to avoid infinite loop
-        if (in.read() == -1) {
-          long skipped = toSkip - n;
-          throw new EOFException("reached end of stream after skipping "
-              + skipped + " bytes; " + toSkip + " bytes expected");
-        }
-        n--;
-      } else {
-        n -= amt;
-      }
-    }
-  }
-
   public void testAsReadOnlyByteBuffer() {
     ByteBuffer byteBuffer = stringUnderTest.asReadOnlyByteBuffer();
     byte[] roundTripBytes = new byte[referenceBytes.length];
     assertTrue(byteBuffer.remaining() == referenceBytes.length);
     assertTrue(byteBuffer.isReadOnly());
     byteBuffer.get(roundTripBytes);
     assertTrue(classUnderTest + ".asReadOnlyByteBuffer() must give back the same bytes",
         Arrays.equals(referenceBytes, roundTripBytes));
   }
 
@@ skipping 19 matching lines @@
         Arrays.equals(referenceBytes, roundTripBytes));
   }
 
   public void testWriteTo() throws IOException {
     ByteArrayOutputStream bos = new ByteArrayOutputStream();
     stringUnderTest.writeTo(bos);
     byte[] roundTripBytes = bos.toByteArray();
     assertTrue(classUnderTest + ".writeTo() must give back the same bytes",
         Arrays.equals(referenceBytes, roundTripBytes));
   }
-
-  public void testWriteToShouldNotExposeInternalBufferToOutputStream() throws IOException {
+  
+  public void testWriteTo_mutating() throws IOException {
     OutputStream os = new OutputStream() {
       @Override
       public void write(byte[] b, int off, int len) {
-        Arrays.fill(b, off, off + len, (byte) 0);
+        for (int x = 0; x < len; ++x) {
+          b[off + x] = (byte) 0;
+        }
       }
 
       @Override
       public void write(int b) {
-        throw new UnsupportedOperationException();
+        // Purposefully left blank.
       }
     };
 
     stringUnderTest.writeTo(os);
+    byte[] newBytes = stringUnderTest.toByteArray();
     assertTrue(classUnderTest + ".writeTo() must not grant access to underlying array",
-        Arrays.equals(referenceBytes, stringUnderTest.toByteArray()));
-  }
-
-  public void testWriteToInternalShouldExposeInternalBufferToOutputStream() throws IOException {
-    OutputStream os = new OutputStream() {
-      @Override
-      public void write(byte[] b, int off, int len) {
-        Arrays.fill(b, off, off + len, (byte) 0);
-      }
-
-      @Override
-      public void write(int b) {
-        throw new UnsupportedOperationException();
-      }
-    };
-
-    stringUnderTest.writeToInternal(os, 0, stringUnderTest.size());
-    byte[] allZeros = new byte[stringUnderTest.size()];
-    assertTrue(classUnderTest + ".writeToInternal() must grant access to underlying array",
-        Arrays.equals(allZeros, stringUnderTest.toByteArray()));
-  }
-
-  public void testWriteToShouldExposeInternalBufferToByteOutput() throws IOException {
-    ByteOutput out = new ByteOutput() {
-      @Override
-      public void write(byte value) throws IOException {
-        throw new UnsupportedOperationException();
-      }
-
-      @Override
-      public void write(byte[] value, int offset, int length) throws IOException {
-        throw new UnsupportedOperationException();
-      }
-
-      @Override
-      public void writeLazy(byte[] value, int offset, int length) throws IOException {
-        Arrays.fill(value, offset, offset + length, (byte) 0);
-      }
-
-      @Override
-      public void write(ByteBuffer value) throws IOException {
-        throw new UnsupportedOperationException();
-      }
-
-      @Override
-      public void writeLazy(ByteBuffer value) throws IOException {
-        throw new UnsupportedOperationException();
-      }
-    };
-
-    stringUnderTest.writeTo(out);
-    byte[] allZeros = new byte[stringUnderTest.size()];
-    assertTrue(classUnderTest + ".writeToInternal() must grant access to underlying array",
-        Arrays.equals(allZeros, stringUnderTest.toByteArray()));
+        Arrays.equals(referenceBytes, newBytes));
   }
 
   public void testNewOutput() throws IOException {
     ByteArrayOutputStream bos = new ByteArrayOutputStream();
     ByteString.Output output = ByteString.newOutput();
     stringUnderTest.writeTo(output);
     assertEquals("Output Size returns correct result",
         output.size(), stringUnderTest.size());
     output.writeTo(bos);
     assertTrue("Output.writeTo() must give back the same bytes",
         Arrays.equals(referenceBytes, bos.toByteArray()));
 
     // write the output stream to itself! This should cause it to double
     output.writeTo(output);
     assertEquals("Writing an output stream to itself is successful",
         stringUnderTest.concat(stringUnderTest), output.toByteString());
 
     output.reset();
     assertEquals("Output.reset() resets the output", 0, output.size());
     assertEquals("Output.reset() resets the output",
         ByteString.EMPTY, output.toByteString());
-  }
-
-  public void testToString() throws UnsupportedEncodingException {
-    String testString = "I love unicode \u1234\u5678 characters";
-    ByteString unicode = ByteString.wrap(testString.getBytes(Internal.UTF_8));
-    String roundTripString = unicode.toString(UTF_8);
-    assertEquals(classUnderTest + " unicode must match", testString, roundTripString);
-  }
-
-  public void testCharsetToString() {
-    String testString = "I love unicode \u1234\u5678 characters";
-    ByteString unicode = ByteString.wrap(testString.getBytes(Internal.UTF_8));
-    String roundTripString = unicode.toString(Internal.UTF_8);
-    assertEquals(classUnderTest + " unicode must match", testString, roundTripString);
-  }
-
-  public void testToString_returnsCanonicalEmptyString() {
-    assertSame(classUnderTest + " must be the same string references",
-        ByteString.EMPTY.toString(Internal.UTF_8),
-        ByteString.wrap(new byte[]{}).toString(Internal.UTF_8));
-  }
-
-  public void testToString_raisesException() {
-    try {
-      ByteString.EMPTY.toString("invalid");
-      fail("Should have thrown an exception.");
-    } catch (UnsupportedEncodingException expected) {
-      // This is success
-    }
-
-    try {
-      ByteString.wrap(referenceBytes).toString("invalid");
-      fail("Should have thrown an exception.");
-    } catch (UnsupportedEncodingException expected) {
-      // This is success
-    }
-  }
-
-  public void testEquals() {
-    assertEquals(classUnderTest + " must not equal null", false, stringUnderTest.equals(null));
-    assertEquals(classUnderTest + " must equal self", stringUnderTest, stringUnderTest);
-    assertFalse(classUnderTest + " must not equal the empty string",
-        stringUnderTest.equals(ByteString.EMPTY));
-    assertEquals(classUnderTest + " empty strings must be equal",
-        ByteString.wrap(new byte[]{}), stringUnderTest.substring(55, 55));
-    assertEquals(classUnderTest + " must equal another string with the same value",
-        stringUnderTest, ByteString.wrap(referenceBytes));
-
-    byte[] mungedBytes = new byte[referenceBytes.length];
-    System.arraycopy(referenceBytes, 0, mungedBytes, 0, referenceBytes.length);
-    mungedBytes[mungedBytes.length - 5] = (byte) (mungedBytes[mungedBytes.length - 5] ^ 0xFF);
-    assertFalse(classUnderTest + " must not equal every string with the same length",
-        stringUnderTest.equals(ByteString.wrap(mungedBytes)));
+    
   }
 
   public void testHashCode() {
     int hash = stringUnderTest.hashCode();
     assertEquals(classUnderTest + " must have expected hashCode", expectedHashCode, hash);
   }
 
-  public void testPeekCachedHashCode() {
-    assertEquals(classUnderTest + ".peekCachedHashCode() should return zero at first", 0,
-        stringUnderTest.peekCachedHashCode());
-    stringUnderTest.hashCode();
-    assertEquals(classUnderTest + ".peekCachedHashCode should return zero at first",
-        expectedHashCode, stringUnderTest.peekCachedHashCode());
-  }
-
-  public void testPartialHash() {
-    // partialHash() is more strenuously tested elsewhere by testing hashes of substrings.
-    // This test would fail if the expected hash were 1.  It's not.
-    int hash = stringUnderTest.partialHash(stringUnderTest.size(), 0, stringUnderTest.size());
-    assertEquals(classUnderTest + ".partialHash() must yield expected hashCode",
-        expectedHashCode, hash);
-  }
-
   public void testNewInput() throws IOException {
     InputStream input = stringUnderTest.newInput();
     assertEquals("InputStream.available() returns correct value",
         stringUnderTest.size(), input.available());
     boolean stillEqual = true;
     for (byte referenceByte : referenceBytes) {
       int expectedInt = (referenceByte & 0xFF);
       stillEqual = (expectedInt == input.read());
     }
     assertEquals("InputStream.available() returns correct value",
@@ skipping 39 matching lines @@
   /**
    * Make sure we keep things simple when concatenating with empty. See also
    * {@link ByteStringTest#testConcat_empty()}.
    */
   public void testConcat_empty() {
     assertSame(classUnderTest + " concatenated with empty must give " + classUnderTest,
         stringUnderTest.concat(ByteString.EMPTY), stringUnderTest);
     assertSame("empty concatenated with " + classUnderTest + " must give " + classUnderTest,
         ByteString.EMPTY.concat(stringUnderTest), stringUnderTest);
   }
-
-  public void testJavaSerialization() throws Exception {
-    ByteArrayOutputStream out = new ByteArrayOutputStream();
-    ObjectOutputStream oos = new ObjectOutputStream(out);
-    oos.writeObject(stringUnderTest);
-    oos.close();
-    byte[] pickled = out.toByteArray();
-    InputStream in = new ByteArrayInputStream(pickled);
-    ObjectInputStream ois = new ObjectInputStream(in);
-    Object o = ois.readObject();
-    assertTrue("Didn't get a ByteString back", o instanceof ByteString);
-    assertEquals("Should get an equal ByteString back", stringUnderTest, o);
-  }
 }