Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(89)

Unified Diff: third_party/protobuf/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java

Issue 2600753002: Reverts third_party/protobuf: Update to HEAD (f52e188fe4) (Closed)
Patch Set: Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: third_party/protobuf/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java
diff --git a/third_party/protobuf/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java b/third_party/protobuf/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java
index e440c7db3dcba30a2ce61c12115d2450e3a11757..ca940cedb24535ede3794c36b17cd463f40f1a51 100644
--- a/third_party/protobuf/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java
+++ b/third_party/protobuf/java/core/src/test/java/com/google/protobuf/CodedInputStreamTest.java
@@ -35,13 +35,15 @@ import protobuf_unittest.UnittestProto.Int32Message;
import protobuf_unittest.UnittestProto.Int64Message;
import protobuf_unittest.UnittestProto.TestAllTypes;
import protobuf_unittest.UnittestProto.TestRecursiveMessage;
+
+import junit.framework.TestCase;
+
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
-import junit.framework.TestCase;
/**
* Unit test for {@link CodedInputStream}.
@@ -49,45 +51,10 @@ import junit.framework.TestCase;
* @author kenton@google.com Kenton Varda
*/
public class CodedInputStreamTest extends TestCase {
- private enum InputType {
- ARRAY {
- @Override
- CodedInputStream newDecoder(byte[] data, int blockSize) {
- return CodedInputStream.newInstance(data);
- }
- },
- NIO_HEAP {
- @Override
- CodedInputStream newDecoder(byte[] data, int blockSize) {
- return CodedInputStream.newInstance(ByteBuffer.wrap(data));
- }
- },
- NIO_DIRECT {
- @Override
- CodedInputStream newDecoder(byte[] data, int blockSize) {
- ByteBuffer buffer = ByteBuffer.allocateDirect(data.length);
- buffer.put(data);
- buffer.flip();
- return CodedInputStream.newInstance(buffer);
- }
- },
- STREAM {
- @Override
- CodedInputStream newDecoder(byte[] data, int blockSize) {
- return CodedInputStream.newInstance(new SmallBlockInputStream(data, blockSize));
- }
- };
-
- CodedInputStream newDecoder(byte[] data) {
- return newDecoder(data, data.length);
- }
-
- abstract CodedInputStream newDecoder(byte[] data, int blockSize);
- }
-
/**
- * Helper to construct a byte array from a bunch of bytes. The inputs are actually ints so that I
- * can use hex notation and not get stupid errors about precision.
+ * Helper to construct a byte array from a bunch of bytes. The inputs are
+ * actually ints so that I can use hex notation and not get stupid errors
+ * about precision.
*/
private byte[] bytes(int... bytesAsInts) {
byte[] bytes = new byte[bytesAsInts.length];
@@ -98,14 +65,19 @@ public class CodedInputStreamTest extends TestCase {
}
/**
- * An InputStream which limits the number of bytes it reads at a time. We use this to make sure
- * that CodedInputStream doesn't screw up when reading in small blocks.
+ * An InputStream which limits the number of bytes it reads at a time.
+ * We use this to make sure that CodedInputStream doesn't screw up when
+ * reading in small blocks.
*/
private static final class SmallBlockInputStream extends FilterInputStream {
private final int blockSize;
public SmallBlockInputStream(byte[] data, int blockSize) {
- super(new ByteArrayInputStream(data));
+ this(new ByteArrayInputStream(data), blockSize);
+ }
+
+ public SmallBlockInputStream(InputStream in, int blockSize) {
+ super(in);
this.blockSize = blockSize;
}
@@ -120,36 +92,54 @@ public class CodedInputStreamTest extends TestCase {
}
}
- private void assertDataConsumed(String msg, byte[] data, CodedInputStream input)
+ private void assertDataConsumed(byte[] data, CodedInputStream input)
throws IOException {
- assertEquals(msg, data.length, input.getTotalBytesRead());
- assertTrue(msg, input.isAtEnd());
+ assertEquals(data.length, input.getTotalBytesRead());
+ assertTrue(input.isAtEnd());
}
/**
- * Parses the given bytes using readRawVarint32() and readRawVarint64() and checks that the result
- * matches the given value.
+ * Parses the given bytes using readRawVarint32() and readRawVarint64() and
+ * checks that the result matches the given value.
*/
private void assertReadVarint(byte[] data, long value) throws Exception {
- for (InputType inputType : InputType.values()) {
- // Try different block sizes.
- for (int blockSize = 1; blockSize <= 16; blockSize *= 2) {
- CodedInputStream input = inputType.newDecoder(data, blockSize);
- assertEquals(inputType.name(), (int) value, input.readRawVarint32());
- assertDataConsumed(inputType.name(), data, input);
-
- input = inputType.newDecoder(data, blockSize);
- assertEquals(inputType.name(), value, input.readRawVarint64());
- assertDataConsumed(inputType.name(), data, input);
-
- input = inputType.newDecoder(data, blockSize);
- assertEquals(inputType.name(), value, input.readRawVarint64SlowPath());
- assertDataConsumed(inputType.name(), data, input);
-
- input = inputType.newDecoder(data, blockSize);
- assertTrue(inputType.name(), input.skipField(WireFormat.WIRETYPE_VARINT));
- assertDataConsumed(inputType.name(), data, input);
- }
+ CodedInputStream input = CodedInputStream.newInstance(data);
+ assertEquals((int) value, input.readRawVarint32());
+ assertDataConsumed(data, input);
+
+ input = CodedInputStream.newInstance(data);
+ assertEquals(value, input.readRawVarint64());
+ assertDataConsumed(data, input);
+
+ input = CodedInputStream.newInstance(data);
+ assertEquals(value, input.readRawVarint64SlowPath());
+ assertDataConsumed(data, input);
+
+ input = CodedInputStream.newInstance(data);
+ assertTrue(input.skipField(WireFormat.WIRETYPE_VARINT));
+ assertDataConsumed(data, input);
+
+ // Try different block sizes.
+ for (int blockSize = 1; blockSize <= 16; blockSize *= 2) {
+ input = CodedInputStream.newInstance(
+ new SmallBlockInputStream(data, blockSize));
+ assertEquals((int) value, input.readRawVarint32());
+ assertDataConsumed(data, input);
+
+ input = CodedInputStream.newInstance(
+ new SmallBlockInputStream(data, blockSize));
+ assertEquals(value, input.readRawVarint64());
+ assertDataConsumed(data, input);
+
+ input = CodedInputStream.newInstance(
+ new SmallBlockInputStream(data, blockSize));
+ assertEquals(value, input.readRawVarint64SlowPath());
+ assertDataConsumed(data, input);
+
+ input = CodedInputStream.newInstance(
+ new SmallBlockInputStream(data, blockSize));
+ assertTrue(input.skipField(WireFormat.WIRETYPE_VARINT));
+ assertDataConsumed(data, input);
}
// Try reading direct from an InputStream. We want to verify that it
@@ -163,26 +153,35 @@ public class CodedInputStreamTest extends TestCase {
}
/**
- * Parses the given bytes using readRawVarint32() and readRawVarint64() and expects them to fail
- * with an InvalidProtocolBufferException whose description matches the given one.
+ * Parses the given bytes using readRawVarint32() and readRawVarint64() and
+ * expects them to fail with an InvalidProtocolBufferException whose
+ * description matches the given one.
*/
- private void assertReadVarintFailure(InvalidProtocolBufferException expected, byte[] data)
+ private void assertReadVarintFailure(
+ InvalidProtocolBufferException expected, byte[] data)
throws Exception {
- for (InputType inputType : InputType.values()) {
- try {
- CodedInputStream input = inputType.newDecoder(data);
- input.readRawVarint32();
- fail(inputType.name() + ": Should have thrown an exception.");
- } catch (InvalidProtocolBufferException e) {
- assertEquals(inputType.name(), expected.getMessage(), e.getMessage());
- }
- try {
- CodedInputStream input = inputType.newDecoder(data);
- input.readRawVarint64();
- fail(inputType.name() + ": Should have thrown an exception.");
- } catch (InvalidProtocolBufferException e) {
- assertEquals(inputType.name(), expected.getMessage(), e.getMessage());
- }
+ CodedInputStream input = CodedInputStream.newInstance(data);
+ try {
+ input.readRawVarint32();
+ fail("Should have thrown an exception.");
+ } catch (InvalidProtocolBufferException e) {
+ assertEquals(expected.getMessage(), e.getMessage());
+ }
+
+ input = CodedInputStream.newInstance(data);
+ try {
+ input.readRawVarint64();
+ fail("Should have thrown an exception.");
+ } catch (InvalidProtocolBufferException e) {
+ assertEquals(expected.getMessage(), e.getMessage());
+ }
+
+ input = CodedInputStream.newInstance(data);
+ try {
+ input.readRawVarint64SlowPath();
+ fail("Should have thrown an exception.");
+ } catch (InvalidProtocolBufferException e) {
+ assertEquals(expected.getMessage(), e.getMessage());
}
// Make sure we get the same error when reading direct from an InputStream.
@@ -202,74 +201,72 @@ public class CodedInputStreamTest extends TestCase {
// 14882
assertReadVarint(bytes(0xa2, 0x74), (0x22 << 0) | (0x74 << 7));
// 2961488830
- assertReadVarint(
- bytes(0xbe, 0xf7, 0x92, 0x84, 0x0b),
- (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | (0x0bL << 28));
+ assertReadVarint(bytes(0xbe, 0xf7, 0x92, 0x84, 0x0b),
+ (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) |
+ (0x0bL << 28));
// 64-bit
// 7256456126
- assertReadVarint(
- bytes(0xbe, 0xf7, 0x92, 0x84, 0x1b),
- (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | (0x1bL << 28));
+ assertReadVarint(bytes(0xbe, 0xf7, 0x92, 0x84, 0x1b),
+ (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) |
+ (0x1bL << 28));
// 41256202580718336
assertReadVarint(
- bytes(0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49),
- (0x00 << 0)
- | (0x66 << 7)
- | (0x6b << 14)
- | (0x1c << 21)
- | (0x43L << 28)
- | (0x49L << 35)
- | (0x24L << 42)
- | (0x49L << 49));
+ bytes(0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49),
+ (0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) |
+ (0x43L << 28) | (0x49L << 35) | (0x24L << 42) | (0x49L << 49));
// 11964378330978735131
assertReadVarint(
- bytes(0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01),
- (0x1b << 0)
- | (0x28 << 7)
- | (0x79 << 14)
- | (0x42 << 21)
- | (0x3bL << 28)
- | (0x56L << 35)
- | (0x00L << 42)
- | (0x05L << 49)
- | (0x26L << 56)
- | (0x01L << 63));
+ bytes(0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01),
+ (0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) |
+ (0x3bL << 28) | (0x56L << 35) | (0x00L << 42) |
+ (0x05L << 49) | (0x26L << 56) | (0x01L << 63));
// Failures
assertReadVarintFailure(
- InvalidProtocolBufferException.malformedVarint(),
- bytes(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00));
- assertReadVarintFailure(InvalidProtocolBufferException.truncatedMessage(), bytes(0x80));
+ InvalidProtocolBufferException.malformedVarint(),
+ bytes(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x00));
+ assertReadVarintFailure(
+ InvalidProtocolBufferException.truncatedMessage(),
+ bytes(0x80));
}
/**
- * Parses the given bytes using readRawLittleEndian32() and checks that the result matches the
- * given value.
+ * Parses the given bytes using readRawLittleEndian32() and checks
+ * that the result matches the given value.
*/
- private void assertReadLittleEndian32(byte[] data, int value) throws Exception {
- for (InputType inputType : InputType.values()) {
- // Try different block sizes.
- for (int blockSize = 1; blockSize <= 16; blockSize *= 2) {
- CodedInputStream input = inputType.newDecoder(data, blockSize);
- assertEquals(inputType.name(), value, input.readRawLittleEndian32());
- assertTrue(inputType.name(), input.isAtEnd());
- }
+ private void assertReadLittleEndian32(byte[] data, int value)
+ throws Exception {
+ CodedInputStream input = CodedInputStream.newInstance(data);
+ assertEquals(value, input.readRawLittleEndian32());
+ assertTrue(input.isAtEnd());
+
+ // Try different block sizes.
+ for (int blockSize = 1; blockSize <= 16; blockSize *= 2) {
+ input = CodedInputStream.newInstance(
+ new SmallBlockInputStream(data, blockSize));
+ assertEquals(value, input.readRawLittleEndian32());
+ assertTrue(input.isAtEnd());
}
}
/**
- * Parses the given bytes using readRawLittleEndian64() and checks that the result matches the
- * given value.
+ * Parses the given bytes using readRawLittleEndian64() and checks
+ * that the result matches the given value.
*/
- private void assertReadLittleEndian64(byte[] data, long value) throws Exception {
- for (InputType inputType : InputType.values()) {
- // Try different block sizes.
- for (int blockSize = 1; blockSize <= 16; blockSize *= 2) {
- CodedInputStream input = inputType.newDecoder(data, blockSize);
- assertEquals(inputType.name(), value, input.readRawLittleEndian64());
- assertTrue(inputType.name(), input.isAtEnd());
- }
+ private void assertReadLittleEndian64(byte[] data, long value)
+ throws Exception {
+ CodedInputStream input = CodedInputStream.newInstance(data);
+ assertEquals(value, input.readRawLittleEndian64());
+ assertTrue(input.isAtEnd());
+
+ // Try different block sizes.
+ for (int blockSize = 1; blockSize <= 16; blockSize *= 2) {
+ input = CodedInputStream.newInstance(
+ new SmallBlockInputStream(data, blockSize));
+ assertEquals(value, input.readRawLittleEndian64());
+ assertTrue(input.isAtEnd());
}
}
@@ -279,32 +276,40 @@ public class CodedInputStreamTest extends TestCase {
assertReadLittleEndian32(bytes(0xf0, 0xde, 0xbc, 0x9a), 0x9abcdef0);
assertReadLittleEndian64(
- bytes(0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12), 0x123456789abcdef0L);
+ bytes(0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12),
+ 0x123456789abcdef0L);
assertReadLittleEndian64(
- bytes(0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a), 0x9abcdef012345678L);
+ bytes(0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a),
+ 0x9abcdef012345678L);
}
/** Test decodeZigZag32() and decodeZigZag64(). */
public void testDecodeZigZag() throws Exception {
- assertEquals(0, CodedInputStream.decodeZigZag32(0));
+ assertEquals( 0, CodedInputStream.decodeZigZag32(0));
assertEquals(-1, CodedInputStream.decodeZigZag32(1));
- assertEquals(1, CodedInputStream.decodeZigZag32(2));
+ assertEquals( 1, CodedInputStream.decodeZigZag32(2));
assertEquals(-2, CodedInputStream.decodeZigZag32(3));
assertEquals(0x3FFFFFFF, CodedInputStream.decodeZigZag32(0x7FFFFFFE));
assertEquals(0xC0000000, CodedInputStream.decodeZigZag32(0x7FFFFFFF));
assertEquals(0x7FFFFFFF, CodedInputStream.decodeZigZag32(0xFFFFFFFE));
assertEquals(0x80000000, CodedInputStream.decodeZigZag32(0xFFFFFFFF));
- assertEquals(0, CodedInputStream.decodeZigZag64(0));
+ assertEquals( 0, CodedInputStream.decodeZigZag64(0));
assertEquals(-1, CodedInputStream.decodeZigZag64(1));
- assertEquals(1, CodedInputStream.decodeZigZag64(2));
+ assertEquals( 1, CodedInputStream.decodeZigZag64(2));
assertEquals(-2, CodedInputStream.decodeZigZag64(3));
- assertEquals(0x000000003FFFFFFFL, CodedInputStream.decodeZigZag64(0x000000007FFFFFFEL));
- assertEquals(0xFFFFFFFFC0000000L, CodedInputStream.decodeZigZag64(0x000000007FFFFFFFL));
- assertEquals(0x000000007FFFFFFFL, CodedInputStream.decodeZigZag64(0x00000000FFFFFFFEL));
- assertEquals(0xFFFFFFFF80000000L, CodedInputStream.decodeZigZag64(0x00000000FFFFFFFFL));
- assertEquals(0x7FFFFFFFFFFFFFFFL, CodedInputStream.decodeZigZag64(0xFFFFFFFFFFFFFFFEL));
- assertEquals(0x8000000000000000L, CodedInputStream.decodeZigZag64(0xFFFFFFFFFFFFFFFFL));
+ assertEquals(0x000000003FFFFFFFL,
+ CodedInputStream.decodeZigZag64(0x000000007FFFFFFEL));
+ assertEquals(0xFFFFFFFFC0000000L,
+ CodedInputStream.decodeZigZag64(0x000000007FFFFFFFL));
+ assertEquals(0x000000007FFFFFFFL,
+ CodedInputStream.decodeZigZag64(0x00000000FFFFFFFEL));
+ assertEquals(0xFFFFFFFF80000000L,
+ CodedInputStream.decodeZigZag64(0x00000000FFFFFFFFL));
+ assertEquals(0x7FFFFFFFFFFFFFFFL,
+ CodedInputStream.decodeZigZag64(0xFFFFFFFFFFFFFFFEL));
+ assertEquals(0x8000000000000000L,
+ CodedInputStream.decodeZigZag64(0xFFFFFFFFFFFFFFFFL));
}
/** Tests reading and parsing a whole message with every field type. */
@@ -314,12 +319,14 @@ public class CodedInputStreamTest extends TestCase {
byte[] rawBytes = message.toByteArray();
assertEquals(rawBytes.length, message.getSerializedSize());
- for (InputType inputType : InputType.values()) {
- // Try different block sizes.
- for (int blockSize = 1; blockSize < 256; blockSize *= 2) {
- TestAllTypes message2 = TestAllTypes.parseFrom(inputType.newDecoder(rawBytes, blockSize));
- TestUtil.assertAllFieldsSet(message2);
- }
+ TestAllTypes message2 = TestAllTypes.parseFrom(rawBytes);
+ TestUtil.assertAllFieldsSet(message2);
+
+ // Try different block sizes.
+ for (int blockSize = 1; blockSize < 256; blockSize *= 2) {
+ message2 = TestAllTypes.parseFrom(
+ new SmallBlockInputStream(rawBytes, blockSize));
+ TestUtil.assertAllFieldsSet(message2);
}
}
@@ -328,65 +335,57 @@ public class CodedInputStreamTest extends TestCase {
TestAllTypes message = TestUtil.getAllSet();
byte[] rawBytes = message.toByteArray();
- InputType[] inputTypes = InputType.values();
- CodedInputStream[] inputs = new CodedInputStream[inputTypes.length];
- for (int i = 0; i < inputs.length; ++i) {
- inputs[i] = inputTypes[i].newDecoder(rawBytes);
- }
+ // Create two parallel inputs. Parse one as unknown fields while using
+ // skipField() to skip each field on the other. Expect the same tags.
+ CodedInputStream input1 = CodedInputStream.newInstance(rawBytes);
+ CodedInputStream input2 = CodedInputStream.newInstance(rawBytes);
UnknownFieldSet.Builder unknownFields = UnknownFieldSet.newBuilder();
while (true) {
- CodedInputStream input1 = inputs[0];
int tag = input1.readTag();
- // Ensure that the rest match.
- for (int i = 1; i < inputs.length; ++i) {
- assertEquals(inputTypes[i].name(), tag, inputs[i].readTag());
- }
+ assertEquals(tag, input2.readTag());
if (tag == 0) {
break;
}
unknownFields.mergeFieldFrom(tag, input1);
- // Skip the field for the rest of the inputs.
- for (int i = 1; i < inputs.length; ++i) {
- inputs[i].skipField(tag);
- }
+ input2.skipField(tag);
}
}
/**
- * Test that a bug in skipRawBytes() has been fixed: if the skip skips exactly up to a limit, this
- * should not break things.
+ * Test that a bug in skipRawBytes() has been fixed: if the skip skips
+ * exactly up to a limit, this should not break things.
*/
public void testSkipRawBytesBug() throws Exception {
- byte[] rawBytes = new byte[] {1, 2};
- for (InputType inputType : InputType.values()) {
- CodedInputStream input = inputType.newDecoder(rawBytes);
- int limit = input.pushLimit(1);
- input.skipRawBytes(1);
- input.popLimit(limit);
- assertEquals(inputType.name(), 2, input.readRawByte());
- }
+ byte[] rawBytes = new byte[] { 1, 2 };
+ CodedInputStream input = CodedInputStream.newInstance(rawBytes);
+
+ int limit = input.pushLimit(1);
+ input.skipRawBytes(1);
+ input.popLimit(limit);
+ assertEquals(2, input.readRawByte());
}
/**
- * Test that a bug in skipRawBytes() has been fixed: if the skip skips past the end of a buffer
- * with a limit that has been set past the end of that buffer, this should not break things.
+ * Test that a bug in skipRawBytes() has been fixed: if the skip skips
+ * past the end of a buffer with a limit that has been set past the end of
+ * that buffer, this should not break things.
*/
public void testSkipRawBytesPastEndOfBufferWithLimit() throws Exception {
- byte[] rawBytes = new byte[] {1, 2, 3, 4, 5};
- for (InputType inputType : InputType.values()) {
- CodedInputStream input = inputType.newDecoder(rawBytes);
- int limit = input.pushLimit(4);
- // In order to expose the bug we need to read at least one byte to prime the
- // buffer inside the CodedInputStream.
- assertEquals(inputType.name(), 1, input.readRawByte());
- // Skip to the end of the limit.
- input.skipRawBytes(3);
- assertTrue(inputType.name(), input.isAtEnd());
- input.popLimit(limit);
- assertEquals(inputType.name(), 5, input.readRawByte());
- }
+ byte[] rawBytes = new byte[] { 1, 2, 3, 4, 5 };
+ CodedInputStream input = CodedInputStream.newInstance(
+ new SmallBlockInputStream(rawBytes, 3));
+
+ int limit = input.pushLimit(4);
+ // In order to expose the bug we need to read at least one byte to prime the
+ // buffer inside the CodedInputStream.
+ assertEquals(1, input.readRawByte());
+ // Skip to the end of the limit.
+ input.skipRawBytes(3);
+ assertTrue(input.isAtEnd());
+ input.popLimit(limit);
+ assertEquals(5, input.readRawByte());
}
public void testReadHugeBlob() throws Exception {
@@ -402,22 +401,19 @@ public class CodedInputStreamTest extends TestCase {
builder.setOptionalBytes(ByteString.copyFrom(blob));
TestAllTypes message = builder.build();
- byte[] data = message.toByteArray();
- for (InputType inputType : InputType.values()) {
- // Serialize and parse it. Make sure to parse from an InputStream, not
- // directly from a ByteString, so that CodedInputStream uses buffered
- // reading.
- TestAllTypes message2 = TestAllTypes.parseFrom(inputType.newDecoder(data));
-
- assertEquals(inputType.name(), message.getOptionalBytes(), message2.getOptionalBytes());
-
- // Make sure all the other fields were parsed correctly.
- TestAllTypes message3 =
- TestAllTypes.newBuilder(message2)
- .setOptionalBytes(TestUtil.getAllSet().getOptionalBytes())
- .build();
- TestUtil.assertAllFieldsSet(message3);
- }
+ // Serialize and parse it. Make sure to parse from an InputStream, not
+ // directly from a ByteString, so that CodedInputStream uses buffered
+ // reading.
+ TestAllTypes message2 =
+ TestAllTypes.parseFrom(message.toByteString().newInput());
+
+ assertEquals(message.getOptionalBytes(), message2.getOptionalBytes());
+
+ // Make sure all the other fields were parsed correctly.
+ TestAllTypes message3 = TestAllTypes.newBuilder(message2)
+ .setOptionalBytes(TestUtil.getAllSet().getOptionalBytes())
+ .build();
+ TestUtil.assertAllFieldsSet(message3);
}
public void testReadMaliciouslyLargeBlob() throws Exception {
@@ -427,95 +423,17 @@ public class CodedInputStreamTest extends TestCase {
int tag = WireFormat.makeTag(1, WireFormat.WIRETYPE_LENGTH_DELIMITED);
output.writeRawVarint32(tag);
output.writeRawVarint32(0x7FFFFFFF);
- output.writeRawBytes(new byte[32]); // Pad with a few random bytes.
+ output.writeRawBytes(new byte[32]); // Pad with a few random bytes.
output.flush();
- byte[] data = rawOutput.toByteString().toByteArray();
- for (InputType inputType : InputType.values()) {
- CodedInputStream input = inputType.newDecoder(data);
- assertEquals(tag, input.readTag());
- try {
- input.readBytes();
- fail(inputType.name() + ": Should have thrown an exception!");
- } catch (InvalidProtocolBufferException e) {
- // success.
- }
- }
- }
+ CodedInputStream input = rawOutput.toByteString().newCodedInput();
+ assertEquals(tag, input.readTag());
- /**
- * Test we can do messages that are up to CodedInputStream#DEFAULT_SIZE_LIMIT
- * in size (2G or Integer#MAX_SIZE).
- * @throws IOException
- */
- public void testParseMessagesCloseTo2G() throws IOException {
- byte[] serializedMessage = getBigSerializedMessage();
- // How many of these big messages do we need to take us near our 2G limit?
- int count = Integer.MAX_VALUE / serializedMessage.length;
- // Now make an inputstream that will fake a near 2G message of messages
- // returning our big serialized message 'count' times.
- InputStream is = new RepeatingInputStream(serializedMessage, count);
- // Parse should succeed!
- TestAllTypes.parseFrom(is);
- }
-
- /**
- * Test there is an exception if a message exceeds
- * CodedInputStream#DEFAULT_SIZE_LIMIT in size (2G or Integer#MAX_SIZE).
- * @throws IOException
- */
- public void testParseMessagesOver2G() throws IOException {
- byte[] serializedMessage = getBigSerializedMessage();
- // How many of these big messages do we need to take us near our 2G limit?
- int count = Integer.MAX_VALUE / serializedMessage.length;
- // Now add one to take us over the limit
- count++;
- // Now make an inputstream that will fake a near 2G message of messages
- // returning our big serialized message 'count' times.
- InputStream is = new RepeatingInputStream(serializedMessage, count);
try {
- TestAllTypes.parseFrom(is);
+ input.readBytes();
fail("Should have thrown an exception!");
} catch (InvalidProtocolBufferException e) {
- assertTrue(e.getMessage().contains("too large"));
- }
- }
-
- /*
- * @return A serialized big message.
- */
- private static byte[] getBigSerializedMessage() {
- byte[] value = new byte[16 * 1024 * 1024];
- ByteString bsValue = ByteString.wrap(value);
- return TestAllTypes.newBuilder().setOptionalBytes(bsValue).build().toByteArray();
- }
-
- /*
- * An input stream that repeats a byte arrays' content a number of times.
- * Simulates really large input without consuming loads of memory. Used above
- * to test the parsing behavior when the input size exceeds 2G or close to it.
- */
- private static class RepeatingInputStream extends InputStream {
- private final byte[] serializedMessage;
- private final int count;
- private int index = 0;
- private int offset = 0;
-
- RepeatingInputStream(byte[] serializedMessage, int count) {
- this.serializedMessage = serializedMessage;
- this.count = count;
- }
-
- @Override
- public int read() throws IOException {
- if (this.offset == this.serializedMessage.length) {
- this.index++;
- this.offset = 0;
- }
- if (this.index == this.count) {
- return -1;
- }
- return this.serializedMessage[offset++];
+ // success.
}
}
@@ -523,55 +441,54 @@ public class CodedInputStreamTest extends TestCase {
if (depth == 0) {
return TestRecursiveMessage.newBuilder().setI(5).build();
} else {
- return TestRecursiveMessage.newBuilder().setA(makeRecursiveMessage(depth - 1)).build();
+ return TestRecursiveMessage.newBuilder()
+ .setA(makeRecursiveMessage(depth - 1)).build();
}
}
- private void assertMessageDepth(String msg, TestRecursiveMessage message, int depth) {
+ private void assertMessageDepth(TestRecursiveMessage message, int depth) {
if (depth == 0) {
- assertFalse(msg, message.hasA());
- assertEquals(msg, 5, message.getI());
+ assertFalse(message.hasA());
+ assertEquals(5, message.getI());
} else {
- assertTrue(msg, message.hasA());
- assertMessageDepth(msg, message.getA(), depth - 1);
+ assertTrue(message.hasA());
+ assertMessageDepth(message.getA(), depth - 1);
}
}
public void testMaliciousRecursion() throws Exception {
- byte[] data100 = makeRecursiveMessage(100).toByteArray();
- byte[] data101 = makeRecursiveMessage(101).toByteArray();
+ ByteString data100 = makeRecursiveMessage(100).toByteString();
+ ByteString data101 = makeRecursiveMessage(101).toByteString();
- for (InputType inputType : InputType.values()) {
- assertMessageDepth(
- inputType.name(), TestRecursiveMessage.parseFrom(inputType.newDecoder(data100)), 100);
+ assertMessageDepth(TestRecursiveMessage.parseFrom(data100), 100);
- try {
- TestRecursiveMessage.parseFrom(inputType.newDecoder(data101));
- fail("Should have thrown an exception!");
- } catch (InvalidProtocolBufferException e) {
- // success.
- }
+ try {
+ TestRecursiveMessage.parseFrom(data101);
+ fail("Should have thrown an exception!");
+ } catch (InvalidProtocolBufferException e) {
+ // success.
+ }
- CodedInputStream input = inputType.newDecoder(data100);
- input.setRecursionLimit(8);
- try {
- TestRecursiveMessage.parseFrom(input);
- fail(inputType.name() + ": Should have thrown an exception!");
- } catch (InvalidProtocolBufferException e) {
- // success.
- }
+ CodedInputStream input = data100.newCodedInput();
+ input.setRecursionLimit(8);
+ try {
+ TestRecursiveMessage.parseFrom(input);
+ fail("Should have thrown an exception!");
+ } catch (InvalidProtocolBufferException e) {
+ // success.
}
}
private void checkSizeLimitExceeded(InvalidProtocolBufferException e) {
- assertEquals(InvalidProtocolBufferException.sizeLimitExceeded().getMessage(), e.getMessage());
+ assertEquals(
+ InvalidProtocolBufferException.sizeLimitExceeded().getMessage(),
+ e.getMessage());
}
public void testSizeLimit() throws Exception {
- // NOTE: Size limit only applies to the stream-backed CIS.
- CodedInputStream input =
- CodedInputStream.newInstance(
- new SmallBlockInputStream(TestUtil.getAllSet().toByteArray(), 16));
+ CodedInputStream input = CodedInputStream.newInstance(
+ new SmallBlockInputStream(
+ TestUtil.getAllSet().toByteString().newInput(), 16));
input.setSizeLimit(16);
try {
@@ -583,9 +500,8 @@ public class CodedInputStreamTest extends TestCase {
}
public void testResetSizeCounter() throws Exception {
- // NOTE: Size limit only applies to the stream-backed CIS.
- CodedInputStream input =
- CodedInputStream.newInstance(new SmallBlockInputStream(new byte[256], 8));
+ CodedInputStream input = CodedInputStream.newInstance(
+ new SmallBlockInputStream(new byte[256], 8));
input.setSizeLimit(16);
input.readRawBytes(16);
assertEquals(16, input.getTotalBytesRead());
@@ -599,7 +515,7 @@ public class CodedInputStreamTest extends TestCase {
input.resetSizeCounter();
assertEquals(0, input.getTotalBytesRead());
- input.readRawByte(); // No exception thrown.
+ input.readRawByte(); // No exception thrown.
input.resetSizeCounter();
assertEquals(0, input.getTotalBytesRead());
input.readRawBytes(16);
@@ -607,7 +523,7 @@ public class CodedInputStreamTest extends TestCase {
input.resetSizeCounter();
try {
- input.readRawBytes(17); // Hits limit again.
+ input.readRawBytes(17); // Hits limit again.
fail("Should have thrown an exception!");
} catch (InvalidProtocolBufferException expected) {
checkSizeLimitExceeded(expected);
@@ -615,12 +531,12 @@ public class CodedInputStreamTest extends TestCase {
}
public void testSizeLimitMultipleMessages() throws Exception {
- // NOTE: Size limit only applies to the stream-backed CIS.
byte[] bytes = new byte[256];
for (int i = 0; i < bytes.length; i++) {
bytes[i] = (byte) i;
}
- CodedInputStream input = CodedInputStream.newInstance(new SmallBlockInputStream(bytes, 7));
+ CodedInputStream input = CodedInputStream.newInstance(
+ new SmallBlockInputStream(bytes, 7));
input.setSizeLimit(16);
for (int i = 0; i < 256 / 16; i++) {
byte[] message = input.readRawBytes(16);
@@ -650,13 +566,12 @@ public class CodedInputStreamTest extends TestCase {
output.writeRawBytes(bytes);
output.flush();
- byte[] rawInput = rawOutput.toByteString().toByteArray();
- for (InputType inputType : InputType.values()) {
- CodedInputStream input = inputType.newDecoder(rawInput);
- assertEquals(inputType.name(), tag, input.readTag());
- String text = input.readString();
- assertEquals(inputType.name(), lorem, text);
- }
+ CodedInputStream input =
+ CodedInputStream.newInstance(
+ new ByteArrayInputStream(rawOutput.toByteString().toByteArray()));
+ assertEquals(tag, input.readTag());
+ String text = input.readString();
+ assertEquals(lorem, text);
}
public void testReadStringRequireUtf8() throws Exception {
@@ -676,18 +591,18 @@ public class CodedInputStreamTest extends TestCase {
output.writeRawBytes(bytes);
output.flush();
- byte[] rawInput = rawOutput.toByteString().toByteArray();
- for (InputType inputType : InputType.values()) {
- CodedInputStream input = inputType.newDecoder(rawInput);
- assertEquals(inputType.name(), tag, input.readTag());
- String text = input.readStringRequireUtf8();
- assertEquals(inputType.name(), lorem, text);
- }
+ CodedInputStream input =
+ CodedInputStream.newInstance(
+ new ByteArrayInputStream(rawOutput.toByteString().toByteArray()));
+ assertEquals(tag, input.readTag());
+ String text = input.readStringRequireUtf8();
+ assertEquals(lorem, text);
}
/**
- * Tests that if we readString invalid UTF-8 bytes, no exception is thrown. Instead, the invalid
- * bytes are replaced with the Unicode "replacement character" U+FFFD.
+ * Tests that if we readString invalid UTF-8 bytes, no exception
+ * is thrown. Instead, the invalid bytes are replaced with the Unicode
+ * "replacement character" U+FFFD.
*/
public void testReadStringInvalidUtf8() throws Exception {
ByteString.Output rawOutput = ByteString.newOutput();
@@ -696,21 +611,18 @@ public class CodedInputStreamTest extends TestCase {
int tag = WireFormat.makeTag(1, WireFormat.WIRETYPE_LENGTH_DELIMITED);
output.writeRawVarint32(tag);
output.writeRawVarint32(1);
- output.writeRawBytes(new byte[] {(byte) 0x80});
+ output.writeRawBytes(new byte[] { (byte) 0x80 });
output.flush();
- byte[] rawInput = rawOutput.toByteString().toByteArray();
- for (InputType inputType : InputType.values()) {
- CodedInputStream input = inputType.newDecoder(rawInput);
- assertEquals(inputType.name(), tag, input.readTag());
- String text = input.readString();
- assertEquals(inputType.name(), 0xfffd, text.charAt(0));
- }
+ CodedInputStream input = rawOutput.toByteString().newCodedInput();
+ assertEquals(tag, input.readTag());
+ String text = input.readString();
+ assertEquals(0xfffd, text.charAt(0));
}
/**
- * Tests that if we readStringRequireUtf8 invalid UTF-8 bytes, an InvalidProtocolBufferException
- * is thrown.
+ * Tests that if we readStringRequireUtf8 invalid UTF-8 bytes, an
+ * InvalidProtocolBufferException is thrown.
*/
public void testReadStringRequireUtf8InvalidUtf8() throws Exception {
ByteString.Output rawOutput = ByteString.newOutput();
@@ -719,20 +631,16 @@ public class CodedInputStreamTest extends TestCase {
int tag = WireFormat.makeTag(1, WireFormat.WIRETYPE_LENGTH_DELIMITED);
output.writeRawVarint32(tag);
output.writeRawVarint32(1);
- output.writeRawBytes(new byte[] {(byte) 0x80});
+ output.writeRawBytes(new byte[] { (byte) 0x80 });
output.flush();
- byte[] rawInput = rawOutput.toByteString().toByteArray();
- for (InputType inputType : InputType.values()) {
- CodedInputStream input = inputType.newDecoder(rawInput);
- assertEquals(tag, input.readTag());
- try {
- input.readStringRequireUtf8();
- fail(inputType.name() + ": Expected invalid UTF-8 exception.");
- } catch (InvalidProtocolBufferException exception) {
- assertEquals(
- inputType.name(), "Protocol message had invalid UTF-8.", exception.getMessage());
- }
+ CodedInputStream input = rawOutput.toByteString().newCodedInput();
+ assertEquals(tag, input.readTag());
+ try {
+ input.readStringRequireUtf8();
+ fail("Expected invalid UTF-8 exception.");
+ } catch (InvalidProtocolBufferException exception) {
+ assertEquals("Protocol message had invalid UTF-8.", exception.getMessage());
}
}
@@ -752,17 +660,13 @@ public class CodedInputStreamTest extends TestCase {
public void testInvalidTag() throws Exception {
// Any tag number which corresponds to field number zero is invalid and
// should throw InvalidProtocolBufferException.
- for (InputType inputType : InputType.values()) {
- for (int i = 0; i < 8; i++) {
- try {
- inputType.newDecoder(bytes(i)).readTag();
- fail(inputType.name() + ": Should have thrown an exception.");
- } catch (InvalidProtocolBufferException e) {
- assertEquals(
- inputType.name(),
- InvalidProtocolBufferException.invalidTag().getMessage(),
- e.getMessage());
- }
+ for (int i = 0; i < 8; i++) {
+ try {
+ CodedInputStream.newInstance(bytes(i)).readTag();
+ fail("Should have thrown an exception.");
+ } catch (InvalidProtocolBufferException e) {
+ assertEquals(InvalidProtocolBufferException.invalidTag().getMessage(),
+ e.getMessage());
}
}
}
@@ -774,10 +678,10 @@ public class CodedInputStreamTest extends TestCase {
output.writeRawVarint32(0);
// One one-byte bytes field
output.writeRawVarint32(1);
- output.writeRawBytes(new byte[] {(byte) 23});
+ output.writeRawBytes(new byte[] { (byte) 23 });
// Another one-byte bytes field
output.writeRawVarint32(1);
- output.writeRawBytes(new byte[] {(byte) 45});
+ output.writeRawBytes(new byte[] { (byte) 45 });
// A bytes field large enough that won't fit into the 4K buffer.
final int bytesLength = 16 * 1024;
byte[] bytes = new byte[bytesLength];
@@ -787,24 +691,20 @@ public class CodedInputStreamTest extends TestCase {
output.writeRawBytes(bytes);
output.flush();
-
- byte[] rawInput = rawOutput.toByteString().toByteArray();
- for (InputType inputType : InputType.values()) {
- CodedInputStream inputStream = inputType.newDecoder(rawInput);
-
- byte[] result = inputStream.readByteArray();
- assertEquals(inputType.name(), 0, result.length);
- result = inputStream.readByteArray();
- assertEquals(inputType.name(), 1, result.length);
- assertEquals(inputType.name(), (byte) 23, result[0]);
- result = inputStream.readByteArray();
- assertEquals(inputType.name(), 1, result.length);
- assertEquals(inputType.name(), (byte) 45, result[0]);
- result = inputStream.readByteArray();
- assertEquals(inputType.name(), bytesLength, result.length);
- assertEquals(inputType.name(), (byte) 67, result[0]);
- assertEquals(inputType.name(), (byte) 89, result[bytesLength - 1]);
- }
+ CodedInputStream inputStream = rawOutput.toByteString().newCodedInput();
+
+ byte[] result = inputStream.readByteArray();
+ assertEquals(0, result.length);
+ result = inputStream.readByteArray();
+ assertEquals(1, result.length);
+ assertEquals((byte) 23, result[0]);
+ result = inputStream.readByteArray();
+ assertEquals(1, result.length);
+ assertEquals((byte) 45, result[0]);
+ result = inputStream.readByteArray();
+ assertEquals(bytesLength, result.length);
+ assertEquals((byte) 67, result[0]);
+ assertEquals((byte) 89, result[bytesLength - 1]);
}
public void testReadByteBuffer() throws Exception {
@@ -814,10 +714,10 @@ public class CodedInputStreamTest extends TestCase {
output.writeRawVarint32(0);
// One one-byte bytes field
output.writeRawVarint32(1);
- output.writeRawBytes(new byte[] {(byte) 23});
+ output.writeRawBytes(new byte[]{(byte) 23});
// Another one-byte bytes field
output.writeRawVarint32(1);
- output.writeRawBytes(new byte[] {(byte) 45});
+ output.writeRawBytes(new byte[]{(byte) 45});
// A bytes field large enough that won't fit into the 4K buffer.
final int bytesLength = 16 * 1024;
byte[] bytes = new byte[bytesLength];
@@ -827,25 +727,21 @@ public class CodedInputStreamTest extends TestCase {
output.writeRawBytes(bytes);
output.flush();
-
- byte[] rawInput = rawOutput.toByteString().toByteArray();
- for (InputType inputType : InputType.values()) {
- CodedInputStream inputStream = inputType.newDecoder(rawInput);
-
- ByteBuffer result = inputStream.readByteBuffer();
- assertEquals(inputType.name(), 0, result.capacity());
- result = inputStream.readByteBuffer();
- assertEquals(inputType.name(), 1, result.capacity());
- assertEquals(inputType.name(), (byte) 23, result.get());
- result = inputStream.readByteBuffer();
- assertEquals(inputType.name(), 1, result.capacity());
- assertEquals(inputType.name(), (byte) 45, result.get());
- result = inputStream.readByteBuffer();
- assertEquals(inputType.name(), bytesLength, result.capacity());
- assertEquals(inputType.name(), (byte) 67, result.get());
- result.position(bytesLength - 1);
- assertEquals(inputType.name(), (byte) 89, result.get());
- }
+ CodedInputStream inputStream = rawOutput.toByteString().newCodedInput();
+
+ ByteBuffer result = inputStream.readByteBuffer();
+ assertEquals(0, result.capacity());
+ result = inputStream.readByteBuffer();
+ assertEquals(1, result.capacity());
+ assertEquals((byte) 23, result.get());
+ result = inputStream.readByteBuffer();
+ assertEquals(1, result.capacity());
+ assertEquals((byte) 45, result.get());
+ result = inputStream.readByteBuffer();
+ assertEquals(bytesLength, result.capacity());
+ assertEquals((byte) 67, result.get());
+ result.position(bytesLength - 1);
+ assertEquals((byte) 89, result.get());
}
public void testReadByteBufferAliasing() throws Exception {
@@ -855,10 +751,10 @@ public class CodedInputStreamTest extends TestCase {
output.writeRawVarint32(0);
// One one-byte bytes field
output.writeRawVarint32(1);
- output.writeRawBytes(new byte[] {(byte) 23});
+ output.writeRawBytes(new byte[]{(byte) 23});
// Another one-byte bytes field
output.writeRawVarint32(1);
- output.writeRawBytes(new byte[] {(byte) 45});
+ output.writeRawBytes(new byte[]{(byte) 45});
// A bytes field large enough that won't fit into the 4K buffer.
final int bytesLength = 16 * 1024;
byte[] bytes = new byte[bytesLength];
@@ -867,105 +763,59 @@ public class CodedInputStreamTest extends TestCase {
output.writeRawVarint32(bytesLength);
output.writeRawBytes(bytes);
output.flush();
-
byte[] data = byteArrayStream.toByteArray();
- for (InputType inputType : InputType.values()) {
- if (inputType == InputType.STREAM) {
- // Aliasing doesn't apply to stream-backed CIS.
- continue;
- }
-
- // Without aliasing
- CodedInputStream inputStream = inputType.newDecoder(data);
- ByteBuffer result = inputStream.readByteBuffer();
- assertEquals(inputType.name(), 0, result.capacity());
- result = inputStream.readByteBuffer();
- assertTrue(inputType.name(), result.array() != data);
- assertEquals(inputType.name(), 1, result.capacity());
- assertEquals(inputType.name(), (byte) 23, result.get());
- result = inputStream.readByteBuffer();
- assertTrue(inputType.name(), result.array() != data);
- assertEquals(inputType.name(), 1, result.capacity());
- assertEquals(inputType.name(), (byte) 45, result.get());
- result = inputStream.readByteBuffer();
- assertTrue(inputType.name(), result.array() != data);
- assertEquals(inputType.name(), bytesLength, result.capacity());
- assertEquals(inputType.name(), (byte) 67, result.get());
- result.position(bytesLength - 1);
- assertEquals(inputType.name(), (byte) 89, result.get());
-
- // Enable aliasing
- inputStream = inputType.newDecoder(data);
- inputStream.enableAliasing(true);
- result = inputStream.readByteBuffer();
- assertEquals(inputType.name(), 0, result.capacity());
- result = inputStream.readByteBuffer();
- if (result.hasArray()) {
- assertTrue(inputType.name(), result.array() == data);
- }
- assertEquals(inputType.name(), 1, result.capacity());
- assertEquals(inputType.name(), (byte) 23, result.get());
- result = inputStream.readByteBuffer();
- if (result.hasArray()) {
- assertTrue(inputType.name(), result.array() == data);
- }
- assertEquals(inputType.name(), 1, result.capacity());
- assertEquals(inputType.name(), (byte) 45, result.get());
- result = inputStream.readByteBuffer();
- if (result.hasArray()) {
- assertTrue(inputType.name(), result.array() == data);
- }
- assertEquals(inputType.name(), bytesLength, result.capacity());
- assertEquals(inputType.name(), (byte) 67, result.get());
- result.position(bytesLength - 1);
- assertEquals(inputType.name(), (byte) 89, result.get());
- }
+ // Without aliasing
+ CodedInputStream inputStream = CodedInputStream.newInstance(data);
+ ByteBuffer result = inputStream.readByteBuffer();
+ assertEquals(0, result.capacity());
+ result = inputStream.readByteBuffer();
+ assertTrue(result.array() != data);
+ assertEquals(1, result.capacity());
+ assertEquals((byte) 23, result.get());
+ result = inputStream.readByteBuffer();
+ assertTrue(result.array() != data);
+ assertEquals(1, result.capacity());
+ assertEquals((byte) 45, result.get());
+ result = inputStream.readByteBuffer();
+ assertTrue(result.array() != data);
+ assertEquals(bytesLength, result.capacity());
+ assertEquals((byte) 67, result.get());
+ result.position(bytesLength - 1);
+ assertEquals((byte) 89, result.get());
+
+ // Enable aliasing
+ inputStream = CodedInputStream.newInstance(data);
+ inputStream.enableAliasing(true);
+ result = inputStream.readByteBuffer();
+ assertEquals(0, result.capacity());
+ result = inputStream.readByteBuffer();
+ assertTrue(result.array() == data);
+ assertEquals(1, result.capacity());
+ assertEquals((byte) 23, result.get());
+ result = inputStream.readByteBuffer();
+ assertTrue(result.array() == data);
+ assertEquals(1, result.capacity());
+ assertEquals((byte) 45, result.get());
+ result = inputStream.readByteBuffer();
+ assertTrue(result.array() == data);
+ assertEquals(bytesLength, result.capacity());
+ assertEquals((byte) 67, result.get());
+ result.position(bytesLength - 1);
+ assertEquals((byte) 89, result.get());
}
public void testCompatibleTypes() throws Exception {
long data = 0x100000000L;
Int64Message message = Int64Message.newBuilder().setData(data).build();
- byte[] serialized = message.toByteArray();
- for (InputType inputType : InputType.values()) {
- CodedInputStream inputStream = inputType.newDecoder(serialized);
-
- // Test int64(long) is compatible with bool(boolean)
- BoolMessage msg2 = BoolMessage.parseFrom(inputStream);
- assertTrue(msg2.getData());
-
- // Test int64(long) is compatible with int32(int)
- inputStream = inputType.newDecoder(serialized);
- Int32Message msg3 = Int32Message.parseFrom(inputStream);
- assertEquals((int) data, msg3.getData());
- }
- }
+ ByteString serialized = message.toByteString();
- public void testSkipInvalidVarint_FastPath() throws Exception {
- // Fast path: We have >= 10 bytes available. Ensure we properly recognize a non-ending varint.
- byte[] data = new byte[] {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0};
- for (InputType inputType : InputType.values()) {
- try {
- CodedInputStream input = inputType.newDecoder(data);
- input.skipField(WireFormat.makeTag(1, WireFormat.WIRETYPE_VARINT));
- fail(inputType.name() + ": Should have thrown an exception.");
- } catch (InvalidProtocolBufferException e) {
- // Expected
- }
- }
- }
+ // Test int64(long) is compatible with bool(boolean)
+ BoolMessage msg2 = BoolMessage.parseFrom(serialized);
+ assertTrue(msg2.getData());
- public void testSkipInvalidVarint_SlowPath() throws Exception {
- // Slow path: < 10 bytes available. Ensure we properly recognize a non-ending varint.
- byte[] data = new byte[] {-1, -1, -1, -1, -1, -1, -1, -1, -1};
- for (InputType inputType : InputType.values()) {
- try {
- CodedInputStream input = inputType.newDecoder(data);
- input.skipField(WireFormat.makeTag(1, WireFormat.WIRETYPE_VARINT));
- fail(inputType.name() + ": Should have thrown an exception.");
- } catch (InvalidProtocolBufferException e) {
- // Expected
- }
- }
+ // Test int64(long) is compatible with int32(int)
+ Int32Message msg3 = Int32Message.parseFrom(serialized);
+ assertEquals((int) data, msg3.getData());
}
}

Powered by Google App Engine
This is Rietveld 408576698