Push out changes from internal codebase.

All Languages
* Repeated fields of primitive types (types other that string, group, and
  nested messages) may now use the option [packed = true] to get a more
  efficient encoding.  In the new encoding, the entire list is written
  as a single byte blob using the "length-delimited" wire type.  Within
  this blob, the individual values are encoded the same way they would
  be normally except without a tag before each value (thus, they are
  tightly "packed").

C++
* UnknownFieldSet now supports STL-like iteration.
* Message interface has method ParseFromBoundedZeroCopyStream() which parses
  a limited number of bytes from an input stream rather than parsing until
  EOF.

Java
* Fixed bug where Message.mergeFrom(Message) failed to merge extensions.
* Message interface has new method toBuilder() which is equivalent to
  newBuilderForType().mergeFrom(this).
* All enums now implement the ProtocolMessageEnum interface.
* Setting a field to null now throws NullPointerException.
* Fixed tendency for TextFormat's parsing to overflow the stack when
  parsing large string values.  The underlying problem is with Java's
  regex implementation (which unfortunately uses recursive backtracking
  rather than building an NFA).  Worked around by making use of possesive
  quantifiers.

Python
* Updated RPC interfaces to allow for blocking operation.  A client may
  now pass None for a callback when making an RPC, in which case the
  call will block until the response is received, and the response
  object will be returned directly to the caller.  This interface change
  cannot be used in practice until RPC implementations are updated to
  implement it.

7 files changed, 1355 insertions, 540 deletions

diff --git a/java/src/test/java/com/google/protobuf/AbstractMessageTest.java b/java/src/test/java/com/google/protobuf/AbstractMessageTest.java
index 10ab7e75..da073561 100644
--- a/java/src/test/java/com/google/protobuf/AbstractMessageTest.java
+++ b/java/src/test/java/com/google/protobuf/AbstractMessageTest.java
@@ -34,6 +34,7 @@ import protobuf_unittest.UnittestProto;
 import protobuf_unittest.UnittestProto.ForeignMessage;
 import protobuf_unittest.UnittestProto.TestAllTypes;
 import protobuf_unittest.UnittestProto.TestAllExtensions;
+import protobuf_unittest.UnittestProto.TestPackedTypes;
 import protobuf_unittest.UnittestProto.TestRequired;
 import protobuf_unittest.UnittestProto.TestRequiredForeign;
 import protobuf_unittest.UnittestOptimizeFor.TestOptimizedForSize;
