← Back to branch summary

~statik/ubuntu/maverick/protobuf/A

« back to all changes in this revision

Viewing changes to java/src/test/java/com/google/protobuf/TestUtil.java

  • Committer: Bazaar Package Importer
  • Author(s): Steve Kowalik
  • Date: 2010-02-11 11:13:19 UTC
  • mfrom: (2.2.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100211111319-zdn8hmw0gh8s4cf8
Tags: 2.2.0a-0.1ubuntu1
* Merge from Debian testing.
* Remaining Ubuntu changes:
  - Don't use python2.4.
* Ubuntu changes dropped:
  - Disable death tests on Itanium, fixed upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
java/src/test/java/com/google/protobuf/TestUtil.java
31
31
package com.google.protobuf;
32
32
 
33
33
import protobuf_unittest.UnittestProto;
 
34
import com.google.protobuf.UnittestLite;
34
35
 
35
36
// The static imports are to avoid 100+ char lines.  The following is roughly equivalent to
36
37
// import static protobuf_unittest.UnittestProto.*;
123
124
import static protobuf_unittest.UnittestProto.packedBoolExtension;
124
125
import static protobuf_unittest.UnittestProto.packedEnumExtension;
125
126
 
 
127
import static com.google.protobuf.UnittestLite.defaultInt32ExtensionLite;
 
128
import static com.google.protobuf.UnittestLite.defaultInt64ExtensionLite;
 
129
import static com.google.protobuf.UnittestLite.defaultUint32ExtensionLite;
 
130
import static com.google.protobuf.UnittestLite.defaultUint64ExtensionLite;
 
131
import static com.google.protobuf.UnittestLite.defaultSint32ExtensionLite;
 
132
import static com.google.protobuf.UnittestLite.defaultSint64ExtensionLite;
 
133
import static com.google.protobuf.UnittestLite.defaultFixed32ExtensionLite;
 
134
import static com.google.protobuf.UnittestLite.defaultFixed64ExtensionLite;
 
135
import static com.google.protobuf.UnittestLite.defaultSfixed32ExtensionLite;
 
136
import static com.google.protobuf.UnittestLite.defaultSfixed64ExtensionLite;
 
137
import static com.google.protobuf.UnittestLite.defaultFloatExtensionLite;
 
138
import static com.google.protobuf.UnittestLite.defaultDoubleExtensionLite;
 
139
import static com.google.protobuf.UnittestLite.defaultBoolExtensionLite;
 
140
import static com.google.protobuf.UnittestLite.defaultStringExtensionLite;
 
141
import static com.google.protobuf.UnittestLite.defaultBytesExtensionLite;
 
142
import static com.google.protobuf.UnittestLite.defaultNestedEnumExtensionLite;
 
143
import static com.google.protobuf.UnittestLite.defaultForeignEnumExtensionLite;
 
144
import static com.google.protobuf.UnittestLite.defaultImportEnumExtensionLite;
 
145
import static com.google.protobuf.UnittestLite.defaultStringPieceExtensionLite;
 
146
import static com.google.protobuf.UnittestLite.defaultCordExtensionLite;
 
147
 
 
148
import static com.google.protobuf.UnittestLite.optionalInt32ExtensionLite;
 
149
import static com.google.protobuf.UnittestLite.optionalInt64ExtensionLite;
 
150
import static com.google.protobuf.UnittestLite.optionalUint32ExtensionLite;
 
151
import static com.google.protobuf.UnittestLite.optionalUint64ExtensionLite;
 
152
import static com.google.protobuf.UnittestLite.optionalSint32ExtensionLite;
 
153
import static com.google.protobuf.UnittestLite.optionalSint64ExtensionLite;
 
154
import static com.google.protobuf.UnittestLite.optionalFixed32ExtensionLite;
 
155
import static com.google.protobuf.UnittestLite.optionalFixed64ExtensionLite;
 
156
import static com.google.protobuf.UnittestLite.optionalSfixed32ExtensionLite;
 
157
import static com.google.protobuf.UnittestLite.optionalSfixed64ExtensionLite;
 
158
import static com.google.protobuf.UnittestLite.optionalFloatExtensionLite;
 
159
import static com.google.protobuf.UnittestLite.optionalDoubleExtensionLite;
 
160
import static com.google.protobuf.UnittestLite.optionalBoolExtensionLite;
 
161
import static com.google.protobuf.UnittestLite.optionalStringExtensionLite;
 
162
import static com.google.protobuf.UnittestLite.optionalBytesExtensionLite;
 
163
import static com.google.protobuf.UnittestLite.optionalGroupExtensionLite;
 
164
import static com.google.protobuf.UnittestLite.optionalNestedMessageExtensionLite;
 
165
import static com.google.protobuf.UnittestLite.optionalForeignMessageExtensionLite;
 
166
import static com.google.protobuf.UnittestLite.optionalImportMessageExtensionLite;
 
167
import static com.google.protobuf.UnittestLite.optionalNestedEnumExtensionLite;
 
168
import static com.google.protobuf.UnittestLite.optionalForeignEnumExtensionLite;
 
169
import static com.google.protobuf.UnittestLite.optionalImportEnumExtensionLite;
 
170
import static com.google.protobuf.UnittestLite.optionalStringPieceExtensionLite;
 
171
import static com.google.protobuf.UnittestLite.optionalCordExtensionLite;
 
172
 
 
173
import static com.google.protobuf.UnittestLite.repeatedInt32ExtensionLite;
 
174
import static com.google.protobuf.UnittestLite.repeatedInt64ExtensionLite;
 
175
import static com.google.protobuf.UnittestLite.repeatedUint32ExtensionLite;
 
176
import static com.google.protobuf.UnittestLite.repeatedUint64ExtensionLite;
 
177
import static com.google.protobuf.UnittestLite.repeatedSint32ExtensionLite;
 
178
import static com.google.protobuf.UnittestLite.repeatedSint64ExtensionLite;
 
179
import static com.google.protobuf.UnittestLite.repeatedFixed32ExtensionLite;
 
180
import static com.google.protobuf.UnittestLite.repeatedFixed64ExtensionLite;
 
181
import static com.google.protobuf.UnittestLite.repeatedSfixed32ExtensionLite;
 
182
import static com.google.protobuf.UnittestLite.repeatedSfixed64ExtensionLite;
 
183
import static com.google.protobuf.UnittestLite.repeatedFloatExtensionLite;
 
184
import static com.google.protobuf.UnittestLite.repeatedDoubleExtensionLite;
 
185
import static com.google.protobuf.UnittestLite.repeatedBoolExtensionLite;
 
186
import static com.google.protobuf.UnittestLite.repeatedStringExtensionLite;
 
187
import static com.google.protobuf.UnittestLite.repeatedBytesExtensionLite;
 
188
import static com.google.protobuf.UnittestLite.repeatedGroupExtensionLite;
 
189
import static com.google.protobuf.UnittestLite.repeatedNestedMessageExtensionLite;
 
190
import static com.google.protobuf.UnittestLite.repeatedForeignMessageExtensionLite;
 
191
import static com.google.protobuf.UnittestLite.repeatedImportMessageExtensionLite;
 
192
import static com.google.protobuf.UnittestLite.repeatedNestedEnumExtensionLite;
 
193
import static com.google.protobuf.UnittestLite.repeatedForeignEnumExtensionLite;
 
194
import static com.google.protobuf.UnittestLite.repeatedImportEnumExtensionLite;
 
195
import static com.google.protobuf.UnittestLite.repeatedStringPieceExtensionLite;
 
196
import static com.google.protobuf.UnittestLite.repeatedCordExtensionLite;
 
197
 
 
198
import static com.google.protobuf.UnittestLite.OptionalGroup_extension_lite;
 
199
import static com.google.protobuf.UnittestLite.RepeatedGroup_extension_lite;
 
200
 
 
201
import static com.google.protobuf.UnittestLite.packedInt32ExtensionLite;
 
202
import static com.google.protobuf.UnittestLite.packedInt64ExtensionLite;
 
203
import static com.google.protobuf.UnittestLite.packedUint32ExtensionLite;
 
204
import static com.google.protobuf.UnittestLite.packedUint64ExtensionLite;
 
205
import static com.google.protobuf.UnittestLite.packedSint32ExtensionLite;
 
206
import static com.google.protobuf.UnittestLite.packedSint64ExtensionLite;
 
207
import static com.google.protobuf.UnittestLite.packedFixed32ExtensionLite;
 
208
import static com.google.protobuf.UnittestLite.packedFixed64ExtensionLite;
 
209
import static com.google.protobuf.UnittestLite.packedSfixed32ExtensionLite;
 
210
import static com.google.protobuf.UnittestLite.packedSfixed64ExtensionLite;
 
211
import static com.google.protobuf.UnittestLite.packedFloatExtensionLite;
 
212
import static com.google.protobuf.UnittestLite.packedDoubleExtensionLite;
 
213
import static com.google.protobuf.UnittestLite.packedBoolExtensionLite;
 
214
import static com.google.protobuf.UnittestLite.packedEnumExtensionLite;
 
215
 
126
216
import protobuf_unittest.UnittestProto.TestAllExtensions;
127
217
import protobuf_unittest.UnittestProto.TestAllTypes;
128
218
import protobuf_unittest.UnittestProto.TestPackedExtensions;
132
222
import com.google.protobuf.test.UnittestImport.ImportMessage;
133
223
import com.google.protobuf.test.UnittestImport.ImportEnum;
134
224
 
 
225
import com.google.protobuf.UnittestLite.TestAllTypesLite;
 
226
import com.google.protobuf.UnittestLite.TestAllExtensionsLite;
 
227
import com.google.protobuf.UnittestLite.TestPackedExtensionsLite;
 
228
import com.google.protobuf.UnittestLite.ForeignMessageLite;
 
229
import com.google.protobuf.UnittestLite.ForeignEnumLite;
 
230
import com.google.protobuf.UnittestImportLite.ImportMessageLite;
 
231
import com.google.protobuf.UnittestImportLite.ImportEnumLite;
 
232
 
135
233
import junit.framework.Assert;
136
234
 
137
235
import java.io.File;
179
277
    return builder.build();
180
278
  }
