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.

17 files changed, 2008 insertions, 754 deletions

diff --git a/java/src/main/java/com/google/protobuf/AbstractMessage.java b/java/src/main/java/com/google/protobuf/AbstractMessage.java
index 2f61859d..24c32a47 100644
--- a/java/src/main/java/com/google/protobuf/AbstractMessage.java
+++ b/java/src/main/java/com/google/protobuf/AbstractMessage.java
@@ -86,8 +86,25 @@ public abstract class AbstractMessage implements Message {
     for (Map.Entry<FieldDescriptor, Object> entry : getAllFields().entrySet()) {
       FieldDescriptor field = entry.getKey();
       if (field.isRepeated()) {
-        for (Object element : (List) entry.getValue()) {
-          output.writeField(field.getType(), field.getNumber(), element);
+        List valueList = (List) entry.getValue();
+        if (field.getOptions().getPacked()) {
+
+          output.writeTag(field.getNumber(),
+                          WireFormat.WIRETYPE_LENGTH_DELIMITED);
+          int dataSize = 0;
+          for (Object element : valueList) {
+            dataSize += CodedOutputStream.computeFieldSizeNoTag(
+                field.getType(), element);
+          }
+          output.writeRawVarint32(dataSize);
+
+          for (Object element : valueList) {
+            output.writeFieldNoTag(field.getType(), element);
+          }
+        } else {
+          for (Object element : valueList) {
+            output.writeField(field.getType(), field.getNumber(), element);
+          }
         }
       } else {
         output.writeField(field.getType(), field.getNumber(), entry.getValue());
@@ -145,9 +162,21 @@ public abstract class AbstractMessage implements Message {
     for (Map.Entry<FieldDescriptor, Object> entry : getAllFields().entrySet()) {
       FieldDescriptor field = entry.getKey();
       if (field.isRepeated()) {
-        for (Object element : (List) entry.getValue()) {
-          size += CodedOutputStream.computeFieldSize(
-            field.getType(), field.getNumber(), element);
+        List valueList = (List) entry.getValue();
+        if (field.getOptions().getPacked()) {
+          int dataSize = 0;
+          for (Object element : valueList) {
+            dataSize += CodedOutputStream.computeFieldSizeNoTag(
+                field.getType(), element);
+          }
+          size += dataSize;
+          size += CodedOutputStream.computeTagSize(field.getNumber());
+          size += CodedOutputStream.computeRawVarint32Size(dataSize);
+        } else {
+          for (Object element : valueList) {
+            size += CodedOutputStream.computeFieldSize(
+                field.getType(), field.getNumber(), element);
+          }
         }
       } else {
         size += CodedOutputStream.computeFieldSize(
@@ -165,7 +194,7 @@ public abstract class AbstractMessage implements Message {
     memoizedSize = size;
     return size;
   }
-  
+
   @Override
   public boolean equals(Object other) {
     if (other == this) {
@@ -180,7 +209,7 @@ public abstract class AbstractMessage implements Message {
     }
     return getAllFields().equals(otherMessage.getAllFields());
   }
-  
+
   @Override
   public int hashCode() {
     int hash = 41;
diff --git a/java/src/main/java/com/google/protobuf/CodedInputStream.java b/java/src/main/java/com/google/protobuf/CodedInputStream.java
index caef068b..8f277a9f 100644
--- a/java/src/main/java/com/google/protobuf/CodedInputStream.java
+++ b/java/src/main/java/com/google/protobuf/CodedInputStream.java
@@ -193,7 +193,7 @@ public final class CodedInputStream {
   /** Read a {@code string} field value from the stream. */
   public String readString() throws IOException {
     int size = readRawVarint32();
-    if (size < bufferSize - bufferPos && size > 0) {
+    if (size <= (bufferSize - bufferPos) && size > 0) {
       // Fast path:  We already have the bytes in a contiguous buffer, so
       //   just copy directly from it.
       String result = new String(buffer, bufferPos, size, "UTF-8");
@@ -584,6 +584,19 @@ public final class CodedInputStream {
   }
 
   /**
+   * Returns the number of bytes to be read before the current limit.
+   * If no limit is set, returns -1.
+   */
+  public int getBytesUntilLimit() {
+    if (currentLimit == Integer.MAX_VALUE) {
+      return -1;
+    }
+
+    int currentAbsolutePosition = totalBytesRetired + bufferPos;
+    return currentLimit - currentAbsolutePosition;
+  }
+
+  /**
    * Called with {@code this.buffer} is empty to read more bytes from the
    * input.  If {@code mustSucceed} is true, refillBuffer() gurantees that
    * either there will be at least one byte in the buffer when it returns
diff --git a/java/src/main/java/com/google/protobuf/CodedOutputStream.java b/java/src/main/java/com/google/protobuf/CodedOutputStream.java
index d232841a..e8be8611 100644
--- a/java/src/main/java/com/google/protobuf/CodedOutputStream.java
+++ b/java/src/main/java/com/google/protobuf/CodedOutputStream.java
@@ -118,71 +118,61 @@ public final class CodedOutputStream {
   /** Write a {@code double} field, including tag, to the stream. */
   public void writeDouble(int fieldNumber, double value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64);
-    writeRawLittleEndian64(Double.doubleToRawLongBits(value));
+    writeDoubleNoTag(value);
   }
 
   /** Write a {@code float} field, including tag, to the stream. */
   public void writeFloat(int fieldNumber, float value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32);
-    writeRawLittleEndian32(Float.floatToRawIntBits(value));
+    writeFloatNoTag(value);
   }
 
   /** Write a {@code uint64} field, including tag, to the stream. */
   public void writeUInt64(int fieldNumber, long value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT);
-    writeRawVarint64(value);
+    writeUInt64NoTag(value);
   }
 
   /** Write an {@code int64} field, including tag, to the stream. */
   public void writeInt64(int fieldNumber, long value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT);
-    writeRawVarint64(value);
+    writeInt64NoTag(value);
   }
 
   /** Write an {@code int32} field, including tag, to the stream. */
   public void writeInt32(int fieldNumber, int value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT);
-    if (value >= 0) {
-      writeRawVarint32(value);
-    } else {
-      // Must sign-extend.
-      writeRawVarint64(value);
-    }
+    writeInt32NoTag(value);
   }
 
   /** Write a {@code fixed64} field, including tag, to the stream. */
   public void writeFixed64(int fieldNumber, long value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64);
-    writeRawLittleEndian64(value);
+    writeFixed64NoTag(value);
   }
 
   /** Write a {@code fixed32} field, including tag, to the stream. */
   public void writeFixed32(int fieldNumber, int value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32);
-    writeRawLittleEndian32(value);
+    writeFixed32NoTag(value);
   }
 
   /** Write a {@code bool} field, including tag, to the stream. */
   public void writeBool(int fieldNumber, boolean value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT);
-    writeRawByte(value ? 1 : 0);
+    writeBoolNoTag(value);
   }
 
   /** Write a {@code string} field, including tag, to the stream. */
   public void writeString(int fieldNumber, String value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED);
-    // Unfortunately there does not appear to be any way to tell Java to encode
-    // UTF-8 directly into our buffer, so we have to let it create its own byte
-    // array and then copy.
-    byte[] bytes = value.getBytes("UTF-8");
-    writeRawVarint32(bytes.length);
-    writeRawBytes(bytes);
+    writeStringNoTag(value);
   }
 
   /** Write a {@code group} field, including tag, to the stream. */
   public void writeGroup(int fieldNumber, Message value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_START_GROUP);
-    value.writeTo(this);
+    writeGroupNoTag(value);
     writeTag(fieldNumber, WireFormat.WIRETYPE_END_GROUP);
   }
 
@@ -190,29 +180,26 @@ public final class CodedOutputStream {
   public void writeUnknownGroup(int fieldNumber, UnknownFieldSet value)
       throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_START_GROUP);
-    value.writeTo(this);
+    writeUnknownGroupNoTag(value);
     writeTag(fieldNumber, WireFormat.WIRETYPE_END_GROUP);
   }
 
   /** Write an embedded message field, including tag, to the stream. */
   public void writeMessage(int fieldNumber, Message value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED);
-    writeRawVarint32(value.getSerializedSize());
-    value.writeTo(this);
+    writeMessageNoTag(value);
   }
 
   /** Write a {@code bytes} field, including tag, to the stream. */
   public void writeBytes(int fieldNumber, ByteString value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED);
-    byte[] bytes = value.toByteArray();
-    writeRawVarint32(bytes.length);
-    writeRawBytes(bytes);
+    writeBytesNoTag(value);
   }
 
   /** Write a {@code uint32} field, including tag, to the stream. */
   public void writeUInt32(int fieldNumber, int value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT);
-    writeRawVarint32(value);
+    writeUInt32NoTag(value);
   }
 
   /**
@@ -221,31 +208,31 @@ public final class CodedOutputStream {
    */
   public void writeEnum(int fieldNumber, int value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT);
-    writeRawVarint32(value);
+    writeEnumNoTag(value);
   }
 
   /** Write an {@code sfixed32} field, including tag, to the stream. */
   public void writeSFixed32(int fieldNumber, int value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32);