@@ -91,6 +92,9 @@ public class AbstractMessageTest extends TestCase {
     public Builder newBuilderForType() {
       return new Builder(wrappedMessage.newBuilderForType());
     }
+    public Builder toBuilder() {
+      return new Builder(wrappedMessage.toBuilder());
+    }
 
     static class Builder extends AbstractMessage.Builder<Builder> {
       private final Message.Builder wrappedBuilder;
@@ -215,6 +219,25 @@ public class AbstractMessageTest extends TestCase {
     TestUtil.assertAllFieldsSet((TestAllTypes) message.wrappedMessage);
   }
 
+  public void testPackedSerialization() throws Exception {
+    Message abstractMessage =
+        new AbstractMessageWrapper(TestUtil.getPackedSet());
+
+    TestUtil.assertPackedFieldsSet(
+      TestPackedTypes.parseFrom(abstractMessage.toByteString()));
+
+    assertEquals(TestUtil.getPackedSet().toByteString(),
+                 abstractMessage.toByteString());
+  }
+
+  public void testPackedParsing() throws Exception {
+    AbstractMessageWrapper.Builder builder =
+      new AbstractMessageWrapper.Builder(TestPackedTypes.newBuilder());
+    AbstractMessageWrapper message =
+      builder.mergeFrom(TestUtil.getPackedSet().toByteString()).build();
+    TestUtil.assertPackedFieldsSet((TestPackedTypes) 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/CodedOutputStreamTest.java b/java/src/test/java/com/google/protobuf/CodedOutputStreamTest.java
index 5a96e3e6..c42b485c 100644
--- a/java/src/test/java/com/google/protobuf/CodedOutputStreamTest.java
+++ b/java/src/test/java/com/google/protobuf/CodedOutputStreamTest.java
@@ -31,6 +31,7 @@
 package com.google.protobuf;
 
 import protobuf_unittest.UnittestProto.TestAllTypes;
+import protobuf_unittest.UnittestProto.TestPackedTypes;
 
 import junit.framework.TestCase;
 
@@ -290,4 +291,14 @@ public class CodedOutputStreamTest extends TestCase {
       assertEqualBytes(rawBytes, rawOutput.toByteArray());
     }
   }
+
+  /** Tests writing a whole message with every packed field type. Ensures the
+   * wire format of packed fields is compatible with C++. */
+  public void testWriteWholePackedFieldsMessage() throws Exception {
+    TestPackedTypes message = TestUtil.getPackedSet();
+
+    byte[] rawBytes = message.toByteArray();
+    assertEqualBytes(TestUtil.getGoldenPackedFieldsMessage().toByteArray(),
+                     rawBytes);
+  }
 }
diff --git a/java/src/test/java/com/google/protobuf/DynamicMessageTest.java b/java/src/test/java/com/google/protobuf/DynamicMessageTest.java
index e2c15c64..fc53c531 100644
--- a/java/src/test/java/com/google/protobuf/DynamicMessageTest.java
+++ b/java/src/test/java/com/google/protobuf/DynamicMessageTest.java
@@ -32,8 +32,10 @@ package com.google.protobuf;
 
 import protobuf_unittest.UnittestProto.TestAllTypes;
 import protobuf_unittest.UnittestProto.TestAllExtensions;
+import protobuf_unittest.UnittestProto.TestPackedTypes;
 
 import junit.framework.TestCase;
+import java.util.Arrays;
 
 /**
  * Unit test for {@link DynamicMessage}.  See also {@link MessageTest}, which
@@ -48,6 +50,8 @@ public class DynamicMessageTest extends TestCase {
   TestUtil.ReflectionTester extensionsReflectionTester =
     new TestUtil.ReflectionTester(TestAllExtensions.getDescriptor(),
                                   TestUtil.getExtensionRegistry());
+  TestUtil.ReflectionTester packedReflectionTester =
+    new TestUtil.ReflectionTester(TestPackedTypes.getDescriptor(), null);
 
   public void testDynamicMessageAccessors() throws Exception {
     Message.Builder builder =
@@ -57,6 +61,12 @@ public class DynamicMessageTest extends TestCase {
     reflectionTester.assertAllFieldsSetViaReflection(message);
   }
 
+  public void testDynamicMessageSettersRejectNull() throws Exception {
+    Message.Builder builder =
+      DynamicMessage.newBuilder(TestAllTypes.getDescriptor());
+    reflectionTester.assertReflectionSettersRejectNull(builder);
+  }
+
   public void testDynamicMessageExtensionAccessors() throws Exception {
     // We don't need to extensively test DynamicMessage's handling of
     // extensions because, frankly, it doesn't do anything special with them.
@@ -68,6 +78,12 @@ public class DynamicMessageTest extends TestCase {
     extensionsReflectionTester.assertAllFieldsSetViaReflection(message);
   }
 
+  public void testDynamicMessageExtensionSettersRejectNull() throws Exception {
+    Message.Builder builder =
+      DynamicMessage.newBuilder(TestAllExtensions.getDescriptor());
+    extensionsReflectionTester.assertReflectionSettersRejectNull(builder);
+  }
+
   public void testDynamicMessageRepeatedSetters() throws Exception {
     Message.Builder builder =
       DynamicMessage.newBuilder(TestAllTypes.getDescriptor());
@@ -77,6 +93,12 @@ public class DynamicMessageTest extends TestCase {
     reflectionTester.assertRepeatedFieldsModifiedViaReflection(message);
   }
 
+  public void testDynamicMessageRepeatedSettersRejectNull() throws Exception {
+    Message.Builder builder =
+      DynamicMessage.newBuilder(TestAllTypes.getDescriptor());
+    reflectionTester.assertReflectionRepeatedSettersRejectNull(builder);
+  }
+
   public void testDynamicMessageDefaults() throws Exception {
     reflectionTester.assertClearViaReflection(
       DynamicMessage.getDefaultInstance(TestAllTypes.getDescriptor()));
@@ -123,6 +145,33 @@ public class DynamicMessageTest extends TestCase {
     reflectionTester.assertAllFieldsSetViaReflection(message2);
   }
 
+  public void testDynamicMessagePackedSerialization() throws Exception {
+    Message.Builder builder =
+        DynamicMessage.newBuilder(TestPackedTypes.getDescriptor());
+    packedReflectionTester.setPackedFieldsViaReflection(builder);
+    Message message = builder.build();
+
+    ByteString rawBytes = message.toByteString();
+    TestPackedTypes message2 = TestPackedTypes.parseFrom(rawBytes);
+
+    TestUtil.assertPackedFieldsSet(message2);
+
+    // In fact, the serialized forms should be exactly the same, byte-for-byte.
+    assertEquals(TestUtil.getPackedSet().toByteString(), rawBytes);
+  }
+
+  public void testDynamicMessagePackedParsing() throws Exception {
+    TestPackedTypes.Builder builder = TestPackedTypes.newBuilder();
+    TestUtil.setPackedFields(builder);
+    TestPackedTypes message = builder.build();
+
+    ByteString rawBytes = message.toByteString();
+
+    Message message2 =
+      DynamicMessage.parseFrom(TestPackedTypes.getDescriptor(), rawBytes);
+    packedReflectionTester.assertPackedFieldsSetViaReflection(message2);
+  }
+
   public void testDynamicMessageCopy() throws Exception {
     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
     TestUtil.setAllFields(builder);
@@ -131,4 +180,23 @@ public class DynamicMessageTest extends TestCase {
     DynamicMessage copy = DynamicMessage.newBuilder(message).build();
     reflectionTester.assertAllFieldsSetViaReflection(copy);
   }
+
+  public void testToBuilder() throws Exception {
+    DynamicMessage.Builder builder =
+        DynamicMessage.newBuilder(TestAllTypes.getDescriptor());
+    reflectionTester.setAllFieldsViaReflection(builder);
+    int unknownFieldNum = 9;
+    long unknownFieldVal = 90;
+    builder.setUnknownFields(UnknownFieldSet.newBuilder()
+        .addField(unknownFieldNum,
+            UnknownFieldSet.Field.newBuilder()
+                .addVarint(unknownFieldVal).build())
+        .build());
+    DynamicMessage message = builder.build();
+
+    DynamicMessage derived = message.toBuilder().build();
+    reflectionTester.assertAllFieldsSetViaReflection(derived);
+    assertEquals(Arrays.asList(unknownFieldVal),
+        derived.getUnknownFields().getField(unknownFieldNum).getVarintList());
+  }
 }
diff --git a/java/src/test/java/com/google/protobuf/GeneratedMessageTest.java b/java/src/test/java/com/google/protobuf/GeneratedMessageTest.java
index 95c269a2..0ecdc6ae 100644
--- a/java/src/test/java/com/google/protobuf/GeneratedMessageTest.java
+++ b/java/src/test/java/com/google/protobuf/GeneratedMessageTest.java
@@ -71,6 +71,72 @@ public class GeneratedMessageTest extends TestCase {
     TestUtil.assertAllFieldsSet(message);
   }
 
+  public void testSettersRejectNull() throws Exception {
+    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
+    try {
+      builder.setOptionalString(null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+    try {
+      builder.setOptionalBytes(null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+    try {
+      builder.setOptionalNestedMessage((TestAllTypes.NestedMessage) null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+    try {
+      builder.setOptionalNestedMessage(
+          (TestAllTypes.NestedMessage.Builder) null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+    try {
+      builder.setOptionalNestedEnum(null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+    try {
+      builder.addRepeatedString(null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+    try {
+      builder.addRepeatedBytes(null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+    try {
+      builder.addRepeatedNestedMessage((TestAllTypes.NestedMessage) null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+    try {
+      builder.addRepeatedNestedMessage(
+          (TestAllTypes.NestedMessage.Builder) null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+    try {
+      builder.addRepeatedNestedEnum(null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+  }
+
   public void testRepeatedSetters() throws Exception {
     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
     TestUtil.setAllFields(builder);
@@ -79,6 +145,55 @@ public class GeneratedMessageTest extends TestCase {
     TestUtil.assertRepeatedFieldsModified(message);
   }
 
+  public void testRepeatedSettersRejectNull() throws Exception {
+    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
+
+    builder.addRepeatedString("one");
+    builder.addRepeatedString("two");
+    try {
+      builder.setRepeatedString(1, null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+
+    builder.addRepeatedBytes(TestUtil.toBytes("one"));
+    builder.addRepeatedBytes(TestUtil.toBytes("two"));
+    try {
+      builder.setRepeatedBytes(1, null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+
+    builder.addRepeatedNestedMessage(
+      TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
+    builder.addRepeatedNestedMessage(
+      TestAllTypes.NestedMessage.newBuilder().setBb(456).build());
+    try {
+      builder.setRepeatedNestedMessage(1, (TestAllTypes.NestedMessage) null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+    try {
+      builder.setRepeatedNestedMessage(
+          1, (TestAllTypes.NestedMessage.Builder) null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+
+    builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.FOO);
+    builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAR);
+    try {
+      builder.setRepeatedNestedEnum(1, null);
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+  }
+
   public void testRepeatedAppend() throws Exception {
     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 
@@ -97,6 +212,42 @@ public class GeneratedMessageTest extends TestCase {
     assertEquals(12, message.getRepeatedForeignMessage(0).getC());
   }
 
+  public void testRepeatedAppendRejectsNull() throws Exception {
+    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
+
+    ForeignMessage foreignMessage =
+        ForeignMessage.newBuilder().setC(12).build();
+    try {
+      builder.addAllRepeatedForeignMessage(
+          Arrays.asList(foreignMessage, (ForeignMessage) null));
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+
+    try {
+      builder.addAllRepeatedForeignEnum(
+          Arrays.asList(ForeignEnum.FOREIGN_BAZ, null));
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+
+    try {
+      builder.addAllRepeatedString(Arrays.asList("one", null));
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+
+    try {
+      builder.addAllRepeatedBytes(Arrays.asList(TestUtil.toBytes("one"), null));
+      fail("Exception was not thrown");
+    } catch (NullPointerException e) {
+      // We expect this exception.
+    }
+  }
+
   public void testSettingForeignMessageUsingBuilder() throws Exception {
     TestAllTypes message = TestAllTypes.newBuilder()
         // Pass builder for foreign message instance.
@@ -146,6 +297,11 @@ public class GeneratedMessageTest extends TestCase {
     TestUtil.assertAllFieldsSet(message);
   }
 
+  public void testReflectionSettersRejectNull() throws Exception {
+    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
+    reflectionTester.assertReflectionSettersRejectNull(builder);
+  }
+
   public void testReflectionRepeatedSetters() throws Exception {
     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
     reflectionTester.setAllFieldsViaReflection(builder);
@@ -154,6 +310,11 @@ public class GeneratedMessageTest extends TestCase {
     TestUtil.assertRepeatedFieldsModified(message);
   }
 
+  public void testReflectionRepeatedSettersRejectNull() throws Exception {
+    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
+    reflectionTester.assertReflectionRepeatedSettersRejectNull(builder);
+  }
+
   public void testReflectionDefaults() throws Exception {
     reflectionTester.assertClearViaReflection(
       TestAllTypes.getDefaultInstance());
@@ -161,6 +322,11 @@ public class GeneratedMessageTest extends TestCase {
       TestAllTypes.newBuilder().build());
   }
 
+  public void testEnumInterface() throws Exception {
+    assertTrue(TestAllTypes.getDefaultInstance().getDefaultNestedEnum()
+        instanceof ProtocolMessageEnum);
+  }
+
   // =================================================================
   // Extensions.
 
@@ -202,6 +368,11 @@ public class GeneratedMessageTest extends TestCase {
     TestUtil.assertAllExtensionsSet(message);
   }
 
+  public void testExtensionReflectionSettersRejectNull() throws Exception {
+    TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
+    extensionsReflectionTester.assertReflectionSettersRejectNull(builder);
+  }
+
   public void testExtensionReflectionRepeatedSetters() throws Exception {
     TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
     extensionsReflectionTester.setAllFieldsViaReflection(builder);
@@ -210,6 +381,13 @@ public class GeneratedMessageTest extends TestCase {
     TestUtil.assertRepeatedExtensionsModified(message);
   }
 
+  public void testExtensionReflectionRepeatedSettersRejectNull()
+      throws Exception {
+    TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
+    extensionsReflectionTester.assertReflectionRepeatedSettersRejectNull(
+        builder);
+  }
+
   public void testExtensionReflectionDefaults() throws Exception {
     extensionsReflectionTester.assertClearViaReflection(
       TestAllExtensions.getDefaultInstance());
@@ -231,6 +409,17 @@ public class GeneratedMessageTest extends TestCase {
         .getExtensionCount(UnittestProto.repeatedInt32Extension));
   }
 
+  public void testExtensionMergeFrom() throws Exception {
+    TestAllExtensions original =
+      TestAllExtensions.newBuilder()
+        .setExtension(UnittestProto.optionalInt32Extension, 1).build();
+    TestAllExtensions merged =
+        TestAllExtensions.newBuilder().mergeFrom(original).build();
+    assertTrue(merged.hasExtension(UnittestProto.optionalInt32Extension));
+    assertEquals(
+        1, (int) merged.getExtension(UnittestProto.optionalInt32Extension));
+  }
+
   // =================================================================
   // multiple_files_test
 
@@ -266,7 +455,7 @@ public class GeneratedMessageTest extends TestCase {
     TestOptionalOptimizedForSize message =
         TestOptionalOptimizedForSize.getDefaultInstance();
     assertTrue(message.isInitialized());
-    
+
     message = TestOptionalOptimizedForSize.newBuilder().setO(
         TestRequiredOptimizedForSize.newBuilder().buildPartial()
         ).buildPartial();
@@ -292,4 +481,11 @@ public class GeneratedMessageTest extends TestCase {
     assertTrue(builder.isInitialized());
     assertTrue(builder.buildPartial().isInitialized());
   }
+
+  public void testToBuilder() throws Exception {
+    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
+    TestUtil.setAllFields(builder);
+    TestAllTypes message = builder.build();
+    TestUtil.assertAllFieldsSet(message.toBuilder().build());
+  }
 }
diff --git a/java/src/test/java/com/google/protobuf/TestUtil.java b/java/src/test/java/com/google/protobuf/TestUtil.java
index d99ab85e..2f47b714 100644
--- a/java/src/test/java/com/google/protobuf/TestUtil.java
+++ b/java/src/test/java/com/google/protobuf/TestUtil.java
@@ -28,17 +28,105 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// Note:  This file contains many lines over 80 characters.  It even contains
-// many lines over 100 characters, which fails a presubmit test.  However,
-// given the extremely repetitive nature of the file, I (kenton) feel that
-// having similar components of each statement line up is more important than
-// avoiding horizontal scrolling.  So, I am bypassing the presubmit check.
-
 package com.google.protobuf;
 
 import protobuf_unittest.UnittestProto;
-import protobuf_unittest.UnittestProto.TestAllTypes;
+
+// The static imports are to avoid 100+ char lines.  The following is roughly equivalent to
+// import static protobuf_unittest.UnittestProto.*;
+import static protobuf_unittest.UnittestProto.defaultInt32Extension;
+import static protobuf_unittest.UnittestProto.defaultInt64Extension;
+import static protobuf_unittest.UnittestProto.defaultUint32Extension;
+import static protobuf_unittest.UnittestProto.defaultUint64Extension;
+import static protobuf_unittest.UnittestProto.defaultSint32Extension;
+import static protobuf_unittest.UnittestProto.defaultSint64Extension;
+import static protobuf_unittest.UnittestProto.defaultFixed32Extension;
+import static protobuf_unittest.UnittestProto.defaultFixed64Extension;
+import static protobuf_unittest.UnittestProto.defaultSfixed32Extension;
+import static protobuf_unittest.UnittestProto.defaultSfixed64Extension;
+import static protobuf_unittest.UnittestProto.defaultFloatExtension;
+import static protobuf_unittest.UnittestProto.defaultDoubleExtension;
+import static protobuf_unittest.UnittestProto.defaultBoolExtension;
+import static protobuf_unittest.UnittestProto.defaultStringExtension;
+import static protobuf_unittest.UnittestProto.defaultBytesExtension;
+import static protobuf_unittest.UnittestProto.defaultNestedEnumExtension;
+import static protobuf_unittest.UnittestProto.defaultForeignEnumExtension;
+import static protobuf_unittest.UnittestProto.defaultImportEnumExtension;
+import static protobuf_unittest.UnittestProto.defaultStringPieceExtension;
+import static protobuf_unittest.UnittestProto.defaultCordExtension;
+
+import static protobuf_unittest.UnittestProto.optionalInt32Extension;
+import static protobuf_unittest.UnittestProto.optionalInt64Extension;
+import static protobuf_unittest.UnittestProto.optionalUint32Extension;
+import static protobuf_unittest.UnittestProto.optionalUint64Extension;
+import static protobuf_unittest.UnittestProto.optionalSint32Extension;
+import static protobuf_unittest.UnittestProto.optionalSint64Extension;
+import static protobuf_unittest.UnittestProto.optionalFixed32Extension;
+import static protobuf_unittest.UnittestProto.optionalFixed64Extension;
+import static protobuf_unittest.UnittestProto.optionalSfixed32Extension;
+import static protobuf_unittest.UnittestProto.optionalSfixed64Extension;
+import static protobuf_unittest.UnittestProto.optionalFloatExtension;
+import static protobuf_unittest.UnittestProto.optionalDoubleExtension;
+import static protobuf_unittest.UnittestProto.optionalBoolExtension;
+import static protobuf_unittest.UnittestProto.optionalStringExtension;
+import static protobuf_unittest.UnittestProto.optionalBytesExtension;
+import static protobuf_unittest.UnittestProto.optionalGroupExtension;
+import static protobuf_unittest.UnittestProto.optionalNestedMessageExtension;
+import static protobuf_unittest.UnittestProto.optionalForeignMessageExtension;
+import static protobuf_unittest.UnittestProto.optionalImportMessageExtension;
+import static protobuf_unittest.UnittestProto.optionalNestedEnumExtension;
+import static protobuf_unittest.UnittestProto.optionalForeignEnumExtension;
+import static protobuf_unittest.UnittestProto.optionalImportEnumExtension;
+import static protobuf_unittest.UnittestProto.optionalStringPieceExtension;
+import static protobuf_unittest.UnittestProto.optionalCordExtension;
+
+import static protobuf_unittest.UnittestProto.repeatedInt32Extension;
+import static protobuf_unittest.UnittestProto.repeatedInt64Extension;
+import static protobuf_unittest.UnittestProto.repeatedUint32Extension;
+import static protobuf_unittest.UnittestProto.repeatedUint64Extension;
+import static protobuf_unittest.UnittestProto.repeatedSint32Extension;
+import static protobuf_unittest.UnittestProto.repeatedSint64Extension;
+import static protobuf_unittest.UnittestProto.repeatedFixed32Extension;
+import static protobuf_unittest.UnittestProto.repeatedFixed64Extension;
+import static protobuf_unittest.UnittestProto.repeatedSfixed32Extension;
+import static protobuf_unittest.UnittestProto.repeatedSfixed64Extension;
+import static protobuf_unittest.UnittestProto.repeatedFloatExtension;
+import static protobuf_unittest.UnittestProto.repeatedDoubleExtension;
+import static protobuf_unittest.UnittestProto.repeatedBoolExtension;
+import static protobuf_unittest.UnittestProto.repeatedStringExtension;
+import static protobuf_unittest.UnittestProto.repeatedBytesExtension;
+import static protobuf_unittest.UnittestProto.repeatedGroupExtension;
+import static protobuf_unittest.UnittestProto.repeatedNestedMessageExtension;
+import static protobuf_unittest.UnittestProto.repeatedForeignMessageExtension;
+import static protobuf_unittest.UnittestProto.repeatedImportMessageExtension;
+import static protobuf_unittest.UnittestProto.repeatedNestedEnumExtension;
+import static protobuf_unittest.UnittestProto.repeatedForeignEnumExtension;
+import static protobuf_unittest.UnittestProto.repeatedImportEnumExtension;
+import static protobuf_unittest.UnittestProto.repeatedStringPieceExtension;
+import static protobuf_unittest.UnittestProto.repeatedCordExtension;
+
+import static protobuf_unittest.UnittestProto.OptionalGroup_extension;
+import static protobuf_unittest.UnittestProto.RepeatedGroup_extension;
+
+import static protobuf_unittest.UnittestProto.packedInt32Extension;
+import static protobuf_unittest.UnittestProto.packedInt64Extension;
+import static protobuf_unittest.UnittestProto.packedUint32Extension;
+import static protobuf_unittest.UnittestProto.packedUint64Extension;
+import static protobuf_unittest.UnittestProto.packedSint32Extension;
+import static protobuf_unittest.UnittestProto.packedSint64Extension;
+import static protobuf_unittest.UnittestProto.packedFixed32Extension;
+import static protobuf_unittest.UnittestProto.packedFixed64Extension;
+import static protobuf_unittest.UnittestProto.packedSfixed32Extension;
+import static protobuf_unittest.UnittestProto.packedSfixed64Extension;
+import static protobuf_unittest.UnittestProto.packedFloatExtension;
+import static protobuf_unittest.UnittestProto.packedDoubleExtension;
+import static protobuf_unittest.UnittestProto.packedBoolExtension;
+import static protobuf_unittest.UnittestProto.packedEnumExtension;
+
 import protobuf_unittest.UnittestProto.TestAllExtensions;
+import protobuf_unittest.UnittestProto.TestAllTypes;
+import protobuf_unittest.UnittestProto.TestPackedExtensions;
+import protobuf_unittest.UnittestProto.TestPackedTypes;
 import protobuf_unittest.UnittestProto.ForeignMessage;
 import protobuf_unittest.UnittestProto.ForeignEnum;
 import com.google.protobuf.test.UnittestImport.ImportMessage;
@@ -63,7 +151,7 @@ class TestUtil {
   private TestUtil() {}
 
   /** Helper to convert a String to ByteString. */
-  private static ByteString toBytes(String str) {
+  static ByteString toBytes(String str) {
     try {
       return ByteString.copyFrom(str.getBytes("UTF-8"));
     } catch(java.io.UnsupportedEncodingException e) {
@@ -91,6 +179,18 @@ class TestUtil {
     return builder.build();
   }
 
+  public static TestPackedTypes getPackedSet() {
+    TestPackedTypes.Builder builder = TestPackedTypes.newBuilder();
+    setPackedFields(builder);
+    return builder.build();
+  }
+
+  public static TestPackedExtensions getPackedExtensionsSet() {
+    TestPackedExtensions.Builder builder = TestPackedExtensions.newBuilder();
+    setPackedExtensions(builder);
+    return builder.build();
+  }
+
   /**
    * Set every field of {@code message} to the values expected by
    * {@code assertAllFieldsSet()}.
@@ -770,141 +870,129 @@ class TestUtil {
    * {@code assertAllExtensionsSet()}.
    */
   public static void setAllExtensions(TestAllExtensions.Builder message) {
-    message.setExtension(UnittestProto.optionalInt32Extension   , 101);
-    message.setExtension(UnittestProto.optionalInt64Extension   , 102L);
-    message.setExtension(UnittestProto.optionalUint32Extension  , 103);
-    message.setExtension(UnittestProto.optionalUint64Extension  , 104L);
-    message.setExtension(UnittestProto.optionalSint32Extension  , 105);
-    message.setExtension(UnittestProto.optionalSint64Extension  , 106L);
-    message.setExtension(UnittestProto.optionalFixed32Extension , 107);
-    message.setExtension(UnittestProto.optionalFixed64Extension , 108L);
-    message.setExtension(UnittestProto.optionalSfixed32Extension, 109);
-    message.setExtension(UnittestProto.optionalSfixed64Extension, 110L);
-    message.setExtension(UnittestProto.optionalFloatExtension   , 111F);
-    message.setExtension(UnittestProto.optionalDoubleExtension  , 112D);
-    message.setExtension(UnittestProto.optionalBoolExtension    , true);
-    message.setExtension(UnittestProto.optionalStringExtension  , "115");
-    message.setExtension(UnittestProto.optionalBytesExtension   , toBytes("116"));
-
-    message.setExtension(UnittestProto.optionalGroupExtension,
-      UnittestProto.OptionalGroup_extension.newBuilder().setA(117).build());
-    message.setExtension(UnittestProto.optionalNestedMessageExtension,
+    message.setExtension(optionalInt32Extension   , 101);
+    message.setExtension(optionalInt64Extension   , 102L);
+    message.setExtension(optionalUint32Extension  , 103);
+    message.setExtension(optionalUint64Extension  , 104L);
+    message.setExtension(optionalSint32Extension  , 105);
+    message.setExtension(optionalSint64Extension  , 106L);
+    message.setExtension(optionalFixed32Extension , 107);
+    message.setExtension(optionalFixed64Extension , 108L);
+    message.setExtension(optionalSfixed32Extension, 109);
+    message.setExtension(optionalSfixed64Extension, 110L);
+    message.setExtension(optionalFloatExtension   , 111F);
+    message.setExtension(optionalDoubleExtension  , 112D);
+    message.setExtension(optionalBoolExtension    , true);
+    message.setExtension(optionalStringExtension  , "115");
+    message.setExtension(optionalBytesExtension   , toBytes("116"));
+
+    message.setExtension(optionalGroupExtension,
+      OptionalGroup_extension.newBuilder().setA(117).build());
+    message.setExtension(optionalNestedMessageExtension,
       TestAllTypes.NestedMessage.newBuilder().setBb(118).build());
-    message.setExtension(UnittestProto.optionalForeignMessageExtension,
+    message.setExtension(optionalForeignMessageExtension,
       ForeignMessage.newBuilder().setC(119).build());
-    message.setExtension(UnittestProto.optionalImportMessageExtension,
+    message.setExtension(optionalImportMessageExtension,
       ImportMessage.newBuilder().setD(120).build());
 
-    message.setExtension(UnittestProto.optionalNestedEnumExtension,
-                         TestAllTypes.NestedEnum.BAZ);
-    message.setExtension(UnittestProto.optionalForeignEnumExtension,
-                         ForeignEnum.FOREIGN_BAZ);
-    message.setExtension(UnittestProto.optionalImportEnumExtension,
-                         ImportEnum.IMPORT_BAZ);
+    message.setExtension(optionalNestedEnumExtension, TestAllTypes.NestedEnum.BAZ);
+    message.setExtension(optionalForeignEnumExtension, ForeignEnum.FOREIGN_BAZ);
+    message.setExtension(optionalImportEnumExtension, ImportEnum.IMPORT_BAZ);
 
-    message.setExtension(UnittestProto.optionalStringPieceExtension, "124");
-    message.setExtension(UnittestProto.optionalCordExtension, "125");
+    message.setExtension(optionalStringPieceExtension, "124");
+    message.setExtension(optionalCordExtension, "125");
 
     // -----------------------------------------------------------------
 
-    message.addExtension(UnittestProto.repeatedInt32Extension   , 201);
-    message.addExtension(UnittestProto.repeatedInt64Extension   , 202L);
-    message.addExtension(UnittestProto.repeatedUint32Extension  , 203);
-    message.addExtension(UnittestProto.repeatedUint64Extension  , 204L);
-    message.addExtension(UnittestProto.repeatedSint32Extension  , 205);
-    message.addExtension(UnittestProto.repeatedSint64Extension  , 206L);
-    message.addExtension(UnittestProto.repeatedFixed32Extension , 207);
-    message.addExtension(UnittestProto.repeatedFixed64Extension , 208L);
-    message.addExtension(UnittestProto.repeatedSfixed32Extension, 209);
-    message.addExtension(UnittestProto.repeatedSfixed64Extension, 210L);
-    message.addExtension(UnittestProto.repeatedFloatExtension   , 211F);
-    message.addExtension(UnittestProto.repeatedDoubleExtension  , 212D);
-    message.addExtension(UnittestProto.repeatedBoolExtension    , true);
-    message.addExtension(UnittestProto.repeatedStringExtension  , "215");
-    message.addExtension(UnittestProto.repeatedBytesExtension   , toBytes("216"));
-
-    message.addExtension(UnittestProto.repeatedGroupExtension,
-      UnittestProto.RepeatedGroup_extension.newBuilder().setA(217).build());
-    message.addExtension(UnittestProto.repeatedNestedMessageExtension,
+    message.addExtension(repeatedInt32Extension   , 201);
+    message.addExtension(repeatedInt64Extension   , 202L);
+    message.addExtension(repeatedUint32Extension  , 203);
+    message.addExtension(repeatedUint64Extension  , 204L);
+    message.addExtension(repeatedSint32Extension  , 205);
+    message.addExtension(repeatedSint64Extension  , 206L);
+    message.addExtension(repeatedFixed32Extension , 207);
+    message.addExtension(repeatedFixed64Extension , 208L);
+    message.addExtension(repeatedSfixed32Extension, 209);
+    message.addExtension(repeatedSfixed64Extension, 210L);
+    message.addExtension(repeatedFloatExtension   , 211F);
+    message.addExtension(repeatedDoubleExtension  , 212D);
+    message.addExtension(repeatedBoolExtension    , true);
+    message.addExtension(repeatedStringExtension  , "215");
+    message.addExtension(repeatedBytesExtension   , toBytes("216"));
+
+    message.addExtension(repeatedGroupExtension,
+      RepeatedGroup_extension.newBuilder().setA(217).build());
+    message.addExtension(repeatedNestedMessageExtension,
       TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
-    message.addExtension(UnittestProto.repeatedForeignMessageExtension,
+    message.addExtension(repeatedForeignMessageExtension,
       ForeignMessage.newBuilder().setC(219).build());
-    message.addExtension(UnittestProto.repeatedImportMessageExtension,
+    message.addExtension(repeatedImportMessageExtension,
       ImportMessage.newBuilder().setD(220).build());
 
-    message.addExtension(UnittestProto.repeatedNestedEnumExtension,
-                         TestAllTypes.NestedEnum.BAR);
-    message.addExtension(UnittestProto.repeatedForeignEnumExtension,
-                         ForeignEnum.FOREIGN_BAR);
-    message.addExtension(UnittestProto.repeatedImportEnumExtension,
-                         ImportEnum.IMPORT_BAR);
+    message.addExtension(repeatedNestedEnumExtension, TestAllTypes.NestedEnum.BAR);
+    message.addExtension(repeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAR);
+    message.addExtension(repeatedImportEnumExtension, ImportEnum.IMPORT_BAR);
 
-    message.addExtension(UnittestProto.repeatedStringPieceExtension, "224");
-    message.addExtension(UnittestProto.repeatedCordExtension, "225");
+    message.addExtension(repeatedStringPieceExtension, "224");
+    message.addExtension(repeatedCordExtension, "225");
 
     // Add a second one of each field.
-    message.addExtension(UnittestProto.repeatedInt32Extension   , 301);
-    message.addExtension(UnittestProto.repeatedInt64Extension   , 302L);
-    message.addExtension(UnittestProto.repeatedUint32Extension  , 303);
-    message.addExtension(UnittestProto.repeatedUint64Extension  , 304L);
-    message.addExtension(UnittestProto.repeatedSint32Extension  , 305);
-    message.addExtension(UnittestProto.repeatedSint64Extension  , 306L);
-    message.addExtension(UnittestProto.repeatedFixed32Extension , 307);
-    message.addExtension(UnittestProto.repeatedFixed64Extension , 308L);
-    message.addExtension(UnittestProto.repeatedSfixed32Extension, 309);
-    message.addExtension(UnittestProto.repeatedSfixed64Extension, 310L);
-    message.addExtension(UnittestProto.repeatedFloatExtension   , 311F);
-    message.addExtension(UnittestProto.repeatedDoubleExtension  , 312D);
-    message.addExtension(UnittestProto.repeatedBoolExtension    , false);
-    message.addExtension(UnittestProto.repeatedStringExtension  , "315");
-    message.addExtension(UnittestProto.repeatedBytesExtension   , toBytes("316"));
-
-    message.addExtension(UnittestProto.repeatedGroupExtension,
-      UnittestProto.RepeatedGroup_extension.newBuilder().setA(317).build());
-    message.addExtension(UnittestProto.repeatedNestedMessageExtension,
+    message.addExtension(repeatedInt32Extension   , 301);
+    message.addExtension(repeatedInt64Extension   , 302L);
+    message.addExtension(repeatedUint32Extension  , 303);
+    message.addExtension(repeatedUint64Extension  , 304L);
+    message.addExtension(repeatedSint32Extension  , 305);
+    message.addExtension(repeatedSint64Extension  , 306L);
+    message.addExtension(repeatedFixed32Extension , 307);
+    message.addExtension(repeatedFixed64Extension , 308L);
+    message.addExtension(repeatedSfixed32Extension, 309);
+    message.addExtension(repeatedSfixed64Extension, 310L);
+    message.addExtension(repeatedFloatExtension   , 311F);
+    message.addExtension(repeatedDoubleExtension  , 312D);
+    message.addExtension(repeatedBoolExtension    , false);
+    message.addExtension(repeatedStringExtension  , "315");
+    message.addExtension(repeatedBytesExtension   , toBytes("316"));
+
+    message.addExtension(repeatedGroupExtension,
+      RepeatedGroup_extension.newBuilder().setA(317).build());
+    message.addExtension(repeatedNestedMessageExtension,
       TestAllTypes.NestedMessage.newBuilder().setBb(318).build());
-    message.addExtension(UnittestProto.repeatedForeignMessageExtension,
+    message.addExtension(repeatedForeignMessageExtension,
       ForeignMessage.newBuilder().setC(319).build());
-    message.addExtension(UnittestProto.repeatedImportMessageExtension,
+    message.addExtension(repeatedImportMessageExtension,
       ImportMessage.newBuilder().setD(320).build());
 
-    message.addExtension(UnittestProto.repeatedNestedEnumExtension,
-                         TestAllTypes.NestedEnum.BAZ);
-    message.addExtension(UnittestProto.repeatedForeignEnumExtension,
-                         ForeignEnum.FOREIGN_BAZ);
-    message.addExtension(UnittestProto.repeatedImportEnumExtension,
-                         ImportEnum.IMPORT_BAZ);
+    message.addExtension(repeatedNestedEnumExtension, TestAllTypes.NestedEnum.BAZ);
+    message.addExtension(repeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAZ);
+    message.addExtension(repeatedImportEnumExtension, ImportEnum.IMPORT_BAZ);
 
-    message.addExtension(UnittestProto.repeatedStringPieceExtension, "324");
-    message.addExtension(UnittestProto.repeatedCordExtension, "325");
+    message.addExtension(repeatedStringPieceExtension, "324");
+    message.addExtension(repeatedCordExtension, "325");
 
     // -----------------------------------------------------------------
 
-    message.setExtension(UnittestProto.defaultInt32Extension   , 401);
-    message.setExtension(UnittestProto.defaultInt64Extension   , 402L);
-    message.setExtension(UnittestProto.defaultUint32Extension  , 403);
-    message.setExtension(UnittestProto.defaultUint64Extension  , 404L);
-    message.setExtension(UnittestProto.defaultSint32Extension  , 405);
-    message.setExtension(UnittestProto.defaultSint64Extension  , 406L);
-    message.setExtension(UnittestProto.defaultFixed32Extension , 407);
-    message.setExtension(UnittestProto.defaultFixed64Extension , 408L);
-    message.setExtension(UnittestProto.defaultSfixed32Extension, 409);
-    message.setExtension(UnittestProto.defaultSfixed64Extension, 410L);
-    message.setExtension(UnittestProto.defaultFloatExtension   , 411F);
-    message.setExtension(UnittestProto.defaultDoubleExtension  , 412D);
-    message.setExtension(UnittestProto.defaultBoolExtension    , false);
-    message.setExtension(UnittestProto.defaultStringExtension  , "415");
-    message.setExtension(UnittestProto.defaultBytesExtension   , toBytes("416"));
-
-    message.setExtension(UnittestProto.defaultNestedEnumExtension,
-                         TestAllTypes.NestedEnum.FOO);
-    message.setExtension(UnittestProto.defaultForeignEnumExtension,
-                         ForeignEnum.FOREIGN_FOO);
-    message.setExtension(UnittestProto.defaultImportEnumExtension,
-                         ImportEnum.IMPORT_FOO);
-
-    message.setExtension(UnittestProto.defaultStringPieceExtension, "424");
-    message.setExtension(UnittestProto.defaultCordExtension, "425");
+    message.setExtension(defaultInt32Extension   , 401);
+    message.setExtension(defaultInt64Extension   , 402L);
+    message.setExtension(defaultUint32Extension  , 403);
+    message.setExtension(defaultUint64Extension  , 404L);
+    message.setExtension(defaultSint32Extension  , 405);
+    message.setExtension(defaultSint64Extension  , 406L);
+    message.setExtension(defaultFixed32Extension , 407);
+    message.setExtension(defaultFixed64Extension , 408L);
+    message.setExtension(defaultSfixed32Extension, 409);
+    message.setExtension(defaultSfixed64Extension, 410L);
+    message.setExtension(defaultFloatExtension   , 411F);
+    message.setExtension(defaultDoubleExtension  , 412D);
+    message.setExtension(defaultBoolExtension    , false);
+    message.setExtension(defaultStringExtension  , "415");
+    message.setExtension(defaultBytesExtension   , toBytes("416"));
+
+    message.setExtension(defaultNestedEnumExtension, TestAllTypes.NestedEnum.FOO);
+    message.setExtension(defaultForeignEnumExtension, ForeignEnum.FOREIGN_FOO);
+    message.setExtension(defaultImportEnumExtension, ImportEnum.IMPORT_FOO);
+
+    message.setExtension(defaultStringPieceExtension, "424");
+    message.setExtension(defaultCordExtension, "425");
   }
 
   // -------------------------------------------------------------------
@@ -915,40 +1003,37 @@ class TestUtil {
    */
   public static void modifyRepeatedExtensions(
       TestAllExtensions.Builder message) {
-    message.setExtension(UnittestProto.repeatedInt32Extension   , 1, 501);
-    message.setExtension(UnittestProto.repeatedInt64Extension   , 1, 502L);
-    message.setExtension(UnittestProto.repeatedUint32Extension  , 1, 503);
-    message.setExtension(UnittestProto.repeatedUint64Extension  , 1, 504L);
-    message.setExtension(UnittestProto.repeatedSint32Extension  , 1, 505);
-    message.setExtension(UnittestProto.repeatedSint64Extension  , 1, 506L);
-    message.setExtension(UnittestProto.repeatedFixed32Extension , 1, 507);
-    message.setExtension(UnittestProto.repeatedFixed64Extension , 1, 508L);
-    message.setExtension(UnittestProto.repeatedSfixed32Extension, 1, 509);
-    message.setExtension(UnittestProto.repeatedSfixed64Extension, 1, 510L);
-    message.setExtension(UnittestProto.repeatedFloatExtension   , 1, 511F);
-    message.setExtension(UnittestProto.repeatedDoubleExtension  , 1, 512D);
-    message.setExtension(UnittestProto.repeatedBoolExtension    , 1, true);
-    message.setExtension(UnittestProto.repeatedStringExtension  , 1, "515");
-    message.setExtension(UnittestProto.repeatedBytesExtension   , 1, toBytes("516"));
-
-    message.setExtension(UnittestProto.repeatedGroupExtension, 1,
-      UnittestProto.RepeatedGroup_extension.newBuilder().setA(517).build());
-    message.setExtension(UnittestProto.repeatedNestedMessageExtension, 1,
+    message.setExtension(repeatedInt32Extension   , 1, 501);
+    message.setExtension(repeatedInt64Extension   , 1, 502L);
+    message.setExtension(repeatedUint32Extension  , 1, 503);
+    message.setExtension(repeatedUint64Extension  , 1, 504L);
+    message.setExtension(repeatedSint32Extension  , 1, 505);
+    message.setExtension(repeatedSint64Extension  , 1, 506L);
+    message.setExtension(repeatedFixed32Extension , 1, 507);
+    message.setExtension(repeatedFixed64Extension , 1, 508L);
+    message.setExtension(repeatedSfixed32Extension, 1, 509);
+    message.setExtension(repeatedSfixed64Extension, 1, 510L);
+    message.setExtension(repeatedFloatExtension   , 1, 511F);
+    message.setExtension(repeatedDoubleExtension  , 1, 512D);
+    message.setExtension(repeatedBoolExtension    , 1, true);
+    message.setExtension(repeatedStringExtension  , 1, "515");
+    message.setExtension(repeatedBytesExtension   , 1, toBytes("516"));
+
+    message.setExtension(repeatedGroupExtension, 1,
+      RepeatedGroup_extension.newBuilder().setA(517).build());
+    message.setExtension(repeatedNestedMessageExtension, 1,
       TestAllTypes.NestedMessage.newBuilder().setBb(518).build());
-    message.setExtension(UnittestProto.repeatedForeignMessageExtension, 1,
+    message.setExtension(repeatedForeignMessageExtension, 1,
       ForeignMessage.newBuilder().setC(519).build());
-    message.setExtension(UnittestProto.repeatedImportMessageExtension, 1,
+    message.setExtension(repeatedImportMessageExtension, 1,
       ImportMessage.newBuilder().setD(520).build());
 
-    message.setExtension(UnittestProto.repeatedNestedEnumExtension , 1,
-                         TestAllTypes.NestedEnum.FOO);
-    message.setExtension(UnittestProto.repeatedForeignEnumExtension, 1,
-                         ForeignEnum.FOREIGN_FOO);
-    message.setExtension(UnittestProto.repeatedImportEnumExtension , 1,
-                         ImportEnum.IMPORT_FOO);
+    message.setExtension(repeatedNestedEnumExtension , 1, TestAllTypes.NestedEnum.FOO);
+    message.setExtension(repeatedForeignEnumExtension, 1, ForeignEnum.FOREIGN_FOO);
+    message.setExtension(repeatedImportEnumExtension , 1, ImportEnum.IMPORT_FOO);
 
-    message.setExtension(UnittestProto.repeatedStringPieceExtension, 1, "524");
-    message.setExtension(UnittestProto.repeatedCordExtension, 1, "525");
+    message.setExtension(repeatedStringPieceExtension, 1, "524");
+    message.setExtension(repeatedCordExtension, 1, "525");
   }
 
   // -------------------------------------------------------------------
@@ -958,211 +1043,211 @@ class TestUtil {
    * {@code message} are set to the values assigned by {@code setAllExtensions}.
    */
   public static void assertAllExtensionsSet(TestAllExtensions message) {
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalInt32Extension   ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalInt64Extension   ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalUint32Extension  ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalUint64Extension  ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalSint32Extension  ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalSint64Extension  ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalFixed32Extension ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalFixed64Extension ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalSfixed32Extension));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalSfixed64Extension));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalFloatExtension   ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalDoubleExtension  ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalBoolExtension    ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalStringExtension  ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalBytesExtension   ));
-
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalGroupExtension         ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalNestedMessageExtension ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalForeignMessageExtension));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalImportMessageExtension ));
-
-    Assert.assertTrue(message.getExtension(UnittestProto.optionalGroupExtension         ).hasA());
-    Assert.assertTrue(message.getExtension(UnittestProto.optionalNestedMessageExtension ).hasBb());
-    Assert.assertTrue(message.getExtension(UnittestProto.optionalForeignMessageExtension).hasC());
-    Assert.assertTrue(message.getExtension(UnittestProto.optionalImportMessageExtension ).hasD());
-
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalNestedEnumExtension ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalForeignEnumExtension));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalImportEnumExtension ));
-
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalStringPieceExtension));
-    Assert.assertTrue(message.hasExtension(UnittestProto.optionalCordExtension));
-
-    assertEqualsExactType(101  , message.getExtension(UnittestProto.optionalInt32Extension   ));
-    assertEqualsExactType(102L , message.getExtension(UnittestProto.optionalInt64Extension   ));
-    assertEqualsExactType(103  , message.getExtension(UnittestProto.optionalUint32Extension  ));
-    assertEqualsExactType(104L , message.getExtension(UnittestProto.optionalUint64Extension  ));
-    assertEqualsExactType(105  , message.getExtension(UnittestProto.optionalSint32Extension  ));
-    assertEqualsExactType(106L , message.getExtension(UnittestProto.optionalSint64Extension  ));
-    assertEqualsExactType(107  , message.getExtension(UnittestProto.optionalFixed32Extension ));
-    assertEqualsExactType(108L , message.getExtension(UnittestProto.optionalFixed64Extension ));
-    assertEqualsExactType(109  , message.getExtension(UnittestProto.optionalSfixed32Extension));
-    assertEqualsExactType(110L , message.getExtension(UnittestProto.optionalSfixed64Extension));
-    assertEqualsExactType(111F , message.getExtension(UnittestProto.optionalFloatExtension   ));
-    assertEqualsExactType(112D , message.getExtension(UnittestProto.optionalDoubleExtension  ));
-    assertEqualsExactType(true , message.getExtension(UnittestProto.optionalBoolExtension    ));
-    assertEqualsExactType("115", message.getExtension(UnittestProto.optionalStringExtension  ));
-    assertEqualsExactType(toBytes("116"), message.getExtension(UnittestProto.optionalBytesExtension));
-
-    assertEqualsExactType(117, message.getExtension(UnittestProto.optionalGroupExtension         ).getA());
-    assertEqualsExactType(118, message.getExtension(UnittestProto.optionalNestedMessageExtension ).getBb());
-    assertEqualsExactType(119, message.getExtension(UnittestProto.optionalForeignMessageExtension).getC());
-    assertEqualsExactType(120, message.getExtension(UnittestProto.optionalImportMessageExtension ).getD());
+    Assert.assertTrue(message.hasExtension(optionalInt32Extension   ));
+    Assert.assertTrue(message.hasExtension(optionalInt64Extension   ));
+    Assert.assertTrue(message.hasExtension(optionalUint32Extension  ));
+    Assert.assertTrue(message.hasExtension(optionalUint64Extension  ));
+    Assert.assertTrue(message.hasExtension(optionalSint32Extension  ));
+    Assert.assertTrue(message.hasExtension(optionalSint64Extension  ));
+    Assert.assertTrue(message.hasExtension(optionalFixed32Extension ));
+    Assert.assertTrue(message.hasExtension(optionalFixed64Extension ));
+    Assert.assertTrue(message.hasExtension(optionalSfixed32Extension));
+    Assert.assertTrue(message.hasExtension(optionalSfixed64Extension));
+    Assert.assertTrue(message.hasExtension(optionalFloatExtension   ));
+    Assert.assertTrue(message.hasExtension(optionalDoubleExtension  ));
+    Assert.assertTrue(message.hasExtension(optionalBoolExtension    ));
+    Assert.assertTrue(message.hasExtension(optionalStringExtension  ));
+    Assert.assertTrue(message.hasExtension(optionalBytesExtension   ));
+
+    Assert.assertTrue(message.hasExtension(optionalGroupExtension         ));
+    Assert.assertTrue(message.hasExtension(optionalNestedMessageExtension ));
+    Assert.assertTrue(message.hasExtension(optionalForeignMessageExtension));
+    Assert.assertTrue(message.hasExtension(optionalImportMessageExtension ));
+
+    Assert.assertTrue(message.getExtension(optionalGroupExtension         ).hasA());
+    Assert.assertTrue(message.getExtension(optionalNestedMessageExtension ).hasBb());
+    Assert.assertTrue(message.getExtension(optionalForeignMessageExtension).hasC());
+    Assert.assertTrue(message.getExtension(optionalImportMessageExtension ).hasD());
+
+    Assert.assertTrue(message.hasExtension(optionalNestedEnumExtension ));
+    Assert.assertTrue(message.hasExtension(optionalForeignEnumExtension));
+    Assert.assertTrue(message.hasExtension(optionalImportEnumExtension ));
+
+    Assert.assertTrue(message.hasExtension(optionalStringPieceExtension));
+    Assert.assertTrue(message.hasExtension(optionalCordExtension));
+
+    assertEqualsExactType(101  , message.getExtension(optionalInt32Extension   ));
+    assertEqualsExactType(102L , message.getExtension(optionalInt64Extension   ));
+    assertEqualsExactType(103  , message.getExtension(optionalUint32Extension  ));
+    assertEqualsExactType(104L , message.getExtension(optionalUint64Extension  ));
+    assertEqualsExactType(105  , message.getExtension(optionalSint32Extension  ));
+    assertEqualsExactType(106L , message.getExtension(optionalSint64Extension  ));
+    assertEqualsExactType(107  , message.getExtension(optionalFixed32Extension ));
+    assertEqualsExactType(108L , message.getExtension(optionalFixed64Extension ));
+    assertEqualsExactType(109  , message.getExtension(optionalSfixed32Extension));
+    assertEqualsExactType(110L , message.getExtension(optionalSfixed64Extension));
+    assertEqualsExactType(111F , message.getExtension(optionalFloatExtension   ));
+    assertEqualsExactType(112D , message.getExtension(optionalDoubleExtension  ));
+    assertEqualsExactType(true , message.getExtension(optionalBoolExtension    ));
+    assertEqualsExactType("115", message.getExtension(optionalStringExtension  ));
+    assertEqualsExactType(toBytes("116"), message.getExtension(optionalBytesExtension));
+
+    assertEqualsExactType(117, message.getExtension(optionalGroupExtension         ).getA());
+    assertEqualsExactType(118, message.getExtension(optionalNestedMessageExtension ).getBb());
+    assertEqualsExactType(119, message.getExtension(optionalForeignMessageExtension).getC());
+    assertEqualsExactType(120, message.getExtension(optionalImportMessageExtension ).getD());
 
     assertEqualsExactType(TestAllTypes.NestedEnum.BAZ,
-      message.getExtension(UnittestProto.optionalNestedEnumExtension));
+      message.getExtension(optionalNestedEnumExtension));
     assertEqualsExactType(ForeignEnum.FOREIGN_BAZ,
-      message.getExtension(UnittestProto.optionalForeignEnumExtension));
+      message.getExtension(optionalForeignEnumExtension));
     assertEqualsExactType(ImportEnum.IMPORT_BAZ,
-      message.getExtension(UnittestProto.optionalImportEnumExtension));
+      message.getExtension(optionalImportEnumExtension));
 
-    assertEqualsExactType("124", message.getExtension(UnittestProto.optionalStringPieceExtension));
-    assertEqualsExactType("125", message.getExtension(UnittestProto.optionalCordExtension));
+    assertEqualsExactType("124", message.getExtension(optionalStringPieceExtension));
+    assertEqualsExactType("125", message.getExtension(optionalCordExtension));
 
     // -----------------------------------------------------------------
 
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedInt32Extension   ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedInt64Extension   ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedUint32Extension  ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedUint64Extension  ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSint32Extension  ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSint64Extension  ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedFixed32Extension ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedFixed64Extension ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSfixed32Extension));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSfixed64Extension));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedFloatExtension   ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedDoubleExtension  ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedBoolExtension    ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedStringExtension  ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedBytesExtension   ));
-
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedGroupExtension         ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedNestedMessageExtension ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedForeignMessageExtension));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedImportMessageExtension ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedNestedEnumExtension    ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedForeignEnumExtension   ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedImportEnumExtension    ));
-
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedStringPieceExtension));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedCordExtension));
-
-    assertEqualsExactType(201  , message.getExtension(UnittestProto.repeatedInt32Extension   , 0));
-    assertEqualsExactType(202L , message.getExtension(UnittestProto.repeatedInt64Extension   , 0));
-    assertEqualsExactType(203  , message.getExtension(UnittestProto.repeatedUint32Extension  , 0));
-    assertEqualsExactType(204L , message.getExtension(UnittestProto.repeatedUint64Extension  , 0));
-    assertEqualsExactType(205  , message.getExtension(UnittestProto.repeatedSint32Extension  , 0));
-    assertEqualsExactType(206L , message.getExtension(UnittestProto.repeatedSint64Extension  , 0));
-    assertEqualsExactType(207  , message.getExtension(UnittestProto.repeatedFixed32Extension , 0));
-    assertEqualsExactType(208L , message.getExtension(UnittestProto.repeatedFixed64Extension , 0));
-    assertEqualsExactType(209  , message.getExtension(UnittestProto.repeatedSfixed32Extension, 0));
-    assertEqualsExactType(210L , message.getExtension(UnittestProto.repeatedSfixed64Extension, 0));
-    assertEqualsExactType(211F , message.getExtension(UnittestProto.repeatedFloatExtension   , 0));
-    assertEqualsExactType(212D , message.getExtension(UnittestProto.repeatedDoubleExtension  , 0));
-    assertEqualsExactType(true , message.getExtension(UnittestProto.repeatedBoolExtension    , 0));
-    assertEqualsExactType("215", message.getExtension(UnittestProto.repeatedStringExtension  , 0));
-    assertEqualsExactType(toBytes("216"), message.getExtension(UnittestProto.repeatedBytesExtension, 0));
-
-    assertEqualsExactType(217, message.getExtension(UnittestProto.repeatedGroupExtension         , 0).getA());
-    assertEqualsExactType(218, message.getExtension(UnittestProto.repeatedNestedMessageExtension , 0).getBb());
-    assertEqualsExactType(219, message.getExtension(UnittestProto.repeatedForeignMessageExtension, 0).getC());
-    assertEqualsExactType(220, message.getExtension(UnittestProto.repeatedImportMessageExtension , 0).getD());
+    Assert.assertEquals(2, message.getExtensionCount(repeatedInt32Extension   ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedInt64Extension   ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedUint32Extension  ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedUint64Extension  ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedSint32Extension  ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedSint64Extension  ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32Extension ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64Extension ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32Extension));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64Extension));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtension   ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtension  ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtension    ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtension  ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtension   ));
+
+    Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtension         ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtension ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtension));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtension ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension    ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtension   ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension    ));
+
+    Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtension));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtension));
+
+    assertEqualsExactType(201  , message.getExtension(repeatedInt32Extension   , 0));
+    assertEqualsExactType(202L , message.getExtension(repeatedInt64Extension   , 0));
+    assertEqualsExactType(203  , message.getExtension(repeatedUint32Extension  , 0));
+    assertEqualsExactType(204L , message.getExtension(repeatedUint64Extension  , 0));
+    assertEqualsExactType(205  , message.getExtension(repeatedSint32Extension  , 0));
+    assertEqualsExactType(206L , message.getExtension(repeatedSint64Extension  , 0));
+    assertEqualsExactType(207  , message.getExtension(repeatedFixed32Extension , 0));
+    assertEqualsExactType(208L , message.getExtension(repeatedFixed64Extension , 0));
+    assertEqualsExactType(209  , message.getExtension(repeatedSfixed32Extension, 0));
+    assertEqualsExactType(210L , message.getExtension(repeatedSfixed64Extension, 0));
+    assertEqualsExactType(211F , message.getExtension(repeatedFloatExtension   , 0));
+    assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtension  , 0));
+    assertEqualsExactType(true , message.getExtension(repeatedBoolExtension    , 0));
+    assertEqualsExactType("215", message.getExtension(repeatedStringExtension  , 0));
+    assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtension, 0));
+
+    assertEqualsExactType(217, message.getExtension(repeatedGroupExtension         , 0).getA());
+    assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtension , 0).getBb());
+    assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtension, 0).getC());
+    assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtension , 0).getD());
 
     assertEqualsExactType(TestAllTypes.NestedEnum.BAR,
-      message.getExtension(UnittestProto.repeatedNestedEnumExtension, 0));
+      message.getExtension(repeatedNestedEnumExtension, 0));
     assertEqualsExactType(ForeignEnum.FOREIGN_BAR,
-      message.getExtension(UnittestProto.repeatedForeignEnumExtension, 0));
+      message.getExtension(repeatedForeignEnumExtension, 0));
     assertEqualsExactType(ImportEnum.IMPORT_BAR,
-      message.getExtension(UnittestProto.repeatedImportEnumExtension, 0));
-
-    assertEqualsExactType("224", message.getExtension(UnittestProto.repeatedStringPieceExtension, 0));
-    assertEqualsExactType("225", message.getExtension(UnittestProto.repeatedCordExtension, 0));
-
-    assertEqualsExactType(301  , message.getExtension(UnittestProto.repeatedInt32Extension   , 1));
-    assertEqualsExactType(302L , message.getExtension(UnittestProto.repeatedInt64Extension   , 1));
-    assertEqualsExactType(303  , message.getExtension(UnittestProto.repeatedUint32Extension  , 1));
-    assertEqualsExactType(304L , message.getExtension(UnittestProto.repeatedUint64Extension  , 1));
-    assertEqualsExactType(305  , message.getExtension(UnittestProto.repeatedSint32Extension  , 1));
-    assertEqualsExactType(306L , message.getExtension(UnittestProto.repeatedSint64Extension  , 1));
-    assertEqualsExactType(307  , message.getExtension(UnittestProto.repeatedFixed32Extension , 1));
-    assertEqualsExactType(308L , message.getExtension(UnittestProto.repeatedFixed64Extension , 1));
-    assertEqualsExactType(309  , message.getExtension(UnittestProto.repeatedSfixed32Extension, 1));
-    assertEqualsExactType(310L , message.getExtension(UnittestProto.repeatedSfixed64Extension, 1));
-    assertEqualsExactType(311F , message.getExtension(UnittestProto.repeatedFloatExtension   , 1));
-    assertEqualsExactType(312D , message.getExtension(UnittestProto.repeatedDoubleExtension  , 1));
-    assertEqualsExactType(false, message.getExtension(UnittestProto.repeatedBoolExtension    , 1));
-    assertEqualsExactType("315", message.getExtension(UnittestProto.repeatedStringExtension  , 1));
-    assertEqualsExactType(toBytes("316"), message.getExtension(UnittestProto.repeatedBytesExtension, 1));
-
-    assertEqualsExactType(317, message.getExtension(UnittestProto.repeatedGroupExtension         , 1).getA());
-    assertEqualsExactType(318, message.getExtension(UnittestProto.repeatedNestedMessageExtension , 1).getBb());
-    assertEqualsExactType(319, message.getExtension(UnittestProto.repeatedForeignMessageExtension, 1).getC());
-    assertEqualsExactType(320, message.getExtension(UnittestProto.repeatedImportMessageExtension , 1).getD());
+      message.getExtension(repeatedImportEnumExtension, 0));
+
+    assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtension, 0));
+    assertEqualsExactType("225", message.getExtension(repeatedCordExtension, 0));
+
+    assertEqualsExactType(301  , message.getExtension(repeatedInt32Extension   , 1));
+    assertEqualsExactType(302L , message.getExtension(repeatedInt64Extension   , 1));
+    assertEqualsExactType(303  , message.getExtension(repeatedUint32Extension  , 1));
+    assertEqualsExactType(304L , message.getExtension(repeatedUint64Extension  , 1));
+    assertEqualsExactType(305  , message.getExtension(repeatedSint32Extension  , 1));
+    assertEqualsExactType(306L , message.getExtension(repeatedSint64Extension  , 1));
+    assertEqualsExactType(307  , message.getExtension(repeatedFixed32Extension , 1));
+    assertEqualsExactType(308L , message.getExtension(repeatedFixed64Extension , 1));
+    assertEqualsExactType(309  , message.getExtension(repeatedSfixed32Extension, 1));
+    assertEqualsExactType(310L , message.getExtension(repeatedSfixed64Extension, 1));
+    assertEqualsExactType(311F , message.getExtension(repeatedFloatExtension   , 1));
+    assertEqualsExactType(312D , message.getExtension(repeatedDoubleExtension  , 1));
+    assertEqualsExactType(false, message.getExtension(repeatedBoolExtension    , 1));
+    assertEqualsExactType("315", message.getExtension(repeatedStringExtension  , 1));
+    assertEqualsExactType(toBytes("316"), message.getExtension(repeatedBytesExtension, 1));
+
+    assertEqualsExactType(317, message.getExtension(repeatedGroupExtension         , 1).getA());
+    assertEqualsExactType(318, message.getExtension(repeatedNestedMessageExtension , 1).getBb());
+    assertEqualsExactType(319, message.getExtension(repeatedForeignMessageExtension, 1).getC());
+    assertEqualsExactType(320, message.getExtension(repeatedImportMessageExtension , 1).getD());
 
     assertEqualsExactType(TestAllTypes.NestedEnum.BAZ,
-      message.getExtension(UnittestProto.repeatedNestedEnumExtension, 1));
+      message.getExtension(repeatedNestedEnumExtension, 1));
     assertEqualsExactType(ForeignEnum.FOREIGN_BAZ,
-      message.getExtension(UnittestProto.repeatedForeignEnumExtension, 1));
+      message.getExtension(repeatedForeignEnumExtension, 1));
     assertEqualsExactType(ImportEnum.IMPORT_BAZ,
-      message.getExtension(UnittestProto.repeatedImportEnumExtension, 1));
+      message.getExtension(repeatedImportEnumExtension, 1));
 
