third_party/protobuf/java/src/test/java/com/google/protobuf/TestUtil.java - Issue 21208003: Update protobuf to r428, part 1.

Unified Diff: third_party/protobuf/java/src/test/java/com/google/protobuf/TestUtil.java

Issue 21208003: Update protobuf to r428, part 1. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/

Patch Set: Created 7 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

« no previous file with comments | « third_party/protobuf/java/src/test/java/com/google/protobuf/TestBadIdentifiers.java ('k') | third_party/protobuf/java/src/test/java/com/google/protobuf/TextFormatTest.java » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: third_party/protobuf/java/src/test/java/com/google/protobuf/TestUtil.java

===================================================================

--- third_party/protobuf/java/src/test/java/com/google/protobuf/TestUtil.java (revision 216642)

+++ third_party/protobuf/java/src/test/java/com/google/protobuf/TestUtil.java (working copy)

@@ -72,14 +72,16 @@

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.optionalCordExtension;

+import static protobuf_unittest.UnittestProto.optionalForeignEnumExtension;

import static protobuf_unittest.UnittestProto.optionalForeignMessageExtension;

+import static protobuf_unittest.UnittestProto.optionalImportEnumExtension;

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.optionalNestedMessageExtension;

+import static protobuf_unittest.UnittestProto.optionalPublicImportMessageExtension;

+import static protobuf_unittest.UnittestProto.optionalLazyMessageExtension;

import static protobuf_unittest.UnittestProto.optionalStringPieceExtension;

-import static protobuf_unittest.UnittestProto.optionalCordExtension;

import static protobuf_unittest.UnittestProto.repeatedInt32Extension;

import static protobuf_unittest.UnittestProto.repeatedInt64Extension;

@@ -100,6 +102,7 @@

import static protobuf_unittest.UnittestProto.repeatedNestedMessageExtension;

import static protobuf_unittest.UnittestProto.repeatedForeignMessageExtension;

import static protobuf_unittest.UnittestProto.repeatedImportMessageExtension;

+import static protobuf_unittest.UnittestProto.repeatedLazyMessageExtension;

import static protobuf_unittest.UnittestProto.repeatedNestedEnumExtension;

import static protobuf_unittest.UnittestProto.repeatedForeignEnumExtension;

import static protobuf_unittest.UnittestProto.repeatedImportEnumExtension;

@@ -162,11 +165,13 @@

import static com.google.protobuf.UnittestLite.optionalBytesExtensionLite;

import static com.google.protobuf.UnittestLite.optionalGroupExtensionLite;

import static com.google.protobuf.UnittestLite.optionalNestedMessageExtensionLite;

+import static com.google.protobuf.UnittestLite.optionalForeignEnumExtensionLite;

import static com.google.protobuf.UnittestLite.optionalForeignMessageExtensionLite;

+import static com.google.protobuf.UnittestLite.optionalImportEnumExtensionLite;

import static com.google.protobuf.UnittestLite.optionalImportMessageExtensionLite;

import static com.google.protobuf.UnittestLite.optionalNestedEnumExtensionLite;

-import static com.google.protobuf.UnittestLite.optionalForeignEnumExtensionLite;

-import static com.google.protobuf.UnittestLite.optionalImportEnumExtensionLite;

+import static com.google.protobuf.UnittestLite.optionalPublicImportMessageExtensionLite;

+import static com.google.protobuf.UnittestLite.optionalLazyMessageExtensionLite;

import static com.google.protobuf.UnittestLite.optionalStringPieceExtensionLite;

import static com.google.protobuf.UnittestLite.optionalCordExtensionLite;

@@ -189,6 +194,7 @@

import static com.google.protobuf.UnittestLite.repeatedNestedMessageExtensionLite;

import static com.google.protobuf.UnittestLite.repeatedForeignMessageExtensionLite;

import static com.google.protobuf.UnittestLite.repeatedImportMessageExtensionLite;

+import static com.google.protobuf.UnittestLite.repeatedLazyMessageExtensionLite;

import static com.google.protobuf.UnittestLite.repeatedNestedEnumExtensionLite;

import static com.google.protobuf.UnittestLite.repeatedForeignEnumExtensionLite;

import static com.google.protobuf.UnittestLite.repeatedImportEnumExtensionLite;

@@ -222,8 +228,9 @@

import protobuf_unittest.UnittestProto.TestUnpackedTypes;

import protobuf_unittest.UnittestProto.ForeignMessage;

import protobuf_unittest.UnittestProto.ForeignEnum;

+import com.google.protobuf.test.UnittestImport.ImportEnum;

import com.google.protobuf.test.UnittestImport.ImportMessage;

-import com.google.protobuf.test.UnittestImport.ImportEnum;

+import com.google.protobuf.test.UnittestImportPublic.PublicImportMessage;

import com.google.protobuf.UnittestLite.TestAllTypesLite;

import com.google.protobuf.UnittestLite.TestAllExtensionsLite;

@@ -231,8 +238,9 @@

import com.google.protobuf.UnittestLite.TestPackedExtensionsLite;