181
279
 
 
280
  public static TestAllExtensionsLite getAllLiteExtensionsSet() {
 
281
    TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
 
282
    setAllExtensions(builder);
 
283
    return builder.build();
 
284
  }
 
285
 
182
286
  public static TestPackedTypes getPackedSet() {
183
287
    TestPackedTypes.Builder builder = TestPackedTypes.newBuilder();
184
288
    setPackedFields(builder);
191
295
    return builder.build();
192
296
  }
193
297
 
 
298
  public static TestPackedExtensionsLite getLitePackedExtensionsSet() {
 
299
    TestPackedExtensionsLite.Builder builder =
 
300
        TestPackedExtensionsLite.newBuilder();
 
301
    setPackedExtensions(builder);
 
302
    return builder.build();
 
303
  }
 
304
 
194
305
  /**
195
306
   * Set every field of {@code message} to the values expected by
196
307
   * {@code assertAllFieldsSet()}.
809
920
    Assert.assertEquals("525", message.getRepeatedCord(1));
810
921
  }
811
922
 
 
923
  /**
 
924
   * Set every field of {@code message} to a unique value.
 
925
   */
 
926
  public static void setPackedFields(TestPackedTypes.Builder message) {
 
927
    message.addPackedInt32   (601);
 
928
    message.addPackedInt64   (602);
 
929
    message.addPackedUint32  (603);
 
930
    message.addPackedUint64  (604);
 
931
    message.addPackedSint32  (605);
 
932
    message.addPackedSint64  (606);
 
933
    message.addPackedFixed32 (607);
 
934
    message.addPackedFixed64 (608);
 
935
    message.addPackedSfixed32(609);
 
936
    message.addPackedSfixed64(610);
 
937
    message.addPackedFloat   (611);
 
938
    message.addPackedDouble  (612);
 
939
    message.addPackedBool    (true);
 
940
    message.addPackedEnum    (ForeignEnum.FOREIGN_BAR);
 
941
    // Add a second one of each field.
 
942
    message.addPackedInt32   (701);
 
943
    message.addPackedInt64   (702);
 
944
    message.addPackedUint32  (703);
 
945
    message.addPackedUint64  (704);
 
946
    message.addPackedSint32  (705);
 
947
    message.addPackedSint64  (706);
 
948
    message.addPackedFixed32 (707);
 
949
    message.addPackedFixed64 (708);
 
950
    message.addPackedSfixed32(709);
 
951
    message.addPackedSfixed64(710);
 
952
    message.addPackedFloat   (711);
 
953
    message.addPackedDouble  (712);
 
954
    message.addPackedBool    (false);
 
955
    message.addPackedEnum    (ForeignEnum.FOREIGN_BAZ);
 
956
  }
 
957
 
 
958
  /**
 
959
   * Assert (using {@code junit.framework.Assert}} that all fields of
 
960
   * {@code message} are set to the values assigned by {@code setPackedFields}.
 
961
   */
 
962
  public static void assertPackedFieldsSet(TestPackedTypes message) {
 
963
    Assert.assertEquals(2, message.getPackedInt32Count   ());
 
964
    Assert.assertEquals(2, message.getPackedInt64Count   ());
 
965
    Assert.assertEquals(2, message.getPackedUint32Count  ());
 
966
    Assert.assertEquals(2, message.getPackedUint64Count  ());
 
967
    Assert.assertEquals(2, message.getPackedSint32Count  ());
 
968
    Assert.assertEquals(2, message.getPackedSint64Count  ());
 
969
    Assert.assertEquals(2, message.getPackedFixed32Count ());
 
970
    Assert.assertEquals(2, message.getPackedFixed64Count ());
 
971
    Assert.assertEquals(2, message.getPackedSfixed32Count());
 
972
    Assert.assertEquals(2, message.getPackedSfixed64Count());
 
973
    Assert.assertEquals(2, message.getPackedFloatCount   ());
 
974
    Assert.assertEquals(2, message.getPackedDoubleCount  ());
 
975
    Assert.assertEquals(2, message.getPackedBoolCount    ());
 
976
    Assert.assertEquals(2, message.getPackedEnumCount   ());
 
977
    Assert.assertEquals(601  , message.getPackedInt32   (0));
 
978
    Assert.assertEquals(602  , message.getPackedInt64   (0));
 
979
    Assert.assertEquals(603  , message.getPackedUint32  (0));
 
980
    Assert.assertEquals(604  , message.getPackedUint64  (0));
 
981
    Assert.assertEquals(605  , message.getPackedSint32  (0));
 
982
    Assert.assertEquals(606  , message.getPackedSint64  (0));
 
983
    Assert.assertEquals(607  , message.getPackedFixed32 (0));
 
984
    Assert.assertEquals(608  , message.getPackedFixed64 (0));
 
985
    Assert.assertEquals(609  , message.getPackedSfixed32(0));
 
986
    Assert.assertEquals(610  , message.getPackedSfixed64(0));
 
987
    Assert.assertEquals(611  , message.getPackedFloat   (0), 0.0);
 
988
    Assert.assertEquals(612  , message.getPackedDouble  (0), 0.0);
 
989
    Assert.assertEquals(true , message.getPackedBool    (0));
 
990
    Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getPackedEnum(0));
 
991
    Assert.assertEquals(701  , message.getPackedInt32   (1));
 
992
    Assert.assertEquals(702  , message.getPackedInt64   (1));
 
993
    Assert.assertEquals(703  , message.getPackedUint32  (1));
 
994
    Assert.assertEquals(704  , message.getPackedUint64  (1));
 
995
    Assert.assertEquals(705  , message.getPackedSint32  (1));
 
996
    Assert.assertEquals(706  , message.getPackedSint64  (1));
 
997
    Assert.assertEquals(707  , message.getPackedFixed32 (1));
 
998
    Assert.assertEquals(708  , message.getPackedFixed64 (1));
 
999
    Assert.assertEquals(709  , message.getPackedSfixed32(1));
 
1000
    Assert.assertEquals(710  , message.getPackedSfixed64(1));
 
1001
    Assert.assertEquals(711  , message.getPackedFloat   (1), 0.0);
 
1002
    Assert.assertEquals(712  , message.getPackedDouble  (1), 0.0);
 
1003
    Assert.assertEquals(false, message.getPackedBool    (1));
 
1004
    Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getPackedEnum(1));
 
1005
  }
 
1006
 
812
1007
  // ===================================================================
813
1008
  // Like above, but for extensions
814
1009
 
846
1041
  private static void assertEqualsExactType(ImportEnum a, ImportEnum b) {
847
1042
    Assert.assertEquals(a, b);
848
1043
  }
 
1044
  private static void assertEqualsExactType(TestAllTypesLite.NestedEnum a,
 
1045
                                            TestAllTypesLite.NestedEnum b) {
 
1046
    Assert.assertEquals(a, b);
 
1047
  }
 
1048
  private static void assertEqualsExactType(ForeignEnumLite a,
 
1049
                                            ForeignEnumLite b) {
 
1050
    Assert.assertEquals(a, b);
 
1051
  }
 
1052
  private static void assertEqualsExactType(ImportEnumLite a,
 
1053
                                            ImportEnumLite b) {
 
1054
    Assert.assertEquals(a, b);
 
1055
  }
849
1056
 
850
1057
  /**
851
1058
   * Get an unmodifiable {@link ExtensionRegistry} containing all the
857
1064
    return registry.getUnmodifiable();
858
1065
  }
859
1066
 
 
1067
  public static ExtensionRegistryLite getExtensionRegistryLite() {
 
1068
    ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
 
1069
    registerAllExtensionsLite(registry);
 
1070
    return registry.getUnmodifiable();
 
1071
  }
 
1072
 
860
1073
  /**
861
 
   * Register all of {@code TestAllExtensions}' extensions with the
 
1074
   * Register all of {@code TestAllExtensions}'s extensions with the
862
1075
   * given {@link ExtensionRegistry}.
863
1076
   */
864
1077
  public static void registerAllExtensions(ExtensionRegistry registry) {
865
1078
    UnittestProto.registerAllExtensions(registry);
 
1079
    registerAllExtensionsLite(registry);
 
1080
  }
 
1081
 
 
1082
  public static void registerAllExtensionsLite(ExtensionRegistryLite registry) {
 
1083
    UnittestLite.registerAllExtensions(registry);
866
1084
  }
867
1085
 
868
1086
  /**
1509
1727
    assertEqualsExactType("525", message.getExtension(repeatedCordExtension, 1));
1510
1728
  }
1511
1729
 
1512
 
  /**
1513
 
   * Set every field of {@code message} to a unique value.
1514
 
   */
1515
 
  public static void setPackedFields(TestPackedTypes.Builder message) {
1516
 
    message.addPackedInt32   (601);
1517
 
    message.addPackedInt64   (602);
1518
 
    message.addPackedUint32  (603);
1519
 
    message.addPackedUint64  (604);
1520
 
    message.addPackedSint32  (605);
1521
 
    message.addPackedSint64  (606);
1522
 
    message.addPackedFixed32 (607);
1523
 
    message.addPackedFixed64 (608);
1524
 
    message.addPackedSfixed32(609);
1525
 
    message.addPackedSfixed64(610);
1526
 
    message.addPackedFloat   (611);
1527
 
    message.addPackedDouble  (612);
1528
 
    message.addPackedBool    (true);
1529
 
    message.addPackedEnum    (ForeignEnum.FOREIGN_BAR);
1530
 
    // Add a second one of each field.
1531
 
    message.addPackedInt32   (701);
1532
 
    message.addPackedInt64   (702);
1533
 
    message.addPackedUint32  (703);
1534
 
    message.addPackedUint64  (704);
1535
 
    message.addPackedSint32  (705);
1536
 
    message.addPackedSint64  (706);
1537
 
    message.addPackedFixed32 (707);
1538
 
    message.addPackedFixed64 (708);
1539
 
    message.addPackedSfixed32(709);
1540
 
    message.addPackedSfixed64(710);
1541
 
    message.addPackedFloat   (711);
1542
 
    message.addPackedDouble  (712);
1543
 
    message.addPackedBool    (false);
1544
 
    message.addPackedEnum    (ForeignEnum.FOREIGN_BAZ);
1545
 
  }