-    assertEqualsExactType("324", message.getExtension(UnittestProto.repeatedStringPieceExtension, 1));
-    assertEqualsExactType("325", message.getExtension(UnittestProto.repeatedCordExtension, 1));
+    assertEqualsExactType("324", message.getExtension(repeatedStringPieceExtension, 1));
+    assertEqualsExactType("325", message.getExtension(repeatedCordExtension, 1));
 
     // -----------------------------------------------------------------
 
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultInt32Extension   ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultInt64Extension   ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultUint32Extension  ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultUint64Extension  ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultSint32Extension  ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultSint64Extension  ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultFixed32Extension ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultFixed64Extension ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultSfixed32Extension));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultSfixed64Extension));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultFloatExtension   ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultDoubleExtension  ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultBoolExtension    ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultStringExtension  ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultBytesExtension   ));
-
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultNestedEnumExtension ));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultForeignEnumExtension));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultImportEnumExtension ));
-
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultStringPieceExtension));
-    Assert.assertTrue(message.hasExtension(UnittestProto.defaultCordExtension));
-
-    assertEqualsExactType(401  , message.getExtension(UnittestProto.defaultInt32Extension   ));
-    assertEqualsExactType(402L , message.getExtension(UnittestProto.defaultInt64Extension   ));
-    assertEqualsExactType(403  , message.getExtension(UnittestProto.defaultUint32Extension  ));
-    assertEqualsExactType(404L , message.getExtension(UnittestProto.defaultUint64Extension  ));
-    assertEqualsExactType(405  , message.getExtension(UnittestProto.defaultSint32Extension  ));
-    assertEqualsExactType(406L , message.getExtension(UnittestProto.defaultSint64Extension  ));
-    assertEqualsExactType(407  , message.getExtension(UnittestProto.defaultFixed32Extension ));
-    assertEqualsExactType(408L , message.getExtension(UnittestProto.defaultFixed64Extension ));
-    assertEqualsExactType(409  , message.getExtension(UnittestProto.defaultSfixed32Extension));
-    assertEqualsExactType(410L , message.getExtension(UnittestProto.defaultSfixed64Extension));
-    assertEqualsExactType(411F , message.getExtension(UnittestProto.defaultFloatExtension   ));
-    assertEqualsExactType(412D , message.getExtension(UnittestProto.defaultDoubleExtension  ));
-    assertEqualsExactType(false, message.getExtension(UnittestProto.defaultBoolExtension    ));
-    assertEqualsExactType("415", message.getExtension(UnittestProto.defaultStringExtension  ));
-    assertEqualsExactType(toBytes("416"), message.getExtension(UnittestProto.defaultBytesExtension));
+    Assert.assertTrue(message.hasExtension(defaultInt32Extension   ));
+    Assert.assertTrue(message.hasExtension(defaultInt64Extension   ));
+    Assert.assertTrue(message.hasExtension(defaultUint32Extension  ));
+    Assert.assertTrue(message.hasExtension(defaultUint64Extension  ));
+    Assert.assertTrue(message.hasExtension(defaultSint32Extension  ));
+    Assert.assertTrue(message.hasExtension(defaultSint64Extension  ));
+    Assert.assertTrue(message.hasExtension(defaultFixed32Extension ));
+    Assert.assertTrue(message.hasExtension(defaultFixed64Extension ));
+    Assert.assertTrue(message.hasExtension(defaultSfixed32Extension));
+    Assert.assertTrue(message.hasExtension(defaultSfixed64Extension));
+    Assert.assertTrue(message.hasExtension(defaultFloatExtension   ));
+    Assert.assertTrue(message.hasExtension(defaultDoubleExtension  ));
+    Assert.assertTrue(message.hasExtension(defaultBoolExtension    ));
+    Assert.assertTrue(message.hasExtension(defaultStringExtension  ));
+    Assert.assertTrue(message.hasExtension(defaultBytesExtension   ));
+
+    Assert.assertTrue(message.hasExtension(defaultNestedEnumExtension ));
+    Assert.assertTrue(message.hasExtension(defaultForeignEnumExtension));
+    Assert.assertTrue(message.hasExtension(defaultImportEnumExtension ));
+
+    Assert.assertTrue(message.hasExtension(defaultStringPieceExtension));
+    Assert.assertTrue(message.hasExtension(defaultCordExtension));
+
+    assertEqualsExactType(401  , message.getExtension(defaultInt32Extension   ));
+    assertEqualsExactType(402L , message.getExtension(defaultInt64Extension   ));
+    assertEqualsExactType(403  , message.getExtension(defaultUint32Extension  ));
+    assertEqualsExactType(404L , message.getExtension(defaultUint64Extension  ));
+    assertEqualsExactType(405  , message.getExtension(defaultSint32Extension  ));
+    assertEqualsExactType(406L , message.getExtension(defaultSint64Extension  ));
+    assertEqualsExactType(407  , message.getExtension(defaultFixed32Extension ));
+    assertEqualsExactType(408L , message.getExtension(defaultFixed64Extension ));
+    assertEqualsExactType(409  , message.getExtension(defaultSfixed32Extension));
+    assertEqualsExactType(410L , message.getExtension(defaultSfixed64Extension));
+    assertEqualsExactType(411F , message.getExtension(defaultFloatExtension   ));
+    assertEqualsExactType(412D , message.getExtension(defaultDoubleExtension  ));
+    assertEqualsExactType(false, message.getExtension(defaultBoolExtension    ));
+    assertEqualsExactType("415", message.getExtension(defaultStringExtension  ));
+    assertEqualsExactType(toBytes("416"), message.getExtension(defaultBytesExtension));
 
     assertEqualsExactType(TestAllTypes.NestedEnum.FOO,
-      message.getExtension(UnittestProto.defaultNestedEnumExtension ));
+      message.getExtension(defaultNestedEnumExtension ));
     assertEqualsExactType(ForeignEnum.FOREIGN_FOO,
-      message.getExtension(UnittestProto.defaultForeignEnumExtension));
+      message.getExtension(defaultForeignEnumExtension));
     assertEqualsExactType(ImportEnum.IMPORT_FOO,
-      message.getExtension(UnittestProto.defaultImportEnumExtension));
+      message.getExtension(defaultImportEnumExtension));
 
