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

11 files changed, 365 insertions, 2978 deletions

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 {