1546
 
 
1547
 
  /**
1548
 
   * Assert (using {@code junit.framework.Assert}} that all fields of
1549
 
   * {@code message} are set to the values assigned by {@code setPackedFields}.
1550
 
   */
1551
 
  public static void assertPackedFieldsSet(TestPackedTypes message) {
1552
 
    Assert.assertEquals(2, message.getPackedInt32Count   ());
1553
 
    Assert.assertEquals(2, message.getPackedInt64Count   ());
1554
 
    Assert.assertEquals(2, message.getPackedUint32Count  ());
1555
 
    Assert.assertEquals(2, message.getPackedUint64Count  ());
1556
 
    Assert.assertEquals(2, message.getPackedSint32Count  ());
1557
 
    Assert.assertEquals(2, message.getPackedSint64Count  ());
1558
 
    Assert.assertEquals(2, message.getPackedFixed32Count ());
1559
 
    Assert.assertEquals(2, message.getPackedFixed64Count ());
1560
 
    Assert.assertEquals(2, message.getPackedSfixed32Count());
1561
 
    Assert.assertEquals(2, message.getPackedSfixed64Count());
1562
 
    Assert.assertEquals(2, message.getPackedFloatCount   ());
1563
 
    Assert.assertEquals(2, message.getPackedDoubleCount  ());
1564
 
    Assert.assertEquals(2, message.getPackedBoolCount    ());
1565
 
    Assert.assertEquals(2, message.getPackedEnumCount   ());
1566
 
    Assert.assertEquals(601  , message.getPackedInt32   (0));
1567
 
    Assert.assertEquals(602  , message.getPackedInt64   (0));
1568
 
    Assert.assertEquals(603  , message.getPackedUint32  (0));
1569
 
    Assert.assertEquals(604  , message.getPackedUint64  (0));
1570
 
    Assert.assertEquals(605  , message.getPackedSint32  (0));
1571
 
    Assert.assertEquals(606  , message.getPackedSint64  (0));
1572
 
    Assert.assertEquals(607  , message.getPackedFixed32 (0));
1573
 
    Assert.assertEquals(608  , message.getPackedFixed64 (0));
1574
 
    Assert.assertEquals(609  , message.getPackedSfixed32(0));
1575
 
    Assert.assertEquals(610  , message.getPackedSfixed64(0));
1576
 
    Assert.assertEquals(611  , message.getPackedFloat   (0), 0.0);
1577
 
    Assert.assertEquals(612  , message.getPackedDouble  (0), 0.0);
1578
 
    Assert.assertEquals(true , message.getPackedBool    (0));
1579
 
    Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getPackedEnum(0));
1580
 
    Assert.assertEquals(701  , message.getPackedInt32   (1));
1581
 
    Assert.assertEquals(702  , message.getPackedInt64   (1));
1582
 
    Assert.assertEquals(703  , message.getPackedUint32  (1));
1583
 
    Assert.assertEquals(704  , message.getPackedUint64  (1));
1584
 
    Assert.assertEquals(705  , message.getPackedSint32  (1));
1585
 
    Assert.assertEquals(706  , message.getPackedSint64  (1));
1586
 
    Assert.assertEquals(707  , message.getPackedFixed32 (1));
1587
 
    Assert.assertEquals(708  , message.getPackedFixed64 (1));
1588
 
    Assert.assertEquals(709  , message.getPackedSfixed32(1));
1589
 
    Assert.assertEquals(710  , message.getPackedSfixed64(1));
1590
 
    Assert.assertEquals(711  , message.getPackedFloat   (1), 0.0);
1591
 
    Assert.assertEquals(712  , message.getPackedDouble  (1), 0.0);
1592
 
    Assert.assertEquals(false, message.getPackedBool    (1));
1593
 
    Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getPackedEnum(1));
1594
 
  }
1595
 
 
1596
1730
  public static void setPackedExtensions(TestPackedExtensions.Builder message) {
1597
1731
    message.addExtension(packedInt32Extension   , 601);
1598
1732
    message.addExtension(packedInt64Extension   , 602L);
1672
1806
                          message.getExtension(packedEnumExtension, 1));
1673
1807
  }
1674
1808
 
1675
 
 
1676
1809
  // ===================================================================
 
1810
  // Lite extensions
 
1811
 
 
1812
  /**
 
1813
   * Set every field of {@code message} to the values expected by
 
1814
   * {@code assertAllExtensionsSet()}.
 
1815
   */
 
1816
  public static void setAllExtensions(TestAllExtensionsLite.Builder message) {
 
1817
    message.setExtension(optionalInt32ExtensionLite   , 101);
 
1818
    message.setExtension(optionalInt64ExtensionLite   , 102L);
 
1819
    message.setExtension(optionalUint32ExtensionLite  , 103);
 
1820
    message.setExtension(optionalUint64ExtensionLite  , 104L);
 
1821
    message.setExtension(optionalSint32ExtensionLite  , 105);
 
1822
    message.setExtension(optionalSint64ExtensionLite  , 106L);
 
1823
    message.setExtension(optionalFixed32ExtensionLite , 107);
 
1824
    message.setExtension(optionalFixed64ExtensionLite , 108L);
 
1825
    message.setExtension(optionalSfixed32ExtensionLite, 109);
 
1826
    message.setExtension(optionalSfixed64ExtensionLite, 110L);
 
1827
    message.setExtension(optionalFloatExtensionLite   , 111F);
 
1828
    message.setExtension(optionalDoubleExtensionLite  , 112D);
 
1829
    message.setExtension(optionalBoolExtensionLite    , true);
 
1830
    message.setExtension(optionalStringExtensionLite  , "115");
 
1831
    message.setExtension(optionalBytesExtensionLite   , toBytes("116"));
 
1832
 
 
1833
    message.setExtension(optionalGroupExtensionLite,
 
1834
      OptionalGroup_extension_lite.newBuilder().setA(117).build());
 
1835
    message.setExtension(optionalNestedMessageExtensionLite,
 
1836
      TestAllTypesLite.NestedMessage.newBuilder().setBb(118).build());
 
1837
    message.setExtension(optionalForeignMessageExtensionLite,
 
1838
      ForeignMessageLite.newBuilder().setC(119).build());
 
1839
    message.setExtension(optionalImportMessageExtensionLite,
 
1840
      ImportMessageLite.newBuilder().setD(120).build());
 
1841
 
 
1842
    message.setExtension(optionalNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ);
 
1843
    message.setExtension(optionalForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ);
 
1844
    message.setExtension(optionalImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ);
 
1845
 
 
1846
    message.setExtension(optionalStringPieceExtensionLite, "124");
 
1847
    message.setExtension(optionalCordExtensionLite, "125");
 
1848
 
 
1849
    // -----------------------------------------------------------------
 
1850
 
 
1851
    message.addExtension(repeatedInt32ExtensionLite   , 201);
 
1852
    message.addExtension(repeatedInt64ExtensionLite   , 202L);
 
1853
    message.addExtension(repeatedUint32ExtensionLite  , 203);
 
1854
    message.addExtension(repeatedUint64ExtensionLite  , 204L);
 
1855
    message.addExtension(repeatedSint32ExtensionLite  , 205);
 
1856
    message.addExtension(repeatedSint64ExtensionLite  , 206L);
 
1857
    message.addExtension(repeatedFixed32ExtensionLite , 207);
 
1858
    message.addExtension(repeatedFixed64ExtensionLite , 208L);
 
1859
    message.addExtension(repeatedSfixed32ExtensionLite, 209);
 
1860
    message.addExtension(repeatedSfixed64ExtensionLite, 210L);
 
1861
    message.addExtension(repeatedFloatExtensionLite   , 211F);
 
1862
    message.addExtension(repeatedDoubleExtensionLite  , 212D);
 
1863
    message.addExtension(repeatedBoolExtensionLite    , true);
 
1864
    message.addExtension(repeatedStringExtensionLite  , "215");
 
1865
    message.addExtension(repeatedBytesExtensionLite   , toBytes("216"));
 
1866
 
 
1867
    message.addExtension(repeatedGroupExtensionLite,
 
1868
      RepeatedGroup_extension_lite.newBuilder().setA(217).build());
 
1869
    message.addExtension(repeatedNestedMessageExtensionLite,
 
1870
      TestAllTypesLite.NestedMessage.newBuilder().setBb(218).build());
 
1871
    message.addExtension(repeatedForeignMessageExtensionLite,
 
1872
      ForeignMessageLite.newBuilder().setC(219).build());
 
1873
    message.addExtension(repeatedImportMessageExtensionLite,
 
1874
      ImportMessageLite.newBuilder().setD(220).build());
 
1875
 
 
1876
    message.addExtension(repeatedNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAR);
 
1877
    message.addExtension(repeatedForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAR);
 
1878
    message.addExtension(repeatedImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAR);
 
1879
 
 
1880
    message.addExtension(repeatedStringPieceExtensionLite, "224");
 
1881
    message.addExtension(repeatedCordExtensionLite, "225");
 
1882
 
 
1883
    // Add a second one of each field.
 
1884
    message.addExtension(repeatedInt32ExtensionLite   , 301);
 
1885
    message.addExtension(repeatedInt64ExtensionLite   , 302L);
 
1886
    message.addExtension(repeatedUint32ExtensionLite  , 303);
 
1887
    message.addExtension(repeatedUint64ExtensionLite  , 304L);
 
1888
    message.addExtension(repeatedSint32ExtensionLite  , 305);
 
1889
    message.addExtension(repeatedSint64ExtensionLite  , 306L);
 
1890
    message.addExtension(repeatedFixed32ExtensionLite , 307);
 
1891
    message.addExtension(repeatedFixed64ExtensionLite , 308L);
 
1892
    message.addExtension(repeatedSfixed32ExtensionLite, 309);
 
1893
    message.addExtension(repeatedSfixed64ExtensionLite, 310L);
 
1894
    message.addExtension(repeatedFloatExtensionLite   , 311F);
 
1895
    message.addExtension(repeatedDoubleExtensionLite  , 312D);
 
1896
    message.addExtension(repeatedBoolExtensionLite    , false);
 
1897
    message.addExtension(repeatedStringExtensionLite  , "315");
 
1898
    message.addExtension(repeatedBytesExtensionLite   , toBytes("316"));
 
1899
 
 
1900
    message.addExtension(repeatedGroupExtensionLite,
 
1901
      RepeatedGroup_extension_lite.newBuilder().setA(317).build());
 
1902
    message.addExtension(repeatedNestedMessageExtensionLite,
 
1903
      TestAllTypesLite.NestedMessage.newBuilder().setBb(318).build());
 
1904
    message.addExtension(repeatedForeignMessageExtensionLite,
 
1905
      ForeignMessageLite.newBuilder().setC(319).build());
 
1906
    message.addExtension(repeatedImportMessageExtensionLite,
 
1907
      ImportMessageLite.newBuilder().setD(320).build());
 
1908
 
 
1909
    message.addExtension(repeatedNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ);
 
1910
    message.addExtension(repeatedForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ);
 
1911
    message.addExtension(repeatedImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ);
 
1912
 
 
1913
    message.addExtension(repeatedStringPieceExtensionLite, "324");
 
1914
    message.addExtension(repeatedCordExtensionLite, "325");
 
1915
 
 
1916
    // -----------------------------------------------------------------
 
1917
 
 
1918
    message.setExtension(defaultInt32ExtensionLite   , 401);
 
1919
    message.setExtension(defaultInt64ExtensionLite   , 402L);
 
1920
    message.setExtension(defaultUint32ExtensionLite  , 403);
 
1921
    message.setExtension(defaultUint64ExtensionLite  , 404L);
 
1922
    message.setExtension(defaultSint32ExtensionLite  , 405);
 
1923
    message.setExtension(defaultSint64ExtensionLite  , 406L);
 
1924
    message.setExtension(defaultFixed32ExtensionLite , 407);
 
1925
    message.setExtension(defaultFixed64ExtensionLite , 408L);
 
1926
    message.setExtension(defaultSfixed32ExtensionLite, 409);
 
1927
    message.setExtension(defaultSfixed64ExtensionLite, 410L);
 
1928
    message.setExtension(defaultFloatExtensionLite   , 411F);
 
1929
    message.setExtension(defaultDoubleExtensionLite  , 412D);
 
1930
    message.setExtension(defaultBoolExtensionLite    , false);
 
1931
    message.setExtension(defaultStringExtensionLite  , "415");
 
1932
    message.setExtension(defaultBytesExtensionLite   , toBytes("416"));
 
1933
 
 
1934
    message.setExtension(defaultNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.FOO);
 
1935
    message.setExtension(defaultForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_FOO);
 
1936
    message.setExtension(defaultImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_FOO);
 
1937
 
 
1938
    message.setExtension(defaultStringPieceExtensionLite, "424");
 
1939
    message.setExtension(defaultCordExtensionLite, "425");
 
1940
  }
 