-    assertEqualsExactType("424", message.getExtension(UnittestProto.defaultStringPieceExtension));
-    assertEqualsExactType("425", message.getExtension(UnittestProto.defaultCordExtension));
+    assertEqualsExactType("424", message.getExtension(defaultStringPieceExtension));
+    assertEqualsExactType("425", message.getExtension(defaultCordExtension));
   }
 
   // -------------------------------------------------------------------
@@ -1174,151 +1259,151 @@ class TestUtil {
    */
   public static void assertExtensionsClear(TestAllExtensions message) {
     // hasBlah() should initially be false for all optional fields.
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalInt32Extension   ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalInt64Extension   ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalUint32Extension  ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalUint64Extension  ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalSint32Extension  ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalSint64Extension  ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalFixed32Extension ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalFixed64Extension ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalSfixed32Extension));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalSfixed64Extension));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalFloatExtension   ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalDoubleExtension  ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalBoolExtension    ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalStringExtension  ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalBytesExtension   ));
-
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalGroupExtension         ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalNestedMessageExtension ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalForeignMessageExtension));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalImportMessageExtension ));
-
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalNestedEnumExtension ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalForeignEnumExtension));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalImportEnumExtension ));
-
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalStringPieceExtension));
-    Assert.assertFalse(message.hasExtension(UnittestProto.optionalCordExtension));
+    Assert.assertFalse(message.hasExtension(optionalInt32Extension   ));
+    Assert.assertFalse(message.hasExtension(optionalInt64Extension   ));
+    Assert.assertFalse(message.hasExtension(optionalUint32Extension  ));
+    Assert.assertFalse(message.hasExtension(optionalUint64Extension  ));
+    Assert.assertFalse(message.hasExtension(optionalSint32Extension  ));
+    Assert.assertFalse(message.hasExtension(optionalSint64Extension  ));
+    Assert.assertFalse(message.hasExtension(optionalFixed32Extension ));
+    Assert.assertFalse(message.hasExtension(optionalFixed64Extension ));
+    Assert.assertFalse(message.hasExtension(optionalSfixed32Extension));
+    Assert.assertFalse(message.hasExtension(optionalSfixed64Extension));
+    Assert.assertFalse(message.hasExtension(optionalFloatExtension   ));
+    Assert.assertFalse(message.hasExtension(optionalDoubleExtension  ));
+    Assert.assertFalse(message.hasExtension(optionalBoolExtension    ));
+    Assert.assertFalse(message.hasExtension(optionalStringExtension  ));
+    Assert.assertFalse(message.hasExtension(optionalBytesExtension   ));
+
+    Assert.assertFalse(message.hasExtension(optionalGroupExtension         ));
+    Assert.assertFalse(message.hasExtension(optionalNestedMessageExtension ));
+    Assert.assertFalse(message.hasExtension(optionalForeignMessageExtension));
+    Assert.assertFalse(message.hasExtension(optionalImportMessageExtension ));
+
+    Assert.assertFalse(message.hasExtension(optionalNestedEnumExtension ));
+    Assert.assertFalse(message.hasExtension(optionalForeignEnumExtension));
+    Assert.assertFalse(message.hasExtension(optionalImportEnumExtension ));
+
+    Assert.assertFalse(message.hasExtension(optionalStringPieceExtension));
+    Assert.assertFalse(message.hasExtension(optionalCordExtension));
 
     // Optional fields without defaults are set to zero or something like it.
