From d0332953cda33fb4f8e24ebff9c49159b69c43d6 Mon Sep 17 00:00:00 2001
From: Wink Saville <wink@google.com>
Date: Sat, 29 May 2010 13:00:38 -0700
Subject: Add protobuf 2.3.0 sources
This is the contents of protobuf-2.3.0.tar.bz2 from
http://code.google.com/p/protobuf/downloads/list.
Change-Id: Idfde09ce7ef5ac027b07ee83f2674fbbed5c30b2
---
.../com/google/protobuf/AbstractMessageTest.java | 38 +
.../com/google/protobuf/CodedInputStreamTest.java | 21 +
.../java/com/google/protobuf/DescriptorsTest.java | 51 +
.../com/google/protobuf/GeneratedMessageTest.java | 35 +-
.../test/java/com/google/protobuf/LiteTest.java | 4 +-
.../test/java/com/google/protobuf/MicroTest.java | 2138 --------------------
.../test/java/com/google/protobuf/PerfTimer.java | 832 --------
.../test/java/com/google/protobuf/ServiceTest.java | 47 +
.../test/java/com/google/protobuf/TestUtil.java | 120 ++
.../java/com/google/protobuf/TextFormatTest.java | 32 +-
.../java/com/google/protobuf/WireFormatTest.java | 25 +
11 files changed, 365 insertions(+), 2978 deletions(-)
delete mode 100644 java/src/test/java/com/google/protobuf/MicroTest.java
delete mode 100644 java/src/test/java/com/google/protobuf/PerfTimer.java
(limited to 'java/src/test')
diff --git a/java/src/test/java/com/google/protobuf/AbstractMessageTest.java b/java/src/test/java/com/google/protobuf/AbstractMessageTest.java
index 2c59fd0..c44d660 100644
--- a/java/src/test/java/com/google/protobuf/AbstractMessageTest.java
+++ b/java/src/test/java/com/google/protobuf/AbstractMessageTest.java
@@ -38,6 +38,7 @@ import protobuf_unittest.UnittestProto.TestAllTypes;
import protobuf_unittest.UnittestProto.TestPackedTypes;
import protobuf_unittest.UnittestProto.TestRequired;
import protobuf_unittest.UnittestProto.TestRequiredForeign;
+import protobuf_unittest.UnittestProto.TestUnpackedTypes;
import junit.framework.TestCase;
@@ -238,6 +239,43 @@ public class AbstractMessageTest extends TestCase {
TestUtil.assertPackedFieldsSet((TestPackedTypes) message.wrappedMessage);
}
+ public void testUnpackedSerialization() throws Exception {
+ Message abstractMessage =
+ new AbstractMessageWrapper(TestUtil.getUnpackedSet());
+
+ TestUtil.assertUnpackedFieldsSet(
+ TestUnpackedTypes.parseFrom(abstractMessage.toByteString()));
+
+ assertEquals(TestUtil.getUnpackedSet().toByteString(),
+ abstractMessage.toByteString());
+ }
+
+ public void testParsePackedToUnpacked() throws Exception {
+ AbstractMessageWrapper.Builder builder =
+ new AbstractMessageWrapper.Builder(TestUnpackedTypes.newBuilder());
+ AbstractMessageWrapper message =
+ builder.mergeFrom(TestUtil.getPackedSet().toByteString()).build();
+ TestUtil.assertUnpackedFieldsSet(
+ (TestUnpackedTypes) message.wrappedMessage);
+ }
+
+ public void testParseUnpackedToPacked() throws Exception {
+ AbstractMessageWrapper.Builder builder =
+ new AbstractMessageWrapper.Builder(TestPackedTypes.newBuilder());
+ AbstractMessageWrapper message =
+ builder.mergeFrom(TestUtil.getUnpackedSet().toByteString()).build();
+ TestUtil.assertPackedFieldsSet((TestPackedTypes) message.wrappedMessage);
+ }
+
+ public void testUnpackedParsing() throws Exception {
+ AbstractMessageWrapper.Builder builder =
+ new AbstractMessageWrapper.Builder(TestUnpackedTypes.newBuilder());
+ AbstractMessageWrapper message =
+ builder.mergeFrom(TestUtil.getUnpackedSet().toByteString()).build();
+ TestUtil.assertUnpackedFieldsSet(
+ (TestUnpackedTypes) message.wrappedMessage);
+ }
+
public void testOptimizedForSize() throws Exception {
// We're mostly only checking that this class was compiled successfully.
TestOptimizedForSize message =
diff --git a/java/src/test/java/com/google/protobuf/CodedInputStreamTest.java b/java/src/test/java/com/google/protobuf/CodedInputStreamTest.java
index 850b8aa..6acd322 100644
--- a/java/src/test/java/com/google/protobuf/CodedInputStreamTest.java
+++ b/java/src/test/java/com/google/protobuf/CodedInputStreamTest.java
@@ -434,6 +434,7 @@ public class CodedInputStreamTest extends TestCase {
new SmallBlockInputStream(new byte[256], 8));
input.setSizeLimit(16);
input.readRawBytes(16);
+ assertEquals(16, input.getTotalBytesRead());
try {
input.readRawByte();
@@ -443,7 +444,10 @@ public class CodedInputStreamTest extends TestCase {
}
input.resetSizeCounter();
+ assertEquals(0, input.getTotalBytesRead());
input.readRawByte(); // No exception thrown.
+ input.resetSizeCounter();
+ assertEquals(0, input.getTotalBytesRead());
try {
input.readRawBytes(16); // Hits limit again.
@@ -477,10 +481,27 @@ public class CodedInputStreamTest extends TestCase {
public void testReadFromSlice() throws Exception {
byte[] bytes = bytes(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
CodedInputStream in = CodedInputStream.newInstance(bytes, 3, 5);
+ assertEquals(0, in.getTotalBytesRead());
for (int i = 3; i < 8; i++) {
assertEquals(i, in.readRawByte());
+ assertEquals(i-2, in.getTotalBytesRead());
}
// eof
assertEquals(0, in.readTag());
+ assertEquals(5, in.getTotalBytesRead());
+ }
+
+ public void testInvalidTag() throws Exception {
+ // Any tag number which corresponds to field number zero is invalid and
+ // should throw InvalidProtocolBufferException.
+ 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());
+ }
+ }
}
}
diff --git a/java/src/test/java/com/google/protobuf/DescriptorsTest.java b/java/src/test/java/com/google/protobuf/DescriptorsTest.java
index c5c38b2..f41d070 100644
--- a/java/src/test/java/com/google/protobuf/DescriptorsTest.java
+++ b/java/src/test/java/com/google/protobuf/DescriptorsTest.java
@@ -30,6 +30,10 @@
package com.google.protobuf;
+import com.google.protobuf.DescriptorProtos.DescriptorProto;
+import com.google.protobuf.DescriptorProtos.FieldDescriptorProto;
+import com.google.protobuf.DescriptorProtos.FileDescriptorProto;
+import com.google.protobuf.Descriptors.DescriptorValidationException;
import com.google.protobuf.Descriptors.FileDescriptor;
import com.google.protobuf.Descriptors.Descriptor;
import com.google.protobuf.Descriptors.FieldDescriptor;
@@ -63,6 +67,22 @@ import java.util.Collections;
* @author kenton@google.com Kenton Varda
*/
public class DescriptorsTest extends TestCase {
+
+ // Regression test for bug where referencing a FieldDescriptor.Type value
+ // before a FieldDescriptorProto.Type value would yield a
+ // ExceptionInInitializerError.
+ private static final Object STATIC_INIT_TEST = FieldDescriptor.Type.BOOL;
+
+ public void testFieldTypeEnumMapping() throws Exception {
+ assertEquals(FieldDescriptor.Type.values().length,
+ FieldDescriptorProto.Type.values().length);
+ for (FieldDescriptor.Type type : FieldDescriptor.Type.values()) {
+ FieldDescriptorProto.Type protoType = type.toProto();
+ assertEquals("TYPE_" + type.name(), protoType.name());
+ assertEquals(type, FieldDescriptor.Type.valueOf(protoType));
+ }
+ }
+
public void testFileDescriptor() throws Exception {
FileDescriptor file = UnittestProto.getDescriptor();
@@ -405,4 +425,35 @@ public class DescriptorsTest extends TestCase {
UnittestEnormousDescriptor.getDescriptor()
.toProto().getSerializedSize() > 65536);
}
+
+ /**
+ * Tests that the DescriptorValidationException works as intended.
+ */
+ public void testDescriptorValidatorException() throws Exception {
+ FileDescriptorProto fileDescriptorProto = FileDescriptorProto.newBuilder()
+ .setName("foo.proto")
+ .addMessageType(DescriptorProto.newBuilder()
+ .setName("Foo")
+ .addField(FieldDescriptorProto.newBuilder()
+ .setLabel(FieldDescriptorProto.Label.LABEL_OPTIONAL)
+ .setType(FieldDescriptorProto.Type.TYPE_INT32)
+ .setName("foo")
+ .setNumber(1)
+ .setDefaultValue("invalid")
+ .build())
+ .build())
+ .build();
+ try {
+ Descriptors.FileDescriptor.buildFrom(fileDescriptorProto,
+ new FileDescriptor[0]);
+ fail("DescriptorValidationException expected");
+ } catch (DescriptorValidationException e) {
+ // Expected; check that the error message contains some useful hints
+ assertTrue(e.getMessage().indexOf("foo") != -1);
+ assertTrue(e.getMessage().indexOf("Foo") != -1);
+ assertTrue(e.getMessage().indexOf("invalid") != -1);
+ assertTrue(e.getCause() instanceof NumberFormatException);
+ assertTrue(e.getCause().getMessage().indexOf("invalid") != -1);
+ }
+ }
}
diff --git a/java/src/test/java/com/google/protobuf/GeneratedMessageTest.java b/java/src/test/java/com/google/protobuf/GeneratedMessageTest.java
index cdf60c5..73c71f3 100644
--- a/java/src/test/java/com/google/protobuf/GeneratedMessageTest.java
+++ b/java/src/test/java/com/google/protobuf/GeneratedMessageTest.java
@@ -39,6 +39,8 @@ import protobuf_unittest.UnittestProto.ForeignEnum;
import protobuf_unittest.UnittestProto.TestAllTypes;
import protobuf_unittest.UnittestProto.TestAllExtensions;
import protobuf_unittest.UnittestProto.TestExtremeDefaultValues;
+import protobuf_unittest.UnittestProto.TestPackedTypes;
+import protobuf_unittest.UnittestProto.TestUnpackedTypes;
import protobuf_unittest.MultipleFilesTestProto;
import protobuf_unittest.MessageWithNoOuter;
import protobuf_unittest.EnumWithNoOuter;
@@ -303,8 +305,15 @@ public class GeneratedMessageTest extends TestCase {
TestUtil.assertClear(TestAllTypes.getDefaultInstance());
TestUtil.assertClear(TestAllTypes.newBuilder().build());
- assertEquals("\u1234",
- TestExtremeDefaultValues.getDefaultInstance().getUtf8String());
+ TestExtremeDefaultValues message =
+ TestExtremeDefaultValues.getDefaultInstance();
+ assertEquals("\u1234", message.getUtf8String());
+ assertEquals(Double.POSITIVE_INFINITY, message.getInfDouble());
+ assertEquals(Double.NEGATIVE_INFINITY, message.getNegInfDouble());
+ assertTrue(Double.isNaN(message.getNanDouble()));
+ assertEquals(Float.POSITIVE_INFINITY, message.getInfFloat());
+ assertEquals(Float.NEGATIVE_INFINITY, message.getNegInfFloat());
+ assertTrue(Float.isNaN(message.getNanFloat()));
}
public void testReflectionGetters() throws Exception {
@@ -361,6 +370,20 @@ public class GeneratedMessageTest extends TestCase {
assertTrue(map.findValueByNumber(12345) == null);
}
+ public void testParsePackedToUnpacked() throws Exception {
+ TestUnpackedTypes.Builder builder = TestUnpackedTypes.newBuilder();
+ TestUnpackedTypes message =
+ builder.mergeFrom(TestUtil.getPackedSet().toByteString()).build();
+ TestUtil.assertUnpackedFieldsSet(message);
+ }
+
+ public void testParseUnpackedToPacked() throws Exception {
+ TestPackedTypes.Builder builder = TestPackedTypes.newBuilder();
+ TestPackedTypes message =
+ builder.mergeFrom(TestUtil.getUnpackedSet().toByteString()).build();
+ TestUtil.assertPackedFieldsSet(message);
+ }
+
// =================================================================
// Extensions.
@@ -615,4 +638,12 @@ public class GeneratedMessageTest extends TestCase {
UnittestProto.REPEATED_NESTED_MESSAGE_EXTENSION_FIELD_NUMBER, 48);
assertEquals(UnittestProto.REPEATED_NESTED_ENUM_EXTENSION_FIELD_NUMBER, 51);
}
+
+ public void testRecursiveMessageDefaultInstance() throws Exception {
+ UnittestProto.TestRecursiveMessage message =
+ UnittestProto.TestRecursiveMessage.getDefaultInstance();
+ assertTrue(message != null);
+ assertTrue(message.getA() != null);
+ assertTrue(message.getA() == message);
+ }
}
diff --git a/java/src/test/java/com/google/protobuf/LiteTest.java b/java/src/test/java/com/google/protobuf/LiteTest.java
index 9dd730c..728bad9 100644
--- a/java/src/test/java/com/google/protobuf/LiteTest.java
+++ b/java/src/test/java/com/google/protobuf/LiteTest.java
@@ -83,7 +83,7 @@ public class LiteTest extends TestCase {
public void testLiteExtensions() throws Exception {
// TODO(kenton): Unlike other features of the lite library, extensions are
// implemented completely differently from the regular library. We
- // need to test them more thoroughly, once they are fully-implemented.
+ // should probably test them more thoroughly.
TestAllExtensionsLite message =
TestAllExtensionsLite.newBuilder()
@@ -104,6 +104,8 @@ public class LiteTest extends TestCase {
UnittestLite.optionalInt32ExtensionLite));
assertEquals(1, message2.getExtensionCount(
UnittestLite.repeatedStringExtensionLite));
+ assertEquals(1, message2.getExtension(
+ UnittestLite.repeatedStringExtensionLite).size());
assertEquals("hello", message2.getExtension(
UnittestLite.repeatedStringExtensionLite, 0));
assertEquals(TestAllTypesLite.NestedEnum.BAZ, message2.getExtension(
diff --git a/java/src/test/java/com/google/protobuf/MicroTest.java b/java/src/test/java/com/google/protobuf/MicroTest.java
deleted file mode 100644
index ebfccc2..0000000
--- a/java/src/test/java/com/google/protobuf/MicroTest.java
+++ /dev/null
@@ -1,2138 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc. All rights reserved.
-// 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;
-
-import com.google.protobuf.micro.MicroOuterClass;
-import com.google.protobuf.micro.MicroOuterClass.TestAllTypesMicro;
-import com.google.protobuf.micro.RecursiveMessageMicro;
-import com.google.protobuf.micro.SimpleMessageMicro;
-import com.google.protobuf.micro.StringUtf8;
-import com.google.protobuf.micro.StringUtf8Micro;
-import com.google.protobuf.micro.UnittestImportMicro;
-import com.google.protobuf.micro.ByteStringMicro;
-
-import junit.framework.TestCase;
-
-/**
- * Test micro runtime.
- *
- * @author wink@google.com Wink Saville
- */
-public class MicroTest extends TestCase {
- public void setUp() throws Exception {
- }
-
- public void testSimpleMessageMicro() throws Exception {
- SimpleMessageMicro msg = new SimpleMessageMicro();
- assertFalse(msg.hasD());
- assertEquals(123, msg.getD());
- assertFalse(msg.hasNestedMsg());
- assertEquals(null, msg.getNestedMsg());
- assertFalse(msg.hasDefaultNestedEnum());
- assertEquals(SimpleMessageMicro.BAZ, msg.getDefaultNestedEnum());
-
- msg.setD(456);
- assertTrue(msg.hasD());
- assertEquals(456, msg.getD());
- msg.clearD()
- .setD(456);
- assertTrue(msg.hasD());
-
- SimpleMessageMicro.NestedMessage nestedMsg = new SimpleMessageMicro.NestedMessage()
- .setBb(2);
- assertTrue(nestedMsg.hasBb());
- assertEquals(2, nestedMsg.getBb());
- msg.setNestedMsg(nestedMsg);
- assertTrue(msg.hasNestedMsg());
- assertEquals(2, msg.getNestedMsg().getBb());
-
- msg.setDefaultNestedEnum(SimpleMessageMicro.BAR);
- assertTrue(msg.hasDefaultNestedEnum());
- assertEquals(SimpleMessageMicro.BAR, msg.getDefaultNestedEnum());
-
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 9);
- assertEquals(result.length, msgSerializedSize);
-
- SimpleMessageMicro newMsg = SimpleMessageMicro.parseFrom(result);
- assertTrue(newMsg.hasD());
- assertTrue(newMsg.hasNestedMsg());
- assertTrue(newMsg.hasDefaultNestedEnum());
- assertEquals(456, newMsg.getD());
- assertEquals(2, msg.getNestedMsg().getBb());
- assertEquals(SimpleMessageMicro.BAR, msg.getDefaultNestedEnum());
- }
-
- public void testRecursiveMessageMicro() throws Exception {
- RecursiveMessageMicro msg = new RecursiveMessageMicro();
- assertFalse(msg.hasId());
- assertFalse(msg.hasNestedMessage());
- assertFalse(msg.hasOptionalRecursiveMessageMicro());
- assertEquals(0, msg.getRepeatedRecursiveMessageMicroCount());
-
- RecursiveMessageMicro msg1 = new RecursiveMessageMicro();
- msg1.setId(1);
- assertEquals(1, msg1.getId());
- RecursiveMessageMicro msg2 = new RecursiveMessageMicro();
- msg2.setId(2);
- RecursiveMessageMicro msg3 = new RecursiveMessageMicro();
- msg3.setId(3);
-
- RecursiveMessageMicro.NestedMessage nestedMsg = new RecursiveMessageMicro.NestedMessage();
- nestedMsg.setA(msg1);
- assertEquals(1, nestedMsg.getA().getId());
-
- msg.setId(0);
- msg.setNestedMessage(nestedMsg);
- msg.setOptionalRecursiveMessageMicro(msg2);
- msg.addRepeatedRecursiveMessageMicro(msg3);
-
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 16);
- assertEquals(result.length, msgSerializedSize);
-
- RecursiveMessageMicro newMsg = RecursiveMessageMicro.parseFrom(result);
- assertTrue(newMsg.hasId());
- assertTrue(newMsg.hasNestedMessage());
- assertTrue(newMsg.hasOptionalRecursiveMessageMicro());
- assertEquals(1, newMsg.getRepeatedRecursiveMessageMicroCount());
-
- assertEquals(0, newMsg.getId());
- assertEquals(1, newMsg.getNestedMessage().getA().getId());
- assertEquals(2, newMsg.getOptionalRecursiveMessageMicro().getId());
- assertEquals(3, newMsg.getRepeatedRecursiveMessageMicro(0).getId());
- }
-
- public void testMicroRequiredInt32() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasId());
- assertFalse(msg.isInitialized());
- msg.setId(123);
- assertTrue(msg.hasId());
- assertTrue(msg.isInitialized());
- assertEquals(123, msg.getId());
- msg.clearId();
- assertFalse(msg.hasId());
- assertFalse(msg.isInitialized());
- msg.clearId()
- .setId(456);
- assertTrue(msg.hasId());
- msg.clear();
- assertFalse(msg.hasId());
- assertFalse(msg.isInitialized());
-
- msg.setId(123);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasId());
- assertTrue(newMsg.isInitialized());
- assertEquals(123, newMsg.getId());
- }
-
- public void testMicroOptionalInt32() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalInt32());
- msg.setOptionalInt32(123);
- assertTrue(msg.hasOptionalInt32());
- assertEquals(123, msg.getOptionalInt32());
- msg.clearOptionalInt32();
- assertFalse(msg.hasOptionalInt32());
- msg.clearOptionalInt32()
- .setOptionalInt32(456);
- assertTrue(msg.hasOptionalInt32());
- msg.clear();
- assertFalse(msg.hasOptionalInt32());
-
- msg.setOptionalInt32(123);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 2);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalInt32());
- assertEquals(123, newMsg.getOptionalInt32());
- }
-
- public void testMicroOptionalInt64() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalInt64());
- msg.setOptionalInt64(123);
- assertTrue(msg.hasOptionalInt64());
- assertEquals(123, msg.getOptionalInt64());
- msg.clearOptionalInt64();
- assertFalse(msg.hasOptionalInt64());
- msg.clearOptionalInt64()
- .setOptionalInt64(456);
- assertTrue(msg.hasOptionalInt64());
- msg.clear();
- assertFalse(msg.hasOptionalInt64());
-
- msg.setOptionalInt64(123);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 2);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalInt64());
- assertEquals(123, newMsg.getOptionalInt64());
- }
-
- public void testMicroOptionalUint32() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalUint32());
- msg.setOptionalUint32(123);
- assertTrue(msg.hasOptionalUint32());
- assertEquals(123, msg.getOptionalUint32());
- msg.clearOptionalUint32();
- assertFalse(msg.hasOptionalUint32());
- msg.clearOptionalUint32()
- .setOptionalUint32(456);
- assertTrue(msg.hasOptionalUint32());
- msg.clear();
- assertFalse(msg.hasOptionalUint32());
-
- msg.setOptionalUint32(123);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 2);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalUint32());
- assertEquals(123, newMsg.getOptionalUint32());
- }
-
- public void testMicroOptionalUint64() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalUint64());
- msg.setOptionalUint64(123);
- assertTrue(msg.hasOptionalUint64());
- assertEquals(123, msg.getOptionalUint64());
- msg.clearOptionalUint64();
- assertFalse(msg.hasOptionalUint64());
- msg.clearOptionalUint64()
- .setOptionalUint64(456);
- assertTrue(msg.hasOptionalUint64());
- msg.clear();
- assertFalse(msg.hasOptionalUint64());
-
- msg.setOptionalUint64(123);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 2);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalUint64());
- assertEquals(123, newMsg.getOptionalUint64());
- }
-
- public void testMicroOptionalSint32() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalSint32());
- msg.setOptionalSint32(123);
- assertTrue(msg.hasOptionalSint32());
- assertEquals(123, msg.getOptionalSint32());
- msg.clearOptionalSint32();
- assertFalse(msg.hasOptionalSint32());
- msg.clearOptionalSint32()
- .setOptionalSint32(456);
- assertTrue(msg.hasOptionalSint32());
- msg.clear();
- assertFalse(msg.hasOptionalSint32());
-
- msg.setOptionalSint32(-123);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalSint32());
- assertEquals(-123, newMsg.getOptionalSint32());
- }
-
- public void testMicroOptionalSint64() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalSint64());
- msg.setOptionalSint64(123);
- assertTrue(msg.hasOptionalSint64());
- assertEquals(123, msg.getOptionalSint64());
- msg.clearOptionalSint64();
- assertFalse(msg.hasOptionalSint64());
- msg.clearOptionalSint64()
- .setOptionalSint64(456);
- assertTrue(msg.hasOptionalSint64());
- msg.clear();
- assertFalse(msg.hasOptionalSint64());
-
- msg.setOptionalSint64(-123);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalSint64());
- assertEquals(-123, newMsg.getOptionalSint64());
- }
-
- public void testMicroOptionalFixed32() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalFixed32());
- msg.setOptionalFixed32(123);
- assertTrue(msg.hasOptionalFixed32());
- assertEquals(123, msg.getOptionalFixed32());
- msg.clearOptionalFixed32();
- assertFalse(msg.hasOptionalFixed32());
- msg.clearOptionalFixed32()
- .setOptionalFixed32(456);
- assertTrue(msg.hasOptionalFixed32());
- msg.clear();
- assertFalse(msg.hasOptionalFixed32());
-
- msg.setOptionalFixed32(123);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 5);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalFixed32());
- assertEquals(123, newMsg.getOptionalFixed32());
- }
-
- public void testMicroOptionalFixed64() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalFixed64());
- msg.setOptionalFixed64(123);
- assertTrue(msg.hasOptionalFixed64());
- assertEquals(123, msg.getOptionalFixed64());
- msg.clearOptionalFixed64();
- assertFalse(msg.hasOptionalFixed64());
- msg.clearOptionalFixed64()
- .setOptionalFixed64(456);
- assertTrue(msg.hasOptionalFixed64());
- msg.clear();
- assertFalse(msg.hasOptionalFixed64());
-
- msg.setOptionalFixed64(123);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 9);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalFixed64());
- assertEquals(123, newMsg.getOptionalFixed64());
- }
- public void testMicroOptionalSfixed32() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalSfixed32());
- msg.setOptionalSfixed32(123);
- assertTrue(msg.hasOptionalSfixed32());
- assertEquals(123, msg.getOptionalSfixed32());
- msg.clearOptionalSfixed32();
- assertFalse(msg.hasOptionalSfixed32());
- msg.clearOptionalSfixed32()
- .setOptionalSfixed32(456);
- assertTrue(msg.hasOptionalSfixed32());
- msg.clear();
- assertFalse(msg.hasOptionalSfixed32());
-
- msg.setOptionalSfixed32(123);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 5);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalSfixed32());
- assertEquals(123, newMsg.getOptionalSfixed32());
- }
-
- public void testMicroOptionalSfixed64() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalSfixed64());
- msg.setOptionalSfixed64(123);
- assertTrue(msg.hasOptionalSfixed64());
- assertEquals(123, msg.getOptionalSfixed64());
- msg.clearOptionalSfixed64();
- assertFalse(msg.hasOptionalSfixed64());
- msg.clearOptionalSfixed64()
- .setOptionalSfixed64(456);
- assertTrue(msg.hasOptionalSfixed64());
- msg.clear();
- assertFalse(msg.hasOptionalSfixed64());
-
- msg.setOptionalSfixed64(-123);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 9);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalSfixed64());
- assertEquals(-123, newMsg.getOptionalSfixed64());
- }
-
- public void testMicroOptionalFloat() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalFloat());
- msg.setOptionalFloat(123f);
- assertTrue(msg.hasOptionalFloat());
- assertTrue(123.0f == msg.getOptionalFloat());
- msg.clearOptionalFloat();
- assertFalse(msg.hasOptionalFloat());
- msg.clearOptionalFloat()
- .setOptionalFloat(456.0f);
- assertTrue(msg.hasOptionalFloat());
- msg.clear();
- assertFalse(msg.hasOptionalFloat());
-
- msg.setOptionalFloat(-123.456f);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 5);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalFloat());
- assertTrue(-123.456f == newMsg.getOptionalFloat());
- }
-
- public void testMicroOptionalDouble() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalDouble());
- msg.setOptionalDouble(123);
- assertTrue(msg.hasOptionalDouble());
- assertTrue(123.0 == msg.getOptionalDouble());
- msg.clearOptionalDouble();
- assertFalse(msg.hasOptionalDouble());
- msg.clearOptionalDouble()
- .setOptionalDouble(456.0);
- assertTrue(msg.hasOptionalDouble());
- msg.clear();
- assertFalse(msg.hasOptionalDouble());
-
- msg.setOptionalDouble(-123.456);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 9);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalDouble());
- assertTrue(-123.456 == newMsg.getOptionalDouble());
- }
-
- public void testMicroOptionalBool() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalBool());
- msg.setOptionalBool(true);
- assertTrue(msg.hasOptionalBool());
- assertEquals(true, msg.getOptionalBool());
- msg.clearOptionalBool();
- assertFalse(msg.hasOptionalBool());
- msg.clearOptionalBool()
- .setOptionalBool(true);
- assertTrue(msg.hasOptionalBool());
- msg.clear();
- assertFalse(msg.hasOptionalBool());
-
- msg.setOptionalBool(false);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 2);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalBool());
- assertEquals(false, newMsg.getOptionalBool());
- }
-
- public void testMicroOptionalString() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalString());
- msg.setOptionalString("hello");
- assertTrue(msg.hasOptionalString());
- assertEquals("hello", msg.getOptionalString());
- msg.clearOptionalString();
- assertFalse(msg.hasOptionalString());
- msg.clearOptionalString()
- .setOptionalString("hello");
- assertTrue(msg.hasOptionalString());
- msg.clear();
- assertFalse(msg.hasOptionalString());
-
- msg.setOptionalString("bye");
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 5);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalString());
- assertEquals("bye", newMsg.getOptionalString());
- }
-
- public void testMicroOptionalBytes() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalBytes());
- msg.setOptionalBytes(ByteStringMicro.copyFromUtf8("hello"));
- assertTrue(msg.hasOptionalBytes());
- assertEquals("hello", msg.getOptionalBytes().toStringUtf8());
- msg.clearOptionalBytes();
- assertFalse(msg.hasOptionalBytes());
- msg.clearOptionalBytes()
- .setOptionalBytes(ByteStringMicro.copyFromUtf8("hello"));
- assertTrue(msg.hasOptionalBytes());
- msg.clear();
- assertFalse(msg.hasOptionalBytes());
-
- msg.setOptionalBytes(ByteStringMicro.copyFromUtf8("bye"));
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 5);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalBytes());
- assertEquals("bye", newMsg.getOptionalBytes().toStringUtf8());
- }
-
- public void testMicroOptionalGroup() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- TestAllTypesMicro.OptionalGroup grp = new TestAllTypesMicro.OptionalGroup();
- grp.setA(1);
- assertFalse(msg.hasOptionalGroup());
- msg.setOptionalGroup(grp);
- assertTrue(msg.hasOptionalGroup());
- assertEquals(1, msg.getOptionalGroup().getA());
- msg.clearOptionalGroup();
- assertFalse(msg.hasOptionalGroup());
- msg.clearOptionalGroup()
- .setOptionalGroup(new TestAllTypesMicro.OptionalGroup().setA(2));
- assertTrue(msg.hasOptionalGroup());
- msg.clear();
- assertFalse(msg.hasOptionalGroup());
-
- msg.setOptionalGroup(grp);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 7);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalGroup());
- assertEquals(1, newMsg.getOptionalGroup().getA());
- }
-
- public void testMicroOptionalNestedMessage() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- TestAllTypesMicro.NestedMessage nestedMsg = new TestAllTypesMicro.NestedMessage();
- nestedMsg.setBb(1);
- assertFalse(msg.hasOptionalNestedMessage());
- msg.setOptionalNestedMessage(nestedMsg);
- assertTrue(msg.hasOptionalNestedMessage());
- assertEquals(1, msg.getOptionalNestedMessage().getBb());
- msg.clearOptionalNestedMessage();
- assertFalse(msg.hasOptionalNestedMessage());
- msg.clearOptionalNestedMessage()
- .setOptionalNestedMessage(new TestAllTypesMicro.NestedMessage().setBb(2));
- assertTrue(msg.hasOptionalNestedMessage());
- msg.clear();
- assertFalse(msg.hasOptionalNestedMessage());
-
- msg.setOptionalNestedMessage(nestedMsg);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 5);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalNestedMessage());
- assertEquals(1, newMsg.getOptionalNestedMessage().getBb());
- }
-
- public void testMicroOptionalForeignMessage() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- MicroOuterClass.ForeignMessageMicro foreignMsg =
- new MicroOuterClass.ForeignMessageMicro();
- assertFalse(foreignMsg.hasC());
- foreignMsg.setC(1);
- assertTrue(foreignMsg.hasC());
- assertFalse(msg.hasOptionalForeignMessage());
- msg.setOptionalForeignMessage(foreignMsg);
- assertTrue(msg.hasOptionalForeignMessage());
- assertEquals(1, msg.getOptionalForeignMessage().getC());
- msg.clearOptionalForeignMessage();
- assertFalse(msg.hasOptionalForeignMessage());
- msg.clearOptionalForeignMessage()
- .setOptionalForeignMessage(new MicroOuterClass.ForeignMessageMicro().setC(2));
- assertTrue(msg.hasOptionalForeignMessage());
- msg.clear();
- assertFalse(msg.hasOptionalForeignMessage());
-
- msg.setOptionalForeignMessage(foreignMsg);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 5);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalForeignMessage());
- assertEquals(1, newMsg.getOptionalForeignMessage().getC());
- }
-
- public void testMicroOptionalImportMessage() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- UnittestImportMicro.ImportMessageMicro importMsg =
- new UnittestImportMicro.ImportMessageMicro();
- assertFalse(importMsg.hasD());
- importMsg.setD(1);
- assertTrue(importMsg.hasD());
- assertFalse(msg.hasOptionalImportMessage());
- msg.setOptionalImportMessage(importMsg);
- assertTrue(msg.hasOptionalImportMessage());
- assertEquals(1, msg.getOptionalImportMessage().getD());
- msg.clearOptionalImportMessage();
- assertFalse(msg.hasOptionalImportMessage());
- msg.clearOptionalImportMessage()
- .setOptionalImportMessage(new UnittestImportMicro.ImportMessageMicro().setD(2));
- assertTrue(msg.hasOptionalImportMessage());
- msg.clear();
- assertFalse(msg.hasOptionalImportMessage());
-
- msg.setOptionalImportMessage(importMsg);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 5);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalImportMessage());
- assertEquals(1, newMsg.getOptionalImportMessage().getD());
- }
-
- public void testMicroOptionalNestedEnum() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- msg.setOptionalNestedEnum(TestAllTypesMicro.BAR);
- assertTrue(msg.hasOptionalNestedEnum());
- assertEquals(TestAllTypesMicro.BAR, msg.getOptionalNestedEnum());
- msg.clearOptionalNestedEnum();
- assertFalse(msg.hasOptionalNestedEnum());
- msg.clearOptionalNestedEnum()
- .setOptionalNestedEnum(TestAllTypesMicro.BAZ);
- assertTrue(msg.hasOptionalNestedEnum());
- msg.clear();
- assertFalse(msg.hasOptionalNestedEnum());
-
- msg.setOptionalNestedEnum(TestAllTypesMicro.BAR);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalNestedEnum());
- assertEquals(TestAllTypesMicro.BAR, newMsg.getOptionalNestedEnum());
- }
-
- public void testMicroOptionalForeignEnum() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- msg.setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
- assertTrue(msg.hasOptionalForeignEnum());
- assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR,
- msg.getOptionalForeignEnum());
- msg.clearOptionalForeignEnum();
- assertFalse(msg.hasOptionalForeignEnum());
- msg.clearOptionalForeignEnum()
- .setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAZ);
- assertTrue(msg.hasOptionalForeignEnum());
- msg.clear();
- assertFalse(msg.hasOptionalForeignEnum());
-
- msg.setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalForeignEnum());
- assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR,
- newMsg.getOptionalForeignEnum());
- }
-
- public void testMicroOptionalImportEnum() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- msg.setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
- assertTrue(msg.hasOptionalImportEnum());
- assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR,
- msg.getOptionalImportEnum());
- msg.clearOptionalImportEnum();
- assertFalse(msg.hasOptionalImportEnum());
- msg.clearOptionalImportEnum()
- .setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAZ);
- assertTrue(msg.hasOptionalImportEnum());
- msg.clear();
- assertFalse(msg.hasOptionalImportEnum());
-
- msg.setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalImportEnum());
- assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR,
- newMsg.getOptionalImportEnum());
- }
-
- public void testMicroOptionalStringPiece() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalStringPiece());
- msg.setOptionalStringPiece("hello");
- assertTrue(msg.hasOptionalStringPiece());
- assertEquals("hello", msg.getOptionalStringPiece());
- msg.clearOptionalStringPiece();
- assertFalse(msg.hasOptionalStringPiece());
- msg.clearOptionalStringPiece()
- .setOptionalStringPiece("hello");
- assertTrue(msg.hasOptionalStringPiece());
- msg.clear();
- assertFalse(msg.hasOptionalStringPiece());
-
- msg.setOptionalStringPiece("bye");
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 6);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalStringPiece());
- assertEquals("bye", newMsg.getOptionalStringPiece());
- }
-
- public void testMicroOptionalCord() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasOptionalCord());
- msg.setOptionalCord("hello");
- assertTrue(msg.hasOptionalCord());
- assertEquals("hello", msg.getOptionalCord());
- msg.clearOptionalCord();
- assertFalse(msg.hasOptionalCord());
- msg.clearOptionalCord()
- .setOptionalCord("hello");
- assertTrue(msg.hasOptionalCord());
- msg.clear();
- assertFalse(msg.hasOptionalCord());
-
- msg.setOptionalCord("bye");
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 6);
- assertEquals(result.length, msgSerializedSize);
-
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertTrue(newMsg.hasOptionalCord());
- assertEquals("bye", newMsg.getOptionalCord());
- }
-
- public void testMicroRepeatedInt32() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedInt32Count());
- msg.addRepeatedInt32(123);
- assertEquals(1, msg.getRepeatedInt32Count());
- assertEquals(123, msg.getRepeatedInt32(0));
- msg.addRepeatedInt32(456);
- assertEquals(2, msg.getRepeatedInt32Count());
- assertEquals(123, msg.getRepeatedInt32(0));
- assertEquals(456, msg.getRepeatedInt32(1));
- msg.setRepeatedInt32(0, 789);
- assertEquals(2, msg.getRepeatedInt32Count());
- assertEquals(789, msg.getRepeatedInt32(0));
- assertEquals(456, msg.getRepeatedInt32(1));
- msg.clearRepeatedInt32();
- assertEquals(0, msg.getRepeatedInt32Count());
- msg.clearRepeatedInt32()
- .addRepeatedInt32(456);
- assertEquals(1, msg.getRepeatedInt32Count());
- assertEquals(456, msg.getRepeatedInt32(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedInt32Count());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedInt32(123);
- assertEquals(1, msg.getRepeatedInt32Count());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedInt32Count());
- assertEquals(123, newMsg.getRepeatedInt32(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedInt32(123)
- .addRepeatedInt32(456);
- assertEquals(2, msg.getRepeatedInt32Count());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 7);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedInt32Count());
- assertEquals(123, newMsg.getRepeatedInt32(0));
- assertEquals(456, newMsg.getRepeatedInt32(1));
- }
-
- public void testMicroRepeatedInt64() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedInt64Count());
- msg.addRepeatedInt64(123);
- assertEquals(1, msg.getRepeatedInt64Count());
- assertEquals(123, msg.getRepeatedInt64(0));
- msg.addRepeatedInt64(456);
- assertEquals(2, msg.getRepeatedInt64Count());
- assertEquals(123, msg.getRepeatedInt64(0));
- assertEquals(456, msg.getRepeatedInt64(1));
- msg.setRepeatedInt64(0, 789);
- assertEquals(2, msg.getRepeatedInt64Count());
- assertEquals(789, msg.getRepeatedInt64(0));
- assertEquals(456, msg.getRepeatedInt64(1));
- msg.clearRepeatedInt64();
- assertEquals(0, msg.getRepeatedInt64Count());
- msg.clearRepeatedInt64()
- .addRepeatedInt64(456);
- assertEquals(1, msg.getRepeatedInt64Count());
- assertEquals(456, msg.getRepeatedInt64(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedInt64Count());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedInt64(123);
- assertEquals(1, msg.getRepeatedInt64Count());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedInt64Count());
- assertEquals(123, newMsg.getRepeatedInt64(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedInt64(123)
- .addRepeatedInt64(456);
- assertEquals(2, msg.getRepeatedInt64Count());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 7);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedInt64Count());
- assertEquals(123, newMsg.getRepeatedInt64(0));
- assertEquals(456, newMsg.getRepeatedInt64(1));
- }
-
- public void testMicroRepeatedUint32() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedUint32Count());
- msg.addRepeatedUint32(123);
- assertEquals(1, msg.getRepeatedUint32Count());
- assertEquals(123, msg.getRepeatedUint32(0));
- msg.addRepeatedUint32(456);
- assertEquals(2, msg.getRepeatedUint32Count());
- assertEquals(123, msg.getRepeatedUint32(0));
- assertEquals(456, msg.getRepeatedUint32(1));
- msg.setRepeatedUint32(0, 789);
- assertEquals(2, msg.getRepeatedUint32Count());
- assertEquals(789, msg.getRepeatedUint32(0));
- assertEquals(456, msg.getRepeatedUint32(1));
- msg.clearRepeatedUint32();
- assertEquals(0, msg.getRepeatedUint32Count());
- msg.clearRepeatedUint32()
- .addRepeatedUint32(456);
- assertEquals(1, msg.getRepeatedUint32Count());
- assertEquals(456, msg.getRepeatedUint32(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedUint32Count());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedUint32(123);
- assertEquals(1, msg.getRepeatedUint32Count());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedUint32Count());
- assertEquals(123, newMsg.getRepeatedUint32(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedUint32(123)
- .addRepeatedUint32(456);
- assertEquals(2, msg.getRepeatedUint32Count());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 7);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedUint32Count());
- assertEquals(123, newMsg.getRepeatedUint32(0));
- assertEquals(456, newMsg.getRepeatedUint32(1));
- }
-
- public void testMicroRepeatedUint64() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedUint64Count());
- msg.addRepeatedUint64(123);
- assertEquals(1, msg.getRepeatedUint64Count());
- assertEquals(123, msg.getRepeatedUint64(0));
- msg.addRepeatedUint64(456);
- assertEquals(2, msg.getRepeatedUint64Count());
- assertEquals(123, msg.getRepeatedUint64(0));
- assertEquals(456, msg.getRepeatedUint64(1));
- msg.setRepeatedUint64(0, 789);
- assertEquals(2, msg.getRepeatedUint64Count());
- assertEquals(789, msg.getRepeatedUint64(0));
- assertEquals(456, msg.getRepeatedUint64(1));
- msg.clearRepeatedUint64();
- assertEquals(0, msg.getRepeatedUint64Count());
- msg.clearRepeatedUint64()
- .addRepeatedUint64(456);
- assertEquals(1, msg.getRepeatedUint64Count());
- assertEquals(456, msg.getRepeatedUint64(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedUint64Count());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedUint64(123);
- assertEquals(1, msg.getRepeatedUint64Count());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedUint64Count());
- assertEquals(123, newMsg.getRepeatedUint64(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedUint64(123)
- .addRepeatedUint64(456);
- assertEquals(2, msg.getRepeatedUint64Count());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 7);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedUint64Count());
- assertEquals(123, newMsg.getRepeatedUint64(0));
- assertEquals(456, newMsg.getRepeatedUint64(1));
- }
-
- public void testMicroRepeatedSint32() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedSint32Count());
- msg.addRepeatedSint32(123);
- assertEquals(1, msg.getRepeatedSint32Count());
- assertEquals(123, msg.getRepeatedSint32(0));
- msg.addRepeatedSint32(456);
- assertEquals(2, msg.getRepeatedSint32Count());
- assertEquals(123, msg.getRepeatedSint32(0));
- assertEquals(456, msg.getRepeatedSint32(1));
- msg.setRepeatedSint32(0, 789);
- assertEquals(2, msg.getRepeatedSint32Count());
- assertEquals(789, msg.getRepeatedSint32(0));
- assertEquals(456, msg.getRepeatedSint32(1));
- msg.clearRepeatedSint32();
- assertEquals(0, msg.getRepeatedSint32Count());
- msg.clearRepeatedSint32()
- .addRepeatedSint32(456);
- assertEquals(1, msg.getRepeatedSint32Count());
- assertEquals(456, msg.getRepeatedSint32(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedSint32Count());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedSint32(123);
- assertEquals(1, msg.getRepeatedSint32Count());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 4);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedSint32Count());
- assertEquals(123, newMsg.getRepeatedSint32(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedSint32(123)
- .addRepeatedSint32(456);
- assertEquals(2, msg.getRepeatedSint32Count());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 8);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedSint32Count());
- assertEquals(123, newMsg.getRepeatedSint32(0));
- assertEquals(456, newMsg.getRepeatedSint32(1));
- }
-
- public void testMicroRepeatedSint64() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedSint64Count());
- msg.addRepeatedSint64(123);
- assertEquals(1, msg.getRepeatedSint64Count());
- assertEquals(123, msg.getRepeatedSint64(0));
- msg.addRepeatedSint64(456);
- assertEquals(2, msg.getRepeatedSint64Count());
- assertEquals(123, msg.getRepeatedSint64(0));
- assertEquals(456, msg.getRepeatedSint64(1));
- msg.setRepeatedSint64(0, 789);
- assertEquals(2, msg.getRepeatedSint64Count());
- assertEquals(789, msg.getRepeatedSint64(0));
- assertEquals(456, msg.getRepeatedSint64(1));
- msg.clearRepeatedSint64();
- assertEquals(0, msg.getRepeatedSint64Count());
- msg.clearRepeatedSint64()
- .addRepeatedSint64(456);
- assertEquals(1, msg.getRepeatedSint64Count());
- assertEquals(456, msg.getRepeatedSint64(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedSint64Count());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedSint64(123);
- assertEquals(1, msg.getRepeatedSint64Count());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 4);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedSint64Count());
- assertEquals(123, newMsg.getRepeatedSint64(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedSint64(123)
- .addRepeatedSint64(456);
- assertEquals(2, msg.getRepeatedSint64Count());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 8);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedSint64Count());
- assertEquals(123, newMsg.getRepeatedSint64(0));
- assertEquals(456, newMsg.getRepeatedSint64(1));
- }
-
- public void testMicroRepeatedFixed32() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedFixed32Count());
- msg.addRepeatedFixed32(123);
- assertEquals(1, msg.getRepeatedFixed32Count());
- assertEquals(123, msg.getRepeatedFixed32(0));
- msg.addRepeatedFixed32(456);
- assertEquals(2, msg.getRepeatedFixed32Count());
- assertEquals(123, msg.getRepeatedFixed32(0));
- assertEquals(456, msg.getRepeatedFixed32(1));
- msg.setRepeatedFixed32(0, 789);
- assertEquals(2, msg.getRepeatedFixed32Count());
- assertEquals(789, msg.getRepeatedFixed32(0));
- assertEquals(456, msg.getRepeatedFixed32(1));
- msg.clearRepeatedFixed32();
- assertEquals(0, msg.getRepeatedFixed32Count());
- msg.clearRepeatedFixed32()
- .addRepeatedFixed32(456);
- assertEquals(1, msg.getRepeatedFixed32Count());
- assertEquals(456, msg.getRepeatedFixed32(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedFixed32Count());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedFixed32(123);
- assertEquals(1, msg.getRepeatedFixed32Count());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 6);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedFixed32Count());
- assertEquals(123, newMsg.getRepeatedFixed32(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedFixed32(123)
- .addRepeatedFixed32(456);
- assertEquals(2, msg.getRepeatedFixed32Count());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 12);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedFixed32Count());
- assertEquals(123, newMsg.getRepeatedFixed32(0));
- assertEquals(456, newMsg.getRepeatedFixed32(1));
- }
-
- public void testMicroRepeatedFixed64() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedFixed64Count());
- msg.addRepeatedFixed64(123);
- assertEquals(1, msg.getRepeatedFixed64Count());
- assertEquals(123, msg.getRepeatedFixed64(0));
- msg.addRepeatedFixed64(456);
- assertEquals(2, msg.getRepeatedFixed64Count());
- assertEquals(123, msg.getRepeatedFixed64(0));
- assertEquals(456, msg.getRepeatedFixed64(1));
- msg.setRepeatedFixed64(0, 789);
- assertEquals(2, msg.getRepeatedFixed64Count());
- assertEquals(789, msg.getRepeatedFixed64(0));
- assertEquals(456, msg.getRepeatedFixed64(1));
- msg.clearRepeatedFixed64();
- assertEquals(0, msg.getRepeatedFixed64Count());
- msg.clearRepeatedFixed64()
- .addRepeatedFixed64(456);
- assertEquals(1, msg.getRepeatedFixed64Count());
- assertEquals(456, msg.getRepeatedFixed64(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedFixed64Count());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedFixed64(123);
- assertEquals(1, msg.getRepeatedFixed64Count());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 10);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedFixed64Count());
- assertEquals(123, newMsg.getRepeatedFixed64(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedFixed64(123)
- .addRepeatedFixed64(456);
- assertEquals(2, msg.getRepeatedFixed64Count());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 20);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedFixed64Count());
- assertEquals(123, newMsg.getRepeatedFixed64(0));
- assertEquals(456, newMsg.getRepeatedFixed64(1));
- }
-
- public void testMicroRepeatedSfixed32() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedSfixed32Count());
- msg.addRepeatedSfixed32(123);
- assertEquals(1, msg.getRepeatedSfixed32Count());
- assertEquals(123, msg.getRepeatedSfixed32(0));
- msg.addRepeatedSfixed32(456);
- assertEquals(2, msg.getRepeatedSfixed32Count());
- assertEquals(123, msg.getRepeatedSfixed32(0));
- assertEquals(456, msg.getRepeatedSfixed32(1));
- msg.setRepeatedSfixed32(0, 789);
- assertEquals(2, msg.getRepeatedSfixed32Count());
- assertEquals(789, msg.getRepeatedSfixed32(0));
- assertEquals(456, msg.getRepeatedSfixed32(1));
- msg.clearRepeatedSfixed32();
- assertEquals(0, msg.getRepeatedSfixed32Count());
- msg.clearRepeatedSfixed32()
- .addRepeatedSfixed32(456);
- assertEquals(1, msg.getRepeatedSfixed32Count());
- assertEquals(456, msg.getRepeatedSfixed32(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedSfixed32Count());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedSfixed32(123);
- assertEquals(1, msg.getRepeatedSfixed32Count());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 6);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedSfixed32Count());
- assertEquals(123, newMsg.getRepeatedSfixed32(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedSfixed32(123)
- .addRepeatedSfixed32(456);
- assertEquals(2, msg.getRepeatedSfixed32Count());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 12);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedSfixed32Count());
- assertEquals(123, newMsg.getRepeatedSfixed32(0));
- assertEquals(456, newMsg.getRepeatedSfixed32(1));
- }
-
- public void testMicroRepeatedSfixed64() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedSfixed64Count());
- msg.addRepeatedSfixed64(123);
- assertEquals(1, msg.getRepeatedSfixed64Count());
- assertEquals(123, msg.getRepeatedSfixed64(0));
- msg.addRepeatedSfixed64(456);
- assertEquals(2, msg.getRepeatedSfixed64Count());
- assertEquals(123, msg.getRepeatedSfixed64(0));
- assertEquals(456, msg.getRepeatedSfixed64(1));
- msg.setRepeatedSfixed64(0, 789);
- assertEquals(2, msg.getRepeatedSfixed64Count());
- assertEquals(789, msg.getRepeatedSfixed64(0));
- assertEquals(456, msg.getRepeatedSfixed64(1));
- msg.clearRepeatedSfixed64();
- assertEquals(0, msg.getRepeatedSfixed64Count());
- msg.clearRepeatedSfixed64()
- .addRepeatedSfixed64(456);
- assertEquals(1, msg.getRepeatedSfixed64Count());
- assertEquals(456, msg.getRepeatedSfixed64(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedSfixed64Count());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedSfixed64(123);
- assertEquals(1, msg.getRepeatedSfixed64Count());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 10);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedSfixed64Count());
- assertEquals(123, newMsg.getRepeatedSfixed64(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedSfixed64(123)
- .addRepeatedSfixed64(456);
- assertEquals(2, msg.getRepeatedSfixed64Count());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 20);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedSfixed64Count());
- assertEquals(123, newMsg.getRepeatedSfixed64(0));
- assertEquals(456, newMsg.getRepeatedSfixed64(1));
- }
-
- public void testMicroRepeatedFloat() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedFloatCount());
- msg.addRepeatedFloat(123f);
- assertEquals(1, msg.getRepeatedFloatCount());
- assertTrue(123f == msg.getRepeatedFloat(0));
- msg.addRepeatedFloat(456f);
- assertEquals(2, msg.getRepeatedFloatCount());
- assertTrue(123f == msg.getRepeatedFloat(0));
- assertTrue(456f == msg.getRepeatedFloat(1));
- msg.setRepeatedFloat(0, 789f);
- assertEquals(2, msg.getRepeatedFloatCount());
- assertTrue(789f == msg.getRepeatedFloat(0));
- assertTrue(456f == msg.getRepeatedFloat(1));
- msg.clearRepeatedFloat();
- assertEquals(0, msg.getRepeatedFloatCount());
- msg.clearRepeatedFloat()
- .addRepeatedFloat(456f);
- assertEquals(1, msg.getRepeatedFloatCount());
- assertTrue(456f == msg.getRepeatedFloat(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedFloatCount());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedFloat(123f);
- assertEquals(1, msg.getRepeatedFloatCount());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 6);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedFloatCount());
- assertTrue(123f == newMsg.getRepeatedFloat(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedFloat(123f)
- .addRepeatedFloat(456f);
- assertEquals(2, msg.getRepeatedFloatCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 12);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedFloatCount());
- assertTrue(123f == newMsg.getRepeatedFloat(0));
- assertTrue(456f == newMsg.getRepeatedFloat(1));
- }
-
- public void testMicroRepeatedDouble() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedDoubleCount());
- msg.addRepeatedDouble(123.0);
- assertEquals(1, msg.getRepeatedDoubleCount());
- assertTrue(123.0 == msg.getRepeatedDouble(0));
- msg.addRepeatedDouble(456.0);
- assertEquals(2, msg.getRepeatedDoubleCount());
- assertTrue(123.0 == msg.getRepeatedDouble(0));
- assertTrue(456.0 == msg.getRepeatedDouble(1));
- msg.setRepeatedDouble(0, 789.0);
- assertEquals(2, msg.getRepeatedDoubleCount());
- assertTrue(789.0 == msg.getRepeatedDouble(0));
- assertTrue(456.0 == msg.getRepeatedDouble(1));
- msg.clearRepeatedDouble();
- assertEquals(0, msg.getRepeatedDoubleCount());
- msg.clearRepeatedDouble()
- .addRepeatedDouble(456.0);
- assertEquals(1, msg.getRepeatedDoubleCount());
- assertTrue(456.0 == msg.getRepeatedDouble(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedDoubleCount());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedDouble(123.0);
- assertEquals(1, msg.getRepeatedDoubleCount());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 10);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedDoubleCount());
- assertTrue(123.0 == newMsg.getRepeatedDouble(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedDouble(123.0)
- .addRepeatedDouble(456.0);
- assertEquals(2, msg.getRepeatedDoubleCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 20);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedDoubleCount());
- assertTrue(123.0 == newMsg.getRepeatedDouble(0));
- assertTrue(456.0 == newMsg.getRepeatedDouble(1));
- }
-
- public void testMicroRepeatedBool() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedBoolCount());
- msg.addRepeatedBool(true);
- assertEquals(1, msg.getRepeatedBoolCount());
- assertEquals(true, msg.getRepeatedBool(0));
- msg.addRepeatedBool(false);
- assertEquals(2, msg.getRepeatedBoolCount());
- assertEquals(true, msg.getRepeatedBool(0));
- assertEquals(false, msg.getRepeatedBool(1));
- msg.setRepeatedBool(0, false);
- assertEquals(2, msg.getRepeatedBoolCount());
- assertEquals(false, msg.getRepeatedBool(0));
- assertEquals(false, msg.getRepeatedBool(1));
- msg.clearRepeatedBool();
- assertEquals(0, msg.getRepeatedBoolCount());
- msg.clearRepeatedBool()
- .addRepeatedBool(true);
- assertEquals(1, msg.getRepeatedBoolCount());
- assertEquals(true, msg.getRepeatedBool(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedBoolCount());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedBool(false);
- assertEquals(1, msg.getRepeatedBoolCount());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedBoolCount());
- assertEquals(false, newMsg.getRepeatedBool(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedBool(true)
- .addRepeatedBool(false);
- assertEquals(2, msg.getRepeatedBoolCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 6);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedBoolCount());
- assertEquals(true, newMsg.getRepeatedBool(0));
- assertEquals(false, newMsg.getRepeatedBool(1));
- }
-
- public void testMicroRepeatedString() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedStringCount());
- msg.addRepeatedString("hello");
- assertEquals(1, msg.getRepeatedStringCount());
- assertEquals("hello", msg.getRepeatedString(0));
- msg.addRepeatedString("bye");
- assertEquals(2, msg.getRepeatedStringCount());
- assertEquals("hello", msg.getRepeatedString(0));
- assertEquals("bye", msg.getRepeatedString(1));
- msg.setRepeatedString(0, "boo");
- assertEquals(2, msg.getRepeatedStringCount());
- assertEquals("boo", msg.getRepeatedString(0));
- assertEquals("bye", msg.getRepeatedString(1));
- msg.clearRepeatedString();
- assertEquals(0, msg.getRepeatedStringCount());
- msg.clearRepeatedString()
- .addRepeatedString("hello");
- assertEquals(1, msg.getRepeatedStringCount());
- assertEquals("hello", msg.getRepeatedString(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedStringCount());
-
- // Test 1 entry and an empty string
- msg.clear()
- .addRepeatedString("");
- assertEquals(1, msg.getRepeatedStringCount());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedStringCount());
- assertEquals("", newMsg.getRepeatedString(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedString("hello")
- .addRepeatedString("world");
- assertEquals(2, msg.getRepeatedStringCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 16);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedStringCount());
- assertEquals("hello", newMsg.getRepeatedString(0));
- assertEquals("world", newMsg.getRepeatedString(1));
- }
-
- public void testMicroRepeatedBytes() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedBytesCount());
- msg.addRepeatedBytes(ByteStringMicro.copyFromUtf8("hello"));
- assertEquals(1, msg.getRepeatedBytesCount());
- assertEquals("hello", msg.getRepeatedBytes(0).toStringUtf8());
- msg.addRepeatedBytes(ByteStringMicro.copyFromUtf8("bye"));
- assertEquals(2, msg.getRepeatedBytesCount());
- assertEquals("hello", msg.getRepeatedBytes(0).toStringUtf8());
- assertEquals("bye", msg.getRepeatedBytes(1).toStringUtf8());
- msg.setRepeatedBytes(0, ByteStringMicro.copyFromUtf8("boo"));
- assertEquals(2, msg.getRepeatedBytesCount());
- assertEquals("boo", msg.getRepeatedBytes(0).toStringUtf8());
- assertEquals("bye", msg.getRepeatedBytes(1).toStringUtf8());
- msg.clearRepeatedBytes();
- assertEquals(0, msg.getRepeatedBytesCount());
- msg.clearRepeatedBytes()
- .addRepeatedBytes(ByteStringMicro.copyFromUtf8("hello"));
- assertEquals(1, msg.getRepeatedBytesCount());
- assertEquals("hello", msg.getRepeatedBytes(0).toStringUtf8());
- msg.clear();
- assertEquals(0, msg.getRepeatedBytesCount());
-
- // Test 1 entry and an empty byte array can be serialized
- msg.clear()
- .addRepeatedBytes(ByteStringMicro.copyFromUtf8(""));
- assertEquals(1, msg.getRepeatedBytesCount());
- assertEquals("", msg.getRepeatedBytes(0).toStringUtf8());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedBytesCount());
- assertEquals("", newMsg.getRepeatedBytes(0).toStringUtf8());
-
- // Test 2 entries
- msg.clear()
- .addRepeatedBytes(ByteStringMicro.copyFromUtf8("hello"))
- .addRepeatedBytes(ByteStringMicro.copyFromUtf8("world"));
- assertEquals(2, msg.getRepeatedBytesCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 16);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedBytesCount());
- assertEquals("hello", newMsg.getRepeatedBytes(0).toStringUtf8());
- assertEquals("world", newMsg.getRepeatedBytes(1).toStringUtf8());
- }
-
- public void testMicroRepeatedGroup() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- TestAllTypesMicro.RepeatedGroup group0 =
- new TestAllTypesMicro.RepeatedGroup().setA(0);
- TestAllTypesMicro.RepeatedGroup group1 =
- new TestAllTypesMicro.RepeatedGroup().setA(1);
- TestAllTypesMicro.RepeatedGroup group2 =
- new TestAllTypesMicro.RepeatedGroup().setA(2);
-
- msg.addRepeatedGroup(group0);
- assertEquals(1, msg.getRepeatedGroupCount());
- assertEquals(0, msg.getRepeatedGroup(0).getA());
- msg.addRepeatedGroup(group1);
- assertEquals(2, msg.getRepeatedGroupCount());
- assertEquals(0, msg.getRepeatedGroup(0).getA());
- assertEquals(1, msg.getRepeatedGroup(1).getA());
- msg.setRepeatedGroup(0, group2);
- assertEquals(2, msg.getRepeatedGroupCount());
- assertEquals(2, msg.getRepeatedGroup(0).getA());
- assertEquals(1, msg.getRepeatedGroup(1).getA());
- msg.clearRepeatedGroup();
- assertEquals(0, msg.getRepeatedGroupCount());
- msg.clearRepeatedGroup()
- .addRepeatedGroup(group1);
- assertEquals(1, msg.getRepeatedGroupCount());
- assertEquals(1, msg.getRepeatedGroup(0).getA());
- msg.clear();
- assertEquals(0, msg.getRepeatedGroupCount());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedGroup(group0);
- assertEquals(1, msg.getRepeatedGroupCount());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 7);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedGroupCount());
- assertEquals(0, newMsg.getRepeatedGroup(0).getA());
-
- // Test 2 entries
- msg.clear()
- .addRepeatedGroup(group0)
- .addRepeatedGroup(group1);
- assertEquals(2, msg.getRepeatedGroupCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 14);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedGroupCount());
- assertEquals(0, newMsg.getRepeatedGroup(0).getA());
- assertEquals(1, newMsg.getRepeatedGroup(1).getA());
- }
-
-
- public void testMicroRepeatedNestedMessage() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- TestAllTypesMicro.NestedMessage nestedMsg0 =
- new TestAllTypesMicro.NestedMessage().setBb(0);
- TestAllTypesMicro.NestedMessage nestedMsg1 =
- new TestAllTypesMicro.NestedMessage().setBb(1);
- TestAllTypesMicro.NestedMessage nestedMsg2 =
- new TestAllTypesMicro.NestedMessage().setBb(2);
-
- msg.addRepeatedNestedMessage(nestedMsg0);
- assertEquals(1, msg.getRepeatedNestedMessageCount());
- assertEquals(0, msg.getRepeatedNestedMessage(0).getBb());
- msg.addRepeatedNestedMessage(nestedMsg1);
- assertEquals(2, msg.getRepeatedNestedMessageCount());
- assertEquals(0, msg.getRepeatedNestedMessage(0).getBb());
- assertEquals(1, msg.getRepeatedNestedMessage(1).getBb());
- msg.setRepeatedNestedMessage(0, nestedMsg2);
- assertEquals(2, msg.getRepeatedNestedMessageCount());
- assertEquals(2, msg.getRepeatedNestedMessage(0).getBb());
- assertEquals(1, msg.getRepeatedNestedMessage(1).getBb());
- msg.clearRepeatedNestedMessage();
- assertEquals(0, msg.getRepeatedNestedMessageCount());
- msg.clearRepeatedNestedMessage()
- .addRepeatedNestedMessage(nestedMsg1);
- assertEquals(1, msg.getRepeatedNestedMessageCount());
- assertEquals(1, msg.getRepeatedNestedMessage(0).getBb());
- msg.clear();
- assertEquals(0, msg.getRepeatedNestedMessageCount());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedNestedMessage(nestedMsg0);
- assertEquals(1, msg.getRepeatedNestedMessageCount());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 5);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedNestedMessageCount());
- assertEquals(0, newMsg.getRepeatedNestedMessage(0).getBb());
-
- // Test 2 entries
- msg.clear()
- .addRepeatedNestedMessage(nestedMsg0)
- .addRepeatedNestedMessage(nestedMsg1);
- assertEquals(2, msg.getRepeatedNestedMessageCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 10);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedNestedMessageCount());
- assertEquals(0, newMsg.getRepeatedNestedMessage(0).getBb());
- assertEquals(1, newMsg.getRepeatedNestedMessage(1).getBb());
- }
-
- public void testMicroRepeatedForeignMessage() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- MicroOuterClass.ForeignMessageMicro foreignMsg0 =
- new MicroOuterClass.ForeignMessageMicro().setC(0);
- MicroOuterClass.ForeignMessageMicro foreignMsg1 =
- new MicroOuterClass.ForeignMessageMicro().setC(1);
- MicroOuterClass.ForeignMessageMicro foreignMsg2 =
- new MicroOuterClass.ForeignMessageMicro().setC(2);
-
- msg.addRepeatedForeignMessage(foreignMsg0);
- assertEquals(1, msg.getRepeatedForeignMessageCount());
- assertEquals(0, msg.getRepeatedForeignMessage(0).getC());
- msg.addRepeatedForeignMessage(foreignMsg1);
- assertEquals(2, msg.getRepeatedForeignMessageCount());
- assertEquals(0, msg.getRepeatedForeignMessage(0).getC());
- assertEquals(1, msg.getRepeatedForeignMessage(1).getC());
- msg.setRepeatedForeignMessage(0, foreignMsg2);
- assertEquals(2, msg.getRepeatedForeignMessageCount());
- assertEquals(2, msg.getRepeatedForeignMessage(0).getC());
- assertEquals(1, msg.getRepeatedForeignMessage(1).getC());
- msg.clearRepeatedForeignMessage();
- assertEquals(0, msg.getRepeatedForeignMessageCount());
- msg.clearRepeatedForeignMessage()
- .addRepeatedForeignMessage(foreignMsg1);
- assertEquals(1, msg.getRepeatedForeignMessageCount());
- assertEquals(1, msg.getRepeatedForeignMessage(0).getC());
- msg.clear();
- assertEquals(0, msg.getRepeatedForeignMessageCount());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedForeignMessage(foreignMsg0);
- assertEquals(1, msg.getRepeatedForeignMessageCount());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 5);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedForeignMessageCount());
- assertEquals(0, newMsg.getRepeatedForeignMessage(0).getC());
-
- // Test 2 entries
- msg.clear()
- .addRepeatedForeignMessage(foreignMsg0)
- .addRepeatedForeignMessage(foreignMsg1);
- assertEquals(2, msg.getRepeatedForeignMessageCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 10);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedForeignMessageCount());
- assertEquals(0, newMsg.getRepeatedForeignMessage(0).getC());
- assertEquals(1, newMsg.getRepeatedForeignMessage(1).getC());
- }
-
- public void testMicroRepeatedImportMessage() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- UnittestImportMicro.ImportMessageMicro importMsg0 =
- new UnittestImportMicro.ImportMessageMicro().setD(0);
- UnittestImportMicro.ImportMessageMicro importMsg1 =
- new UnittestImportMicro.ImportMessageMicro().setD(1);
- UnittestImportMicro.ImportMessageMicro importMsg2 =
- new UnittestImportMicro.ImportMessageMicro().setD(2);
-
- msg.addRepeatedImportMessage(importMsg0);
- assertEquals(1, msg.getRepeatedImportMessageCount());
- assertEquals(0, msg.getRepeatedImportMessage(0).getD());
- msg.addRepeatedImportMessage(importMsg1);
- assertEquals(2, msg.getRepeatedImportMessageCount());
- assertEquals(0, msg.getRepeatedImportMessage(0).getD());
- assertEquals(1, msg.getRepeatedImportMessage(1).getD());
- msg.setRepeatedImportMessage(0, importMsg2);
- assertEquals(2, msg.getRepeatedImportMessageCount());
- assertEquals(2, msg.getRepeatedImportMessage(0).getD());
- assertEquals(1, msg.getRepeatedImportMessage(1).getD());
- msg.clearRepeatedImportMessage();
- assertEquals(0, msg.getRepeatedImportMessageCount());
- msg.clearRepeatedImportMessage()
- .addRepeatedImportMessage(importMsg1);
- assertEquals(1, msg.getRepeatedImportMessageCount());
- assertEquals(1, msg.getRepeatedImportMessage(0).getD());
- msg.clear();
- assertEquals(0, msg.getRepeatedImportMessageCount());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedImportMessage(importMsg0);
- assertEquals(1, msg.getRepeatedImportMessageCount());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 5);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedImportMessageCount());
- assertEquals(0, newMsg.getRepeatedImportMessage(0).getD());
-
- // Test 2 entries
- msg.clear()
- .addRepeatedImportMessage(importMsg0)
- .addRepeatedImportMessage(importMsg1);
- assertEquals(2, msg.getRepeatedImportMessageCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 10);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedImportMessageCount());
- assertEquals(0, newMsg.getRepeatedImportMessage(0).getD());
- assertEquals(1, newMsg.getRepeatedImportMessage(1).getD());
- }
-
- public void testMicroRepeatedNestedEnum() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- msg.addRepeatedNestedEnum(TestAllTypesMicro.FOO);
- assertEquals(1, msg.getRepeatedNestedEnumCount());
- assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
- msg.addRepeatedNestedEnum(TestAllTypesMicro.BAR);
- assertEquals(2, msg.getRepeatedNestedEnumCount());
- assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
- assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
- msg.setRepeatedNestedEnum(0, TestAllTypesMicro.BAZ);
- assertEquals(2, msg.getRepeatedNestedEnumCount());
- assertEquals(TestAllTypesMicro.BAZ, msg.getRepeatedNestedEnum(0));
- assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
- msg.clearRepeatedNestedEnum();
- assertEquals(0, msg.getRepeatedNestedEnumCount());
- msg.clearRepeatedNestedEnum()
- .addRepeatedNestedEnum(TestAllTypesMicro.BAR);
- assertEquals(1, msg.getRepeatedNestedEnumCount());
- assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedNestedEnumCount());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedNestedEnum(TestAllTypesMicro.FOO);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedNestedEnumCount());
- assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedNestedEnum(TestAllTypesMicro.FOO)
- .addRepeatedNestedEnum(TestAllTypesMicro.BAR);
- assertEquals(2, msg.getRepeatedNestedEnumCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 6);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedNestedEnumCount());
- assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
- assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
- }
-
- public void testMicroRepeatedForeignEnum() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- msg.addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_FOO);
- assertEquals(1, msg.getRepeatedForeignEnumCount());
- assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
- msg.addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
- assertEquals(2, msg.getRepeatedForeignEnumCount());
- assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
- assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
- msg.setRepeatedForeignEnum(0, MicroOuterClass.FOREIGN_MICRO_BAZ);
- assertEquals(2, msg.getRepeatedForeignEnumCount());
- assertEquals(MicroOuterClass.FOREIGN_MICRO_BAZ, msg.getRepeatedForeignEnum(0));
- assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
- msg.clearRepeatedForeignEnum();
- assertEquals(0, msg.getRepeatedForeignEnumCount());
- msg.clearRepeatedForeignEnum()
- .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
- assertEquals(1, msg.getRepeatedForeignEnumCount());
- assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedForeignEnumCount());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_FOO);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedForeignEnumCount());
- assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_FOO)
- .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
- assertEquals(2, msg.getRepeatedForeignEnumCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 6);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedForeignEnumCount());
- assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
- assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
- }
-
- public void testMicroRepeatedImportEnum() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- msg.addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_FOO);
- assertEquals(1, msg.getRepeatedImportEnumCount());
- assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
- msg.addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
- assertEquals(2, msg.getRepeatedImportEnumCount());
- assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
- assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
- msg.setRepeatedImportEnum(0, UnittestImportMicro.IMPORT_MICRO_BAZ);
- assertEquals(2, msg.getRepeatedImportEnumCount());
- assertEquals(UnittestImportMicro.IMPORT_MICRO_BAZ, msg.getRepeatedImportEnum(0));
- assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
- msg.clearRepeatedImportEnum();
- assertEquals(0, msg.getRepeatedImportEnumCount());
- msg.clearRepeatedImportEnum()
- .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
- assertEquals(1, msg.getRepeatedImportEnumCount());
- assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedImportEnumCount());
-
- // Test 1 entry
- msg.clear()
- .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_FOO);
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedImportEnumCount());
- assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_FOO)
- .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
- assertEquals(2, msg.getRepeatedImportEnumCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 6);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedImportEnumCount());
- assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
- assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
- }
-
- public void testMicroRepeatedStringPiece() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedStringPieceCount());
- msg.addRepeatedStringPiece("hello");
- assertEquals(1, msg.getRepeatedStringPieceCount());
- assertEquals("hello", msg.getRepeatedStringPiece(0));
- msg.addRepeatedStringPiece("bye");
- assertEquals(2, msg.getRepeatedStringPieceCount());
- assertEquals("hello", msg.getRepeatedStringPiece(0));
- assertEquals("bye", msg.getRepeatedStringPiece(1));
- msg.setRepeatedStringPiece(0, "boo");
- assertEquals(2, msg.getRepeatedStringPieceCount());
- assertEquals("boo", msg.getRepeatedStringPiece(0));
- assertEquals("bye", msg.getRepeatedStringPiece(1));
- msg.clearRepeatedStringPiece();
- assertEquals(0, msg.getRepeatedStringPieceCount());
- msg.clearRepeatedStringPiece()
- .addRepeatedStringPiece("hello");
- assertEquals(1, msg.getRepeatedStringPieceCount());
- assertEquals("hello", msg.getRepeatedStringPiece(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedStringPieceCount());
-
- // Test 1 entry and an empty string
- msg.clear()
- .addRepeatedStringPiece("");
- assertEquals(1, msg.getRepeatedStringPieceCount());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedStringPieceCount());
- assertEquals("", newMsg.getRepeatedStringPiece(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedStringPiece("hello")
- .addRepeatedStringPiece("world");
- assertEquals(2, msg.getRepeatedStringPieceCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 16);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedStringPieceCount());
- assertEquals("hello", newMsg.getRepeatedStringPiece(0));
- assertEquals("world", newMsg.getRepeatedStringPiece(1));
- }
-
- public void testMicroRepeatedCord() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertEquals(0, msg.getRepeatedCordCount());
- msg.addRepeatedCord("hello");
- assertEquals(1, msg.getRepeatedCordCount());
- assertEquals("hello", msg.getRepeatedCord(0));
- msg.addRepeatedCord("bye");
- assertEquals(2, msg.getRepeatedCordCount());
- assertEquals("hello", msg.getRepeatedCord(0));
- assertEquals("bye", msg.getRepeatedCord(1));
- msg.setRepeatedCord(0, "boo");
- assertEquals(2, msg.getRepeatedCordCount());
- assertEquals("boo", msg.getRepeatedCord(0));
- assertEquals("bye", msg.getRepeatedCord(1));
- msg.clearRepeatedCord();
- assertEquals(0, msg.getRepeatedCordCount());
- msg.clearRepeatedCord()
- .addRepeatedCord("hello");
- assertEquals(1, msg.getRepeatedCordCount());
- assertEquals("hello", msg.getRepeatedCord(0));
- msg.clear();
- assertEquals(0, msg.getRepeatedCordCount());
-
- // Test 1 entry and an empty string
- msg.clear()
- .addRepeatedCord("");
- assertEquals(1, msg.getRepeatedCordCount());
- byte [] result = msg.toByteArray();
- int msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 3);
- assertEquals(result.length, msgSerializedSize);
- TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(1, newMsg.getRepeatedCordCount());
- assertEquals("", newMsg.getRepeatedCord(0));
-
- // Test 2 entries
- msg.clear()
- .addRepeatedCord("hello")
- .addRepeatedCord("world");
- assertEquals(2, msg.getRepeatedCordCount());
- result = msg.toByteArray();
- msgSerializedSize = msg.getSerializedSize();
- //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
- assertTrue(msgSerializedSize == 16);
- assertEquals(result.length, msgSerializedSize);
-
- newMsg = TestAllTypesMicro.parseFrom(result);
- assertEquals(2, newMsg.getRepeatedCordCount());
- assertEquals("hello", newMsg.getRepeatedCord(0));
- assertEquals("world", newMsg.getRepeatedCord(1));
- }
-
- public void testMicroDefaults() throws Exception {
- TestAllTypesMicro msg = new TestAllTypesMicro();
- assertFalse(msg.hasDefaultInt32());
- assertEquals(41, msg.getDefaultInt32());
- assertFalse(msg.hasDefaultInt64());
- assertEquals(42, msg.getDefaultInt64());
- assertFalse(msg.hasDefaultUint32());
- assertEquals(43, msg.getDefaultUint32());
- assertFalse(msg.hasDefaultUint64());
- assertEquals(44, msg.getDefaultUint64());
- assertFalse(msg.hasDefaultSint32());
- assertEquals(-45, msg.getDefaultSint32());
- assertFalse(msg.hasDefaultSint64());
- assertEquals(46, msg.getDefaultSint64());
- assertFalse(msg.hasDefaultFixed32());
- assertEquals(47, msg.getDefaultFixed32());
- assertFalse(msg.hasDefaultFixed64());
- assertEquals(48, msg.getDefaultFixed64());
- assertFalse(msg.hasDefaultSfixed32());
- assertEquals(49, msg.getDefaultSfixed32());
- assertFalse(msg.hasDefaultSfixed64());
- assertEquals(-50, msg.getDefaultSfixed64());
- assertFalse(msg.hasDefaultFloat());
- assertTrue(51.5f == msg.getDefaultFloat());
- assertFalse(msg.hasDefaultDouble());
- assertTrue(52.0e3 == msg.getDefaultDouble());
- assertFalse(msg.hasDefaultBool());
- assertEquals(true, msg.getDefaultBool());
- assertFalse(msg.hasDefaultString());
- assertEquals("hello", msg.getDefaultString());
- assertFalse(msg.hasDefaultBytes());
- assertEquals("world", msg.getDefaultBytes().toStringUtf8());
- assertFalse(msg.hasDefaultNestedEnum());
- assertEquals(TestAllTypesMicro.BAR, msg.getDefaultNestedEnum());
- assertFalse(msg.hasDefaultForeignEnum());
- assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getDefaultForeignEnum());
- assertFalse(msg.hasDefaultImportEnum());
- assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getDefaultImportEnum());
- }
-}
diff --git a/java/src/test/java/com/google/protobuf/PerfTimer.java b/java/src/test/java/com/google/protobuf/PerfTimer.java
deleted file mode 100644
index d6df4ff..0000000
--- a/java/src/test/java/com/google/protobuf/PerfTimer.java
+++ /dev/null
@@ -1,832 +0,0 @@
-/*
- * Copyright (C) 2010 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.protobuf;
-
-import java.util.Arrays;
-
-/**
- * A Performance Timing class that can be used to estimate the amount of time a
- * sequence of code takes. The typical code sequence would be as follows:</p>
- * <code>
- PerfTimer pt = new PerfTimer();
- pt.calibrate();
- pt.timeEachAutomatically(new Runnable() = {
- public void run() {
- // Add code to time
- }
- });
- System.out.printf("time per loop=" + pt);
-
- * The calibrate method determines the overhead of timing the run() method and
- * the number of times to call the run() method to have approximately 1% precision
- * for timing. The method pt.stats() method will return a string containing some
- * statistics tpl, il, ol, min, max, mean, median, stddev and total.
- *
- * tpl ::= Timer per loop
- * min ::= minimum time one call to run() took
- * stddev ::= Standard deviation of the collected times
- * mean ::= the average time to call run()
- * median ::= 1/2 the times were > than this time and 1/2 were less.
- * total ::= Sum of the times collected.
- * il ::= innerLoops; the number of times run() between each call to start/stop
- * ol ::= outerLoops, the number of times start/stop was called
- *
- * You can also use start/stop/restart to do simple timing:
- *
- * pt.start();
- * a += 1;
- * pt.stop();
- * pt.log("time=" + pt);
- * pt.restart();
- * doSomething();
- * pt.stop();
- * System.out.printf("time=" + pt);
- * </code>
- *
- * @author wink@google.com (Wink Saville)
- */
-public class PerfTimer {
- /** No debug */
- public static final int DEBUG_LEVEL_NONE = 0;
-
- /** Some debug */
- public static final int DEBUG_LEVEL_SOME = 1;
-
- /** All debug */
- public static final int DEBUG_LEVEL_ALL = 2;
-
- /** Timer ticks per microsecond */
- private static final double TICKS_PER_MICROSECOND = 1000.0;
-
- /** Random number generator */
- java.util.Random rng = new java.util.Random();
-
- /** get ticks */
- private static long getTicks() {
- return System.nanoTime();
- }
-
- /** Debug logging */
- private static void log(String s) {
- System.out.printf(String.format("[PerfTimer] %s\n", s));
- }
-
- /** Outer loops for timeEachAutomatically */
- private static final int OUTER_LOOPS = 100;
-
- /** Thrown if an error occurs while timing */
- public static class PerfTimerException extends RuntimeException {
- }
-
- /**
- * Calibration record
- */
- public static class CalibrationRec {
- /** Runnable overhead */
- public double mRunnableOverheadInMicros = 0.0;
-
- /** Minimum Threshold value for timeEachAutomaticaly */
- public double mMinThresholdInMicros = 3000.0;
-
- /** Maximum Threshold value for timeEachAutomaticaly */
- public double mMaxThresholdInMicros = 6000.0;
-
- /** Desired precision in decimal digits */
- public double mPrecisionInDecimalDigits = 2.0;
-
- /**
- * Default number of retries if the standard deviation ratio is too
- * large
- */
- public final int mStdDevRetrys = 5;
-
- /** Default maximum standard deviation radio */
- public final double mMaxStdDevRatio = 0.15;
-
- /** Number of votes looking for smallest time per loop */
- public final int mVotes = 3;
-
- /** Convert to string */
- @Override
- public String toString() {
- return String
- .format(
- "oh=%.6fus minT=%.6fus maxT=%.6fus prc=%,.3f stdDevRetrys=%d maxStdDevRatio=%.2f votes=%d",
- mRunnableOverheadInMicros, mMinThresholdInMicros,
- mMaxThresholdInMicros, mPrecisionInDecimalDigits, mStdDevRetrys,
- mMaxStdDevRatio, mVotes);
- }
- }
-
- /**
- * Calibration record
- */
- private CalibrationRec mCr;
-
- /**
- * Statistics calculated on the timing data.
- */
- public static class Stats {
- /** Number of outer loops */
- private int mOuterLoops;
-
- /** Number of inner loops */
- private int mInnerLoops;
-
- /** Minimum time in times array */
- private long mMin;
-
- /** Maximum time in times array */
- private long mMax;
-
- /** Median value in times array */
- private double mMedian;
-
- /** The mean (average) of the values in times array */
- private double mMean;
-
- /** The standard deviation of the values in times array */
- private double mStdDev;
-
- private int mStdDevTooLargeCount;
-
- /** Sum of the times in the times array */
- private double mTotal;
-
- /** Initialize */
- public void init() {
- mInnerLoops = 1;
- mOuterLoops = 1;
- mMin = 0;
- mMax = 0;
- mMedian = 0;
- mMean = 0;
- mStdDev = 0;
- mStdDevTooLargeCount = 0;
- mTotal = 0;
- }
-
- /** Constructor */
- public Stats() {
- init();
- }
-
- /** Set number of inner loops */
- public void setInnerLoops(int loops) {
- mInnerLoops = loops;
- }
-
- /** Get number of inner loops */
- public int getInnerLoops() {
- return mInnerLoops;
- }
-
- /** Set number of inner loops */
- public void setOuterLoops(int loops) {
- mOuterLoops = loops;
- }
-
- /** Get number of inner loops */
- public int getOuterLoops() {
- return mOuterLoops;
- }
-
- /**
- * Minimum value of collected data in microseconds, valid after analyze.
- */
- public double getMinInMicros() {
- return mMin / TICKS_PER_MICROSECOND;
- }
-
- /**
- * Maximum value of collected data in microseconds, valid after analyze.
- */
- public double getMaxInMicros() {
- return mMax / TICKS_PER_MICROSECOND;
- }
-
- /**
- * Sum of the values of collected data in microseconds, valid after
- * analyze.
- */
- public double getTotalInMicros() {
- return mTotal / TICKS_PER_MICROSECOND;
- }
-
- /** Sum of the values of collected data in seconds, valid after analyze. */
- public double getTotalInSecs() {
- return mTotal / (TICKS_PER_MICROSECOND * 1000000.0);
- }
-
- /** Sum of the values of collected data in seconds, valid after analyze. */
- public double getMeanInMicros() {
- return mMean / TICKS_PER_MICROSECOND;
- }
-
- /** Median value of collected data in microseconds, valid after analyze. */
- public double getMedianInMicros() {
- return mMedian / TICKS_PER_MICROSECOND;
- }
-
- /**
- * Standard deviation of collected data in microseconds, valid after
- * analyze.
- */
- public double getStdDevInMicros() {
- return mStdDev / TICKS_PER_MICROSECOND;
- }
-
- public double getStdDevRatio() {
- return mStdDev / mMin;
- }
-
- /** Return true if (mStdDev / mMin) <= maxStdDevRation */
- public boolean stdDevOk(double maxStdDevRatio) {
- return getStdDevRatio() <= maxStdDevRatio;
- }
-
- /** Increment StdDevTooLargeCount */
- public void incStdDevTooLargeCount() {
- mStdDevTooLargeCount += 1;
- }
-
- /** Return number of times stdDev was not ok */
- public int getStdDevTooLargeCount() {
- return mStdDevTooLargeCount;
- }
-
- /** Return time per loop */
- public double getTimePerLoop() {
- return mMin / TICKS_PER_MICROSECOND / mInnerLoops;
- }
-
- /**
- * Calculate the stats for the data. Note the data in the range will be
- * sorted.
- *
- * @param data
- * @param count
- */
- public Stats calculate(long data[], int count) {
- if (count == 1) {
- mMin = mMax = data[0];
- mTotal = mMedian = mMean = data[0];
- mStdDev = 0;
- } else if (count > 1) {
- Arrays.sort(data, 0, count);
- mMin = data[0];
- mMax = data[count - 1];
- if ((count & 1) == 1) {
- mMedian = data[((count + 1) / 2) - 1];
- } else {
- mMedian = (data[count / 2] + data[(count / 2) - 1]) / 2;
- }
- mTotal = 0;
- double sumSquares = 0;
- for (int i = 0; i < count; i++) {
- long t = data[i];
- mTotal += t;
- sumSquares += t * t;
- }
- mMean = mTotal / count;
- double variance = (sumSquares / count) - (mMean * mMean);
- mStdDev = Math.pow(variance, 0.5);
- } else {
- init();
- }
- return this;
- }
-
- /** Convert to string */
- @Override
- public String toString() {
- double timePerLoop = getTimePerLoop();
- double stdDevPerLoop = mStdDev / TICKS_PER_MICROSECOND / mInnerLoops;
- return String.format(
- "tpl=%,.6fus stdDev=%,.6fus tpl/stdDev=%.2fpercent min=%,.6fus median=%,.6fus mean=%,.6fus max=%,.6fus total=%,.6fs il=%d, ol=%d tlc=%d",
- timePerLoop, stdDevPerLoop, (stdDevPerLoop / timePerLoop) * 100, mMin
- / TICKS_PER_MICROSECOND, mMedian / TICKS_PER_MICROSECOND, mMean
- / TICKS_PER_MICROSECOND, mMax / TICKS_PER_MICROSECOND, mTotal
- / (TICKS_PER_MICROSECOND * 1000000.0), mInnerLoops, mOuterLoops, mStdDevTooLargeCount);
- }
- }
-
- /** Statistics */
- private Stats mStats = new Stats();
-
- /** Statistics of the clock precision */
- private Stats mClockStats;
-
- /** Number of items in times array */
- private int mCount;
-
- /** Array of stop - start times */
- private long mTimes[];
-
- /** Time of last started */
- private long mStart;
-
- /** Sleep a little so we don't look like a hog */
- private void sleep() {
- try {
- Thread.sleep(0);
- } catch (InterruptedException e) {
- // Ignore exception
- }
- }
-
- /** Empty Runnable used for determining overhead */
- private Runnable mEmptyRunnable = new Runnable() {
- public void run() {
- }
- };
-
- /** Initialize */
- private void init(int maxCount, CalibrationRec cr) {
- mTimes = new long[maxCount];
- mCr = cr;
- reset();
- }
-
- /** Construct the stop watch */
- public PerfTimer() {
- init(10, new CalibrationRec());
- }
-
- /** Construct setting size of times array */
- public PerfTimer(int maxCount) {
- init(maxCount, new CalibrationRec());
- }
-
- /** Construct the stop watch */
- public PerfTimer(CalibrationRec cr) {
- init(10, cr);
- }
-
- /** Construct the stop watch */
- public PerfTimer(int maxCount, CalibrationRec cr) {
- init(maxCount, cr);
- }
-
- /** Reset the contents of the times array */
- public PerfTimer reset() {
- mCount = 0;
- mStats.init();
- return this;
- }
-
- /** Reset and then start the timer */
- public PerfTimer restart() {
- reset();
- mStart = getTicks();
- return this;
- }
-
- /** Start timing */
- public PerfTimer start() {
- mStart = getTicks();
- return this;
- }
-
- /**
- * Record the difference between start and now in the times array
- * incrementing count. The time will be stored in the times array if the
- * array is not full.
- */
- public PerfTimer stop() {
- long stop = getTicks();
- if (mCount < mTimes.length) {
- mTimes[mCount++] = stop - mStart;
- }
- return this;
- }
-
- /**
- * Time how long it takes to execute runnable.run() innerLoop number of
- * times outerLoops number of times.
- *
- * @param outerLoops
- * @param innerLoops
- * @param runnable
- * @return PerfTimer
- */
- public PerfTimer timeEach(Stats stats, int outerLoops, int innerLoops, Runnable runnable) {
- reset();
- resize(outerLoops);
- stats.setOuterLoops(outerLoops);
- stats.setInnerLoops(innerLoops);
- for (int i = 0; i < outerLoops; i++) {
- start();
- for (int j = 0; j < innerLoops; j++) {
- runnable.run();
- }
- stop();
- sleep();
- }
- return this;
- }
-
- /**
- * Time how long it takes to execute runnable.run(). Runs runnable votes
- * times and returns the Stats of the fastest run. The actual number times
- * that runnable.run() is executes is enough times so that it runs at least
- * minThreadholeInMicros but not greater than maxThreadholdInMicro. This
- * minimizes the chance that long context switches influence the result.
- *
- * @param votes is the number of runnable will be executed to determine
- * fastest run
- * @param outerLoops is the number of of times the inner loop is run
- * @param initialInnerLoops is the initial inner loop
- * @param maxStdDevRetrys if the maxStdDevRatio is exceeded this number of
- * time the PerfTimerException is thrown.
- * @param maxStdDevRatio the ratio of the standard deviation of the run and
- * the time to run.
- * @param debugLevel DEBUG_LEVEL_NONE, DEBUG_LEVEL_SOME, DEBUG_LEVEL_ALL
- * @param runnable is the code to test.
- * @return Stats of the fastest run.
- */
- public Stats timeEachAutomatically(int votes, int outerLoops, int initialInnerLoops,
- double minThresholdInMicros, double maxThresholdInMicros, int maxStdDevRetrys,
- double maxStdDevRatio, int debugLevel, Runnable runnable) throws PerfTimerException {
- Stats minStats = null;
-
- for (int v = 0; v < votes; v++) {
- boolean successful = false;
- Stats stats = new Stats();
- int innerLoops = initialInnerLoops;
-
- /* Warm up cache */
- timeEach(stats, outerLoops, initialInnerLoops, runnable);
-
- for (int stdDevRetrys = 0; stdDevRetrys < maxStdDevRetrys; stdDevRetrys++) {
- /**
- * First time may be long enough
- */
- timeEach(stats, outerLoops, innerLoops, runnable);
- analyze(stats, mTimes, outerLoops, debugLevel);
- double innerLoopTime = stats.getMinInMicros();
- if ((innerLoopTime >= minThresholdInMicros
- - ((maxThresholdInMicros - minThresholdInMicros) / 2))) {
- if (stats.stdDevOk(maxStdDevRatio)) {
- successful = true;
- break;
- } else {
- stats.incStdDevTooLargeCount();
- if (debugLevel >= DEBUG_LEVEL_SOME) {
- log(String.format(
- "tea: tlc=%d StdDevRatio=%.2f > maxStdDevRatio=%.2f",
- stats.getStdDevTooLargeCount(), stats.getStdDevRatio(),
- maxStdDevRatio));
- }
- }
- } else {
- /**
- * The initial number of loops is too short find the number
- * of loops that exceeds maxThresholdInMicros. Then use a
- * binary search to find the approriate innerLoop value that
- * is between min/maxThreshold.
- */
- innerLoops *= 10;
- int maxInnerLoops = innerLoops;
- int minInnerLoops = 1;
- boolean binarySearch = false;
- for (int i = 0; i < 10; i++) {
- timeEach(stats, outerLoops, innerLoops, runnable);
- analyze(stats, mTimes, outerLoops, debugLevel);
- innerLoopTime = stats.getMedianInMicros();
- if ((innerLoopTime >= minThresholdInMicros)
- && (innerLoopTime <= maxThresholdInMicros)) {
- if (stats.stdDevOk(maxStdDevRatio)) {
- successful = true;
- break;
- } else {
- stats.incStdDevTooLargeCount();
- if (debugLevel >= DEBUG_LEVEL_SOME) {
- log(String.format(
- "tea: tlc=%d StdDevRatio=%.2f > maxStdDevRatio=%.2f",
- stats.getStdDevTooLargeCount(), stats.getStdDevRatio(),
- maxStdDevRatio));
- }
- }
- } else if (binarySearch) {
- if ((innerLoopTime < minThresholdInMicros)) {
- minInnerLoops = innerLoops;
- } else {
- maxInnerLoops = innerLoops;
- }
- innerLoops = (maxInnerLoops + minInnerLoops) / 2;
- } else if (innerLoopTime >= maxThresholdInMicros) {
- /* Found a too large value, change to binary search */
- binarySearch = true;
- maxInnerLoops = innerLoops;
- innerLoops = (maxInnerLoops + minInnerLoops) / 2;
- } else {
- innerLoops *= 10;
- }
- }
- if (successful) {
- break;
- }
- }
- }
- if (!successful) {
- /* Couldn't find the number of loops to execute */
- throw new PerfTimerException();
- }
-
- /** Looking for minimum */
- if ((minStats == null) || (minStats.getTimePerLoop() > stats.getTimePerLoop())) {
- minStats = stats;
- }
- if (debugLevel >= DEBUG_LEVEL_SOME) {
- log(String.format("minStats.getTimePerLoop=%f minStats: %s", minStats.getTimePerLoop(), minStats));
- }
- }
-
- return minStats;
- }
-
- /**
- * Time how long it takes to execute runnable.run() with a threshold of 1 to
- * 10ms.
- *
- * @param debugLevel DEBUG_LEVEL_NONE, DEBUG_LEVEL_SOME, DEBUG_LEVEL_ALL
- * @param runnable
- * @throws PerfTimerException
- */
- public Stats timeEachAutomatically(int debugLevel, Runnable runnable)
- throws PerfTimerException {
- mStats = timeEachAutomatically(mCr.mVotes, OUTER_LOOPS, 1, mCr.mMinThresholdInMicros,
- mCr.mMaxThresholdInMicros, mCr.mStdDevRetrys, mCr.mMaxStdDevRatio, debugLevel,
- runnable);
- return mStats;
- }
-
- /**
- * Time how long it takes to execute runnable.run() with a threshold of 1 to
- * 10ms.
- *
- * @param runnable
- * @throws PerfTimerException
- */
- public Stats timeEachAutomatically(Runnable runnable) throws PerfTimerException {
- mStats = timeEachAutomatically(mCr.mVotes, OUTER_LOOPS, 1, mCr.mMinThresholdInMicros,
- mCr.mMaxThresholdInMicros, mCr.mStdDevRetrys, mCr.mMaxStdDevRatio,
- DEBUG_LEVEL_NONE, runnable);
- return mStats;
- }
-
- /** Resize the times array */
- public void resize(int maxCount) {
- if (maxCount > mTimes.length) {
- mTimes = new long[maxCount];
- }
- }
-
- /**
- * Analyze the data calculating the min, max, total, median, mean and
- * stdDev. The standard deviation is calculated as sqrt(((sum of the squares
- * of each time) / count) - mean^2)
- * {@link "http://www.sciencebuddies.org/mentoring/project_data_analysis_variance_std_deviation.shtml"}
- *
- * @param debugLevel DEBUG_LEVEL_NONE, DEBUG_LEVEL_SOME, DEBUG_LEVEL_ALL
- * @return StopWatch
- */
- public Stats analyze(Stats stats, long data[], int count, int debugLevel) {
- if (count > 0) {
- if (debugLevel >= DEBUG_LEVEL_ALL) {
- for (int j = 0; j < count; j++) {
- log(String.format("data[%d]=%,dns", j, data[j]));
- }
- }
- stats.calculate(data, count);
- } else {
- stats.init();
- }
- if (debugLevel >= DEBUG_LEVEL_SOME) {
- log("stats: " + stats);
- }
- return stats;
- }
-
- /**
- * Calibrate the system and set it for this PerfTimer instance
- *
- * @param debugLevel DEBUG_LEVEL_NONE, DEBUG_LEVEL_SOME, DEBUG_LEVEL_ALL
- * @param precisionInDecimalDigits the precision in number of decimal digits
- */
- public CalibrationRec calibrate(int debugLevel, double precisionInDecimalDigits)
- throws PerfTimerException {
- int nonZeroCount = 0;
- Stats stats = new Stats();
- CalibrationRec cr = new CalibrationRec();
-
- /* initialize the precision */
- cr.mPrecisionInDecimalDigits = precisionInDecimalDigits;
-
- /* Warm up the cache */
- timeEach(stats, OUTER_LOOPS, 10, mEmptyRunnable);
-
- /*
- * Determine the clock stats with at least 20% non-zero unique values.
- */
- for (int clockStatsTries = 1; clockStatsTries < 100; clockStatsTries++) {
- int j;
- int i;
- long cur;
- long prev;
- long min;
-
- int innerLoops = clockStatsTries * 10;
- timeEach(stats, OUTER_LOOPS, innerLoops, mEmptyRunnable);
- long nonZeroValues[] = new long[mCount];
- prev = 0;
- for (nonZeroCount = 0, i = 0; i < mCount; i++) {
- cur = mTimes[i];
- if (cur > 0) {
- nonZeroValues[nonZeroCount++] = cur;
- }
- }
- if (nonZeroCount > (mCount * 0.20)) {
- // Calculate thresholds
- analyze(stats, nonZeroValues, nonZeroCount, debugLevel);
- stats.calculate(nonZeroValues, nonZeroCount);
- cr.mMinThresholdInMicros = stats.getMeanInMicros()
- * Math.pow(10, cr.mPrecisionInDecimalDigits);
- cr.mMaxThresholdInMicros = cr.mMinThresholdInMicros * 2;
-
- // Set overhead to 0 and time the empty loop then set overhead.
- cr.mRunnableOverheadInMicros = 0;
- mClockStats = timeEachAutomatically(mCr.mVotes, OUTER_LOOPS, innerLoops,
- cr.mMinThresholdInMicros, cr.mMaxThresholdInMicros, mCr.mStdDevRetrys,
- mCr.mMaxStdDevRatio, debugLevel, mEmptyRunnable);
- cr.mRunnableOverheadInMicros = mClockStats.getMinInMicros()
- / mClockStats.getInnerLoops();
- break;
- }
- nonZeroCount = 0;
- }
- if (nonZeroCount == 0) {
- throw new PerfTimerException();
- }
- if (debugLevel >= DEBUG_LEVEL_SOME) {
- log(String.format("calibrate X oh=%.6fus minT=%,.6fus maxT=%,.6fus stats: %s",
- cr.mRunnableOverheadInMicros, cr.mMinThresholdInMicros,
- cr.mMaxThresholdInMicros, stats));
- }
- mCr = cr;
- return mCr;
- }
-
- /** Calibrate the system and set it for this PerfTimer instance */
- public CalibrationRec calibrate(double precisionInDecimalDigits) throws PerfTimerException {
- return calibrate(DEBUG_LEVEL_NONE, precisionInDecimalDigits);
- }
-
- /** Calibrate the system and set it for this PerfTimer instance */
- public CalibrationRec calibrate() throws PerfTimerException {
- return calibrate(DEBUG_LEVEL_NONE, mCr.mPrecisionInDecimalDigits);
- }
-
- /*
- * Accessors for the private data
- */
-
- /** Set calibration record */
- public void setCalibrationRec(CalibrationRec cr) {
- mCr = cr;
- }
-
- /** Get calibration record */
- public CalibrationRec getCalibrationRec() {
- return mCr;
- }
-
- /** Number of samples in times array. */
- public int getCount() {
- return mCount;
- }
-
- /** Minimum value of collected data in microseconds, valid after analyze. */
- public double getMinInMicros() {
- return mStats.getMinInMicros();
- }
-
- /** Maximum value of collected data in microseconds, valid after analyze. */
- public double getMaxInMicros() {
- return mStats.getMaxInMicros();
- }
-
- /**
- * Sum of the values of collected data in microseconds, valid after analyze.
- */
- public double getTotalInMicros() {
- return mStats.getTotalInMicros();
- }
-
- /** Sum of the values of collected data in seconds, valid after analyze. */
- public double getTotalInSecs() {
- return mStats.getTotalInSecs();
- }
-
- /** Sum of the values of collected data in seconds, valid after analyze. */
- public double getMeanInMicros() {
- return mStats.getMeanInMicros();
- }
-
- /** Median value of collected data in microseconds, valid after analyze. */
- public double getMedianInMicros() {
- return mStats.getMedianInMicros();
- }
-
- /**
- * Standard deviation of collected data in microseconds, valid after
- * analyze.
- */
- public double getStdDevInMicros() {
- return mStats.getStdDevInMicros();
- }
-
- /** The mTimes[index] value */
- public long getTime(int index) {
- return mTimes[index];
- }
-
- /** The mTimes */
- public long[] getTimes() {
- return mTimes;
- }
-
- /** @return the clock stats as measured in calibrate */
- public Stats getClockStats() {
- return mClockStats;
- }
-
- /** @return the stats */
- public Stats getStats() {
- return mStats;
- }
-
- /**
- * Convert stats to string
- *
- * @param debugLevel DEBUG_LEVEL_NONE, DEBUG_LEVEL_SOME, DEBUG_LEVEL_ALL
- */
- public String stats(int debugLevel) {
- int innerLoops = mStats.getInnerLoops();
- if (mCount == 0) {
- return String.format("%,.3fus", (getTicks() - mStart) / TICKS_PER_MICROSECOND);
- } else {
- if (mCount == 1) {
- return String.format("%,.3fus", getTime());
- } else {
- analyze(mStats, mTimes, mCount, debugLevel);
- return mStats.toString();
- }
- }
- }
-
- /**
- * Convert string
- */
- public String stats() {
- return stats(0);
- }
-
- /**
- * Get time
- */
- public double getTime() {
- int innerLoops = mStats.getInnerLoops();
- if (mCount == 0) {
- return (getTicks() - mStart) / TICKS_PER_MICROSECOND;
- } else {
- if (mCount == 1) {
- return mStats.getTotalInMicros();
- } else {
- analyze(mStats, mTimes, mCount, DEBUG_LEVEL_NONE);
- return (mStats.getMinInMicros() / innerLoops) - mCr.mRunnableOverheadInMicros;
- }
- }
- }
-
- /** Convert to string */
- @Override
- public String toString() {
- return String.format("%,.3fus", getTime());
- }
-}
diff --git a/java/src/test/java/com/google/protobuf/ServiceTest.java b/java/src/test/java/com/google/protobuf/ServiceTest.java
index d8523ea..e10322d 100644
--- a/java/src/test/java/com/google/protobuf/ServiceTest.java
+++ b/java/src/test/java/com/google/protobuf/ServiceTest.java
@@ -30,7 +30,9 @@
package com.google.protobuf;
+import com.google.protobuf.Descriptors.FileDescriptor;
import com.google.protobuf.Descriptors.MethodDescriptor;
+import google.protobuf.no_generic_services_test.UnittestNoGenericServices;
import protobuf_unittest.MessageWithNoOuter;
import protobuf_unittest.ServiceWithNoOuter;
import protobuf_unittest.UnittestProto.TestAllTypes;
@@ -44,6 +46,9 @@ import org.easymock.classextension.EasyMock;
import org.easymock.classextension.IMocksControl;
import org.easymock.IArgumentMatcher;
+import java.util.HashSet;
+import java.util.Set;
+
import junit.framework.TestCase;
/**
@@ -220,6 +225,48 @@ public class ServiceTest extends TestCase {
control.verify();
}
+ public void testNoGenericServices() throws Exception {
+ // Non-services should be usable.
+ UnittestNoGenericServices.TestMessage message =
+ UnittestNoGenericServices.TestMessage.newBuilder()
+ .setA(123)
+ .setExtension(UnittestNoGenericServices.testExtension, 456)
+ .build();
+ assertEquals(123, message.getA());
+ assertEquals(1, UnittestNoGenericServices.TestEnum.FOO.getNumber());
+
+ // Build a list of the class names nested in UnittestNoGenericServices.
+ String outerName = "google.protobuf.no_generic_services_test." +
+ "UnittestNoGenericServices";
+ Class<?> outerClass = Class.forName(outerName);
+
+ Set<String> innerClassNames = new HashSet<String>();
+ for (Class<?> innerClass : outerClass.getClasses()) {
+ String fullName = innerClass.getName();
+ // Figure out the unqualified name of the inner class.
+ // Note: Surprisingly, the full name of an inner class will be separated
+ // from the outer class name by a '$' rather than a '.'. This is not
+ // mentioned in the documentation for java.lang.Class. I don't want to
+ // make assumptions, so I'm just going to accept any character as the
+ // separator.
+ assertTrue(fullName.startsWith(outerName));
+ innerClassNames.add(fullName.substring(outerName.length() + 1));
+ }
+
+ // No service class should have been generated.
+ assertTrue(innerClassNames.contains("TestMessage"));
+ assertTrue(innerClassNames.contains("TestEnum"));
+ assertFalse(innerClassNames.contains("TestService"));
+
+ // But descriptors are there.
+ FileDescriptor file = UnittestNoGenericServices.getDescriptor();
+ assertEquals(1, file.getServices().size());
+ assertEquals("TestService", file.getServices().get(0).getName());
+ assertEquals(1, file.getServices().get(0).getMethods().size());
+ assertEquals("Foo",
+ file.getServices().get(0).getMethods().get(0).getName());
+ }
+
// =================================================================
/**
diff --git a/java/src/test/java/com/google/protobuf/TestUtil.java b/java/src/test/java/com/google/protobuf/TestUtil.java
index 805c42a..2b8b2af 100644
--- a/java/src/test/java/com/google/protobuf/TestUtil.java
+++ b/java/src/test/java/com/google/protobuf/TestUtil.java
@@ -217,6 +217,7 @@ import protobuf_unittest.UnittestProto.TestAllExtensions;
import protobuf_unittest.UnittestProto.TestAllTypes;
import protobuf_unittest.UnittestProto.TestPackedExtensions;
import protobuf_unittest.UnittestProto.TestPackedTypes;
+import protobuf_unittest.UnittestProto.TestUnpackedTypes;
import protobuf_unittest.UnittestProto.ForeignMessage;
import protobuf_unittest.UnittestProto.ForeignEnum;
import com.google.protobuf.test.UnittestImport.ImportMessage;
@@ -289,6 +290,12 @@ class TestUtil {
return builder.build();
}
+ public static TestUnpackedTypes getUnpackedSet() {
+ TestUnpackedTypes.Builder builder = TestUnpackedTypes.newBuilder();
+ setUnpackedFields(builder);
+ return builder.build();
+ }
+
public static TestPackedExtensions getPackedExtensionsSet() {
TestPackedExtensions.Builder builder = TestPackedExtensions.newBuilder();
setPackedExtensions(builder);
@@ -956,6 +963,42 @@ class TestUtil {
}
/**
+ * Set every field of {@code message} to a unique value. Must correspond with
+ * the values applied by {@code setPackedFields}.
+ */
+ public static void setUnpackedFields(TestUnpackedTypes.Builder message) {
+ message.addUnpackedInt32 (601);
+ message.addUnpackedInt64 (602);
+ message.addUnpackedUint32 (603);
+ message.addUnpackedUint64 (604);
+ message.addUnpackedSint32 (605);
+ message.addUnpackedSint64 (606);
+ message.addUnpackedFixed32 (607);
+ message.addUnpackedFixed64 (608);
+ message.addUnpackedSfixed32(609);
+ message.addUnpackedSfixed64(610);
+ message.addUnpackedFloat (611);
+ message.addUnpackedDouble (612);
+ message.addUnpackedBool (true);
+ message.addUnpackedEnum (ForeignEnum.FOREIGN_BAR);
+ // Add a second one of each field.
+ message.addUnpackedInt32 (701);
+ message.addUnpackedInt64 (702);
+ message.addUnpackedUint32 (703);
+ message.addUnpackedUint64 (704);
+ message.addUnpackedSint32 (705);
+ message.addUnpackedSint64 (706);
+ message.addUnpackedFixed32 (707);
+ message.addUnpackedFixed64 (708);
+ message.addUnpackedSfixed32(709);
+ message.addUnpackedSfixed64(710);
+ message.addUnpackedFloat (711);
+ message.addUnpackedDouble (712);
+ message.addUnpackedBool (false);
+ message.addUnpackedEnum (ForeignEnum.FOREIGN_BAZ);
+ }
+
+ /**
* Assert (using {@code junit.framework.Assert}} that all fields of
* {@code message} are set to the values assigned by {@code setPackedFields}.
*/
@@ -1004,6 +1047,55 @@ class TestUtil {
Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getPackedEnum(1));
}
+ /**
+ * Assert (using {@code junit.framework.Assert}} that all fields of
+ * {@code message} are set to the values assigned by {@code setUnpackedFields}.
+ */
+ public static void assertUnpackedFieldsSet(TestUnpackedTypes message) {
+ Assert.assertEquals(2, message.getUnpackedInt32Count ());
+ Assert.assertEquals(2, message.getUnpackedInt64Count ());
+ Assert.assertEquals(2, message.getUnpackedUint32Count ());
+ Assert.assertEquals(2, message.getUnpackedUint64Count ());
+ Assert.assertEquals(2, message.getUnpackedSint32Count ());
+ Assert.assertEquals(2, message.getUnpackedSint64Count ());
+ Assert.assertEquals(2, message.getUnpackedFixed32Count ());
+ Assert.assertEquals(2, message.getUnpackedFixed64Count ());
+ Assert.assertEquals(2, message.getUnpackedSfixed32Count());
+ Assert.assertEquals(2, message.getUnpackedSfixed64Count());
+ Assert.assertEquals(2, message.getUnpackedFloatCount ());
+ Assert.assertEquals(2, message.getUnpackedDoubleCount ());
+ Assert.assertEquals(2, message.getUnpackedBoolCount ());
+ Assert.assertEquals(2, message.getUnpackedEnumCount ());
+ Assert.assertEquals(601 , message.getUnpackedInt32 (0));
+ Assert.assertEquals(602 , message.getUnpackedInt64 (0));
+ Assert.assertEquals(603 , message.getUnpackedUint32 (0));
+ Assert.assertEquals(604 , message.getUnpackedUint64 (0));
+ Assert.assertEquals(605 , message.getUnpackedSint32 (0));
+ Assert.assertEquals(606 , message.getUnpackedSint64 (0));
+ Assert.assertEquals(607 , message.getUnpackedFixed32 (0));
+ Assert.assertEquals(608 , message.getUnpackedFixed64 (0));
+ Assert.assertEquals(609 , message.getUnpackedSfixed32(0));
+ Assert.assertEquals(610 , message.getUnpackedSfixed64(0));
+ Assert.assertEquals(611 , message.getUnpackedFloat (0), 0.0);
+ Assert.assertEquals(612 , message.getUnpackedDouble (0), 0.0);
+ Assert.assertEquals(true , message.getUnpackedBool (0));
+ Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getUnpackedEnum(0));
+ Assert.assertEquals(701 , message.getUnpackedInt32 (1));
+ Assert.assertEquals(702 , message.getUnpackedInt64 (1));
+ Assert.assertEquals(703 , message.getUnpackedUint32 (1));
+ Assert.assertEquals(704 , message.getUnpackedUint64 (1));
+ Assert.assertEquals(705 , message.getUnpackedSint32 (1));
+ Assert.assertEquals(706 , message.getUnpackedSint64 (1));
+ Assert.assertEquals(707 , message.getUnpackedFixed32 (1));
+ Assert.assertEquals(708 , message.getUnpackedFixed64 (1));
+ Assert.assertEquals(709 , message.getUnpackedSfixed32(1));
+ Assert.assertEquals(710 , message.getUnpackedSfixed64(1));
+ Assert.assertEquals(711 , message.getUnpackedFloat (1), 0.0);
+ Assert.assertEquals(712 , message.getUnpackedDouble (1), 0.0);
+ Assert.assertEquals(false, message.getUnpackedBool (1));
+ Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getUnpackedEnum(1));
+ }
+
// ===================================================================
// Like above, but for extensions
@@ -1572,6 +1664,34 @@ class TestUtil {
Assert.assertEquals(0, message.getExtensionCount(repeatedStringPieceExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedCordExtension));
+ // Repeated fields are empty via getExtension().size().
+ Assert.assertEquals(0, message.getExtension(repeatedInt32Extension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedInt64Extension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedUint32Extension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedUint64Extension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedSint32Extension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedSint64Extension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedFixed32Extension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedFixed64Extension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedSfixed32Extension).size());
+ Assert.assertEquals(0, message.getExtension(repeatedSfixed64Extension).size());
+ Assert.assertEquals(0, message.getExtension(repeatedFloatExtension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedDoubleExtension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedBoolExtension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedStringExtension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedBytesExtension ).size());
+
+ Assert.assertEquals(0, message.getExtension(repeatedGroupExtension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedNestedMessageExtension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedForeignMessageExtension).size());
+ Assert.assertEquals(0, message.getExtension(repeatedImportMessageExtension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedNestedEnumExtension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedForeignEnumExtension ).size());
+ Assert.assertEquals(0, message.getExtension(repeatedImportEnumExtension ).size());
+
+ Assert.assertEquals(0, message.getExtension(repeatedStringPieceExtension).size());
+ Assert.assertEquals(0, message.getExtension(repeatedCordExtension).size());
+
// hasBlah() should also be false for all default fields.
Assert.assertFalse(message.hasExtension(defaultInt32Extension ));
Assert.assertFalse(message.hasExtension(defaultInt64Extension ));
diff --git a/java/src/test/java/com/google/protobuf/TextFormatTest.java b/java/src/test/java/com/google/protobuf/TextFormatTest.java
index 1d73165..60bd800 100644
--- a/java/src/test/java/com/google/protobuf/TextFormatTest.java
+++ b/java/src/test/java/com/google/protobuf/TextFormatTest.java
@@ -68,7 +68,7 @@ public class TextFormatTest extends TestCase {
private static String allExtensionsSetText = TestUtil.readTextFromFile(
"text_format_unittest_extensions_data.txt");
- private String exoticText =
+ private static String exoticText =
"repeated_int32: -1\n" +
"repeated_int32: -2147483648\n" +
"repeated_int64: -1\n" +
@@ -80,7 +80,13 @@ public class TextFormatTest extends TestCase {
"repeated_double: 123.0\n" +
"repeated_double: 123.5\n" +
"repeated_double: 0.125\n" +
+ "repeated_double: .125\n" +
+ "repeated_double: -.125\n" +
"repeated_double: 1.23E17\n" +
+ "repeated_double: 1.23E+17\n" +
+ "repeated_double: -1.23e-17\n" +
+ "repeated_double: .23e+17\n" +
+ "repeated_double: -.23E17\n" +
"repeated_double: 1.235E22\n" +
"repeated_double: 1.235E-18\n" +
"repeated_double: 123.456789\n" +
@@ -91,6 +97,10 @@ public class TextFormatTest extends TestCase {
"\\341\\210\\264\"\n" +
"repeated_bytes: \"\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"\\376\"\n";
+ private static String canonicalExoticText =
+ exoticText.replace(": .", ": 0.").replace(": -.", ": -0.") // short-form double
+ .replace("23e", "23E").replace("E+", "E").replace("0.23E17", "2.3E16");
+
private String messageSetText =
"[protobuf_unittest.TestMessageSetExtension1] {\n" +
" i: 123\n" +
@@ -186,12 +196,12 @@ public class TextFormatTest extends TestCase {
final FieldDescriptor optionalField =
TestAllTypes.getDescriptor().findFieldByName("optional_nested_message");
final Object value = NestedMessage.newBuilder().setBb(42).build();
-
+
assertEquals(
"optional_nested_message {\n bb: 42\n}\n",
TextFormat.printFieldToString(optionalField, value));
}
-
+
/**
* Helper to construct a ByteString from a String containing only 8-bit
* characters. The characters are converted directly to bytes, *not*
@@ -231,7 +241,13 @@ public class TextFormatTest extends TestCase {
.addRepeatedDouble(123)
.addRepeatedDouble(123.5)
.addRepeatedDouble(0.125)
+ .addRepeatedDouble(.125)
+ .addRepeatedDouble(-.125)
+ .addRepeatedDouble(123e15)
.addRepeatedDouble(123e15)
+ .addRepeatedDouble(-1.23e-17)
+ .addRepeatedDouble(.23e17)
+ .addRepeatedDouble(-23e15)
.addRepeatedDouble(123.5e20)
.addRepeatedDouble(123.5e-20)
.addRepeatedDouble(123.456789)
@@ -244,7 +260,7 @@ public class TextFormatTest extends TestCase {
.addRepeatedBytes(bytes("\0\001\007\b\f\n\r\t\013\\\'\"\u00fe"))
.build();
- assertEquals(exoticText, message.toString());
+ assertEquals(canonicalExoticText, message.toString());
}
public void testPrintMessageSet() throws Exception {
@@ -319,7 +335,7 @@ public class TextFormatTest extends TestCase {
// Too lazy to check things individually. Don't try to debug this
// if testPrintExotic() is failing.
- assertEquals(exoticText, builder.build().toString());
+ assertEquals(canonicalExoticText, builder.build().toString());
}
public void testParseMessageSet() throws Exception {
@@ -633,4 +649,10 @@ public class TextFormatTest extends TestCase {
TextFormat.merge("optional_string: \"" + longText + "\"", builder);
assertEquals(longText, builder.getOptionalString());
}
+
+ public void testParseAdjacentStringLiterals() throws Exception {
+ TestAllTypes.Builder builder = TestAllTypes.newBuilder();
+ TextFormat.merge("optional_string: \"foo\" 'corge' \"grault\"", builder);
+ assertEquals("foocorgegrault", builder.getOptionalString());
+ }
}
diff --git a/java/src/test/java/com/google/protobuf/WireFormatTest.java b/java/src/test/java/com/google/protobuf/WireFormatTest.java
index bd1c6db..5ea1dd6 100644
--- a/java/src/test/java/com/google/protobuf/WireFormatTest.java
+++ b/java/src/test/java/com/google/protobuf/WireFormatTest.java
@@ -102,6 +102,28 @@ public class WireFormatTest extends TestCase {
assertEquals(rawBytes, rawBytes2);
}
+ public void testSerializationPackedWithoutGetSerializedSize()
+ throws Exception {
+ // Write directly to an OutputStream, without invoking getSerializedSize()
+ // This used to be a bug where the size of a packed field was incorrect,
+ // since getSerializedSize() was never invoked.
+ TestPackedTypes message = TestUtil.getPackedSet();
+
+ // Directly construct a CodedOutputStream around the actual OutputStream,
+ // in case writeTo(OutputStream output) invokes getSerializedSize();
+ ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+ CodedOutputStream codedOutput = CodedOutputStream.newInstance(outputStream);
+
+ message.writeTo(codedOutput);
+
+ codedOutput.flush();
+
+ TestPackedTypes message2 = TestPackedTypes.parseFrom(
+ outputStream.toByteArray());
+
+ TestUtil.assertPackedFieldsSet(message2);
+ }
+
public void testSerializeExtensionsLite() throws Exception {
// TestAllTypes and TestAllExtensions should have compatible wire formats,
// so if we serialize a TestAllExtensions then parse it as TestAllTypes
@@ -213,6 +235,9 @@ public class WireFormatTest extends TestCase {
TestUtil.assertPackedFieldsSet(TestPackedTypes.parseDelimitedFrom(input));
assertEquals(34, input.read());
assertEquals(-1, input.read());
+
+ // We're at EOF, so parsing again should return null.
+ assertTrue(TestAllTypes.parseDelimitedFrom(input) == null);
}
private void assertFieldsInOrder(ByteString data) throws Exception {
--
cgit v1.1