1941
 
 
1942
  // -------------------------------------------------------------------
 
1943
 
 
1944
  /**
 
1945
   * Modify the repeated extensions of {@code message} to contain the values
 
1946
   * expected by {@code assertRepeatedExtensionsModified()}.
 
1947
   */
 
1948
  public static void modifyRepeatedExtensions(
 
1949
      TestAllExtensionsLite.Builder message) {
 
1950
    message.setExtension(repeatedInt32ExtensionLite   , 1, 501);
 
1951
    message.setExtension(repeatedInt64ExtensionLite   , 1, 502L);
 
1952
    message.setExtension(repeatedUint32ExtensionLite  , 1, 503);
 
1953
    message.setExtension(repeatedUint64ExtensionLite  , 1, 504L);
 
1954
    message.setExtension(repeatedSint32ExtensionLite  , 1, 505);
 
1955
    message.setExtension(repeatedSint64ExtensionLite  , 1, 506L);
 
1956
    message.setExtension(repeatedFixed32ExtensionLite , 1, 507);
 
1957
    message.setExtension(repeatedFixed64ExtensionLite , 1, 508L);
 
1958
    message.setExtension(repeatedSfixed32ExtensionLite, 1, 509);
 
1959
    message.setExtension(repeatedSfixed64ExtensionLite, 1, 510L);
 
1960
    message.setExtension(repeatedFloatExtensionLite   , 1, 511F);
 
1961
    message.setExtension(repeatedDoubleExtensionLite  , 1, 512D);
 
1962
    message.setExtension(repeatedBoolExtensionLite    , 1, true);
 
1963
    message.setExtension(repeatedStringExtensionLite  , 1, "515");
 
1964
    message.setExtension(repeatedBytesExtensionLite   , 1, toBytes("516"));
 
1965
 
 
1966
    message.setExtension(repeatedGroupExtensionLite, 1,
 
1967
      RepeatedGroup_extension_lite.newBuilder().setA(517).build());
 
1968
    message.setExtension(repeatedNestedMessageExtensionLite, 1,
 
1969
      TestAllTypesLite.NestedMessage.newBuilder().setBb(518).build());
 
1970
    message.setExtension(repeatedForeignMessageExtensionLite, 1,
 
1971
      ForeignMessageLite.newBuilder().setC(519).build());
 
1972
    message.setExtension(repeatedImportMessageExtensionLite, 1,
 
1973
      ImportMessageLite.newBuilder().setD(520).build());
 
1974
 
 
1975
    message.setExtension(repeatedNestedEnumExtensionLite , 1, TestAllTypesLite.NestedEnum.FOO);
 
1976
    message.setExtension(repeatedForeignEnumExtensionLite, 1, ForeignEnumLite.FOREIGN_LITE_FOO);
 
1977
    message.setExtension(repeatedImportEnumExtensionLite , 1, ImportEnumLite.IMPORT_LITE_FOO);
 
1978
 
 
1979
    message.setExtension(repeatedStringPieceExtensionLite, 1, "524");
 
1980
    message.setExtension(repeatedCordExtensionLite, 1, "525");
 
1981
  }
 
1982
 
 
1983
  // -------------------------------------------------------------------
 
1984
 
 
1985
  /**
 
1986
   * Assert (using {@code junit.framework.Assert}} that all extensions of
 
1987
   * {@code message} are set to the values assigned by {@code setAllExtensions}.
 
1988
   */
 
1989
  public static void assertAllExtensionsSet(TestAllExtensionsLite message) {
 
1990
    Assert.assertTrue(message.hasExtension(optionalInt32ExtensionLite   ));
 
1991
    Assert.assertTrue(message.hasExtension(optionalInt64ExtensionLite   ));
 
1992
    Assert.assertTrue(message.hasExtension(optionalUint32ExtensionLite  ));
 
1993
    Assert.assertTrue(message.hasExtension(optionalUint64ExtensionLite  ));
 
1994
    Assert.assertTrue(message.hasExtension(optionalSint32ExtensionLite  ));
 
1995
    Assert.assertTrue(message.hasExtension(optionalSint64ExtensionLite  ));
 
1996
    Assert.assertTrue(message.hasExtension(optionalFixed32ExtensionLite ));
 
1997
    Assert.assertTrue(message.hasExtension(optionalFixed64ExtensionLite ));
 
1998
    Assert.assertTrue(message.hasExtension(optionalSfixed32ExtensionLite));
 
1999
    Assert.assertTrue(message.hasExtension(optionalSfixed64ExtensionLite));
 
2000
    Assert.assertTrue(message.hasExtension(optionalFloatExtensionLite   ));
 
2001
    Assert.assertTrue(message.hasExtension(optionalDoubleExtensionLite  ));
 
2002
    Assert.assertTrue(message.hasExtension(optionalBoolExtensionLite    ));
 
2003
    Assert.assertTrue(message.hasExtension(optionalStringExtensionLite  ));
 
2004
    Assert.assertTrue(message.hasExtension(optionalBytesExtensionLite   ));
 
2005
 
 
2006
    Assert.assertTrue(message.hasExtension(optionalGroupExtensionLite         ));
 
2007
    Assert.assertTrue(message.hasExtension(optionalNestedMessageExtensionLite ));
 
2008
    Assert.assertTrue(message.hasExtension(optionalForeignMessageExtensionLite));
 
2009
    Assert.assertTrue(message.hasExtension(optionalImportMessageExtensionLite ));
 
2010
 
 
2011
    Assert.assertTrue(message.getExtension(optionalGroupExtensionLite         ).hasA());
 
2012
    Assert.assertTrue(message.getExtension(optionalNestedMessageExtensionLite ).hasBb());
 
2013
    Assert.assertTrue(message.getExtension(optionalForeignMessageExtensionLite).hasC());
 
2014
    Assert.assertTrue(message.getExtension(optionalImportMessageExtensionLite ).hasD());
 
2015
 
 
2016
    Assert.assertTrue(message.hasExtension(optionalNestedEnumExtensionLite ));
 
2017
    Assert.assertTrue(message.hasExtension(optionalForeignEnumExtensionLite));
 
2018
    Assert.assertTrue(message.hasExtension(optionalImportEnumExtensionLite ));
 
2019
 
 
2020
    Assert.assertTrue(message.hasExtension(optionalStringPieceExtensionLite));
 
2021
    Assert.assertTrue(message.hasExtension(optionalCordExtensionLite));
 
2022
 
 
2023
    assertEqualsExactType(101  , message.getExtension(optionalInt32ExtensionLite   ));
 
2024
    assertEqualsExactType(102L , message.getExtension(optionalInt64ExtensionLite   ));
 
2025
    assertEqualsExactType(103  , message.getExtension(optionalUint32ExtensionLite  ));
 
2026
    assertEqualsExactType(104L , message.getExtension(optionalUint64ExtensionLite  ));
 
2027
    assertEqualsExactType(105  , message.getExtension(optionalSint32ExtensionLite  ));
 
2028
    assertEqualsExactType(106L , message.getExtension(optionalSint64ExtensionLite  ));
 
2029
    assertEqualsExactType(107  , message.getExtension(optionalFixed32ExtensionLite ));
 
2030
    assertEqualsExactType(108L , message.getExtension(optionalFixed64ExtensionLite ));
 
2031
    assertEqualsExactType(109  , message.getExtension(optionalSfixed32ExtensionLite));
 
2032
    assertEqualsExactType(110L , message.getExtension(optionalSfixed64ExtensionLite));
 
2033
    assertEqualsExactType(111F , message.getExtension(optionalFloatExtensionLite   ));
 
2034
    assertEqualsExactType(112D , message.getExtension(optionalDoubleExtensionLite  ));
 
2035
    assertEqualsExactType(true , message.getExtension(optionalBoolExtensionLite    ));
 
2036
    assertEqualsExactType("115", message.getExtension(optionalStringExtensionLite  ));
 
2037
    assertEqualsExactType(toBytes("116"), message.getExtension(optionalBytesExtensionLite));
 
2038
 
 
2039
    assertEqualsExactType(117, message.getExtension(optionalGroupExtensionLite         ).getA());
 
2040
    assertEqualsExactType(118, message.getExtension(optionalNestedMessageExtensionLite ).getBb());
 
2041
    assertEqualsExactType(119, message.getExtension(optionalForeignMessageExtensionLite).getC());
 
2042
    assertEqualsExactType(120, message.getExtension(optionalImportMessageExtensionLite ).getD());
 
2043
 
 
2044
    assertEqualsExactType(TestAllTypesLite.NestedEnum.BAZ,
 
2045
      message.getExtension(optionalNestedEnumExtensionLite));
 
2046
    assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAZ,
 
2047
      message.getExtension(optionalForeignEnumExtensionLite));
 