-    assertEqualsExactType(0    , message.getExtension(UnittestProto.optionalInt32Extension   ));
-    assertEqualsExactType(0L   , message.getExtension(UnittestProto.optionalInt64Extension   ));
-    assertEqualsExactType(0    , message.getExtension(UnittestProto.optionalUint32Extension  ));
-    assertEqualsExactType(0L   , message.getExtension(UnittestProto.optionalUint64Extension  ));
-    assertEqualsExactType(0    , message.getExtension(UnittestProto.optionalSint32Extension  ));
-    assertEqualsExactType(0L   , message.getExtension(UnittestProto.optionalSint64Extension  ));
-    assertEqualsExactType(0    , message.getExtension(UnittestProto.optionalFixed32Extension ));
-    assertEqualsExactType(0L   , message.getExtension(UnittestProto.optionalFixed64Extension ));
-    assertEqualsExactType(0    , message.getExtension(UnittestProto.optionalSfixed32Extension));
-    assertEqualsExactType(0L   , message.getExtension(UnittestProto.optionalSfixed64Extension));
-    assertEqualsExactType(0F   , message.getExtension(UnittestProto.optionalFloatExtension   ));
-    assertEqualsExactType(0D   , message.getExtension(UnittestProto.optionalDoubleExtension  ));
-    assertEqualsExactType(false, message.getExtension(UnittestProto.optionalBoolExtension    ));
-    assertEqualsExactType(""   , message.getExtension(UnittestProto.optionalStringExtension  ));
-    assertEqualsExactType(ByteString.EMPTY, message.getExtension(UnittestProto.optionalBytesExtension));
+    assertEqualsExactType(0    , message.getExtension(optionalInt32Extension   ));
+    assertEqualsExactType(0L   , message.getExtension(optionalInt64Extension   ));
+    assertEqualsExactType(0    , message.getExtension(optionalUint32Extension  ));
+    assertEqualsExactType(0L   , message.getExtension(optionalUint64Extension  ));
+    assertEqualsExactType(0    , message.getExtension(optionalSint32Extension  ));
+    assertEqualsExactType(0L   , message.getExtension(optionalSint64Extension  ));
+    assertEqualsExactType(0    , message.getExtension(optionalFixed32Extension ));
+    assertEqualsExactType(0L   , message.getExtension(optionalFixed64Extension ));
+    assertEqualsExactType(0    , message.getExtension(optionalSfixed32Extension));
+    assertEqualsExactType(0L   , message.getExtension(optionalSfixed64Extension));
+    assertEqualsExactType(0F   , message.getExtension(optionalFloatExtension   ));
+    assertEqualsExactType(0D   , message.getExtension(optionalDoubleExtension  ));
+    assertEqualsExactType(false, message.getExtension(optionalBoolExtension    ));
+    assertEqualsExactType(""   , message.getExtension(optionalStringExtension  ));
+    assertEqualsExactType(ByteString.EMPTY, message.getExtension(optionalBytesExtension));
 
     // Embedded messages should also be clear.
-    Assert.assertFalse(message.getExtension(UnittestProto.optionalGroupExtension         ).hasA());
-    Assert.assertFalse(message.getExtension(UnittestProto.optionalNestedMessageExtension ).hasBb());
-    Assert.assertFalse(message.getExtension(UnittestProto.optionalForeignMessageExtension).hasC());
-    Assert.assertFalse(message.getExtension(UnittestProto.optionalImportMessageExtension ).hasD());
+    Assert.assertFalse(message.getExtension(optionalGroupExtension         ).hasA());
+    Assert.assertFalse(message.getExtension(optionalNestedMessageExtension ).hasBb());
+    Assert.assertFalse(message.getExtension(optionalForeignMessageExtension).hasC());
+    Assert.assertFalse(message.getExtension(optionalImportMessageExtension ).hasD());
 