-    writeRawLittleEndian32(value);
+    writeSFixed32NoTag(value);
   }
 
   /** Write an {@code sfixed64} field, including tag, to the stream. */
   public void writeSFixed64(int fieldNumber, long value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64);
-    writeRawLittleEndian64(value);
+    writeSFixed64NoTag(value);
   }
 
   /** Write an {@code sint32} field, including tag, to the stream. */
   public void writeSInt32(int fieldNumber, int value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT);
-    writeRawVarint32(encodeZigZag32(value));
+    writeSInt32NoTag(value);
   }
 
   /** Write an {@code sint64} field, including tag, to the stream. */
   public void writeSInt64(int fieldNumber, long value) throws IOException {
     writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT);
-    writeRawVarint64(encodeZigZag64(value));
+    writeSInt64NoTag(value);
   }
 
   /**
@@ -283,32 +270,168 @@ public final class CodedOutputStream {
    *               this field.
    */
   public void writeField(Descriptors.FieldDescriptor.Type type,
-                         int number, Object value) throws IOException {
+                         int number,
+                         Object value) throws IOException {
+    // Special case for groups, which need a start and end tag; other fields
+    // can just use writeTag() and writeFieldNoTag().
+    if (type == Descriptors.FieldDescriptor.Type.GROUP) {
+      writeGroup(number, (Message) value);
+    } else {
+      writeTag(number, WireFormat.getWireFormatForFieldType(type));
+      writeFieldNoTag(type, value);
+    }
+  }
+
+  /**
+   * Write a field of arbitrary type, without its tag, to the stream.
+   *
+   * @param type The field's type.
+   * @param value  Object representing the field's value.  Must be of the exact
+   *               type which would be returned by
+   *               {@link Message#getField(Descriptors.FieldDescriptor)} for
+   *               this field.
+   */
+  public void writeFieldNoTag(Descriptors.FieldDescriptor.Type type,
+                              Object value) throws IOException {
     switch (type) {
-      case DOUBLE  : writeDouble  (number, (Double    )value); break;
-      case FLOAT   : writeFloat   (number, (Float     )value); break;
-      case INT64   : writeInt64   (number, (Long      )value); break;
-      case UINT64  : writeUInt64  (number, (Long      )value); break;
-      case INT32   : writeInt32   (number, (Integer   )value); break;
-      case FIXED64 : writeFixed64 (number, (Long      )value); break;
-      case FIXED32 : writeFixed32 (number, (Integer   )value); break;
-      case BOOL    : writeBool    (number, (Boolean   )value); break;
-      case STRING  : writeString  (number, (String    )value); break;
-      case GROUP   : writeGroup   (number, (Message   )value); break;
-      case MESSAGE : writeMessage (number, (Message   )value); break;
-      case BYTES   : writeBytes   (number, (ByteString)value); break;
-      case UINT32  : writeUInt32  (number, (Integer   )value); break;
-      case SFIXED32: writeSFixed32(number, (Integer   )value); break;
-      case SFIXED64: writeSFixed64(number, (Long      )value); break;
-      case SINT32  : writeSInt32  (number, (Integer   )value); break;
-      case SINT64  : writeSInt64  (number, (Long      )value); break;
+      case DOUBLE  : writeDoubleNoTag  ((Double    ) value); break;
+      case FLOAT   : writeFloatNoTag   ((Float     ) value); break;
+      case INT64   : writeInt64NoTag   ((Long      ) value); break;
+      case UINT64  : writeUInt64NoTag  ((Long      ) value); break;
+      case INT32   : writeInt32NoTag   ((Integer   ) value); break;
+      case FIXED64 : writeFixed64NoTag ((Long      ) value); break;
+      case FIXED32 : writeFixed32NoTag ((Integer   ) value); break;
+      case BOOL    : writeBoolNoTag    ((Boolean   ) value); break;
+      case STRING  : writeStringNoTag  ((String    ) value); break;
+      case GROUP   : writeGroupNoTag   ((Message   ) value); break;
+      case MESSAGE : writeMessageNoTag ((Message   ) value); break;
+      case BYTES   : writeBytesNoTag   ((ByteString) value); break;
+      case UINT32  : writeUInt32NoTag  ((Integer   ) value); break;
+      case SFIXED32: writeSFixed32NoTag((Integer   ) value); break;
+      case SFIXED64: writeSFixed64NoTag((Long      ) value); break;
+      case SINT32  : writeSInt32NoTag  ((Integer   ) value); break;
+      case SINT64  : writeSInt64NoTag  ((Long      ) value); break;
 
       case ENUM:
-        writeEnum(number, ((Descriptors.EnumValueDescriptor)value).getNumber());
+        writeEnumNoTag(((Descriptors.EnumValueDescriptor) value).getNumber());
         break;
     }
   }
 