2048
    assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAZ,
 
2049
      message.getExtension(optionalImportEnumExtensionLite));
 
2050
 
 
2051
    assertEqualsExactType("124", message.getExtension(optionalStringPieceExtensionLite));
 
2052
    assertEqualsExactType("125", message.getExtension(optionalCordExtensionLite));
 
2053
 
 
2054
    // -----------------------------------------------------------------
 
2055
 
 
2056
    Assert.assertEquals(2, message.getExtensionCount(repeatedInt32ExtensionLite   ));
 
2057
    Assert.assertEquals(2, message.getExtensionCount(repeatedInt64ExtensionLite   ));
 
2058
    Assert.assertEquals(2, message.getExtensionCount(repeatedUint32ExtensionLite  ));
 
2059
    Assert.assertEquals(2, message.getExtensionCount(repeatedUint64ExtensionLite  ));
 
2060
    Assert.assertEquals(2, message.getExtensionCount(repeatedSint32ExtensionLite  ));
 
2061
    Assert.assertEquals(2, message.getExtensionCount(repeatedSint64ExtensionLite  ));
 
2062
    Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32ExtensionLite ));
 
2063
    Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64ExtensionLite ));
 
2064
    Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32ExtensionLite));
 
2065
    Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64ExtensionLite));
 
2066
    Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtensionLite   ));
 
2067
    Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtensionLite  ));
 
2068
    Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtensionLite    ));
 
2069
    Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtensionLite  ));
 
2070
    Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtensionLite   ));
 
2071
 
 
2072
    Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtensionLite         ));
 
2073
    Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtensionLite ));
 
2074
    Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtensionLite));
 
2075
    Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtensionLite ));
 
2076
    Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtensionLite    ));
 
2077
    Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtensionLite   ));
 
2078
    Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtensionLite    ));
 
2079
 
 
2080
    Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtensionLite));
 
2081
    Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtensionLite));
 
2082
 
 
2083
    assertEqualsExactType(201  , message.getExtension(repeatedInt32ExtensionLite   , 0));
 
2084
    assertEqualsExactType(202L , message.getExtension(repeatedInt64ExtensionLite   , 0));
 
2085
    assertEqualsExactType(203  , message.getExtension(repeatedUint32ExtensionLite  , 0));
 
2086
    assertEqualsExactType(204L , message.getExtension(repeatedUint64ExtensionLite  , 0));
 
2087
    assertEqualsExactType(205  , message.getExtension(repeatedSint32ExtensionLite  , 0));
 
2088
    assertEqualsExactType(206L , message.getExtension(repeatedSint64ExtensionLite  , 0));
 
2089
    assertEqualsExactType(207  , message.getExtension(repeatedFixed32ExtensionLite , 0));
 
2090
    assertEqualsExactType(208L , message.getExtension(repeatedFixed64ExtensionLite , 0));
 
2091
    assertEqualsExactType(209  , message.getExtension(repeatedSfixed32ExtensionLite, 0));
 
2092
    assertEqualsExactType(210L , message.getExtension(repeatedSfixed64ExtensionLite, 0));
 
2093
    assertEqualsExactType(211F , message.getExtension(repeatedFloatExtensionLite   , 0));
 
2094
    assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtensionLite  , 0));
 
2095
    assertEqualsExactType(true , message.getExtension(repeatedBoolExtensionLite    , 0));
 
2096
    assertEqualsExactType("215", message.getExtension(repeatedStringExtensionLite  , 0));
 
2097
    assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtensionLite, 0));
 
2098
 
 
2099
    assertEqualsExactType(217, message.getExtension(repeatedGroupExtensionLite         ,0).getA());
 
2100
    assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtensionLite ,0).getBb());
 
2101
    assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtensionLite,0).getC());
 
2102
    assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtensionLite ,0).getD());
 
2103
 
 
2104
    assertEqualsExactType(TestAllTypesLite.NestedEnum.BAR,
 
2105
      message.getExtension(repeatedNestedEnumExtensionLite, 0));
 
2106
    assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAR,
 
2107
      message.getExtension(repeatedForeignEnumExtensionLite, 0));
 
2108
    assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAR,
 
2109
      message.getExtension(repeatedImportEnumExtensionLite, 0));
 
2110
 
 
2111
    assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtensionLite, 0));
 
2112
    assertEqualsExactType("225", message.getExtension(repeatedCordExtensionLite, 0));
 
2113
 
 
2114
    assertEqualsExactType(301  , message.getExtension(repeatedInt32ExtensionLite   , 1));
 
2115
    assertEqualsExactType(302L , message.getExtension(repeatedInt64ExtensionLite   , 1));
 
2116
    assertEqualsExactType(303  , message.getExtension(repeatedUint32ExtensionLite  , 1));
 
2117
    assertEqualsExactType(304L , message.getExtension(repeatedUint64ExtensionLite  , 1));
 
2118
    assertEqualsExactType(305  , message.getExtension(repeatedSint32ExtensionLite  , 1));
 
2119
    assertEqualsExactType(306L , message.getExtension(repeatedSint64ExtensionLite  , 1));
 
2120
    assertEqualsExactType(307  , message.getExtension(repeatedFixed32ExtensionLite , 1));
 
2121
    assertEqualsExactType(308L , message.getExtension(repeatedFixed64ExtensionLite , 1));
 
2122
    assertEqualsExactType(309  , message.getExtension(repeatedSfixed32ExtensionLite, 1));
 
2123
    assertEqualsExactType(310L , message.getExtension(repeatedSfixed64ExtensionLite, 1));
 
2124
    assertEqualsExactType(311F , message.getExtension(repeatedFloatExtensionLite   , 1));
 
2125
    assertEqualsExactType(312D , message.getExtension(repeatedDoubleExtensionLite  , 1));
 
2126
    assertEqualsExactType(false, message.getExtension(repeatedBoolExtensionLite    , 1));
 
2127
    assertEqualsExactType("315", message.getExtension(repeatedStringExtensionLite  , 1));
 
2128
    assertEqualsExactType(toBytes("316"), message.getExtension(repeatedBytesExtensionLite, 1));
 
2129
 
 
2130
    assertEqualsExactType(317, message.getExtension(repeatedGroupExtensionLite         ,1).getA());
 
2131
    assertEqualsExactType(318, message.getExtension(repeatedNestedMessageExtensionLite ,1).getBb());
 
2132
    assertEqualsExactType(319, message.getExtension(repeatedForeignMessageExtensionLite,1).getC());
 
2133
    assertEqualsExactType(320, message.getExtension(repeatedImportMessageExtensionLite ,1).getD());
 
2134
 
 
2135
    assertEqualsExactType(TestAllTypesLite.NestedEnum.BAZ,
 
2136
      message.getExtension(repeatedNestedEnumExtensionLite, 1));
 
2137
    assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAZ,
 
2138
      message.getExtension(repeatedForeignEnumExtensionLite, 1));
 
2139
    assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAZ,
 
2140
      message.getExtension(repeatedImportEnumExtensionLite, 1));
 
2141
 
 
2142
    assertEqualsExactType("324", message.getExtension(repeatedStringPieceExtensionLite, 1));
 
2143
    assertEqualsExactType("325", message.getExtension(repeatedCordExtensionLite, 1));
 
2144
 
 
2145
    // -----------------------------------------------------------------
 
2146
 
 
2147
    Assert.assertTrue(message.hasExtension(defaultInt32ExtensionLite   ));
 
2148
    Assert.assertTrue(message.hasExtension(defaultInt64ExtensionLite   ));
 
2149
    Assert.assertTrue(message.hasExtension(defaultUint32ExtensionLite  ));
 
2150
    Assert.assertTrue(message.hasExtension(defaultUint64ExtensionLite  ));
 
2151
    Assert.assertTrue(message.hasExtension(defaultSint32ExtensionLite  ));
 
2152
    Assert.assertTrue(message.hasExtension(defaultSint64ExtensionLite  ));
 
2153
    Assert.assertTrue(message.hasExtension(defaultFixed32ExtensionLite ));
 
2154
    Assert.assertTrue(message.hasExtension(defaultFixed64ExtensionLite ));
 
2155
    Assert.assertTrue(message.hasExtension(defaultSfixed32ExtensionLite));
 
2156
    Assert.assertTrue(message.hasExtension(defaultSfixed64ExtensionLite));
 
2157
    Assert.assertTrue(message.hasExtension(defaultFloatExtensionLite   ));
 
2158
    Assert.assertTrue(message.hasExtension(defaultDoubleExtensionLite  ));
 
2159
    Assert.assertTrue(message.hasExtension(defaultBoolExtensionLite    ));
 
2160
    Assert.assertTrue(message.hasExtension(defaultStringExtensionLite  ));
 
2161
    Assert.assertTrue(message.hasExtension(defaultBytesExtensionLite   ));
 
2162
 
 
2163
    Assert.assertTrue(message.hasExtension(defaultNestedEnumExtensionLite ));
 
2164
    Assert.assertTrue(message.hasExtension(defaultForeignEnumExtensionLite));
 
2165
    Assert.assertTrue(message.hasExtension(defaultImportEnumExtensionLite ));
 