import com.google.protobuf.UnittestLite.ForeignMessageLite;

import com.google.protobuf.UnittestLite.ForeignEnumLite;

+import com.google.protobuf.UnittestImportLite.ImportEnumLite;

import com.google.protobuf.UnittestImportLite.ImportMessageLite;

-import com.google.protobuf.UnittestImportLite.ImportEnumLite;

+import com.google.protobuf.UnittestImportPublicLite.PublicImportMessageLite;

import junit.framework.Assert;

@@ -242,7 +250,7 @@

/**

* Contains methods for setting all fields of {@code TestAllTypes} to

- * some vaules as well as checking that all the fields are set to those values.

+ * some values as well as checking that all the fields are set to those values.

* These are useful for testing various protocol message features, e.g.

* set all fields of a message, serialize it, parse it, and check that all

* fields are set.

@@ -275,6 +283,16 @@

}

/**

+ * Get a {@code TestAllTypes.Builder} with all fields set as they would be by

+ * {@link #setAllFields(TestAllTypes.Builder)}.

+ */

+ public static TestAllTypes.Builder getAllSetBuilder() {

+ TestAllTypes.Builder builder = TestAllTypes.newBuilder();

+ setAllFields(builder);

+ return builder;

+ }

+ /**

* Get a {@code TestAllExtensions} with all fields set as they would be by

* {@link #setAllExtensions(TestAllExtensions.Builder)}.

@@ -344,6 +362,10 @@

ForeignMessage.newBuilder().setC(119).build());

message.setOptionalImportMessage(

ImportMessage.newBuilder().setD(120).build());

+ message.setOptionalPublicImportMessage(

+ PublicImportMessage.newBuilder().setE(126).build());

+ message.setOptionalLazyMessage(

+ TestAllTypes.NestedMessage.newBuilder().setBb(127).build());

message.setOptionalNestedEnum (TestAllTypes.NestedEnum.BAZ);

message.setOptionalForeignEnum(ForeignEnum.FOREIGN_BAZ);

@@ -378,6 +400,8 @@

ForeignMessage.newBuilder().setC(219).build());

message.addRepeatedImportMessage(

ImportMessage.newBuilder().setD(220).build());

+ message.addRepeatedLazyMessage(

+ TestAllTypes.NestedMessage.newBuilder().setBb(227).build());

message.addRepeatedNestedEnum (TestAllTypes.NestedEnum.BAR);

message.addRepeatedForeignEnum(ForeignEnum.FOREIGN_BAR);

@@ -411,6 +435,8 @@

ForeignMessage.newBuilder().setC(319).build());

message.addRepeatedImportMessage(

ImportMessage.newBuilder().setD(320).build());

+ message.addRepeatedLazyMessage(

+ TestAllTypes.NestedMessage.newBuilder().setBb(327).build());

message.addRepeatedNestedEnum (TestAllTypes.NestedEnum.BAZ);

message.addRepeatedForeignEnum(ForeignEnum.FOREIGN_BAZ);

@@ -476,6 +502,8 @@

ForeignMessage.newBuilder().setC(519).build());

message.setRepeatedImportMessage(1,

ImportMessage.newBuilder().setD(520).build());

+ message.setRepeatedLazyMessage(1,

+ TestAllTypes.NestedMessage.newBuilder().setBb(527).build());

message.setRepeatedNestedEnum (1, TestAllTypes.NestedEnum.FOO);

message.setRepeatedForeignEnum(1, ForeignEnum.FOREIGN_FOO);

@@ -541,10 +569,12 @@

Assert.assertEquals("115", message.getOptionalString ());

Assert.assertEquals(toBytes("116"), message.getOptionalBytes());

- Assert.assertEquals(117, message.getOptionalGroup ().getA());

- Assert.assertEquals(118, message.getOptionalNestedMessage ().getBb());

- Assert.assertEquals(119, message.getOptionalForeignMessage().getC());

- Assert.assertEquals(120, message.getOptionalImportMessage ().getD());

+ Assert.assertEquals(117, message.getOptionalGroup ().getA());

+ Assert.assertEquals(118, message.getOptionalNestedMessage ().getBb());

+ Assert.assertEquals(119, message.getOptionalForeignMessage ().getC());

+ Assert.assertEquals(120, message.getOptionalImportMessage ().getD());

+ Assert.assertEquals(126, message.getOptionalPublicImportMessage().getE());

+ Assert.assertEquals(127, message.getOptionalLazyMessage ().getBb());

Assert.assertEquals(TestAllTypes.NestedEnum.BAZ, message.getOptionalNestedEnum());

Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getOptionalForeignEnum());

@@ -575,6 +605,7 @@

Assert.assertEquals(2, message.getRepeatedNestedMessageCount ());

Assert.assertEquals(2, message.getRepeatedForeignMessageCount());

Assert.assertEquals(2, message.getRepeatedImportMessageCount ());

+ Assert.assertEquals(2, message.getRepeatedLazyMessageCount ());

Assert.assertEquals(2, message.getRepeatedNestedEnumCount ());

Assert.assertEquals(2, message.getRepeatedForeignEnumCount ());

Assert.assertEquals(2, message.getRepeatedImportEnumCount ());

@@ -602,6 +633,7 @@

Assert.assertEquals(218, message.getRepeatedNestedMessage (0).getBb());

Assert.assertEquals(219, message.getRepeatedForeignMessage(0).getC());

Assert.assertEquals(220, message.getRepeatedImportMessage (0).getD());

+ Assert.assertEquals(227, message.getRepeatedLazyMessage (0).getBb());

Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getRepeatedNestedEnum (0));

Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getRepeatedForeignEnum(0));

@@ -630,6 +662,7 @@

Assert.assertEquals(318, message.getRepeatedNestedMessage (1).getBb());

Assert.assertEquals(319, message.getRepeatedForeignMessage(1).getC());

Assert.assertEquals(320, message.getRepeatedImportMessage (1).getD());

+ Assert.assertEquals(327, message.getRepeatedLazyMessage (1).getBb());

Assert.assertEquals(TestAllTypes.NestedEnum.BAZ, message.getRepeatedNestedEnum (1));

Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getRepeatedForeignEnum(1));

@@ -741,15 +774,19 @@

Assert.assertEquals(ByteString.EMPTY, message.getOptionalBytes());

// Embedded messages should also be clear.

- Assert.assertFalse(message.getOptionalGroup ().hasA());

- Assert.assertFalse(message.getOptionalNestedMessage ().hasBb());

- Assert.assertFalse(message.getOptionalForeignMessage().hasC());

- Assert.assertFalse(message.getOptionalImportMessage ().hasD());

+ Assert.assertFalse(message.getOptionalGroup ().hasA());

+ Assert.assertFalse(message.getOptionalNestedMessage ().hasBb());

+ Assert.assertFalse(message.getOptionalForeignMessage ().hasC());

+ Assert.assertFalse(message.getOptionalImportMessage ().hasD());

+ Assert.assertFalse(message.getOptionalPublicImportMessage().hasE());

+ Assert.assertFalse(message.getOptionalLazyMessage ().hasBb());

- Assert.assertEquals(0, message.getOptionalGroup ().getA());

- Assert.assertEquals(0, message.getOptionalNestedMessage ().getBb());

- Assert.assertEquals(0, message.getOptionalForeignMessage().getC());

- Assert.assertEquals(0, message.getOptionalImportMessage ().getD());

+ Assert.assertEquals(0, message.getOptionalGroup ().getA());

+ Assert.assertEquals(0, message.getOptionalNestedMessage ().getBb());

+ Assert.assertEquals(0, message.getOptionalForeignMessage ().getC());

+ Assert.assertEquals(0, message.getOptionalImportMessage ().getD());

+ Assert.assertEquals(0, message.getOptionalPublicImportMessage().getE());

+ Assert.assertEquals(0, message.getOptionalLazyMessage ().getBb());

// Enums without defaults are set to the first value in the enum.

Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getOptionalNestedEnum ());

@@ -780,6 +817,7 @@

Assert.assertEquals(0, message.getRepeatedNestedMessageCount ());

Assert.assertEquals(0, message.getRepeatedForeignMessageCount());

Assert.assertEquals(0, message.getRepeatedImportMessageCount ());

+ Assert.assertEquals(0, message.getRepeatedLazyMessageCount ());

Assert.assertEquals(0, message.getRepeatedNestedEnumCount ());

Assert.assertEquals(0, message.getRepeatedForeignEnumCount ());

Assert.assertEquals(0, message.getRepeatedImportEnumCount ());

@@ -868,6 +906,7 @@

Assert.assertEquals(2, message.getRepeatedNestedMessageCount ());

Assert.assertEquals(2, message.getRepeatedForeignMessageCount());

Assert.assertEquals(2, message.getRepeatedImportMessageCount ());

+ Assert.assertEquals(2, message.getRepeatedLazyMessageCount ());

Assert.assertEquals(2, message.getRepeatedNestedEnumCount ());

Assert.assertEquals(2, message.getRepeatedForeignEnumCount ());

Assert.assertEquals(2, message.getRepeatedImportEnumCount ());

@@ -895,6 +934,7 @@

Assert.assertEquals(218, message.getRepeatedNestedMessage (0).getBb());

Assert.assertEquals(219, message.getRepeatedForeignMessage(0).getC());

Assert.assertEquals(220, message.getRepeatedImportMessage (0).getD());

+ Assert.assertEquals(227, message.getRepeatedLazyMessage (0).getBb());

Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getRepeatedNestedEnum (0));

Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getRepeatedForeignEnum(0));

@@ -924,6 +964,7 @@

Assert.assertEquals(518, message.getRepeatedNestedMessage (1).getBb());

Assert.assertEquals(519, message.getRepeatedForeignMessage(1).getC());

Assert.assertEquals(520, message.getRepeatedImportMessage (1).getD());

+ Assert.assertEquals(527, message.getRepeatedLazyMessage (1).getBb());

Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getRepeatedNestedEnum (1));

Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getRepeatedForeignEnum(1));

@@ -1210,6 +1251,10 @@

ForeignMessage.newBuilder().setC(119).build());

message.setExtension(optionalImportMessageExtension,

ImportMessage.newBuilder().setD(120).build());

+ message.setExtension(optionalPublicImportMessageExtension,

+ PublicImportMessage.newBuilder().setE(126).build());

+ message.setExtension(optionalLazyMessageExtension,

+ TestAllTypes.NestedMessage.newBuilder().setBb(127).build());

message.setExtension(optionalNestedEnumExtension, TestAllTypes.NestedEnum.BAZ);

message.setExtension(optionalForeignEnumExtension, ForeignEnum.FOREIGN_BAZ);

@@ -1244,6 +1289,8 @@

ForeignMessage.newBuilder().setC(219).build());

message.addExtension(repeatedImportMessageExtension,

ImportMessage.newBuilder().setD(220).build());

+ message.addExtension(repeatedLazyMessageExtension,

+ TestAllTypes.NestedMessage.newBuilder().setBb(227).build());

message.addExtension(repeatedNestedEnumExtension, TestAllTypes.NestedEnum.BAR);

message.addExtension(repeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAR);

@@ -1277,6 +1324,8 @@

ForeignMessage.newBuilder().setC(319).build());

message.addExtension(repeatedImportMessageExtension,

ImportMessage.newBuilder().setD(320).build());

+ message.addExtension(repeatedLazyMessageExtension,

+ TestAllTypes.NestedMessage.newBuilder().setBb(327).build());

message.addExtension(repeatedNestedEnumExtension, TestAllTypes.NestedEnum.BAZ);

message.addExtension(repeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAZ);

@@ -1343,6 +1392,8 @@

ForeignMessage.newBuilder().setC(519).build());

message.setExtension(repeatedImportMessageExtension, 1,

ImportMessage.newBuilder().setD(520).build());

+ message.setExtension(repeatedLazyMessageExtension, 1,

+ TestAllTypes.NestedMessage.newBuilder().setBb(527).build());

message.setExtension(repeatedNestedEnumExtension , 1, TestAllTypes.NestedEnum.FOO);

message.setExtension(repeatedForeignEnumExtension, 1, ForeignEnum.FOREIGN_FOO);

@@ -1409,10 +1460,12 @@

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(117, message.getExtension(optionalGroupExtension ).getA());

+ assertEqualsExactType(118, message.getExtension(optionalNestedMessageExtension ).getBb());

+ assertEqualsExactType(119, message.getExtension(optionalForeignMessageExtension ).getC());

+ assertEqualsExactType(120, message.getExtension(optionalImportMessageExtension ).getD());

+ assertEqualsExactType(126, message.getExtension(optionalPublicImportMessageExtension).getE());

+ assertEqualsExactType(127, message.getExtension(optionalLazyMessageExtension ).getBb());

assertEqualsExactType(TestAllTypes.NestedEnum.BAZ,

message.getExtension(optionalNestedEnumExtension));

@@ -1446,6 +1499,7 @@

Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtension ));

Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtension));

Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtension ));

+ Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtension ));

Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension ));

Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtension ));

Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension ));

@@ -1473,6 +1527,7 @@

assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtension , 0).getBb());

assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtension, 0).getC());

assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtension , 0).getD());

+ assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtension , 0).getBb());

assertEqualsExactType(TestAllTypes.NestedEnum.BAR,

message.getExtension(repeatedNestedEnumExtension, 0));

@@ -1504,6 +1559,7 @@

assertEqualsExactType(318, message.getExtension(repeatedNestedMessageExtension , 1).getBb());

assertEqualsExactType(319, message.getExtension(repeatedForeignMessageExtension, 1).getC());

assertEqualsExactType(320, message.getExtension(repeatedImportMessageExtension , 1).getD());

+ assertEqualsExactType(327, message.getExtension(repeatedLazyMessageExtension , 1).getBb());

assertEqualsExactType(TestAllTypes.NestedEnum.BAZ,

message.getExtension(repeatedNestedEnumExtension, 1));

@@ -1664,6 +1720,7 @@

Assert.assertEquals(0, message.getExtensionCount(repeatedNestedMessageExtension ));

Assert.assertEquals(0, message.getExtensionCount(repeatedForeignMessageExtension));

Assert.assertEquals(0, message.getExtensionCount(repeatedImportMessageExtension ));

+ Assert.assertEquals(0, message.getExtensionCount(repeatedLazyMessageExtension ));

Assert.assertEquals(0, message.getExtensionCount(repeatedNestedEnumExtension ));

Assert.assertEquals(0, message.getExtensionCount(repeatedForeignEnumExtension ));

Assert.assertEquals(0, message.getExtensionCount(repeatedImportEnumExtension ));

@@ -1692,6 +1749,7 @@

Assert.assertEquals(0, message.getExtension(repeatedNestedMessageExtension ).size());

Assert.assertEquals(0, message.getExtension(repeatedForeignMessageExtension).size());

Assert.assertEquals(0, message.getExtension(repeatedImportMessageExtension ).size());

+ Assert.assertEquals(0, message.getExtension(repeatedLazyMessageExtension ).size());

Assert.assertEquals(0, message.getExtension(repeatedNestedEnumExtension ).size());

Assert.assertEquals(0, message.getExtension(repeatedForeignEnumExtension ).size());

Assert.assertEquals(0, message.getExtension(repeatedImportEnumExtension ).size());

@@ -1783,6 +1841,7 @@

Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtension ));

Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtension));

Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtension ));

+ Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtension ));

Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension ));

Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtension ));

Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension ));

@@ -1810,6 +1869,7 @@

assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtension , 0).getBb());

assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtension, 0).getC());

assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtension , 0).getD());

+ assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtension , 0).getBb());

assertEqualsExactType(TestAllTypes.NestedEnum.BAR,

message.getExtension(repeatedNestedEnumExtension, 0));

@@ -1842,6 +1902,7 @@

assertEqualsExactType(518, message.getExtension(repeatedNestedMessageExtension , 1).getBb());

assertEqualsExactType(519, message.getExtension(repeatedForeignMessageExtension, 1).getC());

assertEqualsExactType(520, message.getExtension(repeatedImportMessageExtension , 1).getD());

+ assertEqualsExactType(527, message.getExtension(repeatedLazyMessageExtension , 1).getBb());

assertEqualsExactType(TestAllTypes.NestedEnum.FOO,

message.getExtension(repeatedNestedEnumExtension, 1));

@@ -1965,6 +2026,10 @@

ForeignMessageLite.newBuilder().setC(119).build());

message.setExtension(optionalImportMessageExtensionLite,

ImportMessageLite.newBuilder().setD(120).build());

+ message.setExtension(optionalPublicImportMessageExtensionLite,

+ PublicImportMessageLite.newBuilder().setE(126).build());

+ message.setExtension(optionalLazyMessageExtensionLite,

+ TestAllTypesLite.NestedMessage.newBuilder().setBb(127).build());

message.setExtension(optionalNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ);

message.setExtension(optionalForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ);

@@ -1999,6 +2064,8 @@

ForeignMessageLite.newBuilder().setC(219).build());

message.addExtension(repeatedImportMessageExtensionLite,

ImportMessageLite.newBuilder().setD(220).build());

+ message.addExtension(repeatedLazyMessageExtensionLite,

+ TestAllTypesLite.NestedMessage.newBuilder().setBb(227).build());

message.addExtension(repeatedNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAR);

message.addExtension(repeatedForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAR);

@@ -2032,6 +2099,8 @@

ForeignMessageLite.newBuilder().setC(319).build());

message.addExtension(repeatedImportMessageExtensionLite,

ImportMessageLite.newBuilder().setD(320).build());

+ message.addExtension(repeatedLazyMessageExtensionLite,

+ TestAllTypesLite.NestedMessage.newBuilder().setBb(327).build());

message.addExtension(repeatedNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ);

message.addExtension(repeatedForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ);

@@ -2098,6 +2167,8 @@

ForeignMessageLite.newBuilder().setC(519).build());

message.setExtension(repeatedImportMessageExtensionLite, 1,

ImportMessageLite.newBuilder().setD(520).build());

+ message.setExtension(repeatedLazyMessageExtensionLite, 1,

+ TestAllTypesLite.NestedMessage.newBuilder().setBb(527).build());

message.setExtension(repeatedNestedEnumExtensionLite , 1, TestAllTypesLite.NestedEnum.FOO);

message.setExtension(repeatedForeignEnumExtensionLite, 1, ForeignEnumLite.FOREIGN_LITE_FOO);

@@ -2168,6 +2239,9 @@

assertEqualsExactType(118, message.getExtension(optionalNestedMessageExtensionLite ).getBb());

assertEqualsExactType(119, message.getExtension(optionalForeignMessageExtensionLite).getC());

assertEqualsExactType(120, message.getExtension(optionalImportMessageExtensionLite ).getD());

+ assertEqualsExactType(126, message.getExtension(

+ optionalPublicImportMessageExtensionLite).getE());

+ assertEqualsExactType(127, message.getExtension(optionalLazyMessageExtensionLite).getBb());

assertEqualsExactType(TestAllTypesLite.NestedEnum.BAZ,

message.getExtension(optionalNestedEnumExtensionLite));

@@ -2201,6 +2275,7 @@

Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtensionLite ));

Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtensionLite));

Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtensionLite ));

+ Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtensionLite ));

Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtensionLite ));

Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtensionLite ));

Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtensionLite ));

@@ -2228,6 +2303,7 @@

assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtensionLite ,0).getBb());

assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtensionLite,0).getC());

assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtensionLite ,0).getD());

+ assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtensionLite ,0).getBb());

assertEqualsExactType(TestAllTypesLite.NestedEnum.BAR,

message.getExtension(repeatedNestedEnumExtensionLite, 0));

@@ -2259,6 +2335,7 @@

assertEqualsExactType(318, message.getExtension(repeatedNestedMessageExtensionLite ,1).getBb());

assertEqualsExactType(319, message.getExtension(repeatedForeignMessageExtensionLite,1).getC());

assertEqualsExactType(320, message.getExtension(repeatedImportMessageExtensionLite ,1).getD());

+ assertEqualsExactType(327, message.getExtension(repeatedLazyMessageExtensionLite ,1).getBb());

assertEqualsExactType(TestAllTypesLite.NestedEnum.BAZ,

message.getExtension(repeatedNestedEnumExtensionLite, 1));

@@ -2348,10 +2425,12 @@

Assert.assertFalse(message.hasExtension(optionalStringExtensionLite ));

Assert.assertFalse(message.hasExtension(optionalBytesExtensionLite ));

- Assert.assertFalse(message.hasExtension(optionalGroupExtensionLite ));

- Assert.assertFalse(message.hasExtension(optionalNestedMessageExtensionLite ));

- Assert.assertFalse(message.hasExtension(optionalForeignMessageExtensionLite));

- Assert.assertFalse(message.hasExtension(optionalImportMessageExtensionLite ));

+ Assert.assertFalse(message.hasExtension(optionalGroupExtensionLite ));

+ Assert.assertFalse(message.hasExtension(optionalNestedMessageExtensionLite ));

+ Assert.assertFalse(message.hasExtension(optionalForeignMessageExtensionLite ));

+ Assert.assertFalse(message.hasExtension(optionalImportMessageExtensionLite ));

+ Assert.assertFalse(message.hasExtension(optionalPublicImportMessageExtensionLite));

+ Assert.assertFalse(message.hasExtension(optionalLazyMessageExtensionLite ));

Assert.assertFalse(message.hasExtension(optionalNestedEnumExtensionLite ));

Assert.assertFalse(message.hasExtension(optionalForeignEnumExtensionLite));

@@ -2378,15 +2457,20 @@

assertEqualsExactType(ByteString.EMPTY, message.getExtension(optionalBytesExtensionLite));

// Embedded messages should also be clear.

- Assert.assertFalse(message.getExtension(optionalGroupExtensionLite ).hasA());

- Assert.assertFalse(message.getExtension(optionalNestedMessageExtensionLite ).hasBb());

- Assert.assertFalse(message.getExtension(optionalForeignMessageExtensionLite).hasC());

- Assert.assertFalse(message.getExtension(optionalImportMessageExtensionLite ).hasD());

+ Assert.assertFalse(message.getExtension(optionalGroupExtensionLite ).hasA());

+ Assert.assertFalse(message.getExtension(optionalNestedMessageExtensionLite ).hasBb());

+ Assert.assertFalse(message.getExtension(optionalForeignMessageExtensionLite ).hasC());

+ Assert.assertFalse(message.getExtension(optionalImportMessageExtensionLite ).hasD());

+ Assert.assertFalse(message.getExtension(optionalPublicImportMessageExtensionLite).hasE());

+ Assert.assertFalse(message.getExtension(optionalLazyMessageExtensionLite ).hasBb());

assertEqualsExactType(0, message.getExtension(optionalGroupExtensionLite ).getA());

assertEqualsExactType(0, message.getExtension(optionalNestedMessageExtensionLite ).getBb());

assertEqualsExactType(0, message.getExtension(optionalForeignMessageExtensionLite).getC());

assertEqualsExactType(0, message.getExtension(optionalImportMessageExtensionLite ).getD());

+ assertEqualsExactType(0, message.getExtension(

+ optionalPublicImportMessageExtensionLite).getE());

+ assertEqualsExactType(0, message.getExtension(optionalLazyMessageExtensionLite ).getBb());

// Enums without defaults are set to the first value in the enum.

assertEqualsExactType(TestAllTypesLite.NestedEnum.FOO,

@@ -2420,6 +2504,7 @@

Assert.assertEquals(0, message.getExtensionCount(repeatedNestedMessageExtensionLite ));

Assert.assertEquals(0, message.getExtensionCount(repeatedForeignMessageExtensionLite));

Assert.assertEquals(0, message.getExtensionCount(repeatedImportMessageExtensionLite ));

+ Assert.assertEquals(0, message.getExtensionCount(repeatedLazyMessageExtensionLite ));

Assert.assertEquals(0, message.getExtensionCount(repeatedNestedEnumExtensionLite ));

Assert.assertEquals(0, message.getExtensionCount(repeatedForeignEnumExtensionLite ));

Assert.assertEquals(0, message.getExtensionCount(repeatedImportEnumExtensionLite ));

@@ -2511,6 +2596,7 @@

Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtensionLite ));

Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtensionLite));

Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtensionLite ));

+ Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtensionLite ));

Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtensionLite ));

Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtensionLite ));

Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtensionLite ));

@@ -2538,6 +2624,7 @@

assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtensionLite ,0).getBb());

assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtensionLite,0).getC());

assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtensionLite ,0).getD());

+ assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtensionLite ,0).getBb());

assertEqualsExactType(TestAllTypesLite.NestedEnum.BAR,

message.getExtension(repeatedNestedEnumExtensionLite, 0));

@@ -2570,6 +2657,7 @@

assertEqualsExactType(518, message.getExtension(repeatedNestedMessageExtensionLite ,1).getBb());

assertEqualsExactType(519, message.getExtension(repeatedForeignMessageExtensionLite,1).getC());

assertEqualsExactType(520, message.getExtension(repeatedImportMessageExtensionLite ,1).getD());

+ assertEqualsExactType(527, message.getExtension(repeatedLazyMessageExtensionLite ,1).getBb());

assertEqualsExactType(TestAllTypesLite.NestedEnum.FOO,

message.getExtension(repeatedNestedEnumExtensionLite, 1));

@@ -2674,18 +2762,21 @@

private final Descriptors.FileDescriptor file;

private final Descriptors.FileDescriptor importFile;

+ private final Descriptors.FileDescriptor publicImportFile;

private final Descriptors.Descriptor optionalGroup;

private final Descriptors.Descriptor repeatedGroup;

private final Descriptors.Descriptor nestedMessage;

private final Descriptors.Descriptor foreignMessage;

private final Descriptors.Descriptor importMessage;

+ private final Descriptors.Descriptor publicImportMessage;

private final Descriptors.FieldDescriptor groupA;

private final Descriptors.FieldDescriptor repeatedGroupA;

private final Descriptors.FieldDescriptor nestedB;

private final Descriptors.FieldDescriptor foreignC;

private final Descriptors.FieldDescriptor importD;

+ private final Descriptors.FieldDescriptor importE;

private final Descriptors.EnumDescriptor nestedEnum;

private final Descriptors.EnumDescriptor foreignEnum;

@@ -2722,6 +2813,7 @@

this.file = baseDescriptor.getFile();

Assert.assertEquals(1, file.getDependencies().size());

this.importFile = file.getDependencies().get(0);

+ this.publicImportFile = importFile.getDependencies().get(0);

Descriptors.Descriptor testAllTypes;

if (baseDescriptor.getName() == "TestAllTypes") {

@@ -2748,6 +2840,8 @@

this.nestedMessage = testAllTypes.findNestedTypeByName("NestedMessage");

this.foreignMessage = file.findMessageTypeByName("ForeignMessage");

this.importMessage = importFile.findMessageTypeByName("ImportMessage");

+ this.publicImportMessage = publicImportFile.findMessageTypeByName(

+ "PublicImportMessage");

this.nestedEnum = testAllTypes.findEnumTypeByName("NestedEnum");

this.foreignEnum = file.findEnumTypeByName("ForeignEnum");

@@ -2765,6 +2859,7 @@

this.nestedB = nestedMessage .findFieldByName("bb");

this.foreignC = foreignMessage.findFieldByName("c");

this.importD = importMessage .findFieldByName("d");

+ this.importE = publicImportMessage.findFieldByName("e");

this.nestedFoo = nestedEnum.findValueByName("FOO");

this.nestedBar = nestedEnum.findValueByName("BAR");

this.nestedBaz = nestedEnum.findValueByName("BAZ");

@@ -2783,6 +2878,7 @@

Assert.assertNotNull(nestedB );

Assert.assertNotNull(foreignC );

Assert.assertNotNull(importD );

+ Assert.assertNotNull(importE );

Assert.assertNotNull(nestedFoo );

Assert.assertNotNull(nestedBar );

Assert.assertNotNull(nestedBaz );

@@ -2863,6 +2959,12 @@

message.setField(f("optional_import_message"),

newBuilderForField(message, f("optional_import_message"))

.setField(importD, 120).build());

+ message.setField(f("optional_public_import_message"),

+ newBuilderForField(message, f("optional_public_import_message"))

+ .setField(importE, 126).build());

+ message.setField(f("optional_lazy_message"),

+ newBuilderForField(message, f("optional_lazy_message"))

+ .setField(nestedB, 127).build());

message.setField(f("optional_nested_enum" ), nestedBaz);

message.setField(f("optional_foreign_enum"), foreignBaz);

@@ -2901,6 +3003,9 @@

message.addRepeatedField(f("repeated_import_message"),

newBuilderForField(message, f("repeated_import_message"))

.setField(importD, 220).build());

+ message.addRepeatedField(f("repeated_lazy_message"),

+ newBuilderForField(message, f("repeated_lazy_message"))

+ .setField(nestedB, 227).build());

message.addRepeatedField(f("repeated_nested_enum" ), nestedBar);

message.addRepeatedField(f("repeated_foreign_enum"), foreignBar);

@@ -2938,6 +3043,9 @@

message.addRepeatedField(f("repeated_import_message"),

newBuilderForField(message, f("repeated_import_message"))

.setField(importD, 320).build());

+ message.addRepeatedField(f("repeated_lazy_message"),

+ newBuilderForField(message, f("repeated_lazy_message"))

+ .setField(nestedB, 327).build());

message.addRepeatedField(f("repeated_nested_enum" ), nestedBaz);

message.addRepeatedField(f("repeated_foreign_enum"), foreignBaz);

@@ -3008,6 +3116,9 @@

message.setRepeatedField(f("repeated_import_message"), 1,

newBuilderForField(message, f("repeated_import_message"))

.setField(importD, 520).build());

+ message.setRepeatedField(f("repeated_lazy_message"), 1,

+ newBuilderForField(message, f("repeated_lazy_message"))

+ .setField(nestedB, 527).build());

message.setRepeatedField(f("repeated_nested_enum" ), 1, nestedFoo);

message.setRepeatedField(f("repeated_foreign_enum"), 1, foreignFoo);

@@ -3092,6 +3203,12 @@

Assert.assertEquals(120,

((Message)message.getField(f("optional_import_message")))

.getField(importD));

+ Assert.assertEquals(126,

+ ((Message)message.getField(f("optional_public_import_message")))

+ .getField(importE));

+ Assert.assertEquals(127,

+ ((Message)message.getField(f("optional_lazy_message")))

+ .getField(nestedB));

Assert.assertEquals( nestedBaz, message.getField(f("optional_nested_enum" )));

Assert.assertEquals(foreignBaz, message.getField(f("optional_foreign_enum")));

@@ -3122,6 +3239,7 @@

Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_message" )));

Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_message")));

Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_message" )));

+ Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_lazy_message" )));

Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_enum" )));

Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_enum" )));

Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_enum" )));

@@ -3157,6 +3275,9 @@

Assert.assertEquals(220,

((Message)message.getRepeatedField(f("repeated_import_message"), 0))

.getField(importD));

+ Assert.assertEquals(227,

+ ((Message)message.getRepeatedField(f("repeated_lazy_message"), 0))

+ .getField(nestedB));

Assert.assertEquals( nestedBar, message.getRepeatedField(f("repeated_nested_enum" ),0));

Assert.assertEquals(foreignBar, message.getRepeatedField(f("repeated_foreign_enum"),0));

@@ -3193,6 +3314,9 @@

Assert.assertEquals(320,

((Message)message.getRepeatedField(f("repeated_import_message"), 1))

.getField(importD));

+ Assert.assertEquals(327,

+ ((Message)message.getRepeatedField(f("repeated_lazy_message"), 1))

+ .getField(nestedB));

Assert.assertEquals( nestedBaz, message.getRepeatedField(f("repeated_nested_enum" ),1));

Assert.assertEquals(foreignBaz, message.getRepeatedField(f("repeated_foreign_enum"),1));

@@ -3316,6 +3440,12 @@

Assert.assertFalse(

((Message)message.getField(f("optional_import_message")))

.hasField(importD));

+ Assert.assertFalse(

+ ((Message)message.getField(f("optional_public_import_message")))

+ .hasField(importE));

+ Assert.assertFalse(

+ ((Message)message.getField(f("optional_lazy_message")))

+ .hasField(nestedB));

Assert.assertEquals(0,

((Message)message.getField(f("optionalgroup"))).getField(groupA));

@@ -3328,6 +3458,12 @@

Assert.assertEquals(0,

((Message)message.getField(f("optional_import_message")))

.getField(importD));

+ Assert.assertEquals(0,

+ ((Message)message.getField(f("optional_public_import_message")))

+ .getField(importE));

+ Assert.assertEquals(0,

+ ((Message)message.getField(f("optional_lazy_message")))

+ .getField(nestedB));

// Enums without defaults are set to the first value in the enum.

Assert.assertEquals( nestedFoo, message.getField(f("optional_nested_enum" )));

@@ -3358,6 +3494,7 @@

Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_nested_message" )));

Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_foreign_message")));

Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_import_message" )));

+ Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_lazy_message" )));

Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_nested_enum" )));

Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_foreign_enum" )));

Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_import_enum" )));

@@ -3442,6 +3579,7 @@

Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_message" )));

Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_message")));

Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_message" )));

+ Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_lazy_message" )));

Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_enum" )));

Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_enum" )));

Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_enum" )));

@@ -3477,6 +3615,9 @@

Assert.assertEquals(220,

((Message)message.getRepeatedField(f("repeated_import_message"), 0))

.getField(importD));

+ Assert.assertEquals(227,

+ ((Message)message.getRepeatedField(f("repeated_lazy_message"), 0))

+ .getField(nestedB));

Assert.assertEquals( nestedBar, message.getRepeatedField(f("repeated_nested_enum" ),0));

Assert.assertEquals(foreignBar, message.getRepeatedField(f("repeated_foreign_enum"),0));

@@ -3513,6 +3654,9 @@

Assert.assertEquals(520,

((Message)message.getRepeatedField(f("repeated_import_message"), 1))

.getField(importD));

+ Assert.assertEquals(527,

+ ((Message)message.getRepeatedField(f("repeated_lazy_message"), 1))

+ .getField(nestedB));

Assert.assertEquals( nestedFoo, message.getRepeatedField(f("repeated_nested_enum" ),1));

Assert.assertEquals(foreignFoo, message.getRepeatedField(f("repeated_foreign_enum"),1));