Protocol Buffer runtime library and 'protoc' plugin

tests/lib/protobuf/protobuf_client_test.dart

+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#library("protobuftest");
+#import('../../../lib/protobuf/runtime/Protobuf_client.dart');
+#source('../../../lib/protobuf/plugin/protoc/descriptor.pb.dart');
+#source('test_util.dart');
+#source('unittest.pb.dart');
+#source('unittest_import.pb.dart');
+
+void main() {
+  // CodedBufferReader tests
+  testReadVarint();
+  testReadWholeMessage();
+  testSkipWholeMessage();
+  testReadHugeBlob();
+  testReadMaliciouslyLargeBlob();
+  testMaliciousRecursion();
+  testSizeLimit();
+  testReadInvalidUtf8();
+  testInvalidTag();
+
+  // CodedBufferWriter tests
+  testWriteWholeMessage();
+  testWriteWholePackedFieldsMessage();
+  testWriteMessageWithNegativeEnumValue();
+
+  // Wire protocol tests
+  testBuffer();
+  testSerialization();
+  testSerializationPacked();
+  testSerializeExtensions();
+  testSerializePackedExtensions();
+  testSerializationPackedWithoutGetSerializedSize();
+  testParseExtensions();
+  testParsePackedExtensions();
+  testExtensionsSerializedSize();
+
+  // GeneratedMessage tests
+  testMessageOrBuilder();
+  testUsingBuilderMultipleTimes();
+  testProtosShareRepeatedArraysIfDidntChange();
+  testRepeatedArraysAreImmutable();
+  testSettersRejectNull();
+  testRepeatedSetters();
+  testRepeatedSettersRejectNull();
+  testRepeatedAppend();
+  testRepeatedAppendRejectsNull();
+  testSettingForeignMessageUsingBuilder();
+  testSettingRepeatedForeignMessageUsingBuilder();
+  testDefaults();
+  testClear();
+  testEnumInterface();
+  testEnumMap();
+  testParsePackedToUnpacked();
+  testParseUnpackedToPacked();
+  testExtensionMessageOrBuilder();
+  testExtensionRepeatedSetters();
+  testExtensionDefaults();
+  testClearExtension();
+  testExtensionCopy();
+  testExtensionMergeFrom();
+  testToBuilder();
+  testRecursiveMessageDefaultInstance();
+  testSerialize();
+  testSerializePartial();
+  testEnumValues();
+  testBadExtension();
+
+  // JSON tests
+  testOutput();
+  testBase64Encode();
+  testBase64Decode();
+  testParse();
+  testExtensionsOutput();
+  testExtensionsParse();
+
+  // Message tests
+  setUpMessageTests();
+  testMergeFrom();
+  testRequired();
+  testRequiredForeign();
+  testRequiredExtension();
+  testUninitializedException();
+  testBuildPartial();
+  testNestedUninitializedException();
+  testBuildNestedPartial();
+  testParseUnititialized();
+  testParseNestedUnititialized();
+
+  // UnknownFieldSet tests
+  setUpUnknownFieldSetTests();
+  testVarint();
+  testFixed32();
+  testFixed64();
+  testLengthDelimited();
+  testGroup();
+  testSerialize2();
+  testCopyFrom();
+  testMergeFrom2();
+  testClear2();
+  testEmpty();
+  testClearMessage();
+  testParseKnownAndUnknown();
+  testWrongTypeTreatedAsUnknown();
+  testUnknownExtensions();
+  testWrongExtensionTypeTreatedAsUnknown();
+  testParseUnknownEnumValue();
+  testLargeVarint();
+  testEqualsAndHashCode();
+}
+
+void testReadVarint() {
+  _assertReadRawVarint([0x00], [0x00, 0x00, 0x00, 0x00]);
+  _assertReadRawVarint([0x01], [0x01, 0x00, 0x00, 0x00]);
+  _assertReadRawVarint([0x7f], [0x7f, 0x00, 0x00, 0x00]);
+  _assertReadRawVarint([0xa2, 0x74], [0xa2, 0x74, 0x00, 0x00]);
+  _assertReadRawVarint([0xbe, 0xf7, 0x92, 0x84, 0x0b], [0xbe, 0xf7, 0x92,
+      0x84, 0x0b, 0x00, 0x00, 0x00, 0x00]);
+  _assertReadRawVarint(
+    [0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01],
+    [0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01, 0x00]);
+  _assertReadVarintFailure(<int>[0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+      0x80, 0x80, 0x80, 0x00]);
+  _assertReadVarintFailure(<int>[0x80]);
+}
+
+void _assertReadRawVarint(List<int> expected, List<int> src) {
+  CodedBufferReader reader = new CodedBufferReader.fromBuffer(src);
+  Expect.listEquals(expected, reader.readRawVarint());
+}
+
+void _assertReadVarintFailure(List<int> src) {
+  try {
+    CodedBufferReader reader = new CodedBufferReader.fromBuffer(src);
+    reader.readRawVarint();
+    Expect.fail("Should throw exception");
+  } catch (InvalidProtocolBufferException e) {
+    // success
+  }
+}
+
+void testReadWholeMessage() {
+  Protobuf_Unittest_TestAllTypes message = getAllSet();
+  List<int> rawBytes = message.writeToBuffer();
+  Expect.equals(rawBytes.length, message.getSerializedSize());
+
+  Protobuf_Unittest_TestAllTypes message2 =
+      Protobuf_Unittest_TestAllTypes.parseFromBuffer(rawBytes);
+  assertAllFieldsSet(message2);
+}
+
+/** Tests skipField(). */
+void testSkipWholeMessage() {
+  Protobuf_Unittest_TestAllTypes message = getAllSet();
+  List<int> rawBytes = message.writeToBuffer();
+
+  // Create two parallel inputs.  Parse one as unknown fields while using
+  // skipField() to skip each field on the other.  Expect the same tags.
+  CodedBufferReader input1 = new CodedBufferReader.fromBuffer(rawBytes);
+  CodedBufferReader input2 = new CodedBufferReader.fromBuffer(rawBytes);
+  UnknownFieldSet_Builder unknownFields = new UnknownFieldSet_Builder();
+
+  while (true) {
+    int input1Tag = input1.readTag();
+    int input2Tag = input2.readTag();
+    Expect.equals(input1Tag, input2Tag);
+    if (input1Tag == 0) {
+      break;
+    }
+    unknownFields.mergeFieldFromBuffer(input1Tag, input1);
+    input2.skipField(input2Tag);
+  }
+}
+
+void testReadHugeBlob() {
+  // Allocate and initialize a 1MB blob.
+  List<int> blob = new List<int>(1 << 20);
+  for (int i = 0; i < blob.length; i++) {
+    blob[i] = i % 256;
+  }
+
+  // Make a message containing it.
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  setAllFields(builder);
+  builder.optionalBytes = blob;
+  Protobuf_Unittest_TestAllTypes message = builder.build();
+
+  Protobuf_Unittest_TestAllTypes message2 =
+    Protobuf_Unittest_TestAllTypes.parseFromBuffer(message.writeToBuffer());
+
+  Expect.listEquals(message.optionalBytes, message2.optionalBytes);
+}
+
+void testReadMaliciouslyLargeBlob() {
+  CodedBufferWriter output = new CodedBufferWriter(38);
+
+  int tag = WireFormat.makeTag(1, WireFormat.WIRETYPE_LENGTH_DELIMITED);
+  output.writeRawBytes(PbCodec.int32ToBytes(tag));
+  output.writeInt32NoTag(0x7FFFFFFF);
+  // Pad with a few random bytes.
+  List<int> randomBits = <int>[];
+  randomBits.insertRange(0, 32, 47);
+  output.writeRawBytes(randomBits);
+
+  CodedBufferReader input = new CodedBufferReader.fromBuffer(output.buffer);
+  Expect.equals(tag, input.readTag());
+
+  try {
+    input.readBytes();
+    Expect.fail("Should have thrown an exception!");
+  } catch (InvalidProtocolBufferException e) {
+    // success.
+  }
+}
+
+void testMaliciousRecursion() {
+  List<int> data64 = _makeRecursiveMessage(64).writeToBuffer();
+  List<int> data65 = _makeRecursiveMessage(65).writeToBuffer();
+
+  _assertMessageDepth(
+      Protobuf_Unittest_TestRecursiveMessage.parseFromBuffer(data64), 64);
+
+  try {
+    Protobuf_Unittest_TestRecursiveMessage.parseFromBuffer(data65);
+    Expect.fail("Should have thrown an exception!");
+  } catch (InvalidProtocolBufferException e) {
+    // success.
+  }
+
+  CodedBufferReader input = new CodedBufferReader.fromBuffer(data64, 8);
+  try {
+    // uncomfortable alternative to below...
+    new Protobuf_Unittest_TestRecursiveMessage_Builder()
+        .mergeFromCodedBufferReader(input);
+    Expect.fail("Should have thrown an exception!");
+  } catch (InvalidProtocolBufferException e) {
+    // success.
+  }
+}
+
+Protobuf_Unittest_TestRecursiveMessage _makeRecursiveMessage(int depth) {
+  if (depth == 0) {
+    Protobuf_Unittest_TestRecursiveMessage_Builder builder =
+        new Protobuf_Unittest_TestRecursiveMessage_Builder();
+    builder.i = 5;
+    return builder.build();
+  } else {
+    Protobuf_Unittest_TestRecursiveMessage_Builder builder =
+        new Protobuf_Unittest_TestRecursiveMessage_Builder();
+    builder.a = _makeRecursiveMessage(depth - 1);
+    return builder.build();
+  }
+}
+
+void _assertMessageDepth(Protobuf_Unittest_TestRecursiveMessage message,
+    int depth) {
+  if (depth == 0) {
+    Expect.isFalse(message.hasA());
+    Expect.equals(5, message.i);
+  } else {
+    Expect.isTrue(message.hasA());
+    _assertMessageDepth(message.a, depth - 1);
+  }
+}
+
+void testSizeLimit() {
+  CodedBufferReader input = new CodedBufferReader.fromBuffer(
+      getAllSet().writeToBuffer(), sizeLimit: 16);
+
+  try {
+    // uncomfortable alternative to below...
+    new Protobuf_Unittest_TestAllTypes_Builder()
+        .mergeFromCodedBufferReader(input);
+    Expect.fail("Size limit too small, should have thrown an exception!");
+  } catch (InvalidProtocolBufferException e) {
+    // success.
+  }
+}
+
+/**
+ * Tests that if we read an string that contains invalid UTF-8, no exception
+ * is thrown.  Instead, the invalid bytes are replaced with the Unicode
+ * "replacement character" U+FFFD.
+ */
+void testReadInvalidUtf8() {
+  CodedBufferWriter writer = new CodedBufferWriter(3);
+  writer.writeBytes(1, [0x80]);
+
+  CodedBufferReader input = new CodedBufferReader.fromBuffer(writer.buffer);
+  Expect.equals(
+      WireFormat.makeTag(1, WireFormat.WIRETYPE_LENGTH_DELIMITED),
+      input.readTag());
+  String text = input.readString();
+  Expect.equals(0xfffd, text.charCodeAt(0));
+}
+
+void testInvalidTag() {
+  // Any tag number which corresponds to field number zero is invalid and
+  // should throw InvalidProtocolBufferException.
+  for (int i = 0; i < 8; i++) {
+    try {
+      new CodedBufferReader.fromBuffer([i]).readTag();
+      Expect.fail("Should have thrown an exception.");
+    } catch (InvalidProtocolBufferException e) {
+      // success
+    }
+  }
+}
+
+void testWriteWholeMessage() {
+  Protobuf_Unittest_TestAllTypes message = getAllSet();
+
+  List<int> rawBytes = message.writeToBuffer();
+  Expect.listEquals(goldenMessage, rawBytes);
+}
+
+void testWriteWholePackedFieldsMessage() {
+  List<int> rawBytes = getPackedSet().writeToBuffer();
+  Expect.listEquals(goldenPackedMessage, rawBytes);
+}
+
+void testWriteMessageWithNegativeEnumValue() {
+  Protobuf_Unittest_SparseEnumMessage_Builder builder =
+      new Protobuf_Unittest_SparseEnumMessage_Builder();
+  builder.sparseEnum = Protobuf_Unittest_TestSparseEnum.SPARSE_E;
+  Protobuf_Unittest_SparseEnumMessage message = builder.build();
+  Expect.isTrue(message.sparseEnum.value < 0, "enum.value should be -53452");
+  List<int> buffer = message.writeToBuffer();
+  Protobuf_Unittest_SparseEnumMessage message2 =
+      Protobuf_Unittest_SparseEnumMessage.parseFromBuffer(buffer);
+  Expect.equals(Protobuf_Unittest_TestSparseEnum.SPARSE_E,
+      message2.sparseEnum, "should resolve back to SPARSE_E");
+
+}
+
+void testBuffer() {
+  GoogleProtobuf_DescriptorProto_ExtensionRange_Builder builder =
+      new GoogleProtobuf_DescriptorProto_ExtensionRange_Builder();
+  builder.start = 1;
+  builder.end = 10000;
+  GoogleProtobuf_DescriptorProto_ExtensionRange range = builder.build();
+  
+  List<int> wireFormat = range.writeToBuffer();
+  Expect.equals(8, wireFormat[0]);   // tag 1, type 0 (varint)
+  Expect.equals(1, wireFormat[1]);   // value 1
+  Expect.equals(16, wireFormat[2]);  // tag 2, type 0 (varint)
+  Expect.equals(144, wireFormat[3]); // value 10000 = (78 << 7) + (144 & 0x7f);
+  Expect.equals(78, wireFormat[4]);
+  
+  // Set values manually
+  wireFormat[1] = 120;
+  wireFormat[3] = 185;
+  wireFormat[4] = 96;
+  
+  GoogleProtobuf_DescriptorProto_ExtensionRange range2 =
+      GoogleProtobuf_DescriptorProto_ExtensionRange.parseFromBuffer(wireFormat);
+  Expect.equals(120, range2.start);
+  Expect.equals(12345, range2.end);
+}
+
+void testSerialization() {
+  Protobuf_Unittest_TestAllTypes message = getAllSet();
+
+  List<int> rawBytes = message.writeToBuffer();
+  Expect.equals(rawBytes.length, message.getSerializedSize());
+
+  Protobuf_Unittest_TestAllTypes message2 =
+      Protobuf_Unittest_TestAllTypes.parseFromBuffer(rawBytes);
+  assertAllFieldsSet(message2);
+}
+
+
+void testSerializationPacked() {
+  Protobuf_Unittest_TestPackedTypes message = getPackedSet();
+
+  List<int> rawBytes = message.writeToBuffer();
+  Expect.equals(rawBytes.length, message.getSerializedSize());
+
+  Protobuf_Unittest_TestPackedTypes message2 =
+      Protobuf_Unittest_TestPackedTypes.parseFromBuffer(rawBytes);
+  assertPackedFieldsSet(message2);
+}
+
+void testSerializeExtensions() {
+  Protobuf_Unittest_TestAllExtensions message = getAllExtensionsSet();
+  List<int> rawBytes = message.writeToBuffer();
+  Expect.equals(rawBytes.length, message.getSerializedSize());
+
+  Protobuf_Unittest_TestAllTypes message2 =
+    Protobuf_Unittest_TestAllTypes.parseFromBuffer(rawBytes);
+  assertAllFieldsSet(message2);
+}
+
+void testSerializePackedExtensions() {
+  Protobuf_Unittest_TestPackedExtensions message = getPackedExtensionsSet();
+  List<int> rawBytes = message.writeToBuffer();
+
+  Protobuf_Unittest_TestPackedTypes message2 = getPackedSet();
+  List<int> rawBytes2 = message2.writeToBuffer();
+
+  Expect.listEquals(rawBytes, rawBytes2);
+}
+
+void testSerializationPackedWithoutGetSerializedSize() {
+  // At one point, the Java impl. had a bug where size was not computed
+  // unless the getSerializedSize() was called on the message outside
+  // of the writing of the message.
+  Protobuf_Unittest_TestPackedTypes message = getPackedSet();
+
+  // Directly construct a CodedBufferWriter around a buffer, in case
+  // writeToBuffer() invokes getSerializedSize();
+  CodedBufferWriter writer = new CodedBufferWriter(10000);
+  message.writeToCodedBufferWriter(writer);
+
+  List<int> buffer = writer.buffer.getRange(0, writer.length);
+  Protobuf_Unittest_TestPackedTypes message2 =
+      Protobuf_Unittest_TestPackedTypes.parseFromBuffer(buffer);
+
+  assertPackedFieldsSet(message2);
+}
+
+void testParseExtensions() {
+  // TestAllTypes and TestAllExtensions should have compatible wire formats,
+  // so if we serialize a TestAllTypes then parse it as TestAllExtensions
+  // it should work.
+
+  Protobuf_Unittest_TestAllTypes message = getAllSet();
+  List<int> rawBytes = message.writeToBuffer();
+
+  ExtensionRegistry registry = getExtensionRegistry();
+
+  Protobuf_Unittest_TestAllExtensions message2 =
+      Protobuf_Unittest_TestAllExtensions.parseFromBuffer(rawBytes, registry);
+
+  assertAllExtensionsSet(message2);
+}
+
+void testParsePackedExtensions() {
+  // Ensure that packed extensions can be properly parsed.
+  Protobuf_Unittest_TestPackedExtensions message = getPackedExtensionsSet();
+  List<int> rawBytes = message.writeToBuffer();
+
+  ExtensionRegistry registry = getExtensionRegistry();
+
+  Protobuf_Unittest_TestPackedExtensions message2 =
+    Protobuf_Unittest_TestPackedExtensions.parseFromBuffer(rawBytes,
+    registry);
+
+  assertPackedExtensionsSet(message2);
+}
+
+void testExtensionsSerializedSize() {
+  Expect.equals(getAllSet().getSerializedSize(),
+    getAllExtensionsSet().getSerializedSize());
+}
+
+void testMessageOrBuilder() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  setAllFields(builder);
+  Protobuf_Unittest_TestAllTypes message = builder.build();
+  assertAllFieldsSet(message);
+}
+
+void testUsingBuilderMultipleTimes() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  // primitive field scalar and repeated
+  builder.optionalSfixed64 = 100;
+  builder.repeatedInt32.add(100);
+  // enum field scalar and repeated
+  builder.optionalImportEnum = Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR;
+  builder.repeatedImportEnum.add(
+      Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR);
+  // proto field scalar and repeated
+  Protobuf_Unittest_ForeignMessage_Builder optionalForeignMessageBuilder =
+      new Protobuf_Unittest_ForeignMessage_Builder();
+  optionalForeignMessageBuilder.c = 1;
+  builder.optionalForeignMessage = optionalForeignMessageBuilder.build();
+  builder.repeatedForeignMessage.add(optionalForeignMessageBuilder.build());
+
+  Protobuf_Unittest_TestAllTypes value1 = builder.build();
+
+  Expect.equals(100, value1.optionalSfixed64);
+  Expect.equals(100, value1.repeatedInt32[0]);
+  Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR,
+      value1.optionalImportEnum);
+  Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR,
+      value1.repeatedImportEnum[0]);
+  Expect.equals(1, value1.optionalForeignMessage.c);
+  Expect.equals(1, value1.repeatedForeignMessage[0].c);
+
+  // Make sure that builder didn't update previously created values
+  builder.optionalSfixed64 = 200;
+  builder.repeatedInt32[0] = 200;
+  builder.optionalImportEnum = Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO;
+  builder.repeatedImportEnum[0] =
+      Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO;
+  optionalForeignMessageBuilder.c = 2;
+  builder.optionalForeignMessage = optionalForeignMessageBuilder.build();
+  builder.repeatedForeignMessage[0] = optionalForeignMessageBuilder.build();
+
+  Protobuf_Unittest_TestAllTypes value2 = builder.build();
+
+  // Make sure value1 didn't change.
+  Expect.equals(100, value1.optionalSfixed64);
+  Expect.equals(100, value1.repeatedInt32[0]);
+  Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR,
+      value1.optionalImportEnum);
+  Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR,
+      value1.repeatedImportEnum[0]);
+  Expect.equals(1, value1.optionalForeignMessage.c);
+  Expect.equals(1, value1.repeatedForeignMessage[0].c);
+
+  // Make sure value2 is correct
+  Expect.equals(200, value2.optionalSfixed64);
+  Expect.equals(200, value2.repeatedInt32[0]);
+  Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO,
+      value2.optionalImportEnum);
+  Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO,
+      value2.repeatedImportEnum[0]);
+  Expect.equals(2, value2.optionalForeignMessage.c);
+  Expect.equals(2, value2.repeatedForeignMessage[0].c);
+}
+
+void testProtosShareRepeatedArraysIfDidntChange() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  builder.repeatedInt32.add(100);
+  builder.repeatedImportEnum
+      .add(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR);
+  builder.repeatedForeignMessage
+      .add(Protobuf_Unittest_ForeignMessage.defaultInstance);
+
+  Protobuf_Unittest_TestAllTypes value1 = builder.build();
+  Protobuf_Unittest_TestAllTypes value2 = value1.toBuilder().build();
+
+  Expect.listEquals(value1.repeatedInt32, value2.repeatedInt32);
+  Expect.listEquals(value1.repeatedImportEnum, value2.repeatedImportEnum);
+  Expect.listEquals(value1.repeatedForeignMessage,
+      value2.repeatedForeignMessage);
+}
+
+void testRepeatedArraysAreImmutable() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  builder.repeatedInt32.add(100);
+  builder.repeatedImportEnum.add(
+      Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR);
+  builder.repeatedForeignMessage.add(
+      Protobuf_Unittest_ForeignMessage.defaultInstance);
+
+  Protobuf_Unittest_TestAllTypes value = builder.build();
+  _assertIsUnmodifiable(value.repeatedInt32);
+  _assertIsUnmodifiable(value.repeatedImportEnum);
+  _assertIsUnmodifiable(value.repeatedForeignMessage);
+  // Following line fails. Default repeating values are not properly being
+  // converted into immutable lists (could be a generic empty list).
+  _assertIsUnmodifiable(value.repeatedFloat);
+}
+
+void _assertIsUnmodifiable(List list) {
+  try {
+    list.clear();
+    Expect.fail("List wasn't immutable");
+  } catch (UnsupportedOperationException e) {
+    // good
+  }
+}
+
+void testSettersRejectNull() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  try {
+    builder.optionalString = null;
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+  try {
+    builder.optionalBytes = null;
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+  try {
+    builder.optionalNestedMessage = null;
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+  try {
+    builder.optionalNestedMessage =null;
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+  try {
+    builder.optionalNestedEnum = null;
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+  try {
+    builder.repeatedString.add(null);
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+  try {
+    builder.repeatedBytes.add(null);
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+  try {
+    builder.repeatedNestedMessage.add(null);
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+  try {
+    builder.repeatedNestedMessage.add(null);
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+  try {
+    builder.repeatedNestedEnum.add(null);
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+}
+
+void testRepeatedSetters() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  setAllFields(builder);
+  modifyRepeatedFields(builder);
+  Protobuf_Unittest_TestAllTypes message = builder.build();
+  assertRepeatedFieldsModified(message);
+}
+
+void testRepeatedSettersRejectNull() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+
+  builder.repeatedString.add("one");
+  builder.repeatedString.add("two");
+  try {
+    builder.repeatedString[1] = null;
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+
+  builder.repeatedBytes.add("one".charCodes());
+  builder.repeatedBytes.add("two".charCodes());
+  try {
+    builder.repeatedBytes[1] = null;
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+
+  Protobuf_Unittest_TestAllTypes_NestedMessage_Builder repeatedNestedBuilder =
+      new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder();
+  repeatedNestedBuilder.bb = 318;
+  builder.repeatedNestedMessage.add(repeatedNestedBuilder.build());
+  repeatedNestedBuilder.bb = 456;
+  builder.repeatedNestedMessage.add(repeatedNestedBuilder.build());
+
+  try {
+    builder.repeatedNestedMessage[1] = null;
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+  try {
+    builder.repeatedNestedMessage[1] = null;
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+
+  builder.repeatedNestedEnum
+      .add(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO);
+  builder.repeatedNestedEnum
+      .add(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR);
+  try {
+    builder.repeatedNestedEnum[1] = null;
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+}
+
+void testRepeatedAppend() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+
+  builder.repeatedInt32.addAll([1, 2, 3, 4]);
+  builder.repeatedForeignEnum.addAll([
+      Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ]);
+
+  Protobuf_Unittest_ForeignMessage_Builder foreignMessageBuilder =
+      new Protobuf_Unittest_ForeignMessage_Builder();
+  foreignMessageBuilder.c = 12;
+  builder.repeatedForeignMessage.addAll([foreignMessageBuilder.build()]);
+
+  Protobuf_Unittest_TestAllTypes message = builder.build();
+  Expect.listEquals([1, 2, 3, 4], message.repeatedInt32, "s.b. [1,2,3,4]");
+  Expect.listEquals([Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ],
+      message.repeatedForeignEnum);
+  Expect.equals(1, message.repeatedForeignMessage.length);
+  Expect.equals(12, message.repeatedForeignMessage[0].c);
+}
+
+void testRepeatedAppendRejectsNull() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+
+  Protobuf_Unittest_ForeignMessage_Builder foreignMessageBuilder =
+      new Protobuf_Unittest_ForeignMessage_Builder();
+  foreignMessageBuilder.c = 12;
+
+  try {
+    builder.repeatedForeignMessage.addAll([foreignMessageBuilder.build(),
+        null]);
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+
+  try {
+    builder.repeatedForeignEnum.addAll([
+        Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ, null]);
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+
+  try {
+    builder.repeatedString.addAll(["one", null]);
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+
+  try {
+    builder.repeatedBytes.addAll(["one".charCodes(), null]);
+    Expect.fail("Exception was not thrown");
+  } catch (NullPointerException e) {
+    // We expect this exception.
+  }
+}
+
+void testSettingForeignMessageUsingBuilder() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  // Pass builder for foreign message instance.
+  Protobuf_Unittest_ForeignMessage_Builder foreignMessageBuilder =
+      new Protobuf_Unittest_ForeignMessage_Builder();
+  foreignMessageBuilder.c = 123;
+  builder.optionalForeignMessage = foreignMessageBuilder.build();
+  Protobuf_Unittest_TestAllTypes message = builder.build();
+
+  builder = new Protobuf_Unittest_TestAllTypes_Builder();
+  // Pass builder for foreign message instance.
+  foreignMessageBuilder = new Protobuf_Unittest_ForeignMessage_Builder();
+  foreignMessageBuilder.c = 123;
+  builder.optionalForeignMessage = foreignMessageBuilder.build();
+  Protobuf_Unittest_TestAllTypes expectedMessage = builder.build();
+
+  // TODO: In Java version, ngd says:
+  // Upgrade to using real #equals method once implemented
+  Expect.stringEquals(expectedMessage.toString(), message.toString());
+}
+
+void testSettingRepeatedForeignMessageUsingBuilder() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  // Pass builder for foreign message instance.
+  Protobuf_Unittest_ForeignMessage_Builder foreignMessageBuilder =
+      new Protobuf_Unittest_ForeignMessage_Builder();
+  foreignMessageBuilder.c = 456;
+  builder.repeatedForeignMessage.add(foreignMessageBuilder.build());
+  Protobuf_Unittest_TestAllTypes message = builder.build();
+
+  builder = new Protobuf_Unittest_TestAllTypes_Builder();
+  // Pass builder for foreign message instance.
+  foreignMessageBuilder = new Protobuf_Unittest_ForeignMessage_Builder();
+  foreignMessageBuilder.c = 456;
+  builder.repeatedForeignMessage.add(foreignMessageBuilder.build());
+  Protobuf_Unittest_TestAllTypes expectedMessage = builder.build();
+
+  // TODO(ngd): Upgrade to using real #equals method once implemented
+  Expect.stringEquals(expectedMessage.toString(), message.toString());
+}
+
+void testDefaults() {
+  assertClear(Protobuf_Unittest_TestAllTypes.defaultInstance);
+  assertClear((new Protobuf_Unittest_TestAllTypes_Builder()).build());
+
+  Protobuf_Unittest_TestExtremeDefaultValues message =
+      Protobuf_Unittest_TestExtremeDefaultValues.defaultInstance;
+
+  Expect.stringEquals("\u1234", message.utf8String);
+  Expect.identical(double.INFINITY, message.infDouble);
+  Expect.identical(double.NEGATIVE_INFINITY, message.negInfDouble);
+  Expect.isTrue(message.nanDouble.isNaN());
+  Expect.identical(double.INFINITY, message.infFloat);
+  Expect.identical(double.NEGATIVE_INFINITY, message.negInfFloat);
+  Expect.isTrue(message.nanFloat.isNaN());
+  Expect.stringEquals("? ? ?? ?? ??? ??/ ??-", message.cppTrigraph);
+}
+
+void testClear() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+
+  assertClear(builder.build());
+  setAllFields(builder);
+  builder.clear();
+  assertClear(builder.build());
+}
+
+void testEnumInterface() {
+  Expect.isTrue(
+      Protobuf_Unittest_TestAllTypes.defaultInstance.defaultNestedEnum
+      is ProtobufEnum);
+}
+
+void testEnumMap() {
+  for (Protobuf_Unittest_ForeignEnum value in
+      Protobuf_Unittest_ForeignEnum.values) {
+    Expect.equals(value, Protobuf_Unittest_ForeignEnum.valueOf(value.value));
+  }
+  Expect.isNull(Protobuf_Unittest_ForeignEnum.valueOf(12345));
+}
+
+void testParsePackedToUnpacked() {
+  Protobuf_Unittest_TestUnpackedTypes_Builder builder =
+      new Protobuf_Unittest_TestUnpackedTypes_Builder();
+  Protobuf_Unittest_TestUnpackedTypes message =
+      builder.mergeFromBuffer(getPackedSet().writeToBuffer()).build();
+  assertUnpackedFieldsSet(message);
+}
+
+void testParseUnpackedToPacked() {
+  Protobuf_Unittest_TestPackedTypes_Builder builder =
+      new Protobuf_Unittest_TestPackedTypes_Builder();
+  Protobuf_Unittest_TestPackedTypes message =
+      builder.mergeFromBuffer(getUnpackedSet().writeToBuffer()).build();
+  assertPackedFieldsSet(message);
+}
+
+// =================================================================
+// Extensions.
+void testExtensionMessageOrBuilder() {
+  Protobuf_Unittest_TestAllExtensions_Builder builder =
+      new Protobuf_Unittest_TestAllExtensions_Builder();
+  setAllExtensions(builder);
+  Protobuf_Unittest_TestAllExtensions message = builder.build();
+  assertAllExtensionsSet(message);
+}
+
+void testExtensionRepeatedSetters() {
+  Protobuf_Unittest_TestAllExtensions_Builder builder =
+    new Protobuf_Unittest_TestAllExtensions_Builder();
+  setAllExtensions(builder);
+  modifyRepeatedExtensions(builder);
+  Protobuf_Unittest_TestAllExtensions message = builder.build();
+  assertRepeatedExtensionsModified(message);
+}
+
+void testExtensionDefaults() {
+  assertExtensionsClear(Protobuf_Unittest_TestAllExtensions
+      .defaultInstance);
+  assertExtensionsClear(new Protobuf_Unittest_TestAllExtensions_Builder()
+      .build());
+}
+
+void testClearExtension() {
+  // clearExtension() is not actually used in TestUtil, so try it manually.
+  var builder = new Protobuf_Unittest_TestAllExtensions_Builder();
+  builder.setExtension(Unittest.optionalInt32Extension, 1);
+  builder.clearExtension(Unittest.optionalInt32Extension);
+  Expect.isFalse(builder.hasExtension(
+      Unittest.optionalInt32Extension));
+
+  builder = new Protobuf_Unittest_TestAllExtensions_Builder();
+  builder.addExtension(Unittest.repeatedInt32Extension, 1);
+  builder.clearExtension(Unittest.repeatedInt32Extension);
+  Expect.equals(0, builder.getExtensionCount(
+      Unittest.repeatedInt32Extension));
+}
+
+void testExtensionCopy() {
+  Protobuf_Unittest_TestAllExtensions original = getAllExtensionsSet();
+
+  Protobuf_Unittest_TestAllExtensions_Builder builder =
+    new Protobuf_Unittest_TestAllExtensions_Builder();
+  builder.mergeFromMessage(original);
+  Protobuf_Unittest_TestAllExtensions copy = builder.build();
+  assertAllExtensionsSet(copy);
+}
+
+void testExtensionMergeFrom() {
+  Protobuf_Unittest_TestAllExtensions_Builder builder =
+      new Protobuf_Unittest_TestAllExtensions_Builder();
+  builder.setExtension(Unittest.optionalInt32Extension, 1);
+  Protobuf_Unittest_TestAllExtensions original = builder.build();
+  Protobuf_Unittest_TestAllExtensions merged =
+      new Protobuf_Unittest_TestAllExtensions_Builder().
+          mergeFromMessage(original).build();
+  Expect.isTrue(merged.hasExtension(
+      Unittest.optionalInt32Extension));
+  Expect.equals(
+      1, merged.getExtension(
+          Unittest.optionalInt32Extension));
+}
+
+void testToBuilder() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  setAllFields(builder);
+  Protobuf_Unittest_TestAllTypes message = builder.build();
+  assertAllFieldsSet(message);
+  assertAllFieldsSet(message.toBuilder().build());
+}
+
+void testRecursiveMessageDefaultInstance() {
+  Protobuf_Unittest_TestRecursiveMessage message =
+      Protobuf_Unittest_TestRecursiveMessage.defaultInstance;
+  Expect.isNotNull(message);
+  Expect.isNotNull(message.a);
+  Expect.equals(message.a, message);
+}
+
+void testSerialize() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  setAllFields(builder);
+  Protobuf_Unittest_TestAllTypes expected = builder.build();
+  List<int> out = expected.writeToBuffer();
+  Protobuf_Unittest_TestAllTypes actual =
+      Protobuf_Unittest_TestAllTypes.parseFromBuffer(out);
+  Expect.equals(expected, actual);
+}
+
+void testSerializePartial() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  Protobuf_Unittest_TestAllTypes expected = builder.buildPartial();
+  List<int> out = expected.writeToBuffer();
+  Protobuf_Unittest_TestAllTypes actual =
+      Protobuf_Unittest_TestAllTypes.parseFromBuffer(out);
+  Expect.equals(expected, actual);
+}
+
+void testEnumValues() {
+  Expect.setEquals([
+      Protobuf_Unittest_TestAllTypes_NestedEnum.FOO,
+      Protobuf_Unittest_TestAllTypes_NestedEnum.BAR,
+      Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ],
+      Protobuf_Unittest_TestAllTypes_NestedEnum.values);
+  Expect.equals(1, Protobuf_Unittest_TestAllTypes_NestedEnum.FOO.value);
+  Expect.equals(2, Protobuf_Unittest_TestAllTypes_NestedEnum.BAR.value);
+  Expect.equals(3, Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ.value);
+}
+
+void testBadExtension() {
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  try {
+    builder.setExtension(Unittest.optionalInt32Extension,
+        101);
+    Expect.fail("Extension range not set. Should throw exception");
+  } catch (IllegalArgumentException e) {
+  }
+
+  try {
+    builder.getExtension(Unittest.optionalInt32Extension);
+    Expect.fail("Extension range not set. Should throw exception");
+  } catch (IllegalArgumentException e) {
+  }
+}
+
+final String TEST_ALL_TYPES_JSON = '{"1":101,"2":"102","3":103,"4":"104",'
+    '"5":105,"6":"106","7":107,"8":"108","9":109,"10":"110","11":111.0,'
+    '"12":112.0,"13":true,"14":"115","15":"MTE2","16":{"17":117},'
+    '"18":{"1":118},"19":{"1":119},"20":{"1":120},"21":3,"22":6,"23":9,'
+    '"24":"124","25":"125","31":[201,301],"32":["202","302"],'
+    '"33":[203,303],"34":["204","304"],"35":[205,305],"36":["206","306"],'
+    '"37":[207,307],"38":["208","308"],"39":[209,309],"40":["210","310"],'
+    '"41":[211.0,311.0],"42":[212.0,312.0],"43":[true,false],'
+    '"44":["215","315"],"45":["MjE2","MzE2"],"46":[{"47":217},{"47":317}],'
+    '"48":[{"1":218},{"1":318}],"49":[{"1":219},{"1":319}],'
+    '"50":[{"1":220},{"1":320}],"51":[2,3],"52":[5,6],"53":[8,9],'
+    '"54":["224","324"],"55":["225","325"],"61":401,"62":"402","63":403,'
+    '"64":"404","65":405,"66":"406","67":407,"68":"408","69":409,'
+    '"70":"410","71":411.0,"72":412.0,"73":false,"74":"415","75":"NDE2",'
+    '"81":1,"82":4,"83":7,"84":"424","85":"425"}';
+
+void testOutput() {
+  Protobuf_Unittest_TestAllTypes message = getAllSet();
+  String json = message.writeToJson();
+  Expect.stringEquals(TEST_ALL_TYPES_JSON, json);
+
+  // Test empty list
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      Protobuf_Unittest_TestAllTypes.newBuilder().mergeFromMessage(message);
+  builder.repeatedBool.clear();
+  json = builder.build().writeToJson();
+  Expect.stringEquals(TEST_ALL_TYPES_JSON.replaceAll('[true,false]', '[]'),
+      json);
+
+  // test negative number
+  builder =
+    Protobuf_Unittest_TestAllTypes.newBuilder().mergeFromMessage(message);
+  builder.optionalInt32 = -1234567;
+  json = builder.build().writeToJson();
+  Expect.stringEquals(TEST_ALL_TYPES_JSON.replaceAll(':101,', ':-1234567,'),
+      json);
+
+  // 64-bit numbers are quoted
+  builder =
+    Protobuf_Unittest_TestAllTypes.newBuilder().mergeFromMessage(message);
+  builder.optionalInt64 = 9007199254740992;
+  json = builder.build().writeToJson();
+  Expect.stringEquals(TEST_ALL_TYPES_JSON.replaceAll(':"102",',
+      ':"9007199254740992",'), json);
+
+  // Quotes, backslashes, and control characters in strings are quoted
+  builder =
+    Protobuf_Unittest_TestAllTypes.newBuilder().mergeFromMessage(message);
+  builder.optionalString = "a\u0000b\u0001cd\\e\"fg";
+  json = builder.build().writeToJson();
+  Expect.stringEquals(TEST_ALL_TYPES_JSON.replaceAll(':"115",',
+      ':"a\\u0000b\\u0001cd\\\\e\\"fg",'), json);
+}
+
+void testBase64Encode() {
+  Protobuf_Unittest_TestAllTypes message = getAllSet();
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+    Protobuf_Unittest_TestAllTypes.newBuilder().mergeFromMessage(message);
+  builder.optionalBytes = "Hello, world".charCodes();
+  String json = builder.build().writeToJson();
+  Expect.stringEquals(TEST_ALL_TYPES_JSON.replaceAll(':"MTE2",',
+      ':"SGVsbG8sIHdvcmxk",'), json);
+  
+  builder =
+    Protobuf_Unittest_TestAllTypes.newBuilder().mergeFromMessage(message);
+  builder.optionalBytes = "Hello, world!".charCodes();
+  json = builder.build().writeToJson();
+  Expect.stringEquals(TEST_ALL_TYPES_JSON.replaceAll(':"MTE2",',
+      ':"SGVsbG8sIHdvcmxkIQ==",'), json);
+  
+  builder =
+    Protobuf_Unittest_TestAllTypes.newBuilder().mergeFromMessage(message);
+  builder.optionalBytes = "Hello, world!!".charCodes();
+  json = builder.build().writeToJson();
+  Expect.stringEquals(TEST_ALL_TYPES_JSON.replaceAll(':"MTE2",',
+      ':"SGVsbG8sIHdvcmxkISE=",'), json);
+
+  // An empty list should not appear in the output
+  builder =
+    Protobuf_Unittest_TestAllTypes.newBuilder().mergeFromMessage(message);
+  builder.optionalBytes = [];
+  json = builder.build().writeToJson();
+  Expect.stringEquals(TEST_ALL_TYPES_JSON.replaceAll('"15":"MTE2",',
+      ''), json);
+
+  builder =
+    Protobuf_Unittest_TestAllTypes.newBuilder().mergeFromMessage(message);
+  builder.optionalBytes = "a".charCodes();
+  json = builder.build().writeToJson();
+  Expect.stringEquals(TEST_ALL_TYPES_JSON.replaceAll(':"MTE2",',
+      ':"YQ==",'), json);
+}
+
+void testBase64Decode() {
+  String json = TEST_ALL_TYPES_JSON.replaceAll(':"MTE2",',
+    ':"SGVsbG8sIHdvcmxk",');
+  Protobuf_Unittest_TestAllTypes message =
+    Protobuf_Unittest_TestAllTypes.parseFromJson(json);
+  Expect.stringEquals("Hello, world", new String.fromCharCodes(message.optionalBytes));
+
+  json = TEST_ALL_TYPES_JSON.replaceAll(':"MTE2",',
+      ':"SGVsbG8sIHdvcmxkIQ==",');
+  message =
+      Protobuf_Unittest_TestAllTypes.parseFromJson(json);
+  Expect.stringEquals("Hello, world!", new String.fromCharCodes(message.optionalBytes));
+
+  json = TEST_ALL_TYPES_JSON.replaceAll(':"MTE2",',
+      ':"SGVsbG8sIHdvcmxkISE=",');
+  message =
+      Protobuf_Unittest_TestAllTypes.parseFromJson(json);
+  Expect.stringEquals("Hello, world!!", new String.fromCharCodes(message.optionalBytes));
+
+  // Remove optionalBytes tag, reads back as empty list
+  json = TEST_ALL_TYPES_JSON.replaceAll('"15":"MTE2",',
+      '');
+  message =
+      Protobuf_Unittest_TestAllTypes.parseFromJson(json);
+  Expect.listEquals([], message.optionalBytes);
+
+  // Keep optionalBytes tag, set data to empty string, get back empty list
+  json = TEST_ALL_TYPES_JSON.replaceAll(':"MTE2",',
+      ':"",');
+  message =
+      Protobuf_Unittest_TestAllTypes.parseFromJson(json);
+  Expect.listEquals([], message.optionalBytes);
+
+  json = TEST_ALL_TYPES_JSON.replaceAll(':"MTE2",',
+      ':"YQ==",');
+  message =
+      Protobuf_Unittest_TestAllTypes.parseFromJson(json);
+  Expect.stringEquals("a", new String.fromCharCodes(message.optionalBytes));
+}
+
+void testParse() {
+  Protobuf_Unittest_TestAllTypes message =
+      Protobuf_Unittest_TestAllTypes.parseFromJson(TEST_ALL_TYPES_JSON);
+  Protobuf_Unittest_TestAllTypes expected = getAllSet();
+  Expect.equals(expected, message);
+}
+
+void testExtensionsOutput() {
+  Protobuf_Unittest_TestAllExtensions message = getAllExtensionsSet();
+  String json = message.writeToJson();
+  Expect.equals(TEST_ALL_TYPES_JSON, json);
+}
+
+void testExtensionsParse() {
+  ExtensionRegistry registry = getExtensionRegistry();
+  Protobuf_Unittest_TestAllExtensions message =
+      Protobuf_Unittest_TestAllExtensions.parseFromJson(TEST_ALL_TYPES_JSON,
+          registry);
+  Protobuf_Unittest_TestAllExtensions expected = getAllExtensionsSet();
+  Expect.equals(expected, message);
+}
+
+  Protobuf_Unittest_TestAllTypes MERGE_SOURCE;
+  Protobuf_Unittest_TestAllTypes MERGE_DEST;
+  String MERGE_RESULT_TEXT = """
+optionalInt32: 1
+optionalInt64: 2
+optionalString: baz
+optionalForeignMessage: {
+  c: 3
+}
+repeatedString: bar
+repeatedString: qux
+""";
+
+void setUpMessageTests() {
+  Protobuf_Unittest_TestAllTypes_Builder mergeSourceBuilder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  mergeSourceBuilder.optionalInt32 = 1;
+  mergeSourceBuilder.optionalString = "foo";
+  mergeSourceBuilder.optionalForeignMessage =
+      Protobuf_Unittest_ForeignMessage.defaultInstance;
+  mergeSourceBuilder.repeatedString.add("bar");
+  MERGE_SOURCE = mergeSourceBuilder.build();
+
+  Protobuf_Unittest_TestAllTypes_Builder mergeDestBuilder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+  mergeDestBuilder.optionalInt64 = 2;
+  mergeDestBuilder.optionalString = "baz";
+  mergeDestBuilder.optionalForeignMessage =
+      Protobuf_Unittest_ForeignMessage.defaultInstance;
+  Protobuf_Unittest_ForeignMessage_Builder foreignMessageBuilder =
+      new Protobuf_Unittest_ForeignMessage_Builder();
+  foreignMessageBuilder.c = 3;
+  mergeDestBuilder.optionalForeignMessage = foreignMessageBuilder.build();
+  mergeDestBuilder.repeatedString.add("qux");
+  MERGE_DEST = mergeDestBuilder.build();
+
+  TEST_REQUIRED_UNINITIALIZED =
+      Protobuf_Unittest_TestRequired.defaultInstance;
+
+  Protobuf_Unittest_TestRequired_Builder testRequiredBuilder =
+      new Protobuf_Unittest_TestRequired_Builder();
+  testRequiredBuilder.a = 1;
+  testRequiredBuilder.b = 2;
+  testRequiredBuilder.c = 3;
+  TEST_REQUIRED_INITIALIZED = testRequiredBuilder.build();
+}
+
+void testMergeFrom() {
+  // was:
+  //Protobuf_Unittest_TestAllTypes result =
+  //    TestAllTypes.newBuilder(MERGE_DEST)
+  //        .mergeFrom(MERGE_SOURCE).build();
+  // less succinct now...
+  Protobuf_Unittest_TestAllTypes_Builder builder =
+      new Protobuf_Unittest_TestAllTypes_Builder();
+      // TODO add (builder construction) to the message class?
+  Protobuf_Unittest_TestAllTypes result =
+       builder.mergeFromMessage(MERGE_SOURCE)
+       // TODO can we create a builder from a message instance?
+          .mergeFromMessage(MERGE_DEST).build();
+
+  Expect.equals(MERGE_RESULT_TEXT, result.toString());
+}
+
+// void testMergeFromDynamic() {} // UNSUPPORTED no Dynamic implementation
+// void testDynamicMergeFrom() {} // UNSUPPORTED no Dynamic implementation
+
+Protobuf_Unittest_TestRequired TEST_REQUIRED_UNINITIALIZED;
+Protobuf_Unittest_TestRequired TEST_REQUIRED_INITIALIZED;
+
+void testRequired() {
+  Protobuf_Unittest_TestRequired_Builder builder =
+      new Protobuf_Unittest_TestRequired_Builder();
+
+  Expect.isFalse(builder.isInitialized(), "no required fields set");
+  builder.a = 1;
+  Expect.isFalse(builder.isInitialized(), "single required field set");
+  builder.b = 1;
+  Expect.isFalse(builder.isInitialized(), "all but one required field set");
+  builder.c = 1;
+  Expect.isTrue(builder.isInitialized(), "required fields set");
+}
+
+void testRequiredForeign() {
+  Protobuf_Unittest_TestRequiredForeign_Builder builder =
+      new Protobuf_Unittest_TestRequiredForeign_Builder();
+  Expect.isTrue(builder.isInitialized(),
+      "TestRequiredForeign without children should be initialized");
+
+  builder.optionalMessage = TEST_REQUIRED_UNINITIALIZED;
+  Expect.isFalse(builder.isInitialized(),
+      "TestRequiredForeign with optional TEST_REQUIRED_UNINITIALIZED "
+      "should not be initialized");
+
+  builder.optionalMessage = TEST_REQUIRED_INITIALIZED;
+  Expect.isTrue(builder.isInitialized(),
+    "TestRequiredForeign with optional TEST_REQUIRED_INITIALIZED "
+    "should be initialized");
+
+  builder.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED);
+  Expect.isFalse(builder.isInitialized(),
+      "TestRequiredForeign with repeating TEST_REQUIRED_UNINITIALIZED "
+      "should not be initialized");
+
+  builder.repeatedMessage[0] = TEST_REQUIRED_INITIALIZED;
+  Expect.isTrue(builder.isInitialized(),
+      "TestRequiredForeign with repeating TEST_REQUIRED_INITIALIZED "
+      "should be initialized");
+}
+
+void testRequiredExtension() {
+  Protobuf_Unittest_TestAllExtensions_Builder builder =
+      new Protobuf_Unittest_TestAllExtensions_Builder();
+  Expect.isTrue(builder.isInitialized());
+
+  builder.setExtension(Protobuf_Unittest_TestRequired.single,
+      TEST_REQUIRED_UNINITIALIZED);
+  Expect.isFalse(builder.isInitialized());
+
+  builder.setExtension(Protobuf_Unittest_TestRequired.single,
+      TEST_REQUIRED_INITIALIZED);
+  Expect.isTrue(builder.isInitialized());
+
+  builder.addExtension(Protobuf_Unittest_TestRequired.multi,
+      TEST_REQUIRED_UNINITIALIZED);
+  Expect.isFalse(builder.isInitialized());
+
+  builder.getExtension(Protobuf_Unittest_TestRequired.multi)[0] =
+      TEST_REQUIRED_INITIALIZED;
+  Expect.isTrue(builder.isInitialized());
+}
+
+// void testRequiredDynamic() {} // UNSUPPORTED no Dynamic implementation
+// void testRequiredDynamicForeign() {} // UNSUPPORTED no Dynamic impl
+
+void testUninitializedException() {
+  try {
+    new Protobuf_Unittest_TestRequired_Builder().build();
+    Expect.fail("Should have thrown an exception.");
+  } catch (UninitializedMessageException e) {
+    Expect.equals("Message missing required fields: a, b, c", e.message);
+  }
+}
+
+void testBuildPartial() {
+  // We're mostly testing that no exception is thrown.
+  Protobuf_Unittest_TestRequired message =
+      new Protobuf_Unittest_TestRequired_Builder().buildPartial();
+  Expect.isFalse(message.isInitialized());
+}
+
+void testNestedUninitializedException() {
+  try {
+    Protobuf_Unittest_TestRequiredForeign_Builder builder =
+        new Protobuf_Unittest_TestRequiredForeign_Builder();
+    builder.optionalMessage = TEST_REQUIRED_UNINITIALIZED;
+    builder.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED);
+    builder.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED);
+    builder.build();
+    Expect.fail("Should have thrown an exception.");
+  } catch (UninitializedMessageException e) {
+    // NOTE: error message differs from Java in that
+    // fields are referenced using Dart fieldnames r.t.
+    // proto field names.
+    Expect.equals(
+      "Message missing required fields: "
+      "optionalMessage.a, "
+      "optionalMessage.b, "
+      "optionalMessage.c, "
+      "repeatedMessage[0].a, "
+      "repeatedMessage[0].b, "
+      "repeatedMessage[0].c, "
+      "repeatedMessage[1].a, "
+      "repeatedMessage[1].b, "
+      "repeatedMessage[1].c",
+      e.message);
+  }
+}
+
+void testBuildNestedPartial() {
+  // We're mostly testing that no exception is thrown.
+  Protobuf_Unittest_TestRequiredForeign_Builder builder =
+      new Protobuf_Unittest_TestRequiredForeign_Builder();
+  builder.optionalMessage = TEST_REQUIRED_UNINITIALIZED;
+  builder.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED);
+  builder.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED);
+  Protobuf_Unittest_TestRequiredForeign message = builder.buildPartial();
+  Expect.isFalse(message.isInitialized());
+}
+
+void testParseUnititialized() {
+  try {
+    Protobuf_Unittest_TestRequired.parseFromBuffer([]);
+    Expect.fail("Should have thrown an exception.");
+  } catch (UninitializedMessageException e) {
+    Expect.equals("Message missing required fields: a, b, c", e.message);
+  }
+}
+
+void testParseNestedUnititialized() {
+  Protobuf_Unittest_TestRequiredForeign_Builder builder =
+      new Protobuf_Unittest_TestRequiredForeign_Builder();
+  builder.optionalMessage = TEST_REQUIRED_UNINITIALIZED;
+  builder.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED);
+  builder.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED);
+  List<int> buffer = builder.buildPartial().writeToBuffer();
+
+  try {
+    Protobuf_Unittest_TestRequiredForeign.parseFromBuffer(buffer);
+    Expect.fail("Should have thrown an exception.");
+  } catch (UninitializedMessageException e) {
+    // NOTE: error message differs from Java in that
+    // fields are referenced using Dart fieldnames r.t.
+    // proto field names.
+    Expect.equals(
+        "Message missing required fields: "
+        "optionalMessage.a, "
+        "optionalMessage.b, "
+        "optionalMessage.c, "
+        "repeatedMessage[0].a, "
+        "repeatedMessage[0].b, "
+        "repeatedMessage[0].c, "
+        "repeatedMessage[1].a, "
+        "repeatedMessage[1].b, "
+        "repeatedMessage[1].c",
+        e.message);
+  }
+}
+
+Protobuf_Unittest_TestEmptyMessage emptyMessage;
+Protobuf_Unittest_TestAllTypes testAllTypes;
+UnknownFieldSet unknownFields;
+List<int> allFieldsData;
+
+void setUpUnknownFieldSetTests() {
+  testAllTypes = getAllSet();
+  allFieldsData = testAllTypes.writeToBuffer();
+  emptyMessage =
+      Protobuf_Unittest_TestEmptyMessage.parseFromBuffer(allFieldsData);
+  unknownFields = emptyMessage.unknownFields;
+}
+
+UnknownFieldSet_Field getField(String name) {
+  int tagNumber = testAllTypes.getTagNumber(name);
+  assert(unknownFields.hasField(tagNumber));
+  return unknownFields.getField(tagNumber);
+}
+
+void testVarint() {
+  UnknownFieldSet_Field optionalInt32 = getField("optionalInt32");
+  Expect.equals(testAllTypes.optionalInt32,
+      optionalInt32.varintList[0].toInt());
+}
+
+void testFixed32() {
+  UnknownFieldSet_Field optionalFixed32 = getField("optionalFixed32");
+  Expect.equals(testAllTypes.optionalFixed32, optionalFixed32.fixed32List[0]);
+}
+
+void testFixed64() {
+  UnknownFieldSet_Field optionalFixed64 = getField("optionalFixed64");
+  Expect.equals(testAllTypes.optionalFixed64,
+      optionalFixed64.fixed64List[0].toInt());
+}
+
+void testLengthDelimited() {
+  UnknownFieldSet_Field optionalBytes = getField("optionalBytes");
+  Expect.listEquals(testAllTypes.optionalBytes,
+      optionalBytes.lengthDelimitedList[0]);
+}
+
+void testGroup() {
+  int tagNumberA = Protobuf_Unittest_TestAllTypes_OptionalGroup
+      .defaultInstance.getTagNumber("a");
+  Expect.isTrue(tagNumberA != null);
+
+  UnknownFieldSet_Field optionalGroupField = getField("optionalGroup");
+  Expect.equals(1, optionalGroupField.groupList.length);
+  UnknownFieldSet group = optionalGroupField.groupList[0];
+  Expect.isTrue(group.hasField(tagNumberA));
+  Expect.equals(testAllTypes.optionalGroup.a, group.getField(tagNumberA)
+      .varintList[0].toInt());
+}
+
+void testSerialize2() {
+  List<int> data = emptyMessage.writeToBuffer();
+  Expect.listEquals(allFieldsData, data);
+}
+
+void testCopyFrom() {
+  Protobuf_Unittest_TestEmptyMessage message =
+    Protobuf_Unittest_TestEmptyMessage.newBuilder()
+    .mergeFromMessage(emptyMessage).build();
+  Expect.stringEquals(emptyMessage.toString(), message.toString());
+  Expect.isFalse(emptyMessage.toString().isEmpty());
+}
+
+void testMergeFrom2() {
+  // source
+  UnknownFieldSet sourceFieldSet = new UnknownFieldSet_Builder()
+      .addField(2, new UnknownFieldSet_Field_Builder().addVarint(2).build())
+      .addField(3, new UnknownFieldSet_Field_Builder().addVarint(3).build())
+      .build();
+
+  Protobuf_Unittest_TestEmptyMessage_Builder sourceBuilder =
+      Protobuf_Unittest_TestEmptyMessage.newBuilder();
+  sourceBuilder.unknownFields = sourceFieldSet;
+  Protobuf_Unittest_TestEmptyMessage source = sourceBuilder.build();
+
+  // destination
+  UnknownFieldSet destinationFieldSet = new UnknownFieldSet_Builder()
+      .addField(1, new UnknownFieldSet_Field_Builder().addVarint(1).build())
+      .addField(3, new UnknownFieldSet_Field_Builder().addVarint(4).build())
+      .build();
+
+  Protobuf_Unittest_TestEmptyMessage_Builder destinationBuilder =
+      Protobuf_Unittest_TestEmptyMessage.newBuilder();
+  destinationBuilder.unknownFields = destinationFieldSet;
+  destinationBuilder.mergeFromMessage(source);
+  Protobuf_Unittest_TestEmptyMessage destination = destinationBuilder.build();
+
+  Expect.stringEquals(
+    "1: 1\n"
+    "2: 2\n"
+    "3: 4\n"
+    "3: 3\n",
+    destination.toString());
+}
+
+void testClear2() {
+  UnknownFieldSet_Builder fsb = new UnknownFieldSet_Builder(unknownFields);
+  fsb.clear();
+  UnknownFieldSet fields = fsb.build();
+  Expect.isTrue(fields.asMap().isEmpty());
+}
+
+void testEmpty() {
+  UnknownFieldSet fields = (new UnknownFieldSet_Builder()).build();
+  Expect.isTrue(fields.asMap().isEmpty());
+}
+
+void testClearMessage() {
+  Protobuf_Unittest_TestEmptyMessage_Builder messageBuilder =
+      Protobuf_Unittest_TestEmptyMessage.newBuilder();
+  messageBuilder.mergeFromMessage(emptyMessage);
+  messageBuilder.clear();
+  Protobuf_Unittest_TestEmptyMessage message = messageBuilder.build();
+  Expect.equals(0, message.getSerializedSize());
+}
+
+void testParseKnownAndUnknown() {
+  // Test mixing known and unknown fields when parsing.
+  UnknownFieldSet fields = (new UnknownFieldSet_Builder(unknownFields))
+      .addField(123456,
+          (new UnknownFieldSet_Field_Builder()).addVarint(654321).build())
+      .build();
+
+  CodedBufferWriter writer =
+      new CodedBufferWriter(fields.getSerializedSize());
+  fields.writeToCodedBufferWriter(writer);
+
+  Protobuf_Unittest_TestAllTypes destination =
+      Protobuf_Unittest_TestAllTypes.parseFromBuffer(writer.buffer);
+
+  assertAllFieldsSet(destination);
+  Expect.equals(1, destination.unknownFields.asMap().length);
+
+  UnknownFieldSet_Field field =
+    destination.unknownFields.getField(123456);
+  Expect.equals(1, field.varintList.length);
+  Expect.equals(654321, field.varintList[0].toInt());
+}
+
+// Constructs a protocol buffer which contains fields with all the same
+// numbers as allFieldsData except that each field is some other wire
+// type.
+List<int> getBizarroData() {
+  UnknownFieldSet_Builder bizarroFieldsBuilder =
+      new UnknownFieldSet_Builder();
+
+  UnknownFieldSet_Field_Builder varintField =
+      (new UnknownFieldSet_Field_Builder()).addVarint(1);
+
+  UnknownFieldSet_Field_Builder fixed32Field =
+      (new UnknownFieldSet_Field_Builder()).addFixed32(1);
+
+  unknownFields.asMap().forEach(void _(int tag, UnknownFieldSet_Field value) {
+    if (value.varintList.isEmpty()) {
+      // Original field is not a varint, so use a varint.
+      bizarroFieldsBuilder.addField(tag, varintField.build());
+    } else {
+      // Original field *is* a varint, so use something else.
+      bizarroFieldsBuilder.addField(tag, fixed32Field.build());
+    }
+  });
+  UnknownFieldSet bizarroFields = bizarroFieldsBuilder.build();
+  CodedBufferWriter writer =
+      new CodedBufferWriter(bizarroFields.getSerializedSize());
+  bizarroFields.writeToCodedBufferWriter(writer);
+  return writer.buffer;
+}
+
+void testWrongTypeTreatedAsUnknown() {
+  // Test that fields of the wrong wire type are treated like unknown fields
+  // when parsing.
+  List<int> bizarroData = getBizarroData();
+  Protobuf_Unittest_TestAllTypes allTypesMessage =
+      Protobuf_Unittest_TestAllTypes.parseFromBuffer(bizarroData);
+  Protobuf_Unittest_TestEmptyMessage emptyMessage_ =
+      Protobuf_Unittest_TestEmptyMessage.parseFromBuffer(bizarroData);
+  // All fields should have been interpreted as unknown, so the debug strings
+  // should be the same.
+  Expect.stringEquals(emptyMessage_.toString(), allTypesMessage.toString());
+}
+
+void testUnknownExtensions() {
+  // Make sure fields are properly parsed to the UnknownFieldSet even when
+  // they are declared as extension numbers.
+  Protobuf_Unittest_TestEmptyMessageWithExtensions message =
+      Protobuf_Unittest_TestEmptyMessageWithExtensions
+          .parseFromBuffer(allFieldsData);
+
+  Expect.equals(unknownFields.asMap().length,
+               message.unknownFields.asMap().length);
+  Expect.listEquals(allFieldsData, message.writeToBuffer());
+}
+
+void testWrongExtensionTypeTreatedAsUnknown() {
+  // Test that fields of the wrong wire type are treated like unknown fields
+  // when parsing extensions.
+
+  List<int> bizarroData = getBizarroData();
+  Protobuf_Unittest_TestAllExtensions allExtensionsMessage =
+    Protobuf_Unittest_TestAllExtensions.parseFromBuffer(bizarroData);
+  Protobuf_Unittest_TestEmptyMessage emptyMessage_ =
+      Protobuf_Unittest_TestEmptyMessage.parseFromBuffer(bizarroData);
+
+  // All fields should have been interpreted as unknown, so the debug strings
+  // should be the same.
+  Expect.stringEquals(emptyMessage_.toString(),
+      allExtensionsMessage.toString());
+}
+
+void testParseUnknownEnumValue() {
+  int singularFieldNum = testAllTypes.getTagNumber("optionalNestedEnum");
+  int repeatedFieldNum = testAllTypes.getTagNumber("repeatedNestedEnum");
+  Expect.isNotNull(singularFieldNum);
+  Expect.isNotNull(repeatedFieldNum);
+
+  UnknownFieldSet fieldSet = (new UnknownFieldSet_Builder())
+      .addField(singularFieldNum, (new UnknownFieldSet_Field_Builder())
+          .addVarint(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR.value)
+          .addVarint(5).build())
+      .addField(repeatedFieldNum, (new UnknownFieldSet_Field_Builder())
+          .addVarint(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO.value)
+          .addVarint(4)
+          .addVarint(Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ.value)
+          .addVarint(6).build())
+      .build();
+
+  CodedBufferWriter writer =
+      new CodedBufferWriter(fieldSet.getSerializedSize());
+  fieldSet.writeToCodedBufferWriter(writer);
+  {
+    Protobuf_Unittest_TestAllTypes message =
+        Protobuf_Unittest_TestAllTypes.parseFromBuffer(writer.buffer);
+    Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR,
+        message.optionalNestedEnum);
+    Expect.listEquals([Protobuf_Unittest_TestAllTypes_NestedEnum.FOO,
+        Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ],
+        message.repeatedNestedEnum);
+    Expect.equals(1, 
+        message.unknownFields.getField(singularFieldNum).varintList.length);
+    Expect.equals(5,
+        message.unknownFields.getField(singularFieldNum).varintList[0].toInt());
+    Expect.equals(2,
+        message.unknownFields.getField(repeatedFieldNum).varintList.length);
+    Expect.equals(4,
+        message.unknownFields.getField(repeatedFieldNum).varintList[0].toInt());
+    Expect.equals(6,
+        message.unknownFields.getField(repeatedFieldNum).varintList[1].toInt());
+  }
+  {
+    Protobuf_Unittest_TestAllExtensions message =
+        Protobuf_Unittest_TestAllExtensions.parseFromBuffer(writer.buffer,
+        getExtensionRegistry());
+    Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR,
+        message.getExtension(
+        Unittest.optionalNestedEnumExtension));
+
+    Expect.listEquals([Protobuf_Unittest_TestAllTypes_NestedEnum.FOO,
+        Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ],
+        message.getExtension(
+        Unittest.repeatedNestedEnumExtension));
+    Expect.equals(1, 
+        message.unknownFields.getField(singularFieldNum).varintList.length);
+    Expect.equals(5,
+        message.unknownFields.getField(singularFieldNum).varintList[0].toInt());
+    Expect.equals(2,
+        message.unknownFields.getField(repeatedFieldNum).varintList.length);
+    Expect.equals(4,
+        message.unknownFields.getField(repeatedFieldNum).varintList[0].toInt());
+    Expect.equals(6,
+        message.unknownFields.getField(repeatedFieldNum).varintList[1].toInt());
+  }
+}
+
+void testLargeVarint() {
+  Packed64 maxint = new Packed64(0x7FFFFFFF, 0xFFFFFFFF);
+  UnknownFieldSet unknownFieldSet = (new UnknownFieldSet_Builder())
+      .addField(1, (new UnknownFieldSet_Field_Builder())
+          .addVarint(maxint).build())
+      .build();
+  CodedBufferWriter writer =
+      new CodedBufferWriter(unknownFieldSet.getSerializedSize());
+  unknownFieldSet.writeToCodedBufferWriter(writer);
+
+  var parsed = new UnknownFieldSet_Builder();
+  parsed.mergeFromCodedBufferReader(
+      new CodedBufferReader.fromBuffer(writer.buffer));
+  var field = parsed.build().getField(1);
+  Expect.equals(1, field.varintList.length);
+  Expect.equals(new Packed64(0x7FFFFFFF, 0xFFFFFFFF).toString(),
+      field.varintList[0].toString());
+}
+
+void testEqualsAndHashCode() {
+  UnknownFieldSet a = (new UnknownFieldSet_Builder())
+      .addField(1, (new UnknownFieldSet_Field_Builder())
+      .addFixed32(1).build()).build();
+
+  UnknownFieldSet b = (new UnknownFieldSet_Builder())
+      .addField(1, (new UnknownFieldSet_Field_Builder())
+          .addFixed64(new Packed64.fromInt(1)).build()).build();
+
+  UnknownFieldSet c = (new UnknownFieldSet_Builder())
+      .addField(1, (new UnknownFieldSet_Field_Builder()).addVarint(1).build())
+      .build();
+
+  UnknownFieldSet d = (new UnknownFieldSet_Builder())
+      .addField(1, (new UnknownFieldSet_Field_Builder())
+      .addLengthDelimited([]).build()).build();
+
+  UnknownFieldSet e = (new UnknownFieldSet_Builder())
+      .addField(1, (new UnknownFieldSet_Field_Builder())
+      .addGroup(unknownFields).build()).build();
+
+  _checkEqualsIsConsistent(a);
+  _checkEqualsIsConsistent(b);
+  _checkEqualsIsConsistent(c);
+  _checkEqualsIsConsistent(d);
+  _checkEqualsIsConsistent(e);
+
+  _checkNotEqual(a, b);
+  _checkNotEqual(a, c);
+  _checkNotEqual(a, d);
+  _checkNotEqual(a, e);
+  _checkNotEqual(b, c);
+  _checkNotEqual(b, d);
+  _checkNotEqual(b, e);
+  _checkNotEqual(c, d);
+  _checkNotEqual(c, e);
+  _checkNotEqual(d, e);
+
+  UnknownFieldSet f1 = (new UnknownFieldSet_Builder())
+      .addField(1,
+          (new UnknownFieldSet_Field_Builder()).addLengthDelimited([1, 2])
+          .build()).build();
+  UnknownFieldSet f2 = (new UnknownFieldSet_Builder())
+      .addField(1,
+          (new UnknownFieldSet_Field_Builder()).addLengthDelimited([2, 1])
+          .build()).build();
+
+  _checkEqualsIsConsistent(f1);
+  _checkEqualsIsConsistent(f2);
+
+  _checkNotEqual(f1, f2);
+}
+
+/**
+ * Asserts that the given field sets are not equal and have different
+ * hash codes.
+ *
+ * N.B.: It is valid for non-equal objects to have the same hash code, so
+ * this test is more strict than necessary. However, in the test cases
+ * identifies, the hash codes should differ, and as a matter of principle 
+ * hash collisions should be relatively rare.
+ */
+void _checkNotEqual(UnknownFieldSet s1, UnknownFieldSet s2) {
+  String equalsError =
+      "${s1.toString()} should not be equal to ${s2.toString}";
+  Expect.isFalse(s1 == s2, equalsError);
+  Expect.isFalse(s2 == s1, equalsError);
+
+  Expect.isFalse(
+      s1.hashCode() == s2.hashCode(),
+      "${s1.toString()} should have a different hash code "
+      "from ${s2.toString()}");
+}
+
+/**
+ * Asserts that the given field sets are equal and have identical hash codes.
+ */
+void _checkEqualsIsConsistent(UnknownFieldSet set) {
+  // Object should be equal to itself.
+  Expect.equals(set, set);
+
+  // Object should be equal to a copy of itself.
+  UnknownFieldSet copy = (new UnknownFieldSet_Builder(set)).build();
+  Expect.equals(set, copy);
+  Expect.equals(copy, set);
+  Expect.equals(set.hashCode(), copy.hashCode());
+}
+
+