2166
 
 
2167
    Assert.assertTrue(message.hasExtension(defaultStringPieceExtensionLite));
 
2168
    Assert.assertTrue(message.hasExtension(defaultCordExtensionLite));
 
2169
 
 
2170
    assertEqualsExactType(401  , message.getExtension(defaultInt32ExtensionLite   ));
 
2171
    assertEqualsExactType(402L , message.getExtension(defaultInt64ExtensionLite   ));
 
2172
    assertEqualsExactType(403  , message.getExtension(defaultUint32ExtensionLite  ));
 
2173
    assertEqualsExactType(404L , message.getExtension(defaultUint64ExtensionLite  ));
 
2174
    assertEqualsExactType(405  , message.getExtension(defaultSint32ExtensionLite  ));
 
2175
    assertEqualsExactType(406L , message.getExtension(defaultSint64ExtensionLite  ));
 
2176
    assertEqualsExactType(407  , message.getExtension(defaultFixed32ExtensionLite ));
 
2177
    assertEqualsExactType(408L , message.getExtension(defaultFixed64ExtensionLite ));
 
2178
    assertEqualsExactType(409  , message.getExtension(defaultSfixed32ExtensionLite));
 
2179
    assertEqualsExactType(410L , message.getExtension(defaultSfixed64ExtensionLite));
 
2180
    assertEqualsExactType(411F , message.getExtension(defaultFloatExtensionLite   ));
 
2181
    assertEqualsExactType(412D , message.getExtension(defaultDoubleExtensionLite  ));
 
2182
    assertEqualsExactType(false, message.getExtension(defaultBoolExtensionLite    ));
 
2183
    assertEqualsExactType("415", message.getExtension(defaultStringExtensionLite  ));
 
2184
    assertEqualsExactType(toBytes("416"), message.getExtension(defaultBytesExtensionLite));
 
2185
 
 
2186
    assertEqualsExactType(TestAllTypesLite.NestedEnum.FOO,
 
2187
      message.getExtension(defaultNestedEnumExtensionLite ));
 
2188
    assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_FOO,
 
2189
      message.getExtension(defaultForeignEnumExtensionLite));
 
2190
    assertEqualsExactType(ImportEnumLite.IMPORT_LITE_FOO,
 
2191
      message.getExtension(defaultImportEnumExtensionLite));
 
2192
 
 
2193
    assertEqualsExactType("424", message.getExtension(defaultStringPieceExtensionLite));
 
2194
    assertEqualsExactType("425", message.getExtension(defaultCordExtensionLite));
 
2195
  }
 
2196
 
 
2197
  // -------------------------------------------------------------------
 
2198
 
 
2199
  /**
 
2200
   * Assert (using {@code junit.framework.Assert}} that all extensions of
 
2201
   * {@code message} are cleared, and that getting the extensions returns their
 
2202
   * default values.
 
2203
   */
 
2204
  public static void assertExtensionsClear(TestAllExtensionsLite message) {
 
2205
    // hasBlah() should initially be false for all optional fields.
 
2206
    Assert.assertFalse(message.hasExtension(optionalInt32ExtensionLite   ));
 
2207
    Assert.assertFalse(message.hasExtension(optionalInt64ExtensionLite   ));
 
2208
    Assert.assertFalse(message.hasExtension(optionalUint32ExtensionLite  ));
 
2209
    Assert.assertFalse(message.hasExtension(optionalUint64ExtensionLite  ));
 
2210
    Assert.assertFalse(message.hasExtension(optionalSint32ExtensionLite  ));
 
2211
    Assert.assertFalse(message.hasExtension(optionalSint64ExtensionLite  ));
 
2212
    Assert.assertFalse(message.hasExtension(optionalFixed32ExtensionLite ));
 
2213
    Assert.assertFalse(message.hasExtension(optionalFixed64ExtensionLite ));
 
2214
    Assert.assertFalse(message.hasExtension(optionalSfixed32ExtensionLite));
 
2215
    Assert.assertFalse(message.hasExtension(optionalSfixed64ExtensionLite));
 
2216
    Assert.assertFalse(message.hasExtension(optionalFloatExtensionLite   ));
 
2217
    Assert.assertFalse(message.hasExtension(optionalDoubleExtensionLite  ));
 
2218
    Assert.assertFalse(message.hasExtension(optionalBoolExtensionLite    ));
 
2219
    Assert.assertFalse(message.hasExtension(optionalStringExtensionLite  ));
 
2220
    Assert.assertFalse(message.hasExtension(optionalBytesExtensionLite   ));
 
2221
 
 
2222
    Assert.assertFalse(message.hasExtension(optionalGroupExtensionLite         ));
 
2223
    Assert.assertFalse(message.hasExtension(optionalNestedMessageExtensionLite ));
 
2224
    Assert.assertFalse(message.hasExtension(optionalForeignMessageExtensionLite));
 
2225
    Assert.assertFalse(message.hasExtension(optionalImportMessageExtensionLite ));
 
2226
 
 
2227
    Assert.assertFalse(message.hasExtension(optionalNestedEnumExtensionLite ));
 
2228
    Assert.assertFalse(message.hasExtension(optionalForeignEnumExtensionLite));
 
2229
    Assert.assertFalse(message.hasExtension(optionalImportEnumExtensionLite ));
 
2230
 
 
2231
    Assert.assertFalse(message.hasExtension(optionalStringPieceExtensionLite));
 
2232
    Assert.assertFalse(message.hasExtension(optionalCordExtensionLite));
 
2233
 
 
2234
    // Optional fields without defaults are set to zero or something like it.
 
2235
    assertEqualsExactType(0    , message.getExtension(optionalInt32ExtensionLite   ));
 
2236
    assertEqualsExactType(0L   , message.getExtension(optionalInt64ExtensionLite   ));
 
2237
    assertEqualsExactType(0    , message.getExtension(optionalUint32ExtensionLite  ));
 
2238
    assertEqualsExactType(0L   , message.getExtension(optionalUint64ExtensionLite  ));
 
2239
    assertEqualsExactType(0    , message.getExtension(optionalSint32ExtensionLite  ));
 
2240
    assertEqualsExactType(0L   , message.getExtension(optionalSint64ExtensionLite  ));
 
2241
    assertEqualsExactType(0    , message.getExtension(optionalFixed32ExtensionLite ));
 
2242
    assertEqualsExactType(0L   , message.getExtension(optionalFixed64ExtensionLite ));
 
2243
    assertEqualsExactType(0    , message.getExtension(optionalSfixed32ExtensionLite));
 
2244
    assertEqualsExactType(0L   , message.getExtension(optionalSfixed64ExtensionLite));
 
2245
    assertEqualsExactType(0F   , message.getExtension(optionalFloatExtensionLite   ));
 
2246
    assertEqualsExactType(0D   , message.getExtension(optionalDoubleExtensionLite  ));
 
2247
    assertEqualsExactType(false, message.getExtension(optionalBoolExtensionLite    ));
 
2248
    assertEqualsExactType(""   , message.getExtension(optionalStringExtensionLite  ));
 
2249
    assertEqualsExactType(ByteString.EMPTY, message.getExtension(optionalBytesExtensionLite));
 
2250
 
 
2251
    // Embedded messages should also be clear.
 
2252
    Assert.assertFalse(message.getExtension(optionalGroupExtensionLite         ).hasA());
 
2253
    Assert.assertFalse(message.getExtension(optionalNestedMessageExtensionLite ).hasBb());
 
2254
    Assert.assertFalse(message.getExtension(optionalForeignMessageExtensionLite).hasC());
 
2255
    Assert.assertFalse(message.getExtension(optionalImportMessageExtensionLite ).hasD());
 
2256
 
 
2257
    assertEqualsExactType(0, message.getExtension(optionalGroupExtensionLite         ).getA());
 
2258
    assertEqualsExactType(0, message.getExtension(optionalNestedMessageExtensionLite ).getBb());
 
2259
    assertEqualsExactType(0, message.getExtension(optionalForeignMessageExtensionLite).getC());
 
2260
    assertEqualsExactType(0, message.getExtension(optionalImportMessageExtensionLite ).getD());
 
2261
 
 
2262
    // Enums without defaults are set to the first value in the enum.
 
2263
    assertEqualsExactType(TestAllTypesLite.NestedEnum.FOO,
 
2264
      message.getExtension(optionalNestedEnumExtensionLite ));
 
2265
    assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_FOO,
 
2266
      message.getExtension(optionalForeignEnumExtensionLite));
 
2267
    assertEqualsExactType(ImportEnumLite.IMPORT_LITE_FOO,
 
2268
      message.getExtension(optionalImportEnumExtensionLite));
 
2269
 
 
2270
    assertEqualsExactType("", message.getExtension(optionalStringPieceExtensionLite));
 
2271
    assertEqualsExactType("", message.getExtension(optionalCordExtensionLite));
 
2272
 
 
2273
    // Repeated fields are empty.
 
2274
    Assert.assertEquals(0, message.getExtensionCount(repeatedInt32ExtensionLite   ));
 
2275
    Assert.assertEquals(0, message.getExtensionCount(repeatedInt64ExtensionLite   ));
 
2276
    Assert.assertEquals(0, message.getExtensionCount(repeatedUint32ExtensionLite  ));
 
2277
    Assert.assertEquals(0, message.getExtensionCount(repeatedUint64ExtensionLite  ));
 
2278
    Assert.assertEquals(0, message.getExtensionCount(repeatedSint32ExtensionLite  ));
 
2279
    Assert.assertEquals(0, message.getExtensionCount(repeatedSint64ExtensionLite  ));
 
2280
    Assert.assertEquals(0, message.getExtensionCount(repeatedFixed32ExtensionLite ));
 
2281
    Assert.assertEquals(0, message.getExtensionCount(repeatedFixed64ExtensionLite ));
 
2282
    Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed32ExtensionLite));
 
2283
    Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed64ExtensionLite));
 
2284
    Assert.assertEquals(0, message.getExtensionCount(repeatedFloatExtensionLite   ));
 
2285
    Assert.assertEquals(0, message.getExtensionCount(repeatedDoubleExtensionLite  ));
 
2286
    Assert.assertEquals(0, message.getExtensionCount(repeatedBoolExtensionLite    ));
 