-    assertEqualsExactType(0, message.getExtension(UnittestProto.optionalGroupExtension         ).getA());
-    assertEqualsExactType(0, message.getExtension(UnittestProto.optionalNestedMessageExtension ).getBb());
-    assertEqualsExactType(0, message.getExtension(UnittestProto.optionalForeignMessageExtension).getC());
-    assertEqualsExactType(0, message.getExtension(UnittestProto.optionalImportMessageExtension ).getD());
+    assertEqualsExactType(0, message.getExtension(optionalGroupExtension         ).getA());
+    assertEqualsExactType(0, message.getExtension(optionalNestedMessageExtension ).getBb());
+    assertEqualsExactType(0, message.getExtension(optionalForeignMessageExtension).getC());
+    assertEqualsExactType(0, message.getExtension(optionalImportMessageExtension ).getD());
 
     // Enums without defaults are set to the first value in the enum.
     assertEqualsExactType(TestAllTypes.NestedEnum.FOO,
-      message.getExtension(UnittestProto.optionalNestedEnumExtension ));
+      message.getExtension(optionalNestedEnumExtension ));
     assertEqualsExactType(ForeignEnum.FOREIGN_FOO,
-      message.getExtension(UnittestProto.optionalForeignEnumExtension));
+      message.getExtension(optionalForeignEnumExtension));
     assertEqualsExactType(ImportEnum.IMPORT_FOO,
-      message.getExtension(UnittestProto.optionalImportEnumExtension));
+      message.getExtension(optionalImportEnumExtension));
 
-    assertEqualsExactType("", message.getExtension(UnittestProto.optionalStringPieceExtension));
-    assertEqualsExactType("", message.getExtension(UnittestProto.optionalCordExtension));
+    assertEqualsExactType("", message.getExtension(optionalStringPieceExtension));
+    assertEqualsExactType("", message.getExtension(optionalCordExtension));
 
     // Repeated fields are empty.
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedInt32Extension   ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedInt64Extension   ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedUint32Extension  ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedUint64Extension  ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedSint32Extension  ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedSint64Extension  ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedFixed32Extension ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedFixed64Extension ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedSfixed32Extension));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedSfixed64Extension));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedFloatExtension   ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedDoubleExtension  ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedBoolExtension    ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedStringExtension  ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedBytesExtension   ));
-
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedGroupExtension         ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedNestedMessageExtension ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedForeignMessageExtension));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedImportMessageExtension ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedNestedEnumExtension    ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedForeignEnumExtension   ));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedImportEnumExtension    ));
-
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedStringPieceExtension));
-    Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedCordExtension));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedInt32Extension   ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedInt64Extension   ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedUint32Extension  ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedUint64Extension  ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedSint32Extension  ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedSint64Extension  ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedFixed32Extension ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedFixed64Extension ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed32Extension));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed64Extension));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedFloatExtension   ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedDoubleExtension  ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedBoolExtension    ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedStringExtension  ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedBytesExtension   ));
+
+    Assert.assertEquals(0, message.getExtensionCount(repeatedGroupExtension         ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedNestedMessageExtension ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedForeignMessageExtension));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedImportMessageExtension ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedNestedEnumExtension    ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedForeignEnumExtension   ));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedImportEnumExtension    ));
+
+    Assert.assertEquals(0, message.getExtensionCount(repeatedStringPieceExtension));
+    Assert.assertEquals(0, message.getExtensionCount(repeatedCordExtension));
 
     // hasBlah() should also be false for all default fields.
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultInt32Extension   ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultInt64Extension   ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultUint32Extension  ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultUint64Extension  ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultSint32Extension  ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultSint64Extension  ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultFixed32Extension ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultFixed64Extension ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultSfixed32Extension));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultSfixed64Extension));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultFloatExtension   ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultDoubleExtension  ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultBoolExtension    ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultStringExtension  ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultBytesExtension   ));
-
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultNestedEnumExtension ));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultForeignEnumExtension));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultImportEnumExtension ));
-
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultStringPieceExtension));
-    Assert.assertFalse(message.hasExtension(UnittestProto.defaultCordExtension));
+    Assert.assertFalse(message.hasExtension(defaultInt32Extension   ));
+    Assert.assertFalse(message.hasExtension(defaultInt64Extension   ));
+    Assert.assertFalse(message.hasExtension(defaultUint32Extension  ));
+    Assert.assertFalse(message.hasExtension(defaultUint64Extension  ));
+    Assert.assertFalse(message.hasExtension(defaultSint32Extension  ));
+    Assert.assertFalse(message.hasExtension(defaultSint64Extension  ));
+    Assert.assertFalse(message.hasExtension(defaultFixed32Extension ));
+    Assert.assertFalse(message.hasExtension(defaultFixed64Extension ));
+    Assert.assertFalse(message.hasExtension(defaultSfixed32Extension));
+    Assert.assertFalse(message.hasExtension(defaultSfixed64Extension));
+    Assert.assertFalse(message.hasExtension(defaultFloatExtension   ));
+    Assert.assertFalse(message.hasExtension(defaultDoubleExtension  ));
+    Assert.assertFalse(message.hasExtension(defaultBoolExtension    ));
+    Assert.assertFalse(message.hasExtension(defaultStringExtension  ));
+    Assert.assertFalse(message.hasExtension(defaultBytesExtension   ));
+
+    Assert.assertFalse(message.hasExtension(defaultNestedEnumExtension ));
+    Assert.assertFalse(message.hasExtension(defaultForeignEnumExtension));
+    Assert.assertFalse(message.hasExtension(defaultImportEnumExtension ));
+
+    Assert.assertFalse(message.hasExtension(defaultStringPieceExtension));
+    Assert.assertFalse(message.hasExtension(defaultCordExtension));
 
     // Fields with defaults have their default values (duh).
-    assertEqualsExactType( 41    , message.getExtension(UnittestProto.defaultInt32Extension   ));
-    assertEqualsExactType( 42L   , message.getExtension(UnittestProto.defaultInt64Extension   ));
-    assertEqualsExactType( 43    , message.getExtension(UnittestProto.defaultUint32Extension  ));
-    assertEqualsExactType( 44L   , message.getExtension(UnittestProto.defaultUint64Extension  ));
-    assertEqualsExactType(-45    , message.getExtension(UnittestProto.defaultSint32Extension  ));
-    assertEqualsExactType( 46L   , message.getExtension(UnittestProto.defaultSint64Extension  ));
-    assertEqualsExactType( 47    , message.getExtension(UnittestProto.defaultFixed32Extension ));
-    assertEqualsExactType( 48L   , message.getExtension(UnittestProto.defaultFixed64Extension ));
-    assertEqualsExactType( 49    , message.getExtension(UnittestProto.defaultSfixed32Extension));
-    assertEqualsExactType(-50L   , message.getExtension(UnittestProto.defaultSfixed64Extension));
-    assertEqualsExactType( 51.5F , message.getExtension(UnittestProto.defaultFloatExtension   ));
-    assertEqualsExactType( 52e3D , message.getExtension(UnittestProto.defaultDoubleExtension  ));
-    assertEqualsExactType(true   , message.getExtension(UnittestProto.defaultBoolExtension    ));
-    assertEqualsExactType("hello", message.getExtension(UnittestProto.defaultStringExtension  ));
-    assertEqualsExactType(toBytes("world"), message.getExtension(UnittestProto.defaultBytesExtension));
+    assertEqualsExactType( 41    , message.getExtension(defaultInt32Extension   ));
+    assertEqualsExactType( 42L   , message.getExtension(defaultInt64Extension   ));
+    assertEqualsExactType( 43    , message.getExtension(defaultUint32Extension  ));
+    assertEqualsExactType( 44L   , message.getExtension(defaultUint64Extension  ));
+    assertEqualsExactType(-45    , message.getExtension(defaultSint32Extension  ));
+    assertEqualsExactType( 46L   , message.getExtension(defaultSint64Extension  ));
+    assertEqualsExactType( 47    , message.getExtension(defaultFixed32Extension ));
+    assertEqualsExactType( 48L   , message.getExtension(defaultFixed64Extension ));
+    assertEqualsExactType( 49    , message.getExtension(defaultSfixed32Extension));
+    assertEqualsExactType(-50L   , message.getExtension(defaultSfixed64Extension));
+    assertEqualsExactType( 51.5F , message.getExtension(defaultFloatExtension   ));
+    assertEqualsExactType( 52e3D , message.getExtension(defaultDoubleExtension  ));
+    assertEqualsExactType(true   , message.getExtension(defaultBoolExtension    ));
+    assertEqualsExactType("hello", message.getExtension(defaultStringExtension  ));
+    assertEqualsExactType(toBytes("world"), message.getExtension(defaultBytesExtension));
 
     assertEqualsExactType(TestAllTypes.NestedEnum.BAR,
-      message.getExtension(UnittestProto.defaultNestedEnumExtension ));
+      message.getExtension(defaultNestedEnumExtension ));
     assertEqualsExactType(ForeignEnum.FOREIGN_BAR,
-      message.getExtension(UnittestProto.defaultForeignEnumExtension));
+      message.getExtension(defaultForeignEnumExtension));
     assertEqualsExactType(ImportEnum.IMPORT_BAR,
-      message.getExtension(UnittestProto.defaultImportEnumExtension));
+      message.getExtension(defaultImportEnumExtension));
 
-    assertEqualsExactType("abc", message.getExtension(UnittestProto.defaultStringPieceExtension));
-    assertEqualsExactType("123", message.getExtension(UnittestProto.defaultCordExtension));
+    assertEqualsExactType("abc", message.getExtension(defaultStringPieceExtension));
+    assertEqualsExactType("123", message.getExtension(defaultCordExtension));
   }
 
   // -------------------------------------------------------------------
@@ -1333,97 +1418,261 @@ class TestUtil {
     // ModifyRepeatedFields only sets the second repeated element of each
     // field.  In addition to verifying this, we also verify that the first
     // element and size were *not* modified.
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedInt32Extension   ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedInt64Extension   ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedUint32Extension  ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedUint64Extension  ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSint32Extension  ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSint64Extension  ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedFixed32Extension ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedFixed64Extension ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSfixed32Extension));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSfixed64Extension));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedFloatExtension   ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedDoubleExtension  ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedBoolExtension    ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedStringExtension  ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedBytesExtension   ));
-
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedGroupExtension         ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedNestedMessageExtension ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedForeignMessageExtension));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedImportMessageExtension ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedNestedEnumExtension    ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedForeignEnumExtension   ));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedImportEnumExtension    ));
-
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedStringPieceExtension));
-    Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedCordExtension));
-
-    assertEqualsExactType(201  , message.getExtension(UnittestProto.repeatedInt32Extension   , 0));
-    assertEqualsExactType(202L , message.getExtension(UnittestProto.repeatedInt64Extension   , 0));
-    assertEqualsExactType(203  , message.getExtension(UnittestProto.repeatedUint32Extension  , 0));
-    assertEqualsExactType(204L , message.getExtension(UnittestProto.repeatedUint64Extension  , 0));
-    assertEqualsExactType(205  , message.getExtension(UnittestProto.repeatedSint32Extension  , 0));
-    assertEqualsExactType(206L , message.getExtension(UnittestProto.repeatedSint64Extension  , 0));
-    assertEqualsExactType(207  , message.getExtension(UnittestProto.repeatedFixed32Extension , 0));
-    assertEqualsExactType(208L , message.getExtension(UnittestProto.repeatedFixed64Extension , 0));
-    assertEqualsExactType(209  , message.getExtension(UnittestProto.repeatedSfixed32Extension, 0));
-    assertEqualsExactType(210L , message.getExtension(UnittestProto.repeatedSfixed64Extension, 0));
-    assertEqualsExactType(211F , message.getExtension(UnittestProto.repeatedFloatExtension   , 0));
-    assertEqualsExactType(212D , message.getExtension(UnittestProto.repeatedDoubleExtension  , 0));
-    assertEqualsExactType(true , message.getExtension(UnittestProto.repeatedBoolExtension    , 0));
-    assertEqualsExactType("215", message.getExtension(UnittestProto.repeatedStringExtension  , 0));
-    assertEqualsExactType(toBytes("216"), message.getExtension(UnittestProto.repeatedBytesExtension, 0));
-
-    assertEqualsExactType(217, message.getExtension(UnittestProto.repeatedGroupExtension         , 0).getA());
-    assertEqualsExactType(218, message.getExtension(UnittestProto.repeatedNestedMessageExtension , 0).getBb());
-    assertEqualsExactType(219, message.getExtension(UnittestProto.repeatedForeignMessageExtension, 0).getC());
-    assertEqualsExactType(220, message.getExtension(UnittestProto.repeatedImportMessageExtension , 0).getD());
+    Assert.assertEquals(2, message.getExtensionCount(repeatedInt32Extension   ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedInt64Extension   ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedUint32Extension  ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedUint64Extension  ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedSint32Extension  ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedSint64Extension  ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32Extension ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64Extension ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32Extension));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64Extension));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtension   ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtension  ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtension    ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtension  ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtension   ));
+
+    Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtension         ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtension ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtension));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtension ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension    ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtension   ));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension    ));
+
+    Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtension));
+    Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtension));
+
+    assertEqualsExactType(201  , message.getExtension(repeatedInt32Extension   , 0));
+    assertEqualsExactType(202L , message.getExtension(repeatedInt64Extension   , 0));
+    assertEqualsExactType(203  , message.getExtension(repeatedUint32Extension  , 0));
+    assertEqualsExactType(204L , message.getExtension(repeatedUint64Extension  , 0));
+    assertEqualsExactType(205  , message.getExtension(repeatedSint32Extension  , 0));
+    assertEqualsExactType(206L , message.getExtension(repeatedSint64Extension  , 0));
+    assertEqualsExactType(207  , message.getExtension(repeatedFixed32Extension , 0));
+    assertEqualsExactType(208L , message.getExtension(repeatedFixed64Extension , 0));
+    assertEqualsExactType(209  , message.getExtension(repeatedSfixed32Extension, 0));
+    assertEqualsExactType(210L , message.getExtension(repeatedSfixed64Extension, 0));
+    assertEqualsExactType(211F , message.getExtension(repeatedFloatExtension   , 0));
+    assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtension  , 0));
+    assertEqualsExactType(true , message.getExtension(repeatedBoolExtension    , 0));
+    assertEqualsExactType("215", message.getExtension(repeatedStringExtension  , 0));
+    assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtension, 0));
+
+    assertEqualsExactType(217, message.getExtension(repeatedGroupExtension         , 0).getA());
+    assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtension , 0).getBb());
+    assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtension, 0).getC());
+    assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtension , 0).getD());
 
     assertEqualsExactType(TestAllTypes.NestedEnum.BAR,
-      message.getExtension(UnittestProto.repeatedNestedEnumExtension, 0));
+      message.getExtension(repeatedNestedEnumExtension, 0));
     assertEqualsExactType(ForeignEnum.FOREIGN_BAR,
-      message.getExtension(UnittestProto.repeatedForeignEnumExtension, 0));
+      message.getExtension(repeatedForeignEnumExtension, 0));
     assertEqualsExactType(ImportEnum.IMPORT_BAR,
-      message.getExtension(UnittestProto.repeatedImportEnumExtension, 0));
+      message.getExtension(repeatedImportEnumExtension, 0));
 
-    assertEqualsExactType("224", message.getExtension(UnittestProto.repeatedStringPieceExtension, 0));
-    assertEqualsExactType("225", message.getExtension(UnittestProto.repeatedCordExtension, 0));
+    assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtension, 0));
+    assertEqualsExactType("225", message.getExtension(repeatedCordExtension, 0));
 
     // Actually verify the second (modified) elements now.