+  // -----------------------------------------------------------------
+
+  /** Write a {@code double} field to the stream. */
+  public void writeDoubleNoTag(double value) throws IOException {
+    writeRawLittleEndian64(Double.doubleToRawLongBits(value));
+  }
+
+  /** Write a {@code float} field to the stream. */
+  public void writeFloatNoTag(float value) throws IOException {
+    writeRawLittleEndian32(Float.floatToRawIntBits(value));
+  }
+
+  /** Write a {@code uint64} field to the stream. */
+  public void writeUInt64NoTag(long value) throws IOException {
+    writeRawVarint64(value);
+  }
+
+  /** Write an {@code int64} field to the stream. */
+  public void writeInt64NoTag(long value) throws IOException {
+    writeRawVarint64(value);
+  }
+
+  /** Write an {@code int32} field to the stream. */
+  public void writeInt32NoTag(int value) throws IOException {
+    if (value >= 0) {
+      writeRawVarint32(value);
+    } else {
+      // Must sign-extend.
+      writeRawVarint64(value);
+    }
+  }
+
+  /** Write a {@code fixed64} field to the stream. */
+  public void writeFixed64NoTag(long value) throws IOException {
+    writeRawLittleEndian64(value);
+  }
+
+  /** Write a {@code fixed32} field to the stream. */
+  public void writeFixed32NoTag(int value) throws IOException {
+    writeRawLittleEndian32(value);
+  }
+
+  /** Write a {@code bool} field to the stream. */
+  public void writeBoolNoTag(boolean value) throws IOException {
+    writeRawByte(value ? 1 : 0);
+  }
+
+  /** Write a {@code string} field to the stream. */
+  public void writeStringNoTag(String value) throws IOException {
+    // Unfortunately there does not appear to be any way to tell Java to encode
+    // UTF-8 directly into our buffer, so we have to let it create its own byte
+    // array and then copy.
+    byte[] bytes = value.getBytes("UTF-8");
+    writeRawVarint32(bytes.length);
+    writeRawBytes(bytes);
+  }
+
+  /** Write a {@code group} field to the stream. */
+  public void writeGroupNoTag(Message value) throws IOException {
+    value.writeTo(this);
+  }
+
+  /** Write a group represented by an {@link UnknownFieldSet}. */
+  public void writeUnknownGroupNoTag(UnknownFieldSet value)
+      throws IOException {
+    value.writeTo(this);
+  }
+
+  /** Write an embedded message field to the stream. */
+  public void writeMessageNoTag(Message value) throws IOException {
+    writeRawVarint32(value.getSerializedSize());
+    value.writeTo(this);
+  }
+
+  /** Write a {@code bytes} field to the stream. */
+  public void writeBytesNoTag(ByteString value) throws IOException {
+    byte[] bytes = value.toByteArray();
+    writeRawVarint32(bytes.length);
+    writeRawBytes(bytes);
+  }
+
+  /** Write a {@code uint32} field to the stream. */
+  public void writeUInt32NoTag(int value) throws IOException {
+    writeRawVarint32(value);
+  }
+
+  /**
+   * Write an enum field to the stream.  Caller is responsible
+   * for converting the enum value to its numeric value.
+   */
+  public void writeEnumNoTag(int value) throws IOException {
+    writeRawVarint32(value);
+  }
+
+  /** Write an {@code sfixed32} field to the stream. */
+  public void writeSFixed32NoTag(int value) throws IOException {
+    writeRawLittleEndian32(value);
+  }
+
+  /** Write an {@code sfixed64} field to the stream. */
+  public void writeSFixed64NoTag(long value) throws IOException {
+    writeRawLittleEndian64(value);
+  }
+
+  /** Write an {@code sint32} field to the stream. */
+  public void writeSInt32NoTag(int value) throws IOException {
+    writeRawVarint32(encodeZigZag32(value));
+  }
+
+  /** Write an {@code sint64} field to the stream. */
+  public void writeSInt64NoTag(long value) throws IOException {
+    writeRawVarint64(encodeZigZag64(value));
+  }
+
   // =================================================================
 
   /**
@@ -316,7 +439,7 @@ public final class CodedOutputStream {
    * {@code double} field, including tag.
    */
   public static int computeDoubleSize(int fieldNumber, double value) {
-    return computeTagSize(fieldNumber) + LITTLE_ENDIAN_64_SIZE;
+    return computeTagSize(fieldNumber) + computeDoubleSizeNoTag(value);
   }
 
   /**
@@ -324,7 +447,7 @@ public final class CodedOutputStream {
    * {@code float} field, including tag.
    */
   public static int computeFloatSize(int fieldNumber, float value) {
-    return computeTagSize(fieldNumber) + LITTLE_ENDIAN_32_SIZE;
+    return computeTagSize(fieldNumber) + computeFloatSizeNoTag(value);
   }
 
   /**
@@ -332,7 +455,7 @@ public final class CodedOutputStream {
    * {@code uint64} field, including tag.
    */
   public static int computeUInt64Size(int fieldNumber, long value) {
-    return computeTagSize(fieldNumber) + computeRawVarint64Size(value);
+    return computeTagSize(fieldNumber) + computeUInt64SizeNoTag(value);
   }
 
   /**
@@ -340,7 +463,7 @@ public final class CodedOutputStream {
    * {@code int64} field, including tag.
    */
   public static int computeInt64Size(int fieldNumber, long value) {
-    return computeTagSize(fieldNumber) + computeRawVarint64Size(value);
+    return computeTagSize(fieldNumber) + computeInt64SizeNoTag(value);
   }
 
   /**
@@ -348,12 +471,7 @@ public final class CodedOutputStream {
    * {@code int32} field, including tag.
    */
   public static int computeInt32Size(int fieldNumber, int value) {
-    if (value >= 0) {
-      return computeTagSize(fieldNumber) + computeRawVarint32Size(value);
-    } else {
-      // Must sign-extend.
-      return computeTagSize(fieldNumber) + 10;
-    }
+    return computeTagSize(fieldNumber) + computeInt32SizeNoTag(value);
   }
 
   /**
@@ -361,7 +479,7 @@ public final class CodedOutputStream {
    * {@code fixed64} field, including tag.
    */
   public static int computeFixed64Size(int fieldNumber, long value) {
-    return computeTagSize(fieldNumber) + LITTLE_ENDIAN_64_SIZE;
+    return computeTagSize(fieldNumber) + computeFixed64SizeNoTag(value);
   }
 
   /**
@@ -369,7 +487,7 @@ public final class CodedOutputStream {
    * {@code fixed32} field, including tag.
    */
   public static int computeFixed32Size(int fieldNumber, int value) {
-    return computeTagSize(fieldNumber) + LITTLE_ENDIAN_32_SIZE;
+    return computeTagSize(fieldNumber) + computeFixed32SizeNoTag(value);
   }
 
   /**
@@ -377,7 +495,7 @@ public final class CodedOutputStream {
    * {@code bool} field, including tag.
    */
   public static int computeBoolSize(int fieldNumber, boolean value) {
-    return computeTagSize(fieldNumber) + 1;
+    return computeTagSize(fieldNumber) + computeBoolSizeNoTag(value);
   }
 
   /**
@@ -385,14 +503,7 @@ public final class CodedOutputStream {
    * {@code string} field, including tag.
    */
   public static int computeStringSize(int fieldNumber, String value) {
-    try {
-      byte[] bytes = value.getBytes("UTF-8");
-      return computeTagSize(fieldNumber) +
-             computeRawVarint32Size(bytes.length) +
-             bytes.length;
-    } catch (java.io.UnsupportedEncodingException e) {
-      throw new RuntimeException("UTF-8 not supported.", e);
-    }
+    return computeTagSize(fieldNumber) + computeStringSizeNoTag(value);
   }
 
   /**
@@ -400,7 +511,7 @@ public final class CodedOutputStream {
    * {@code group} field, including tag.
    */
   public static int computeGroupSize(int fieldNumber, Message value) {
-    return computeTagSize(fieldNumber) * 2 + value.getSerializedSize();
+    return computeTagSize(fieldNumber) * 2 + computeGroupSizeNoTag(value);
   }
 
   /**
@@ -410,7 +521,8 @@ public final class CodedOutputStream {
    */
   public static int computeUnknownGroupSize(int fieldNumber,
                                             UnknownFieldSet value) {
-    return computeTagSize(fieldNumber) * 2 + value.getSerializedSize();
+    return computeTagSize(fieldNumber) * 2 +
+        computeUnknownGroupSizeNoTag(value);
   }
 
   /**
@@ -418,8 +530,7 @@ public final class CodedOutputStream {
    * embedded message field, including tag.
    */
   public static int computeMessageSize(int fieldNumber, Message value) {
-    int size = value.getSerializedSize();
-    return computeTagSize(fieldNumber) + computeRawVarint32Size(size) + size;
+    return computeTagSize(fieldNumber) + computeMessageSizeNoTag(value);
   }
 
   /**
@@ -427,9 +538,7 @@ public final class CodedOutputStream {
    * {@code bytes} field, including tag.
    */
   public static int computeBytesSize(int fieldNumber, ByteString value) {
-    return computeTagSize(fieldNumber) +
-           computeRawVarint32Size(value.size()) +
-           value.size();
+    return computeTagSize(fieldNumber) + computeBytesSizeNoTag(value);
   }
 
   /**
@@ -437,7 +546,7 @@ public final class CodedOutputStream {
    * {@code uint32} field, including tag.
    */
   public static int computeUInt32Size(int fieldNumber, int value) {
-    return computeTagSize(fieldNumber) + computeRawVarint32Size(value);
+    return computeTagSize(fieldNumber) + computeUInt32SizeNoTag(value);
   }
 
   /**
@@ -446,7 +555,7 @@ public final class CodedOutputStream {
    * enum value to its numeric value.
    */
   public static int computeEnumSize(int fieldNumber, int value) {
-    return computeTagSize(fieldNumber) + computeRawVarint32Size(value);
+    return computeTagSize(fieldNumber) + computeEnumSizeNoTag(value);
   }
 
   /**
@@ -454,7 +563,7 @@ public final class CodedOutputStream {
    * {@code sfixed32} field, including tag.
    */
   public static int computeSFixed32Size(int fieldNumber, int value) {
-    return computeTagSize(fieldNumber) + LITTLE_ENDIAN_32_SIZE;
+    return computeTagSize(fieldNumber) + computeSFixed32SizeNoTag(value);
   }
 
   /**
@@ -462,7 +571,7 @@ public final class CodedOutputStream {
    * {@code sfixed64} field, including tag.
    */
   public static int computeSFixed64Size(int fieldNumber, long value) {
-    return computeTagSize(fieldNumber) + LITTLE_ENDIAN_64_SIZE;
+    return computeTagSize(fieldNumber) + computeSFixed64SizeNoTag(value);
   }
 
   /**
@@ -470,8 +579,7 @@ public final class CodedOutputStream {
    * {@code sint32} field, including tag.
    */
   public static int computeSInt32Size(int fieldNumber, int value) {
-    return computeTagSize(fieldNumber) +
-           computeRawVarint32Size(encodeZigZag32(value));
+    return computeTagSize(fieldNumber) + computeSInt32SizeNoTag(value);
   }
 
   /**
@@ -479,8 +587,7 @@ public final class CodedOutputStream {
    * {@code sint64} field, including tag.
    */
   public static int computeSInt64Size(int fieldNumber, long value) {
-    return computeTagSize(fieldNumber) +
-           computeRawVarint64Size(encodeZigZag64(value));
+    return computeTagSize(fieldNumber) + computeSInt64SizeNoTag(value);
   }
 
   /**
@@ -507,6 +614,174 @@ public final class CodedOutputStream {
            computeBytesSize(WireFormat.MESSAGE_SET_MESSAGE, value);
   }
 
+  // -----------------------------------------------------------------
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code double} field, including tag.
+   */
+  public static int computeDoubleSizeNoTag(double value) {
+    return LITTLE_ENDIAN_64_SIZE;
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code float} field, including tag.
+   */
+  public static int computeFloatSizeNoTag(float value) {
+    return LITTLE_ENDIAN_32_SIZE;
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code uint64} field, including tag.
+   */
+  public static int computeUInt64SizeNoTag(long value) {
+    return computeRawVarint64Size(value);
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode an
+   * {@code int64} field, including tag.
+   */
+  public static int computeInt64SizeNoTag(long value) {
+    return computeRawVarint64Size(value);
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode an
+   * {@code int32} field, including tag.
+   */
+  public static int computeInt32SizeNoTag(int value) {
+    if (value >= 0) {
+      return computeRawVarint32Size(value);
+    } else {
+      // Must sign-extend.
+      return 10;
+    }
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code fixed64} field.
+   */
+  public static int computeFixed64SizeNoTag(long value) {
+    return LITTLE_ENDIAN_64_SIZE;
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code fixed32} field.
+   */
+  public static int computeFixed32SizeNoTag(int value) {
+    return LITTLE_ENDIAN_32_SIZE;
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code bool} field.
+   */
+  public static int computeBoolSizeNoTag(boolean value) {
+    return 1;
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code string} field.
+   */
+  public static int computeStringSizeNoTag(String value) {
+    try {
+      byte[] bytes = value.getBytes("UTF-8");
+      return computeRawVarint32Size(bytes.length) +
+             bytes.length;
+    } catch (java.io.UnsupportedEncodingException e) {
+      throw new RuntimeException("UTF-8 not supported.", e);
+    }
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code group} field.
+   */
+  public static int computeGroupSizeNoTag(Message value) {
+    return value.getSerializedSize();
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code group} field represented by an {@code UnknownFieldSet}, including
+   * tag.
+   */
+  public static int computeUnknownGroupSizeNoTag(UnknownFieldSet value) {
+    return value.getSerializedSize();
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode an embedded
+   * message field.
+   */
+  public static int computeMessageSizeNoTag(Message value) {
+    int size = value.getSerializedSize();
+    return computeRawVarint32Size(size) + size;
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code bytes} field.
+   */
+  public static int computeBytesSizeNoTag(ByteString value) {
+    return computeRawVarint32Size(value.size()) +
+           value.size();
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * {@code uint32} field.
+   */
+  public static int computeUInt32SizeNoTag(int value) {
+    return computeRawVarint32Size(value);
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode an enum field.  
+   * Caller is responsible for converting the enum value to its numeric value.
+   */
+  public static int computeEnumSizeNoTag(int value) {
+    return computeRawVarint32Size(value);
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode an
+   * {@code sfixed32} field.
+   */
+  public static int computeSFixed32SizeNoTag(int value) {
+    return LITTLE_ENDIAN_32_SIZE;
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode an
+   * {@code sfixed64} field.
+   */
+  public static int computeSFixed64SizeNoTag(long value) {
+    return LITTLE_ENDIAN_64_SIZE;
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode an
+   * {@code sint32} field.
+   */
+  public static int computeSInt32SizeNoTag(int value) {
+    return computeRawVarint32Size(encodeZigZag32(value));
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode an
+   * {@code sint64} field.
+   */
+  public static int computeSInt64SizeNoTag(long value) {
+    return computeRawVarint64Size(encodeZigZag64(value));
+  }
+
   /**
    * Compute the number of bytes that would be needed to encode a
    * field of arbitrary type, including tag, to the stream.
@@ -521,28 +796,48 @@ public final class CodedOutputStream {
   public static int computeFieldSize(
       Descriptors.FieldDescriptor.Type type,
       int number, Object value) {
+    int tagSize = computeTagSize(number);
+    if (type == Descriptors.FieldDescriptor.Type.GROUP) {
+      tagSize *= 2;
+    }
+    return tagSize + computeFieldSizeNoTag(type, value);
+  }
+
+  /**
+   * Compute the number of bytes that would be needed to encode a
+   * field of arbitrary type, excluding tag, to the stream.
+   *
+   * @param type   The field's type.
+   * @param number The field's number.
+   * @param value  Object representing the field's value.  Must be of the exact
+   *               type which would be returned by
+   *               {@link Message#getField(Descriptors.FieldDescriptor)} for
+   *               this field.
+   */
+  public static int computeFieldSizeNoTag(
+      Descriptors.FieldDescriptor.Type type, Object value) {
     switch (type) {
-      case DOUBLE  : return computeDoubleSize  (number, (Double    )value);
-      case FLOAT   : return computeFloatSize   (number, (Float     )value);
-      case INT64   : return computeInt64Size   (number, (Long      )value);
-      case UINT64  : return computeUInt64Size  (number, (Long      )value);
-      case INT32   : return computeInt32Size   (number, (Integer   )value);
-      case FIXED64 : return computeFixed64Size (number, (Long      )value);
-      case FIXED32 : return computeFixed32Size (number, (Integer   )value);
-      case BOOL    : return computeBoolSize    (number, (Boolean   )value);
-      case STRING  : return computeStringSize  (number, (String    )value);
-      case GROUP   : return computeGroupSize   (number, (Message   )value);
-      case MESSAGE : return computeMessageSize (number, (Message   )value);
-      case BYTES   : return computeBytesSize   (number, (ByteString)value);
-      case UINT32  : return computeUInt32Size  (number, (Integer   )value);
-      case SFIXED32: return computeSFixed32Size(number, (Integer   )value);
-      case SFIXED64: return computeSFixed64Size(number, (Long      )value);
-      case SINT32  : return computeSInt32Size  (number, (Integer   )value);
-      case SINT64  : return computeSInt64Size  (number, (Long      )value);
+      case DOUBLE  : return computeDoubleSizeNoTag  ((Double    )value);
+      case FLOAT   : return computeFloatSizeNoTag   ((Float     )value);
+      case INT64   : return computeInt64SizeNoTag   ((Long      )value);
+      case UINT64  : return computeUInt64SizeNoTag  ((Long      )value);
+      case INT32   : return computeInt32SizeNoTag   ((Integer   )value);
+      case FIXED64 : return computeFixed64SizeNoTag ((Long      )value);
+      case FIXED32 : return computeFixed32SizeNoTag ((Integer   )value);
+      case BOOL    : return computeBoolSizeNoTag    ((Boolean   )value);
+      case STRING  : return computeStringSizeNoTag  ((String    )value);
+      case GROUP   : return computeGroupSizeNoTag   ((Message   )value);
+      case MESSAGE : return computeMessageSizeNoTag ((Message   )value);
+      case BYTES   : return computeBytesSizeNoTag   ((ByteString)value);
+      case UINT32  : return computeUInt32SizeNoTag  ((Integer   )value);
+      case SFIXED32: return computeSFixed32SizeNoTag((Integer   )value);
+      case SFIXED64: return computeSFixed64SizeNoTag((Long      )value);
+      case SINT32  : return computeSInt32SizeNoTag  ((Integer   )value);
+      case SINT64  : return computeSInt64SizeNoTag  ((Long      )value);
 
       case ENUM:
-        return computeEnumSize(number,
-          ((Descriptors.EnumValueDescriptor)value).getNumber());
+        return computeEnumSizeNoTag(
+            ((Descriptors.EnumValueDescriptor)value).getNumber());
     }
 
     throw new RuntimeException(
diff --git a/java/src/main/java/com/google/protobuf/Descriptors.java b/java/src/main/java/com/google/protobuf/Descriptors.java
index ee4d4e3a..80266a59 100644
--- a/java/src/main/java/com/google/protobuf/Descriptors.java
+++ b/java/src/main/java/com/google/protobuf/Descriptors.java
@@ -857,6 +857,19 @@ public final class Descriptors {
           "Field numbers must be positive integers.");
       }
 
+      // Only repeated primitive fields may be packed.
+      if (proto.getOptions().getPacked()) {
+        if (proto.getLabel() != FieldDescriptorProto.Label.LABEL_REPEATED ||
+            proto.getType() == FieldDescriptorProto.Type.TYPE_STRING ||
+            proto.getType() == FieldDescriptorProto.Type.TYPE_GROUP ||
+            proto.getType() == FieldDescriptorProto.Type.TYPE_MESSAGE ||
+            proto.getType() == FieldDescriptorProto.Type.TYPE_BYTES) {
+          throw new DescriptorValidationException(this,
+            "[packed = true] can only be specified for repeated primitive " +
+            "fields.");
+        }
+      }
+
       if (isExtension) {
         if (!proto.hasExtendee()) {
           throw new DescriptorValidationException(this,
diff --git a/java/src/main/java/com/google/protobuf/DynamicMessage.java b/java/src/main/java/com/google/protobuf/DynamicMessage.java
index fefa23ec..99ae253c 100644
--- a/java/src/main/java/com/google/protobuf/DynamicMessage.java
+++ b/java/src/main/java/com/google/protobuf/DynamicMessage.java
@@ -211,6 +211,10 @@ public final class DynamicMessage extends AbstractMessage {
     return new Builder(type);
   }
 
+  public Builder toBuilder() {
+    return newBuilderForType().mergeFrom(this);
+  }
+
   /** Verifies that the field is a field of this message. */
   private void verifyContainingType(FieldDescriptor field) {
     if (field.getContainingType() != type) {
@@ -251,6 +255,7 @@ public final class DynamicMessage extends AbstractMessage {
       }
 
       fields.mergeFrom(other);
+      mergeUnknownFields(other.getUnknownFields());
       return this;
     }
 
diff --git a/java/src/main/java/com/google/protobuf/FieldSet.java b/java/src/main/java/com/google/protobuf/FieldSet.java
index 98a1c328..01da3faf 100644
--- a/java/src/main/java/com/google/protobuf/FieldSet.java
+++ b/java/src/main/java/com/google/protobuf/FieldSet.java
@@ -351,8 +351,7 @@ final class FieldSet {
           setField(field, entry.getValue());
         } else {
           setField(field,
-            existingValue.newBuilderForType()
-              .mergeFrom(existingValue)
+            existingValue.toBuilder()
               .mergeFrom((Message)entry.getValue())
               .build());
         }
@@ -384,8 +383,7 @@ final class FieldSet {
           setField(field, value);
         } else {
           setField(field,
-            existingValue.newBuilderForType()
-              .mergeFrom(existingValue)
+            existingValue.toBuilder()
               .mergeFrom((Message)value)
               .build());
         }
@@ -463,60 +461,83 @@ final class FieldSet {
     }
 
     if (field == null ||
-        wireType != WireFormat.getWireFormatForFieldType(field.getType())) {
+        wireType != WireFormat.getWireFormatForField(field)) {
       // Unknown field or wrong wire type.  Skip.
       return unknownFields.mergeFieldFrom(tag, input);
     } else {
-      Object value;
-      switch (field.getType()) {
-        case GROUP: {
-          Message.Builder subBuilder;
-          if (defaultInstance != null) {
-            subBuilder = defaultInstance.newBuilderForType();
-          } else {
-            subBuilder = builder.newBuilderForField(field);
+      if (field.getOptions().getPacked()) {
+        int length = input.readRawVarint32();
+        int limit = input.pushLimit(length);
+        if (field.getType() == FieldDescriptor.Type.ENUM) {
+          while (input.getBytesUntilLimit() > 0) {
+            int rawValue = input.readEnum();
+            Object value = field.getEnumType().findValueByNumber(rawValue);
+            if (value == null) {
+              // If the number isn't recognized as a valid value for this
+              // enum, drop it (don't even add it to unknownFields).
+              return true;
+            }
+            builder.addRepeatedField(field, value);
           }
-          if (!field.isRepeated()) {
-            subBuilder.mergeFrom((Message) builder.getField(field));
+        } else {
+          while (input.getBytesUntilLimit() > 0) {
+            Object value = input.readPrimitiveField(field.getType());
+            builder.addRepeatedField(field, value);
           }
-          input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
-          value = subBuilder.build();
-          break;
         }
-        case MESSAGE: {
-          Message.Builder subBuilder;
-          if (defaultInstance != null) {
-            subBuilder = defaultInstance.newBuilderForType();
-          } else {
-            subBuilder = builder.newBuilderForField(field);
+        input.popLimit(limit);
+      } else {
+        Object value;
+        switch (field.getType()) {
+          case GROUP: {
+            Message.Builder subBuilder;
+            if (defaultInstance != null) {
+              subBuilder = defaultInstance.newBuilderForType();
+            } else {
+              subBuilder = builder.newBuilderForField(field);
+            }
+            if (!field.isRepeated()) {
+              subBuilder.mergeFrom((Message) builder.getField(field));
+            }
+            input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
+            value = subBuilder.build();
+            break;
           }
-          if (!field.isRepeated()) {
-            subBuilder.mergeFrom((Message) builder.getField(field));
+          case MESSAGE: {
+            Message.Builder subBuilder;
+            if (defaultInstance != null) {
+              subBuilder = defaultInstance.newBuilderForType();
+            } else {
+              subBuilder = builder.newBuilderForField(field);
+            }
+            if (!field.isRepeated()) {
+              subBuilder.mergeFrom((Message) builder.getField(field));
+            }
+            input.readMessage(subBuilder, extensionRegistry);
+            value = subBuilder.build();
+            break;
           }
-          input.readMessage(subBuilder, extensionRegistry);
-          value = subBuilder.build();
-          break;
-        }
-        case ENUM: {
-          int rawValue = input.readEnum();
-          value = field.getEnumType().findValueByNumber(rawValue);
-          // If the number isn't recognized as a valid value for this enum,
-          // drop it.
-          if (value == null) {
-            unknownFields.mergeVarintField(fieldNumber, rawValue);
-            return true;
+          case ENUM: {
+            int rawValue = input.readEnum();
+            value = field.getEnumType().findValueByNumber(rawValue);
+            // If the number isn't recognized as a valid value for this enum,
+            // drop it.
+            if (value == null) {
+              unknownFields.mergeVarintField(fieldNumber, rawValue);
+              return true;
+            }
+            break;
           }
-          break;
+          default:
+            value = input.readPrimitiveField(field.getType());
+            break;
         }
-        default:
-          value = input.readPrimitiveField(field.getType());
-          break;
-      }
 
-      if (field.isRepeated()) {
-        builder.addRepeatedField(field, value);
-      } else {
-        builder.setField(field, value);
+        if (field.isRepeated()) {
+          builder.addRepeatedField(field, value);
+        } else {
+          builder.setField(field, value);
+        }
       }
     }
 
@@ -636,8 +657,24 @@ final class FieldSet {
       output.writeMessageSetExtension(field.getNumber(), (Message)value);
     } else {
       if (field.isRepeated()) {
-        for (Object element : (List)value) {
-          output.writeField(field.getType(), field.getNumber(), element);
+        List valueList = (List)value;
+        if (field.getOptions().getPacked()) {
+          output.writeTag(field.getNumber(),
+                          WireFormat.WIRETYPE_LENGTH_DELIMITED);
+          // Compute the total data size so the length can be written.
+          int dataSize = 0;
+          for (Object element : valueList) {
+            dataSize += output.computeFieldSizeNoTag(field.getType(), element);
+          }
+          output.writeRawVarint32(dataSize);
+          // Write the data itself, without any tags.
+          for (Object element : valueList) {
+            output.writeFieldNoTag(field.getType(), element);
+          }
+        } else {
+          for (Object element : valueList) {
+            output.writeField(field.getType(), field.getNumber(), element);
+          }
         }
       } else {
         output.writeField(field.getType(), field.getNumber(), value);
@@ -658,12 +695,23 @@ final class FieldSet {
       if (field.isExtension() &&
           field.getContainingType().getOptions().getMessageSetWireFormat()) {
         size += CodedOutputStream.computeMessageSetExtensionSize(
-          field.getNumber(), (Message)value);
+          field.getNumber(), (Message) value);
       } else {
         if (field.isRepeated()) {
-          for (Object element : (List)value) {
-            size += CodedOutputStream.computeFieldSize(
-              field.getType(), field.getNumber(), element);
+          if (field.getOptions().getPacked()) {
+            int dataSize = 0;
+            for (Object element : (List)value) {
+              dataSize += CodedOutputStream.computeFieldSizeNoTag(
+                  field.getType(), element);
+            }
+            size += dataSize +
+                CodedOutputStream.computeTagSize(field.getNumber()) +
+                CodedOutputStream.computeRawVarint32Size(dataSize);
+          } else {
+            for (Object element : (List)value) {
+              size += CodedOutputStream.computeFieldSize(
+                  field.getType(), field.getNumber(), element);
+            }
           }
         } else {
           size += CodedOutputStream.computeFieldSize(
diff --git a/java/src/main/java/com/google/protobuf/GeneratedMessage.java b/java/src/main/java/com/google/protobuf/GeneratedMessage.java
index b1be8b14..77c88c30 100644
--- a/java/src/main/java/com/google/protobuf/GeneratedMessage.java
+++ b/java/src/main/java/com/google/protobuf/GeneratedMessage.java
@@ -31,8 +31,8 @@
 package com.google.protobuf;
 
 import com.google.protobuf.Descriptors.Descriptor;
-import com.google.protobuf.Descriptors.FieldDescriptor;
 import com.google.protobuf.Descriptors.EnumValueDescriptor;
+import com.google.protobuf.Descriptors.FieldDescriptor;
 
 import java.io.IOException;
 import java.lang.reflect.Method;
@@ -75,7 +75,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
     Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
     for (FieldDescriptor field : descriptor.getFields()) {
       if (field.isRepeated()) {
-        List value = (List)getField(field);
+        List value = (List) getField(field);
         if (!value.isEmpty()) {
           result.put(field, value);
         }
@@ -87,7 +87,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
     }
     return result;
   }
-  
+
   public boolean isInitialized() {
     for (FieldDescriptor field : getDescriptorForType().getFields()) {
       // Check that all required fields are present.
@@ -99,7 +99,9 @@ public abstract class GeneratedMessage extends AbstractMessage {
       // Check that embedded messages are initialized.
       if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
         if (field.isRepeated()) {
-          for (Message element : (List<Message>) getField(field)) {
+          @SuppressWarnings("unchecked")
+          List<Message> messageList = (List<Message>) getField(field);
+          for (Message element : messageList) {
             if (!element.isInitialized()) {
               return false;
             }
@@ -189,7 +191,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
           setField(field, entry.getValue());
         }
       }
-      return (BuilderType)this;
+      return (BuilderType) this;
     }
 
     public Descriptor getDescriptorForType() {
@@ -214,7 +216,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
         // The underlying list object is still modifiable at this point.
         // Make sure not to expose the modifiable list to the caller.
         return Collections.unmodifiableList(
-          (List)internalGetResult().getField(field));
+          (List) internalGetResult().getField(field));
       } else {
         return internalGetResult().getField(field);
       }
@@ -223,12 +225,12 @@ public abstract class GeneratedMessage extends AbstractMessage {
     public BuilderType setField(Descriptors.FieldDescriptor field,
                                 Object value) {
       internalGetFieldAccessorTable().getField(field).set(this, value);
-      return (BuilderType)this;
+      return (BuilderType) this;
     }
 
     public BuilderType clearField(Descriptors.FieldDescriptor field) {
       internalGetFieldAccessorTable().getField(field).clear(this);
-      return (BuilderType)this;
+      return (BuilderType) this;
     }
 
     public int getRepeatedFieldCount(Descriptors.FieldDescriptor field) {
@@ -244,13 +246,13 @@ public abstract class GeneratedMessage extends AbstractMessage {
                                         int index, Object value) {
       internalGetFieldAccessorTable().getField(field)
         .setRepeated(this, index, value);
-      return (BuilderType)this;
+      return (BuilderType) this;
     }
 
     public BuilderType addRepeatedField(Descriptors.FieldDescriptor field,
                                         Object value) {
       internalGetFieldAccessorTable().getField(field).addRepeated(this, value);
-      return (BuilderType)this;
+      return (BuilderType) this;
     }
 
     public final UnknownFieldSet getUnknownFields() {
@@ -259,7 +261,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
 
     public final BuilderType setUnknownFields(UnknownFieldSet unknownFields) {
       internalGetResult().unknownFields = unknownFields;
-      return (BuilderType)this;
+      return (BuilderType) this;
     }
 
     public final BuilderType mergeUnknownFields(UnknownFieldSet unknownFields) {
@@ -268,7 +270,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
         UnknownFieldSet.newBuilder(result.unknownFields)
                        .mergeFrom(unknownFields)
                        .build();
-      return (BuilderType)this;
+      return (BuilderType) this;
     }
 
     public boolean isInitialized() {
@@ -287,7 +289,18 @@ public abstract class GeneratedMessage extends AbstractMessage {
       return unknownFields.mergeFieldFrom(tag, input);
     }
 
+    /**
+     * Adds the {@code values} to the {@code list}.
+     *
+     * @throws NullPointerException if any of the elements of {@code values} is
+     * null.
+     */
     protected <T> void addAll(Iterable<T> values, Collection<? super T> list) {
+      for (T value : values) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+      }
       if (values instanceof Collection) {
         @SuppressWarnings("unsafe")
         Collection<T> collection = (Collection<T>) values;
@@ -378,9 +391,9 @@ public abstract class GeneratedMessage extends AbstractMessage {
       verifyExtensionContainingType(extension);
       Object value = extensions.getField(extension.getDescriptor());
       if (value == null) {
-        return (Type)extension.getMessageDefaultInstance();
+        return (Type) extension.getMessageDefaultInstance();
       } else {
-        return (Type)extension.fromReflectionType(value);
+        return (Type) extension.fromReflectionType(value);
       }
     }
 
@@ -389,7 +402,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
     public final <Type> Type getExtension(
         GeneratedExtension<MessageType, List<Type>> extension, int index) {
       verifyExtensionContainingType(extension);
-      return (Type)extension.singularFromReflectionType(
+      return (Type) extension.singularFromReflectionType(
         extensions.getRepeatedField(extension.getDescriptor(), index));
     }
 
@@ -397,7 +410,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
     protected boolean extensionsAreInitialized() {
       return extensions.isInitialized();
     }
-    
+
     public boolean isInitialized() {
       return super.isInitialized() && extensionsAreInitialized();
     }
@@ -580,7 +593,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
       message.verifyExtensionContainingType(extension);
       message.extensions.setField(extension.getDescriptor(),
                                   extension.toReflectionType(value));
-      return (BuilderType)this;
+      return (BuilderType) this;
     }
 
     /** Set the value of one element of a repeated extension. */
@@ -592,7 +605,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
       message.extensions.setRepeatedField(
         extension.getDescriptor(), index,
         extension.singularToReflectionType(value));
-      return (BuilderType)this;
+      return (BuilderType) this;
     }
 
     /** Append a value to a repeated extension. */
@@ -602,7 +615,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
       message.verifyExtensionContainingType(extension);
       message.extensions.addRepeatedField(
         extension.getDescriptor(), extension.singularToReflectionType(value));
-      return (BuilderType)this;
+      return (BuilderType) this;
     }
 
     /** Clear an extension. */
@@ -611,7 +624,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
       ExtendableMessage<MessageType> message = internalGetResult();
       message.verifyExtensionContainingType(extension);
       message.extensions.clearField(extension.getDescriptor());
-      return (BuilderType)this;
+      return (BuilderType) this;
     }
 
     /**
@@ -639,7 +652,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
         ExtendableMessage<MessageType> message = internalGetResult();
         message.verifyContainingType(field);
         message.extensions.setField(field, value);
-        return (BuilderType)this;
+        return (BuilderType) this;
       } else {
         return super.setField(field, value);
       }
@@ -650,7 +663,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
         ExtendableMessage<MessageType> message = internalGetResult();
         message.verifyContainingType(field);
         message.extensions.clearField(field);
-        return (BuilderType)this;
+        return (BuilderType) this;
       } else {
         return super.clearField(field);
       }
@@ -662,7 +675,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
         ExtendableMessage<MessageType> message = internalGetResult();
         message.verifyContainingType(field);
         message.extensions.setRepeatedField(field, index, value);
-        return (BuilderType)this;
+        return (BuilderType) this;
       } else {
         return super.setRepeatedField(field, index, value);
       }
@@ -674,11 +687,15 @@ public abstract class GeneratedMessage extends AbstractMessage {
         ExtendableMessage<MessageType> message = internalGetResult();
         message.verifyContainingType(field);
         message.extensions.addRepeatedField(field, value);
-        return (BuilderType)this;
+        return (BuilderType) this;
       } else {
         return super.addRepeatedField(field, value);
       }
     }
+
+    protected final void mergeExtensionFields(ExtendableMessage other) {
+      internalGetResult().extensions.mergeFrom(other.extensions);
+    }
   }
 
   // -----------------------------------------------------------------
@@ -750,8 +767,8 @@ public abstract class GeneratedMessage extends AbstractMessage {
           enumValueOf = null;
           enumGetValueDescriptor = null;
           messageDefaultInstance =
-            (Message)invokeOrDie(getMethodOrDie(type, "getDefaultInstance"),
-                                 null);
+            (Message) invokeOrDie(getMethodOrDie(type, "getDefaultInstance"),
+                                  null);
           break;
         case ENUM:
           enumValueOf = getMethodOrDie(type, "valueOf",
@@ -797,7 +814,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
             descriptor.getJavaType() == FieldDescriptor.JavaType.ENUM) {
           // Must convert the whole list.
           List result = new ArrayList();
-          for (Object element : (List)value) {
+          for (Object element : (List) value) {
             result.add(singularFromReflectionType(element));
           }
           return result;
@@ -826,10 +843,10 @@ public abstract class GeneratedMessage extends AbstractMessage {
             // This should not happen in normal use.  But, to be nice, we'll
             // copy the message to whatever type the caller was expecting.
             return messageDefaultInstance.newBuilderForType()
-                           .mergeFrom((Message)value).build();
+                           .mergeFrom((Message) value).build();
           }
         case ENUM:
-          return invokeOrDie(enumValueOf, null, (EnumValueDescriptor)value);
+          return invokeOrDie(enumValueOf, null, (EnumValueDescriptor) value);
         default:
           return value;
       }
@@ -847,7 +864,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
         if (descriptor.getJavaType() == FieldDescriptor.JavaType.ENUM) {
           // Must convert the whole list.
           List result = new ArrayList();
-          for (Object element : (List)value) {
+          for (Object element : (List) value) {
             result.add(singularToReflectionType(element));
           }
           return result;
@@ -900,9 +917,9 @@ public abstract class GeneratedMessage extends AbstractMessage {
     } catch (java.lang.reflect.InvocationTargetException e) {
       Throwable cause = e.getCause();
       if (cause instanceof RuntimeException) {
-        throw (RuntimeException)cause;
+        throw (RuntimeException) cause;
       } else if (cause instanceof Error) {
-        throw (Error)cause;
+        throw (Error) cause;
       } else {
         throw new RuntimeException(
           "Unexpected exception thrown by generated accessor method.", cause);
@@ -915,6 +932,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
    * with access to the fields of a message object using Java reflection.
    */
   public static final class FieldAccessorTable {
+
     /**
      * Construct a FieldAccessorTable for a particular message class.  Only
      * one FieldAccessorTable should ever be constructed per class.
@@ -1039,7 +1057,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
           "addRepeatedField() called on a singular field.");
       }
       public boolean has(GeneratedMessage message) {
-        return (Boolean)invokeOrDie(hasMethod, message);
+        return (Boolean) invokeOrDie(hasMethod, message);
       }
       public int getRepeatedCount(GeneratedMessage message) {
         throw new UnsupportedOperationException(
@@ -1092,7 +1110,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
         // 2) Insures that the caller cannot modify the list later on and
         //    have the modifications be reflected in the message.
         clear(builder);
-        for (Object element : (List)value) {
+        for (Object element : (List) value) {
           addRepeated(builder, element);
         }
       }
@@ -1111,7 +1129,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
           "hasField() called on a singular field.");
       }
       public int getRepeatedCount(GeneratedMessage message) {
-        return (Integer)invokeOrDie(getCountMethod, message);
+        return (Integer) invokeOrDie(getCountMethod, message);
       }
       public void clear(GeneratedMessage.Builder builder) {
         invokeOrDie(clearMethod, builder);
@@ -1169,7 +1187,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
       @SuppressWarnings("unchecked")
       public Object get(GeneratedMessage message) {
         List newList = new ArrayList();
-        for (Object element : (List)super.get(message)) {
+        for (Object element : (List) super.get(message)) {
           newList.add(invokeOrDie(getValueDescriptorMethod, element));
         }
         return Collections.unmodifiableList(newList);
@@ -1210,8 +1228,8 @@ public abstract class GeneratedMessage extends AbstractMessage {
           // is an alternative implementation of the same type -- e.g. a
           // DynamicMessage -- we should accept it.  In this case we can make
           // a copy of the message.
-          return ((Message.Builder)invokeOrDie(newBuilderMethod, null))
-                  .mergeFrom((Message)value).build();
+          return ((Message.Builder) invokeOrDie(newBuilderMethod, null))
+                  .mergeFrom((Message) value).build();
         }
       }
 
@@ -1219,7 +1237,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
         super.set(builder, coerceType(value));
       }
       public Message.Builder newBuilder() {
-        return (Message.Builder)invokeOrDie(newBuilderMethod, null);
+        return (Message.Builder) invokeOrDie(newBuilderMethod, null);
       }
     }
 
@@ -1244,8 +1262,8 @@ public abstract class GeneratedMessage extends AbstractMessage {
           // is an alternative implementation of the same type -- e.g. a
           // DynamicMessage -- we should accept it.  In this case we can make
           // a copy of the message.
-          return ((Message.Builder)invokeOrDie(newBuilderMethod, null))
-                  .mergeFrom((Message)value).build();
+          return ((Message.Builder) invokeOrDie(newBuilderMethod, null))
+                  .mergeFrom((Message) value).build();
         }
       }
 
@@ -1257,7 +1275,7 @@ public abstract class GeneratedMessage extends AbstractMessage {
         super.addRepeated(builder, coerceType(value));
       }
       public Message.Builder newBuilder() {
-        return (Message.Builder)invokeOrDie(newBuilderMethod, null);
+        return (Message.Builder) invokeOrDie(newBuilderMethod, null);
       }
     }
   }
diff --git a/java/src/main/java/com/google/protobuf/Message.java b/java/src/main/java/com/google/protobuf/Message.java
index 9635387a..2f8700db 100644
--- a/java/src/main/java/com/google/protobuf/Message.java
+++ b/java/src/main/java/com/google/protobuf/Message.java
@@ -195,6 +195,12 @@ public interface Message {
   Builder newBuilderForType();
 
   /**
+   * Constructs a builder initialized with the current message.  Use this to
+   * derive a new message from the current one.
+   */
+  Builder toBuilder();
+
+  /**
    * Abstract interface implemented by Protocol Message builders.
    */
   public static interface Builder extends Cloneable {
diff --git a/java/src/main/java/com/google/protobuf/TextFormat.java b/java/src/main/java/com/google/protobuf/TextFormat.java
index 3a1b1d4e..3dcf68c8 100644
--- a/java/src/main/java/com/google/protobuf/TextFormat.java
+++ b/java/src/main/java/com/google/protobuf/TextFormat.java
@@ -397,13 +397,15 @@ public final class TextFormat {
     private int previousLine = 0;
     private int previousColumn = 0;
 
+    // We use possesive quantifiers (*+ and ++) because otherwise the Java
+    // regex matcher has stack overflows on large inputs.
     private static Pattern WHITESPACE =
-      Pattern.compile("(\\s|(#.*$))+", Pattern.MULTILINE);
+      Pattern.compile("(\\s|(#.*$))++", Pattern.MULTILINE);
     private static Pattern TOKEN = Pattern.compile(
-      "[a-zA-Z_][0-9a-zA-Z_+-]*|" +                 // an identifier
-      "[0-9+-][0-9a-zA-Z_.+-]*|" +                  // a number
-      "\"([^\"\n\\\\]|\\\\.)*(\"|\\\\?$)|" +        // a double-quoted string
-      "\'([^\"\n\\\\]|\\\\.)*(\'|\\\\?$)",          // a single-quoted string
+      "[a-zA-Z_][0-9a-zA-Z_+-]*+|" +                // an identifier
+      "[0-9+-][0-9a-zA-Z_.+-]*+|" +                 // a number
+      "\"([^\"\n\\\\]|\\\\.)*+(\"|\\\\?$)|" +       // a double-quoted string
+      "\'([^\"\n\\\\]|\\\\.)*+(\'|\\\\?$)",         // a single-quoted string
       Pattern.MULTILINE);
 
     private static Pattern DOUBLE_INFINITY = Pattern.compile(
diff --git a/java/src/main/java/com/google/protobuf/WireFormat.java b/java/src/main/java/com/google/protobuf/WireFormat.java
index ff042c05..2faf2448 100644
--- a/java/src/main/java/com/google/protobuf/WireFormat.java
+++ b/java/src/main/java/com/google/protobuf/WireFormat.java
@@ -96,6 +96,16 @@ public final class WireFormat {
       "There is no way to get here, but the compiler thinks otherwise.");
   }
 
+  /** Given a field descriptor, returns the wire type. This differs from
+   * getWireFormatForFieldType for packed repeated fields. */
+  static int getWireFormatForField(Descriptors.FieldDescriptor descriptor) {
+    if (descriptor.getOptions().getPacked()) {
+      return WIRETYPE_LENGTH_DELIMITED;
+    } else {
+      return getWireFormatForFieldType(descriptor.getType());
+    }
+  }
+
   // Field numbers for feilds in MessageSet wire format.
   static final int MESSAGE_SET_ITEM    = 1;
   static final int MESSAGE_SET_TYPE_ID = 2;
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());
   }
 }
-