2287
    Assert.assertEquals(0, message.getExtensionCount(repeatedStringExtensionLite  ));
 
2288
    Assert.assertEquals(0, message.getExtensionCount(repeatedBytesExtensionLite   ));
 
2289
 
 
2290
    Assert.assertEquals(0, message.getExtensionCount(repeatedGroupExtensionLite         ));
 
2291
    Assert.assertEquals(0, message.getExtensionCount(repeatedNestedMessageExtensionLite ));
 
2292
    Assert.assertEquals(0, message.getExtensionCount(repeatedForeignMessageExtensionLite));
 
2293
    Assert.assertEquals(0, message.getExtensionCount(repeatedImportMessageExtensionLite ));
 
2294
    Assert.assertEquals(0, message.getExtensionCount(repeatedNestedEnumExtensionLite    ));
 
2295
    Assert.assertEquals(0, message.getExtensionCount(repeatedForeignEnumExtensionLite   ));
 
2296
    Assert.assertEquals(0, message.getExtensionCount(repeatedImportEnumExtensionLite    ));
 
2297
 
 
2298
    Assert.assertEquals(0, message.getExtensionCount(repeatedStringPieceExtensionLite));
 
2299
    Assert.assertEquals(0, message.getExtensionCount(repeatedCordExtensionLite));
 
2300
 
 
2301
    // hasBlah() should also be false for all default fields.
 
2302
    Assert.assertFalse(message.hasExtension(defaultInt32ExtensionLite   ));
 
2303
    Assert.assertFalse(message.hasExtension(defaultInt64ExtensionLite   ));
 
2304
    Assert.assertFalse(message.hasExtension(defaultUint32ExtensionLite  ));
 
2305
    Assert.assertFalse(message.hasExtension(defaultUint64ExtensionLite  ));
 
2306
    Assert.assertFalse(message.hasExtension(defaultSint32ExtensionLite  ));
 
2307
    Assert.assertFalse(message.hasExtension(defaultSint64ExtensionLite  ));
 
2308
    Assert.assertFalse(message.hasExtension(defaultFixed32ExtensionLite ));
 
2309
    Assert.assertFalse(message.hasExtension(defaultFixed64ExtensionLite ));
 
2310
    Assert.assertFalse(message.hasExtension(defaultSfixed32ExtensionLite));
 
2311
    Assert.assertFalse(message.hasExtension(defaultSfixed64ExtensionLite));
 
2312
    Assert.assertFalse(message.hasExtension(defaultFloatExtensionLite   ));
 
2313
    Assert.assertFalse(message.hasExtension(defaultDoubleExtensionLite  ));
 
2314
    Assert.assertFalse(message.hasExtension(defaultBoolExtensionLite    ));
 
2315
    Assert.assertFalse(message.hasExtension(defaultStringExtensionLite  ));
 
2316
    Assert.assertFalse(message.hasExtension(defaultBytesExtensionLite   ));
 
2317
 
 
2318
    Assert.assertFalse(message.hasExtension(defaultNestedEnumExtensionLite ));
 
2319
    Assert.assertFalse(message.hasExtension(defaultForeignEnumExtensionLite));
 
2320
    Assert.assertFalse(message.hasExtension(defaultImportEnumExtensionLite ));
 
2321
 
 
2322
    Assert.assertFalse(message.hasExtension(defaultStringPieceExtensionLite));
 
2323
    Assert.assertFalse(message.hasExtension(defaultCordExtensionLite));
 
2324
 
 
2325
    // Fields with defaults have their default values (duh).
 
2326
    assertEqualsExactType( 41    , message.getExtension(defaultInt32ExtensionLite   ));
 
2327
    assertEqualsExactType( 42L   , message.getExtension(defaultInt64ExtensionLite   ));
 
2328
    assertEqualsExactType( 43    , message.getExtension(defaultUint32ExtensionLite  ));
 
2329
    assertEqualsExactType( 44L   , message.getExtension(defaultUint64ExtensionLite  ));
 
2330
    assertEqualsExactType(-45    , message.getExtension(defaultSint32ExtensionLite  ));
 
2331
    assertEqualsExactType( 46L   , message.getExtension(defaultSint64ExtensionLite  ));
 
2332
    assertEqualsExactType( 47    , message.getExtension(defaultFixed32ExtensionLite ));
 
2333
    assertEqualsExactType( 48L   , message.getExtension(defaultFixed64ExtensionLite ));
 
2334
    assertEqualsExactType( 49    , message.getExtension(defaultSfixed32ExtensionLite));
 
2335
    assertEqualsExactType(-50L   , message.getExtension(defaultSfixed64ExtensionLite));
 
2336
    assertEqualsExactType( 51.5F , message.getExtension(defaultFloatExtensionLite   ));
 
2337
    assertEqualsExactType( 52e3D , message.getExtension(defaultDoubleExtensionLite  ));
 
2338
    assertEqualsExactType(true   , message.getExtension(defaultBoolExtensionLite    ));
 
2339
    assertEqualsExactType("hello", message.getExtension(defaultStringExtensionLite  ));
 
2340
    assertEqualsExactType(toBytes("world"), message.getExtension(defaultBytesExtensionLite));
 
2341
 
 
2342
    assertEqualsExactType(TestAllTypesLite.NestedEnum.BAR,
 
2343
      message.getExtension(defaultNestedEnumExtensionLite ));
 
2344
    assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAR,
 
2345
      message.getExtension(defaultForeignEnumExtensionLite));
 
2346
    assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAR,
 
2347
      message.getExtension(defaultImportEnumExtensionLite));
 
2348
 
 
2349
    assertEqualsExactType("abc", message.getExtension(defaultStringPieceExtensionLite));
 
2350
    assertEqualsExactType("123", message.getExtension(defaultCordExtensionLite));
 
2351
  }
 
2352
 
 
2353
  // -------------------------------------------------------------------
 
2354
 
 
2355
  /**
 
2356
   * Assert (using {@code junit.framework.Assert}} that all extensions of
 
2357
   * {@code message} are set to the values assigned by {@code setAllExtensions}
 
2358
   * followed by {@code modifyRepeatedExtensions}.
 
2359
   */
 
2360
  public static void assertRepeatedExtensionsModified(
 
2361
      TestAllExtensionsLite message) {
 
2362
    // ModifyRepeatedFields only sets the second repeated element of each
 
2363
    // field.  In addition to verifying this, we also verify that the first
 
2364
    // element and size were *not* modified.
 
2365
    Assert.assertEquals(2, message.getExtensionCount(repeatedInt32ExtensionLite   ));
 
2366
    Assert.assertEquals(2, message.getExtensionCount(repeatedInt64ExtensionLite   ));
 
2367
    Assert.assertEquals(2, message.getExtensionCount(repeatedUint32ExtensionLite  ));
 
2368
    Assert.assertEquals(2, message.getExtensionCount(repeatedUint64ExtensionLite  ));
 
2369
    Assert.assertEquals(2, message.getExtensionCount(repeatedSint32ExtensionLite  ));
 
2370
    Assert.assertEquals(2, message.getExtensionCount(repeatedSint64ExtensionLite  ));
 
2371
    Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32ExtensionLite ));
 
2372
    Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64ExtensionLite ));
 
2373
    Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32ExtensionLite));
 
2374
    Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64ExtensionLite));
 
2375
    Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtensionLite   ));
 
2376
    Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtensionLite  ));
 
2377
    Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtensionLite    ));
 
2378
    Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtensionLite  ));
 
2379
    Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtensionLite   ));
 
2380
 
 
2381
    Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtensionLite         ));
 
2382
    Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtensionLite ));
 
2383
    Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtensionLite));
 
2384
    Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtensionLite ));
 
2385
    Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtensionLite    ));
 
2386
    Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtensionLite   ));
 
2387
    Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtensionLite    ));
 
2388
 
 
2389
    Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtensionLite));
 
2390
    Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtensionLite));
 
2391
 
 
2392
    assertEqualsExactType(201  , message.getExtension(repeatedInt32ExtensionLite   , 0));
 
2393
    assertEqualsExactType(202L , message.getExtension(repeatedInt64ExtensionLite   , 0));
 
2394
    assertEqualsExactType(203  , message.getExtension(repeatedUint32ExtensionLite  , 0));
 
2395
    assertEqualsExactType(204L , message.getExtension(repeatedUint64ExtensionLite  , 0));
 
2396
    assertEqualsExactType(205  , message.getExtension(repeatedSint32ExtensionLite  , 0));
 
2397
    assertEqualsExactType(206L , message.getExtension(repeatedSint64ExtensionLite  , 0));
 
2398
    assertEqualsExactType(207  , message.getExtension(repeatedFixed32ExtensionLite , 0));
 
2399
    assertEqualsExactType(208L , message.getExtension(repeatedFixed64ExtensionLite , 0));
 
2400
    assertEqualsExactType(209  , message.getExtension(repeatedSfixed32ExtensionLite, 0));
 
2401
    assertEqualsExactType(210L , message.getExtension(repeatedSfixed64ExtensionLite, 0));
 
2402
    assertEqualsExactType(211F , message.getExtension(repeatedFloatExtensionLite   , 0));
 
2403
    assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtensionLite  , 0));
 
2404
    assertEqualsExactType(true , message.getExtension(repeatedBoolExtensionLite    , 0));
 
2405
    assertEqualsExactType("215", message.getExtension(repeatedStringExtensionLite  , 0));
 
2406
    assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtensionLite, 0));
 
2407
 
 
2408
    assertEqualsExactType(217, message.getExtension(repeatedGroupExtensionLite         ,0).getA());
 
2409
    assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtensionLite ,0).getBb());
 
2410
    assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtensionLite,0).getC());
 
2411
    assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtensionLite ,0).getD());
 
2412
 
 
2413
    assertEqualsExactType(TestAllTypesLite.NestedEnum.BAR,
 
2414
      message.getExtension(repeatedNestedEnumExtensionLite, 0));
 
2415
    assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAR,
 
2416
      message.getExtension(repeatedForeignEnumExtensionLite, 0));
 
2417
    assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAR,
 
2418
      message.getExtension(repeatedImportEnumExtensionLite, 0));
 
2419
 
 
2420
    assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtensionLite, 0));
 