-    assertEqualsExactType(501  , message.getExtension(UnittestProto.repeatedInt32Extension   , 1));
-    assertEqualsExactType(502L , message.getExtension(UnittestProto.repeatedInt64Extension   , 1));
-    assertEqualsExactType(503  , message.getExtension(UnittestProto.repeatedUint32Extension  , 1));
-    assertEqualsExactType(504L , message.getExtension(UnittestProto.repeatedUint64Extension  , 1));
-    assertEqualsExactType(505  , message.getExtension(UnittestProto.repeatedSint32Extension  , 1));
-    assertEqualsExactType(506L , message.getExtension(UnittestProto.repeatedSint64Extension  , 1));
-    assertEqualsExactType(507  , message.getExtension(UnittestProto.repeatedFixed32Extension , 1));
-    assertEqualsExactType(508L , message.getExtension(UnittestProto.repeatedFixed64Extension , 1));
-    assertEqualsExactType(509  , message.getExtension(UnittestProto.repeatedSfixed32Extension, 1));
-    assertEqualsExactType(510L , message.getExtension(UnittestProto.repeatedSfixed64Extension, 1));
-    assertEqualsExactType(511F , message.getExtension(UnittestProto.repeatedFloatExtension   , 1));
-    assertEqualsExactType(512D , message.getExtension(UnittestProto.repeatedDoubleExtension  , 1));
-    assertEqualsExactType(true , message.getExtension(UnittestProto.repeatedBoolExtension    , 1));
-    assertEqualsExactType("515", message.getExtension(UnittestProto.repeatedStringExtension  , 1));
-    assertEqualsExactType(toBytes("516"), message.getExtension(UnittestProto.repeatedBytesExtension, 1));
-
-    assertEqualsExactType(517, message.getExtension(UnittestProto.repeatedGroupExtension         , 1).getA());
-    assertEqualsExactType(518, message.getExtension(UnittestProto.repeatedNestedMessageExtension , 1).getBb());
-    assertEqualsExactType(519, message.getExtension(UnittestProto.repeatedForeignMessageExtension, 1).getC());
-    assertEqualsExactType(520, message.getExtension(UnittestProto.repeatedImportMessageExtension , 1).getD());
+    assertEqualsExactType(501  , message.getExtension(repeatedInt32Extension   , 1));
+    assertEqualsExactType(502L , message.getExtension(repeatedInt64Extension   , 1));
+    assertEqualsExactType(503  , message.getExtension(repeatedUint32Extension  , 1));
+    assertEqualsExactType(504L , message.getExtension(repeatedUint64Extension  , 1));
+    assertEqualsExactType(505  , message.getExtension(repeatedSint32Extension  , 1));
+    assertEqualsExactType(506L , message.getExtension(repeatedSint64Extension  , 1));
+    assertEqualsExactType(507  , message.getExtension(repeatedFixed32Extension , 1));
+    assertEqualsExactType(508L , message.getExtension(repeatedFixed64Extension , 1));
+    assertEqualsExactType(509  , message.getExtension(repeatedSfixed32Extension, 1));
+    assertEqualsExactType(510L , message.getExtension(repeatedSfixed64Extension, 1));
+    assertEqualsExactType(511F , message.getExtension(repeatedFloatExtension   , 1));
+    assertEqualsExactType(512D , message.getExtension(repeatedDoubleExtension  , 1));
+    assertEqualsExactType(true , message.getExtension(repeatedBoolExtension    , 1));
+    assertEqualsExactType("515", message.getExtension(repeatedStringExtension  , 1));
+    assertEqualsExactType(toBytes("516"), message.getExtension(repeatedBytesExtension, 1));
+
+    assertEqualsExactType(517, message.getExtension(repeatedGroupExtension         , 1).getA());
+    assertEqualsExactType(518, message.getExtension(repeatedNestedMessageExtension , 1).getBb());
+    assertEqualsExactType(519, message.getExtension(repeatedForeignMessageExtension, 1).getC());
+    assertEqualsExactType(520, message.getExtension(repeatedImportMessageExtension , 1).getD());
 
     assertEqualsExactType(TestAllTypes.NestedEnum.FOO,
-      message.getExtension(UnittestProto.repeatedNestedEnumExtension, 1));
+      message.getExtension(repeatedNestedEnumExtension, 1));
     assertEqualsExactType(ForeignEnum.FOREIGN_FOO,
-      message.getExtension(UnittestProto.repeatedForeignEnumExtension, 1));
+      message.getExtension(repeatedForeignEnumExtension, 1));
     assertEqualsExactType(ImportEnum.IMPORT_FOO,
-      message.getExtension(UnittestProto.repeatedImportEnumExtension, 1));
+      message.getExtension(repeatedImportEnumExtension, 1));
+
+    assertEqualsExactType("524", message.getExtension(repeatedStringPieceExtension, 1));
+    assertEqualsExactType("525", message.getExtension(repeatedCordExtension, 1));
+  }
 
-    assertEqualsExactType("524", message.getExtension(UnittestProto.repeatedStringPieceExtension, 1));
-    assertEqualsExactType("525", message.getExtension(UnittestProto.repeatedCordExtension, 1));
+  /**
+   * Set every field of {@code message} to a unique value.
+   */
+  public static void setPackedFields(TestPackedTypes.Builder message) {
+    message.addPackedInt32   (601);
+    message.addPackedInt64   (602);
+    message.addPackedUint32  (603);
+    message.addPackedUint64  (604);
+    message.addPackedSint32  (605);
+    message.addPackedSint64  (606);
+    message.addPackedFixed32 (607);
+    message.addPackedFixed64 (608);
+    message.addPackedSfixed32(609);
+    message.addPackedSfixed64(610);
+    message.addPackedFloat   (611);
+    message.addPackedDouble  (612);
+    message.addPackedBool    (true);
+    message.addPackedEnum    (ForeignEnum.FOREIGN_BAR);
+    // Add a second one of each field.
+    message.addPackedInt32   (701);
+    message.addPackedInt64   (702);
+    message.addPackedUint32  (703);
+    message.addPackedUint64  (704);
+    message.addPackedSint32  (705);
+    message.addPackedSint64  (706);
+    message.addPackedFixed32 (707);
+    message.addPackedFixed64 (708);
+    message.addPackedSfixed32(709);
+    message.addPackedSfixed64(710);
+    message.addPackedFloat   (711);
+    message.addPackedDouble  (712);
+    message.addPackedBool    (false);
+    message.addPackedEnum    (ForeignEnum.FOREIGN_BAZ);
   }
 
