| Index: tests/lib/protobuf/test_util.dart
|
| diff --git a/tests/lib/protobuf/test_util.dart b/tests/lib/protobuf/test_util.dart
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..4d3c8e6417b3230b36a7384347c6b8343dd9e500
|
| --- /dev/null
|
| +++ b/tests/lib/protobuf/test_util.dart
|
| @@ -0,0 +1,2381 @@
|
| +
|
| +List<int> goldenMessage = const <int>[
|
| + 0x08, 0x65, 0x10, 0x66, 0x18, 0x67, 0x20, 0x68, 0x28, 0xd2, 0x01, 0x30,
|
| + 0xd4, 0x01, 0x3d, 0x6b, 0x00, 0x00, 0x00, 0x41, 0x6c, 0x00, 0x00, 0x00,
|
| + 0x00, 0x00, 0x00, 0x00, 0x4d, 0x6d, 0x00, 0x00, 0x00, 0x51, 0x6e, 0x00,
|
| + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0xde, 0x42, 0x61,
|
| + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x40, 0x68, 0x01, 0x72, 0x03,
|
| + 0x31, 0x31, 0x35, 0x7a, 0x03, 0x31, 0x31, 0x36, 0x83, 0x01, 0x88, 0x01,
|
| + 0x75, 0x84, 0x01, 0x92, 0x01, 0x02, 0x08, 0x76, 0x9a, 0x01, 0x02, 0x08,
|
| + 0x77, 0xa2, 0x01, 0x02, 0x08, 0x78, 0xa8, 0x01, 0x03, 0xb0, 0x01, 0x06,
|
| + 0xb8, 0x01, 0x09, 0xc2, 0x01, 0x03, 0x31, 0x32, 0x34, 0xca, 0x01, 0x03,
|
| + 0x31, 0x32, 0x35, 0xf8, 0x01, 0xc9, 0x01, 0xf8, 0x01, 0xad, 0x02, 0x80,
|
| + 0x02, 0xca, 0x01, 0x80, 0x02, 0xae, 0x02, 0x88, 0x02, 0xcb, 0x01, 0x88,
|
| + 0x02, 0xaf, 0x02, 0x90, 0x02, 0xcc, 0x01, 0x90, 0x02, 0xb0, 0x02, 0x98,
|
| + 0x02, 0x9a, 0x03, 0x98, 0x02, 0xe2, 0x04, 0xa0, 0x02, 0x9c, 0x03, 0xa0,
|
| + 0x02, 0xe4, 0x04, 0xad, 0x02, 0xcf, 0x00, 0x00, 0x00, 0xad, 0x02, 0x33,
|
| + 0x01, 0x00, 0x00, 0xb1, 0x02, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
| + 0x00, 0xb1, 0x02, 0x34, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbd,
|
| + 0x02, 0xd1, 0x00, 0x00, 0x00, 0xbd, 0x02, 0x35, 0x01, 0x00, 0x00, 0xc1,
|
| + 0x02, 0xd2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc1, 0x02, 0x36,
|
| + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcd, 0x02, 0x00, 0x00, 0x53,
|
| + 0x43, 0xcd, 0x02, 0x00, 0x80, 0x9b, 0x43, 0xd1, 0x02, 0x00, 0x00, 0x00,
|
| + 0x00, 0x00, 0x80, 0x6a, 0x40, 0xd1, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
|
| + 0x80, 0x73, 0x40, 0xd8, 0x02, 0x01, 0xd8, 0x02, 0x00, 0xe2, 0x02, 0x03,
|
| + 0x32, 0x31, 0x35, 0xe2, 0x02, 0x03, 0x33, 0x31, 0x35, 0xea, 0x02, 0x03,
|
| + 0x32, 0x31, 0x36, 0xea, 0x02, 0x03, 0x33, 0x31, 0x36, 0xf3, 0x02, 0xf8,
|
| + 0x02, 0xd9, 0x01, 0xf4, 0x02, 0xf3, 0x02, 0xf8, 0x02, 0xbd, 0x02, 0xf4,
|
| + 0x02, 0x82, 0x03, 0x03, 0x08, 0xda, 0x01, 0x82, 0x03, 0x03, 0x08, 0xbe,
|
| + 0x02, 0x8a, 0x03, 0x03, 0x08, 0xdb, 0x01, 0x8a, 0x03, 0x03, 0x08, 0xbf,
|
| + 0x02, 0x92, 0x03, 0x03, 0x08, 0xdc, 0x01, 0x92, 0x03, 0x03, 0x08, 0xc0,
|
| + 0x02, 0x98, 0x03, 0x02, 0x98, 0x03, 0x03, 0xa0, 0x03, 0x05, 0xa0, 0x03,
|
| + 0x06, 0xa8, 0x03, 0x08, 0xa8, 0x03, 0x09, 0xb2, 0x03, 0x03, 0x32, 0x32,
|
| + 0x34, 0xb2, 0x03, 0x03, 0x33, 0x32, 0x34, 0xba, 0x03, 0x03, 0x32, 0x32,
|
| + 0x35, 0xba, 0x03, 0x03, 0x33, 0x32, 0x35, 0xe8, 0x03, 0x91, 0x03, 0xf0,
|
| + 0x03, 0x92, 0x03, 0xf8, 0x03, 0x93, 0x03, 0x80, 0x04, 0x94, 0x03, 0x88,
|
| + 0x04, 0xaa, 0x06, 0x90, 0x04, 0xac, 0x06, 0x9d, 0x04, 0x97, 0x01, 0x00,
|
| + 0x00, 0xa1, 0x04, 0x98, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xad,
|
| + 0x04, 0x99, 0x01, 0x00, 0x00, 0xb1, 0x04, 0x9a, 0x01, 0x00, 0x00, 0x00,
|
| + 0x00, 0x00, 0x00, 0xbd, 0x04, 0x00, 0x80, 0xcd, 0x43, 0xc1, 0x04, 0x00,
|
| + 0x00, 0x00, 0x00, 0x00, 0xc0, 0x79, 0x40, 0xc8, 0x04, 0x00, 0xd2, 0x04,
|
| + 0x03, 0x34, 0x31, 0x35, 0xda, 0x04, 0x03, 0x34, 0x31, 0x36, 0x88, 0x05,
|
| + 0x01, 0x90, 0x05, 0x04, 0x98, 0x05, 0x07, 0xa2, 0x05, 0x03, 0x34, 0x32,
|
| + 0x34, 0xaa, 0x05, 0x03, 0x34, 0x32, 0x35
|
| +];
|
| +
|
| +List<int> goldenPackedMessage = const <int>[
|
| + 0xd2, 0x05, 0x04, 0xd9, 0x04, 0xbd, 0x05, 0xda, 0x05, 0x04, 0xda, 0x04,
|
| + 0xbe, 0x05, 0xe2, 0x05, 0x04, 0xdb, 0x04, 0xbf, 0x05, 0xea, 0x05, 0x04,
|
| + 0xdc, 0x04, 0xc0, 0x05, 0xf2, 0x05, 0x04, 0xba, 0x09, 0x82, 0x0b, 0xfa,
|
| + 0x05, 0x04, 0xbc, 0x09, 0x84, 0x0b, 0x82, 0x06, 0x08, 0x5f, 0x02, 0x00,
|
| + 0x00, 0xc3, 0x02, 0x00, 0x00, 0x8a, 0x06, 0x10, 0x60, 0x02, 0x00, 0x00,
|
| + 0x00, 0x00, 0x00, 0x00, 0xc4, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
| + 0x92, 0x06, 0x08, 0x61, 0x02, 0x00, 0x00, 0xc5, 0x02, 0x00, 0x00, 0x9a,
|
| + 0x06, 0x10, 0x62, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x02,
|
| + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0x06, 0x08, 0x00, 0xc0, 0x18,
|
| + 0x44, 0x00, 0xc0, 0x31, 0x44, 0xaa, 0x06, 0x10, 0x00, 0x00, 0x00, 0x00,
|
| + 0x00, 0x20, 0x83, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x86, 0x40,
|
| + 0xb2, 0x06, 0x02, 0x01, 0x00, 0xba, 0x06, 0x02, 0x05, 0x06
|
| +];
|
| +
|
| +/**
|
| + * Get a [Protobuf_Unittest_TestAllTypes] with all fields set as they would
|
| + * be by [setAllFields(Protobuf_Unittest_TestAllTypes_Builder)].
|
| + */
|
| +Protobuf_Unittest_TestAllTypes getAllSet() {
|
| + Protobuf_Unittest_TestAllTypes_Builder builder =
|
| + new Protobuf_Unittest_TestAllTypes_Builder();
|
| + setAllFields(builder);
|
| + return builder.build();
|
| +}
|
| +
|
| +/**
|
| + * Set every field of {@code message} to the values expected by
|
| + * {@code assertAllFieldsSet()}.
|
| + */
|
| +void setAllFields(Protobuf_Unittest_TestAllTypes_Builder message) {
|
| + message.optionalInt32 = 101;
|
| + message.optionalInt64 = 102;
|
| + message.optionalUint32 = 103;
|
| + message.optionalUint64 = 104;
|
| + message.optionalSint32 = 105;
|
| + message.optionalSint64 = 106;
|
| + message.optionalFixed32 = 107;
|
| + message.optionalFixed64 = 108;
|
| + message.optionalSfixed32 = 109;
|
| + message.optionalSfixed64 = 110;
|
| + message.optionalFloat = 111.0;
|
| + message.optionalDouble = 112.0;
|
| + message.optionalBool = true;
|
| + message.optionalString = "115";
|
| + message.optionalBytes = "116".charCodes();
|
| +
|
| + Protobuf_Unittest_TestAllTypes_OptionalGroup_Builder optionalGroupBuilder =
|
| + new Protobuf_Unittest_TestAllTypes_OptionalGroup_Builder();
|
| + optionalGroupBuilder.a = 117;
|
| + message.optionalGroup = optionalGroupBuilder.build();
|
| +
|
| + Protobuf_Unittest_TestAllTypes_NestedMessage_Builder
|
| + optionalNestedMessageBuilder =
|
| + new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder();
|
| + optionalNestedMessageBuilder.bb = 118;
|
| + message.optionalNestedMessage = optionalNestedMessageBuilder.build();
|
| +
|
| + Protobuf_Unittest_ForeignMessage_Builder optionalForeignMessageBuilder =
|
| + new Protobuf_Unittest_ForeignMessage_Builder();
|
| + optionalForeignMessageBuilder.c = 119;
|
| + message.optionalForeignMessage = optionalForeignMessageBuilder.build();
|
| +
|
| + Protobuf_Unittest_Import_ImportMessage_Builder optionalImportMessageBuilder =
|
| + new Protobuf_Unittest_Import_ImportMessage_Builder();
|
| + optionalImportMessageBuilder.d = 120;
|
| + message.optionalImportMessage = optionalImportMessageBuilder.build();
|
| +
|
| + message.optionalNestedEnum = Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ;
|
| + message.optionalForeignEnum = Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ;
|
| + message.optionalImportEnum = Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ;
|
| +
|
| + message.optionalStringPiece = "124";
|
| + message.optionalCord = "125";
|
| +
|
| + // -----------------------------------------------------------------
|
| +
|
| + message.repeatedInt32.add(201);
|
| + message.repeatedInt64.add(202);
|
| + message.repeatedUint32.add(203);
|
| + message.repeatedUint64.add(204);
|
| + message.repeatedSint32.add(205);
|
| + message.repeatedSint64.add(206);
|
| + message.repeatedFixed32.add(207);
|
| + message.repeatedFixed64.add(208);
|
| + message.repeatedSfixed32.add(209);
|
| + message.repeatedSfixed64.add(210);
|
| + message.repeatedFloat.add(211.0);
|
| + message.repeatedDouble.add(212.0);
|
| + message.repeatedBool.add(true);
|
| + message.repeatedString.add("215");
|
| + message.repeatedBytes.add("216".charCodes());
|
| +
|
| + Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder repeatedGroupBuilder =
|
| + new Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder();
|
| + repeatedGroupBuilder.a = 217;
|
| + message.repeatedGroup.add(repeatedGroupBuilder.build());
|
| +
|
| + Protobuf_Unittest_TestAllTypes_NestedMessage_Builder repeatedNestedBuilder =
|
| + new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder();
|
| + repeatedNestedBuilder.bb = 218;
|
| + message.repeatedNestedMessage.add(repeatedNestedBuilder.build());
|
| +
|
| + Protobuf_Unittest_ForeignMessage_Builder repeatedForeignMessageBuilder =
|
| + new Protobuf_Unittest_ForeignMessage_Builder();
|
| + repeatedForeignMessageBuilder.c = 219;
|
| + message.repeatedForeignMessage.add(repeatedForeignMessageBuilder.build());
|
| +
|
| + Protobuf_Unittest_Import_ImportMessage_Builder repeatedImportMessageBuilder =
|
| + new Protobuf_Unittest_Import_ImportMessage_Builder();
|
| + repeatedImportMessageBuilder.d = 220;
|
| + message.repeatedImportMessage.add(repeatedImportMessageBuilder.build());
|
| +
|
| + message.repeatedNestedEnum.add(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR);
|
| + message.repeatedForeignEnum.add(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR);
|
| + message.repeatedImportEnum.add(
|
| + Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR);
|
| +
|
| + message.repeatedStringPiece.add("224");
|
| + message.repeatedCord.add("225");
|
| +
|
| + // Add a second one of each field.
|
| + message.repeatedInt32.add(301);
|
| + message.repeatedInt64.add(302);
|
| + message.repeatedUint32.add(303);
|
| + message.repeatedUint64.add(304);
|
| + message.repeatedSint32.add(305);
|
| + message.repeatedSint64.add(306);
|
| + message.repeatedFixed32.add(307);
|
| + message.repeatedFixed64.add(308);
|
| + message.repeatedSfixed32.add(309);
|
| + message.repeatedSfixed64.add(310);
|
| + message.repeatedFloat.add(311.0);
|
| + message.repeatedDouble.add(312.0);
|
| + message.repeatedBool.add(false);
|
| + message.repeatedString.add("315");
|
| + message.repeatedBytes.add("316".charCodes());
|
| +
|
| + repeatedGroupBuilder =
|
| + new Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder();
|
| + repeatedGroupBuilder.a = 317;
|
| + message.repeatedGroup.add(repeatedGroupBuilder.build());
|
| +
|
| + repeatedNestedBuilder =
|
| + new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder();
|
| + repeatedNestedBuilder.bb = 318;
|
| + message.repeatedNestedMessage.add(repeatedNestedBuilder.build());
|
| +
|
| + repeatedForeignMessageBuilder =
|
| + new Protobuf_Unittest_ForeignMessage_Builder();
|
| + repeatedForeignMessageBuilder.c = 319;
|
| + message.repeatedForeignMessage.add(repeatedForeignMessageBuilder.build());
|
| +
|
| + repeatedImportMessageBuilder =
|
| + new Protobuf_Unittest_Import_ImportMessage_Builder();
|
| + repeatedImportMessageBuilder.d = 320;
|
| + message.repeatedImportMessage.add(repeatedImportMessageBuilder.build());
|
| +
|
| + message.repeatedNestedEnum.add(Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ);
|
| + message.repeatedForeignEnum.add(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ);
|
| + message.repeatedImportEnum
|
| + .add(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ);
|
| +
|
| + message.repeatedStringPiece.add("324");
|
| + message.repeatedCord.add("325");
|
| +
|
| + // -----------------------------------------------------------------
|
| +
|
| + message.defaultInt32 = 401;
|
| + message.defaultInt64 = 402;
|
| + message.defaultUint32 = 403;
|
| + message.defaultUint64 = 404;
|
| + message.defaultSint32 = 405;
|
| + message.defaultSint64 = 406;
|
| + message.defaultFixed32 = 407;
|
| + message.defaultFixed64 = 408;
|
| + message.defaultSfixed32 = 409;
|
| + message.defaultSfixed64 = 410;
|
| + message.defaultFloat = 411.0;
|
| + message.defaultDouble = 412.0;
|
| + message.defaultBool = false;
|
| + message.defaultString = "415";
|
| + message.defaultBytes = "416".charCodes();
|
| +
|
| + message.defaultNestedEnum = Protobuf_Unittest_TestAllTypes_NestedEnum.FOO;
|
| + message.defaultForeignEnum = Protobuf_Unittest_ForeignEnum.FOREIGN_FOO;
|
| + message.defaultImportEnum = Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO;
|
| +
|
| + message.defaultStringPiece = "424";
|
| + message.defaultCord = "425";
|
| +}
|
| +
|
| +void assertAllFieldsSet(Protobuf_Unittest_TestAllTypes message) {
|
| + Expect.isTrue(message.hasOptionalInt32());
|
| + Expect.isTrue(message.hasOptionalInt64());
|
| + Expect.isTrue(message.hasOptionalUint32());
|
| + Expect.isTrue(message.hasOptionalUint64());
|
| + Expect.isTrue(message.hasOptionalSint32());
|
| + Expect.isTrue(message.hasOptionalSint64());
|
| + Expect.isTrue(message.hasOptionalFixed32());
|
| + Expect.isTrue(message.hasOptionalFixed64());
|
| + Expect.isTrue(message.hasOptionalSfixed32());
|
| + Expect.isTrue(message.hasOptionalSfixed64());
|
| + Expect.isTrue(message.hasOptionalFloat());
|
| + Expect.isTrue(message.hasOptionalDouble());
|
| + Expect.isTrue(message.hasOptionalBool());
|
| + Expect.isTrue(message.hasOptionalString());
|
| + Expect.isTrue(message.hasOptionalBytes());
|
| +
|
| + Expect.isTrue(message.hasOptionalGroup());
|
| + Expect.isTrue(message.hasOptionalNestedMessage());
|
| + Expect.isTrue(message.hasOptionalForeignMessage());
|
| + Expect.isTrue(message.hasOptionalImportMessage());
|
| +
|
| + Expect.isTrue(message.optionalGroup.hasA());
|
| + Expect.isTrue(message.optionalNestedMessage.hasBb());
|
| + Expect.isTrue(message.optionalForeignMessage.hasC());
|
| + Expect.isTrue(message.optionalImportMessage.hasD());
|
| +
|
| + Expect.isTrue(message.hasOptionalNestedEnum());
|
| + Expect.isTrue(message.hasOptionalForeignEnum());
|
| + Expect.isTrue(message.hasOptionalImportEnum());
|
| +
|
| + Expect.isTrue(message.hasOptionalStringPiece());
|
| + Expect.isTrue(message.hasOptionalCord());
|
| +
|
| + Expect.equals(101, message.optionalInt32);
|
| + Expect.equals(102, message.optionalInt64);
|
| + Expect.equals(103, message.optionalUint32);
|
| + Expect.equals(104, message.optionalUint64);
|
| + Expect.equals(105, message.optionalSint32);
|
| + Expect.equals(106, message.optionalSint64);
|
| + Expect.equals(107, message.optionalFixed32);
|
| + Expect.equals(108, message.optionalFixed64);
|
| + Expect.equals(109, message.optionalSfixed32);
|
| + Expect.equals(110, message.optionalSfixed64);
|
| + Expect.approxEquals(111.0, message.optionalFloat);
|
| + Expect.approxEquals(112.0, message.optionalDouble);
|
| + Expect.equals(true, message.optionalBool);
|
| + Expect.equals("115", message.optionalString);
|
| + Expect.listEquals("116".charCodes(), message.optionalBytes);
|
| +
|
| + Expect.equals(117, message.optionalGroup.a);
|
| + Expect.equals(118, message.optionalNestedMessage.bb);
|
| + Expect.equals(119, message.optionalForeignMessage.c);
|
| + Expect.equals(120, message.optionalImportMessage.d);
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ,
|
| + message.optionalNestedEnum);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ,
|
| + message.optionalForeignEnum);
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ,
|
| + message.optionalImportEnum);
|
| +
|
| + Expect.equals("124", message.optionalStringPiece);
|
| + Expect.equals("125", message.optionalCord);
|
| +
|
| + // -----------------------------------------------------------------
|
| +
|
| + Expect.equals(2, message.repeatedInt32.length);
|
| + Expect.equals(2, message.repeatedInt64.length);
|
| + Expect.equals(2, message.repeatedUint32.length);
|
| + Expect.equals(2, message.repeatedUint64.length);
|
| + Expect.equals(2, message.repeatedSint32.length);
|
| + Expect.equals(2, message.repeatedSint64.length);
|
| + Expect.equals(2, message.repeatedFixed32.length);
|
| + Expect.equals(2, message.repeatedFixed64.length);
|
| + Expect.equals(2, message.repeatedSfixed32.length);
|
| + Expect.equals(2, message.repeatedSfixed64.length);
|
| + Expect.equals(2, message.repeatedFloat.length);
|
| + Expect.equals(2, message.repeatedDouble.length);
|
| + Expect.equals(2, message.repeatedBool.length);
|
| + Expect.equals(2, message.repeatedString.length);
|
| + Expect.equals(2, message.repeatedBytes.length);
|
| +
|
| + Expect.equals(2, message.repeatedGroup.length);
|
| + Expect.equals(2, message.repeatedNestedMessage.length);
|
| + Expect.equals(2, message.repeatedForeignMessage.length);
|
| + Expect.equals(2, message.repeatedImportMessage.length);
|
| + Expect.equals(2, message.repeatedNestedEnum.length);
|
| + Expect.equals(2, message.repeatedForeignEnum.length);
|
| + Expect.equals(2, message.repeatedImportEnum.length);
|
| +
|
| + Expect.equals(2, message.repeatedStringPiece.length);
|
| + Expect.equals(2, message.repeatedCord.length);
|
| +
|
| + Expect.equals(201, message.repeatedInt32[0]);
|
| + Expect.equals(202, message.repeatedInt64[0]);
|
| + Expect.equals(203, message.repeatedUint32[0]);
|
| + Expect.equals(204, message.repeatedUint64[0]);
|
| + Expect.equals(205, message.repeatedSint32[0]);
|
| + Expect.equals(206, message.repeatedSint64[0]);
|
| + Expect.equals(207, message.repeatedFixed32[0]);
|
| + Expect.equals(208, message.repeatedFixed64[0]);
|
| + Expect.equals(209, message.repeatedSfixed32[0]);
|
| + Expect.equals(210, message.repeatedSfixed64[0]);
|
| + Expect.approxEquals(211.0, message.repeatedFloat[0]);
|
| + Expect.approxEquals(212.0, message.repeatedDouble[0]);
|
| + Expect.equals(true, message.repeatedBool[0]);
|
| + Expect.equals("215", message.repeatedString[0]);
|
| + Expect.listEquals("216".charCodes(), message.repeatedBytes[0]);
|
| +
|
| + Expect.equals(217, message.repeatedGroup[0].a);
|
| + Expect.equals(218, message.repeatedNestedMessage[0].bb);
|
| + Expect.equals(219, message.repeatedForeignMessage[0].c);
|
| + Expect.equals(220, message.repeatedImportMessage[0].d);
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR,
|
| + message.repeatedNestedEnum[0]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR,
|
| + message.repeatedForeignEnum[0]);
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR,
|
| + message.repeatedImportEnum[0]);
|
| +
|
| + Expect.equals("224", message.repeatedStringPiece[0]);
|
| + Expect.equals("225", message.repeatedCord[0]);
|
| +
|
| + Expect.equals(301, message.repeatedInt32[1]);
|
| + Expect.equals(302, message.repeatedInt64[1]);
|
| + Expect.equals(303, message.repeatedUint32[1]);
|
| + Expect.equals(304, message.repeatedUint64[1]);
|
| + Expect.equals(305, message.repeatedSint32[1]);
|
| + Expect.equals(306, message.repeatedSint64[1]);
|
| + Expect.equals(307, message.repeatedFixed32[1]);
|
| + Expect.equals(308, message.repeatedFixed64[1]);
|
| + Expect.equals(309, message.repeatedSfixed32[1]);
|
| + Expect.equals(310, message.repeatedSfixed64[1]);
|
| + Expect.approxEquals(311.0, message.repeatedFloat[1]);
|
| + Expect.approxEquals(312.0, message.repeatedDouble[1]);
|
| + Expect.equals(false, message.repeatedBool[1]);
|
| + Expect.equals("315", message.repeatedString[1]);
|
| + Expect.listEquals("316".charCodes(), message.repeatedBytes[1]);
|
| +
|
| + Expect.equals(317, message.repeatedGroup[1].a);
|
| + Expect.equals(318, message.repeatedNestedMessage[1].bb);
|
| + Expect.equals(319, message.repeatedForeignMessage[1].c);
|
| + Expect.equals(320, message.repeatedImportMessage[1].d);
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ,
|
| + message.repeatedNestedEnum[1]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ,
|
| + message.repeatedForeignEnum[1]);
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ,
|
| + message.repeatedImportEnum[1]);
|
| +
|
| + Expect.equals("324", message.repeatedStringPiece[1]);
|
| + Expect.equals("325", message.repeatedCord[1]);
|
| +
|
| + // -----------------------------------------------------------------
|
| +
|
| + Expect.isTrue(message.hasDefaultInt32());
|
| + Expect.isTrue(message.hasDefaultInt64());
|
| + Expect.isTrue(message.hasDefaultUint32());
|
| + Expect.isTrue(message.hasDefaultUint64());
|
| + Expect.isTrue(message.hasDefaultSint32());
|
| + Expect.isTrue(message.hasDefaultSint64());
|
| + Expect.isTrue(message.hasDefaultFixed32());
|
| + Expect.isTrue(message.hasDefaultFixed64());
|
| + Expect.isTrue(message.hasDefaultSfixed32());
|
| + Expect.isTrue(message.hasDefaultSfixed64());
|
| + Expect.isTrue(message.hasDefaultFloat());
|
| + Expect.isTrue(message.hasDefaultDouble());
|
| + Expect.isTrue(message.hasDefaultBool());
|
| + Expect.isTrue(message.hasDefaultString());
|
| + Expect.isTrue(message.hasDefaultBytes());
|
| +
|
| + Expect.isTrue(message.hasDefaultNestedEnum());
|
| + Expect.isTrue(message.hasDefaultForeignEnum());
|
| + Expect.isTrue(message.hasDefaultImportEnum());
|
| +
|
| + Expect.isTrue(message.hasDefaultStringPiece());
|
| + Expect.isTrue(message.hasDefaultCord());
|
| +
|
| + Expect.equals(401, message.defaultInt32);
|
| + Expect.equals(402, message.defaultInt64);
|
| + Expect.equals(403, message.defaultUint32);
|
| + Expect.equals(404, message.defaultUint64);
|
| + Expect.equals(405, message.defaultSint32);
|
| + Expect.equals(406, message.defaultSint64);
|
| + Expect.equals(407, message.defaultFixed32);
|
| + Expect.equals(408, message.defaultFixed64);
|
| + Expect.equals(409, message.defaultSfixed32);
|
| + Expect.equals(410, message.defaultSfixed64);
|
| + Expect.approxEquals(411.0, message.defaultFloat);
|
| + Expect.approxEquals(412.0, message.defaultDouble);
|
| + Expect.equals(false, message.defaultBool);
|
| + Expect.equals("415", message.defaultString);
|
| + Expect.listEquals("416".charCodes(), message.defaultBytes);
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO,
|
| + message.defaultNestedEnum);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_FOO,
|
| + message.defaultForeignEnum);
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO,
|
| + message.defaultImportEnum);
|
| +
|
| + Expect.equals("424", message.defaultStringPiece);
|
| + Expect.equals("425", message.defaultCord);
|
| +}
|
| +
|
| +Protobuf_Unittest_TestPackedTypes getPackedSet() {
|
| + Protobuf_Unittest_TestPackedTypes_Builder builder =
|
| + new Protobuf_Unittest_TestPackedTypes_Builder();
|
| + setPackedFields(builder);
|
| + return builder.build();
|
| +}
|
| +
|
| +/**
|
| + * Assert (using Expect} that all fields of [message] are set to the values
|
| + * assigned by [setPackedFields].
|
| + */
|
| +void assertPackedFieldsSet(Protobuf_Unittest_TestPackedTypes message) {
|
| + Expect.equals(2, message.packedInt32.length);
|
| + Expect.equals(2, message.packedInt64.length);
|
| + Expect.equals(2, message.packedUint32.length);
|
| + Expect.equals(2, message.packedUint64.length);
|
| + Expect.equals(2, message.packedSint32.length);
|
| + Expect.equals(2, message.packedSint64.length);
|
| + Expect.equals(2, message.packedFixed32.length);
|
| + Expect.equals(2, message.packedFixed64.length);
|
| + Expect.equals(2, message.packedSfixed32.length);
|
| + Expect.equals(2, message.packedSfixed64.length);
|
| + Expect.equals(2, message.packedFloat.length);
|
| + Expect.equals(2, message.packedDouble.length);
|
| + Expect.equals(2, message.packedBool.length);
|
| + Expect.equals(2, message.packedEnum.length);
|
| + Expect.equals(601, message.packedInt32[0]);
|
| + Expect.equals(602, message.packedInt64[0]);
|
| + Expect.equals(603, message.packedUint32[0]);
|
| + Expect.equals(604, message.packedUint64[0]);
|
| + Expect.equals(605, message.packedSint32[0]);
|
| + Expect.equals(606, message.packedSint64[0]);
|
| + Expect.equals(607, message.packedFixed32[0]);
|
| + Expect.equals(608, message.packedFixed64[0]);
|
| + Expect.equals(609, message.packedSfixed32[0]);
|
| + Expect.equals(610, message.packedSfixed64[0]);
|
| + Expect.approxEquals(611.0, message.packedFloat[0], 0.0);
|
| + Expect.approxEquals(612.0, message.packedDouble[0], 0.0);
|
| + Expect.equals(true, message.packedBool[0]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR,
|
| + message.packedEnum[0]);
|
| + Expect.equals(701, message.packedInt32[1]);
|
| + Expect.equals(702, message.packedInt64[1]);
|
| + Expect.equals(703, message.packedUint32[1]);
|
| + Expect.equals(704, message.packedUint64[1]);
|
| + Expect.equals(705, message.packedSint32[1]);
|
| + Expect.equals(706, message.packedSint64[1]);
|
| + Expect.equals(707, message.packedFixed32[1]);
|
| + Expect.equals(708, message.packedFixed64[1]);
|
| + Expect.equals(709, message.packedSfixed32[1]);
|
| + Expect.equals(710, message.packedSfixed64[1]);
|
| + Expect.approxEquals(711.0, message.packedFloat[1], 0.0);
|
| + Expect.approxEquals(712.0, message.packedDouble[1], 0.0);
|
| + Expect.equals(false, message.packedBool[1]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ,
|
| + message.packedEnum[1]);
|
| +}
|
| +
|
| +/**
|
| + * Set every field of [message] to a unique value. Must correspond with
|
| + * the values applied by [setUnpackedFields].
|
| + */
|
| +void setPackedFields(Protobuf_Unittest_TestPackedTypes_Builder message) {
|
| + message.packedInt32.add(601);
|
| + message.packedInt64.add(602);
|
| + message.packedUint32.add(603);
|
| + message.packedUint64.add(604);
|
| + message.packedSint32.add(605);
|
| + message.packedSint64.add(606);
|
| + message.packedFixed32.add(607);
|
| + message.packedFixed64.add(608);
|
| + message.packedSfixed32.add(609);
|
| + message.packedSfixed64.add(610);
|
| + message.packedFloat.add(611.0);
|
| + message.packedDouble.add(612.0);
|
| + message.packedBool.add(true);
|
| + message.packedEnum.add(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR);
|
| + // Add a second one of each field.
|
| + message.packedInt32.add(701);
|
| + message.packedInt64.add(702);
|
| + message.packedUint32.add(703);
|
| + message.packedUint64.add(704);
|
| + message.packedSint32.add(705);
|
| + message.packedSint64.add(706);
|
| + message.packedFixed32.add(707);
|
| + message.packedFixed64.add(708);
|
| + message.packedSfixed32.add(709);
|
| + message.packedSfixed64.add(710);
|
| + message.packedFloat.add(711.0);
|
| + message.packedDouble.add(712.0);
|
| + message.packedBool.add(false);
|
| + message.packedEnum.add(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ);
|
| +}
|
| +
|
| +Protobuf_Unittest_TestAllExtensions getAllExtensionsSet() {
|
| + Protobuf_Unittest_TestAllExtensions_Builder builder =
|
| + new Protobuf_Unittest_TestAllExtensions_Builder();
|
| + setAllExtensions(builder);
|
| + return builder.build();
|
| +}
|
| +void setAllExtensions(Protobuf_Unittest_TestAllExtensions_Builder message) {
|
| + message.setExtension(Unittest.optionalInt32Extension, 101);
|
| + message.setExtension(Unittest.optionalInt64Extension, 102);
|
| + message.setExtension(Unittest.optionalUint32Extension, 103);
|
| + message.setExtension(Unittest.optionalUint64Extension, 104);
|
| + message.setExtension(Unittest.optionalSint32Extension, 105);
|
| + message.setExtension(Unittest.optionalSint64Extension, 106);
|
| + message.setExtension(Unittest.optionalFixed32Extension, 107);
|
| + message.setExtension(Unittest.optionalFixed64Extension, 108);
|
| + message.setExtension(Unittest.optionalSfixed32Extension, 109);
|
| + message.setExtension(Unittest.optionalSfixed64Extension, 110);
|
| + message.setExtension(Unittest.optionalFloatExtension, 111.0);
|
| + message.setExtension(Unittest.optionalDoubleExtension, 112.0);
|
| + message.setExtension(Unittest.optionalBoolExtension, true);
|
| + message.setExtension(Unittest.optionalStringExtension, "115");
|
| + message.setExtension(Unittest.optionalBytesExtension,
|
| + "116".charCodes());
|
| +
|
| + var builder;
|
| +
|
| + builder = new Protobuf_Unittest_OptionalGroup_extension_Builder();
|
| + builder.a = 117;
|
| + message.setExtension(Unittest.optionalGroupExtension,
|
| + builder.build());
|
| +
|
| + builder = new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder();
|
| + builder.bb = 118;
|
| + message.setExtension(Unittest.optionalNestedMessageExtension,
|
| + builder.build());
|
| +
|
| + builder = new Protobuf_Unittest_ForeignMessage_Builder();
|
| + builder.c = 119;
|
| + message.setExtension(Unittest.optionalForeignMessageExtension,
|
| + builder.build());
|
| +
|
| + builder = new Protobuf_Unittest_Import_ImportMessage_Builder();
|
| + builder.d = 120;
|
| + message.setExtension(Unittest.optionalImportMessageExtension,
|
| + builder.build());
|
| +
|
| + message.setExtension(Unittest.optionalNestedEnumExtension,
|
| + Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ);
|
| + message.setExtension(Unittest.optionalForeignEnumExtension,
|
| + Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ);
|
| + message.setExtension(Unittest.optionalImportEnumExtension,
|
| + Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ);
|
| +
|
| + message.setExtension(Unittest.optionalStringPieceExtension,
|
| + "124");
|
| + message.setExtension(Unittest.optionalCordExtension, "125");
|
| +
|
| + // -----------------------------------------------------------------
|
| +
|
| + message.addExtension(Unittest.repeatedInt32Extension, 201);
|
| + message.addExtension(Unittest.repeatedInt64Extension, 202);
|
| + message.addExtension(Unittest.repeatedUint32Extension, 203);
|
| + message.addExtension(Unittest.repeatedUint64Extension, 204);
|
| + message.addExtension(Unittest.repeatedSint32Extension, 205);
|
| + message.addExtension(Unittest.repeatedSint64Extension, 206);
|
| + message.addExtension(Unittest.repeatedFixed32Extension, 207);
|
| + message.addExtension(Unittest.repeatedFixed64Extension, 208);
|
| + message.addExtension(Unittest.repeatedSfixed32Extension, 209);
|
| + message.addExtension(Unittest.repeatedSfixed64Extension, 210);
|
| + message.addExtension(Unittest.repeatedFloatExtension, 211.0);
|
| + message.addExtension(Unittest.repeatedDoubleExtension, 212.0);
|
| + message.addExtension(Unittest.repeatedBoolExtension, true);
|
| + message.addExtension(Unittest.repeatedStringExtension, "215");
|
| + message.addExtension(Unittest.repeatedBytesExtension,
|
| + "216".charCodes());
|
| +
|
| + builder = new Protobuf_Unittest_RepeatedGroup_extension_Builder();
|
| + builder.a = 217;
|
| + message.addExtension(Unittest.repeatedGroupExtension,
|
| + builder.build());
|
| +
|
| + builder = new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder();
|
| + builder.bb = 218;
|
| + message.addExtension(Unittest.repeatedNestedMessageExtension,
|
| + builder.build());
|
| +
|
| + builder = new Protobuf_Unittest_ForeignMessage_Builder();
|
| + builder.c = 219;
|
| + message.addExtension(Unittest.repeatedForeignMessageExtension,
|
| + builder.build());
|
| +
|
| + builder = new Protobuf_Unittest_Import_ImportMessage_Builder();
|
| + builder.d = 220;
|
| + message.addExtension(Unittest.repeatedImportMessageExtension,
|
| + builder.build());
|
| +
|
| + message.addExtension(Unittest.repeatedNestedEnumExtension,
|
| + Protobuf_Unittest_TestAllTypes_NestedEnum.BAR);
|
| + message.addExtension(Unittest.repeatedForeignEnumExtension,
|
| + Protobuf_Unittest_ForeignEnum.FOREIGN_BAR);
|
| + message.addExtension(Unittest.repeatedImportEnumExtension,
|
| + Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR);
|
| +
|
| + message.addExtension(Unittest.repeatedStringPieceExtension,
|
| + "224");
|
| + message.addExtension(Unittest.repeatedCordExtension, "225");
|
| +
|
| + // Add a second one of each field.
|
| + message.addExtension(Unittest.repeatedInt32Extension, 301);
|
| + message.addExtension(Unittest.repeatedInt64Extension, 302);
|
| + message.addExtension(Unittest.repeatedUint32Extension, 303);
|
| + message.addExtension(Unittest.repeatedUint64Extension, 304);
|
| + message.addExtension(Unittest.repeatedSint32Extension, 305);
|
| + message.addExtension(Unittest.repeatedSint64Extension, 306);
|
| + message.addExtension(Unittest.repeatedFixed32Extension, 307);
|
| + message.addExtension(Unittest.repeatedFixed64Extension, 308);
|
| + message.addExtension(Unittest.repeatedSfixed32Extension, 309);
|
| + message.addExtension(Unittest.repeatedSfixed64Extension, 310);
|
| + message.addExtension(Unittest.repeatedFloatExtension, 311.0);
|
| + message.addExtension(Unittest.repeatedDoubleExtension, 312.0);
|
| + message.addExtension(Unittest.repeatedBoolExtension, false);
|
| + message.addExtension(Unittest.repeatedStringExtension, "315");
|
| + message.addExtension(Unittest.repeatedBytesExtension,
|
| + "316".charCodes());
|
| +
|
| + builder = new Protobuf_Unittest_RepeatedGroup_extension_Builder();
|
| + builder.a = 317;
|
| + message.addExtension(Unittest.repeatedGroupExtension,
|
| + builder.build());
|
| +
|
| + builder = new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder();
|
| + builder.bb = 318;
|
| + message.addExtension(Unittest.repeatedNestedMessageExtension,
|
| + builder.build());
|
| +
|
| + builder = new Protobuf_Unittest_ForeignMessage_Builder();
|
| + builder.c = 319;
|
| + message.addExtension(Unittest.repeatedForeignMessageExtension,
|
| + builder.build());
|
| +
|
| + builder = new Protobuf_Unittest_Import_ImportMessage_Builder();
|
| + builder.d = 320;
|
| + message.addExtension(Unittest.repeatedImportMessageExtension,
|
| + builder.build());
|
| +
|
| + message.addExtension(Unittest.repeatedNestedEnumExtension,
|
| + Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ);
|
| + message.addExtension(Unittest.repeatedForeignEnumExtension,
|
| + Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ);
|
| + message.addExtension(Unittest.repeatedImportEnumExtension,
|
| + Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ);
|
| +
|
| + message.addExtension(
|
| + Unittest.repeatedStringPieceExtension, "324");
|
| + message.addExtension(Unittest.repeatedCordExtension, "325");
|
| +
|
| + // -----------------------------------------------------------------
|
| +
|
| + message.setExtension(Unittest.defaultInt32Extension, 401);
|
| + message.setExtension(Unittest.defaultInt64Extension, 402);
|
| + message.setExtension(Unittest.defaultUint32Extension, 403);
|
| + message.setExtension(Unittest.defaultUint64Extension, 404);
|
| + message.setExtension(Unittest.defaultSint32Extension, 405);
|
| + message.setExtension(Unittest.defaultSint64Extension, 406);
|
| + message.setExtension(Unittest.defaultFixed32Extension, 407);
|
| + message.setExtension(Unittest.defaultFixed64Extension, 408);
|
| + message.setExtension(Unittest.defaultSfixed32Extension, 409);
|
| + message.setExtension(Unittest.defaultSfixed64Extension, 410);
|
| + message.setExtension(Unittest.defaultFloatExtension, 411.0);
|
| + message.setExtension(Unittest.defaultDoubleExtension, 412.0);
|
| + message.setExtension(Unittest.defaultBoolExtension, false);
|
| + message.setExtension(Unittest.defaultStringExtension, "415");
|
| + message.setExtension(Unittest.defaultBytesExtension,
|
| + "416".charCodes());
|
| +
|
| + message.setExtension(Unittest.defaultNestedEnumExtension,
|
| + Protobuf_Unittest_TestAllTypes_NestedEnum.FOO);
|
| + message.setExtension(Unittest.defaultForeignEnumExtension,
|
| + Protobuf_Unittest_ForeignEnum.FOREIGN_FOO);
|
| + message.setExtension(Unittest.defaultImportEnumExtension,
|
| + Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO);
|
| +
|
| + message.setExtension(Unittest.defaultStringPieceExtension,
|
| + "424");
|
| + message.setExtension(Unittest.defaultCordExtension, "425");
|
| +}
|
| +
|
| +Protobuf_Unittest_TestPackedExtensions getPackedExtensionsSet() {
|
| + Protobuf_Unittest_TestPackedExtensions_Builder builder =
|
| + new Protobuf_Unittest_TestPackedExtensions_Builder();
|
| + setPackedExtensions(builder);
|
| + return builder.build();
|
| +}
|
| +
|
| +void setPackedExtensions(
|
| + Protobuf_Unittest_TestPackedExtensions_Builder message) {
|
| + message.addExtension(Unittest.packedInt32Extension , 601);
|
| + message.addExtension(Unittest.packedInt64Extension , 602);
|
| + message.addExtension(Unittest.packedUint32Extension , 603);
|
| + message.addExtension(Unittest.packedUint64Extension , 604);
|
| + message.addExtension(Unittest.packedSint32Extension , 605);
|
| + message.addExtension(Unittest.packedSint64Extension , 606);
|
| + message.addExtension(Unittest.packedFixed32Extension , 607);
|
| + message.addExtension(Unittest.packedFixed64Extension , 608);
|
| + message.addExtension(Unittest.packedSfixed32Extension, 609);
|
| + message.addExtension(Unittest.packedSfixed64Extension, 610);
|
| + message.addExtension(Unittest.packedFloatExtension , 611.0);
|
| + message.addExtension(Unittest.packedDoubleExtension , 612.0);
|
| + message.addExtension(Unittest.packedBoolExtension , true);
|
| + message.addExtension(Unittest.packedEnumExtension,
|
| + Protobuf_Unittest_ForeignEnum.FOREIGN_BAR);
|
| + // Add a second one of each field.
|
| + message.addExtension(Unittest.packedInt32Extension , 701);
|
| + message.addExtension(Unittest.packedInt64Extension , 702);
|
| + message.addExtension(Unittest.packedUint32Extension , 703);
|
| + message.addExtension(Unittest.packedUint64Extension , 704);
|
| + message.addExtension(Unittest.packedSint32Extension , 705);
|
| + message.addExtension(Unittest.packedSint64Extension , 706);
|
| + message.addExtension(Unittest.packedFixed32Extension , 707);
|
| + message.addExtension(Unittest.packedFixed64Extension , 708);
|
| + message.addExtension(Unittest.packedSfixed32Extension, 709);
|
| + message.addExtension(Unittest.packedSfixed64Extension, 710);
|
| + message.addExtension(Unittest.packedFloatExtension , 711.0);
|
| + message.addExtension(Unittest.packedDoubleExtension , 712.0);
|
| + message.addExtension(Unittest.packedBoolExtension , false);
|
| + message.addExtension(Unittest.packedEnumExtension,
|
| + Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ);
|
| +}
|
| +
|
| +ExtensionRegistry getExtensionRegistry() {
|
| + ExtensionRegistry registry = new ExtensionRegistry();
|
| + registerAllExtensions(registry);
|
| + return registry/*.getUnmodifiable()*/;
|
| +}
|
| +
|
| +void assertAllExtensionsSet(Protobuf_Unittest_TestAllExtensions message) {
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalInt32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalInt64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalUint32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalUint64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalSint32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalSint64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalFixed32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalFixed64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalSfixed32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalSfixed64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalFloatExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalDoubleExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalBoolExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalStringExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalBytesExtension));
|
| +
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalGroupExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalNestedMessageExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalForeignMessageExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalImportMessageExtension));
|
| +
|
| + Expect.isTrue(message.getExtension(
|
| + Unittest.optionalGroupExtension).hasA());
|
| + Expect.isTrue(message.getExtension(
|
| + Unittest.optionalNestedMessageExtension).hasBb());
|
| + Expect.isTrue(message.getExtension(
|
| + Unittest.optionalForeignMessageExtension).hasC());
|
| + Expect.isTrue(message.getExtension(
|
| + Unittest.optionalImportMessageExtension).hasD());
|
| +
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalNestedEnumExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalForeignEnumExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalImportEnumExtension));
|
| +
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalStringPieceExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalCordExtension));
|
| +
|
| + Expect.equals(101, message.getExtension(
|
| + Unittest.optionalInt32Extension));
|
| + Expect.equals(102, message.getExtension(
|
| + Unittest.optionalInt64Extension));
|
| + Expect.equals(103, message.getExtension(
|
| + Unittest.optionalUint32Extension));
|
| + Expect.equals(104, message.getExtension(
|
| + Unittest.optionalUint64Extension));
|
| + Expect.equals(105, message.getExtension(
|
| + Unittest.optionalSint32Extension));
|
| + Expect.equals(106, message.getExtension(
|
| + Unittest.optionalSint64Extension));
|
| + Expect.equals(107, message.getExtension(
|
| + Unittest.optionalFixed32Extension));
|
| + Expect.equals(108, message.getExtension(
|
| + Unittest.optionalFixed64Extension));
|
| + Expect.equals(109, message.getExtension(
|
| + Unittest.optionalSfixed32Extension));
|
| + Expect.equals(110, message.getExtension(
|
| + Unittest.optionalSfixed64Extension));
|
| + Expect.equals(111.0, message.getExtension(
|
| + Unittest.optionalFloatExtension));
|
| + Expect.equals(112.0, message.getExtension(
|
| + Unittest.optionalDoubleExtension));
|
| + Expect.equals(true, message.getExtension(
|
| + Unittest.optionalBoolExtension));
|
| + Expect.equals("115", message.getExtension(
|
| + Unittest.optionalStringExtension));
|
| + Expect.listEquals("116".charCodes(), message.getExtension(
|
| + Unittest.optionalBytesExtension));
|
| +
|
| + Expect.equals(117, message.getExtension(
|
| + Unittest.optionalGroupExtension).a);
|
| + Expect.equals(118, message.getExtension(
|
| + Unittest.optionalNestedMessageExtension).bb);
|
| + Expect.equals(119, message.getExtension(
|
| + Unittest.optionalForeignMessageExtension).c);
|
| + Expect.equals(120, message.getExtension(
|
| + Unittest.optionalImportMessageExtension).d);
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ,
|
| + message.getExtension(
|
| + Unittest.optionalNestedEnumExtension));
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ,
|
| + message.getExtension(
|
| + Unittest.optionalForeignEnumExtension));
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ,
|
| + message.getExtension(
|
| + Unittest.optionalImportEnumExtension));
|
| +
|
| + Expect.equals("124", message.getExtension(
|
| + Unittest.optionalStringPieceExtension));
|
| + Expect.equals("125", message.getExtension(
|
| + Unittest.optionalCordExtension));
|
| +
|
| + // -----------------------------------------------------------------
|
| +
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedInt32Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedInt64Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedUint32Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedUint64Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedSint32Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedSint64Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedFixed32Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedFixed64Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedSfixed32Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedSfixed64Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedFloatExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedDoubleExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedBoolExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedStringExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedBytesExtension));
|
| +
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedGroupExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedNestedMessageExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedForeignMessageExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedImportMessageExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedNestedEnumExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedForeignEnumExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedImportEnumExtension));
|
| +
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedStringPieceExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedCordExtension));
|
| +
|
| + Expect.equals(201, message.getExtension(
|
| + Unittest.repeatedInt32Extension)[0]);
|
| + Expect.equals(202, message.getExtension(
|
| + Unittest.repeatedInt64Extension)[0]);
|
| + Expect.equals(203, message.getExtension(
|
| + Unittest.repeatedUint32Extension)[0]);
|
| + Expect.equals(204, message.getExtension(
|
| + Unittest.repeatedUint64Extension)[0]);
|
| + Expect.equals(205, message.getExtension(
|
| + Unittest.repeatedSint32Extension)[0]);
|
| + Expect.equals(206, message.getExtension(
|
| + Unittest.repeatedSint64Extension)[0]);
|
| + Expect.equals(207, message.getExtension(
|
| + Unittest.repeatedFixed32Extension)[0]);
|
| + Expect.equals(208, message.getExtension(
|
| + Unittest.repeatedFixed64Extension)[0]);
|
| + Expect.equals(209, message.getExtension(
|
| + Unittest.repeatedSfixed32Extension)[0]);
|
| + Expect.equals(210, message.getExtension(
|
| + Unittest.repeatedSfixed64Extension)[0]);
|
| + Expect.equals(211.0, message.getExtension(
|
| + Unittest.repeatedFloatExtension)[0]);
|
| + Expect.equals(212.0, message.getExtension(
|
| + Unittest.repeatedDoubleExtension)[0]);
|
| + Expect.equals(true, message.getExtension(
|
| + Unittest.repeatedBoolExtension)[0]);
|
| + Expect.equals("215", message.getExtension(
|
| + Unittest.repeatedStringExtension)[0]);
|
| + Expect.listEquals("216".charCodes(), message.getExtension(
|
| + Unittest.repeatedBytesExtension)[0]);
|
| +
|
| + Expect.equals(217, message.getExtension(
|
| + Unittest.repeatedGroupExtension)[0].a);
|
| + Expect.equals(218, message.getExtension(
|
| + Unittest.repeatedNestedMessageExtension)[0].bb);
|
| + Expect.equals(219, message.getExtension(
|
| + Unittest.repeatedForeignMessageExtension)[0].c);
|
| + Expect.equals(220, message.getExtension(
|
| + Unittest.repeatedImportMessageExtension)[0].d);
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR,
|
| + message.getExtension(
|
| + Unittest.repeatedNestedEnumExtension)[0]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR,
|
| + message.getExtension(
|
| + Unittest.repeatedForeignEnumExtension)[0]);
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR,
|
| + message.getExtension(
|
| + Unittest.repeatedImportEnumExtension)[0]);
|
| +
|
| + Expect.equals("224", message.getExtension(
|
| + Unittest.repeatedStringPieceExtension)[0]);
|
| + Expect.equals("225", message.getExtension(
|
| + Unittest.repeatedCordExtension)[0]);
|
| +
|
| + Expect.equals(301, message.getExtension(
|
| + Unittest.repeatedInt32Extension)[1]);
|
| + Expect.equals(302, message.getExtension(
|
| + Unittest.repeatedInt64Extension)[1]);
|
| + Expect.equals(303, message.getExtension(
|
| + Unittest.repeatedUint32Extension)[1]);
|
| + Expect.equals(304, message.getExtension(
|
| + Unittest.repeatedUint64Extension)[1]);
|
| + Expect.equals(305, message.getExtension(
|
| + Unittest.repeatedSint32Extension)[1]);
|
| + Expect.equals(306, message.getExtension(
|
| + Unittest.repeatedSint64Extension)[1]);
|
| + Expect.equals(307, message.getExtension(
|
| + Unittest.repeatedFixed32Extension)[1]);
|
| + Expect.equals(308, message.getExtension(
|
| + Unittest.repeatedFixed64Extension)[1]);
|
| + Expect.equals(309, message.getExtension(
|
| + Unittest.repeatedSfixed32Extension)[1]);
|
| + Expect.equals(310, message.getExtension(
|
| + Unittest.repeatedSfixed64Extension)[1]);
|
| + Expect.equals(311.0, message.getExtension(
|
| + Unittest.repeatedFloatExtension)[1]);
|
| + Expect.equals(312.0, message.getExtension(
|
| + Unittest.repeatedDoubleExtension)[1]);
|
| + Expect.equals(false, message.getExtension(
|
| + Unittest.repeatedBoolExtension)[1]);
|
| + Expect.equals("315", message.getExtension(
|
| + Unittest.repeatedStringExtension)[1]);
|
| + Expect.listEquals("316".charCodes(), message.getExtension(
|
| + Unittest.repeatedBytesExtension)[1]);
|
| +
|
| + Expect.equals(317, message.getExtension(
|
| + Unittest.repeatedGroupExtension)[1].a);
|
| + Expect.equals(318, message.getExtension(
|
| + Unittest.repeatedNestedMessageExtension)[1].bb);
|
| + Expect.equals(319, message.getExtension(
|
| + Unittest.repeatedForeignMessageExtension)[1].c);
|
| + Expect.equals(320, message.getExtension(
|
| + Unittest.repeatedImportMessageExtension)[1].d);
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ,
|
| + message.getExtension(
|
| + Unittest.repeatedNestedEnumExtension)[1]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ,
|
| + message.getExtension(
|
| + Unittest.repeatedForeignEnumExtension)[1]);
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ,
|
| + message.getExtension(
|
| + Unittest.repeatedImportEnumExtension)[1]);
|
| +
|
| + Expect.equals("324", message.getExtension(
|
| + Unittest.repeatedStringPieceExtension)[1]);
|
| + Expect.equals("325", message.getExtension(
|
| + Unittest.repeatedCordExtension)[1]);
|
| +
|
| + // -----------------------------------------------------------------
|
| +
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultInt32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultInt64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultUint32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultUint64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultSint32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultSint64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultFixed32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultFixed64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultSfixed32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultSfixed64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultFloatExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultDoubleExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultBoolExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultStringExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultBytesExtension));
|
| +
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultNestedEnumExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultForeignEnumExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultImportEnumExtension));
|
| +
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultStringPieceExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultCordExtension));
|
| +
|
| + Expect.equals(401, message.getExtension(
|
| + Unittest.defaultInt32Extension));
|
| + Expect.equals(402, message.getExtension(
|
| + Unittest.defaultInt64Extension));
|
| + Expect.equals(403, message.getExtension(
|
| + Unittest.defaultUint32Extension));
|
| + Expect.equals(404, message.getExtension(
|
| + Unittest.defaultUint64Extension));
|
| + Expect.equals(405, message.getExtension(
|
| + Unittest.defaultSint32Extension));
|
| + Expect.equals(406, message.getExtension(
|
| + Unittest.defaultSint64Extension));
|
| + Expect.equals(407, message.getExtension(
|
| + Unittest.defaultFixed32Extension));
|
| + Expect.equals(408, message.getExtension(
|
| + Unittest.defaultFixed64Extension));
|
| + Expect.equals(409, message.getExtension(
|
| + Unittest.defaultSfixed32Extension));
|
| + Expect.equals(410, message.getExtension(
|
| + Unittest.defaultSfixed64Extension));
|
| + Expect.equals(411.0, message.getExtension(
|
| + Unittest.defaultFloatExtension));
|
| + Expect.equals(412.0, message.getExtension(
|
| + Unittest.defaultDoubleExtension));
|
| + Expect.equals(false, message.getExtension(
|
| + Unittest.defaultBoolExtension));
|
| + Expect.equals("415", message.getExtension(
|
| + Unittest.defaultStringExtension));
|
| + Expect.listEquals("416".charCodes(), message.getExtension(
|
| + Unittest.defaultBytesExtension));
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO,
|
| + message.getExtension(Unittest.defaultNestedEnumExtension));
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_FOO,
|
| + message.getExtension(Unittest.defaultForeignEnumExtension));
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO,
|
| + message.getExtension(Unittest.defaultImportEnumExtension));
|
| +
|
| + Expect.equals("424", message.getExtension(
|
| + Unittest.defaultStringPieceExtension));
|
| + Expect.equals("425", message.getExtension(
|
| + Unittest.defaultCordExtension));
|
| +}
|
| +
|
| +void registerAllExtensions(ExtensionRegistry registry) {
|
| + Unittest.registerAllExtensions(registry);
|
| +}
|
| +
|
| +void assertPackedExtensionsSet(Protobuf_Unittest_TestPackedExtensions message) {
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedInt32Extension ));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedInt64Extension ));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedUint32Extension ));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedUint64Extension ));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedSint32Extension ));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedSint64Extension ));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedFixed32Extension ));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedFixed64Extension ));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedSfixed32Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedSfixed64Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedFloatExtension ));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedDoubleExtension ));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedBoolExtension ));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.packedEnumExtension));
|
| + Expect.equals(601,
|
| + message.getExtension(Unittest.packedInt32Extension)[0]);
|
| + Expect.equals(602,
|
| + message.getExtension(Unittest.packedInt64Extension)[0]);
|
| + Expect.equals(603,
|
| + message.getExtension(Unittest.packedUint32Extension)[0]);
|
| + Expect.equals(604,
|
| + message.getExtension(Unittest.packedUint64Extension)[0]);
|
| + Expect.equals(605,
|
| + message.getExtension(Unittest.packedSint32Extension)[0]);
|
| + Expect.equals(606,
|
| + message.getExtension(Unittest.packedSint64Extension)[0]);
|
| + Expect.equals(607,
|
| + message.getExtension(Unittest.packedFixed32Extension)[0]);
|
| + Expect.equals(608,
|
| + message.getExtension(Unittest.packedFixed64Extension)[0]);
|
| + Expect.equals(609, message.getExtension(
|
| + Unittest.packedSfixed32Extension)[0]);
|
| + Expect.equals(610, message.getExtension(
|
| + Unittest.packedSfixed64Extension)[0]);
|
| + Expect.equals(611.0,
|
| + message.getExtension(Unittest.packedFloatExtension)[0]);
|
| + Expect.equals(612.0,
|
| + message.getExtension(Unittest.packedDoubleExtension)[0]);
|
| + Expect.equals(true,
|
| + message.getExtension(Unittest.packedBoolExtension)[0]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR,
|
| + message.getExtension(Unittest.packedEnumExtension)[0]);
|
| + Expect.equals(701,
|
| + message.getExtension(Unittest.packedInt32Extension)[1]);
|
| + Expect.equals(702,
|
| + message.getExtension(Unittest.packedInt64Extension)[1]);
|
| + Expect.equals(703,
|
| + message.getExtension(Unittest.packedUint32Extension)[1]);
|
| + Expect.equals(704,
|
| + message.getExtension(Unittest.packedUint64Extension)[1]);
|
| + Expect.equals(705,
|
| + message.getExtension(Unittest.packedSint32Extension)[1]);
|
| + Expect.equals(706,
|
| + message.getExtension(Unittest.packedSint64Extension)[1]);
|
| + Expect.equals(707,
|
| + message.getExtension(Unittest.packedFixed32Extension)[1]);
|
| + Expect.equals(708,
|
| + message.getExtension(Unittest.packedFixed64Extension)[1]);
|
| + Expect.equals(709, message.getExtension(
|
| + Unittest.packedSfixed32Extension)[1]);
|
| + Expect.equals(710, message.getExtension(
|
| + Unittest.packedSfixed64Extension)[1]);
|
| + Expect.equals(711.0,
|
| + message.getExtension(Unittest.packedFloatExtension)[1]);
|
| + Expect.equals(712.0,
|
| + message.getExtension(Unittest.packedDoubleExtension)[1]);
|
| + Expect.equals(false,
|
| + message.getExtension(Unittest.packedBoolExtension)[1]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ,
|
| + message.getExtension(Unittest.packedEnumExtension)[1]);
|
| +}
|
| +
|
| +/**
|
| + * Modify the repeated fields of {@code message} to contain the values
|
| + * expected by {@code assertRepeatedFieldsModified()}.
|
| + */
|
| +void modifyRepeatedFields(Protobuf_Unittest_TestAllTypes_Builder message) {
|
| + message.repeatedInt32[1] = 501;
|
| + message.repeatedInt64[1] = 502;
|
| + message.repeatedUint32[1] = 503;
|
| + message.repeatedUint64[1] = 504;
|
| + message.repeatedSint32[1] = 505;
|
| + message.repeatedSint64[1] = 506;
|
| + message.repeatedFixed32[1] = 507;
|
| + message.repeatedFixed64[1] = 508;
|
| + message.repeatedSfixed32[1] = 509;
|
| + message.repeatedSfixed64[1] = 510;
|
| + message.repeatedFloat[1] = 511.0;
|
| + message.repeatedDouble[1] = 512.0;
|
| + message.repeatedBool[1] = true;
|
| + message.repeatedString[1] = "515";
|
| + message.repeatedBytes[1] = "516".charCodes();
|
| +
|
| +
|
| + Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder repeatedGroupBuilder =
|
| + new Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder();
|
| + repeatedGroupBuilder.a = 517;
|
| + message.repeatedGroup[1] = repeatedGroupBuilder.build();
|
| +
|
| + Protobuf_Unittest_TestAllTypes_NestedMessage_Builder
|
| + optionalNestedMessageBuilder =
|
| + new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder();
|
| + optionalNestedMessageBuilder.bb = 518;
|
| + message.repeatedNestedMessage[1] = optionalNestedMessageBuilder.build();
|
| +
|
| + Protobuf_Unittest_ForeignMessage_Builder optionalForeignMessageBuilder =
|
| + new Protobuf_Unittest_ForeignMessage_Builder();
|
| + optionalForeignMessageBuilder.c = 519;
|
| + message.repeatedForeignMessage[1] = optionalForeignMessageBuilder.build();
|
| +
|
| + Protobuf_Unittest_Import_ImportMessage_Builder optionalImportMessageBuilder =
|
| + new Protobuf_Unittest_Import_ImportMessage_Builder();
|
| + optionalImportMessageBuilder.d = 520;
|
| + message.repeatedImportMessage[1] = optionalImportMessageBuilder.build();
|
| +
|
| + message.repeatedNestedEnum[1] = Protobuf_Unittest_TestAllTypes_NestedEnum.BAR;
|
| + message.repeatedForeignEnum[1] = Protobuf_Unittest_ForeignEnum.FOREIGN_BAR;
|
| + message.repeatedImportEnum[1] =
|
| + Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR;
|
| +
|
| + message.repeatedStringPiece[1] = "524";
|
| + message.repeatedCord[1] = "525";
|
| +}
|
| +
|
| +void assertRepeatedFieldsModified(Protobuf_Unittest_TestAllTypes 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.
|
| + Expect.equals(2, message.repeatedInt32.length);
|
| + Expect.equals(2, message.repeatedInt64.length);
|
| + Expect.equals(2, message.repeatedUint32.length);
|
| + Expect.equals(2, message.repeatedUint64.length);
|
| + Expect.equals(2, message.repeatedSint32.length);
|
| + Expect.equals(2, message.repeatedSint64.length);
|
| + Expect.equals(2, message.repeatedFixed32.length);
|
| + Expect.equals(2, message.repeatedFixed64.length);
|
| + Expect.equals(2, message.repeatedSfixed32.length);
|
| + Expect.equals(2, message.repeatedSfixed64.length);
|
| + Expect.equals(2, message.repeatedFloat.length);
|
| + Expect.equals(2, message.repeatedDouble.length);
|
| + Expect.equals(2, message.repeatedBool.length);
|
| + Expect.equals(2, message.repeatedString.length);
|
| + Expect.equals(2, message.repeatedBytes.length);
|
| +
|
| + Expect.equals(2, message.repeatedGroup.length);
|
| + Expect.equals(2, message.repeatedNestedMessage.length);
|
| + Expect.equals(2, message.repeatedForeignMessage.length);
|
| + Expect.equals(2, message.repeatedImportMessage.length);
|
| + Expect.equals(2, message.repeatedNestedEnum.length);
|
| + Expect.equals(2, message.repeatedForeignEnum.length);
|
| + Expect.equals(2, message.repeatedImportEnum.length);
|
| +
|
| + Expect.equals(2, message.repeatedStringPiece.length);
|
| + Expect.equals(2, message.repeatedCord.length);
|
| +
|
| + Expect.equals(201, message.repeatedInt32[0]);
|
| + Expect.equals(202, message.repeatedInt64[0]);
|
| + Expect.equals(203, message.repeatedUint32[0]);
|
| + Expect.equals(204, message.repeatedUint64[0]);
|
| + Expect.equals(205, message.repeatedSint32[0]);
|
| + Expect.equals(206, message.repeatedSint64[0]);
|
| + Expect.equals(207, message.repeatedFixed32[0]);
|
| + Expect.equals(208, message.repeatedFixed64[0]);
|
| + Expect.equals(209, message.repeatedSfixed32[0]);
|
| + Expect.equals(210, message.repeatedSfixed64[0]);
|
| + Expect.approxEquals(211.0, message.repeatedFloat[0]);
|
| + Expect.approxEquals(212.0, message.repeatedDouble[0]);
|
| + Expect.equals(true, message.repeatedBool[0]);
|
| + Expect.equals("215", message.repeatedString[0]);
|
| + Expect.listEquals("216".charCodes(), message.repeatedBytes[0]);
|
| +
|
| + Expect.equals(217, message.repeatedGroup[0].a);
|
| + Expect.equals(218, message.repeatedNestedMessage[0].bb);
|
| + Expect.equals(219, message.repeatedForeignMessage[0].c);
|
| + Expect.equals(220, message.repeatedImportMessage[0].d);
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR,
|
| + message.repeatedNestedEnum[0]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR,
|
| + message.repeatedForeignEnum[0]);
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR,
|
| + message.repeatedImportEnum[0]);
|
| +
|
| + Expect.equals("224", message.repeatedStringPiece[0]);
|
| + Expect.equals("225", message.repeatedCord[0]);
|
| +
|
| + // Actually verify the second(modified) elements now.
|
| + Expect.equals(501, message.repeatedInt32[1]);
|
| + Expect.equals(502, message.repeatedInt64[1]);
|
| + Expect.equals(503, message.repeatedUint32[1]);
|
| + Expect.equals(504, message.repeatedUint64[1]);
|
| + Expect.equals(505, message.repeatedSint32[1]);
|
| + Expect.equals(506, message.repeatedSint64[1]);
|
| + Expect.equals(507, message.repeatedFixed32[1]);
|
| + Expect.equals(508, message.repeatedFixed64[1]);
|
| + Expect.equals(509, message.repeatedSfixed32[1]);
|
| + Expect.equals(510, message.repeatedSfixed64[1]);
|
| + Expect.approxEquals(511.0, message.repeatedFloat[1]);
|
| + Expect.approxEquals(512.0, message.repeatedDouble[1]);
|
| + Expect.equals(true, message.repeatedBool[1]);
|
| + Expect.equals("515", message.repeatedString[1]);
|
| + Expect.listEquals("516".charCodes(), message.repeatedBytes[1]);
|
| +
|
| + Expect.equals(517, message.repeatedGroup[1].a);
|
| + Expect.equals(518, message.repeatedNestedMessage[1].bb);
|
| + Expect.equals(519, message.repeatedForeignMessage[1].c);
|
| + Expect.equals(520, message.repeatedImportMessage[1].d);
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR,
|
| + message.repeatedNestedEnum[1]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR,
|
| + message.repeatedForeignEnum[1]);
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR,
|
| + message.repeatedImportEnum[1]);
|
| +
|
| + Expect.equals("524", message.repeatedStringPiece[1]);
|
| + Expect.equals("525", message.repeatedCord[1]);
|
| +}
|
| +
|
| +void assertClear(Protobuf_Unittest_TestAllTypes message) {
|
| + // hasBlah() should initially be false for all optional fields.
|
| + Expect.isFalse(message.hasOptionalInt32());
|
| + Expect.isFalse(message.hasOptionalInt64());
|
| + Expect.isFalse(message.hasOptionalUint32());
|
| + Expect.isFalse(message.hasOptionalUint64());
|
| + Expect.isFalse(message.hasOptionalSint32());
|
| + Expect.isFalse(message.hasOptionalSint64());
|
| + Expect.isFalse(message.hasOptionalFixed32());
|
| + Expect.isFalse(message.hasOptionalFixed64());
|
| + Expect.isFalse(message.hasOptionalSfixed32());
|
| + Expect.isFalse(message.hasOptionalSfixed64());
|
| + Expect.isFalse(message.hasOptionalFloat());
|
| + Expect.isFalse(message.hasOptionalDouble());
|
| + Expect.isFalse(message.hasOptionalBool());
|
| + Expect.isFalse(message.hasOptionalString());
|
| + Expect.isFalse(message.hasOptionalBytes());
|
| +
|
| + Expect.isFalse(message.hasOptionalGroup());
|
| + Expect.isFalse(message.hasOptionalNestedMessage());
|
| + Expect.isFalse(message.hasOptionalForeignMessage());
|
| + Expect.isFalse(message.hasOptionalImportMessage());
|
| +
|
| + Expect.isFalse(message.hasOptionalNestedEnum());
|
| + Expect.isFalse(message.hasOptionalForeignEnum());
|
| + Expect.isFalse(message.hasOptionalImportEnum());
|
| +
|
| + Expect.isFalse(message.hasOptionalStringPiece());
|
| + Expect.isFalse(message.hasOptionalCord());
|
| +
|
| + // Optional fields without defaults are set to zero or something like it.
|
| + Expect.equals(0, message.optionalInt32);
|
| + Expect.equals(0, message.optionalInt64);
|
| + Expect.equals(0, message.optionalUint32);
|
| + Expect.equals(0, message.optionalUint64);
|
| + Expect.equals(0, message.optionalSint32);
|
| + Expect.equals(0, message.optionalSint64);
|
| + Expect.equals(0, message.optionalFixed32);
|
| + Expect.equals(0, message.optionalFixed64);
|
| + Expect.equals(0, message.optionalSfixed32);
|
| + Expect.equals(0, message.optionalSfixed64);
|
| + Expect.approxEquals(0, message.optionalFloat, 0.0);
|
| + Expect.approxEquals(0, message.optionalDouble, 0.0);
|
| + Expect.equals(false, message.optionalBool);
|
| + Expect.stringEquals("", message.optionalString);
|
| + Expect.listEquals(<int>[], message.optionalBytes);
|
| +
|
| + // Embedded messages should also be clear.
|
| + Expect.isFalse(message.optionalGroup.hasA());
|
| + Expect.isFalse(message.optionalNestedMessage.hasBb());
|
| + Expect.isFalse(message.optionalForeignMessage.hasC());
|
| + Expect.isFalse(message.optionalImportMessage.hasD());
|
| +
|
| + Expect.equals(0, message.optionalGroup.a);
|
| + Expect.equals(0, message.optionalNestedMessage.bb);
|
| + Expect.equals(0, message.optionalForeignMessage.c);
|
| + Expect.equals(0, message.optionalImportMessage.d);
|
| +
|
| + // Enums without defaults are set to the first value in the enum.
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO,
|
| + message.optionalNestedEnum);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_FOO,
|
| + message.optionalForeignEnum);
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO,
|
| + message.optionalImportEnum);
|
| +
|
| + Expect.equals("", message.optionalStringPiece);
|
| + Expect.equals("", message.optionalCord);
|
| +
|
| + // Repeated fields are empty.
|
| + Expect.equals(0, message.repeatedInt32.length);
|
| + Expect.equals(0, message.repeatedInt64.length);
|
| + Expect.equals(0, message.repeatedUint32.length);
|
| + Expect.equals(0, message.repeatedUint64.length);
|
| + Expect.equals(0, message.repeatedSint32.length);
|
| + Expect.equals(0, message.repeatedSint64.length);
|
| + Expect.equals(0, message.repeatedFixed32.length);
|
| + Expect.equals(0, message.repeatedFixed64.length);
|
| + Expect.equals(0, message.repeatedSfixed32.length);
|
| + Expect.equals(0, message.repeatedSfixed64.length);
|
| + Expect.equals(0, message.repeatedFloat.length);
|
| + Expect.equals(0, message.repeatedDouble.length);
|
| + Expect.equals(0, message.repeatedBool.length);
|
| + Expect.equals(0, message.repeatedString.length);
|
| + Expect.equals(0, message.repeatedBytes.length);
|
| +
|
| + Expect.equals(0, message.repeatedGroup.length);
|
| + Expect.equals(0, message.repeatedNestedMessage.length);
|
| + Expect.equals(0, message.repeatedForeignMessage.length);
|
| + Expect.equals(0, message.repeatedImportMessage.length);
|
| + Expect.equals(0, message.repeatedNestedEnum.length);
|
| + Expect.equals(0, message.repeatedForeignEnum.length);
|
| + Expect.equals(0, message.repeatedImportEnum.length);
|
| +
|
| + Expect.equals(0, message.repeatedStringPiece.length);
|
| + Expect.equals(0, message.repeatedCord.length);
|
| +
|
| + // hasBlah() should also be false for all default fields.
|
| + Expect.isFalse(message.hasDefaultInt32());
|
| + Expect.isFalse(message.hasDefaultInt64());
|
| + Expect.isFalse(message.hasDefaultUint32());
|
| + Expect.isFalse(message.hasDefaultUint64());
|
| + Expect.isFalse(message.hasDefaultSint32());
|
| + Expect.isFalse(message.hasDefaultSint64());
|
| + Expect.isFalse(message.hasDefaultFixed32());
|
| + Expect.isFalse(message.hasDefaultFixed64());
|
| + Expect.isFalse(message.hasDefaultSfixed32());
|
| + Expect.isFalse(message.hasDefaultSfixed64());
|
| + Expect.isFalse(message.hasDefaultFloat());
|
| + Expect.isFalse(message.hasDefaultDouble());
|
| + Expect.isFalse(message.hasDefaultBool());
|
| + Expect.isFalse(message.hasDefaultString());
|
| + Expect.isFalse(message.hasDefaultBytes());
|
| +
|
| + Expect.isFalse(message.hasDefaultNestedEnum());
|
| + Expect.isFalse(message.hasDefaultForeignEnum());
|
| + Expect.isFalse(message.hasDefaultImportEnum());
|
| +
|
| + Expect.isFalse(message.hasDefaultStringPiece());
|
| + Expect.isFalse(message.hasDefaultCord());
|
| +
|
| + // Fields with defaults have their default values(duh).
|
| + Expect.equals( 41, message.defaultInt32);
|
| + Expect.equals( 42, message.defaultInt64);
|
| + Expect.equals( 43, message.defaultUint32);
|
| + Expect.equals( 44, message.defaultUint64);
|
| + Expect.equals(-45, message.defaultSint32);
|
| + Expect.equals( 46, message.defaultSint64);
|
| + Expect.equals( 47, message.defaultFixed32);
|
| + Expect.equals( 48, message.defaultFixed64);
|
| + Expect.equals( 49, message.defaultSfixed32);
|
| + Expect.equals(-50, message.defaultSfixed64);
|
| + Expect.approxEquals( 51.5, message.defaultFloat, 0.0);
|
| + Expect.approxEquals( 52e3, message.defaultDouble, 0.0);
|
| + Expect.isTrue(message.defaultBool);
|
| + Expect.stringEquals("hello", message.defaultString);
|
| + Expect.listEquals("world".charCodes(), message.defaultBytes);
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR,
|
| + message.defaultNestedEnum);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR,
|
| + message.defaultForeignEnum);
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR,
|
| + message.defaultImportEnum);
|
| +
|
| + Expect.equals("abc", message.defaultStringPiece);
|
| + Expect.equals("123", message.defaultCord);
|
| +}
|
| +
|
| +/**
|
| + * Assert (using Expect} that all fields of [message] are set to the values
|
| + * assigned by [setUnpackedFields].
|
| + */
|
| +void assertUnpackedFieldsSet(Protobuf_Unittest_TestUnpackedTypes message) {
|
| + Expect.equals(2, message.unpackedInt32.length);
|
| + Expect.equals(2, message.unpackedInt64.length);
|
| + Expect.equals(2, message.unpackedUint32.length);
|
| + Expect.equals(2, message.unpackedUint64.length);
|
| + Expect.equals(2, message.unpackedSint32.length);
|
| + Expect.equals(2, message.unpackedSint64.length);
|
| + Expect.equals(2, message.unpackedFixed32.length);
|
| + Expect.equals(2, message.unpackedFixed64.length);
|
| + Expect.equals(2, message.unpackedSfixed32.length);
|
| + Expect.equals(2, message.unpackedSfixed64.length);
|
| + Expect.equals(2, message.unpackedFloat.length);
|
| + Expect.equals(2, message.unpackedDouble.length);
|
| + Expect.equals(2, message.unpackedBool.length);
|
| + Expect.equals(2, message.unpackedEnum.length);
|
| + Expect.equals(601, message.unpackedInt32[0]);
|
| + Expect.equals(602, message.unpackedInt64[0]);
|
| + Expect.equals(603, message.unpackedUint32[0]);
|
| + Expect.equals(604, message.unpackedUint64[0]);
|
| + Expect.equals(605, message.unpackedSint32[0]);
|
| + Expect.equals(606, message.unpackedSint64[0]);
|
| + Expect.equals(607, message.unpackedFixed32[0]);
|
| + Expect.equals(608, message.unpackedFixed64[0]);
|
| + Expect.equals(609, message.unpackedSfixed32[0]);
|
| + Expect.equals(610, message.unpackedSfixed64[0]);
|
| + Expect.approxEquals(611.0, message.unpackedFloat[0], 0.0);
|
| + Expect.approxEquals(612.0, message.unpackedDouble[0], 0.0);
|
| + Expect.equals(true, message.unpackedBool[0]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR,
|
| + message.unpackedEnum[0]);
|
| + Expect.equals(701, message.unpackedInt32[1]);
|
| + Expect.equals(702, message.unpackedInt64[1]);
|
| + Expect.equals(703, message.unpackedUint32[1]);
|
| + Expect.equals(704, message.unpackedUint64[1]);
|
| + Expect.equals(705, message.unpackedSint32[1]);
|
| + Expect.equals(706, message.unpackedSint64[1]);
|
| + Expect.equals(707, message.unpackedFixed32[1]);
|
| + Expect.equals(708, message.unpackedFixed64[1]);
|
| + Expect.equals(709, message.unpackedSfixed32[1]);
|
| + Expect.equals(710, message.unpackedSfixed64[1]);
|
| + Expect.approxEquals(711.0, message.unpackedFloat[1], 0.0);
|
| + Expect.approxEquals(712.0, message.unpackedDouble[1], 0.0);
|
| + Expect.equals(false, message.unpackedBool[1]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ,
|
| + message.unpackedEnum[1]);
|
| +}
|
| +
|
| +Protobuf_Unittest_TestUnpackedTypes getUnpackedSet() {
|
| + Protobuf_Unittest_TestUnpackedTypes_Builder builder =
|
| + new Protobuf_Unittest_TestUnpackedTypes_Builder();
|
| + setUnpackedFields(builder);
|
| + return builder.build();
|
| +}
|
| +
|
| +/**
|
| + * Set every field of [message] to a unique value. Must correspond with
|
| + * the values applied by [setPackedFields].
|
| + */
|
| +void setUnpackedFields(Protobuf_Unittest_TestUnpackedTypes_Builder message) {
|
| + message.unpackedInt32.add(601);
|
| + message.unpackedInt64.add(602);
|
| + message.unpackedUint32.add(603);
|
| + message.unpackedUint64.add(604);
|
| + message.unpackedSint32.add(605);
|
| + message.unpackedSint64.add(606);
|
| + message.unpackedFixed32.add(607);
|
| + message.unpackedFixed64.add(608);
|
| + message.unpackedSfixed32.add(609);
|
| + message.unpackedSfixed64.add(610);
|
| + message.unpackedFloat.add(611.0);
|
| + message.unpackedDouble.add(612.0);
|
| + message.unpackedBool.add(true);
|
| + message.unpackedEnum.add(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR);
|
| + // Add a second one of each field.
|
| + message.unpackedInt32.add(701);
|
| + message.unpackedInt64.add(702);
|
| + message.unpackedUint32.add(703);
|
| + message.unpackedUint64.add(704);
|
| + message.unpackedSint32.add(705);
|
| + message.unpackedSint64.add(706);
|
| + message.unpackedFixed32.add(707);
|
| + message.unpackedFixed64.add(708);
|
| + message.unpackedSfixed32.add(709);
|
| + message.unpackedSfixed64.add(710);
|
| + message.unpackedFloat.add(711.0);
|
| + message.unpackedDouble.add(712.0);
|
| + message.unpackedBool.add(false);
|
| + message.unpackedEnum.add(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ);
|
| +}
|
| +
|
| +void modifyRepeatedExtensions(
|
| + Protobuf_Unittest_TestAllExtensions_Builder message) {
|
| + message.getExtension(
|
| + Unittest.repeatedInt32Extension)[1] = 501;
|
| + message.getExtension(
|
| + Unittest.repeatedInt64Extension)[1] = 502;
|
| + message.getExtension(
|
| + Unittest.repeatedUint32Extension)[1] = 503;
|
| + message.getExtension(
|
| + Unittest.repeatedUint64Extension)[1] = 504;
|
| + message.getExtension(
|
| + Unittest.repeatedSint32Extension)[1] = 505;
|
| + message.getExtension(
|
| + Unittest.repeatedSint64Extension)[1] = 506;
|
| + message.getExtension(
|
| + Unittest.repeatedFixed32Extension)[1] = 507;
|
| + message.getExtension(
|
| + Unittest.repeatedFixed64Extension)[1] = 508;
|
| + message.getExtension(
|
| + Unittest.repeatedSfixed32Extension)[1] = 509;
|
| + message.getExtension(
|
| + Unittest.repeatedSfixed64Extension)[1] = 510;
|
| + message.getExtension(
|
| + Unittest.repeatedFloatExtension)[1] = 511.0;
|
| + message.getExtension(
|
| + Unittest.repeatedDoubleExtension)[1] = 512.0;
|
| + message.getExtension(
|
| + Unittest.repeatedBoolExtension)[1] = true;
|
| + message.getExtension(
|
| + Unittest.repeatedStringExtension)[1] = "515";
|
| + message.getExtension(
|
| + Unittest.repeatedBytesExtension)[1] = "516".charCodes();
|
| +
|
| + var builder;
|
| +
|
| + builder = new Protobuf_Unittest_RepeatedGroup_extension_Builder();
|
| + builder.a = 517;
|
| + message.getExtension(
|
| + Unittest.repeatedGroupExtension)[1] = builder.build();
|
| +
|
| + builder = new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder();
|
| + builder.bb = 518;
|
| + message.getExtension(
|
| + Unittest.repeatedNestedMessageExtension)[1] =
|
| + builder.build();
|
| +
|
| + builder = new Protobuf_Unittest_ForeignMessage_Builder();
|
| + builder.c = 519;
|
| + message.getExtension(
|
| + Unittest.repeatedForeignMessageExtension)[1] =
|
| + builder.build();
|
| +
|
| + builder = new Protobuf_Unittest_Import_ImportMessage_Builder();
|
| + builder.d = 520;
|
| + message.getExtension(
|
| + Unittest.repeatedImportMessageExtension)[1] =
|
| + builder.build();
|
| +
|
| + message.getExtension(
|
| + Unittest.repeatedNestedEnumExtension)[1] =
|
| + Protobuf_Unittest_TestAllTypes_NestedEnum.FOO;
|
| + message.getExtension(
|
| + Unittest.repeatedForeignEnumExtension)[1] =
|
| + Protobuf_Unittest_ForeignEnum.FOREIGN_FOO;
|
| + message.getExtension(
|
| + Unittest.repeatedImportEnumExtension)[1] =
|
| + Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO;
|
| +
|
| + message.getExtension(
|
| + Unittest.repeatedStringPieceExtension)[1] = "524";
|
| + message.getExtension(
|
| + Unittest.repeatedCordExtension)[1] = "525";
|
| +}
|
| +
|
| +void assertRepeatedExtensionsModified(
|
| + Protobuf_Unittest_TestAllExtensions message) {
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalInt32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalInt64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalUint32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalUint64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalSint32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalSint64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalFixed32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalFixed64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalSfixed32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalSfixed64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalFloatExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalDoubleExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalBoolExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalStringExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalBytesExtension));
|
| +
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalGroupExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalNestedMessageExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalForeignMessageExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalImportMessageExtension));
|
| +
|
| + Expect.isTrue(message.getExtension(
|
| + Unittest.optionalGroupExtension).hasA());
|
| + Expect.isTrue(message.getExtension(
|
| + Unittest.optionalNestedMessageExtension).hasBb());
|
| + Expect.isTrue(message.getExtension(
|
| + Unittest.optionalForeignMessageExtension).hasC());
|
| + Expect.isTrue(message.getExtension(
|
| + Unittest.optionalImportMessageExtension).hasD());
|
| +
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalNestedEnumExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalForeignEnumExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalImportEnumExtension));
|
| +
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalStringPieceExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.optionalCordExtension));
|
| +
|
| + Expect.equals(101, message.getExtension(
|
| + Unittest.optionalInt32Extension));
|
| + Expect.equals(102, message.getExtension(
|
| + Unittest.optionalInt64Extension));
|
| + Expect.equals(103, message.getExtension(
|
| + Unittest.optionalUint32Extension));
|
| + Expect.equals(104, message.getExtension(
|
| + Unittest.optionalUint64Extension));
|
| + Expect.equals(105, message.getExtension(
|
| + Unittest.optionalSint32Extension));
|
| + Expect.equals(106, message.getExtension(
|
| + Unittest.optionalSint64Extension));
|
| + Expect.equals(107, message.getExtension(
|
| + Unittest.optionalFixed32Extension));
|
| + Expect.equals(108, message.getExtension(
|
| + Unittest.optionalFixed64Extension));
|
| + Expect.equals(109, message.getExtension(
|
| + Unittest.optionalSfixed32Extension));
|
| + Expect.equals(110, message.getExtension(
|
| + Unittest.optionalSfixed64Extension));
|
| + Expect.equals(111.0, message.getExtension(
|
| + Unittest.optionalFloatExtension));
|
| + Expect.equals(112.0, message.getExtension(
|
| + Unittest.optionalDoubleExtension));
|
| + Expect.equals(true, message.getExtension(
|
| + Unittest.optionalBoolExtension));
|
| + Expect.equals("115", message.getExtension(
|
| + Unittest.optionalStringExtension));
|
| + Expect.listEquals("116".charCodes(), message.getExtension(
|
| + Unittest.optionalBytesExtension));
|
| +
|
| + Expect.equals(117, message.getExtension(
|
| + Unittest.optionalGroupExtension).a);
|
| + Expect.equals(118, message.getExtension(
|
| + Unittest.optionalNestedMessageExtension).bb);
|
| + Expect.equals(119, message.getExtension(
|
| + Unittest.optionalForeignMessageExtension).c);
|
| + Expect.equals(120, message.getExtension(
|
| + Unittest.optionalImportMessageExtension).d);
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ,
|
| + message.getExtension(
|
| + Unittest.optionalNestedEnumExtension));
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ,
|
| + message.getExtension(
|
| + Unittest.optionalForeignEnumExtension));
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ,
|
| + message.getExtension(
|
| + Unittest.optionalImportEnumExtension));
|
| +
|
| + Expect.equals("124", message.getExtension(
|
| + Unittest.optionalStringPieceExtension));
|
| + Expect.equals("125", message.getExtension(
|
| + Unittest.optionalCordExtension));
|
| +
|
| + // -----------------------------------------------------------------
|
| +
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedInt32Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedInt64Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedUint32Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedUint64Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedSint32Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedSint64Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedFixed32Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedFixed64Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedSfixed32Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedSfixed64Extension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedFloatExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedDoubleExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedBoolExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedStringExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedBytesExtension));
|
| +
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedGroupExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedNestedMessageExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedForeignMessageExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedImportMessageExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedNestedEnumExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedForeignEnumExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedImportEnumExtension));
|
| +
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedStringPieceExtension));
|
| + Expect.equals(2, message.getExtensionCount(
|
| + Unittest.repeatedCordExtension));
|
| +
|
| + Expect.equals(201, message.getExtension(
|
| + Unittest.repeatedInt32Extension)[0]);
|
| + Expect.equals(202, message.getExtension(
|
| + Unittest.repeatedInt64Extension)[0]);
|
| + Expect.equals(203, message.getExtension(
|
| + Unittest.repeatedUint32Extension)[0]);
|
| + Expect.equals(204, message.getExtension(
|
| + Unittest.repeatedUint64Extension)[0]);
|
| + Expect.equals(205, message.getExtension(
|
| + Unittest.repeatedSint32Extension)[0]);
|
| + Expect.equals(206, message.getExtension(
|
| + Unittest.repeatedSint64Extension)[0]);
|
| + Expect.equals(207, message.getExtension(
|
| + Unittest.repeatedFixed32Extension)[0]);
|
| + Expect.equals(208, message.getExtension(
|
| + Unittest.repeatedFixed64Extension)[0]);
|
| + Expect.equals(209, message.getExtension(
|
| + Unittest.repeatedSfixed32Extension)[0]);
|
| + Expect.equals(210, message.getExtension(
|
| + Unittest.repeatedSfixed64Extension)[0]);
|
| + Expect.equals(211.0, message.getExtension(
|
| + Unittest.repeatedFloatExtension)[0]);
|
| + Expect.equals(212.0, message.getExtension(
|
| + Unittest.repeatedDoubleExtension)[0]);
|
| + Expect.equals(true, message.getExtension(
|
| + Unittest.repeatedBoolExtension)[0]);
|
| + Expect.equals("215", message.getExtension(
|
| + Unittest.repeatedStringExtension)[0]);
|
| + Expect.listEquals("216".charCodes(), message.getExtension(
|
| + Unittest.repeatedBytesExtension)[0]);
|
| +
|
| + Expect.equals(217, message.getExtension(
|
| + Unittest.repeatedGroupExtension)[0].a);
|
| + Expect.equals(218, message.getExtension(
|
| + Unittest.repeatedNestedMessageExtension)[0].bb);
|
| + Expect.equals(219, message.getExtension(
|
| + Unittest.repeatedForeignMessageExtension)[0].c);
|
| + Expect.equals(220, message.getExtension(
|
| + Unittest.repeatedImportMessageExtension)[0].d);
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR,
|
| + message.getExtension(
|
| + Unittest.repeatedNestedEnumExtension)[0]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR,
|
| + message.getExtension(
|
| + Unittest.repeatedForeignEnumExtension)[0]);
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR,
|
| + message.getExtension(
|
| + Unittest.repeatedImportEnumExtension)[0]);
|
| +
|
| + Expect.equals("224", message.getExtension(
|
| + Unittest.repeatedStringPieceExtension)[0]);
|
| + Expect.equals("225", message.getExtension(
|
| + Unittest.repeatedCordExtension)[0]);
|
| +
|
| + Expect.equals(501, message.getExtension(
|
| + Unittest.repeatedInt32Extension)[1]);
|
| + Expect.equals(502, message.getExtension(
|
| + Unittest.repeatedInt64Extension)[1]);
|
| + Expect.equals(503, message.getExtension(
|
| + Unittest.repeatedUint32Extension)[1]);
|
| + Expect.equals(504, message.getExtension(
|
| + Unittest.repeatedUint64Extension)[1]);
|
| + Expect.equals(505, message.getExtension(
|
| + Unittest.repeatedSint32Extension)[1]);
|
| + Expect.equals(506, message.getExtension(
|
| + Unittest.repeatedSint64Extension)[1]);
|
| + Expect.equals(507, message.getExtension(
|
| + Unittest.repeatedFixed32Extension)[1]);
|
| + Expect.equals(508, message.getExtension(
|
| + Unittest.repeatedFixed64Extension)[1]);
|
| + Expect.equals(509, message.getExtension(
|
| + Unittest.repeatedSfixed32Extension)[1]);
|
| + Expect.equals(510, message.getExtension(
|
| + Unittest.repeatedSfixed64Extension)[1]);
|
| + Expect.equals(511.0, message.getExtension(
|
| + Unittest.repeatedFloatExtension)[1]);
|
| + Expect.equals(512.0, message.getExtension(
|
| + Unittest.repeatedDoubleExtension)[1]);
|
| + Expect.equals(true, message.getExtension(
|
| + Unittest.repeatedBoolExtension)[1]);
|
| + Expect.equals("515", message.getExtension(
|
| + Unittest.repeatedStringExtension)[1]);
|
| + Expect.listEquals("516".charCodes(), message.getExtension(
|
| + Unittest.repeatedBytesExtension)[1]);
|
| +
|
| + Expect.equals(517, message.getExtension(
|
| + Unittest.repeatedGroupExtension)[1].a);
|
| + Expect.equals(518, message.getExtension(
|
| + Unittest.repeatedNestedMessageExtension)[1].bb);
|
| + Expect.equals(519, message.getExtension(
|
| + Unittest.repeatedForeignMessageExtension)[1].c);
|
| + Expect.equals(520, message.getExtension(
|
| + Unittest.repeatedImportMessageExtension)[1].d);
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO,
|
| + message.getExtension(
|
| + Unittest.repeatedNestedEnumExtension)[1]);
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_FOO,
|
| + message.getExtension(
|
| + Unittest.repeatedForeignEnumExtension)[1]);
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO,
|
| + message.getExtension(
|
| + Unittest.repeatedImportEnumExtension)[1]);
|
| +
|
| + Expect.equals("524", message.getExtension(
|
| + Unittest.repeatedStringPieceExtension)[1]);
|
| + Expect.equals("525", message.getExtension(
|
| + Unittest.repeatedCordExtension)[1]);
|
| +
|
| + // -----------------------------------------------------------------
|
| +
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultInt32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultInt64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultUint32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultUint64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultSint32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultSint64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultFixed32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultFixed64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultSfixed32Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultSfixed64Extension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultFloatExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultDoubleExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultBoolExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultStringExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultBytesExtension));
|
| +
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultNestedEnumExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultForeignEnumExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultImportEnumExtension));
|
| +
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultStringPieceExtension));
|
| + Expect.isTrue(message.hasExtension(
|
| + Unittest.defaultCordExtension));
|
| +
|
| + Expect.equals(401, message.getExtension(
|
| + Unittest.defaultInt32Extension));
|
| + Expect.equals(402, message.getExtension(
|
| + Unittest.defaultInt64Extension));
|
| + Expect.equals(403, message.getExtension(
|
| + Unittest.defaultUint32Extension));
|
| + Expect.equals(404, message.getExtension(
|
| + Unittest.defaultUint64Extension));
|
| + Expect.equals(405, message.getExtension(
|
| + Unittest.defaultSint32Extension));
|
| + Expect.equals(406, message.getExtension(
|
| + Unittest.defaultSint64Extension));
|
| + Expect.equals(407, message.getExtension(
|
| + Unittest.defaultFixed32Extension));
|
| + Expect.equals(408, message.getExtension(
|
| + Unittest.defaultFixed64Extension));
|
| + Expect.equals(409, message.getExtension(
|
| + Unittest.defaultSfixed32Extension));
|
| + Expect.equals(410, message.getExtension(
|
| + Unittest.defaultSfixed64Extension));
|
| + Expect.equals(411.0, message.getExtension(
|
| + Unittest.defaultFloatExtension));
|
| + Expect.equals(412.0, message.getExtension(
|
| + Unittest.defaultDoubleExtension));
|
| + Expect.equals(false, message.getExtension(
|
| + Unittest.defaultBoolExtension));
|
| + Expect.equals("415", message.getExtension(
|
| + Unittest.defaultStringExtension));
|
| + Expect.listEquals("416".charCodes(), message.getExtension(
|
| + Unittest.defaultBytesExtension));
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO,
|
| + message.getExtension(Unittest.defaultNestedEnumExtension));
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_FOO,
|
| + message.getExtension(Unittest.defaultForeignEnumExtension));
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO,
|
| + message.getExtension(Unittest.defaultImportEnumExtension));
|
| +
|
| + Expect.equals("424", message.getExtension(
|
| + Unittest.defaultStringPieceExtension));
|
| + Expect.equals("425", message.getExtension(
|
| + Unittest.defaultCordExtension));
|
| +}
|
| +
|
| +void assertExtensionsClear(Protobuf_Unittest_TestAllExtensions message) {
|
| + // hasBlah() should initially be false for all optional fields.
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalInt32Extension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalInt64Extension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalUint32Extension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalUint64Extension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalSint32Extension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalSint64Extension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalFixed32Extension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalFixed64Extension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalSfixed32Extension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalSfixed64Extension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalFloatExtension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalDoubleExtension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalBoolExtension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalStringExtension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalBytesExtension ));
|
| +
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalGroupExtension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalNestedMessageExtension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalForeignMessageExtension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalImportMessageExtension ));
|
| +
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalNestedEnumExtension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalForeignEnumExtension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalImportEnumExtension ));
|
| +
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalStringPieceExtension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.optionalCordExtension));
|
| +
|
| + // Optional fields without defaults are set to zero or something like it.
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalInt32Extension ));
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalInt64Extension ));
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalUint32Extension ));
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalUint64Extension ));
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalSint32Extension ));
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalSint64Extension ));
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalFixed32Extension ));
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalFixed64Extension ));
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalSfixed32Extension));
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalSfixed64Extension));
|
| + Expect.equals(0.0, message.getExtension(
|
| + Unittest.optionalFloatExtension ));
|
| + Expect.equals(0.0, message.getExtension(
|
| + Unittest.optionalDoubleExtension ));
|
| + Expect.equals(false, message.getExtension(
|
| + Unittest.optionalBoolExtension ));
|
| + Expect.equals("", message.getExtension(
|
| + Unittest.optionalStringExtension ));
|
| + Expect.listEquals(<int>[], message.getExtension(
|
| + Unittest.optionalBytesExtension));
|
| +
|
| + // Embedded messages should also be clear.
|
| + Expect.isFalse(message.getExtension(
|
| + Unittest.optionalGroupExtension).hasA());
|
| + Expect.isFalse(message.getExtension(
|
| + Unittest.optionalNestedMessageExtension).hasBb());
|
| + Expect.isFalse(message.getExtension(
|
| + Unittest.optionalForeignMessageExtension).hasC());
|
| + Expect.isFalse(message.getExtension(
|
| + Unittest.optionalImportMessageExtension).hasD());
|
| +
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalGroupExtension).a);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalNestedMessageExtension).bb);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalForeignMessageExtension).c);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.optionalImportMessageExtension).d);
|
| +
|
| + // Enums without defaults are set to the first value in the enum.
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO,
|
| + message.getExtension(
|
| + Unittest.optionalNestedEnumExtension));
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_FOO,
|
| + message.getExtension(
|
| + Unittest.optionalForeignEnumExtension));
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO,
|
| + message.getExtension(
|
| + Unittest.optionalImportEnumExtension));
|
| +
|
| + Expect.equals("", message.getExtension(
|
| + Unittest.optionalStringPieceExtension));
|
| + Expect.equals("",
|
| + message.getExtension(Unittest.optionalCordExtension));
|
| +
|
| + // Repeated fields are empty.
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedInt32Extension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedInt64Extension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedUint32Extension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedUint64Extension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedSint32Extension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedSint64Extension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedFixed32Extension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedFixed64Extension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedSfixed32Extension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedSfixed64Extension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedFloatExtension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedDoubleExtension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedBoolExtension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedStringExtension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedBytesExtension));
|
| +
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedGroupExtension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedNestedMessageExtension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedForeignMessageExtension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedImportMessageExtension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedNestedEnumExtension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedForeignEnumExtension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedImportEnumExtension));
|
| +
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedStringPieceExtension));
|
| + Expect.equals(0, message.getExtensionCount(
|
| + Unittest.repeatedCordExtension));
|
| +
|
| + // Repeated fields are empty via getExtension().length.
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedInt32Extension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedInt64Extension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedUint32Extension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedUint64Extension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedSint32Extension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedSint64Extension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedFixed32Extension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedFixed64Extension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedSfixed32Extension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedSfixed64Extension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedFloatExtension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedDoubleExtension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedBoolExtension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedStringExtension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedBytesExtension).length);
|
| +
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedGroupExtension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedNestedMessageExtension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedForeignMessageExtension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedImportMessageExtension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedNestedEnumExtension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedForeignEnumExtension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedImportEnumExtension).length);
|
| +
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedStringPieceExtension).length);
|
| + Expect.equals(0, message.getExtension(
|
| + Unittest.repeatedCordExtension).length);
|
| +
|
| + // hasBlah() should also be false for all default fields.
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultInt32Extension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultInt64Extension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultUint32Extension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultUint64Extension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultSint32Extension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultSint64Extension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultFixed32Extension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultFixed64Extension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultSfixed32Extension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultSfixed64Extension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultFloatExtension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultDoubleExtension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultBoolExtension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultStringExtension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultBytesExtension));
|
| +
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultNestedEnumExtension ));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultForeignEnumExtension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultImportEnumExtension ));
|
| +
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultStringPieceExtension));
|
| + Expect.isFalse(message.hasExtension(
|
| + Unittest.defaultCordExtension));
|
| +
|
| + // Fields with defaults have their default values (duh).
|
| + Expect.equals(41, message.getExtension(
|
| + Unittest.defaultInt32Extension));
|
| + Expect.equals(42, message.getExtension(
|
| + Unittest.defaultInt64Extension));
|
| + Expect.equals(43, message.getExtension(
|
| + Unittest.defaultUint32Extension));
|
| + Expect.equals(44, message.getExtension(
|
| + Unittest.defaultUint64Extension));
|
| + Expect.equals(-45, message.getExtension(
|
| + Unittest.defaultSint32Extension));
|
| + Expect.equals(46, message.getExtension(
|
| + Unittest.defaultSint64Extension));
|
| + Expect.equals(47, message.getExtension(
|
| + Unittest.defaultFixed32Extension));
|
| + Expect.equals(48, message.getExtension(
|
| + Unittest.defaultFixed64Extension));
|
| + Expect.equals(49, message.getExtension(
|
| + Unittest.defaultSfixed32Extension));
|
| + Expect.equals(-50, message.getExtension(
|
| + Unittest.defaultSfixed64Extension));
|
| + Expect.equals(51.5, message.getExtension(
|
| + Unittest.defaultFloatExtension));
|
| + Expect.equals(52e3, message.getExtension(
|
| + Unittest.defaultDoubleExtension));
|
| + Expect.equals(true, message.getExtension(
|
| + Unittest.defaultBoolExtension));
|
| + Expect.equals("hello", message.getExtension(
|
| + Unittest.defaultStringExtension));
|
| + Expect.listEquals("world".charCodes(), message.getExtension(
|
| + Unittest.defaultBytesExtension));
|
| +
|
| + Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR,
|
| + message.getExtension(Unittest.defaultNestedEnumExtension));
|
| + Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR,
|
| + message.getExtension(Unittest.defaultForeignEnumExtension));
|
| + Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR,
|
| + message.getExtension(Unittest.defaultImportEnumExtension));
|
| +
|
| + Expect.equals("abc", message.getExtension(
|
| + Unittest.defaultStringPieceExtension));
|
| + Expect.equals("123", message.getExtension(
|
| + Unittest.defaultCordExtension));
|
| +}
|
|
|
Chromium Code Reviews
Issue 10595002:
Protocol Buffer runtime library and 'protoc' plugin (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart