code
stringlengths 11
173k
| docstring
stringlengths 2
593k
| func_name
stringlengths 2
189
| language
stringclasses 1
value | repo
stringclasses 844
values | path
stringlengths 11
294
| url
stringlengths 60
339
| license
stringclasses 4
values |
|---|---|---|---|---|---|---|---|
public static void modifyRepeatedFields(TestAllTypes.Builder message) {
message.setRepeatedInt32(1, 501);
message.setRepeatedInt64(1, 502);
message.setRepeatedUint32(1, 503);
message.setRepeatedUint64(1, 504);
message.setRepeatedSint32(1, 505);
message.setRepeatedSint64(1, 506);
message.setRepeatedFixed32(1, 507);
message.setRepeatedFixed64(1, 508);
message.setRepeatedSfixed32(1, 509);
message.setRepeatedSfixed64(1, 510);
message.setRepeatedFloat(1, 511);
message.setRepeatedDouble(1, 512);
message.setRepeatedBool(1, true);
message.setRepeatedString(1, "515");
message.setRepeatedBytes(1, toBytes("516"));
message.setRepeatedGroup(1, TestAllTypes.RepeatedGroup.newBuilder().setA(517).build());
message.setRepeatedNestedMessage(1, TestAllTypes.NestedMessage.newBuilder().setBb(518).build());
message.setRepeatedForeignMessage(1, 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);
message.setRepeatedImportEnum(1, ImportEnum.IMPORT_FOO);
message.setRepeatedStringPiece(1, "524");
message.setRepeatedCord(1, "525");
} |
Modify the repeated fields of {@code message} to contain the values expected by {@code
assertRepeatedFieldsModified()}.
| TestUtil::modifyRepeatedFields | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void assertAllFieldsSet(TestAllTypesOrBuilder message) {
Assert.assertTrue(message.hasOptionalInt32());
Assert.assertTrue(message.hasOptionalInt64());
Assert.assertTrue(message.hasOptionalUint32());
Assert.assertTrue(message.hasOptionalUint64());
Assert.assertTrue(message.hasOptionalSint32());
Assert.assertTrue(message.hasOptionalSint64());
Assert.assertTrue(message.hasOptionalFixed32());
Assert.assertTrue(message.hasOptionalFixed64());
Assert.assertTrue(message.hasOptionalSfixed32());
Assert.assertTrue(message.hasOptionalSfixed64());
Assert.assertTrue(message.hasOptionalFloat());
Assert.assertTrue(message.hasOptionalDouble());
Assert.assertTrue(message.hasOptionalBool());
Assert.assertTrue(message.hasOptionalString());
Assert.assertTrue(message.hasOptionalBytes());
Assert.assertTrue(message.hasOptionalGroup());
Assert.assertTrue(message.hasOptionalNestedMessage());
Assert.assertTrue(message.hasOptionalForeignMessage());
Assert.assertTrue(message.hasOptionalImportMessage());
Assert.assertTrue(message.getOptionalGroup().hasA());
Assert.assertTrue(message.getOptionalNestedMessage().hasBb());
Assert.assertTrue(message.getOptionalForeignMessage().hasC());
Assert.assertTrue(message.getOptionalImportMessage().hasD());
Assert.assertTrue(message.hasOptionalNestedEnum());
Assert.assertTrue(message.hasOptionalForeignEnum());
Assert.assertTrue(message.hasOptionalImportEnum());
Assert.assertTrue(message.hasOptionalStringPiece());
Assert.assertTrue(message.hasOptionalCord());
Assert.assertEquals(101, message.getOptionalInt32());
Assert.assertEquals(102, message.getOptionalInt64());
Assert.assertEquals(103, message.getOptionalUint32());
Assert.assertEquals(104, message.getOptionalUint64());
Assert.assertEquals(105, message.getOptionalSint32());
Assert.assertEquals(106, message.getOptionalSint64());
Assert.assertEquals(107, message.getOptionalFixed32());
Assert.assertEquals(108, message.getOptionalFixed64());
Assert.assertEquals(109, message.getOptionalSfixed32());
Assert.assertEquals(110, message.getOptionalSfixed64());
Assert.assertEquals(111, message.getOptionalFloat(), 0.0);
Assert.assertEquals(112, message.getOptionalDouble(), 0.0);
Assert.assertEquals(true, message.getOptionalBool());
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(126, message.getOptionalPublicImportMessage().getE());
Assert.assertEquals(127, message.getOptionalLazyMessage().getBb());
Assert.assertEquals(TestAllTypes.NestedEnum.BAZ, message.getOptionalNestedEnum());
Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getOptionalForeignEnum());
Assert.assertEquals(ImportEnum.IMPORT_BAZ, message.getOptionalImportEnum());
Assert.assertEquals("124", message.getOptionalStringPiece());
Assert.assertEquals("125", message.getOptionalCord());
// -----------------------------------------------------------------
Assert.assertEquals(2, message.getRepeatedInt32Count());
Assert.assertEquals(2, message.getRepeatedInt64Count());
Assert.assertEquals(2, message.getRepeatedUint32Count());
Assert.assertEquals(2, message.getRepeatedUint64Count());
Assert.assertEquals(2, message.getRepeatedSint32Count());
Assert.assertEquals(2, message.getRepeatedSint64Count());
Assert.assertEquals(2, message.getRepeatedFixed32Count());
Assert.assertEquals(2, message.getRepeatedFixed64Count());
Assert.assertEquals(2, message.getRepeatedSfixed32Count());
Assert.assertEquals(2, message.getRepeatedSfixed64Count());
Assert.assertEquals(2, message.getRepeatedFloatCount());
Assert.assertEquals(2, message.getRepeatedDoubleCount());
Assert.assertEquals(2, message.getRepeatedBoolCount());
Assert.assertEquals(2, message.getRepeatedStringCount());
Assert.assertEquals(2, message.getRepeatedBytesCount());
Assert.assertEquals(2, message.getRepeatedGroupCount());
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());
Assert.assertEquals(2, message.getRepeatedStringPieceCount());
Assert.assertEquals(2, message.getRepeatedCordCount());
Assert.assertEquals(201, message.getRepeatedInt32(0));
Assert.assertEquals(202, message.getRepeatedInt64(0));
Assert.assertEquals(203, message.getRepeatedUint32(0));
Assert.assertEquals(204, message.getRepeatedUint64(0));
Assert.assertEquals(205, message.getRepeatedSint32(0));
Assert.assertEquals(206, message.getRepeatedSint64(0));
Assert.assertEquals(207, message.getRepeatedFixed32(0));
Assert.assertEquals(208, message.getRepeatedFixed64(0));
Assert.assertEquals(209, message.getRepeatedSfixed32(0));
Assert.assertEquals(210, message.getRepeatedSfixed64(0));
Assert.assertEquals(211, message.getRepeatedFloat(0), 0.0);
Assert.assertEquals(212, message.getRepeatedDouble(0), 0.0);
Assert.assertEquals(true, message.getRepeatedBool(0));
Assert.assertEquals("215", message.getRepeatedString(0));
Assert.assertEquals(toBytes("216"), message.getRepeatedBytes(0));
Assert.assertEquals(217, message.getRepeatedGroup(0).getA());
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));
Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getRepeatedImportEnum(0));
Assert.assertEquals("224", message.getRepeatedStringPiece(0));
Assert.assertEquals("225", message.getRepeatedCord(0));
Assert.assertEquals(301, message.getRepeatedInt32(1));
Assert.assertEquals(302, message.getRepeatedInt64(1));
Assert.assertEquals(303, message.getRepeatedUint32(1));
Assert.assertEquals(304, message.getRepeatedUint64(1));
Assert.assertEquals(305, message.getRepeatedSint32(1));
Assert.assertEquals(306, message.getRepeatedSint64(1));
Assert.assertEquals(307, message.getRepeatedFixed32(1));
Assert.assertEquals(308, message.getRepeatedFixed64(1));
Assert.assertEquals(309, message.getRepeatedSfixed32(1));
Assert.assertEquals(310, message.getRepeatedSfixed64(1));
Assert.assertEquals(311, message.getRepeatedFloat(1), 0.0);
Assert.assertEquals(312, message.getRepeatedDouble(1), 0.0);
Assert.assertEquals(false, message.getRepeatedBool(1));
Assert.assertEquals("315", message.getRepeatedString(1));
Assert.assertEquals(toBytes("316"), message.getRepeatedBytes(1));
Assert.assertEquals(317, message.getRepeatedGroup(1).getA());
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));
Assert.assertEquals(ImportEnum.IMPORT_BAZ, message.getRepeatedImportEnum(1));
Assert.assertEquals("324", message.getRepeatedStringPiece(1));
Assert.assertEquals("325", message.getRepeatedCord(1));
// -----------------------------------------------------------------
Assert.assertTrue(message.hasDefaultInt32());
Assert.assertTrue(message.hasDefaultInt64());
Assert.assertTrue(message.hasDefaultUint32());
Assert.assertTrue(message.hasDefaultUint64());
Assert.assertTrue(message.hasDefaultSint32());
Assert.assertTrue(message.hasDefaultSint64());
Assert.assertTrue(message.hasDefaultFixed32());
Assert.assertTrue(message.hasDefaultFixed64());
Assert.assertTrue(message.hasDefaultSfixed32());
Assert.assertTrue(message.hasDefaultSfixed64());
Assert.assertTrue(message.hasDefaultFloat());
Assert.assertTrue(message.hasDefaultDouble());
Assert.assertTrue(message.hasDefaultBool());
Assert.assertTrue(message.hasDefaultString());
Assert.assertTrue(message.hasDefaultBytes());
Assert.assertTrue(message.hasDefaultNestedEnum());
Assert.assertTrue(message.hasDefaultForeignEnum());
Assert.assertTrue(message.hasDefaultImportEnum());
Assert.assertTrue(message.hasDefaultStringPiece());
Assert.assertTrue(message.hasDefaultCord());
Assert.assertEquals(401, message.getDefaultInt32());
Assert.assertEquals(402, message.getDefaultInt64());
Assert.assertEquals(403, message.getDefaultUint32());
Assert.assertEquals(404, message.getDefaultUint64());
Assert.assertEquals(405, message.getDefaultSint32());
Assert.assertEquals(406, message.getDefaultSint64());
Assert.assertEquals(407, message.getDefaultFixed32());
Assert.assertEquals(408, message.getDefaultFixed64());
Assert.assertEquals(409, message.getDefaultSfixed32());
Assert.assertEquals(410, message.getDefaultSfixed64());
Assert.assertEquals(411, message.getDefaultFloat(), 0.0);
Assert.assertEquals(412, message.getDefaultDouble(), 0.0);
Assert.assertEquals(false, message.getDefaultBool());
Assert.assertEquals("415", message.getDefaultString());
Assert.assertEquals(toBytes("416"), message.getDefaultBytes());
Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getDefaultNestedEnum());
Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getDefaultForeignEnum());
Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getDefaultImportEnum());
Assert.assertEquals("424", message.getDefaultStringPiece());
Assert.assertEquals("425", message.getDefaultCord());
Assert.assertEquals(TestAllTypes.OneofFieldCase.ONEOF_BYTES, message.getOneofFieldCase());
Assert.assertFalse(message.hasOneofUint32());
Assert.assertFalse(message.hasOneofNestedMessage());
Assert.assertFalse(message.hasOneofString());
Assert.assertTrue(message.hasOneofBytes());
Assert.assertEquals(toBytes("604"), message.getOneofBytes());
} |
Assert (using {@code junit.framework.Assert}} that all fields of {@code message} are set to the
values assigned by {@code setAllFields}.
| TestUtil::assertAllFieldsSet | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void assertClear(TestAllTypesOrBuilder message) {
// hasBlah() should initially be false for all optional fields.
Assert.assertFalse(message.hasOptionalInt32());
Assert.assertFalse(message.hasOptionalInt64());
Assert.assertFalse(message.hasOptionalUint32());
Assert.assertFalse(message.hasOptionalUint64());
Assert.assertFalse(message.hasOptionalSint32());
Assert.assertFalse(message.hasOptionalSint64());
Assert.assertFalse(message.hasOptionalFixed32());
Assert.assertFalse(message.hasOptionalFixed64());
Assert.assertFalse(message.hasOptionalSfixed32());
Assert.assertFalse(message.hasOptionalSfixed64());
Assert.assertFalse(message.hasOptionalFloat());
Assert.assertFalse(message.hasOptionalDouble());
Assert.assertFalse(message.hasOptionalBool());
Assert.assertFalse(message.hasOptionalString());
Assert.assertFalse(message.hasOptionalBytes());
Assert.assertFalse(message.hasOptionalGroup());
Assert.assertFalse(message.hasOptionalNestedMessage());
Assert.assertFalse(message.hasOptionalForeignMessage());
Assert.assertFalse(message.hasOptionalImportMessage());
Assert.assertFalse(message.hasOptionalNestedEnum());
Assert.assertFalse(message.hasOptionalForeignEnum());
Assert.assertFalse(message.hasOptionalImportEnum());
Assert.assertFalse(message.hasOptionalStringPiece());
Assert.assertFalse(message.hasOptionalCord());
// Optional fields without defaults are set to zero or something like it.
Assert.assertEquals(0, message.getOptionalInt32());
Assert.assertEquals(0, message.getOptionalInt64());
Assert.assertEquals(0, message.getOptionalUint32());
Assert.assertEquals(0, message.getOptionalUint64());
Assert.assertEquals(0, message.getOptionalSint32());
Assert.assertEquals(0, message.getOptionalSint64());
Assert.assertEquals(0, message.getOptionalFixed32());
Assert.assertEquals(0, message.getOptionalFixed64());
Assert.assertEquals(0, message.getOptionalSfixed32());
Assert.assertEquals(0, message.getOptionalSfixed64());
Assert.assertEquals(0, message.getOptionalFloat(), 0.0);
Assert.assertEquals(0, message.getOptionalDouble(), 0.0);
Assert.assertEquals(false, message.getOptionalBool());
Assert.assertEquals("", message.getOptionalString());
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.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.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());
Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getOptionalForeignEnum());
Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getOptionalImportEnum());
Assert.assertEquals("", message.getOptionalStringPiece());
Assert.assertEquals("", message.getOptionalCord());
// Repeated fields are empty.
Assert.assertEquals(0, message.getRepeatedInt32Count());
Assert.assertEquals(0, message.getRepeatedInt64Count());
Assert.assertEquals(0, message.getRepeatedUint32Count());
Assert.assertEquals(0, message.getRepeatedUint64Count());
Assert.assertEquals(0, message.getRepeatedSint32Count());
Assert.assertEquals(0, message.getRepeatedSint64Count());
Assert.assertEquals(0, message.getRepeatedFixed32Count());
Assert.assertEquals(0, message.getRepeatedFixed64Count());
Assert.assertEquals(0, message.getRepeatedSfixed32Count());
Assert.assertEquals(0, message.getRepeatedSfixed64Count());
Assert.assertEquals(0, message.getRepeatedFloatCount());
Assert.assertEquals(0, message.getRepeatedDoubleCount());
Assert.assertEquals(0, message.getRepeatedBoolCount());
Assert.assertEquals(0, message.getRepeatedStringCount());
Assert.assertEquals(0, message.getRepeatedBytesCount());
Assert.assertEquals(0, message.getRepeatedGroupCount());
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());
Assert.assertEquals(0, message.getRepeatedStringPieceCount());
Assert.assertEquals(0, message.getRepeatedCordCount());
// hasBlah() should also be false for all default fields.
Assert.assertFalse(message.hasDefaultInt32());
Assert.assertFalse(message.hasDefaultInt64());
Assert.assertFalse(message.hasDefaultUint32());
Assert.assertFalse(message.hasDefaultUint64());
Assert.assertFalse(message.hasDefaultSint32());
Assert.assertFalse(message.hasDefaultSint64());
Assert.assertFalse(message.hasDefaultFixed32());
Assert.assertFalse(message.hasDefaultFixed64());
Assert.assertFalse(message.hasDefaultSfixed32());
Assert.assertFalse(message.hasDefaultSfixed64());
Assert.assertFalse(message.hasDefaultFloat());
Assert.assertFalse(message.hasDefaultDouble());
Assert.assertFalse(message.hasDefaultBool());
Assert.assertFalse(message.hasDefaultString());
Assert.assertFalse(message.hasDefaultBytes());
Assert.assertFalse(message.hasDefaultNestedEnum());
Assert.assertFalse(message.hasDefaultForeignEnum());
Assert.assertFalse(message.hasDefaultImportEnum());
Assert.assertFalse(message.hasDefaultStringPiece());
Assert.assertFalse(message.hasDefaultCord());
// Fields with defaults have their default values (duh).
Assert.assertEquals(41, message.getDefaultInt32());
Assert.assertEquals(42, message.getDefaultInt64());
Assert.assertEquals(43, message.getDefaultUint32());
Assert.assertEquals(44, message.getDefaultUint64());
Assert.assertEquals(-45, message.getDefaultSint32());
Assert.assertEquals(46, message.getDefaultSint64());
Assert.assertEquals(47, message.getDefaultFixed32());
Assert.assertEquals(48, message.getDefaultFixed64());
Assert.assertEquals(49, message.getDefaultSfixed32());
Assert.assertEquals(-50, message.getDefaultSfixed64());
Assert.assertEquals(51.5, message.getDefaultFloat(), 0.0);
Assert.assertEquals(52e3, message.getDefaultDouble(), 0.0);
Assert.assertEquals(true, message.getDefaultBool());
Assert.assertEquals("hello", message.getDefaultString());
Assert.assertEquals(toBytes("world"), message.getDefaultBytes());
Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getDefaultNestedEnum());
Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getDefaultForeignEnum());
Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getDefaultImportEnum());
Assert.assertEquals("abc", message.getDefaultStringPiece());
Assert.assertEquals("123", message.getDefaultCord());
Assert.assertFalse(message.hasOneofUint32());
Assert.assertFalse(message.hasOneofNestedMessage());
Assert.assertFalse(message.hasOneofString());
Assert.assertFalse(message.hasOneofBytes());
} |
Assert (using {@code junit.framework.Assert}} that all fields of {@code message} are cleared,
and that getting the fields returns their default values.
| TestUtil::assertClear | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void assertRepeatedFieldsModified(TestAllTypesOrBuilder message) {
// ModifyRepeatedFields only sets the second repeated element of each
// field. In addition to verifying this, we also verify that the first
// element and size were *not* modified.
Assert.assertEquals(2, message.getRepeatedInt32Count());
Assert.assertEquals(2, message.getRepeatedInt64Count());
Assert.assertEquals(2, message.getRepeatedUint32Count());
Assert.assertEquals(2, message.getRepeatedUint64Count());
Assert.assertEquals(2, message.getRepeatedSint32Count());
Assert.assertEquals(2, message.getRepeatedSint64Count());
Assert.assertEquals(2, message.getRepeatedFixed32Count());
Assert.assertEquals(2, message.getRepeatedFixed64Count());
Assert.assertEquals(2, message.getRepeatedSfixed32Count());
Assert.assertEquals(2, message.getRepeatedSfixed64Count());
Assert.assertEquals(2, message.getRepeatedFloatCount());
Assert.assertEquals(2, message.getRepeatedDoubleCount());
Assert.assertEquals(2, message.getRepeatedBoolCount());
Assert.assertEquals(2, message.getRepeatedStringCount());
Assert.assertEquals(2, message.getRepeatedBytesCount());
Assert.assertEquals(2, message.getRepeatedGroupCount());
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());
Assert.assertEquals(2, message.getRepeatedStringPieceCount());
Assert.assertEquals(2, message.getRepeatedCordCount());
Assert.assertEquals(201, message.getRepeatedInt32(0));
Assert.assertEquals(202L, message.getRepeatedInt64(0));
Assert.assertEquals(203, message.getRepeatedUint32(0));
Assert.assertEquals(204L, message.getRepeatedUint64(0));
Assert.assertEquals(205, message.getRepeatedSint32(0));
Assert.assertEquals(206L, message.getRepeatedSint64(0));
Assert.assertEquals(207, message.getRepeatedFixed32(0));
Assert.assertEquals(208L, message.getRepeatedFixed64(0));
Assert.assertEquals(209, message.getRepeatedSfixed32(0));
Assert.assertEquals(210L, message.getRepeatedSfixed64(0));
Assert.assertEquals(211F, message.getRepeatedFloat(0));
Assert.assertEquals(212D, message.getRepeatedDouble(0));
Assert.assertEquals(true, message.getRepeatedBool(0));
Assert.assertEquals("215", message.getRepeatedString(0));
Assert.assertEquals(toBytes("216"), message.getRepeatedBytes(0));
Assert.assertEquals(217, message.getRepeatedGroup(0).getA());
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));
Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getRepeatedImportEnum(0));
Assert.assertEquals("224", message.getRepeatedStringPiece(0));
Assert.assertEquals("225", message.getRepeatedCord(0));
// Actually verify the second (modified) elements now.
Assert.assertEquals(501, message.getRepeatedInt32(1));
Assert.assertEquals(502L, message.getRepeatedInt64(1));
Assert.assertEquals(503, message.getRepeatedUint32(1));
Assert.assertEquals(504L, message.getRepeatedUint64(1));
Assert.assertEquals(505, message.getRepeatedSint32(1));
Assert.assertEquals(506L, message.getRepeatedSint64(1));
Assert.assertEquals(507, message.getRepeatedFixed32(1));
Assert.assertEquals(508L, message.getRepeatedFixed64(1));
Assert.assertEquals(509, message.getRepeatedSfixed32(1));
Assert.assertEquals(510L, message.getRepeatedSfixed64(1));
Assert.assertEquals(511F, message.getRepeatedFloat(1));
Assert.assertEquals(512D, message.getRepeatedDouble(1));
Assert.assertEquals(true, message.getRepeatedBool(1));
Assert.assertEquals("515", message.getRepeatedString(1));
Assert.assertEquals(toBytes("516"), message.getRepeatedBytes(1));
Assert.assertEquals(517, message.getRepeatedGroup(1).getA());
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));
Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getRepeatedImportEnum(1));
Assert.assertEquals("524", message.getRepeatedStringPiece(1));
Assert.assertEquals("525", message.getRepeatedCord(1));
} |
Assert (using {@code junit.framework.Assert}} that all fields of {@code message} are set to the
values assigned by {@code setAllFields} followed by {@code modifyRepeatedFields}.
| TestUtil::assertRepeatedFieldsModified | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void setPackedFields(TestPackedTypes.Builder message) {
message.addPackedInt32(601);
message.addPackedInt64(602);
message.addPackedUint32(603);
message.addPackedUint64(604);
message.addPackedSint32(605);
message.addPackedSint64(606);
message.addPackedFixed32(607);
message.addPackedFixed64(608);
message.addPackedSfixed32(609);
message.addPackedSfixed64(610);
message.addPackedFloat(611);
message.addPackedDouble(612);
message.addPackedBool(true);
message.addPackedEnum(ForeignEnum.FOREIGN_BAR);
// Add a second one of each field.
message.addPackedInt32(701);
message.addPackedInt64(702);
message.addPackedUint32(703);
message.addPackedUint64(704);
message.addPackedSint32(705);
message.addPackedSint64(706);
message.addPackedFixed32(707);
message.addPackedFixed64(708);
message.addPackedSfixed32(709);
message.addPackedSfixed64(710);
message.addPackedFloat(711);
message.addPackedDouble(712);
message.addPackedBool(false);
message.addPackedEnum(ForeignEnum.FOREIGN_BAZ);
} |
Assert (using {@code junit.framework.Assert}} that all fields of {@code message} are set to the
values assigned by {@code setAllFields} followed by {@code modifyRepeatedFields}.
public static void assertRepeatedFieldsModified(TestAllTypesOrBuilder message) {
// ModifyRepeatedFields only sets the second repeated element of each
// field. In addition to verifying this, we also verify that the first
// element and size were *not* modified.
Assert.assertEquals(2, message.getRepeatedInt32Count());
Assert.assertEquals(2, message.getRepeatedInt64Count());
Assert.assertEquals(2, message.getRepeatedUint32Count());
Assert.assertEquals(2, message.getRepeatedUint64Count());
Assert.assertEquals(2, message.getRepeatedSint32Count());
Assert.assertEquals(2, message.getRepeatedSint64Count());
Assert.assertEquals(2, message.getRepeatedFixed32Count());
Assert.assertEquals(2, message.getRepeatedFixed64Count());
Assert.assertEquals(2, message.getRepeatedSfixed32Count());
Assert.assertEquals(2, message.getRepeatedSfixed64Count());
Assert.assertEquals(2, message.getRepeatedFloatCount());
Assert.assertEquals(2, message.getRepeatedDoubleCount());
Assert.assertEquals(2, message.getRepeatedBoolCount());
Assert.assertEquals(2, message.getRepeatedStringCount());
Assert.assertEquals(2, message.getRepeatedBytesCount());
Assert.assertEquals(2, message.getRepeatedGroupCount());
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());
Assert.assertEquals(2, message.getRepeatedStringPieceCount());
Assert.assertEquals(2, message.getRepeatedCordCount());
Assert.assertEquals(201, message.getRepeatedInt32(0));
Assert.assertEquals(202L, message.getRepeatedInt64(0));
Assert.assertEquals(203, message.getRepeatedUint32(0));
Assert.assertEquals(204L, message.getRepeatedUint64(0));
Assert.assertEquals(205, message.getRepeatedSint32(0));
Assert.assertEquals(206L, message.getRepeatedSint64(0));
Assert.assertEquals(207, message.getRepeatedFixed32(0));
Assert.assertEquals(208L, message.getRepeatedFixed64(0));
Assert.assertEquals(209, message.getRepeatedSfixed32(0));
Assert.assertEquals(210L, message.getRepeatedSfixed64(0));
Assert.assertEquals(211F, message.getRepeatedFloat(0));
Assert.assertEquals(212D, message.getRepeatedDouble(0));
Assert.assertEquals(true, message.getRepeatedBool(0));
Assert.assertEquals("215", message.getRepeatedString(0));
Assert.assertEquals(toBytes("216"), message.getRepeatedBytes(0));
Assert.assertEquals(217, message.getRepeatedGroup(0).getA());
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));
Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getRepeatedImportEnum(0));
Assert.assertEquals("224", message.getRepeatedStringPiece(0));
Assert.assertEquals("225", message.getRepeatedCord(0));
// Actually verify the second (modified) elements now.
Assert.assertEquals(501, message.getRepeatedInt32(1));
Assert.assertEquals(502L, message.getRepeatedInt64(1));
Assert.assertEquals(503, message.getRepeatedUint32(1));
Assert.assertEquals(504L, message.getRepeatedUint64(1));
Assert.assertEquals(505, message.getRepeatedSint32(1));
Assert.assertEquals(506L, message.getRepeatedSint64(1));
Assert.assertEquals(507, message.getRepeatedFixed32(1));
Assert.assertEquals(508L, message.getRepeatedFixed64(1));
Assert.assertEquals(509, message.getRepeatedSfixed32(1));
Assert.assertEquals(510L, message.getRepeatedSfixed64(1));
Assert.assertEquals(511F, message.getRepeatedFloat(1));
Assert.assertEquals(512D, message.getRepeatedDouble(1));
Assert.assertEquals(true, message.getRepeatedBool(1));
Assert.assertEquals("515", message.getRepeatedString(1));
Assert.assertEquals(toBytes("516"), message.getRepeatedBytes(1));
Assert.assertEquals(517, message.getRepeatedGroup(1).getA());
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));
Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getRepeatedImportEnum(1));
Assert.assertEquals("524", message.getRepeatedStringPiece(1));
Assert.assertEquals("525", message.getRepeatedCord(1));
}
/** Set every field of {@code message} to a unique value. | TestUtil::setPackedFields | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void setUnpackedFields(TestUnpackedTypes.Builder message) {
message.addUnpackedInt32(601);
message.addUnpackedInt64(602);
message.addUnpackedUint32(603);
message.addUnpackedUint64(604);
message.addUnpackedSint32(605);
message.addUnpackedSint64(606);
message.addUnpackedFixed32(607);
message.addUnpackedFixed64(608);
message.addUnpackedSfixed32(609);
message.addUnpackedSfixed64(610);
message.addUnpackedFloat(611);
message.addUnpackedDouble(612);
message.addUnpackedBool(true);
message.addUnpackedEnum(ForeignEnum.FOREIGN_BAR);
// Add a second one of each field.
message.addUnpackedInt32(701);
message.addUnpackedInt64(702);
message.addUnpackedUint32(703);
message.addUnpackedUint64(704);
message.addUnpackedSint32(705);
message.addUnpackedSint64(706);
message.addUnpackedFixed32(707);
message.addUnpackedFixed64(708);
message.addUnpackedSfixed32(709);
message.addUnpackedSfixed64(710);
message.addUnpackedFloat(711);
message.addUnpackedDouble(712);
message.addUnpackedBool(false);
message.addUnpackedEnum(ForeignEnum.FOREIGN_BAZ);
} |
Set every field of {@code message} to a unique value. Must correspond with the values applied
by {@code setPackedFields}.
| TestUtil::setUnpackedFields | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void assertPackedFieldsSet(TestPackedTypes message) {
Assert.assertEquals(2, message.getPackedInt32Count());
Assert.assertEquals(2, message.getPackedInt64Count());
Assert.assertEquals(2, message.getPackedUint32Count());
Assert.assertEquals(2, message.getPackedUint64Count());
Assert.assertEquals(2, message.getPackedSint32Count());
Assert.assertEquals(2, message.getPackedSint64Count());
Assert.assertEquals(2, message.getPackedFixed32Count());
Assert.assertEquals(2, message.getPackedFixed64Count());
Assert.assertEquals(2, message.getPackedSfixed32Count());
Assert.assertEquals(2, message.getPackedSfixed64Count());
Assert.assertEquals(2, message.getPackedFloatCount());
Assert.assertEquals(2, message.getPackedDoubleCount());
Assert.assertEquals(2, message.getPackedBoolCount());
Assert.assertEquals(2, message.getPackedEnumCount());
Assert.assertEquals(601, message.getPackedInt32(0));
Assert.assertEquals(602, message.getPackedInt64(0));
Assert.assertEquals(603, message.getPackedUint32(0));
Assert.assertEquals(604, message.getPackedUint64(0));
Assert.assertEquals(605, message.getPackedSint32(0));
Assert.assertEquals(606, message.getPackedSint64(0));
Assert.assertEquals(607, message.getPackedFixed32(0));
Assert.assertEquals(608, message.getPackedFixed64(0));
Assert.assertEquals(609, message.getPackedSfixed32(0));
Assert.assertEquals(610, message.getPackedSfixed64(0));
Assert.assertEquals(611, message.getPackedFloat(0), 0.0);
Assert.assertEquals(612, message.getPackedDouble(0), 0.0);
Assert.assertEquals(true, message.getPackedBool(0));
Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getPackedEnum(0));
Assert.assertEquals(701, message.getPackedInt32(1));
Assert.assertEquals(702, message.getPackedInt64(1));
Assert.assertEquals(703, message.getPackedUint32(1));
Assert.assertEquals(704, message.getPackedUint64(1));
Assert.assertEquals(705, message.getPackedSint32(1));
Assert.assertEquals(706, message.getPackedSint64(1));
Assert.assertEquals(707, message.getPackedFixed32(1));
Assert.assertEquals(708, message.getPackedFixed64(1));
Assert.assertEquals(709, message.getPackedSfixed32(1));
Assert.assertEquals(710, message.getPackedSfixed64(1));
Assert.assertEquals(711, message.getPackedFloat(1), 0.0);
Assert.assertEquals(712, message.getPackedDouble(1), 0.0);
Assert.assertEquals(false, message.getPackedBool(1));
Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getPackedEnum(1));
} |
Assert (using {@code junit.framework.Assert}} that all fields of {@code message} are set to the
values assigned by {@code setPackedFields}.
| TestUtil::assertPackedFieldsSet | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void assertUnpackedFieldsSet(TestUnpackedTypes message) {
Assert.assertEquals(2, message.getUnpackedInt32Count());
Assert.assertEquals(2, message.getUnpackedInt64Count());
Assert.assertEquals(2, message.getUnpackedUint32Count());
Assert.assertEquals(2, message.getUnpackedUint64Count());
Assert.assertEquals(2, message.getUnpackedSint32Count());
Assert.assertEquals(2, message.getUnpackedSint64Count());
Assert.assertEquals(2, message.getUnpackedFixed32Count());
Assert.assertEquals(2, message.getUnpackedFixed64Count());
Assert.assertEquals(2, message.getUnpackedSfixed32Count());
Assert.assertEquals(2, message.getUnpackedSfixed64Count());
Assert.assertEquals(2, message.getUnpackedFloatCount());
Assert.assertEquals(2, message.getUnpackedDoubleCount());
Assert.assertEquals(2, message.getUnpackedBoolCount());
Assert.assertEquals(2, message.getUnpackedEnumCount());
Assert.assertEquals(601, message.getUnpackedInt32(0));
Assert.assertEquals(602, message.getUnpackedInt64(0));
Assert.assertEquals(603, message.getUnpackedUint32(0));
Assert.assertEquals(604, message.getUnpackedUint64(0));
Assert.assertEquals(605, message.getUnpackedSint32(0));
Assert.assertEquals(606, message.getUnpackedSint64(0));
Assert.assertEquals(607, message.getUnpackedFixed32(0));
Assert.assertEquals(608, message.getUnpackedFixed64(0));
Assert.assertEquals(609, message.getUnpackedSfixed32(0));
Assert.assertEquals(610, message.getUnpackedSfixed64(0));
Assert.assertEquals(611, message.getUnpackedFloat(0), 0.0);
Assert.assertEquals(612, message.getUnpackedDouble(0), 0.0);
Assert.assertEquals(true, message.getUnpackedBool(0));
Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getUnpackedEnum(0));
Assert.assertEquals(701, message.getUnpackedInt32(1));
Assert.assertEquals(702, message.getUnpackedInt64(1));
Assert.assertEquals(703, message.getUnpackedUint32(1));
Assert.assertEquals(704, message.getUnpackedUint64(1));
Assert.assertEquals(705, message.getUnpackedSint32(1));
Assert.assertEquals(706, message.getUnpackedSint64(1));
Assert.assertEquals(707, message.getUnpackedFixed32(1));
Assert.assertEquals(708, message.getUnpackedFixed64(1));
Assert.assertEquals(709, message.getUnpackedSfixed32(1));
Assert.assertEquals(710, message.getUnpackedSfixed64(1));
Assert.assertEquals(711, message.getUnpackedFloat(1), 0.0);
Assert.assertEquals(712, message.getUnpackedDouble(1), 0.0);
Assert.assertEquals(false, message.getUnpackedBool(1));
Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getUnpackedEnum(1));
} |
Assert (using {@code junit.framework.Assert}} that all fields of {@code message} are set to the
values assigned by {@code setUnpackedFields}.
| TestUtil::assertUnpackedFieldsSet | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static ExtensionRegistryLite getExtensionRegistry() {
ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
registerAllExtensions(registry);
return registry.getUnmodifiable();
} |
Get an unmodifiable {@link ExtensionRegistry} containing all the extensions of {@code
TestAllExtensions}.
| TestUtil::getExtensionRegistry | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static ExtensionRegistry getFullExtensionRegistry() {
ExtensionRegistry registry = ExtensionRegistry.newInstance();
registerAllExtensions(registry);
return registry.getUnmodifiable();
} |
Get an unmodifiable {@link ExtensionRegistry} containing all the extensions of {@code
TestAllExtensions}.
| TestUtil::getFullExtensionRegistry | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void registerAllExtensions(ExtensionRegistryLite registry) {
UnittestProto.registerAllExtensions(registry);
TestUtilLite.registerAllExtensionsLite(registry);
} |
Register all of {@code TestAllExtensions}'s extensions with the given {@link
ExtensionRegistry}.
| TestUtil::registerAllExtensions | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void setAllExtensions(TestAllExtensions.Builder message) {
message.setExtension(optionalInt32Extension, 101);
message.setExtension(optionalInt64Extension, 102L);
message.setExtension(optionalUint32Extension, 103);
message.setExtension(optionalUint64Extension, 104L);
message.setExtension(optionalSint32Extension, 105);
message.setExtension(optionalSint64Extension, 106L);
message.setExtension(optionalFixed32Extension, 107);
message.setExtension(optionalFixed64Extension, 108L);
message.setExtension(optionalSfixed32Extension, 109);
message.setExtension(optionalSfixed64Extension, 110L);
message.setExtension(optionalFloatExtension, 111F);
message.setExtension(optionalDoubleExtension, 112D);
message.setExtension(optionalBoolExtension, true);
message.setExtension(optionalStringExtension, "115");
message.setExtension(optionalBytesExtension, toBytes("116"));
message.setExtension(
optionalGroupExtension, OptionalGroup_extension.newBuilder().setA(117).build());
message.setExtension(
optionalNestedMessageExtension, TestAllTypes.NestedMessage.newBuilder().setBb(118).build());
message.setExtension(
optionalForeignMessageExtension, 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);
message.setExtension(optionalImportEnumExtension, ImportEnum.IMPORT_BAZ);
message.setExtension(optionalStringPieceExtension, "124");
message.setExtension(optionalCordExtension, "125");
// -----------------------------------------------------------------
message.addExtension(repeatedInt32Extension, 201);
message.addExtension(repeatedInt64Extension, 202L);
message.addExtension(repeatedUint32Extension, 203);
message.addExtension(repeatedUint64Extension, 204L);
message.addExtension(repeatedSint32Extension, 205);
message.addExtension(repeatedSint64Extension, 206L);
message.addExtension(repeatedFixed32Extension, 207);
message.addExtension(repeatedFixed64Extension, 208L);
message.addExtension(repeatedSfixed32Extension, 209);
message.addExtension(repeatedSfixed64Extension, 210L);
message.addExtension(repeatedFloatExtension, 211F);
message.addExtension(repeatedDoubleExtension, 212D);
message.addExtension(repeatedBoolExtension, true);
message.addExtension(repeatedStringExtension, "215");
message.addExtension(repeatedBytesExtension, toBytes("216"));
message.addExtension(
repeatedGroupExtension, RepeatedGroup_extension.newBuilder().setA(217).build());
message.addExtension(
repeatedNestedMessageExtension, TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
message.addExtension(
repeatedForeignMessageExtension, 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);
message.addExtension(repeatedImportEnumExtension, ImportEnum.IMPORT_BAR);
message.addExtension(repeatedStringPieceExtension, "224");
message.addExtension(repeatedCordExtension, "225");
// Add a second one of each field.
message.addExtension(repeatedInt32Extension, 301);
message.addExtension(repeatedInt64Extension, 302L);
message.addExtension(repeatedUint32Extension, 303);
message.addExtension(repeatedUint64Extension, 304L);
message.addExtension(repeatedSint32Extension, 305);
message.addExtension(repeatedSint64Extension, 306L);
message.addExtension(repeatedFixed32Extension, 307);
message.addExtension(repeatedFixed64Extension, 308L);
message.addExtension(repeatedSfixed32Extension, 309);
message.addExtension(repeatedSfixed64Extension, 310L);
message.addExtension(repeatedFloatExtension, 311F);
message.addExtension(repeatedDoubleExtension, 312D);
message.addExtension(repeatedBoolExtension, false);
message.addExtension(repeatedStringExtension, "315");
message.addExtension(repeatedBytesExtension, toBytes("316"));
message.addExtension(
repeatedGroupExtension, RepeatedGroup_extension.newBuilder().setA(317).build());
message.addExtension(
repeatedNestedMessageExtension, TestAllTypes.NestedMessage.newBuilder().setBb(318).build());
message.addExtension(
repeatedForeignMessageExtension, 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);
message.addExtension(repeatedImportEnumExtension, ImportEnum.IMPORT_BAZ);
message.addExtension(repeatedStringPieceExtension, "324");
message.addExtension(repeatedCordExtension, "325");
// -----------------------------------------------------------------
message.setExtension(defaultInt32Extension, 401);
message.setExtension(defaultInt64Extension, 402L);
message.setExtension(defaultUint32Extension, 403);
message.setExtension(defaultUint64Extension, 404L);
message.setExtension(defaultSint32Extension, 405);
message.setExtension(defaultSint64Extension, 406L);
message.setExtension(defaultFixed32Extension, 407);
message.setExtension(defaultFixed64Extension, 408L);
message.setExtension(defaultSfixed32Extension, 409);
message.setExtension(defaultSfixed64Extension, 410L);
message.setExtension(defaultFloatExtension, 411F);
message.setExtension(defaultDoubleExtension, 412D);
message.setExtension(defaultBoolExtension, false);
message.setExtension(defaultStringExtension, "415");
message.setExtension(defaultBytesExtension, toBytes("416"));
message.setExtension(defaultNestedEnumExtension, TestAllTypes.NestedEnum.FOO);
message.setExtension(defaultForeignEnumExtension, ForeignEnum.FOREIGN_FOO);
message.setExtension(defaultImportEnumExtension, ImportEnum.IMPORT_FOO);
message.setExtension(defaultStringPieceExtension, "424");
message.setExtension(defaultCordExtension, "425");
message.setExtension(oneofUint32Extension, 601);
message.setExtension(
oneofNestedMessageExtension, TestAllTypes.NestedMessage.newBuilder().setBb(602).build());
message.setExtension(oneofStringExtension, "603");
message.setExtension(oneofBytesExtension, toBytes("604"));
} |
Set every field of {@code message} to the values expected by {@code assertAllExtensionsSet()}.
| TestUtil::setAllExtensions | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void modifyRepeatedExtensions(TestAllExtensions.Builder message) {
message.setExtension(repeatedInt32Extension, 1, 501);
message.setExtension(repeatedInt64Extension, 1, 502L);
message.setExtension(repeatedUint32Extension, 1, 503);
message.setExtension(repeatedUint64Extension, 1, 504L);
message.setExtension(repeatedSint32Extension, 1, 505);
message.setExtension(repeatedSint64Extension, 1, 506L);
message.setExtension(repeatedFixed32Extension, 1, 507);
message.setExtension(repeatedFixed64Extension, 1, 508L);
message.setExtension(repeatedSfixed32Extension, 1, 509);
message.setExtension(repeatedSfixed64Extension, 1, 510L);
message.setExtension(repeatedFloatExtension, 1, 511F);
message.setExtension(repeatedDoubleExtension, 1, 512D);
message.setExtension(repeatedBoolExtension, 1, true);
message.setExtension(repeatedStringExtension, 1, "515");
message.setExtension(repeatedBytesExtension, 1, toBytes("516"));
message.setExtension(
repeatedGroupExtension, 1, RepeatedGroup_extension.newBuilder().setA(517).build());
message.setExtension(
repeatedNestedMessageExtension,
1,
TestAllTypes.NestedMessage.newBuilder().setBb(518).build());
message.setExtension(
repeatedForeignMessageExtension, 1, 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);
message.setExtension(repeatedImportEnumExtension, 1, ImportEnum.IMPORT_FOO);
message.setExtension(repeatedStringPieceExtension, 1, "524");
message.setExtension(repeatedCordExtension, 1, "525");
} |
Modify the repeated extensions of {@code message} to contain the values expected by {@code
assertRepeatedExtensionsModified()}.
| TestUtil::modifyRepeatedExtensions | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void assertAllExtensionsSet(TestAllExtensionsOrBuilder message) {
Assert.assertTrue(message.hasExtension(optionalInt32Extension));
Assert.assertTrue(message.hasExtension(optionalInt64Extension));
Assert.assertTrue(message.hasExtension(optionalUint32Extension));
Assert.assertTrue(message.hasExtension(optionalUint64Extension));
Assert.assertTrue(message.hasExtension(optionalSint32Extension));
Assert.assertTrue(message.hasExtension(optionalSint64Extension));
Assert.assertTrue(message.hasExtension(optionalFixed32Extension));
Assert.assertTrue(message.hasExtension(optionalFixed64Extension));
Assert.assertTrue(message.hasExtension(optionalSfixed32Extension));
Assert.assertTrue(message.hasExtension(optionalSfixed64Extension));
Assert.assertTrue(message.hasExtension(optionalFloatExtension));
Assert.assertTrue(message.hasExtension(optionalDoubleExtension));
Assert.assertTrue(message.hasExtension(optionalBoolExtension));
Assert.assertTrue(message.hasExtension(optionalStringExtension));
Assert.assertTrue(message.hasExtension(optionalBytesExtension));
Assert.assertTrue(message.hasExtension(optionalGroupExtension));
Assert.assertTrue(message.hasExtension(optionalNestedMessageExtension));
Assert.assertTrue(message.hasExtension(optionalForeignMessageExtension));
Assert.assertTrue(message.hasExtension(optionalImportMessageExtension));
Assert.assertTrue(message.getExtension(optionalGroupExtension).hasA());
Assert.assertTrue(message.getExtension(optionalNestedMessageExtension).hasBb());
Assert.assertTrue(message.getExtension(optionalForeignMessageExtension).hasC());
Assert.assertTrue(message.getExtension(optionalImportMessageExtension).hasD());
Assert.assertTrue(message.hasExtension(optionalNestedEnumExtension));
Assert.assertTrue(message.hasExtension(optionalForeignEnumExtension));
Assert.assertTrue(message.hasExtension(optionalImportEnumExtension));
Assert.assertTrue(message.hasExtension(optionalStringPieceExtension));
Assert.assertTrue(message.hasExtension(optionalCordExtension));
assertEqualsExactType(101, message.getExtension(optionalInt32Extension));
assertEqualsExactType(102L, message.getExtension(optionalInt64Extension));
assertEqualsExactType(103, message.getExtension(optionalUint32Extension));
assertEqualsExactType(104L, message.getExtension(optionalUint64Extension));
assertEqualsExactType(105, message.getExtension(optionalSint32Extension));
assertEqualsExactType(106L, message.getExtension(optionalSint64Extension));
assertEqualsExactType(107, message.getExtension(optionalFixed32Extension));
assertEqualsExactType(108L, message.getExtension(optionalFixed64Extension));
assertEqualsExactType(109, message.getExtension(optionalSfixed32Extension));
assertEqualsExactType(110L, message.getExtension(optionalSfixed64Extension));
assertEqualsExactType(111F, message.getExtension(optionalFloatExtension));
assertEqualsExactType(112D, message.getExtension(optionalDoubleExtension));
assertEqualsExactType(true, message.getExtension(optionalBoolExtension));
assertEqualsExactType("115", message.getExtension(optionalStringExtension));
assertEqualsExactType(toBytes("116"), message.getExtension(optionalBytesExtension));
assertEqualsExactType(117, message.getExtension(optionalGroupExtension).getA());
assertEqualsExactType(118, message.getExtension(optionalNestedMessageExtension).getBb());
assertEqualsExactType(119, message.getExtension(optionalForeignMessageExtension).getC());
assertEqualsExactType(120, message.getExtension(optionalImportMessageExtension).getD());
assertEqualsExactType(126, message.getExtension(optionalPublicImportMessageExtension).getE());
assertEqualsExactType(127, message.getExtension(optionalLazyMessageExtension).getBb());
assertEqualsExactType(
TestAllTypes.NestedEnum.BAZ, message.getExtension(optionalNestedEnumExtension));
assertEqualsExactType(
ForeignEnum.FOREIGN_BAZ, message.getExtension(optionalForeignEnumExtension));
assertEqualsExactType(ImportEnum.IMPORT_BAZ, message.getExtension(optionalImportEnumExtension));
assertEqualsExactType("124", message.getExtension(optionalStringPieceExtension));
assertEqualsExactType("125", message.getExtension(optionalCordExtension));
// -----------------------------------------------------------------
Assert.assertEquals(2, message.getExtensionCount(repeatedInt32Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedInt64Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedUint32Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedUint64Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedSint32Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedSint64Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtension));
assertEqualsExactType(201, message.getExtension(repeatedInt32Extension, 0));
assertEqualsExactType(202L, message.getExtension(repeatedInt64Extension, 0));
assertEqualsExactType(203, message.getExtension(repeatedUint32Extension, 0));
assertEqualsExactType(204L, message.getExtension(repeatedUint64Extension, 0));
assertEqualsExactType(205, message.getExtension(repeatedSint32Extension, 0));
assertEqualsExactType(206L, message.getExtension(repeatedSint64Extension, 0));
assertEqualsExactType(207, message.getExtension(repeatedFixed32Extension, 0));
assertEqualsExactType(208L, message.getExtension(repeatedFixed64Extension, 0));
assertEqualsExactType(209, message.getExtension(repeatedSfixed32Extension, 0));
assertEqualsExactType(210L, message.getExtension(repeatedSfixed64Extension, 0));
assertEqualsExactType(211F, message.getExtension(repeatedFloatExtension, 0));
assertEqualsExactType(212D, message.getExtension(repeatedDoubleExtension, 0));
assertEqualsExactType(true, message.getExtension(repeatedBoolExtension, 0));
assertEqualsExactType("215", message.getExtension(repeatedStringExtension, 0));
assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtension, 0));
assertEqualsExactType(217, message.getExtension(repeatedGroupExtension, 0).getA());
assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtension, 0).getBb());
assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtension, 0).getC());
assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtension, 0).getD());
assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtension, 0).getBb());
assertEqualsExactType(
TestAllTypes.NestedEnum.BAR, message.getExtension(repeatedNestedEnumExtension, 0));
assertEqualsExactType(
ForeignEnum.FOREIGN_BAR, message.getExtension(repeatedForeignEnumExtension, 0));
assertEqualsExactType(
ImportEnum.IMPORT_BAR, message.getExtension(repeatedImportEnumExtension, 0));
assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtension, 0));
assertEqualsExactType("225", message.getExtension(repeatedCordExtension, 0));
assertEqualsExactType(301, message.getExtension(repeatedInt32Extension, 1));
assertEqualsExactType(302L, message.getExtension(repeatedInt64Extension, 1));
assertEqualsExactType(303, message.getExtension(repeatedUint32Extension, 1));
assertEqualsExactType(304L, message.getExtension(repeatedUint64Extension, 1));
assertEqualsExactType(305, message.getExtension(repeatedSint32Extension, 1));
assertEqualsExactType(306L, message.getExtension(repeatedSint64Extension, 1));
assertEqualsExactType(307, message.getExtension(repeatedFixed32Extension, 1));
assertEqualsExactType(308L, message.getExtension(repeatedFixed64Extension, 1));
assertEqualsExactType(309, message.getExtension(repeatedSfixed32Extension, 1));
assertEqualsExactType(310L, message.getExtension(repeatedSfixed64Extension, 1));
assertEqualsExactType(311F, message.getExtension(repeatedFloatExtension, 1));
assertEqualsExactType(312D, message.getExtension(repeatedDoubleExtension, 1));
assertEqualsExactType(false, message.getExtension(repeatedBoolExtension, 1));
assertEqualsExactType("315", message.getExtension(repeatedStringExtension, 1));
assertEqualsExactType(toBytes("316"), message.getExtension(repeatedBytesExtension, 1));
assertEqualsExactType(317, message.getExtension(repeatedGroupExtension, 1).getA());
assertEqualsExactType(318, message.getExtension(repeatedNestedMessageExtension, 1).getBb());
assertEqualsExactType(319, message.getExtension(repeatedForeignMessageExtension, 1).getC());
assertEqualsExactType(320, message.getExtension(repeatedImportMessageExtension, 1).getD());
assertEqualsExactType(327, message.getExtension(repeatedLazyMessageExtension, 1).getBb());
assertEqualsExactType(
TestAllTypes.NestedEnum.BAZ, message.getExtension(repeatedNestedEnumExtension, 1));
assertEqualsExactType(
ForeignEnum.FOREIGN_BAZ, message.getExtension(repeatedForeignEnumExtension, 1));
assertEqualsExactType(
ImportEnum.IMPORT_BAZ, message.getExtension(repeatedImportEnumExtension, 1));
assertEqualsExactType("324", message.getExtension(repeatedStringPieceExtension, 1));
assertEqualsExactType("325", message.getExtension(repeatedCordExtension, 1));
// -----------------------------------------------------------------
Assert.assertTrue(message.hasExtension(defaultInt32Extension));
Assert.assertTrue(message.hasExtension(defaultInt64Extension));
Assert.assertTrue(message.hasExtension(defaultUint32Extension));
Assert.assertTrue(message.hasExtension(defaultUint64Extension));
Assert.assertTrue(message.hasExtension(defaultSint32Extension));
Assert.assertTrue(message.hasExtension(defaultSint64Extension));
Assert.assertTrue(message.hasExtension(defaultFixed32Extension));
Assert.assertTrue(message.hasExtension(defaultFixed64Extension));
Assert.assertTrue(message.hasExtension(defaultSfixed32Extension));
Assert.assertTrue(message.hasExtension(defaultSfixed64Extension));
Assert.assertTrue(message.hasExtension(defaultFloatExtension));
Assert.assertTrue(message.hasExtension(defaultDoubleExtension));
Assert.assertTrue(message.hasExtension(defaultBoolExtension));
Assert.assertTrue(message.hasExtension(defaultStringExtension));
Assert.assertTrue(message.hasExtension(defaultBytesExtension));
Assert.assertTrue(message.hasExtension(defaultNestedEnumExtension));
Assert.assertTrue(message.hasExtension(defaultForeignEnumExtension));
Assert.assertTrue(message.hasExtension(defaultImportEnumExtension));
Assert.assertTrue(message.hasExtension(defaultStringPieceExtension));
Assert.assertTrue(message.hasExtension(defaultCordExtension));
assertEqualsExactType(401, message.getExtension(defaultInt32Extension));
assertEqualsExactType(402L, message.getExtension(defaultInt64Extension));
assertEqualsExactType(403, message.getExtension(defaultUint32Extension));
assertEqualsExactType(404L, message.getExtension(defaultUint64Extension));
assertEqualsExactType(405, message.getExtension(defaultSint32Extension));
assertEqualsExactType(406L, message.getExtension(defaultSint64Extension));
assertEqualsExactType(407, message.getExtension(defaultFixed32Extension));
assertEqualsExactType(408L, message.getExtension(defaultFixed64Extension));
assertEqualsExactType(409, message.getExtension(defaultSfixed32Extension));
assertEqualsExactType(410L, message.getExtension(defaultSfixed64Extension));
assertEqualsExactType(411F, message.getExtension(defaultFloatExtension));
assertEqualsExactType(412D, message.getExtension(defaultDoubleExtension));
assertEqualsExactType(false, message.getExtension(defaultBoolExtension));
assertEqualsExactType("415", message.getExtension(defaultStringExtension));
assertEqualsExactType(toBytes("416"), message.getExtension(defaultBytesExtension));
assertEqualsExactType(
TestAllTypes.NestedEnum.FOO, message.getExtension(defaultNestedEnumExtension));
assertEqualsExactType(
ForeignEnum.FOREIGN_FOO, message.getExtension(defaultForeignEnumExtension));
assertEqualsExactType(ImportEnum.IMPORT_FOO, message.getExtension(defaultImportEnumExtension));
assertEqualsExactType("424", message.getExtension(defaultStringPieceExtension));
assertEqualsExactType("425", message.getExtension(defaultCordExtension));
Assert.assertTrue(message.hasExtension(oneofBytesExtension));
assertEqualsExactType(toBytes("604"), message.getExtension(oneofBytesExtension));
} |
Assert (using {@code junit.framework.Assert}} that all extensions of {@code message} are set to
the values assigned by {@code setAllExtensions}.
| TestUtil::assertAllExtensionsSet | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void assertExtensionsClear(TestAllExtensionsOrBuilder message) {
// hasBlah() should initially be false for all optional fields.
Assert.assertFalse(message.hasExtension(optionalInt32Extension));
Assert.assertFalse(message.hasExtension(optionalInt64Extension));
Assert.assertFalse(message.hasExtension(optionalUint32Extension));
Assert.assertFalse(message.hasExtension(optionalUint64Extension));
Assert.assertFalse(message.hasExtension(optionalSint32Extension));
Assert.assertFalse(message.hasExtension(optionalSint64Extension));
Assert.assertFalse(message.hasExtension(optionalFixed32Extension));
Assert.assertFalse(message.hasExtension(optionalFixed64Extension));
Assert.assertFalse(message.hasExtension(optionalSfixed32Extension));
Assert.assertFalse(message.hasExtension(optionalSfixed64Extension));
Assert.assertFalse(message.hasExtension(optionalFloatExtension));
Assert.assertFalse(message.hasExtension(optionalDoubleExtension));
Assert.assertFalse(message.hasExtension(optionalBoolExtension));
Assert.assertFalse(message.hasExtension(optionalStringExtension));
Assert.assertFalse(message.hasExtension(optionalBytesExtension));
Assert.assertFalse(message.hasExtension(optionalGroupExtension));
Assert.assertFalse(message.hasExtension(optionalNestedMessageExtension));
Assert.assertFalse(message.hasExtension(optionalForeignMessageExtension));
Assert.assertFalse(message.hasExtension(optionalImportMessageExtension));
Assert.assertFalse(message.hasExtension(optionalNestedEnumExtension));
Assert.assertFalse(message.hasExtension(optionalForeignEnumExtension));
Assert.assertFalse(message.hasExtension(optionalImportEnumExtension));
Assert.assertFalse(message.hasExtension(optionalStringPieceExtension));
Assert.assertFalse(message.hasExtension(optionalCordExtension));
// Optional fields without defaults are set to zero or something like it.
assertEqualsExactType(0, message.getExtension(optionalInt32Extension));
assertEqualsExactType(0L, message.getExtension(optionalInt64Extension));
assertEqualsExactType(0, message.getExtension(optionalUint32Extension));
assertEqualsExactType(0L, message.getExtension(optionalUint64Extension));
assertEqualsExactType(0, message.getExtension(optionalSint32Extension));
assertEqualsExactType(0L, message.getExtension(optionalSint64Extension));
assertEqualsExactType(0, message.getExtension(optionalFixed32Extension));
assertEqualsExactType(0L, message.getExtension(optionalFixed64Extension));
assertEqualsExactType(0, message.getExtension(optionalSfixed32Extension));
assertEqualsExactType(0L, message.getExtension(optionalSfixed64Extension));
assertEqualsExactType(0F, message.getExtension(optionalFloatExtension));
assertEqualsExactType(0D, message.getExtension(optionalDoubleExtension));
assertEqualsExactType(false, message.getExtension(optionalBoolExtension));
assertEqualsExactType("", message.getExtension(optionalStringExtension));
assertEqualsExactType(ByteString.EMPTY, message.getExtension(optionalBytesExtension));
// Embedded messages should also be clear.
Assert.assertFalse(message.getExtension(optionalGroupExtension).hasA());
Assert.assertFalse(message.getExtension(optionalNestedMessageExtension).hasBb());
Assert.assertFalse(message.getExtension(optionalForeignMessageExtension).hasC());
Assert.assertFalse(message.getExtension(optionalImportMessageExtension).hasD());
assertEqualsExactType(0, message.getExtension(optionalGroupExtension).getA());
assertEqualsExactType(0, message.getExtension(optionalNestedMessageExtension).getBb());
assertEqualsExactType(0, message.getExtension(optionalForeignMessageExtension).getC());
assertEqualsExactType(0, message.getExtension(optionalImportMessageExtension).getD());
// Enums without defaults are set to the first value in the enum.
assertEqualsExactType(
TestAllTypes.NestedEnum.FOO, message.getExtension(optionalNestedEnumExtension));
assertEqualsExactType(
ForeignEnum.FOREIGN_FOO, message.getExtension(optionalForeignEnumExtension));
assertEqualsExactType(ImportEnum.IMPORT_FOO, message.getExtension(optionalImportEnumExtension));
assertEqualsExactType("", message.getExtension(optionalStringPieceExtension));
assertEqualsExactType("", message.getExtension(optionalCordExtension));
// Repeated fields are empty.
Assert.assertEquals(0, message.getExtensionCount(repeatedInt32Extension));
Assert.assertEquals(0, message.getExtensionCount(repeatedInt64Extension));
Assert.assertEquals(0, message.getExtensionCount(repeatedUint32Extension));
Assert.assertEquals(0, message.getExtensionCount(repeatedUint64Extension));
Assert.assertEquals(0, message.getExtensionCount(repeatedSint32Extension));
Assert.assertEquals(0, message.getExtensionCount(repeatedSint64Extension));
Assert.assertEquals(0, message.getExtensionCount(repeatedFixed32Extension));
Assert.assertEquals(0, message.getExtensionCount(repeatedFixed64Extension));
Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed32Extension));
Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed64Extension));
Assert.assertEquals(0, message.getExtensionCount(repeatedFloatExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedDoubleExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedBoolExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedStringExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedBytesExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedGroupExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedNestedMessageExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedForeignMessageExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedImportMessageExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedLazyMessageExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedNestedEnumExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedForeignEnumExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedImportEnumExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedStringPieceExtension));
Assert.assertEquals(0, message.getExtensionCount(repeatedCordExtension));
// Repeated fields are empty via getExtension().size().
Assert.assertEquals(0, message.getExtension(repeatedInt32Extension).size());
Assert.assertEquals(0, message.getExtension(repeatedInt64Extension).size());
Assert.assertEquals(0, message.getExtension(repeatedUint32Extension).size());
Assert.assertEquals(0, message.getExtension(repeatedUint64Extension).size());
Assert.assertEquals(0, message.getExtension(repeatedSint32Extension).size());
Assert.assertEquals(0, message.getExtension(repeatedSint64Extension).size());
Assert.assertEquals(0, message.getExtension(repeatedFixed32Extension).size());
Assert.assertEquals(0, message.getExtension(repeatedFixed64Extension).size());
Assert.assertEquals(0, message.getExtension(repeatedSfixed32Extension).size());
Assert.assertEquals(0, message.getExtension(repeatedSfixed64Extension).size());
Assert.assertEquals(0, message.getExtension(repeatedFloatExtension).size());
Assert.assertEquals(0, message.getExtension(repeatedDoubleExtension).size());
Assert.assertEquals(0, message.getExtension(repeatedBoolExtension).size());
Assert.assertEquals(0, message.getExtension(repeatedStringExtension).size());
Assert.assertEquals(0, message.getExtension(repeatedBytesExtension).size());
Assert.assertEquals(0, message.getExtension(repeatedGroupExtension).size());
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());
Assert.assertEquals(0, message.getExtension(repeatedStringPieceExtension).size());
Assert.assertEquals(0, message.getExtension(repeatedCordExtension).size());
// hasBlah() should also be false for all default fields.
Assert.assertFalse(message.hasExtension(defaultInt32Extension));
Assert.assertFalse(message.hasExtension(defaultInt64Extension));
Assert.assertFalse(message.hasExtension(defaultUint32Extension));
Assert.assertFalse(message.hasExtension(defaultUint64Extension));
Assert.assertFalse(message.hasExtension(defaultSint32Extension));
Assert.assertFalse(message.hasExtension(defaultSint64Extension));
Assert.assertFalse(message.hasExtension(defaultFixed32Extension));
Assert.assertFalse(message.hasExtension(defaultFixed64Extension));
Assert.assertFalse(message.hasExtension(defaultSfixed32Extension));
Assert.assertFalse(message.hasExtension(defaultSfixed64Extension));
Assert.assertFalse(message.hasExtension(defaultFloatExtension));
Assert.assertFalse(message.hasExtension(defaultDoubleExtension));
Assert.assertFalse(message.hasExtension(defaultBoolExtension));
Assert.assertFalse(message.hasExtension(defaultStringExtension));
Assert.assertFalse(message.hasExtension(defaultBytesExtension));
Assert.assertFalse(message.hasExtension(defaultNestedEnumExtension));
Assert.assertFalse(message.hasExtension(defaultForeignEnumExtension));
Assert.assertFalse(message.hasExtension(defaultImportEnumExtension));
Assert.assertFalse(message.hasExtension(defaultStringPieceExtension));
Assert.assertFalse(message.hasExtension(defaultCordExtension));
// Fields with defaults have their default values (duh).
assertEqualsExactType(41, message.getExtension(defaultInt32Extension));
assertEqualsExactType(42L, message.getExtension(defaultInt64Extension));
assertEqualsExactType(43, message.getExtension(defaultUint32Extension));
assertEqualsExactType(44L, message.getExtension(defaultUint64Extension));
assertEqualsExactType(-45, message.getExtension(defaultSint32Extension));
assertEqualsExactType(46L, message.getExtension(defaultSint64Extension));
assertEqualsExactType(47, message.getExtension(defaultFixed32Extension));
assertEqualsExactType(48L, message.getExtension(defaultFixed64Extension));
assertEqualsExactType(49, message.getExtension(defaultSfixed32Extension));
assertEqualsExactType(-50L, message.getExtension(defaultSfixed64Extension));
assertEqualsExactType(51.5F, message.getExtension(defaultFloatExtension));
assertEqualsExactType(52e3D, message.getExtension(defaultDoubleExtension));
assertEqualsExactType(true, message.getExtension(defaultBoolExtension));
assertEqualsExactType("hello", message.getExtension(defaultStringExtension));
assertEqualsExactType(toBytes("world"), message.getExtension(defaultBytesExtension));
assertEqualsExactType(
TestAllTypes.NestedEnum.BAR, message.getExtension(defaultNestedEnumExtension));
assertEqualsExactType(
ForeignEnum.FOREIGN_BAR, message.getExtension(defaultForeignEnumExtension));
assertEqualsExactType(ImportEnum.IMPORT_BAR, message.getExtension(defaultImportEnumExtension));
assertEqualsExactType("abc", message.getExtension(defaultStringPieceExtension));
assertEqualsExactType("123", message.getExtension(defaultCordExtension));
Assert.assertFalse(message.hasExtension(oneofUint32Extension));
Assert.assertFalse(message.hasExtension(oneofNestedMessageExtension));
Assert.assertFalse(message.hasExtension(oneofStringExtension));
Assert.assertFalse(message.hasExtension(oneofBytesExtension));
} |
Assert (using {@code junit.framework.Assert}} that all extensions of {@code message} are
cleared, and that getting the extensions returns their default values.
| TestUtil::assertExtensionsClear | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void assertRepeatedExtensionsModified(TestAllExtensionsOrBuilder message) {
// ModifyRepeatedFields only sets the second repeated element of each
// field. In addition to verifying this, we also verify that the first
// element and size were *not* modified.
Assert.assertEquals(2, message.getExtensionCount(repeatedInt32Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedInt64Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedUint32Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedUint64Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedSint32Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedSint64Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64Extension));
Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtension));
Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtension));
assertEqualsExactType(201, message.getExtension(repeatedInt32Extension, 0));
assertEqualsExactType(202L, message.getExtension(repeatedInt64Extension, 0));
assertEqualsExactType(203, message.getExtension(repeatedUint32Extension, 0));
assertEqualsExactType(204L, message.getExtension(repeatedUint64Extension, 0));
assertEqualsExactType(205, message.getExtension(repeatedSint32Extension, 0));
assertEqualsExactType(206L, message.getExtension(repeatedSint64Extension, 0));
assertEqualsExactType(207, message.getExtension(repeatedFixed32Extension, 0));
assertEqualsExactType(208L, message.getExtension(repeatedFixed64Extension, 0));
assertEqualsExactType(209, message.getExtension(repeatedSfixed32Extension, 0));
assertEqualsExactType(210L, message.getExtension(repeatedSfixed64Extension, 0));
assertEqualsExactType(211F, message.getExtension(repeatedFloatExtension, 0));
assertEqualsExactType(212D, message.getExtension(repeatedDoubleExtension, 0));
assertEqualsExactType(true, message.getExtension(repeatedBoolExtension, 0));
assertEqualsExactType("215", message.getExtension(repeatedStringExtension, 0));
assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtension, 0));
assertEqualsExactType(217, message.getExtension(repeatedGroupExtension, 0).getA());
assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtension, 0).getBb());
assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtension, 0).getC());
assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtension, 0).getD());
assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtension, 0).getBb());
assertEqualsExactType(
TestAllTypes.NestedEnum.BAR, message.getExtension(repeatedNestedEnumExtension, 0));
assertEqualsExactType(
ForeignEnum.FOREIGN_BAR, message.getExtension(repeatedForeignEnumExtension, 0));
assertEqualsExactType(
ImportEnum.IMPORT_BAR, message.getExtension(repeatedImportEnumExtension, 0));
assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtension, 0));
assertEqualsExactType("225", message.getExtension(repeatedCordExtension, 0));
// Actually verify the second (modified) elements now.
assertEqualsExactType(501, message.getExtension(repeatedInt32Extension, 1));
assertEqualsExactType(502L, message.getExtension(repeatedInt64Extension, 1));
assertEqualsExactType(503, message.getExtension(repeatedUint32Extension, 1));
assertEqualsExactType(504L, message.getExtension(repeatedUint64Extension, 1));
assertEqualsExactType(505, message.getExtension(repeatedSint32Extension, 1));
assertEqualsExactType(506L, message.getExtension(repeatedSint64Extension, 1));
assertEqualsExactType(507, message.getExtension(repeatedFixed32Extension, 1));
assertEqualsExactType(508L, message.getExtension(repeatedFixed64Extension, 1));
assertEqualsExactType(509, message.getExtension(repeatedSfixed32Extension, 1));
assertEqualsExactType(510L, message.getExtension(repeatedSfixed64Extension, 1));
assertEqualsExactType(511F, message.getExtension(repeatedFloatExtension, 1));
assertEqualsExactType(512D, message.getExtension(repeatedDoubleExtension, 1));
assertEqualsExactType(true, message.getExtension(repeatedBoolExtension, 1));
assertEqualsExactType("515", message.getExtension(repeatedStringExtension, 1));
assertEqualsExactType(toBytes("516"), message.getExtension(repeatedBytesExtension, 1));
assertEqualsExactType(517, message.getExtension(repeatedGroupExtension, 1).getA());
assertEqualsExactType(518, message.getExtension(repeatedNestedMessageExtension, 1).getBb());
assertEqualsExactType(519, message.getExtension(repeatedForeignMessageExtension, 1).getC());
assertEqualsExactType(520, message.getExtension(repeatedImportMessageExtension, 1).getD());
assertEqualsExactType(527, message.getExtension(repeatedLazyMessageExtension, 1).getBb());
assertEqualsExactType(
TestAllTypes.NestedEnum.FOO, message.getExtension(repeatedNestedEnumExtension, 1));
assertEqualsExactType(
ForeignEnum.FOREIGN_FOO, message.getExtension(repeatedForeignEnumExtension, 1));
assertEqualsExactType(
ImportEnum.IMPORT_FOO, message.getExtension(repeatedImportEnumExtension, 1));
assertEqualsExactType("524", message.getExtension(repeatedStringPieceExtension, 1));
assertEqualsExactType("525", message.getExtension(repeatedCordExtension, 1));
} |
Assert (using {@code junit.framework.Assert}} that all extensions of {@code message} are set to
the values assigned by {@code setAllExtensions} followed by {@code modifyRepeatedExtensions}.
| TestUtil::assertRepeatedExtensionsModified | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void assertAllExtensionsSet(TestAllExtensionsLiteOrBuilder message) {
Assert.assertTrue(message.hasExtension(optionalInt32ExtensionLite));
Assert.assertTrue(message.hasExtension(optionalInt64ExtensionLite));
Assert.assertTrue(message.hasExtension(optionalUint32ExtensionLite));
Assert.assertTrue(message.hasExtension(optionalUint64ExtensionLite));
Assert.assertTrue(message.hasExtension(optionalSint32ExtensionLite));
Assert.assertTrue(message.hasExtension(optionalSint64ExtensionLite));
Assert.assertTrue(message.hasExtension(optionalFixed32ExtensionLite));
Assert.assertTrue(message.hasExtension(optionalFixed64ExtensionLite));
Assert.assertTrue(message.hasExtension(optionalSfixed32ExtensionLite));
Assert.assertTrue(message.hasExtension(optionalSfixed64ExtensionLite));
Assert.assertTrue(message.hasExtension(optionalFloatExtensionLite));
Assert.assertTrue(message.hasExtension(optionalDoubleExtensionLite));
Assert.assertTrue(message.hasExtension(optionalBoolExtensionLite));
Assert.assertTrue(message.hasExtension(optionalStringExtensionLite));
Assert.assertTrue(message.hasExtension(optionalBytesExtensionLite));
Assert.assertTrue(message.hasExtension(optionalGroupExtensionLite));
Assert.assertTrue(message.hasExtension(optionalNestedMessageExtensionLite));
Assert.assertTrue(message.hasExtension(optionalForeignMessageExtensionLite));
Assert.assertTrue(message.hasExtension(optionalImportMessageExtensionLite));
Assert.assertTrue(message.getExtension(optionalGroupExtensionLite).hasA());
Assert.assertTrue(message.getExtension(optionalNestedMessageExtensionLite).hasBb());
Assert.assertTrue(message.getExtension(optionalForeignMessageExtensionLite).hasC());
Assert.assertTrue(message.getExtension(optionalImportMessageExtensionLite).hasD());
Assert.assertTrue(message.hasExtension(optionalNestedEnumExtensionLite));
Assert.assertTrue(message.hasExtension(optionalForeignEnumExtensionLite));
Assert.assertTrue(message.hasExtension(optionalImportEnumExtensionLite));
Assert.assertTrue(message.hasExtension(optionalStringPieceExtensionLite));
Assert.assertTrue(message.hasExtension(optionalCordExtensionLite));
assertEqualsExactType(101, message.getExtension(optionalInt32ExtensionLite));
assertEqualsExactType(102L, message.getExtension(optionalInt64ExtensionLite));
assertEqualsExactType(103, message.getExtension(optionalUint32ExtensionLite));
assertEqualsExactType(104L, message.getExtension(optionalUint64ExtensionLite));
assertEqualsExactType(105, message.getExtension(optionalSint32ExtensionLite));
assertEqualsExactType(106L, message.getExtension(optionalSint64ExtensionLite));
assertEqualsExactType(107, message.getExtension(optionalFixed32ExtensionLite));
assertEqualsExactType(108L, message.getExtension(optionalFixed64ExtensionLite));
assertEqualsExactType(109, message.getExtension(optionalSfixed32ExtensionLite));
assertEqualsExactType(110L, message.getExtension(optionalSfixed64ExtensionLite));
assertEqualsExactType(111F, message.getExtension(optionalFloatExtensionLite));
assertEqualsExactType(112D, message.getExtension(optionalDoubleExtensionLite));
assertEqualsExactType(true, message.getExtension(optionalBoolExtensionLite));
assertEqualsExactType("115", message.getExtension(optionalStringExtensionLite));
assertEqualsExactType(toBytes("116"), message.getExtension(optionalBytesExtensionLite));
assertEqualsExactType(117, message.getExtension(optionalGroupExtensionLite).getA());
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));
assertEqualsExactType(
ForeignEnumLite.FOREIGN_LITE_BAZ, message.getExtension(optionalForeignEnumExtensionLite));
assertEqualsExactType(
ImportEnumLite.IMPORT_LITE_BAZ, message.getExtension(optionalImportEnumExtensionLite));
assertEqualsExactType("124", message.getExtension(optionalStringPieceExtensionLite));
assertEqualsExactType("125", message.getExtension(optionalCordExtensionLite));
// -----------------------------------------------------------------
Assert.assertEquals(2, message.getExtensionCount(repeatedInt32ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedInt64ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedUint32ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedUint64ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedSint32ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedSint64ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtensionLite));
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));
Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtensionLite));
assertEqualsExactType(201, message.getExtension(repeatedInt32ExtensionLite, 0));
assertEqualsExactType(202L, message.getExtension(repeatedInt64ExtensionLite, 0));
assertEqualsExactType(203, message.getExtension(repeatedUint32ExtensionLite, 0));
assertEqualsExactType(204L, message.getExtension(repeatedUint64ExtensionLite, 0));
assertEqualsExactType(205, message.getExtension(repeatedSint32ExtensionLite, 0));
assertEqualsExactType(206L, message.getExtension(repeatedSint64ExtensionLite, 0));
assertEqualsExactType(207, message.getExtension(repeatedFixed32ExtensionLite, 0));
assertEqualsExactType(208L, message.getExtension(repeatedFixed64ExtensionLite, 0));
assertEqualsExactType(209, message.getExtension(repeatedSfixed32ExtensionLite, 0));
assertEqualsExactType(210L, message.getExtension(repeatedSfixed64ExtensionLite, 0));
assertEqualsExactType(211F, message.getExtension(repeatedFloatExtensionLite, 0));
assertEqualsExactType(212D, message.getExtension(repeatedDoubleExtensionLite, 0));
assertEqualsExactType(true, message.getExtension(repeatedBoolExtensionLite, 0));
assertEqualsExactType("215", message.getExtension(repeatedStringExtensionLite, 0));
assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtensionLite, 0));
assertEqualsExactType(217, message.getExtension(repeatedGroupExtensionLite, 0).getA());
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));
assertEqualsExactType(
ForeignEnumLite.FOREIGN_LITE_BAR,
message.getExtension(repeatedForeignEnumExtensionLite, 0));
assertEqualsExactType(
ImportEnumLite.IMPORT_LITE_BAR, message.getExtension(repeatedImportEnumExtensionLite, 0));
assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtensionLite, 0));
assertEqualsExactType("225", message.getExtension(repeatedCordExtensionLite, 0));
assertEqualsExactType(301, message.getExtension(repeatedInt32ExtensionLite, 1));
assertEqualsExactType(302L, message.getExtension(repeatedInt64ExtensionLite, 1));
assertEqualsExactType(303, message.getExtension(repeatedUint32ExtensionLite, 1));
assertEqualsExactType(304L, message.getExtension(repeatedUint64ExtensionLite, 1));
assertEqualsExactType(305, message.getExtension(repeatedSint32ExtensionLite, 1));
assertEqualsExactType(306L, message.getExtension(repeatedSint64ExtensionLite, 1));
assertEqualsExactType(307, message.getExtension(repeatedFixed32ExtensionLite, 1));
assertEqualsExactType(308L, message.getExtension(repeatedFixed64ExtensionLite, 1));
assertEqualsExactType(309, message.getExtension(repeatedSfixed32ExtensionLite, 1));
assertEqualsExactType(310L, message.getExtension(repeatedSfixed64ExtensionLite, 1));
assertEqualsExactType(311F, message.getExtension(repeatedFloatExtensionLite, 1));
assertEqualsExactType(312D, message.getExtension(repeatedDoubleExtensionLite, 1));
assertEqualsExactType(false, message.getExtension(repeatedBoolExtensionLite, 1));
assertEqualsExactType("315", message.getExtension(repeatedStringExtensionLite, 1));
assertEqualsExactType(toBytes("316"), message.getExtension(repeatedBytesExtensionLite, 1));
assertEqualsExactType(317, message.getExtension(repeatedGroupExtensionLite, 1).getA());
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));
assertEqualsExactType(
ForeignEnumLite.FOREIGN_LITE_BAZ,
message.getExtension(repeatedForeignEnumExtensionLite, 1));
assertEqualsExactType(
ImportEnumLite.IMPORT_LITE_BAZ, message.getExtension(repeatedImportEnumExtensionLite, 1));
assertEqualsExactType("324", message.getExtension(repeatedStringPieceExtensionLite, 1));
assertEqualsExactType("325", message.getExtension(repeatedCordExtensionLite, 1));
// -----------------------------------------------------------------
Assert.assertTrue(message.hasExtension(defaultInt32ExtensionLite));
Assert.assertTrue(message.hasExtension(defaultInt64ExtensionLite));
Assert.assertTrue(message.hasExtension(defaultUint32ExtensionLite));
Assert.assertTrue(message.hasExtension(defaultUint64ExtensionLite));
Assert.assertTrue(message.hasExtension(defaultSint32ExtensionLite));
Assert.assertTrue(message.hasExtension(defaultSint64ExtensionLite));
Assert.assertTrue(message.hasExtension(defaultFixed32ExtensionLite));
Assert.assertTrue(message.hasExtension(defaultFixed64ExtensionLite));
Assert.assertTrue(message.hasExtension(defaultSfixed32ExtensionLite));
Assert.assertTrue(message.hasExtension(defaultSfixed64ExtensionLite));
Assert.assertTrue(message.hasExtension(defaultFloatExtensionLite));
Assert.assertTrue(message.hasExtension(defaultDoubleExtensionLite));
Assert.assertTrue(message.hasExtension(defaultBoolExtensionLite));
Assert.assertTrue(message.hasExtension(defaultStringExtensionLite));
Assert.assertTrue(message.hasExtension(defaultBytesExtensionLite));
Assert.assertTrue(message.hasExtension(defaultNestedEnumExtensionLite));
Assert.assertTrue(message.hasExtension(defaultForeignEnumExtensionLite));
Assert.assertTrue(message.hasExtension(defaultImportEnumExtensionLite));
Assert.assertTrue(message.hasExtension(defaultStringPieceExtensionLite));
Assert.assertTrue(message.hasExtension(defaultCordExtensionLite));
assertEqualsExactType(401, message.getExtension(defaultInt32ExtensionLite));
assertEqualsExactType(402L, message.getExtension(defaultInt64ExtensionLite));
assertEqualsExactType(403, message.getExtension(defaultUint32ExtensionLite));
assertEqualsExactType(404L, message.getExtension(defaultUint64ExtensionLite));
assertEqualsExactType(405, message.getExtension(defaultSint32ExtensionLite));
assertEqualsExactType(406L, message.getExtension(defaultSint64ExtensionLite));
assertEqualsExactType(407, message.getExtension(defaultFixed32ExtensionLite));
assertEqualsExactType(408L, message.getExtension(defaultFixed64ExtensionLite));
assertEqualsExactType(409, message.getExtension(defaultSfixed32ExtensionLite));
assertEqualsExactType(410L, message.getExtension(defaultSfixed64ExtensionLite));
assertEqualsExactType(411F, message.getExtension(defaultFloatExtensionLite));
assertEqualsExactType(412D, message.getExtension(defaultDoubleExtensionLite));
assertEqualsExactType(false, message.getExtension(defaultBoolExtensionLite));
assertEqualsExactType("415", message.getExtension(defaultStringExtensionLite));
assertEqualsExactType(toBytes("416"), message.getExtension(defaultBytesExtensionLite));
assertEqualsExactType(
TestAllTypesLite.NestedEnum.FOO, message.getExtension(defaultNestedEnumExtensionLite));
assertEqualsExactType(
ForeignEnumLite.FOREIGN_LITE_FOO, message.getExtension(defaultForeignEnumExtensionLite));
assertEqualsExactType(
ImportEnumLite.IMPORT_LITE_FOO, message.getExtension(defaultImportEnumExtensionLite));
assertEqualsExactType("424", message.getExtension(defaultStringPieceExtensionLite));
assertEqualsExactType("425", message.getExtension(defaultCordExtensionLite));
Assert.assertTrue(message.hasExtension(oneofBytesExtensionLite));
assertEqualsExactType(toBytes("604"), message.getExtension(oneofBytesExtensionLite));
} |
Assert (using {@code junit.framework.Assert}} that all extensions of {@code message} are set to
the values assigned by {@code setAllExtensions}.
| TestUtil::assertAllExtensionsSet | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void assertExtensionsClear(TestAllExtensionsLiteOrBuilder message) {
// hasBlah() should initially be false for all optional fields.
Assert.assertFalse(message.hasExtension(optionalInt32ExtensionLite));
Assert.assertFalse(message.hasExtension(optionalInt64ExtensionLite));
Assert.assertFalse(message.hasExtension(optionalUint32ExtensionLite));
Assert.assertFalse(message.hasExtension(optionalUint64ExtensionLite));
Assert.assertFalse(message.hasExtension(optionalSint32ExtensionLite));
Assert.assertFalse(message.hasExtension(optionalSint64ExtensionLite));
Assert.assertFalse(message.hasExtension(optionalFixed32ExtensionLite));
Assert.assertFalse(message.hasExtension(optionalFixed64ExtensionLite));
Assert.assertFalse(message.hasExtension(optionalSfixed32ExtensionLite));
Assert.assertFalse(message.hasExtension(optionalSfixed64ExtensionLite));
Assert.assertFalse(message.hasExtension(optionalFloatExtensionLite));
Assert.assertFalse(message.hasExtension(optionalDoubleExtensionLite));
Assert.assertFalse(message.hasExtension(optionalBoolExtensionLite));
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(optionalPublicImportMessageExtensionLite));
Assert.assertFalse(message.hasExtension(optionalLazyMessageExtensionLite));
Assert.assertFalse(message.hasExtension(optionalNestedEnumExtensionLite));
Assert.assertFalse(message.hasExtension(optionalForeignEnumExtensionLite));
Assert.assertFalse(message.hasExtension(optionalImportEnumExtensionLite));
Assert.assertFalse(message.hasExtension(optionalStringPieceExtensionLite));
Assert.assertFalse(message.hasExtension(optionalCordExtensionLite));
// Optional fields without defaults are set to zero or something like it.
assertEqualsExactType(0, message.getExtension(optionalInt32ExtensionLite));
assertEqualsExactType(0L, message.getExtension(optionalInt64ExtensionLite));
assertEqualsExactType(0, message.getExtension(optionalUint32ExtensionLite));
assertEqualsExactType(0L, message.getExtension(optionalUint64ExtensionLite));
assertEqualsExactType(0, message.getExtension(optionalSint32ExtensionLite));
assertEqualsExactType(0L, message.getExtension(optionalSint64ExtensionLite));
assertEqualsExactType(0, message.getExtension(optionalFixed32ExtensionLite));
assertEqualsExactType(0L, message.getExtension(optionalFixed64ExtensionLite));
assertEqualsExactType(0, message.getExtension(optionalSfixed32ExtensionLite));
assertEqualsExactType(0L, message.getExtension(optionalSfixed64ExtensionLite));
assertEqualsExactType(0F, message.getExtension(optionalFloatExtensionLite));
assertEqualsExactType(0D, message.getExtension(optionalDoubleExtensionLite));
assertEqualsExactType(false, message.getExtension(optionalBoolExtensionLite));
assertEqualsExactType("", message.getExtension(optionalStringExtensionLite));
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(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, message.getExtension(optionalNestedEnumExtensionLite));
assertEqualsExactType(
ForeignEnumLite.FOREIGN_LITE_FOO, message.getExtension(optionalForeignEnumExtensionLite));
assertEqualsExactType(
ImportEnumLite.IMPORT_LITE_FOO, message.getExtension(optionalImportEnumExtensionLite));
assertEqualsExactType("", message.getExtension(optionalStringPieceExtensionLite));
assertEqualsExactType("", message.getExtension(optionalCordExtensionLite));
// Repeated fields are empty.
Assert.assertEquals(0, message.getExtensionCount(repeatedInt32ExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedInt64ExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedUint32ExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedUint64ExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedSint32ExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedSint64ExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedFixed32ExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedFixed64ExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed32ExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed64ExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedFloatExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedDoubleExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedBoolExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedStringExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedBytesExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedGroupExtensionLite));
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));
Assert.assertEquals(0, message.getExtensionCount(repeatedStringPieceExtensionLite));
Assert.assertEquals(0, message.getExtensionCount(repeatedCordExtensionLite));
// hasBlah() should also be false for all default fields.
Assert.assertFalse(message.hasExtension(defaultInt32ExtensionLite));
Assert.assertFalse(message.hasExtension(defaultInt64ExtensionLite));
Assert.assertFalse(message.hasExtension(defaultUint32ExtensionLite));
Assert.assertFalse(message.hasExtension(defaultUint64ExtensionLite));
Assert.assertFalse(message.hasExtension(defaultSint32ExtensionLite));
Assert.assertFalse(message.hasExtension(defaultSint64ExtensionLite));
Assert.assertFalse(message.hasExtension(defaultFixed32ExtensionLite));
Assert.assertFalse(message.hasExtension(defaultFixed64ExtensionLite));
Assert.assertFalse(message.hasExtension(defaultSfixed32ExtensionLite));
Assert.assertFalse(message.hasExtension(defaultSfixed64ExtensionLite));
Assert.assertFalse(message.hasExtension(defaultFloatExtensionLite));
Assert.assertFalse(message.hasExtension(defaultDoubleExtensionLite));
Assert.assertFalse(message.hasExtension(defaultBoolExtensionLite));
Assert.assertFalse(message.hasExtension(defaultStringExtensionLite));
Assert.assertFalse(message.hasExtension(defaultBytesExtensionLite));
Assert.assertFalse(message.hasExtension(defaultNestedEnumExtensionLite));
Assert.assertFalse(message.hasExtension(defaultForeignEnumExtensionLite));
Assert.assertFalse(message.hasExtension(defaultImportEnumExtensionLite));
Assert.assertFalse(message.hasExtension(defaultStringPieceExtensionLite));
Assert.assertFalse(message.hasExtension(defaultCordExtensionLite));
// Fields with defaults have their default values (duh).
assertEqualsExactType(41, message.getExtension(defaultInt32ExtensionLite));
assertEqualsExactType(42L, message.getExtension(defaultInt64ExtensionLite));
assertEqualsExactType(43, message.getExtension(defaultUint32ExtensionLite));
assertEqualsExactType(44L, message.getExtension(defaultUint64ExtensionLite));
assertEqualsExactType(-45, message.getExtension(defaultSint32ExtensionLite));
assertEqualsExactType(46L, message.getExtension(defaultSint64ExtensionLite));
assertEqualsExactType(47, message.getExtension(defaultFixed32ExtensionLite));
assertEqualsExactType(48L, message.getExtension(defaultFixed64ExtensionLite));
assertEqualsExactType(49, message.getExtension(defaultSfixed32ExtensionLite));
assertEqualsExactType(-50L, message.getExtension(defaultSfixed64ExtensionLite));
assertEqualsExactType(51.5F, message.getExtension(defaultFloatExtensionLite));
assertEqualsExactType(52e3D, message.getExtension(defaultDoubleExtensionLite));
assertEqualsExactType(true, message.getExtension(defaultBoolExtensionLite));
assertEqualsExactType("hello", message.getExtension(defaultStringExtensionLite));
assertEqualsExactType(toBytes("world"), message.getExtension(defaultBytesExtensionLite));
assertEqualsExactType(
TestAllTypesLite.NestedEnum.BAR, message.getExtension(defaultNestedEnumExtensionLite));
assertEqualsExactType(
ForeignEnumLite.FOREIGN_LITE_BAR, message.getExtension(defaultForeignEnumExtensionLite));
assertEqualsExactType(
ImportEnumLite.IMPORT_LITE_BAR, message.getExtension(defaultImportEnumExtensionLite));
assertEqualsExactType("abc", message.getExtension(defaultStringPieceExtensionLite));
assertEqualsExactType("123", message.getExtension(defaultCordExtensionLite));
Assert.assertFalse(message.hasExtension(oneofUint32ExtensionLite));
Assert.assertFalse(message.hasExtension(oneofNestedMessageExtensionLite));
Assert.assertFalse(message.hasExtension(oneofStringExtensionLite));
Assert.assertFalse(message.hasExtension(oneofBytesExtensionLite));
} |
Assert (using {@code junit.framework.Assert}} that all extensions of {@code message} are
cleared, and that getting the extensions returns their default values.
| TestUtil::assertExtensionsClear | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void assertRepeatedExtensionsModified(TestAllExtensionsLiteOrBuilder message) {
// ModifyRepeatedFields only sets the second repeated element of each
// field. In addition to verifying this, we also verify that the first
// element and size were *not* modified.
Assert.assertEquals(2, message.getExtensionCount(repeatedInt32ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedInt64ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedUint32ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedUint64ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedSint32ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedSint64ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64ExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtensionLite));
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));
Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtensionLite));
Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtensionLite));
assertEqualsExactType(201, message.getExtension(repeatedInt32ExtensionLite, 0));
assertEqualsExactType(202L, message.getExtension(repeatedInt64ExtensionLite, 0));
assertEqualsExactType(203, message.getExtension(repeatedUint32ExtensionLite, 0));
assertEqualsExactType(204L, message.getExtension(repeatedUint64ExtensionLite, 0));
assertEqualsExactType(205, message.getExtension(repeatedSint32ExtensionLite, 0));
assertEqualsExactType(206L, message.getExtension(repeatedSint64ExtensionLite, 0));
assertEqualsExactType(207, message.getExtension(repeatedFixed32ExtensionLite, 0));
assertEqualsExactType(208L, message.getExtension(repeatedFixed64ExtensionLite, 0));
assertEqualsExactType(209, message.getExtension(repeatedSfixed32ExtensionLite, 0));
assertEqualsExactType(210L, message.getExtension(repeatedSfixed64ExtensionLite, 0));
assertEqualsExactType(211F, message.getExtension(repeatedFloatExtensionLite, 0));
assertEqualsExactType(212D, message.getExtension(repeatedDoubleExtensionLite, 0));
assertEqualsExactType(true, message.getExtension(repeatedBoolExtensionLite, 0));
assertEqualsExactType("215", message.getExtension(repeatedStringExtensionLite, 0));
assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtensionLite, 0));
assertEqualsExactType(217, message.getExtension(repeatedGroupExtensionLite, 0).getA());
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));
assertEqualsExactType(
ForeignEnumLite.FOREIGN_LITE_BAR,
message.getExtension(repeatedForeignEnumExtensionLite, 0));
assertEqualsExactType(
ImportEnumLite.IMPORT_LITE_BAR, message.getExtension(repeatedImportEnumExtensionLite, 0));
assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtensionLite, 0));
assertEqualsExactType("225", message.getExtension(repeatedCordExtensionLite, 0));
// Actually verify the second (modified) elements now.
assertEqualsExactType(501, message.getExtension(repeatedInt32ExtensionLite, 1));
assertEqualsExactType(502L, message.getExtension(repeatedInt64ExtensionLite, 1));
assertEqualsExactType(503, message.getExtension(repeatedUint32ExtensionLite, 1));
assertEqualsExactType(504L, message.getExtension(repeatedUint64ExtensionLite, 1));
assertEqualsExactType(505, message.getExtension(repeatedSint32ExtensionLite, 1));
assertEqualsExactType(506L, message.getExtension(repeatedSint64ExtensionLite, 1));
assertEqualsExactType(507, message.getExtension(repeatedFixed32ExtensionLite, 1));
assertEqualsExactType(508L, message.getExtension(repeatedFixed64ExtensionLite, 1));
assertEqualsExactType(509, message.getExtension(repeatedSfixed32ExtensionLite, 1));
assertEqualsExactType(510L, message.getExtension(repeatedSfixed64ExtensionLite, 1));
assertEqualsExactType(511F, message.getExtension(repeatedFloatExtensionLite, 1));
assertEqualsExactType(512D, message.getExtension(repeatedDoubleExtensionLite, 1));
assertEqualsExactType(true, message.getExtension(repeatedBoolExtensionLite, 1));
assertEqualsExactType("515", message.getExtension(repeatedStringExtensionLite, 1));
assertEqualsExactType(toBytes("516"), message.getExtension(repeatedBytesExtensionLite, 1));
assertEqualsExactType(517, message.getExtension(repeatedGroupExtensionLite, 1).getA());
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));
assertEqualsExactType(
ForeignEnumLite.FOREIGN_LITE_FOO,
message.getExtension(repeatedForeignEnumExtensionLite, 1));
assertEqualsExactType(
ImportEnumLite.IMPORT_LITE_FOO, message.getExtension(repeatedImportEnumExtensionLite, 1));
assertEqualsExactType("524", message.getExtension(repeatedStringPieceExtensionLite, 1));
assertEqualsExactType("525", message.getExtension(repeatedCordExtensionLite, 1));
} |
Assert (using {@code junit.framework.Assert}} that all extensions of {@code message} are set to
the values assigned by {@code setAllExtensions} followed by {@code modifyRepeatedExtensions}.
| TestUtil::assertRepeatedExtensionsModified | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public void setLocale(Locale locale)
{
fLocale = locale;
} |
Set the Locale object to use.
@param locale non-null reference to Locale object.
| XMLMessages::setLocale | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/res/XMLMessages.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/res/XMLMessages.java | Apache-2.0 |
public Locale getLocale()
{
return fLocale;
} |
Get the Locale object that is being used.
@return non-null reference to Locale object.
| XMLMessages::getLocale | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/res/XMLMessages.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/res/XMLMessages.java | Apache-2.0 |
public static final String createXMLMessage(String msgKey, Object args[])
{
// BEGIN android-changed
// don't localize exceptions
return createMsg(XMLBundle, msgKey, args);
// END android-changed
} |
Creates a message from the specified key and replacement
arguments, localized to the given locale.
@param msgKey The key for the message text.
@param args The arguments to be used as replacement text
in the message created.
@return The formatted message string.
| XMLMessages::createXMLMessage | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/res/XMLMessages.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/res/XMLMessages.java | Apache-2.0 |
public static final String createMsg(ListResourceBundle fResourceBundle,
String msgKey, Object args[]) //throws Exception
{
String fmsg = null;
boolean throwex = false;
String msg = null;
if (msgKey != null)
msg = fResourceBundle.getString(msgKey);
if (msg == null)
{
msg = fResourceBundle.getString(BAD_CODE);
throwex = true;
}
if (args != null)
{
try
{
// Do this to keep format from crying.
// This is better than making a bunch of conditional
// code all over the place.
int n = args.length;
for (int i = 0; i < n; i++)
{
if (null == args[i])
args[i] = "";
}
fmsg = java.text.MessageFormat.format(msg, args);
}
catch (Exception e)
{
fmsg = fResourceBundle.getString(FORMAT_FAILED);
fmsg += " " + msg;
}
}
else
fmsg = msg;
if (throwex)
{
throw new RuntimeException(fmsg);
}
return fmsg;
} |
Creates a message from the specified key and replacement
arguments, localized to the given locale.
@param fResourceBundle The resource bundle to use.
@param msgKey The message key to use.
@param args The arguments to be used as replacement text
in the message created.
@return The formatted message string.
| XMLMessages::createMsg | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/res/XMLMessages.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/res/XMLMessages.java | Apache-2.0 |
public Object[][] getContents()
{
return new Object[][] {
/** Error message ID that has a null message, but takes in a single object. */
{"ER0000" , "{0}" },
{ ER_FUNCTION_NOT_SUPPORTED,
"Function not supported!"},
{ ER_CANNOT_OVERWRITE_CAUSE,
"Cannot overwrite cause"},
{ ER_NO_DEFAULT_IMPL,
"No default implementation found "},
{ ER_CHUNKEDINTARRAY_NOT_SUPPORTED,
"ChunkedIntArray({0}) not currently supported"},
{ ER_OFFSET_BIGGER_THAN_SLOT,
"Offset bigger than slot"},
{ ER_COROUTINE_NOT_AVAIL,
"Coroutine not available, id={0}"},
{ ER_COROUTINE_CO_EXIT,
"CoroutineManager received co_exit() request"},
{ ER_COJOINROUTINESET_FAILED,
"co_joinCoroutineSet() failed"},
{ ER_COROUTINE_PARAM,
"Coroutine parameter error ({0})"},
{ ER_PARSER_DOTERMINATE_ANSWERS,
"\nUNEXPECTED: Parser doTerminate answers {0}"},
{ ER_NO_PARSE_CALL_WHILE_PARSING,
"parse may not be called while parsing"},
{ ER_TYPED_ITERATOR_AXIS_NOT_IMPLEMENTED,
"Error: typed iterator for axis {0} not implemented"},
{ ER_ITERATOR_AXIS_NOT_IMPLEMENTED,
"Error: iterator for axis {0} not implemented "},
{ ER_ITERATOR_CLONE_NOT_SUPPORTED,
"Iterator clone not supported"},
{ ER_UNKNOWN_AXIS_TYPE,
"Unknown axis traversal type: {0}"},
{ ER_AXIS_NOT_SUPPORTED,
"Axis traverser not supported: {0}"},
{ ER_NO_DTMIDS_AVAIL,
"No more DTM IDs are available"},
{ ER_NOT_SUPPORTED,
"Not supported: {0}"},
{ ER_NODE_NON_NULL,
"Node must be non-null for getDTMHandleFromNode"},
{ ER_COULD_NOT_RESOLVE_NODE,
"Could not resolve the node to a handle"},
{ ER_STARTPARSE_WHILE_PARSING,
"startParse may not be called while parsing"},
{ ER_STARTPARSE_NEEDS_SAXPARSER,
"startParse needs a non-null SAXParser"},
{ ER_COULD_NOT_INIT_PARSER,
"could not initialize parser with"},
{ ER_EXCEPTION_CREATING_POOL,
"exception creating new instance for pool"},
{ ER_PATH_CONTAINS_INVALID_ESCAPE_SEQUENCE,
"Path contains invalid escape sequence"},
{ ER_SCHEME_REQUIRED,
"Scheme is required!"},
{ ER_NO_SCHEME_IN_URI,
"No scheme found in URI: {0}"},
{ ER_NO_SCHEME_INURI,
"No scheme found in URI"},
{ ER_PATH_INVALID_CHAR,
"Path contains invalid character: {0}"},
{ ER_SCHEME_FROM_NULL_STRING,
"Cannot set scheme from null string"},
{ ER_SCHEME_NOT_CONFORMANT,
"The scheme is not conformant."},
{ ER_HOST_ADDRESS_NOT_WELLFORMED,
"Host is not a well formed address"},
{ ER_PORT_WHEN_HOST_NULL,
"Port cannot be set when host is null"},
{ ER_INVALID_PORT,
"Invalid port number"},
{ ER_FRAG_FOR_GENERIC_URI,
"Fragment can only be set for a generic URI"},
{ ER_FRAG_WHEN_PATH_NULL,
"Fragment cannot be set when path is null"},
{ ER_FRAG_INVALID_CHAR,
"Fragment contains invalid character"},
{ ER_PARSER_IN_USE,
"Parser is already in use"},
{ ER_CANNOT_CHANGE_WHILE_PARSING,
"Cannot change {0} {1} while parsing"},
{ ER_SELF_CAUSATION_NOT_PERMITTED,
"Self-causation not permitted"},
{ ER_NO_USERINFO_IF_NO_HOST,
"Userinfo may not be specified if host is not specified"},
{ ER_NO_PORT_IF_NO_HOST,
"Port may not be specified if host is not specified"},
{ ER_NO_QUERY_STRING_IN_PATH,
"Query string cannot be specified in path and query string"},
{ ER_NO_FRAGMENT_STRING_IN_PATH,
"Fragment cannot be specified in both the path and fragment"},
{ ER_CANNOT_INIT_URI_EMPTY_PARMS,
"Cannot initialize URI with empty parameters"},
{ ER_METHOD_NOT_SUPPORTED,
"Method not yet supported "},
{ ER_INCRSAXSRCFILTER_NOT_RESTARTABLE,
"IncrementalSAXSource_Filter not currently restartable"},
{ ER_XMLRDR_NOT_BEFORE_STARTPARSE,
"XMLReader not before startParse request"},
{ ER_AXIS_TRAVERSER_NOT_SUPPORTED,
"Axis traverser not supported: {0}"},
{ ER_ERRORHANDLER_CREATED_WITH_NULL_PRINTWRITER,
"ListingErrorHandler created with null PrintWriter!"},
{ ER_SYSTEMID_UNKNOWN,
"SystemId Unknown"},
{ ER_LOCATION_UNKNOWN,
"Location of error unknown"},
{ ER_PREFIX_MUST_RESOLVE,
"Prefix must resolve to a namespace: {0}"},
{ ER_CREATEDOCUMENT_NOT_SUPPORTED,
"createDocument() not supported in XPathContext!"},
{ ER_CHILD_HAS_NO_OWNER_DOCUMENT,
"Attribute child does not have an owner document!"},
{ ER_CHILD_HAS_NO_OWNER_DOCUMENT_ELEMENT,
"Attribute child does not have an owner document element!"},
{ ER_CANT_OUTPUT_TEXT_BEFORE_DOC,
"Warning: can't output text before document element! Ignoring..."},
{ ER_CANT_HAVE_MORE_THAN_ONE_ROOT,
"Can't have more than one root on a DOM!"},
{ ER_ARG_LOCALNAME_NULL,
"Argument 'localName' is null"},
// Note to translators: A QNAME has the syntactic form [NCName:]NCName
// The localname is the portion after the optional colon; the message indicates
// that there is a problem with that part of the QNAME.
{ ER_ARG_LOCALNAME_INVALID,
"Localname in QNAME should be a valid NCName"},
// Note to translators: A QNAME has the syntactic form [NCName:]NCName
// The prefix is the portion before the optional colon; the message indicates
// that there is a problem with that part of the QNAME.
{ ER_ARG_PREFIX_INVALID,
"Prefix in QNAME should be a valid NCName"},
{ ER_NAME_CANT_START_WITH_COLON,
"Name cannot start with a colon"},
{ "BAD_CODE", "Parameter to createMessage was out of bounds"},
{ "FORMAT_FAILED", "Exception thrown during messageFormat call"},
{ "line", "Line #"},
{ "column","Column #"}
};
} |
Get the lookup table for error messages
@return The association list.
| XMLErrorResources::getContents | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/res/XMLErrorResources.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/res/XMLErrorResources.java | Apache-2.0 |
public ToUnknownStream()
{
m_handler = new ToXMLStream();
} |
Default constructor.
Initially this object wraps an XML Stream object, so _handler is never null.
That may change later to an HTML Stream object.
| ToUnknownStream::ToUnknownStream | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public ContentHandler asContentHandler() throws IOException
{
/* don't return the real handler ( m_handler ) because
* that would expose the real handler to the outside.
* Keep m_handler private so it can be internally swapped
* to an HTML handler.
*/
return this;
} |
@see Serializer#asContentHandler()
@return the wrapped XML or HTML handler
| ToUnknownStream::asContentHandler | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void close()
{
m_handler.close();
} |
@see SerializationHandler#close()
| ToUnknownStream::close | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public Properties getOutputFormat()
{
return m_handler.getOutputFormat();
} |
@see Serializer#getOutputFormat()
@return the properties of the underlying handler
| ToUnknownStream::getOutputFormat | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public OutputStream getOutputStream()
{
return m_handler.getOutputStream();
} |
@see Serializer#getOutputStream()
@return the OutputStream of the underlying XML or HTML handler
| ToUnknownStream::getOutputStream | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public Writer getWriter()
{
return m_handler.getWriter();
} |
@see Serializer#getWriter()
@return the Writer of the underlying XML or HTML handler
| ToUnknownStream::getWriter | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public boolean reset()
{
return m_handler.reset();
} |
passes the call on to the underlying HTML or XML handler
@see Serializer#reset()
@return ???
| ToUnknownStream::reset | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void serialize(Node node) throws IOException
{
if (m_firstTagNotEmitted)
{
flush();
}
m_handler.serialize(node);
} |
Converts the DOM node to output
@param node the DOM node to transform to output
@see DOMSerializer#serialize(Node)
| ToUnknownStream::serialize | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public boolean setEscaping(boolean escape) throws SAXException
{
return m_handler.setEscaping(escape);
} |
@see SerializationHandler#setEscaping(boolean)
| ToUnknownStream::setEscaping | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setOutputFormat(Properties format)
{
m_handler.setOutputFormat(format);
} |
Set the properties of the handler
@param format the output properties to set
@see Serializer#setOutputFormat(Properties)
| ToUnknownStream::setOutputFormat | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setOutputStream(OutputStream output)
{
m_handler.setOutputStream(output);
} |
Sets the output stream to write to
@param output the OutputStream to write to
@see Serializer#setOutputStream(OutputStream)
| ToUnknownStream::setOutputStream | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setWriter(Writer writer)
{
m_handler.setWriter(writer);
} |
Sets the writer to write to
@param writer the writer to write to
@see Serializer#setWriter(Writer)
| ToUnknownStream::setWriter | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void addAttribute(
String uri,
String localName,
String rawName,
String type,
String value,
boolean XSLAttribute)
throws SAXException
{
if (m_firstTagNotEmitted)
{
flush();
}
m_handler.addAttribute(uri, localName, rawName, type, value, XSLAttribute);
} |
Adds an attribute to the currenly open tag
@param uri the URI of a namespace
@param localName the attribute name, without prefix
@param rawName the attribute name, with prefix (if any)
@param type the type of the attribute, typically "CDATA"
@param value the value of the parameter
@param XSLAttribute true if this attribute is coming from an xsl:attribute element
@see ExtendedContentHandler#addAttribute(String, String, String, String, String)
| ToUnknownStream::addAttribute | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void addAttribute(String rawName, String value)
{
if (m_firstTagNotEmitted)
{
flush();
}
m_handler.addAttribute(rawName, value);
} |
Adds an attribute to the currenly open tag
@param rawName the attribute name, with prefix (if any)
@param value the value of the parameter
@see ExtendedContentHandler#addAttribute(String, String)
| ToUnknownStream::addAttribute | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void addUniqueAttribute(String rawName, String value, int flags)
throws SAXException
{
if (m_firstTagNotEmitted)
{
flush();
}
m_handler.addUniqueAttribute(rawName, value, flags);
} |
Adds a unique attribute to the currenly open tag
| ToUnknownStream::addUniqueAttribute | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void characters(String chars) throws SAXException
{
final int length = chars.length();
if (length > m_charsBuff.length)
{
m_charsBuff = new char[length*2 + 1];
}
chars.getChars(0, length, m_charsBuff, 0);
this.characters(m_charsBuff, 0, length);
} |
Converts the String to a character array and calls the SAX method
characters(char[],int,int);
@see ExtendedContentHandler#characters(String)
| ToUnknownStream::characters | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void endElement(String elementName) throws SAXException
{
if (m_firstTagNotEmitted)
{
flush();
}
m_handler.endElement(elementName);
} |
Pass the call on to the underlying handler
@see ExtendedContentHandler#endElement(String)
| ToUnknownStream::endElement | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void startPrefixMapping(String prefix, String uri) throws SAXException
{
this.startPrefixMapping(prefix,uri, true);
} |
@see org.xml.sax.ContentHandler#startPrefixMapping(String, String)
@param prefix The prefix that maps to the URI
@param uri The URI for the namespace
| ToUnknownStream::startPrefixMapping | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void namespaceAfterStartElement(String prefix, String uri)
throws SAXException
{
// hack for XSLTC with finding URI for default namespace
if (m_firstTagNotEmitted && m_firstElementURI == null && m_firstElementName != null)
{
String prefix1 = getPrefixPart(m_firstElementName);
if (prefix1 == null && EMPTYSTRING.equals(prefix))
{
// the elements URI is not known yet, and it
// doesn't have a prefix, and we are currently
// setting the uri for prefix "", so we have
// the uri for the element... lets remember it
m_firstElementURI = uri;
}
}
startPrefixMapping(prefix,uri, false);
} |
This method is used when a prefix/uri namespace mapping
is indicated after the element was started with a
startElement() and before and endElement().
startPrefixMapping(prefix,uri) would be used before the
startElement() call.
@param uri the URI of the namespace
@param prefix the prefix associated with the given URI.
@see ExtendedContentHandler#namespaceAfterStartElement(String, String)
| ToUnknownStream::namespaceAfterStartElement | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void startDocument() throws SAXException
{
m_needToCallStartDocument = true;
} |
@see org.xml.sax.ContentHandler#startDocument()
| ToUnknownStream::startDocument | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void comment(String comment) throws SAXException
{
if (m_firstTagNotEmitted && m_firstElementName != null)
{
emitFirstTag();
}
else if (m_needToCallStartDocument)
{
m_handler.startDocument();
m_needToCallStartDocument = false;
}
m_handler.comment(comment);
} |
Pass the call on to the underlying handler
@see ExtendedLexicalHandler#comment(String)
| ToUnknownStream::comment | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public String getDoctypePublic()
{
return m_handler.getDoctypePublic();
} |
Pass the call on to the underlying handler
@see XSLOutputAttributes#getDoctypePublic()
| ToUnknownStream::getDoctypePublic | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public String getDoctypeSystem()
{
return m_handler.getDoctypeSystem();
} |
Pass the call on to the underlying handler
@see XSLOutputAttributes#getDoctypeSystem()
| ToUnknownStream::getDoctypeSystem | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public String getEncoding()
{
return m_handler.getEncoding();
} |
Pass the call on to the underlying handler
@see XSLOutputAttributes#getEncoding()
| ToUnknownStream::getEncoding | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public boolean getIndent()
{
return m_handler.getIndent();
} |
Pass the call on to the underlying handler
@see XSLOutputAttributes#getIndent()
| ToUnknownStream::getIndent | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public int getIndentAmount()
{
return m_handler.getIndentAmount();
} |
Pass the call on to the underlying handler
@see XSLOutputAttributes#getIndentAmount()
| ToUnknownStream::getIndentAmount | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public String getMediaType()
{
return m_handler.getMediaType();
} |
Pass the call on to the underlying handler
@see XSLOutputAttributes#getMediaType()
| ToUnknownStream::getMediaType | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public boolean getOmitXMLDeclaration()
{
return m_handler.getOmitXMLDeclaration();
} |
Pass the call on to the underlying handler
@see XSLOutputAttributes#getOmitXMLDeclaration()
| ToUnknownStream::getOmitXMLDeclaration | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public String getStandalone()
{
return m_handler.getStandalone();
} |
Pass the call on to the underlying handler
@see XSLOutputAttributes#getStandalone()
| ToUnknownStream::getStandalone | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public String getVersion()
{
return m_handler.getVersion();
} |
Pass the call on to the underlying handler
@see XSLOutputAttributes#getVersion()
| ToUnknownStream::getVersion | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setDoctype(String system, String pub)
{
m_handler.setDoctypePublic(pub);
m_handler.setDoctypeSystem(system);
} |
@see XSLOutputAttributes#setDoctype(String, String)
| ToUnknownStream::setDoctype | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setDoctypePublic(String doctype)
{
m_handler.setDoctypePublic(doctype);
m_setDoctypePublic_called = true;
} |
Set the doctype in the underlying XML handler. Remember that this method
was called, just in case we need to transfer this doctype to an HTML handler
@param doctype the public doctype to set
@see XSLOutputAttributes#setDoctypePublic(String)
| ToUnknownStream::setDoctypePublic | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setDoctypeSystem(String doctype)
{
m_handler.setDoctypeSystem(doctype);
m_setDoctypeSystem_called = true;
} |
Set the doctype in the underlying XML handler. Remember that this method
was called, just in case we need to transfer this doctype to an HTML handler
@param doctype the system doctype to set
@see XSLOutputAttributes#setDoctypeSystem(String)
| ToUnknownStream::setDoctypeSystem | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setEncoding(String encoding)
{
m_handler.setEncoding(encoding);
} |
Pass the call on to the underlying handler
@see XSLOutputAttributes#setEncoding(String)
| ToUnknownStream::setEncoding | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setIndent(boolean indent)
{
m_handler.setIndent(indent);
} |
Pass the call on to the underlying handler
@see XSLOutputAttributes#setIndent(boolean)
| ToUnknownStream::setIndent | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setIndentAmount(int value)
{
m_handler.setIndentAmount(value);
} |
Pass the call on to the underlying handler
| ToUnknownStream::setIndentAmount | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setMediaType(String mediaType)
{
m_handler.setMediaType(mediaType);
m_setMediaType_called = true;
} |
@see XSLOutputAttributes#setMediaType(String)
| ToUnknownStream::setMediaType | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setOmitXMLDeclaration(boolean b)
{
m_handler.setOmitXMLDeclaration(b);
} |
Pass the call on to the underlying handler
@see XSLOutputAttributes#setOmitXMLDeclaration(boolean)
| ToUnknownStream::setOmitXMLDeclaration | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setStandalone(String standalone)
{
m_handler.setStandalone(standalone);
} |
Pass the call on to the underlying handler
@see XSLOutputAttributes#setStandalone(String)
| ToUnknownStream::setStandalone | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void attributeDecl(
String arg0,
String arg1,
String arg2,
String arg3,
String arg4)
throws SAXException
{
m_handler.attributeDecl(arg0, arg1, arg2, arg3, arg4);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ext.DeclHandler#attributeDecl(String, String, String, String, String)
| ToUnknownStream::attributeDecl | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void elementDecl(String arg0, String arg1) throws SAXException
{
if (m_firstTagNotEmitted)
{
emitFirstTag();
}
m_handler.elementDecl(arg0, arg1);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ext.DeclHandler#elementDecl(String, String)
| ToUnknownStream::elementDecl | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void externalEntityDecl(
String name,
String publicId,
String systemId)
throws SAXException
{
if (m_firstTagNotEmitted)
{
flush();
}
m_handler.externalEntityDecl(name, publicId, systemId);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ext.DeclHandler#externalEntityDecl(String, String, String)
| ToUnknownStream::externalEntityDecl | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void internalEntityDecl(String arg0, String arg1)
throws SAXException
{
if (m_firstTagNotEmitted)
{
flush();
}
m_handler.internalEntityDecl(arg0, arg1);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ext.DeclHandler#internalEntityDecl(String, String)
| ToUnknownStream::internalEntityDecl | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void characters(char[] characters, int offset, int length)
throws SAXException
{
if (m_firstTagNotEmitted)
{
flush();
}
m_handler.characters(characters, offset, length);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ContentHandler#characters(char[], int, int)
| ToUnknownStream::characters | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void endDocument() throws SAXException
{
if (m_firstTagNotEmitted)
{
flush();
}
m_handler.endDocument();
} |
Pass the call on to the underlying handler
@see org.xml.sax.ContentHandler#endDocument()
| ToUnknownStream::endDocument | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void endElement(String namespaceURI, String localName, String qName)
throws SAXException
{
if (m_firstTagNotEmitted)
{
flush();
if (namespaceURI == null && m_firstElementURI != null)
namespaceURI = m_firstElementURI;
if (localName == null && m_firstElementLocalName != null)
localName = m_firstElementLocalName;
}
m_handler.endElement(namespaceURI, localName, qName);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ContentHandler#endElement(String, String, String)
| ToUnknownStream::endElement | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void endPrefixMapping(String prefix) throws SAXException
{
m_handler.endPrefixMapping(prefix);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ContentHandler#endPrefixMapping(String)
| ToUnknownStream::endPrefixMapping | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void ignorableWhitespace(char[] ch, int start, int length)
throws SAXException
{
if (m_firstTagNotEmitted)
{
flush();
}
m_handler.ignorableWhitespace(ch, start, length);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ContentHandler#ignorableWhitespace(char[], int, int)
| ToUnknownStream::ignorableWhitespace | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void processingInstruction(String target, String data)
throws SAXException
{
if (m_firstTagNotEmitted)
{
flush();
}
m_handler.processingInstruction(target, data);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ContentHandler#processingInstruction(String, String)
| ToUnknownStream::processingInstruction | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setDocumentLocator(Locator locator)
{
m_handler.setDocumentLocator(locator);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ContentHandler#setDocumentLocator(Locator)
| ToUnknownStream::setDocumentLocator | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void skippedEntity(String name) throws SAXException
{
m_handler.skippedEntity(name);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ContentHandler#skippedEntity(String)
| ToUnknownStream::skippedEntity | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void comment(char[] ch, int start, int length) throws SAXException
{
if (m_firstTagNotEmitted)
{
flush();
}
m_handler.comment(ch, start, length);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ext.LexicalHandler#comment(char[], int, int)
| ToUnknownStream::comment | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void endCDATA() throws SAXException
{
m_handler.endCDATA();
} |
Pass the call on to the underlying handler
@see org.xml.sax.ext.LexicalHandler#endCDATA()
| ToUnknownStream::endCDATA | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void endDTD() throws SAXException
{
m_handler.endDTD();
} |
Pass the call on to the underlying handler
@see org.xml.sax.ext.LexicalHandler#endDTD()
| ToUnknownStream::endDTD | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void endEntity(String name) throws SAXException
{
if (m_firstTagNotEmitted)
{
emitFirstTag();
}
m_handler.endEntity(name);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ext.LexicalHandler#endEntity(String)
| ToUnknownStream::endEntity | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void startCDATA() throws SAXException
{
m_handler.startCDATA();
} |
Pass the call on to the underlying handler
@see org.xml.sax.ext.LexicalHandler#startCDATA()
| ToUnknownStream::startCDATA | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void startDTD(String name, String publicId, String systemId)
throws SAXException
{
m_handler.startDTD(name, publicId, systemId);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ext.LexicalHandler#startDTD(String, String, String)
| ToUnknownStream::startDTD | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void startEntity(String name) throws SAXException
{
m_handler.startEntity(name);
} |
Pass the call on to the underlying handler
@see org.xml.sax.ext.LexicalHandler#startEntity(String)
| ToUnknownStream::startEntity | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
private void initStreamOutput() throws SAXException
{
// Try to rule out if this is an not to be an HTML document based on prefix
boolean firstElementIsHTML = isFirstElemHTML();
if (firstElementIsHTML)
{
// create an HTML output handler, and initialize it
// keep a reference to the old handler, ... it will soon be gone
SerializationHandler oldHandler = m_handler;
/* We have to make sure we get an output properties with the proper
* defaults for the HTML method. The easiest way to do this is to
* have the OutputProperties class do it.
*/
Properties htmlProperties =
OutputPropertiesFactory.getDefaultMethodProperties(Method.HTML);
Serializer serializer =
SerializerFactory.getSerializer(htmlProperties);
// The factory should be returning a ToStream
// Don't know what to do if it doesn't
// i.e. the user has over-ridden the content-handler property
// for html
m_handler = (SerializationHandler) serializer;
//m_handler = new ToHTMLStream();
Writer writer = oldHandler.getWriter();
if (null != writer)
m_handler.setWriter(writer);
else
{
OutputStream os = oldHandler.getOutputStream();
if (null != os)
m_handler.setOutputStream(os);
}
// need to copy things from the old handler to the new one here
// if (_setVersion_called)
// {
m_handler.setVersion(oldHandler.getVersion());
// }
// if (_setDoctypeSystem_called)
// {
m_handler.setDoctypeSystem(oldHandler.getDoctypeSystem());
// }
// if (_setDoctypePublic_called)
// {
m_handler.setDoctypePublic(oldHandler.getDoctypePublic());
// }
// if (_setMediaType_called)
// {
m_handler.setMediaType(oldHandler.getMediaType());
// }
m_handler.setTransformer(oldHandler.getTransformer());
}
/* Now that we have a real wrapped handler (XML or HTML) lets
* pass any cached calls to it
*/
// Call startDocument() if necessary
if (m_needToCallStartDocument)
{
m_handler.startDocument();
m_needToCallStartDocument = false;
}
// the wrapped handler is now fully initialized
m_wrapped_handler_not_initialized = false;
} |
Initialize the wrapped output stream (XML or HTML).
If the stream handler should be HTML, then replace the XML handler with
an HTML handler. After than send the starting method calls that were cached
to the wrapped handler.
| ToUnknownStream::initStreamOutput | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
private String getLocalNameUnknown(String value)
{
int idx = value.lastIndexOf(':');
if (idx >= 0)
value = value.substring(idx + 1);
idx = value.lastIndexOf('@');
if (idx >= 0)
value = value.substring(idx + 1);
return (value);
} |
Utility function for calls to local-name().
Don't want to override static function on SerializerBase
So added Unknown suffix to method name.
| ToUnknownStream::getLocalNameUnknown | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
private String getPrefixPartUnknown(String qname)
{
final int index = qname.indexOf(':');
return (index > 0) ? qname.substring(0, index) : EMPTYSTRING;
} |
Utility function to return prefix
Don't want to override static function on SerializerBase
So added Unknown suffix to method name.
| ToUnknownStream::getPrefixPartUnknown | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
private boolean isFirstElemHTML()
{
boolean isHTML;
// is the first tag html, not considering the prefix ?
isHTML =
getLocalNameUnknown(m_firstElementName).equalsIgnoreCase("html");
// Try to rule out if this is not to be an HTML document based on URI
if (isHTML
&& m_firstElementURI != null
&& !EMPTYSTRING.equals(m_firstElementURI))
{
// the <html> element has a non-trivial namespace
isHTML = false;
}
// Try to rule out if this is an not to be an HTML document based on prefix
if (isHTML && m_namespacePrefix != null)
{
/* the first element has a name of "html", but lets check the prefix.
* If the prefix points to a namespace with a URL that is not ""
* then the doecument doesn't start with an <html> tag, and isn't html
*/
final int max = m_namespacePrefix.size();
for (int i = 0; i < max; i++)
{
final String prefix = (String) m_namespacePrefix.elementAt(i);
final String uri = (String) m_namespaceURI.elementAt(i);
if (m_firstElementPrefix != null
&& m_firstElementPrefix.equals(prefix)
&& !EMPTYSTRING.equals(uri))
{
// The first element has a prefix, so it can't be <html>
isHTML = false;
break;
}
}
}
return isHTML;
} |
Determine if the firts element in the document is <html> or <HTML>
This uses the cached first element name, first element prefix and the
cached namespaces from previous method calls
@return true if the first element is an opening <html> tag
| ToUnknownStream::isFirstElemHTML | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public DOMSerializer asDOMSerializer() throws IOException
{
return m_handler.asDOMSerializer();
} |
@see Serializer#asDOMSerializer()
| ToUnknownStream::asDOMSerializer | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setCdataSectionElements(Vector URI_and_localNames)
{
m_handler.setCdataSectionElements(URI_and_localNames);
} |
@param URI_and_localNames Vector a list of pairs of URI/localName
specified in the cdata-section-elements attribute.
@see SerializationHandler#setCdataSectionElements(java.util.Vector)
| ToUnknownStream::setCdataSectionElements | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void addAttributes(Attributes atts) throws SAXException
{
m_handler.addAttributes(atts);
} |
@see ExtendedContentHandler#addAttributes(org.xml.sax.Attributes)
| ToUnknownStream::addAttributes | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public NamespaceMappings getNamespaceMappings()
{
NamespaceMappings mappings = null;
if (m_handler != null)
{
mappings = m_handler.getNamespaceMappings();
}
return mappings;
} |
Get the current namespace mappings.
Simply returns the mappings of the wrapped handler.
@see ExtendedContentHandler#getNamespaceMappings()
| ToUnknownStream::getNamespaceMappings | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void flushPending() throws SAXException
{
flush();
m_handler.flushPending();
} |
@see SerializationHandler#flushPending()
| ToUnknownStream::flushPending | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public String getPrefix(String namespaceURI)
{
return m_handler.getPrefix(namespaceURI);
} |
@see ExtendedContentHandler#getPrefix
| ToUnknownStream::getPrefix | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void entityReference(String entityName) throws SAXException
{
m_handler.entityReference(entityName);
} |
@see ExtendedContentHandler#entityReference(java.lang.String)
| ToUnknownStream::entityReference | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public String getNamespaceURI(String qname, boolean isElement)
{
return m_handler.getNamespaceURI(qname, isElement);
} |
@see ExtendedContentHandler#getNamespaceURI(java.lang.String, boolean)
| ToUnknownStream::getNamespaceURI | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setContentHandler(ContentHandler ch)
{
m_handler.setContentHandler(ch);
} |
@see SerializationHandler#setContentHandler(org.xml.sax.ContentHandler)
| ToUnknownStream::setContentHandler | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public void setSourceLocator(SourceLocator locator)
{
m_handler.setSourceLocator(locator);
} |
This method is used to set the source locator, which might be used to
generated an error message.
@param locator the source locator
@see ExtendedContentHandler#setSourceLocator(javax.xml.transform.SourceLocator)
| ToUnknownStream::setSourceLocator | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public Object asDOM3Serializer() throws IOException
{
return m_handler.asDOM3Serializer();
} |
@see org.apache.xml.serializer.Serializer#asDOM3Serializer()
| ToUnknownStream::asDOM3Serializer | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToUnknownStream.java | Apache-2.0 |
public ToXMLStream()
{
m_charInfo = m_xmlcharInfo;
initCDATA();
// initialize namespaces
m_prefixMap = new NamespaceMappings();
} |
Default constructor.
| ToXMLStream::ToXMLStream | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToXMLStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToXMLStream.java | Apache-2.0 |
public void CopyFrom(ToXMLStream xmlListener)
{
setWriter(xmlListener.m_writer);
// m_outputStream = xmlListener.m_outputStream;
String encoding = xmlListener.getEncoding();
setEncoding(encoding);
setOmitXMLDeclaration(xmlListener.getOmitXMLDeclaration());
m_ispreserve = xmlListener.m_ispreserve;
m_preserves = xmlListener.m_preserves;
m_isprevtext = xmlListener.m_isprevtext;
m_doIndent = xmlListener.m_doIndent;
setIndentAmount(xmlListener.getIndentAmount());
m_startNewLine = xmlListener.m_startNewLine;
m_needToOutputDocTypeDecl = xmlListener.m_needToOutputDocTypeDecl;
setDoctypeSystem(xmlListener.getDoctypeSystem());
setDoctypePublic(xmlListener.getDoctypePublic());
setStandalone(xmlListener.getStandalone());
setMediaType(xmlListener.getMediaType());
m_encodingInfo = xmlListener.m_encodingInfo;
m_spaceBeforeClose = xmlListener.m_spaceBeforeClose;
m_cdataStartCalled = xmlListener.m_cdataStartCalled;
} |
Copy properties from another SerializerToXML.
@param xmlListener non-null reference to a SerializerToXML object.
| ToXMLStream::CopyFrom | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToXMLStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToXMLStream.java | Apache-2.0 |
public void startDocumentInternal() throws org.xml.sax.SAXException
{
if (m_needToCallStartDocument)
{
super.startDocumentInternal();
m_needToCallStartDocument = false;
if (m_inEntityRef)
return;
m_needToOutputDocTypeDecl = true;
m_startNewLine = false;
/* The call to getXMLVersion() might emit an error message
* and we should emit this message regardless of if we are
* writing out an XML header or not.
*/
final String version = getXMLVersion();
if (getOmitXMLDeclaration() == false)
{
String encoding = Encodings.getMimeEncoding(getEncoding());
String standalone;
if (m_standaloneWasSpecified)
{
standalone = " standalone=\"" + getStandalone() + "\"";
}
else
{
standalone = "";
}
try
{
final java.io.Writer writer = m_writer;
writer.write("<?xml version=\"");
writer.write(version);
writer.write("\" encoding=\"");
writer.write(encoding);
writer.write('\"');
writer.write(standalone);
writer.write("?>");
if (m_doIndent) {
if (m_standaloneWasSpecified
|| getDoctypePublic() != null
|| getDoctypeSystem() != null) {
// We almost never put a newline after the XML
// header because this XML could be used as
// an extenal general parsed entity
// and we don't know the context into which it
// will be used in the future. Only when
// standalone, or a doctype system or public is
// specified are we free to insert a new line
// after the header. Is it even worth bothering
// in these rare cases?
writer.write(m_lineSep, 0, m_lineSepLen);
}
}
}
catch(IOException e)
{
throw new SAXException(e);
}
}
}
} |
Receive notification of the beginning of a document.
@throws org.xml.sax.SAXException Any SAX exception, possibly
wrapping another exception.
@throws org.xml.sax.SAXException
| ToXMLStream::startDocumentInternal | java | google/j2objc | xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToXMLStream.java | https://github.com/google/j2objc/blob/master/xalan/third_party/android/platform/external/apache-xml/src/main/java/org/apache/xml/serializer/ToXMLStream.java | Apache-2.0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.