+  /**
+   * Assert (using {@code junit.framework.Assert}} that all fields of
+   * {@code message} are set to the values assigned by {@code setPackedFields}.
+   */
+  public static void assertPackedFieldsSet(TestPackedTypes message) {
+    Assert.assertEquals(2, message.getPackedInt32Count   ());
+    Assert.assertEquals(2, message.getPackedInt64Count   ());
+    Assert.assertEquals(2, message.getPackedUint32Count  ());
+    Assert.assertEquals(2, message.getPackedUint64Count  ());
+    Assert.assertEquals(2, message.getPackedSint32Count  ());
+    Assert.assertEquals(2, message.getPackedSint64Count  ());
+    Assert.assertEquals(2, message.getPackedFixed32Count ());
+    Assert.assertEquals(2, message.getPackedFixed64Count ());
+    Assert.assertEquals(2, message.getPackedSfixed32Count());
+    Assert.assertEquals(2, message.getPackedSfixed64Count());
+    Assert.assertEquals(2, message.getPackedFloatCount   ());
+    Assert.assertEquals(2, message.getPackedDoubleCount  ());
+    Assert.assertEquals(2, message.getPackedBoolCount    ());
+    Assert.assertEquals(2, message.getPackedEnumCount   ());
+    Assert.assertEquals(601  , message.getPackedInt32   (0));
+    Assert.assertEquals(602  , message.getPackedInt64   (0));
+    Assert.assertEquals(603  , message.getPackedUint32  (0));
+    Assert.assertEquals(604  , message.getPackedUint64  (0));
+    Assert.assertEquals(605  , message.getPackedSint32  (0));
+    Assert.assertEquals(606  , message.getPackedSint64  (0));
+    Assert.assertEquals(607  , message.getPackedFixed32 (0));
+    Assert.assertEquals(608  , message.getPackedFixed64 (0));
+    Assert.assertEquals(609  , message.getPackedSfixed32(0));
+    Assert.assertEquals(610  , message.getPackedSfixed64(0));
+    Assert.assertEquals(611  , message.getPackedFloat   (0), 0.0);
+    Assert.assertEquals(612  , message.getPackedDouble  (0), 0.0);
+    Assert.assertEquals(true , message.getPackedBool    (0));
+    Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getPackedEnum(0));
+    Assert.assertEquals(701  , message.getPackedInt32   (1));
+    Assert.assertEquals(702  , message.getPackedInt64   (1));
+    Assert.assertEquals(703  , message.getPackedUint32  (1));
+    Assert.assertEquals(704  , message.getPackedUint64  (1));
+    Assert.assertEquals(705  , message.getPackedSint32  (1));
+    Assert.assertEquals(706  , message.getPackedSint64  (1));
+    Assert.assertEquals(707  , message.getPackedFixed32 (1));
+    Assert.assertEquals(708  , message.getPackedFixed64 (1));
+    Assert.assertEquals(709  , message.getPackedSfixed32(1));
+    Assert.assertEquals(710  , message.getPackedSfixed64(1));
+    Assert.assertEquals(711  , message.getPackedFloat   (1), 0.0);
+    Assert.assertEquals(712  , message.getPackedDouble  (1), 0.0);
+    Assert.assertEquals(false, message.getPackedBool    (1));
+    Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getPackedEnum(1));
+  }
+
+  public static void setPackedExtensions(TestPackedExtensions.Builder message) {
+    message.addExtension(packedInt32Extension   , 601);
+    message.addExtension(packedInt64Extension   , 602L);
+    message.addExtension(packedUint32Extension  , 603);
+    message.addExtension(packedUint64Extension  , 604L);
+    message.addExtension(packedSint32Extension  , 605);
+    message.addExtension(packedSint64Extension  , 606L);
+    message.addExtension(packedFixed32Extension , 607);
+    message.addExtension(packedFixed64Extension , 608L);
+    message.addExtension(packedSfixed32Extension, 609);
+    message.addExtension(packedSfixed64Extension, 610L);
+    message.addExtension(packedFloatExtension   , 611F);
+    message.addExtension(packedDoubleExtension  , 612D);
+    message.addExtension(packedBoolExtension    , true);
+    message.addExtension(packedEnumExtension, ForeignEnum.FOREIGN_BAR);
+    // Add a second one of each field.
+    message.addExtension(packedInt32Extension   , 701);
+    message.addExtension(packedInt64Extension   , 702L);
+    message.addExtension(packedUint32Extension  , 703);
+    message.addExtension(packedUint64Extension  , 704L);
+    message.addExtension(packedSint32Extension  , 705);
+    message.addExtension(packedSint64Extension  , 706L);
+    message.addExtension(packedFixed32Extension , 707);
+    message.addExtension(packedFixed64Extension , 708L);
+    message.addExtension(packedSfixed32Extension, 709);
+    message.addExtension(packedSfixed64Extension, 710L);
+    message.addExtension(packedFloatExtension   , 711F);
+    message.addExtension(packedDoubleExtension  , 712D);
+    message.addExtension(packedBoolExtension    , false);
+    message.addExtension(packedEnumExtension, ForeignEnum.FOREIGN_BAZ);
+  }
+
+  public static void assertPackedExtensionsSet(TestPackedExtensions message) {
+    Assert.assertEquals(2, message.getExtensionCount(packedInt32Extension   ));
+    Assert.assertEquals(2, message.getExtensionCount(packedInt64Extension   ));
+    Assert.assertEquals(2, message.getExtensionCount(packedUint32Extension  ));
+    Assert.assertEquals(2, message.getExtensionCount(packedUint64Extension  ));
+    Assert.assertEquals(2, message.getExtensionCount(packedSint32Extension  ));
+    Assert.assertEquals(2, message.getExtensionCount(packedSint64Extension  ));
+    Assert.assertEquals(2, message.getExtensionCount(packedFixed32Extension ));
+    Assert.assertEquals(2, message.getExtensionCount(packedFixed64Extension ));
+    Assert.assertEquals(2, message.getExtensionCount(packedSfixed32Extension));
+    Assert.assertEquals(2, message.getExtensionCount(packedSfixed64Extension));
+    Assert.assertEquals(2, message.getExtensionCount(packedFloatExtension   ));
+    Assert.assertEquals(2, message.getExtensionCount(packedDoubleExtension  ));
+    Assert.assertEquals(2, message.getExtensionCount(packedBoolExtension    ));
+    Assert.assertEquals(2, message.getExtensionCount(packedEnumExtension));
+    assertEqualsExactType(601  , message.getExtension(packedInt32Extension   , 0));
+    assertEqualsExactType(602L , message.getExtension(packedInt64Extension   , 0));
+    assertEqualsExactType(603  , message.getExtension(packedUint32Extension  , 0));
+    assertEqualsExactType(604L , message.getExtension(packedUint64Extension  , 0));
+    assertEqualsExactType(605  , message.getExtension(packedSint32Extension  , 0));
+    assertEqualsExactType(606L , message.getExtension(packedSint64Extension  , 0));
+    assertEqualsExactType(607  , message.getExtension(packedFixed32Extension , 0));
+    assertEqualsExactType(608L , message.getExtension(packedFixed64Extension , 0));
+    assertEqualsExactType(609  , message.getExtension(packedSfixed32Extension, 0));
+    assertEqualsExactType(610L , message.getExtension(packedSfixed64Extension, 0));
+    assertEqualsExactType(611F , message.getExtension(packedFloatExtension   , 0));
+    assertEqualsExactType(612D , message.getExtension(packedDoubleExtension  , 0));
+    assertEqualsExactType(true , message.getExtension(packedBoolExtension    , 0));
+    assertEqualsExactType(ForeignEnum.FOREIGN_BAR,
+                          message.getExtension(packedEnumExtension, 0));
+    assertEqualsExactType(701  , message.getExtension(packedInt32Extension   , 1));
+    assertEqualsExactType(702L , message.getExtension(packedInt64Extension   , 1));
+    assertEqualsExactType(703  , message.getExtension(packedUint32Extension  , 1));
+    assertEqualsExactType(704L , message.getExtension(packedUint64Extension  , 1));
+    assertEqualsExactType(705  , message.getExtension(packedSint32Extension  , 1));
+    assertEqualsExactType(706L , message.getExtension(packedSint64Extension  , 1));
+    assertEqualsExactType(707  , message.getExtension(packedFixed32Extension , 1));
+    assertEqualsExactType(708L , message.getExtension(packedFixed64Extension , 1));
+    assertEqualsExactType(709  , message.getExtension(packedSfixed32Extension, 1));
+    assertEqualsExactType(710L , message.getExtension(packedSfixed64Extension, 1));
+    assertEqualsExactType(711F , message.getExtension(packedFloatExtension   , 1));
+    assertEqualsExactType(712D , message.getExtension(packedDoubleExtension  , 1));
+    assertEqualsExactType(false, message.getExtension(packedBoolExtension    , 1));
+    assertEqualsExactType(ForeignEnum.FOREIGN_BAZ,
+                          message.getExtension(packedEnumExtension, 1));
+  }
+
+
   // ===================================================================
 
   /**
@@ -1487,7 +1736,7 @@ class TestUtil {
       this.importFile = file.getDependencies().get(0);
 
       Descriptors.Descriptor testAllTypes;
-      if (extensionRegistry == null) {
+      if (baseDescriptor.getName() == "TestAllTypes") {
         testAllTypes = baseDescriptor;
       } else {
         testAllTypes = file.findMessageTypeByName("TestAllTypes");
@@ -1495,10 +1744,13 @@ class TestUtil {
       }
 
       if (extensionRegistry == null) {
+        // Use testAllTypes, rather than baseDescriptor, to allow
+        // initialization using TestPackedTypes descriptors. These objects
+        // won't be used by the methods for packed fields.
         this.optionalGroup =
-          baseDescriptor.findNestedTypeByName("OptionalGroup");
+          testAllTypes.findNestedTypeByName("OptionalGroup");
         this.repeatedGroup =
-          baseDescriptor.findNestedTypeByName("RepeatedGroup");
+          testAllTypes.findNestedTypeByName("RepeatedGroup");
       } else {
         this.optionalGroup =
           file.findMessageTypeByName("OptionalGroup_extension");
@@ -2279,6 +2531,191 @@ class TestUtil {
       Assert.assertEquals("524", message.getRepeatedField(f("repeated_string_piece"), 1));
       Assert.assertEquals("525", message.getRepeatedField(f("repeated_cord"), 1));
     }
+
+    public void setPackedFieldsViaReflection(Message.Builder message) {
+      message.addRepeatedField(f("packed_int32"   ), 601 );
+      message.addRepeatedField(f("packed_int64"   ), 602L);
+      message.addRepeatedField(f("packed_uint32"  ), 603 );
+      message.addRepeatedField(f("packed_uint64"  ), 604L);
+      message.addRepeatedField(f("packed_sint32"  ), 605 );
+      message.addRepeatedField(f("packed_sint64"  ), 606L);
+      message.addRepeatedField(f("packed_fixed32" ), 607 );
+      message.addRepeatedField(f("packed_fixed64" ), 608L);
+      message.addRepeatedField(f("packed_sfixed32"), 609 );
+      message.addRepeatedField(f("packed_sfixed64"), 610L);
+      message.addRepeatedField(f("packed_float"   ), 611F);
+      message.addRepeatedField(f("packed_double"  ), 612D);
+      message.addRepeatedField(f("packed_bool"    ), true);
+      message.addRepeatedField(f("packed_enum" ),  foreignBar);
+      // Add a second one of each field.
+      message.addRepeatedField(f("packed_int32"   ), 701 );
+      message.addRepeatedField(f("packed_int64"   ), 702L);
+      message.addRepeatedField(f("packed_uint32"  ), 703 );
+      message.addRepeatedField(f("packed_uint64"  ), 704L);
+      message.addRepeatedField(f("packed_sint32"  ), 705 );
+      message.addRepeatedField(f("packed_sint64"  ), 706L);
+      message.addRepeatedField(f("packed_fixed32" ), 707 );
+      message.addRepeatedField(f("packed_fixed64" ), 708L);
+      message.addRepeatedField(f("packed_sfixed32"), 709 );
+      message.addRepeatedField(f("packed_sfixed64"), 710L);
+      message.addRepeatedField(f("packed_float"   ), 711F);
+      message.addRepeatedField(f("packed_double"  ), 712D);
+      message.addRepeatedField(f("packed_bool"    ), false);
+      message.addRepeatedField(f("packed_enum" ),  foreignBaz);
+    }
+
+    public void assertPackedFieldsSetViaReflection(Message message) {
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_int32"   )));
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_int64"   )));
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_uint32"  )));
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_uint64"  )));
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sint32"  )));
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sint64"  )));
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_fixed32" )));
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_fixed64" )));
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sfixed32")));
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sfixed64")));
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_float"   )));
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_double"  )));
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_bool"    )));
+      Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_enum"   )));
+      Assert.assertEquals(601  , message.getRepeatedField(f("packed_int32"   ), 0));
+      Assert.assertEquals(602L , message.getRepeatedField(f("packed_int64"   ), 0));
+      Assert.assertEquals(603  , message.getRepeatedField(f("packed_uint32"  ), 0));
+      Assert.assertEquals(604L , message.getRepeatedField(f("packed_uint64"  ), 0));
+      Assert.assertEquals(605  , message.getRepeatedField(f("packed_sint32"  ), 0));
+      Assert.assertEquals(606L , message.getRepeatedField(f("packed_sint64"  ), 0));
+      Assert.assertEquals(607  , message.getRepeatedField(f("packed_fixed32" ), 0));
+      Assert.assertEquals(608L , message.getRepeatedField(f("packed_fixed64" ), 0));
+      Assert.assertEquals(609  , message.getRepeatedField(f("packed_sfixed32"), 0));
+      Assert.assertEquals(610L , message.getRepeatedField(f("packed_sfixed64"), 0));
+      Assert.assertEquals(611F , message.getRepeatedField(f("packed_float"   ), 0));
+      Assert.assertEquals(612D , message.getRepeatedField(f("packed_double"  ), 0));
+      Assert.assertEquals(true , message.getRepeatedField(f("packed_bool"    ), 0));
+      Assert.assertEquals(foreignBar, message.getRepeatedField(f("packed_enum" ),0));
+      Assert.assertEquals(701  , message.getRepeatedField(f("packed_int32"   ), 1));
+      Assert.assertEquals(702L , message.getRepeatedField(f("packed_int64"   ), 1));
+      Assert.assertEquals(703  , message.getRepeatedField(f("packed_uint32"  ), 1));
+      Assert.assertEquals(704L , message.getRepeatedField(f("packed_uint64"  ), 1));
+      Assert.assertEquals(705  , message.getRepeatedField(f("packed_sint32"  ), 1));
+      Assert.assertEquals(706L , message.getRepeatedField(f("packed_sint64"  ), 1));
+      Assert.assertEquals(707  , message.getRepeatedField(f("packed_fixed32" ), 1));
+      Assert.assertEquals(708L , message.getRepeatedField(f("packed_fixed64" ), 1));
+      Assert.assertEquals(709  , message.getRepeatedField(f("packed_sfixed32"), 1));
+      Assert.assertEquals(710L , message.getRepeatedField(f("packed_sfixed64"), 1));
+      Assert.assertEquals(711F , message.getRepeatedField(f("packed_float"   ), 1));
+      Assert.assertEquals(712D , message.getRepeatedField(f("packed_double"  ), 1));
+      Assert.assertEquals(false, message.getRepeatedField(f("packed_bool"    ), 1));
+      Assert.assertEquals(foreignBaz, message.getRepeatedField(f("packed_enum" ),1));
+    }
+
+    /**
+     * Verifies that the reflection setters for the given.Builder object throw a
+     * NullPointerException if they are passed a null value.  Uses Assert to throw an
+     * appropriate assertion failure, if the condition is not verified.
+     */
+    public void assertReflectionSettersRejectNull(Message.Builder builder)
+        throws Exception {
+      try {
+        builder.setField(f("optional_string"), null);
+        Assert.fail("Exception was not thrown");
+      } catch (NullPointerException e) {
+        // We expect this exception.
+      }
+      try {
+        builder.setField(f("optional_bytes"), null);
+        Assert.fail("Exception was not thrown");
+      } catch (NullPointerException e) {
+        // We expect this exception.
+      }
+      try {
+        builder.setField(f("optional_nested_enum"), null);
+        Assert.fail("Exception was not thrown");
+      } catch (NullPointerException e) {
+        // We expect this exception.
+      }
+      try {
+        builder.setField(f("optional_nested_message"),
+                         (TestAllTypes.NestedMessage) null);
+        Assert.fail("Exception was not thrown");
+      } catch (NullPointerException e) {
+        // We expect this exception.
+      }
+      try {
+        builder.setField(f("optional_nested_message"),
+                         (TestAllTypes.NestedMessage.Builder) null);
+        Assert.fail("Exception was not thrown");
+      } catch (NullPointerException e) {
+        // We expect this exception.
+      }
+
+      try {
+        builder.addRepeatedField(f("repeated_string"), null);
+        Assert.fail("Exception was not thrown");
+      } catch (NullPointerException e) {
+        // We expect this exception.
+      }
+      try {
+        builder.addRepeatedField(f("repeated_bytes"), null);
+        Assert.fail("Exception was not thrown");
+      } catch (NullPointerException e) {
+        // We expect this exception.
+      }
+      try {
+        builder.addRepeatedField(f("repeated_nested_enum"), null);
+        Assert.fail("Exception was not thrown");
+      } catch (NullPointerException e) {
+        // We expect this exception.
+      }
+      try {
+        builder.addRepeatedField(f("repeated_nested_message"), null);
+        Assert.fail("Exception was not thrown");
+      } catch (NullPointerException e) {
+        // We expect this exception.
+      }
+    }
+
+    /**
+     * Verifies that the reflection repeated setters for the given Builder object throw a
+     * NullPointerException if they are passed a null value.  Uses Assert to throw an appropriate
+     * assertion failure, if the condition is not verified.
+     */
+    public void assertReflectionRepeatedSettersRejectNull(Message.Builder builder)
+        throws Exception {
+      builder.addRepeatedField(f("repeated_string"), "one");
+      try {
+        builder.setRepeatedField(f("repeated_string"), 0, null);
+        Assert.fail("Exception was not thrown");
+      } catch (NullPointerException e) {
+        // We expect this exception.
+      }
+
+      builder.addRepeatedField(f("repeated_bytes"), toBytes("one"));
+      try {
+        builder.setRepeatedField(f("repeated_bytes"), 0, null);
+        Assert.fail("Exception was not thrown");
+      } catch (NullPointerException e) {
+        // We expect this exception.
+      }
+
+      builder.addRepeatedField(f("repeated_nested_enum"), nestedBaz);
+      try {
+        builder.setRepeatedField(f("repeated_nested_enum"), 0, null);
+        Assert.fail("Exception was not thrown");
+      } catch (NullPointerException e) {
+        // We expect this exception.
+      }
+
+      builder.addRepeatedField(
+          f("repeated_nested_message"),
+          TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
+      try {
+        builder.setRepeatedField(f("repeated_nested_message"), 0, null);
+        Assert.fail("Exception was not thrown");
+      } catch (NullPointerException e) {
+        // We expect this exception.
+      }
+    }
   }
 
   /**
@@ -2344,4 +2781,21 @@ class TestUtil {
     return goldenMessage;
   }
   private static ByteString goldenMessage = null;
+
+  /**
+   * Get the bytes of the "golden packed fields message".  This is a serialized
+   * TestPackedTypes with all fields set as they would be by
+   * {@link setPackedFields(TestPackedTypes.Builder)}, but it is loaded from a
+   * file on disk rather than generated dynamically.  The file is actually
+   * generated by C++ code, so testing against it verifies compatibility with
+   * C++.
+   */
+  public static ByteString getGoldenPackedFieldsMessage() {
+    if (goldenPackedFieldsMessage == null) {
+      goldenPackedFieldsMessage =
+          readBytesFromFile("golden_packed_fields_message");
+    }
+    return goldenPackedFieldsMessage;
+  }
+  private static ByteString goldenPackedFieldsMessage = null;
 }
diff --git a/java/src/test/java/com/google/protobuf/TextFormatTest.java b/java/src/test/java/com/google/protobuf/TextFormatTest.java
index 9557bdf6..ec4910a3 100644
--- a/java/src/test/java/com/google/protobuf/TextFormatTest.java
+++ b/java/src/test/java/com/google/protobuf/TextFormatTest.java
@@ -586,4 +586,32 @@ public class TextFormatTest extends TestCase {
       // success
     }
   }
+
+  public void testParseLongString() throws Exception {
+    String longText =
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890" +
+      "123456789012345678901234567890123456789012345678901234567890";
+
+    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
+    TextFormat.merge("optional_string: \"" + longText + "\"", builder);
+    assertEquals(longText, 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 3fb54fcf..48453faf 100644
--- a/java/src/test/java/com/google/protobuf/WireFormatTest.java
+++ b/java/src/test/java/com/google/protobuf/WireFormatTest.java
@@ -32,9 +32,11 @@ package com.google.protobuf;
 
 import junit.framework.TestCase;
 import protobuf_unittest.UnittestProto;
-import protobuf_unittest.UnittestProto.TestAllTypes;
 import protobuf_unittest.UnittestProto.TestAllExtensions;
+import protobuf_unittest.UnittestProto.TestAllTypes;
 import protobuf_unittest.UnittestProto.TestFieldOrderings;
+import protobuf_unittest.UnittestProto.TestPackedExtensions;
+import protobuf_unittest.UnittestProto.TestPackedTypes;
 import protobuf_unittest.UnittestMset.TestMessageSet;
 import protobuf_unittest.UnittestMset.RawMessageSet;
 import protobuf_unittest.UnittestMset.TestMessageSetExtension1;
@@ -57,9 +59,20 @@ public class WireFormatTest extends TestCase {
     TestUtil.assertAllFieldsSet(message2);
   }
 
+  public void testSerializationPacked() throws Exception {
+    TestPackedTypes message = TestUtil.getPackedSet();
+
+    ByteString rawBytes = message.toByteString();
+    assertEquals(rawBytes.size(), message.getSerializedSize());
+
+    TestPackedTypes message2 = TestPackedTypes.parseFrom(rawBytes);
+
+    TestUtil.assertPackedFieldsSet(message2);
+  }
+
   public void testSerializeExtensions() throws Exception {
     // TestAllTypes and TestAllExtensions should have compatible wire formats,
-    // so if we serealize a TestAllExtensions then parse it as TestAllTypes
+    // so if we serialize a TestAllExtensions then parse it as TestAllTypes
     // it should work.
 
     TestAllExtensions message = TestUtil.getAllExtensionsSet();
@@ -71,17 +84,27 @@ public class WireFormatTest extends TestCase {
     TestUtil.assertAllFieldsSet(message2);
   }
 
+  public void testSerializePackedExtensions() throws Exception {
+    // TestPackedTypes and TestPackedExtensions should have compatible wire
+    // formats; check that they serialize to the same string.
+    TestPackedExtensions message = TestUtil.getPackedExtensionsSet();
+    ByteString rawBytes = message.toByteString();
+
+    TestPackedTypes message2 = TestUtil.getPackedSet();
+    ByteString rawBytes2 = message2.toByteString();
+
+    assertEquals(rawBytes, rawBytes2);
+  }
+
   public void testParseExtensions() throws Exception {
     // TestAllTypes and TestAllExtensions should have compatible wire formats,
-    // so if we serealize a TestAllTypes then parse it as TestAllExtensions
+    // so if we serialize a TestAllTypes then parse it as TestAllExtensions
     // it should work.
 
     TestAllTypes message = TestUtil.getAllSet();
     ByteString rawBytes = message.toByteString();
 
-    ExtensionRegistry registry = ExtensionRegistry.newInstance();
-    TestUtil.registerAllExtensions(registry);
-    registry = registry.getUnmodifiable();
+    ExtensionRegistry registry = TestUtil.getExtensionRegistry();
 
     TestAllExtensions message2 =
       TestAllExtensions.parseFrom(rawBytes, registry);
@@ -89,6 +112,19 @@ public class WireFormatTest extends TestCase {
     TestUtil.assertAllExtensionsSet(message2);
   }
 
+  public void testParsePackedExtensions() throws Exception {
+    // Ensure that packed extensions can be properly parsed.
+    TestPackedExtensions message = TestUtil.getPackedExtensionsSet();
+    ByteString rawBytes = message.toByteString();
+
+    ExtensionRegistry registry = TestUtil.getExtensionRegistry();
+
+    TestPackedExtensions message2 =
+        TestPackedExtensions.parseFrom(rawBytes, registry);
+
+    TestUtil.assertPackedExtensionsSet(message2);
+  }
+
   public void testExtensionsSerializedSize() throws Exception {
     assertEquals(TestUtil.getAllSet().getSerializedSize(),
                  TestUtil.getAllExtensionsSet().getSerializedSize());
@@ -279,4 +315,3 @@ public class WireFormatTest extends TestCase {
     assertEquals("bar", field.getLengthDelimitedList().get(0).toStringUtf8());
   }
 }
-