2421
    assertEqualsExactType("225", message.getExtension(repeatedCordExtensionLite, 0));
 
2422
 
 
2423
    // Actually verify the second (modified) elements now.
 
2424
    assertEqualsExactType(501  , message.getExtension(repeatedInt32ExtensionLite   , 1));
 
2425
    assertEqualsExactType(502L , message.getExtension(repeatedInt64ExtensionLite   , 1));
 
2426
    assertEqualsExactType(503  , message.getExtension(repeatedUint32ExtensionLite  , 1));
 
2427
    assertEqualsExactType(504L , message.getExtension(repeatedUint64ExtensionLite  , 1));
 
2428
    assertEqualsExactType(505  , message.getExtension(repeatedSint32ExtensionLite  , 1));
 
2429
    assertEqualsExactType(506L , message.getExtension(repeatedSint64ExtensionLite  , 1));
 
2430
    assertEqualsExactType(507  , message.getExtension(repeatedFixed32ExtensionLite , 1));
 
2431
    assertEqualsExactType(508L , message.getExtension(repeatedFixed64ExtensionLite , 1));
 
2432
    assertEqualsExactType(509  , message.getExtension(repeatedSfixed32ExtensionLite, 1));
 
2433
    assertEqualsExactType(510L , message.getExtension(repeatedSfixed64ExtensionLite, 1));
 
2434
    assertEqualsExactType(511F , message.getExtension(repeatedFloatExtensionLite   , 1));
 
2435
    assertEqualsExactType(512D , message.getExtension(repeatedDoubleExtensionLite  , 1));
 
2436
    assertEqualsExactType(true , message.getExtension(repeatedBoolExtensionLite    , 1));
 
2437
    assertEqualsExactType("515", message.getExtension(repeatedStringExtensionLite  , 1));
 
2438
    assertEqualsExactType(toBytes("516"), message.getExtension(repeatedBytesExtensionLite, 1));
 
2439
 
 
2440
    assertEqualsExactType(517, message.getExtension(repeatedGroupExtensionLite         ,1).getA());
 
2441
    assertEqualsExactType(518, message.getExtension(repeatedNestedMessageExtensionLite ,1).getBb());
 
2442
    assertEqualsExactType(519, message.getExtension(repeatedForeignMessageExtensionLite,1).getC());
 
2443
    assertEqualsExactType(520, message.getExtension(repeatedImportMessageExtensionLite ,1).getD());
 
2444
 
 
2445
    assertEqualsExactType(TestAllTypesLite.NestedEnum.FOO,
 
2446
      message.getExtension(repeatedNestedEnumExtensionLite, 1));
 
2447
    assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_FOO,
 
2448
      message.getExtension(repeatedForeignEnumExtensionLite, 1));
 
2449
    assertEqualsExactType(ImportEnumLite.IMPORT_LITE_FOO,
 
2450
      message.getExtension(repeatedImportEnumExtensionLite, 1));
 
2451
 
 
2452
    assertEqualsExactType("524", message.getExtension(repeatedStringPieceExtensionLite, 1));
 
2453
    assertEqualsExactType("525", message.getExtension(repeatedCordExtensionLite, 1));
 
2454
  }
 
2455
 
 
2456
  public static void setPackedExtensions(TestPackedExtensionsLite.Builder message) {
 
2457
    message.addExtension(packedInt32ExtensionLite   , 601);
 
2458
    message.addExtension(packedInt64ExtensionLite   , 602L);
 
2459
    message.addExtension(packedUint32ExtensionLite  , 603);
 
2460
    message.addExtension(packedUint64ExtensionLite  , 604L);
 
2461
    message.addExtension(packedSint32ExtensionLite  , 605);
 
2462
    message.addExtension(packedSint64ExtensionLite  , 606L);
 
2463
    message.addExtension(packedFixed32ExtensionLite , 607);
 
2464
    message.addExtension(packedFixed64ExtensionLite , 608L);
 
2465
    message.addExtension(packedSfixed32ExtensionLite, 609);
 
2466
    message.addExtension(packedSfixed64ExtensionLite, 610L);
 
2467
    message.addExtension(packedFloatExtensionLite   , 611F);
 
2468
    message.addExtension(packedDoubleExtensionLite  , 612D);
 
2469
    message.addExtension(packedBoolExtensionLite    , true);
 
2470
    message.addExtension(packedEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAR);
 
2471
    // Add a second one of each field.
 
2472
    message.addExtension(packedInt32ExtensionLite   , 701);
 
2473
    message.addExtension(packedInt64ExtensionLite   , 702L);
 
2474
    message.addExtension(packedUint32ExtensionLite  , 703);
 
2475
    message.addExtension(packedUint64ExtensionLite  , 704L);
 
2476
    message.addExtension(packedSint32ExtensionLite  , 705);
 
2477
    message.addExtension(packedSint64ExtensionLite  , 706L);
 
2478
    message.addExtension(packedFixed32ExtensionLite , 707);
 
2479
    message.addExtension(packedFixed64ExtensionLite , 708L);
 
2480
    message.addExtension(packedSfixed32ExtensionLite, 709);
 
2481
    message.addExtension(packedSfixed64ExtensionLite, 710L);
 
2482
    message.addExtension(packedFloatExtensionLite   , 711F);
 
2483
    message.addExtension(packedDoubleExtensionLite  , 712D);
 
2484
    message.addExtension(packedBoolExtensionLite    , false);
 
2485
    message.addExtension(packedEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ);
 
2486
  }
 
2487
 
 
2488
  public static void assertPackedExtensionsSet(TestPackedExtensionsLite message) {
 
2489
    Assert.assertEquals(2, message.getExtensionCount(packedInt32ExtensionLite   ));
 
2490
    Assert.assertEquals(2, message.getExtensionCount(packedInt64ExtensionLite   ));
 
2491
    Assert.assertEquals(2, message.getExtensionCount(packedUint32ExtensionLite  ));
 
2492
    Assert.assertEquals(2, message.getExtensionCount(packedUint64ExtensionLite  ));
 
2493
    Assert.assertEquals(2, message.getExtensionCount(packedSint32ExtensionLite  ));
 
2494
    Assert.assertEquals(2, message.getExtensionCount(packedSint64ExtensionLite  ));
 
2495
    Assert.assertEquals(2, message.getExtensionCount(packedFixed32ExtensionLite ));
 
2496
    Assert.assertEquals(2, message.getExtensionCount(packedFixed64ExtensionLite ));
 
2497
    Assert.assertEquals(2, message.getExtensionCount(packedSfixed32ExtensionLite));
 
2498
    Assert.assertEquals(2, message.getExtensionCount(packedSfixed64ExtensionLite));
 
2499
    Assert.assertEquals(2, message.getExtensionCount(packedFloatExtensionLite   ));
 
2500
    Assert.assertEquals(2, message.getExtensionCount(packedDoubleExtensionLite  ));
 
2501
    Assert.assertEquals(2, message.getExtensionCount(packedBoolExtensionLite    ));
 
2502
    Assert.assertEquals(2, message.getExtensionCount(packedEnumExtensionLite));
 
2503
    assertEqualsExactType(601  , message.getExtension(packedInt32ExtensionLite   , 0));
 
2504
    assertEqualsExactType(602L , message.getExtension(packedInt64ExtensionLite   , 0));
 
2505
    assertEqualsExactType(603  , message.getExtension(packedUint32ExtensionLite  , 0));
 
2506
    assertEqualsExactType(604L , message.getExtension(packedUint64ExtensionLite  , 0));
 
2507
    assertEqualsExactType(605  , message.getExtension(packedSint32ExtensionLite  , 0));
 
2508
    assertEqualsExactType(606L , message.getExtension(packedSint64ExtensionLite  , 0));
 
2509
    assertEqualsExactType(607  , message.getExtension(packedFixed32ExtensionLite , 0));
 
2510
    assertEqualsExactType(608L , message.getExtension(packedFixed64ExtensionLite , 0));
 
2511
    assertEqualsExactType(609  , message.getExtension(packedSfixed32ExtensionLite, 0));
 
2512
    assertEqualsExactType(610L , message.getExtension(packedSfixed64ExtensionLite, 0));
 
2513
    assertEqualsExactType(611F , message.getExtension(packedFloatExtensionLite   , 0));
 
2514
    assertEqualsExactType(612D , message.getExtension(packedDoubleExtensionLite  , 0));
 
2515
    assertEqualsExactType(true , message.getExtension(packedBoolExtensionLite    , 0));
 
2516
    assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAR,
 
2517
                          message.getExtension(packedEnumExtensionLite, 0));
 
2518
    assertEqualsExactType(701  , message.getExtension(packedInt32ExtensionLite   , 1));
 
2519
    assertEqualsExactType(702L , message.getExtension(packedInt64ExtensionLite   , 1));
 
2520
    assertEqualsExactType(703  , message.getExtension(packedUint32ExtensionLite  , 1));
 
2521
    assertEqualsExactType(704L , message.getExtension(packedUint64ExtensionLite  , 1));
 
2522
    assertEqualsExactType(705  , message.getExtension(packedSint32ExtensionLite  , 1));
 
2523
    assertEqualsExactType(706L , message.getExtension(packedSint64ExtensionLite  , 1));
 
2524
    assertEqualsExactType(707  , message.getExtension(packedFixed32ExtensionLite , 1));
 
2525
    assertEqualsExactType(708L , message.getExtension(packedFixed64ExtensionLite , 1));
 
2526
    assertEqualsExactType(709  , message.getExtension(packedSfixed32ExtensionLite, 1));
 
2527
    assertEqualsExactType(710L , message.getExtension(packedSfixed64ExtensionLite, 1));
 
2528
    assertEqualsExactType(711F , message.getExtension(packedFloatExtensionLite   , 1));
 
2529
    assertEqualsExactType(712D , message.getExtension(packedDoubleExtensionLite  , 1));
 
2530
    assertEqualsExactType(false, message.getExtension(packedBoolExtensionLite    , 1));
 
2531
    assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAZ,
 
2532
                          message.getExtension(packedEnumExtensionLite, 1));
 
2533
  }
 
2534
 
 
2535
  // =================================================================
1677
2536
 
1678
2537
  /**
1679
2538
   * Performs the same things that the methods of {@code TestUtil} do, but