| OLD | NEW |
|---|
| (Empty) | |
| 1 |
| 2 List<int> goldenMessage = const <int>[ |
| 3 0x08, 0x65, 0x10, 0x66, 0x18, 0x67, 0x20, 0x68, 0x28, 0xd2, 0x01, 0x30, |
| 4 0xd4, 0x01, 0x3d, 0x6b, 0x00, 0x00, 0x00, 0x41, 0x6c, 0x00, 0x00, 0x00, |
| 5 0x00, 0x00, 0x00, 0x00, 0x4d, 0x6d, 0x00, 0x00, 0x00, 0x51, 0x6e, 0x00, |
| 6 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0xde, 0x42, 0x61, |
| 7 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x40, 0x68, 0x01, 0x72, 0x03, |
| 8 0x31, 0x31, 0x35, 0x7a, 0x03, 0x31, 0x31, 0x36, 0x83, 0x01, 0x88, 0x01, |
| 9 0x75, 0x84, 0x01, 0x92, 0x01, 0x02, 0x08, 0x76, 0x9a, 0x01, 0x02, 0x08, |
| 10 0x77, 0xa2, 0x01, 0x02, 0x08, 0x78, 0xa8, 0x01, 0x03, 0xb0, 0x01, 0x06, |
| 11 0xb8, 0x01, 0x09, 0xc2, 0x01, 0x03, 0x31, 0x32, 0x34, 0xca, 0x01, 0x03, |
| 12 0x31, 0x32, 0x35, 0xf8, 0x01, 0xc9, 0x01, 0xf8, 0x01, 0xad, 0x02, 0x80, |
| 13 0x02, 0xca, 0x01, 0x80, 0x02, 0xae, 0x02, 0x88, 0x02, 0xcb, 0x01, 0x88, |
| 14 0x02, 0xaf, 0x02, 0x90, 0x02, 0xcc, 0x01, 0x90, 0x02, 0xb0, 0x02, 0x98, |
| 15 0x02, 0x9a, 0x03, 0x98, 0x02, 0xe2, 0x04, 0xa0, 0x02, 0x9c, 0x03, 0xa0, |
| 16 0x02, 0xe4, 0x04, 0xad, 0x02, 0xcf, 0x00, 0x00, 0x00, 0xad, 0x02, 0x33, |
| 17 0x01, 0x00, 0x00, 0xb1, 0x02, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 18 0x00, 0xb1, 0x02, 0x34, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbd, |
| 19 0x02, 0xd1, 0x00, 0x00, 0x00, 0xbd, 0x02, 0x35, 0x01, 0x00, 0x00, 0xc1, |
| 20 0x02, 0xd2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc1, 0x02, 0x36, |
| 21 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcd, 0x02, 0x00, 0x00, 0x53, |
| 22 0x43, 0xcd, 0x02, 0x00, 0x80, 0x9b, 0x43, 0xd1, 0x02, 0x00, 0x00, 0x00, |
| 23 0x00, 0x00, 0x80, 0x6a, 0x40, 0xd1, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 24 0x80, 0x73, 0x40, 0xd8, 0x02, 0x01, 0xd8, 0x02, 0x00, 0xe2, 0x02, 0x03, |
| 25 0x32, 0x31, 0x35, 0xe2, 0x02, 0x03, 0x33, 0x31, 0x35, 0xea, 0x02, 0x03, |
| 26 0x32, 0x31, 0x36, 0xea, 0x02, 0x03, 0x33, 0x31, 0x36, 0xf3, 0x02, 0xf8, |
| 27 0x02, 0xd9, 0x01, 0xf4, 0x02, 0xf3, 0x02, 0xf8, 0x02, 0xbd, 0x02, 0xf4, |
| 28 0x02, 0x82, 0x03, 0x03, 0x08, 0xda, 0x01, 0x82, 0x03, 0x03, 0x08, 0xbe, |
| 29 0x02, 0x8a, 0x03, 0x03, 0x08, 0xdb, 0x01, 0x8a, 0x03, 0x03, 0x08, 0xbf, |
| 30 0x02, 0x92, 0x03, 0x03, 0x08, 0xdc, 0x01, 0x92, 0x03, 0x03, 0x08, 0xc0, |
| 31 0x02, 0x98, 0x03, 0x02, 0x98, 0x03, 0x03, 0xa0, 0x03, 0x05, 0xa0, 0x03, |
| 32 0x06, 0xa8, 0x03, 0x08, 0xa8, 0x03, 0x09, 0xb2, 0x03, 0x03, 0x32, 0x32, |
| 33 0x34, 0xb2, 0x03, 0x03, 0x33, 0x32, 0x34, 0xba, 0x03, 0x03, 0x32, 0x32, |
| 34 0x35, 0xba, 0x03, 0x03, 0x33, 0x32, 0x35, 0xe8, 0x03, 0x91, 0x03, 0xf0, |
| 35 0x03, 0x92, 0x03, 0xf8, 0x03, 0x93, 0x03, 0x80, 0x04, 0x94, 0x03, 0x88, |
| 36 0x04, 0xaa, 0x06, 0x90, 0x04, 0xac, 0x06, 0x9d, 0x04, 0x97, 0x01, 0x00, |
| 37 0x00, 0xa1, 0x04, 0x98, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xad, |
| 38 0x04, 0x99, 0x01, 0x00, 0x00, 0xb1, 0x04, 0x9a, 0x01, 0x00, 0x00, 0x00, |
| 39 0x00, 0x00, 0x00, 0xbd, 0x04, 0x00, 0x80, 0xcd, 0x43, 0xc1, 0x04, 0x00, |
| 40 0x00, 0x00, 0x00, 0x00, 0xc0, 0x79, 0x40, 0xc8, 0x04, 0x00, 0xd2, 0x04, |
| 41 0x03, 0x34, 0x31, 0x35, 0xda, 0x04, 0x03, 0x34, 0x31, 0x36, 0x88, 0x05, |
| 42 0x01, 0x90, 0x05, 0x04, 0x98, 0x05, 0x07, 0xa2, 0x05, 0x03, 0x34, 0x32, |
| 43 0x34, 0xaa, 0x05, 0x03, 0x34, 0x32, 0x35 |
| 44 ]; |
| 45 |
| 46 List<int> goldenPackedMessage = const <int>[ |
| 47 0xd2, 0x05, 0x04, 0xd9, 0x04, 0xbd, 0x05, 0xda, 0x05, 0x04, 0xda, 0x04, |
| 48 0xbe, 0x05, 0xe2, 0x05, 0x04, 0xdb, 0x04, 0xbf, 0x05, 0xea, 0x05, 0x04, |
| 49 0xdc, 0x04, 0xc0, 0x05, 0xf2, 0x05, 0x04, 0xba, 0x09, 0x82, 0x0b, 0xfa, |
| 50 0x05, 0x04, 0xbc, 0x09, 0x84, 0x0b, 0x82, 0x06, 0x08, 0x5f, 0x02, 0x00, |
| 51 0x00, 0xc3, 0x02, 0x00, 0x00, 0x8a, 0x06, 0x10, 0x60, 0x02, 0x00, 0x00, |
| 52 0x00, 0x00, 0x00, 0x00, 0xc4, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 53 0x92, 0x06, 0x08, 0x61, 0x02, 0x00, 0x00, 0xc5, 0x02, 0x00, 0x00, 0x9a, |
| 54 0x06, 0x10, 0x62, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x02, |
| 55 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2, 0x06, 0x08, 0x00, 0xc0, 0x18, |
| 56 0x44, 0x00, 0xc0, 0x31, 0x44, 0xaa, 0x06, 0x10, 0x00, 0x00, 0x00, 0x00, |
| 57 0x00, 0x20, 0x83, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x86, 0x40, |
| 58 0xb2, 0x06, 0x02, 0x01, 0x00, 0xba, 0x06, 0x02, 0x05, 0x06 |
| 59 ]; |
| 60 |
| 61 /** |
| 62 * Get a [Protobuf_Unittest_TestAllTypes] with all fields set as they would |
| 63 * be by [setAllFields(Protobuf_Unittest_TestAllTypes_Builder)]. |
| 64 */ |
| 65 Protobuf_Unittest_TestAllTypes getAllSet() { |
| 66 Protobuf_Unittest_TestAllTypes_Builder builder = |
| 67 new Protobuf_Unittest_TestAllTypes_Builder(); |
| 68 setAllFields(builder); |
| 69 return builder.build(); |
| 70 } |
| 71 |
| 72 /** |
| 73 * Set every field of {@code message} to the values expected by |
| 74 * {@code assertAllFieldsSet()}. |
| 75 */ |
| 76 void setAllFields(Protobuf_Unittest_TestAllTypes_Builder message) { |
| 77 message.optionalInt32 = 101; |
| 78 message.optionalInt64 = 102; |
| 79 message.optionalUint32 = 103; |
| 80 message.optionalUint64 = 104; |
| 81 message.optionalSint32 = 105; |
| 82 message.optionalSint64 = 106; |
| 83 message.optionalFixed32 = 107; |
| 84 message.optionalFixed64 = 108; |
| 85 message.optionalSfixed32 = 109; |
| 86 message.optionalSfixed64 = 110; |
| 87 message.optionalFloat = 111.0; |
| 88 message.optionalDouble = 112.0; |
| 89 message.optionalBool = true; |
| 90 message.optionalString = "115"; |
| 91 message.optionalBytes = "116".charCodes(); |
| 92 |
| 93 Protobuf_Unittest_TestAllTypes_OptionalGroup_Builder optionalGroupBuilder = |
| 94 new Protobuf_Unittest_TestAllTypes_OptionalGroup_Builder(); |
| 95 optionalGroupBuilder.a = 117; |
| 96 message.optionalGroup = optionalGroupBuilder.build(); |
| 97 |
| 98 Protobuf_Unittest_TestAllTypes_NestedMessage_Builder |
| 99 optionalNestedMessageBuilder = |
| 100 new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder(); |
| 101 optionalNestedMessageBuilder.bb = 118; |
| 102 message.optionalNestedMessage = optionalNestedMessageBuilder.build(); |
| 103 |
| 104 Protobuf_Unittest_ForeignMessage_Builder optionalForeignMessageBuilder = |
| 105 new Protobuf_Unittest_ForeignMessage_Builder(); |
| 106 optionalForeignMessageBuilder.c = 119; |
| 107 message.optionalForeignMessage = optionalForeignMessageBuilder.build(); |
| 108 |
| 109 Protobuf_Unittest_Import_ImportMessage_Builder optionalImportMessageBuilder = |
| 110 new Protobuf_Unittest_Import_ImportMessage_Builder(); |
| 111 optionalImportMessageBuilder.d = 120; |
| 112 message.optionalImportMessage = optionalImportMessageBuilder.build(); |
| 113 |
| 114 message.optionalNestedEnum = Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ; |
| 115 message.optionalForeignEnum = Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ; |
| 116 message.optionalImportEnum = Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ; |
| 117 |
| 118 message.optionalStringPiece = "124"; |
| 119 message.optionalCord = "125"; |
| 120 |
| 121 // ----------------------------------------------------------------- |
| 122 |
| 123 message.repeatedInt32.add(201); |
| 124 message.repeatedInt64.add(202); |
| 125 message.repeatedUint32.add(203); |
| 126 message.repeatedUint64.add(204); |
| 127 message.repeatedSint32.add(205); |
| 128 message.repeatedSint64.add(206); |
| 129 message.repeatedFixed32.add(207); |
| 130 message.repeatedFixed64.add(208); |
| 131 message.repeatedSfixed32.add(209); |
| 132 message.repeatedSfixed64.add(210); |
| 133 message.repeatedFloat.add(211.0); |
| 134 message.repeatedDouble.add(212.0); |
| 135 message.repeatedBool.add(true); |
| 136 message.repeatedString.add("215"); |
| 137 message.repeatedBytes.add("216".charCodes()); |
| 138 |
| 139 Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder repeatedGroupBuilder = |
| 140 new Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder(); |
| 141 repeatedGroupBuilder.a = 217; |
| 142 message.repeatedGroup.add(repeatedGroupBuilder.build()); |
| 143 |
| 144 Protobuf_Unittest_TestAllTypes_NestedMessage_Builder repeatedNestedBuilder = |
| 145 new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder(); |
| 146 repeatedNestedBuilder.bb = 218; |
| 147 message.repeatedNestedMessage.add(repeatedNestedBuilder.build()); |
| 148 |
| 149 Protobuf_Unittest_ForeignMessage_Builder repeatedForeignMessageBuilder = |
| 150 new Protobuf_Unittest_ForeignMessage_Builder(); |
| 151 repeatedForeignMessageBuilder.c = 219; |
| 152 message.repeatedForeignMessage.add(repeatedForeignMessageBuilder.build()); |
| 153 |
| 154 Protobuf_Unittest_Import_ImportMessage_Builder repeatedImportMessageBuilder = |
| 155 new Protobuf_Unittest_Import_ImportMessage_Builder(); |
| 156 repeatedImportMessageBuilder.d = 220; |
| 157 message.repeatedImportMessage.add(repeatedImportMessageBuilder.build()); |
| 158 |
| 159 message.repeatedNestedEnum.add(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR); |
| 160 message.repeatedForeignEnum.add(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR); |
| 161 message.repeatedImportEnum.add( |
| 162 Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR); |
| 163 |
| 164 message.repeatedStringPiece.add("224"); |
| 165 message.repeatedCord.add("225"); |
| 166 |
| 167 // Add a second one of each field. |
| 168 message.repeatedInt32.add(301); |
| 169 message.repeatedInt64.add(302); |
| 170 message.repeatedUint32.add(303); |
| 171 message.repeatedUint64.add(304); |
| 172 message.repeatedSint32.add(305); |
| 173 message.repeatedSint64.add(306); |
| 174 message.repeatedFixed32.add(307); |
| 175 message.repeatedFixed64.add(308); |
| 176 message.repeatedSfixed32.add(309); |
| 177 message.repeatedSfixed64.add(310); |
| 178 message.repeatedFloat.add(311.0); |
| 179 message.repeatedDouble.add(312.0); |
| 180 message.repeatedBool.add(false); |
| 181 message.repeatedString.add("315"); |
| 182 message.repeatedBytes.add("316".charCodes()); |
| 183 |
| 184 repeatedGroupBuilder = |
| 185 new Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder(); |
| 186 repeatedGroupBuilder.a = 317; |
| 187 message.repeatedGroup.add(repeatedGroupBuilder.build()); |
| 188 |
| 189 repeatedNestedBuilder = |
| 190 new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder(); |
| 191 repeatedNestedBuilder.bb = 318; |
| 192 message.repeatedNestedMessage.add(repeatedNestedBuilder.build()); |
| 193 |
| 194 repeatedForeignMessageBuilder = |
| 195 new Protobuf_Unittest_ForeignMessage_Builder(); |
| 196 repeatedForeignMessageBuilder.c = 319; |
| 197 message.repeatedForeignMessage.add(repeatedForeignMessageBuilder.build()); |
| 198 |
| 199 repeatedImportMessageBuilder = |
| 200 new Protobuf_Unittest_Import_ImportMessage_Builder(); |
| 201 repeatedImportMessageBuilder.d = 320; |
| 202 message.repeatedImportMessage.add(repeatedImportMessageBuilder.build()); |
| 203 |
| 204 message.repeatedNestedEnum.add(Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ); |
| 205 message.repeatedForeignEnum.add(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ); |
| 206 message.repeatedImportEnum |
| 207 .add(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ); |
| 208 |
| 209 message.repeatedStringPiece.add("324"); |
| 210 message.repeatedCord.add("325"); |
| 211 |
| 212 // ----------------------------------------------------------------- |
| 213 |
| 214 message.defaultInt32 = 401; |
| 215 message.defaultInt64 = 402; |
| 216 message.defaultUint32 = 403; |
| 217 message.defaultUint64 = 404; |
| 218 message.defaultSint32 = 405; |
| 219 message.defaultSint64 = 406; |
| 220 message.defaultFixed32 = 407; |
| 221 message.defaultFixed64 = 408; |
| 222 message.defaultSfixed32 = 409; |
| 223 message.defaultSfixed64 = 410; |
| 224 message.defaultFloat = 411.0; |
| 225 message.defaultDouble = 412.0; |
| 226 message.defaultBool = false; |
| 227 message.defaultString = "415"; |
| 228 message.defaultBytes = "416".charCodes(); |
| 229 |
| 230 message.defaultNestedEnum = Protobuf_Unittest_TestAllTypes_NestedEnum.FOO; |
| 231 message.defaultForeignEnum = Protobuf_Unittest_ForeignEnum.FOREIGN_FOO; |
| 232 message.defaultImportEnum = Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO; |
| 233 |
| 234 message.defaultStringPiece = "424"; |
| 235 message.defaultCord = "425"; |
| 236 } |
| 237 |
| 238 void assertAllFieldsSet(Protobuf_Unittest_TestAllTypes message) { |
| 239 Expect.isTrue(message.hasOptionalInt32()); |
| 240 Expect.isTrue(message.hasOptionalInt64()); |
| 241 Expect.isTrue(message.hasOptionalUint32()); |
| 242 Expect.isTrue(message.hasOptionalUint64()); |
| 243 Expect.isTrue(message.hasOptionalSint32()); |
| 244 Expect.isTrue(message.hasOptionalSint64()); |
| 245 Expect.isTrue(message.hasOptionalFixed32()); |
| 246 Expect.isTrue(message.hasOptionalFixed64()); |
| 247 Expect.isTrue(message.hasOptionalSfixed32()); |
| 248 Expect.isTrue(message.hasOptionalSfixed64()); |
| 249 Expect.isTrue(message.hasOptionalFloat()); |
| 250 Expect.isTrue(message.hasOptionalDouble()); |
| 251 Expect.isTrue(message.hasOptionalBool()); |
| 252 Expect.isTrue(message.hasOptionalString()); |
| 253 Expect.isTrue(message.hasOptionalBytes()); |
| 254 |
| 255 Expect.isTrue(message.hasOptionalGroup()); |
| 256 Expect.isTrue(message.hasOptionalNestedMessage()); |
| 257 Expect.isTrue(message.hasOptionalForeignMessage()); |
| 258 Expect.isTrue(message.hasOptionalImportMessage()); |
| 259 |
| 260 Expect.isTrue(message.optionalGroup.hasA()); |
| 261 Expect.isTrue(message.optionalNestedMessage.hasBb()); |
| 262 Expect.isTrue(message.optionalForeignMessage.hasC()); |
| 263 Expect.isTrue(message.optionalImportMessage.hasD()); |
| 264 |
| 265 Expect.isTrue(message.hasOptionalNestedEnum()); |
| 266 Expect.isTrue(message.hasOptionalForeignEnum()); |
| 267 Expect.isTrue(message.hasOptionalImportEnum()); |
| 268 |
| 269 Expect.isTrue(message.hasOptionalStringPiece()); |
| 270 Expect.isTrue(message.hasOptionalCord()); |
| 271 |
| 272 Expect.equals(101, message.optionalInt32); |
| 273 Expect.equals(102, message.optionalInt64); |
| 274 Expect.equals(103, message.optionalUint32); |
| 275 Expect.equals(104, message.optionalUint64); |
| 276 Expect.equals(105, message.optionalSint32); |
| 277 Expect.equals(106, message.optionalSint64); |
| 278 Expect.equals(107, message.optionalFixed32); |
| 279 Expect.equals(108, message.optionalFixed64); |
| 280 Expect.equals(109, message.optionalSfixed32); |
| 281 Expect.equals(110, message.optionalSfixed64); |
| 282 Expect.approxEquals(111.0, message.optionalFloat); |
| 283 Expect.approxEquals(112.0, message.optionalDouble); |
| 284 Expect.equals(true, message.optionalBool); |
| 285 Expect.equals("115", message.optionalString); |
| 286 Expect.listEquals("116".charCodes(), message.optionalBytes); |
| 287 |
| 288 Expect.equals(117, message.optionalGroup.a); |
| 289 Expect.equals(118, message.optionalNestedMessage.bb); |
| 290 Expect.equals(119, message.optionalForeignMessage.c); |
| 291 Expect.equals(120, message.optionalImportMessage.d); |
| 292 |
| 293 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ, |
| 294 message.optionalNestedEnum); |
| 295 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ, |
| 296 message.optionalForeignEnum); |
| 297 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ, |
| 298 message.optionalImportEnum); |
| 299 |
| 300 Expect.equals("124", message.optionalStringPiece); |
| 301 Expect.equals("125", message.optionalCord); |
| 302 |
| 303 // ----------------------------------------------------------------- |
| 304 |
| 305 Expect.equals(2, message.repeatedInt32.length); |
| 306 Expect.equals(2, message.repeatedInt64.length); |
| 307 Expect.equals(2, message.repeatedUint32.length); |
| 308 Expect.equals(2, message.repeatedUint64.length); |
| 309 Expect.equals(2, message.repeatedSint32.length); |
| 310 Expect.equals(2, message.repeatedSint64.length); |
| 311 Expect.equals(2, message.repeatedFixed32.length); |
| 312 Expect.equals(2, message.repeatedFixed64.length); |
| 313 Expect.equals(2, message.repeatedSfixed32.length); |
| 314 Expect.equals(2, message.repeatedSfixed64.length); |
| 315 Expect.equals(2, message.repeatedFloat.length); |
| 316 Expect.equals(2, message.repeatedDouble.length); |
| 317 Expect.equals(2, message.repeatedBool.length); |
| 318 Expect.equals(2, message.repeatedString.length); |
| 319 Expect.equals(2, message.repeatedBytes.length); |
| 320 |
| 321 Expect.equals(2, message.repeatedGroup.length); |
| 322 Expect.equals(2, message.repeatedNestedMessage.length); |
| 323 Expect.equals(2, message.repeatedForeignMessage.length); |
| 324 Expect.equals(2, message.repeatedImportMessage.length); |
| 325 Expect.equals(2, message.repeatedNestedEnum.length); |
| 326 Expect.equals(2, message.repeatedForeignEnum.length); |
| 327 Expect.equals(2, message.repeatedImportEnum.length); |
| 328 |
| 329 Expect.equals(2, message.repeatedStringPiece.length); |
| 330 Expect.equals(2, message.repeatedCord.length); |
| 331 |
| 332 Expect.equals(201, message.repeatedInt32[0]); |
| 333 Expect.equals(202, message.repeatedInt64[0]); |
| 334 Expect.equals(203, message.repeatedUint32[0]); |
| 335 Expect.equals(204, message.repeatedUint64[0]); |
| 336 Expect.equals(205, message.repeatedSint32[0]); |
| 337 Expect.equals(206, message.repeatedSint64[0]); |
| 338 Expect.equals(207, message.repeatedFixed32[0]); |
| 339 Expect.equals(208, message.repeatedFixed64[0]); |
| 340 Expect.equals(209, message.repeatedSfixed32[0]); |
| 341 Expect.equals(210, message.repeatedSfixed64[0]); |
| 342 Expect.approxEquals(211.0, message.repeatedFloat[0]); |
| 343 Expect.approxEquals(212.0, message.repeatedDouble[0]); |
| 344 Expect.equals(true, message.repeatedBool[0]); |
| 345 Expect.equals("215", message.repeatedString[0]); |
| 346 Expect.listEquals("216".charCodes(), message.repeatedBytes[0]); |
| 347 |
| 348 Expect.equals(217, message.repeatedGroup[0].a); |
| 349 Expect.equals(218, message.repeatedNestedMessage[0].bb); |
| 350 Expect.equals(219, message.repeatedForeignMessage[0].c); |
| 351 Expect.equals(220, message.repeatedImportMessage[0].d); |
| 352 |
| 353 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR, |
| 354 message.repeatedNestedEnum[0]); |
| 355 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR, |
| 356 message.repeatedForeignEnum[0]); |
| 357 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR, |
| 358 message.repeatedImportEnum[0]); |
| 359 |
| 360 Expect.equals("224", message.repeatedStringPiece[0]); |
| 361 Expect.equals("225", message.repeatedCord[0]); |
| 362 |
| 363 Expect.equals(301, message.repeatedInt32[1]); |
| 364 Expect.equals(302, message.repeatedInt64[1]); |
| 365 Expect.equals(303, message.repeatedUint32[1]); |
| 366 Expect.equals(304, message.repeatedUint64[1]); |
| 367 Expect.equals(305, message.repeatedSint32[1]); |
| 368 Expect.equals(306, message.repeatedSint64[1]); |
| 369 Expect.equals(307, message.repeatedFixed32[1]); |
| 370 Expect.equals(308, message.repeatedFixed64[1]); |
| 371 Expect.equals(309, message.repeatedSfixed32[1]); |
| 372 Expect.equals(310, message.repeatedSfixed64[1]); |
| 373 Expect.approxEquals(311.0, message.repeatedFloat[1]); |
| 374 Expect.approxEquals(312.0, message.repeatedDouble[1]); |
| 375 Expect.equals(false, message.repeatedBool[1]); |
| 376 Expect.equals("315", message.repeatedString[1]); |
| 377 Expect.listEquals("316".charCodes(), message.repeatedBytes[1]); |
| 378 |
| 379 Expect.equals(317, message.repeatedGroup[1].a); |
| 380 Expect.equals(318, message.repeatedNestedMessage[1].bb); |
| 381 Expect.equals(319, message.repeatedForeignMessage[1].c); |
| 382 Expect.equals(320, message.repeatedImportMessage[1].d); |
| 383 |
| 384 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ, |
| 385 message.repeatedNestedEnum[1]); |
| 386 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ, |
| 387 message.repeatedForeignEnum[1]); |
| 388 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ, |
| 389 message.repeatedImportEnum[1]); |
| 390 |
| 391 Expect.equals("324", message.repeatedStringPiece[1]); |
| 392 Expect.equals("325", message.repeatedCord[1]); |
| 393 |
| 394 // ----------------------------------------------------------------- |
| 395 |
| 396 Expect.isTrue(message.hasDefaultInt32()); |
| 397 Expect.isTrue(message.hasDefaultInt64()); |
| 398 Expect.isTrue(message.hasDefaultUint32()); |
| 399 Expect.isTrue(message.hasDefaultUint64()); |
| 400 Expect.isTrue(message.hasDefaultSint32()); |
| 401 Expect.isTrue(message.hasDefaultSint64()); |
| 402 Expect.isTrue(message.hasDefaultFixed32()); |
| 403 Expect.isTrue(message.hasDefaultFixed64()); |
| 404 Expect.isTrue(message.hasDefaultSfixed32()); |
| 405 Expect.isTrue(message.hasDefaultSfixed64()); |
| 406 Expect.isTrue(message.hasDefaultFloat()); |
| 407 Expect.isTrue(message.hasDefaultDouble()); |
| 408 Expect.isTrue(message.hasDefaultBool()); |
| 409 Expect.isTrue(message.hasDefaultString()); |
| 410 Expect.isTrue(message.hasDefaultBytes()); |
| 411 |
| 412 Expect.isTrue(message.hasDefaultNestedEnum()); |
| 413 Expect.isTrue(message.hasDefaultForeignEnum()); |
| 414 Expect.isTrue(message.hasDefaultImportEnum()); |
| 415 |
| 416 Expect.isTrue(message.hasDefaultStringPiece()); |
| 417 Expect.isTrue(message.hasDefaultCord()); |
| 418 |
| 419 Expect.equals(401, message.defaultInt32); |
| 420 Expect.equals(402, message.defaultInt64); |
| 421 Expect.equals(403, message.defaultUint32); |
| 422 Expect.equals(404, message.defaultUint64); |
| 423 Expect.equals(405, message.defaultSint32); |
| 424 Expect.equals(406, message.defaultSint64); |
| 425 Expect.equals(407, message.defaultFixed32); |
| 426 Expect.equals(408, message.defaultFixed64); |
| 427 Expect.equals(409, message.defaultSfixed32); |
| 428 Expect.equals(410, message.defaultSfixed64); |
| 429 Expect.approxEquals(411.0, message.defaultFloat); |
| 430 Expect.approxEquals(412.0, message.defaultDouble); |
| 431 Expect.equals(false, message.defaultBool); |
| 432 Expect.equals("415", message.defaultString); |
| 433 Expect.listEquals("416".charCodes(), message.defaultBytes); |
| 434 |
| 435 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO, |
| 436 message.defaultNestedEnum); |
| 437 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_FOO, |
| 438 message.defaultForeignEnum); |
| 439 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO, |
| 440 message.defaultImportEnum); |
| 441 |
| 442 Expect.equals("424", message.defaultStringPiece); |
| 443 Expect.equals("425", message.defaultCord); |
| 444 } |
| 445 |
| 446 Protobuf_Unittest_TestPackedTypes getPackedSet() { |
| 447 Protobuf_Unittest_TestPackedTypes_Builder builder = |
| 448 new Protobuf_Unittest_TestPackedTypes_Builder(); |
| 449 setPackedFields(builder); |
| 450 return builder.build(); |
| 451 } |
| 452 |
| 453 /** |
| 454 * Assert (using Expect} that all fields of [message] are set to the values |
| 455 * assigned by [setPackedFields]. |
| 456 */ |
| 457 void assertPackedFieldsSet(Protobuf_Unittest_TestPackedTypes message) { |
| 458 Expect.equals(2, message.packedInt32.length); |
| 459 Expect.equals(2, message.packedInt64.length); |
| 460 Expect.equals(2, message.packedUint32.length); |
| 461 Expect.equals(2, message.packedUint64.length); |
| 462 Expect.equals(2, message.packedSint32.length); |
| 463 Expect.equals(2, message.packedSint64.length); |
| 464 Expect.equals(2, message.packedFixed32.length); |
| 465 Expect.equals(2, message.packedFixed64.length); |
| 466 Expect.equals(2, message.packedSfixed32.length); |
| 467 Expect.equals(2, message.packedSfixed64.length); |
| 468 Expect.equals(2, message.packedFloat.length); |
| 469 Expect.equals(2, message.packedDouble.length); |
| 470 Expect.equals(2, message.packedBool.length); |
| 471 Expect.equals(2, message.packedEnum.length); |
| 472 Expect.equals(601, message.packedInt32[0]); |
| 473 Expect.equals(602, message.packedInt64[0]); |
| 474 Expect.equals(603, message.packedUint32[0]); |
| 475 Expect.equals(604, message.packedUint64[0]); |
| 476 Expect.equals(605, message.packedSint32[0]); |
| 477 Expect.equals(606, message.packedSint64[0]); |
| 478 Expect.equals(607, message.packedFixed32[0]); |
| 479 Expect.equals(608, message.packedFixed64[0]); |
| 480 Expect.equals(609, message.packedSfixed32[0]); |
| 481 Expect.equals(610, message.packedSfixed64[0]); |
| 482 Expect.approxEquals(611.0, message.packedFloat[0], 0.0); |
| 483 Expect.approxEquals(612.0, message.packedDouble[0], 0.0); |
| 484 Expect.equals(true, message.packedBool[0]); |
| 485 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR, |
| 486 message.packedEnum[0]); |
| 487 Expect.equals(701, message.packedInt32[1]); |
| 488 Expect.equals(702, message.packedInt64[1]); |
| 489 Expect.equals(703, message.packedUint32[1]); |
| 490 Expect.equals(704, message.packedUint64[1]); |
| 491 Expect.equals(705, message.packedSint32[1]); |
| 492 Expect.equals(706, message.packedSint64[1]); |
| 493 Expect.equals(707, message.packedFixed32[1]); |
| 494 Expect.equals(708, message.packedFixed64[1]); |
| 495 Expect.equals(709, message.packedSfixed32[1]); |
| 496 Expect.equals(710, message.packedSfixed64[1]); |
| 497 Expect.approxEquals(711.0, message.packedFloat[1], 0.0); |
| 498 Expect.approxEquals(712.0, message.packedDouble[1], 0.0); |
| 499 Expect.equals(false, message.packedBool[1]); |
| 500 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ, |
| 501 message.packedEnum[1]); |
| 502 } |
| 503 |
| 504 /** |
| 505 * Set every field of [message] to a unique value. Must correspond with |
| 506 * the values applied by [setUnpackedFields]. |
| 507 */ |
| 508 void setPackedFields(Protobuf_Unittest_TestPackedTypes_Builder message) { |
| 509 message.packedInt32.add(601); |
| 510 message.packedInt64.add(602); |
| 511 message.packedUint32.add(603); |
| 512 message.packedUint64.add(604); |
| 513 message.packedSint32.add(605); |
| 514 message.packedSint64.add(606); |
| 515 message.packedFixed32.add(607); |
| 516 message.packedFixed64.add(608); |
| 517 message.packedSfixed32.add(609); |
| 518 message.packedSfixed64.add(610); |
| 519 message.packedFloat.add(611.0); |
| 520 message.packedDouble.add(612.0); |
| 521 message.packedBool.add(true); |
| 522 message.packedEnum.add(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR); |
| 523 // Add a second one of each field. |
| 524 message.packedInt32.add(701); |
| 525 message.packedInt64.add(702); |
| 526 message.packedUint32.add(703); |
| 527 message.packedUint64.add(704); |
| 528 message.packedSint32.add(705); |
| 529 message.packedSint64.add(706); |
| 530 message.packedFixed32.add(707); |
| 531 message.packedFixed64.add(708); |
| 532 message.packedSfixed32.add(709); |
| 533 message.packedSfixed64.add(710); |
| 534 message.packedFloat.add(711.0); |
| 535 message.packedDouble.add(712.0); |
| 536 message.packedBool.add(false); |
| 537 message.packedEnum.add(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ); |
| 538 } |
| 539 |
| 540 Protobuf_Unittest_TestAllExtensions getAllExtensionsSet() { |
| 541 Protobuf_Unittest_TestAllExtensions_Builder builder = |
| 542 new Protobuf_Unittest_TestAllExtensions_Builder(); |
| 543 setAllExtensions(builder); |
| 544 return builder.build(); |
| 545 } |
| 546 void setAllExtensions(Protobuf_Unittest_TestAllExtensions_Builder message) { |
| 547 message.setExtension(Unittest.optionalInt32Extension, 101); |
| 548 message.setExtension(Unittest.optionalInt64Extension, 102); |
| 549 message.setExtension(Unittest.optionalUint32Extension, 103); |
| 550 message.setExtension(Unittest.optionalUint64Extension, 104); |
| 551 message.setExtension(Unittest.optionalSint32Extension, 105); |
| 552 message.setExtension(Unittest.optionalSint64Extension, 106); |
| 553 message.setExtension(Unittest.optionalFixed32Extension, 107); |
| 554 message.setExtension(Unittest.optionalFixed64Extension, 108); |
| 555 message.setExtension(Unittest.optionalSfixed32Extension, 109); |
| 556 message.setExtension(Unittest.optionalSfixed64Extension, 110); |
| 557 message.setExtension(Unittest.optionalFloatExtension, 111.0); |
| 558 message.setExtension(Unittest.optionalDoubleExtension, 112.0); |
| 559 message.setExtension(Unittest.optionalBoolExtension, true); |
| 560 message.setExtension(Unittest.optionalStringExtension, "115"); |
| 561 message.setExtension(Unittest.optionalBytesExtension, |
| 562 "116".charCodes()); |
| 563 |
| 564 var builder; |
| 565 |
| 566 builder = new Protobuf_Unittest_OptionalGroup_extension_Builder(); |
| 567 builder.a = 117; |
| 568 message.setExtension(Unittest.optionalGroupExtension, |
| 569 builder.build()); |
| 570 |
| 571 builder = new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder(); |
| 572 builder.bb = 118; |
| 573 message.setExtension(Unittest.optionalNestedMessageExtension, |
| 574 builder.build()); |
| 575 |
| 576 builder = new Protobuf_Unittest_ForeignMessage_Builder(); |
| 577 builder.c = 119; |
| 578 message.setExtension(Unittest.optionalForeignMessageExtension, |
| 579 builder.build()); |
| 580 |
| 581 builder = new Protobuf_Unittest_Import_ImportMessage_Builder(); |
| 582 builder.d = 120; |
| 583 message.setExtension(Unittest.optionalImportMessageExtension, |
| 584 builder.build()); |
| 585 |
| 586 message.setExtension(Unittest.optionalNestedEnumExtension, |
| 587 Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ); |
| 588 message.setExtension(Unittest.optionalForeignEnumExtension, |
| 589 Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ); |
| 590 message.setExtension(Unittest.optionalImportEnumExtension, |
| 591 Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ); |
| 592 |
| 593 message.setExtension(Unittest.optionalStringPieceExtension, |
| 594 "124"); |
| 595 message.setExtension(Unittest.optionalCordExtension, "125"); |
| 596 |
| 597 // ----------------------------------------------------------------- |
| 598 |
| 599 message.addExtension(Unittest.repeatedInt32Extension, 201); |
| 600 message.addExtension(Unittest.repeatedInt64Extension, 202); |
| 601 message.addExtension(Unittest.repeatedUint32Extension, 203); |
| 602 message.addExtension(Unittest.repeatedUint64Extension, 204); |
| 603 message.addExtension(Unittest.repeatedSint32Extension, 205); |
| 604 message.addExtension(Unittest.repeatedSint64Extension, 206); |
| 605 message.addExtension(Unittest.repeatedFixed32Extension, 207); |
| 606 message.addExtension(Unittest.repeatedFixed64Extension, 208); |
| 607 message.addExtension(Unittest.repeatedSfixed32Extension, 209); |
| 608 message.addExtension(Unittest.repeatedSfixed64Extension, 210); |
| 609 message.addExtension(Unittest.repeatedFloatExtension, 211.0); |
| 610 message.addExtension(Unittest.repeatedDoubleExtension, 212.0); |
| 611 message.addExtension(Unittest.repeatedBoolExtension, true); |
| 612 message.addExtension(Unittest.repeatedStringExtension, "215"); |
| 613 message.addExtension(Unittest.repeatedBytesExtension, |
| 614 "216".charCodes()); |
| 615 |
| 616 builder = new Protobuf_Unittest_RepeatedGroup_extension_Builder(); |
| 617 builder.a = 217; |
| 618 message.addExtension(Unittest.repeatedGroupExtension, |
| 619 builder.build()); |
| 620 |
| 621 builder = new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder(); |
| 622 builder.bb = 218; |
| 623 message.addExtension(Unittest.repeatedNestedMessageExtension, |
| 624 builder.build()); |
| 625 |
| 626 builder = new Protobuf_Unittest_ForeignMessage_Builder(); |
| 627 builder.c = 219; |
| 628 message.addExtension(Unittest.repeatedForeignMessageExtension, |
| 629 builder.build()); |
| 630 |
| 631 builder = new Protobuf_Unittest_Import_ImportMessage_Builder(); |
| 632 builder.d = 220; |
| 633 message.addExtension(Unittest.repeatedImportMessageExtension, |
| 634 builder.build()); |
| 635 |
| 636 message.addExtension(Unittest.repeatedNestedEnumExtension, |
| 637 Protobuf_Unittest_TestAllTypes_NestedEnum.BAR); |
| 638 message.addExtension(Unittest.repeatedForeignEnumExtension, |
| 639 Protobuf_Unittest_ForeignEnum.FOREIGN_BAR); |
| 640 message.addExtension(Unittest.repeatedImportEnumExtension, |
| 641 Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR); |
| 642 |
| 643 message.addExtension(Unittest.repeatedStringPieceExtension, |
| 644 "224"); |
| 645 message.addExtension(Unittest.repeatedCordExtension, "225"); |
| 646 |
| 647 // Add a second one of each field. |
| 648 message.addExtension(Unittest.repeatedInt32Extension, 301); |
| 649 message.addExtension(Unittest.repeatedInt64Extension, 302); |
| 650 message.addExtension(Unittest.repeatedUint32Extension, 303); |
| 651 message.addExtension(Unittest.repeatedUint64Extension, 304); |
| 652 message.addExtension(Unittest.repeatedSint32Extension, 305); |
| 653 message.addExtension(Unittest.repeatedSint64Extension, 306); |
| 654 message.addExtension(Unittest.repeatedFixed32Extension, 307); |
| 655 message.addExtension(Unittest.repeatedFixed64Extension, 308); |
| 656 message.addExtension(Unittest.repeatedSfixed32Extension, 309); |
| 657 message.addExtension(Unittest.repeatedSfixed64Extension, 310); |
| 658 message.addExtension(Unittest.repeatedFloatExtension, 311.0); |
| 659 message.addExtension(Unittest.repeatedDoubleExtension, 312.0); |
| 660 message.addExtension(Unittest.repeatedBoolExtension, false); |
| 661 message.addExtension(Unittest.repeatedStringExtension, "315"); |
| 662 message.addExtension(Unittest.repeatedBytesExtension, |
| 663 "316".charCodes()); |
| 664 |
| 665 builder = new Protobuf_Unittest_RepeatedGroup_extension_Builder(); |
| 666 builder.a = 317; |
| 667 message.addExtension(Unittest.repeatedGroupExtension, |
| 668 builder.build()); |
| 669 |
| 670 builder = new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder(); |
| 671 builder.bb = 318; |
| 672 message.addExtension(Unittest.repeatedNestedMessageExtension, |
| 673 builder.build()); |
| 674 |
| 675 builder = new Protobuf_Unittest_ForeignMessage_Builder(); |
| 676 builder.c = 319; |
| 677 message.addExtension(Unittest.repeatedForeignMessageExtension, |
| 678 builder.build()); |
| 679 |
| 680 builder = new Protobuf_Unittest_Import_ImportMessage_Builder(); |
| 681 builder.d = 320; |
| 682 message.addExtension(Unittest.repeatedImportMessageExtension, |
| 683 builder.build()); |
| 684 |
| 685 message.addExtension(Unittest.repeatedNestedEnumExtension, |
| 686 Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ); |
| 687 message.addExtension(Unittest.repeatedForeignEnumExtension, |
| 688 Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ); |
| 689 message.addExtension(Unittest.repeatedImportEnumExtension, |
| 690 Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ); |
| 691 |
| 692 message.addExtension( |
| 693 Unittest.repeatedStringPieceExtension, "324"); |
| 694 message.addExtension(Unittest.repeatedCordExtension, "325"); |
| 695 |
| 696 // ----------------------------------------------------------------- |
| 697 |
| 698 message.setExtension(Unittest.defaultInt32Extension, 401); |
| 699 message.setExtension(Unittest.defaultInt64Extension, 402); |
| 700 message.setExtension(Unittest.defaultUint32Extension, 403); |
| 701 message.setExtension(Unittest.defaultUint64Extension, 404); |
| 702 message.setExtension(Unittest.defaultSint32Extension, 405); |
| 703 message.setExtension(Unittest.defaultSint64Extension, 406); |
| 704 message.setExtension(Unittest.defaultFixed32Extension, 407); |
| 705 message.setExtension(Unittest.defaultFixed64Extension, 408); |
| 706 message.setExtension(Unittest.defaultSfixed32Extension, 409); |
| 707 message.setExtension(Unittest.defaultSfixed64Extension, 410); |
| 708 message.setExtension(Unittest.defaultFloatExtension, 411.0); |
| 709 message.setExtension(Unittest.defaultDoubleExtension, 412.0); |
| 710 message.setExtension(Unittest.defaultBoolExtension, false); |
| 711 message.setExtension(Unittest.defaultStringExtension, "415"); |
| 712 message.setExtension(Unittest.defaultBytesExtension, |
| 713 "416".charCodes()); |
| 714 |
| 715 message.setExtension(Unittest.defaultNestedEnumExtension, |
| 716 Protobuf_Unittest_TestAllTypes_NestedEnum.FOO); |
| 717 message.setExtension(Unittest.defaultForeignEnumExtension, |
| 718 Protobuf_Unittest_ForeignEnum.FOREIGN_FOO); |
| 719 message.setExtension(Unittest.defaultImportEnumExtension, |
| 720 Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO); |
| 721 |
| 722 message.setExtension(Unittest.defaultStringPieceExtension, |
| 723 "424"); |
| 724 message.setExtension(Unittest.defaultCordExtension, "425"); |
| 725 } |
| 726 |
| 727 Protobuf_Unittest_TestPackedExtensions getPackedExtensionsSet() { |
| 728 Protobuf_Unittest_TestPackedExtensions_Builder builder = |
| 729 new Protobuf_Unittest_TestPackedExtensions_Builder(); |
| 730 setPackedExtensions(builder); |
| 731 return builder.build(); |
| 732 } |
| 733 |
| 734 void setPackedExtensions( |
| 735 Protobuf_Unittest_TestPackedExtensions_Builder message) { |
| 736 message.addExtension(Unittest.packedInt32Extension , 601); |
| 737 message.addExtension(Unittest.packedInt64Extension , 602); |
| 738 message.addExtension(Unittest.packedUint32Extension , 603); |
| 739 message.addExtension(Unittest.packedUint64Extension , 604); |
| 740 message.addExtension(Unittest.packedSint32Extension , 605); |
| 741 message.addExtension(Unittest.packedSint64Extension , 606); |
| 742 message.addExtension(Unittest.packedFixed32Extension , 607); |
| 743 message.addExtension(Unittest.packedFixed64Extension , 608); |
| 744 message.addExtension(Unittest.packedSfixed32Extension, 609); |
| 745 message.addExtension(Unittest.packedSfixed64Extension, 610); |
| 746 message.addExtension(Unittest.packedFloatExtension , 611.0); |
| 747 message.addExtension(Unittest.packedDoubleExtension , 612.0); |
| 748 message.addExtension(Unittest.packedBoolExtension , true); |
| 749 message.addExtension(Unittest.packedEnumExtension, |
| 750 Protobuf_Unittest_ForeignEnum.FOREIGN_BAR); |
| 751 // Add a second one of each field. |
| 752 message.addExtension(Unittest.packedInt32Extension , 701); |
| 753 message.addExtension(Unittest.packedInt64Extension , 702); |
| 754 message.addExtension(Unittest.packedUint32Extension , 703); |
| 755 message.addExtension(Unittest.packedUint64Extension , 704); |
| 756 message.addExtension(Unittest.packedSint32Extension , 705); |
| 757 message.addExtension(Unittest.packedSint64Extension , 706); |
| 758 message.addExtension(Unittest.packedFixed32Extension , 707); |
| 759 message.addExtension(Unittest.packedFixed64Extension , 708); |
| 760 message.addExtension(Unittest.packedSfixed32Extension, 709); |
| 761 message.addExtension(Unittest.packedSfixed64Extension, 710); |
| 762 message.addExtension(Unittest.packedFloatExtension , 711.0); |
| 763 message.addExtension(Unittest.packedDoubleExtension , 712.0); |
| 764 message.addExtension(Unittest.packedBoolExtension , false); |
| 765 message.addExtension(Unittest.packedEnumExtension, |
| 766 Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ); |
| 767 } |
| 768 |
| 769 ExtensionRegistry getExtensionRegistry() { |
| 770 ExtensionRegistry registry = new ExtensionRegistry(); |
| 771 registerAllExtensions(registry); |
| 772 return registry/*.getUnmodifiable()*/; |
| 773 } |
| 774 |
| 775 void assertAllExtensionsSet(Protobuf_Unittest_TestAllExtensions message) { |
| 776 Expect.isTrue(message.hasExtension( |
| 777 Unittest.optionalInt32Extension)); |
| 778 Expect.isTrue(message.hasExtension( |
| 779 Unittest.optionalInt64Extension)); |
| 780 Expect.isTrue(message.hasExtension( |
| 781 Unittest.optionalUint32Extension)); |
| 782 Expect.isTrue(message.hasExtension( |
| 783 Unittest.optionalUint64Extension)); |
| 784 Expect.isTrue(message.hasExtension( |
| 785 Unittest.optionalSint32Extension)); |
| 786 Expect.isTrue(message.hasExtension( |
| 787 Unittest.optionalSint64Extension)); |
| 788 Expect.isTrue(message.hasExtension( |
| 789 Unittest.optionalFixed32Extension)); |
| 790 Expect.isTrue(message.hasExtension( |
| 791 Unittest.optionalFixed64Extension)); |
| 792 Expect.isTrue(message.hasExtension( |
| 793 Unittest.optionalSfixed32Extension)); |
| 794 Expect.isTrue(message.hasExtension( |
| 795 Unittest.optionalSfixed64Extension)); |
| 796 Expect.isTrue(message.hasExtension( |
| 797 Unittest.optionalFloatExtension)); |
| 798 Expect.isTrue(message.hasExtension( |
| 799 Unittest.optionalDoubleExtension)); |
| 800 Expect.isTrue(message.hasExtension( |
| 801 Unittest.optionalBoolExtension)); |
| 802 Expect.isTrue(message.hasExtension( |
| 803 Unittest.optionalStringExtension)); |
| 804 Expect.isTrue(message.hasExtension( |
| 805 Unittest.optionalBytesExtension)); |
| 806 |
| 807 Expect.isTrue(message.hasExtension( |
| 808 Unittest.optionalGroupExtension)); |
| 809 Expect.isTrue(message.hasExtension( |
| 810 Unittest.optionalNestedMessageExtension)); |
| 811 Expect.isTrue(message.hasExtension( |
| 812 Unittest.optionalForeignMessageExtension)); |
| 813 Expect.isTrue(message.hasExtension( |
| 814 Unittest.optionalImportMessageExtension)); |
| 815 |
| 816 Expect.isTrue(message.getExtension( |
| 817 Unittest.optionalGroupExtension).hasA()); |
| 818 Expect.isTrue(message.getExtension( |
| 819 Unittest.optionalNestedMessageExtension).hasBb()); |
| 820 Expect.isTrue(message.getExtension( |
| 821 Unittest.optionalForeignMessageExtension).hasC()); |
| 822 Expect.isTrue(message.getExtension( |
| 823 Unittest.optionalImportMessageExtension).hasD()); |
| 824 |
| 825 Expect.isTrue(message.hasExtension( |
| 826 Unittest.optionalNestedEnumExtension)); |
| 827 Expect.isTrue(message.hasExtension( |
| 828 Unittest.optionalForeignEnumExtension)); |
| 829 Expect.isTrue(message.hasExtension( |
| 830 Unittest.optionalImportEnumExtension)); |
| 831 |
| 832 Expect.isTrue(message.hasExtension( |
| 833 Unittest.optionalStringPieceExtension)); |
| 834 Expect.isTrue(message.hasExtension( |
| 835 Unittest.optionalCordExtension)); |
| 836 |
| 837 Expect.equals(101, message.getExtension( |
| 838 Unittest.optionalInt32Extension)); |
| 839 Expect.equals(102, message.getExtension( |
| 840 Unittest.optionalInt64Extension)); |
| 841 Expect.equals(103, message.getExtension( |
| 842 Unittest.optionalUint32Extension)); |
| 843 Expect.equals(104, message.getExtension( |
| 844 Unittest.optionalUint64Extension)); |
| 845 Expect.equals(105, message.getExtension( |
| 846 Unittest.optionalSint32Extension)); |
| 847 Expect.equals(106, message.getExtension( |
| 848 Unittest.optionalSint64Extension)); |
| 849 Expect.equals(107, message.getExtension( |
| 850 Unittest.optionalFixed32Extension)); |
| 851 Expect.equals(108, message.getExtension( |
| 852 Unittest.optionalFixed64Extension)); |
| 853 Expect.equals(109, message.getExtension( |
| 854 Unittest.optionalSfixed32Extension)); |
| 855 Expect.equals(110, message.getExtension( |
| 856 Unittest.optionalSfixed64Extension)); |
| 857 Expect.equals(111.0, message.getExtension( |
| 858 Unittest.optionalFloatExtension)); |
| 859 Expect.equals(112.0, message.getExtension( |
| 860 Unittest.optionalDoubleExtension)); |
| 861 Expect.equals(true, message.getExtension( |
| 862 Unittest.optionalBoolExtension)); |
| 863 Expect.equals("115", message.getExtension( |
| 864 Unittest.optionalStringExtension)); |
| 865 Expect.listEquals("116".charCodes(), message.getExtension( |
| 866 Unittest.optionalBytesExtension)); |
| 867 |
| 868 Expect.equals(117, message.getExtension( |
| 869 Unittest.optionalGroupExtension).a); |
| 870 Expect.equals(118, message.getExtension( |
| 871 Unittest.optionalNestedMessageExtension).bb); |
| 872 Expect.equals(119, message.getExtension( |
| 873 Unittest.optionalForeignMessageExtension).c); |
| 874 Expect.equals(120, message.getExtension( |
| 875 Unittest.optionalImportMessageExtension).d); |
| 876 |
| 877 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ, |
| 878 message.getExtension( |
| 879 Unittest.optionalNestedEnumExtension)); |
| 880 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ, |
| 881 message.getExtension( |
| 882 Unittest.optionalForeignEnumExtension)); |
| 883 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ, |
| 884 message.getExtension( |
| 885 Unittest.optionalImportEnumExtension)); |
| 886 |
| 887 Expect.equals("124", message.getExtension( |
| 888 Unittest.optionalStringPieceExtension)); |
| 889 Expect.equals("125", message.getExtension( |
| 890 Unittest.optionalCordExtension)); |
| 891 |
| 892 // ----------------------------------------------------------------- |
| 893 |
| 894 Expect.equals(2, message.getExtensionCount( |
| 895 Unittest.repeatedInt32Extension)); |
| 896 Expect.equals(2, message.getExtensionCount( |
| 897 Unittest.repeatedInt64Extension)); |
| 898 Expect.equals(2, message.getExtensionCount( |
| 899 Unittest.repeatedUint32Extension)); |
| 900 Expect.equals(2, message.getExtensionCount( |
| 901 Unittest.repeatedUint64Extension)); |
| 902 Expect.equals(2, message.getExtensionCount( |
| 903 Unittest.repeatedSint32Extension)); |
| 904 Expect.equals(2, message.getExtensionCount( |
| 905 Unittest.repeatedSint64Extension)); |
| 906 Expect.equals(2, message.getExtensionCount( |
| 907 Unittest.repeatedFixed32Extension)); |
| 908 Expect.equals(2, message.getExtensionCount( |
| 909 Unittest.repeatedFixed64Extension)); |
| 910 Expect.equals(2, message.getExtensionCount( |
| 911 Unittest.repeatedSfixed32Extension)); |
| 912 Expect.equals(2, message.getExtensionCount( |
| 913 Unittest.repeatedSfixed64Extension)); |
| 914 Expect.equals(2, message.getExtensionCount( |
| 915 Unittest.repeatedFloatExtension)); |
| 916 Expect.equals(2, message.getExtensionCount( |
| 917 Unittest.repeatedDoubleExtension)); |
| 918 Expect.equals(2, message.getExtensionCount( |
| 919 Unittest.repeatedBoolExtension)); |
| 920 Expect.equals(2, message.getExtensionCount( |
| 921 Unittest.repeatedStringExtension)); |
| 922 Expect.equals(2, message.getExtensionCount( |
| 923 Unittest.repeatedBytesExtension)); |
| 924 |
| 925 Expect.equals(2, message.getExtensionCount( |
| 926 Unittest.repeatedGroupExtension)); |
| 927 Expect.equals(2, message.getExtensionCount( |
| 928 Unittest.repeatedNestedMessageExtension)); |
| 929 Expect.equals(2, message.getExtensionCount( |
| 930 Unittest.repeatedForeignMessageExtension)); |
| 931 Expect.equals(2, message.getExtensionCount( |
| 932 Unittest.repeatedImportMessageExtension)); |
| 933 Expect.equals(2, message.getExtensionCount( |
| 934 Unittest.repeatedNestedEnumExtension)); |
| 935 Expect.equals(2, message.getExtensionCount( |
| 936 Unittest.repeatedForeignEnumExtension)); |
| 937 Expect.equals(2, message.getExtensionCount( |
| 938 Unittest.repeatedImportEnumExtension)); |
| 939 |
| 940 Expect.equals(2, message.getExtensionCount( |
| 941 Unittest.repeatedStringPieceExtension)); |
| 942 Expect.equals(2, message.getExtensionCount( |
| 943 Unittest.repeatedCordExtension)); |
| 944 |
| 945 Expect.equals(201, message.getExtension( |
| 946 Unittest.repeatedInt32Extension)[0]); |
| 947 Expect.equals(202, message.getExtension( |
| 948 Unittest.repeatedInt64Extension)[0]); |
| 949 Expect.equals(203, message.getExtension( |
| 950 Unittest.repeatedUint32Extension)[0]); |
| 951 Expect.equals(204, message.getExtension( |
| 952 Unittest.repeatedUint64Extension)[0]); |
| 953 Expect.equals(205, message.getExtension( |
| 954 Unittest.repeatedSint32Extension)[0]); |
| 955 Expect.equals(206, message.getExtension( |
| 956 Unittest.repeatedSint64Extension)[0]); |
| 957 Expect.equals(207, message.getExtension( |
| 958 Unittest.repeatedFixed32Extension)[0]); |
| 959 Expect.equals(208, message.getExtension( |
| 960 Unittest.repeatedFixed64Extension)[0]); |
| 961 Expect.equals(209, message.getExtension( |
| 962 Unittest.repeatedSfixed32Extension)[0]); |
| 963 Expect.equals(210, message.getExtension( |
| 964 Unittest.repeatedSfixed64Extension)[0]); |
| 965 Expect.equals(211.0, message.getExtension( |
| 966 Unittest.repeatedFloatExtension)[0]); |
| 967 Expect.equals(212.0, message.getExtension( |
| 968 Unittest.repeatedDoubleExtension)[0]); |
| 969 Expect.equals(true, message.getExtension( |
| 970 Unittest.repeatedBoolExtension)[0]); |
| 971 Expect.equals("215", message.getExtension( |
| 972 Unittest.repeatedStringExtension)[0]); |
| 973 Expect.listEquals("216".charCodes(), message.getExtension( |
| 974 Unittest.repeatedBytesExtension)[0]); |
| 975 |
| 976 Expect.equals(217, message.getExtension( |
| 977 Unittest.repeatedGroupExtension)[0].a); |
| 978 Expect.equals(218, message.getExtension( |
| 979 Unittest.repeatedNestedMessageExtension)[0].bb); |
| 980 Expect.equals(219, message.getExtension( |
| 981 Unittest.repeatedForeignMessageExtension)[0].c); |
| 982 Expect.equals(220, message.getExtension( |
| 983 Unittest.repeatedImportMessageExtension)[0].d); |
| 984 |
| 985 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR, |
| 986 message.getExtension( |
| 987 Unittest.repeatedNestedEnumExtension)[0]); |
| 988 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR, |
| 989 message.getExtension( |
| 990 Unittest.repeatedForeignEnumExtension)[0]); |
| 991 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR, |
| 992 message.getExtension( |
| 993 Unittest.repeatedImportEnumExtension)[0]); |
| 994 |
| 995 Expect.equals("224", message.getExtension( |
| 996 Unittest.repeatedStringPieceExtension)[0]); |
| 997 Expect.equals("225", message.getExtension( |
| 998 Unittest.repeatedCordExtension)[0]); |
| 999 |
| 1000 Expect.equals(301, message.getExtension( |
| 1001 Unittest.repeatedInt32Extension)[1]); |
| 1002 Expect.equals(302, message.getExtension( |
| 1003 Unittest.repeatedInt64Extension)[1]); |
| 1004 Expect.equals(303, message.getExtension( |
| 1005 Unittest.repeatedUint32Extension)[1]); |
| 1006 Expect.equals(304, message.getExtension( |
| 1007 Unittest.repeatedUint64Extension)[1]); |
| 1008 Expect.equals(305, message.getExtension( |
| 1009 Unittest.repeatedSint32Extension)[1]); |
| 1010 Expect.equals(306, message.getExtension( |
| 1011 Unittest.repeatedSint64Extension)[1]); |
| 1012 Expect.equals(307, message.getExtension( |
| 1013 Unittest.repeatedFixed32Extension)[1]); |
| 1014 Expect.equals(308, message.getExtension( |
| 1015 Unittest.repeatedFixed64Extension)[1]); |
| 1016 Expect.equals(309, message.getExtension( |
| 1017 Unittest.repeatedSfixed32Extension)[1]); |
| 1018 Expect.equals(310, message.getExtension( |
| 1019 Unittest.repeatedSfixed64Extension)[1]); |
| 1020 Expect.equals(311.0, message.getExtension( |
| 1021 Unittest.repeatedFloatExtension)[1]); |
| 1022 Expect.equals(312.0, message.getExtension( |
| 1023 Unittest.repeatedDoubleExtension)[1]); |
| 1024 Expect.equals(false, message.getExtension( |
| 1025 Unittest.repeatedBoolExtension)[1]); |
| 1026 Expect.equals("315", message.getExtension( |
| 1027 Unittest.repeatedStringExtension)[1]); |
| 1028 Expect.listEquals("316".charCodes(), message.getExtension( |
| 1029 Unittest.repeatedBytesExtension)[1]); |
| 1030 |
| 1031 Expect.equals(317, message.getExtension( |
| 1032 Unittest.repeatedGroupExtension)[1].a); |
| 1033 Expect.equals(318, message.getExtension( |
| 1034 Unittest.repeatedNestedMessageExtension)[1].bb); |
| 1035 Expect.equals(319, message.getExtension( |
| 1036 Unittest.repeatedForeignMessageExtension)[1].c); |
| 1037 Expect.equals(320, message.getExtension( |
| 1038 Unittest.repeatedImportMessageExtension)[1].d); |
| 1039 |
| 1040 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ, |
| 1041 message.getExtension( |
| 1042 Unittest.repeatedNestedEnumExtension)[1]); |
| 1043 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ, |
| 1044 message.getExtension( |
| 1045 Unittest.repeatedForeignEnumExtension)[1]); |
| 1046 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ, |
| 1047 message.getExtension( |
| 1048 Unittest.repeatedImportEnumExtension)[1]); |
| 1049 |
| 1050 Expect.equals("324", message.getExtension( |
| 1051 Unittest.repeatedStringPieceExtension)[1]); |
| 1052 Expect.equals("325", message.getExtension( |
| 1053 Unittest.repeatedCordExtension)[1]); |
| 1054 |
| 1055 // ----------------------------------------------------------------- |
| 1056 |
| 1057 Expect.isTrue(message.hasExtension( |
| 1058 Unittest.defaultInt32Extension)); |
| 1059 Expect.isTrue(message.hasExtension( |
| 1060 Unittest.defaultInt64Extension)); |
| 1061 Expect.isTrue(message.hasExtension( |
| 1062 Unittest.defaultUint32Extension)); |
| 1063 Expect.isTrue(message.hasExtension( |
| 1064 Unittest.defaultUint64Extension)); |
| 1065 Expect.isTrue(message.hasExtension( |
| 1066 Unittest.defaultSint32Extension)); |
| 1067 Expect.isTrue(message.hasExtension( |
| 1068 Unittest.defaultSint64Extension)); |
| 1069 Expect.isTrue(message.hasExtension( |
| 1070 Unittest.defaultFixed32Extension)); |
| 1071 Expect.isTrue(message.hasExtension( |
| 1072 Unittest.defaultFixed64Extension)); |
| 1073 Expect.isTrue(message.hasExtension( |
| 1074 Unittest.defaultSfixed32Extension)); |
| 1075 Expect.isTrue(message.hasExtension( |
| 1076 Unittest.defaultSfixed64Extension)); |
| 1077 Expect.isTrue(message.hasExtension( |
| 1078 Unittest.defaultFloatExtension)); |
| 1079 Expect.isTrue(message.hasExtension( |
| 1080 Unittest.defaultDoubleExtension)); |
| 1081 Expect.isTrue(message.hasExtension( |
| 1082 Unittest.defaultBoolExtension)); |
| 1083 Expect.isTrue(message.hasExtension( |
| 1084 Unittest.defaultStringExtension)); |
| 1085 Expect.isTrue(message.hasExtension( |
| 1086 Unittest.defaultBytesExtension)); |
| 1087 |
| 1088 Expect.isTrue(message.hasExtension( |
| 1089 Unittest.defaultNestedEnumExtension)); |
| 1090 Expect.isTrue(message.hasExtension( |
| 1091 Unittest.defaultForeignEnumExtension)); |
| 1092 Expect.isTrue(message.hasExtension( |
| 1093 Unittest.defaultImportEnumExtension)); |
| 1094 |
| 1095 Expect.isTrue(message.hasExtension( |
| 1096 Unittest.defaultStringPieceExtension)); |
| 1097 Expect.isTrue(message.hasExtension( |
| 1098 Unittest.defaultCordExtension)); |
| 1099 |
| 1100 Expect.equals(401, message.getExtension( |
| 1101 Unittest.defaultInt32Extension)); |
| 1102 Expect.equals(402, message.getExtension( |
| 1103 Unittest.defaultInt64Extension)); |
| 1104 Expect.equals(403, message.getExtension( |
| 1105 Unittest.defaultUint32Extension)); |
| 1106 Expect.equals(404, message.getExtension( |
| 1107 Unittest.defaultUint64Extension)); |
| 1108 Expect.equals(405, message.getExtension( |
| 1109 Unittest.defaultSint32Extension)); |
| 1110 Expect.equals(406, message.getExtension( |
| 1111 Unittest.defaultSint64Extension)); |
| 1112 Expect.equals(407, message.getExtension( |
| 1113 Unittest.defaultFixed32Extension)); |
| 1114 Expect.equals(408, message.getExtension( |
| 1115 Unittest.defaultFixed64Extension)); |
| 1116 Expect.equals(409, message.getExtension( |
| 1117 Unittest.defaultSfixed32Extension)); |
| 1118 Expect.equals(410, message.getExtension( |
| 1119 Unittest.defaultSfixed64Extension)); |
| 1120 Expect.equals(411.0, message.getExtension( |
| 1121 Unittest.defaultFloatExtension)); |
| 1122 Expect.equals(412.0, message.getExtension( |
| 1123 Unittest.defaultDoubleExtension)); |
| 1124 Expect.equals(false, message.getExtension( |
| 1125 Unittest.defaultBoolExtension)); |
| 1126 Expect.equals("415", message.getExtension( |
| 1127 Unittest.defaultStringExtension)); |
| 1128 Expect.listEquals("416".charCodes(), message.getExtension( |
| 1129 Unittest.defaultBytesExtension)); |
| 1130 |
| 1131 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO, |
| 1132 message.getExtension(Unittest.defaultNestedEnumExtension)); |
| 1133 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_FOO, |
| 1134 message.getExtension(Unittest.defaultForeignEnumExtension)); |
| 1135 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO, |
| 1136 message.getExtension(Unittest.defaultImportEnumExtension)); |
| 1137 |
| 1138 Expect.equals("424", message.getExtension( |
| 1139 Unittest.defaultStringPieceExtension)); |
| 1140 Expect.equals("425", message.getExtension( |
| 1141 Unittest.defaultCordExtension)); |
| 1142 } |
| 1143 |
| 1144 void registerAllExtensions(ExtensionRegistry registry) { |
| 1145 Unittest.registerAllExtensions(registry); |
| 1146 } |
| 1147 |
| 1148 void assertPackedExtensionsSet(Protobuf_Unittest_TestPackedExtensions message) { |
| 1149 Expect.equals(2, message.getExtensionCount( |
| 1150 Unittest.packedInt32Extension )); |
| 1151 Expect.equals(2, message.getExtensionCount( |
| 1152 Unittest.packedInt64Extension )); |
| 1153 Expect.equals(2, message.getExtensionCount( |
| 1154 Unittest.packedUint32Extension )); |
| 1155 Expect.equals(2, message.getExtensionCount( |
| 1156 Unittest.packedUint64Extension )); |
| 1157 Expect.equals(2, message.getExtensionCount( |
| 1158 Unittest.packedSint32Extension )); |
| 1159 Expect.equals(2, message.getExtensionCount( |
| 1160 Unittest.packedSint64Extension )); |
| 1161 Expect.equals(2, message.getExtensionCount( |
| 1162 Unittest.packedFixed32Extension )); |
| 1163 Expect.equals(2, message.getExtensionCount( |
| 1164 Unittest.packedFixed64Extension )); |
| 1165 Expect.equals(2, message.getExtensionCount( |
| 1166 Unittest.packedSfixed32Extension)); |
| 1167 Expect.equals(2, message.getExtensionCount( |
| 1168 Unittest.packedSfixed64Extension)); |
| 1169 Expect.equals(2, message.getExtensionCount( |
| 1170 Unittest.packedFloatExtension )); |
| 1171 Expect.equals(2, message.getExtensionCount( |
| 1172 Unittest.packedDoubleExtension )); |
| 1173 Expect.equals(2, message.getExtensionCount( |
| 1174 Unittest.packedBoolExtension )); |
| 1175 Expect.equals(2, message.getExtensionCount( |
| 1176 Unittest.packedEnumExtension)); |
| 1177 Expect.equals(601, |
| 1178 message.getExtension(Unittest.packedInt32Extension)[0]); |
| 1179 Expect.equals(602, |
| 1180 message.getExtension(Unittest.packedInt64Extension)[0]); |
| 1181 Expect.equals(603, |
| 1182 message.getExtension(Unittest.packedUint32Extension)[0]); |
| 1183 Expect.equals(604, |
| 1184 message.getExtension(Unittest.packedUint64Extension)[0]); |
| 1185 Expect.equals(605, |
| 1186 message.getExtension(Unittest.packedSint32Extension)[0]); |
| 1187 Expect.equals(606, |
| 1188 message.getExtension(Unittest.packedSint64Extension)[0]); |
| 1189 Expect.equals(607, |
| 1190 message.getExtension(Unittest.packedFixed32Extension)[0]); |
| 1191 Expect.equals(608, |
| 1192 message.getExtension(Unittest.packedFixed64Extension)[0]); |
| 1193 Expect.equals(609, message.getExtension( |
| 1194 Unittest.packedSfixed32Extension)[0]); |
| 1195 Expect.equals(610, message.getExtension( |
| 1196 Unittest.packedSfixed64Extension)[0]); |
| 1197 Expect.equals(611.0, |
| 1198 message.getExtension(Unittest.packedFloatExtension)[0]); |
| 1199 Expect.equals(612.0, |
| 1200 message.getExtension(Unittest.packedDoubleExtension)[0]); |
| 1201 Expect.equals(true, |
| 1202 message.getExtension(Unittest.packedBoolExtension)[0]); |
| 1203 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR, |
| 1204 message.getExtension(Unittest.packedEnumExtension)[0]); |
| 1205 Expect.equals(701, |
| 1206 message.getExtension(Unittest.packedInt32Extension)[1]); |
| 1207 Expect.equals(702, |
| 1208 message.getExtension(Unittest.packedInt64Extension)[1]); |
| 1209 Expect.equals(703, |
| 1210 message.getExtension(Unittest.packedUint32Extension)[1]); |
| 1211 Expect.equals(704, |
| 1212 message.getExtension(Unittest.packedUint64Extension)[1]); |
| 1213 Expect.equals(705, |
| 1214 message.getExtension(Unittest.packedSint32Extension)[1]); |
| 1215 Expect.equals(706, |
| 1216 message.getExtension(Unittest.packedSint64Extension)[1]); |
| 1217 Expect.equals(707, |
| 1218 message.getExtension(Unittest.packedFixed32Extension)[1]); |
| 1219 Expect.equals(708, |
| 1220 message.getExtension(Unittest.packedFixed64Extension)[1]); |
| 1221 Expect.equals(709, message.getExtension( |
| 1222 Unittest.packedSfixed32Extension)[1]); |
| 1223 Expect.equals(710, message.getExtension( |
| 1224 Unittest.packedSfixed64Extension)[1]); |
| 1225 Expect.equals(711.0, |
| 1226 message.getExtension(Unittest.packedFloatExtension)[1]); |
| 1227 Expect.equals(712.0, |
| 1228 message.getExtension(Unittest.packedDoubleExtension)[1]); |
| 1229 Expect.equals(false, |
| 1230 message.getExtension(Unittest.packedBoolExtension)[1]); |
| 1231 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ, |
| 1232 message.getExtension(Unittest.packedEnumExtension)[1]); |
| 1233 } |
| 1234 |
| 1235 /** |
| 1236 * Modify the repeated fields of {@code message} to contain the values |
| 1237 * expected by {@code assertRepeatedFieldsModified()}. |
| 1238 */ |
| 1239 void modifyRepeatedFields(Protobuf_Unittest_TestAllTypes_Builder message) { |
| 1240 message.repeatedInt32[1] = 501; |
| 1241 message.repeatedInt64[1] = 502; |
| 1242 message.repeatedUint32[1] = 503; |
| 1243 message.repeatedUint64[1] = 504; |
| 1244 message.repeatedSint32[1] = 505; |
| 1245 message.repeatedSint64[1] = 506; |
| 1246 message.repeatedFixed32[1] = 507; |
| 1247 message.repeatedFixed64[1] = 508; |
| 1248 message.repeatedSfixed32[1] = 509; |
| 1249 message.repeatedSfixed64[1] = 510; |
| 1250 message.repeatedFloat[1] = 511.0; |
| 1251 message.repeatedDouble[1] = 512.0; |
| 1252 message.repeatedBool[1] = true; |
| 1253 message.repeatedString[1] = "515"; |
| 1254 message.repeatedBytes[1] = "516".charCodes(); |
| 1255 |
| 1256 |
| 1257 Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder repeatedGroupBuilder = |
| 1258 new Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder(); |
| 1259 repeatedGroupBuilder.a = 517; |
| 1260 message.repeatedGroup[1] = repeatedGroupBuilder.build(); |
| 1261 |
| 1262 Protobuf_Unittest_TestAllTypes_NestedMessage_Builder |
| 1263 optionalNestedMessageBuilder = |
| 1264 new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder(); |
| 1265 optionalNestedMessageBuilder.bb = 518; |
| 1266 message.repeatedNestedMessage[1] = optionalNestedMessageBuilder.build(); |
| 1267 |
| 1268 Protobuf_Unittest_ForeignMessage_Builder optionalForeignMessageBuilder = |
| 1269 new Protobuf_Unittest_ForeignMessage_Builder(); |
| 1270 optionalForeignMessageBuilder.c = 519; |
| 1271 message.repeatedForeignMessage[1] = optionalForeignMessageBuilder.build(); |
| 1272 |
| 1273 Protobuf_Unittest_Import_ImportMessage_Builder optionalImportMessageBuilder = |
| 1274 new Protobuf_Unittest_Import_ImportMessage_Builder(); |
| 1275 optionalImportMessageBuilder.d = 520; |
| 1276 message.repeatedImportMessage[1] = optionalImportMessageBuilder.build(); |
| 1277 |
| 1278 message.repeatedNestedEnum[1] = Protobuf_Unittest_TestAllTypes_NestedEnum.BAR; |
| 1279 message.repeatedForeignEnum[1] = Protobuf_Unittest_ForeignEnum.FOREIGN_BAR; |
| 1280 message.repeatedImportEnum[1] = |
| 1281 Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR; |
| 1282 |
| 1283 message.repeatedStringPiece[1] = "524"; |
| 1284 message.repeatedCord[1] = "525"; |
| 1285 } |
| 1286 |
| 1287 void assertRepeatedFieldsModified(Protobuf_Unittest_TestAllTypes message) { |
| 1288 // ModifyRepeatedFields only sets the second repeated element of each |
| 1289 // field. In addition to verifying this, we also verify that the first |
| 1290 // element and size were *not* modified. |
| 1291 Expect.equals(2, message.repeatedInt32.length); |
| 1292 Expect.equals(2, message.repeatedInt64.length); |
| 1293 Expect.equals(2, message.repeatedUint32.length); |
| 1294 Expect.equals(2, message.repeatedUint64.length); |
| 1295 Expect.equals(2, message.repeatedSint32.length); |
| 1296 Expect.equals(2, message.repeatedSint64.length); |
| 1297 Expect.equals(2, message.repeatedFixed32.length); |
| 1298 Expect.equals(2, message.repeatedFixed64.length); |
| 1299 Expect.equals(2, message.repeatedSfixed32.length); |
| 1300 Expect.equals(2, message.repeatedSfixed64.length); |
| 1301 Expect.equals(2, message.repeatedFloat.length); |
| 1302 Expect.equals(2, message.repeatedDouble.length); |
| 1303 Expect.equals(2, message.repeatedBool.length); |
| 1304 Expect.equals(2, message.repeatedString.length); |
| 1305 Expect.equals(2, message.repeatedBytes.length); |
| 1306 |
| 1307 Expect.equals(2, message.repeatedGroup.length); |
| 1308 Expect.equals(2, message.repeatedNestedMessage.length); |
| 1309 Expect.equals(2, message.repeatedForeignMessage.length); |
| 1310 Expect.equals(2, message.repeatedImportMessage.length); |
| 1311 Expect.equals(2, message.repeatedNestedEnum.length); |
| 1312 Expect.equals(2, message.repeatedForeignEnum.length); |
| 1313 Expect.equals(2, message.repeatedImportEnum.length); |
| 1314 |
| 1315 Expect.equals(2, message.repeatedStringPiece.length); |
| 1316 Expect.equals(2, message.repeatedCord.length); |
| 1317 |
| 1318 Expect.equals(201, message.repeatedInt32[0]); |
| 1319 Expect.equals(202, message.repeatedInt64[0]); |
| 1320 Expect.equals(203, message.repeatedUint32[0]); |
| 1321 Expect.equals(204, message.repeatedUint64[0]); |
| 1322 Expect.equals(205, message.repeatedSint32[0]); |
| 1323 Expect.equals(206, message.repeatedSint64[0]); |
| 1324 Expect.equals(207, message.repeatedFixed32[0]); |
| 1325 Expect.equals(208, message.repeatedFixed64[0]); |
| 1326 Expect.equals(209, message.repeatedSfixed32[0]); |
| 1327 Expect.equals(210, message.repeatedSfixed64[0]); |
| 1328 Expect.approxEquals(211.0, message.repeatedFloat[0]); |
| 1329 Expect.approxEquals(212.0, message.repeatedDouble[0]); |
| 1330 Expect.equals(true, message.repeatedBool[0]); |
| 1331 Expect.equals("215", message.repeatedString[0]); |
| 1332 Expect.listEquals("216".charCodes(), message.repeatedBytes[0]); |
| 1333 |
| 1334 Expect.equals(217, message.repeatedGroup[0].a); |
| 1335 Expect.equals(218, message.repeatedNestedMessage[0].bb); |
| 1336 Expect.equals(219, message.repeatedForeignMessage[0].c); |
| 1337 Expect.equals(220, message.repeatedImportMessage[0].d); |
| 1338 |
| 1339 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR, |
| 1340 message.repeatedNestedEnum[0]); |
| 1341 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR, |
| 1342 message.repeatedForeignEnum[0]); |
| 1343 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR, |
| 1344 message.repeatedImportEnum[0]); |
| 1345 |
| 1346 Expect.equals("224", message.repeatedStringPiece[0]); |
| 1347 Expect.equals("225", message.repeatedCord[0]); |
| 1348 |
| 1349 // Actually verify the second(modified) elements now. |
| 1350 Expect.equals(501, message.repeatedInt32[1]); |
| 1351 Expect.equals(502, message.repeatedInt64[1]); |
| 1352 Expect.equals(503, message.repeatedUint32[1]); |
| 1353 Expect.equals(504, message.repeatedUint64[1]); |
| 1354 Expect.equals(505, message.repeatedSint32[1]); |
| 1355 Expect.equals(506, message.repeatedSint64[1]); |
| 1356 Expect.equals(507, message.repeatedFixed32[1]); |
| 1357 Expect.equals(508, message.repeatedFixed64[1]); |
| 1358 Expect.equals(509, message.repeatedSfixed32[1]); |
| 1359 Expect.equals(510, message.repeatedSfixed64[1]); |
| 1360 Expect.approxEquals(511.0, message.repeatedFloat[1]); |
| 1361 Expect.approxEquals(512.0, message.repeatedDouble[1]); |
| 1362 Expect.equals(true, message.repeatedBool[1]); |
| 1363 Expect.equals("515", message.repeatedString[1]); |
| 1364 Expect.listEquals("516".charCodes(), message.repeatedBytes[1]); |
| 1365 |
| 1366 Expect.equals(517, message.repeatedGroup[1].a); |
| 1367 Expect.equals(518, message.repeatedNestedMessage[1].bb); |
| 1368 Expect.equals(519, message.repeatedForeignMessage[1].c); |
| 1369 Expect.equals(520, message.repeatedImportMessage[1].d); |
| 1370 |
| 1371 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR, |
| 1372 message.repeatedNestedEnum[1]); |
| 1373 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR, |
| 1374 message.repeatedForeignEnum[1]); |
| 1375 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR, |
| 1376 message.repeatedImportEnum[1]); |
| 1377 |
| 1378 Expect.equals("524", message.repeatedStringPiece[1]); |
| 1379 Expect.equals("525", message.repeatedCord[1]); |
| 1380 } |
| 1381 |
| 1382 void assertClear(Protobuf_Unittest_TestAllTypes message) { |
| 1383 // hasBlah() should initially be false for all optional fields. |
| 1384 Expect.isFalse(message.hasOptionalInt32()); |
| 1385 Expect.isFalse(message.hasOptionalInt64()); |
| 1386 Expect.isFalse(message.hasOptionalUint32()); |
| 1387 Expect.isFalse(message.hasOptionalUint64()); |
| 1388 Expect.isFalse(message.hasOptionalSint32()); |
| 1389 Expect.isFalse(message.hasOptionalSint64()); |
| 1390 Expect.isFalse(message.hasOptionalFixed32()); |
| 1391 Expect.isFalse(message.hasOptionalFixed64()); |
| 1392 Expect.isFalse(message.hasOptionalSfixed32()); |
| 1393 Expect.isFalse(message.hasOptionalSfixed64()); |
| 1394 Expect.isFalse(message.hasOptionalFloat()); |
| 1395 Expect.isFalse(message.hasOptionalDouble()); |
| 1396 Expect.isFalse(message.hasOptionalBool()); |
| 1397 Expect.isFalse(message.hasOptionalString()); |
| 1398 Expect.isFalse(message.hasOptionalBytes()); |
| 1399 |
| 1400 Expect.isFalse(message.hasOptionalGroup()); |
| 1401 Expect.isFalse(message.hasOptionalNestedMessage()); |
| 1402 Expect.isFalse(message.hasOptionalForeignMessage()); |
| 1403 Expect.isFalse(message.hasOptionalImportMessage()); |
| 1404 |
| 1405 Expect.isFalse(message.hasOptionalNestedEnum()); |
| 1406 Expect.isFalse(message.hasOptionalForeignEnum()); |
| 1407 Expect.isFalse(message.hasOptionalImportEnum()); |
| 1408 |
| 1409 Expect.isFalse(message.hasOptionalStringPiece()); |
| 1410 Expect.isFalse(message.hasOptionalCord()); |
| 1411 |
| 1412 // Optional fields without defaults are set to zero or something like it. |
| 1413 Expect.equals(0, message.optionalInt32); |
| 1414 Expect.equals(0, message.optionalInt64); |
| 1415 Expect.equals(0, message.optionalUint32); |
| 1416 Expect.equals(0, message.optionalUint64); |
| 1417 Expect.equals(0, message.optionalSint32); |
| 1418 Expect.equals(0, message.optionalSint64); |
| 1419 Expect.equals(0, message.optionalFixed32); |
| 1420 Expect.equals(0, message.optionalFixed64); |
| 1421 Expect.equals(0, message.optionalSfixed32); |
| 1422 Expect.equals(0, message.optionalSfixed64); |
| 1423 Expect.approxEquals(0, message.optionalFloat, 0.0); |
| 1424 Expect.approxEquals(0, message.optionalDouble, 0.0); |
| 1425 Expect.equals(false, message.optionalBool); |
| 1426 Expect.stringEquals("", message.optionalString); |
| 1427 Expect.listEquals(<int>[], message.optionalBytes); |
| 1428 |
| 1429 // Embedded messages should also be clear. |
| 1430 Expect.isFalse(message.optionalGroup.hasA()); |
| 1431 Expect.isFalse(message.optionalNestedMessage.hasBb()); |
| 1432 Expect.isFalse(message.optionalForeignMessage.hasC()); |
| 1433 Expect.isFalse(message.optionalImportMessage.hasD()); |
| 1434 |
| 1435 Expect.equals(0, message.optionalGroup.a); |
| 1436 Expect.equals(0, message.optionalNestedMessage.bb); |
| 1437 Expect.equals(0, message.optionalForeignMessage.c); |
| 1438 Expect.equals(0, message.optionalImportMessage.d); |
| 1439 |
| 1440 // Enums without defaults are set to the first value in the enum. |
| 1441 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO, |
| 1442 message.optionalNestedEnum); |
| 1443 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_FOO, |
| 1444 message.optionalForeignEnum); |
| 1445 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO, |
| 1446 message.optionalImportEnum); |
| 1447 |
| 1448 Expect.equals("", message.optionalStringPiece); |
| 1449 Expect.equals("", message.optionalCord); |
| 1450 |
| 1451 // Repeated fields are empty. |
| 1452 Expect.equals(0, message.repeatedInt32.length); |
| 1453 Expect.equals(0, message.repeatedInt64.length); |
| 1454 Expect.equals(0, message.repeatedUint32.length); |
| 1455 Expect.equals(0, message.repeatedUint64.length); |
| 1456 Expect.equals(0, message.repeatedSint32.length); |
| 1457 Expect.equals(0, message.repeatedSint64.length); |
| 1458 Expect.equals(0, message.repeatedFixed32.length); |
| 1459 Expect.equals(0, message.repeatedFixed64.length); |
| 1460 Expect.equals(0, message.repeatedSfixed32.length); |
| 1461 Expect.equals(0, message.repeatedSfixed64.length); |
| 1462 Expect.equals(0, message.repeatedFloat.length); |
| 1463 Expect.equals(0, message.repeatedDouble.length); |
| 1464 Expect.equals(0, message.repeatedBool.length); |
| 1465 Expect.equals(0, message.repeatedString.length); |
| 1466 Expect.equals(0, message.repeatedBytes.length); |
| 1467 |
| 1468 Expect.equals(0, message.repeatedGroup.length); |
| 1469 Expect.equals(0, message.repeatedNestedMessage.length); |
| 1470 Expect.equals(0, message.repeatedForeignMessage.length); |
| 1471 Expect.equals(0, message.repeatedImportMessage.length); |
| 1472 Expect.equals(0, message.repeatedNestedEnum.length); |
| 1473 Expect.equals(0, message.repeatedForeignEnum.length); |
| 1474 Expect.equals(0, message.repeatedImportEnum.length); |
| 1475 |
| 1476 Expect.equals(0, message.repeatedStringPiece.length); |
| 1477 Expect.equals(0, message.repeatedCord.length); |
| 1478 |
| 1479 // hasBlah() should also be false for all default fields. |
| 1480 Expect.isFalse(message.hasDefaultInt32()); |
| 1481 Expect.isFalse(message.hasDefaultInt64()); |
| 1482 Expect.isFalse(message.hasDefaultUint32()); |
| 1483 Expect.isFalse(message.hasDefaultUint64()); |
| 1484 Expect.isFalse(message.hasDefaultSint32()); |
| 1485 Expect.isFalse(message.hasDefaultSint64()); |
| 1486 Expect.isFalse(message.hasDefaultFixed32()); |
| 1487 Expect.isFalse(message.hasDefaultFixed64()); |
| 1488 Expect.isFalse(message.hasDefaultSfixed32()); |
| 1489 Expect.isFalse(message.hasDefaultSfixed64()); |
| 1490 Expect.isFalse(message.hasDefaultFloat()); |
| 1491 Expect.isFalse(message.hasDefaultDouble()); |
| 1492 Expect.isFalse(message.hasDefaultBool()); |
| 1493 Expect.isFalse(message.hasDefaultString()); |
| 1494 Expect.isFalse(message.hasDefaultBytes()); |
| 1495 |
| 1496 Expect.isFalse(message.hasDefaultNestedEnum()); |
| 1497 Expect.isFalse(message.hasDefaultForeignEnum()); |
| 1498 Expect.isFalse(message.hasDefaultImportEnum()); |
| 1499 |
| 1500 Expect.isFalse(message.hasDefaultStringPiece()); |
| 1501 Expect.isFalse(message.hasDefaultCord()); |
| 1502 |
| 1503 // Fields with defaults have their default values(duh). |
| 1504 Expect.equals( 41, message.defaultInt32); |
| 1505 Expect.equals( 42, message.defaultInt64); |
| 1506 Expect.equals( 43, message.defaultUint32); |
| 1507 Expect.equals( 44, message.defaultUint64); |
| 1508 Expect.equals(-45, message.defaultSint32); |
| 1509 Expect.equals( 46, message.defaultSint64); |
| 1510 Expect.equals( 47, message.defaultFixed32); |
| 1511 Expect.equals( 48, message.defaultFixed64); |
| 1512 Expect.equals( 49, message.defaultSfixed32); |
| 1513 Expect.equals(-50, message.defaultSfixed64); |
| 1514 Expect.approxEquals( 51.5, message.defaultFloat, 0.0); |
| 1515 Expect.approxEquals( 52e3, message.defaultDouble, 0.0); |
| 1516 Expect.isTrue(message.defaultBool); |
| 1517 Expect.stringEquals("hello", message.defaultString); |
| 1518 Expect.listEquals("world".charCodes(), message.defaultBytes); |
| 1519 |
| 1520 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR, |
| 1521 message.defaultNestedEnum); |
| 1522 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR, |
| 1523 message.defaultForeignEnum); |
| 1524 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR, |
| 1525 message.defaultImportEnum); |
| 1526 |
| 1527 Expect.equals("abc", message.defaultStringPiece); |
| 1528 Expect.equals("123", message.defaultCord); |
| 1529 } |
| 1530 |
| 1531 /** |
| 1532 * Assert (using Expect} that all fields of [message] are set to the values |
| 1533 * assigned by [setUnpackedFields]. |
| 1534 */ |
| 1535 void assertUnpackedFieldsSet(Protobuf_Unittest_TestUnpackedTypes message) { |
| 1536 Expect.equals(2, message.unpackedInt32.length); |
| 1537 Expect.equals(2, message.unpackedInt64.length); |
| 1538 Expect.equals(2, message.unpackedUint32.length); |
| 1539 Expect.equals(2, message.unpackedUint64.length); |
| 1540 Expect.equals(2, message.unpackedSint32.length); |
| 1541 Expect.equals(2, message.unpackedSint64.length); |
| 1542 Expect.equals(2, message.unpackedFixed32.length); |
| 1543 Expect.equals(2, message.unpackedFixed64.length); |
| 1544 Expect.equals(2, message.unpackedSfixed32.length); |
| 1545 Expect.equals(2, message.unpackedSfixed64.length); |
| 1546 Expect.equals(2, message.unpackedFloat.length); |
| 1547 Expect.equals(2, message.unpackedDouble.length); |
| 1548 Expect.equals(2, message.unpackedBool.length); |
| 1549 Expect.equals(2, message.unpackedEnum.length); |
| 1550 Expect.equals(601, message.unpackedInt32[0]); |
| 1551 Expect.equals(602, message.unpackedInt64[0]); |
| 1552 Expect.equals(603, message.unpackedUint32[0]); |
| 1553 Expect.equals(604, message.unpackedUint64[0]); |
| 1554 Expect.equals(605, message.unpackedSint32[0]); |
| 1555 Expect.equals(606, message.unpackedSint64[0]); |
| 1556 Expect.equals(607, message.unpackedFixed32[0]); |
| 1557 Expect.equals(608, message.unpackedFixed64[0]); |
| 1558 Expect.equals(609, message.unpackedSfixed32[0]); |
| 1559 Expect.equals(610, message.unpackedSfixed64[0]); |
| 1560 Expect.approxEquals(611.0, message.unpackedFloat[0], 0.0); |
| 1561 Expect.approxEquals(612.0, message.unpackedDouble[0], 0.0); |
| 1562 Expect.equals(true, message.unpackedBool[0]); |
| 1563 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR, |
| 1564 message.unpackedEnum[0]); |
| 1565 Expect.equals(701, message.unpackedInt32[1]); |
| 1566 Expect.equals(702, message.unpackedInt64[1]); |
| 1567 Expect.equals(703, message.unpackedUint32[1]); |
| 1568 Expect.equals(704, message.unpackedUint64[1]); |
| 1569 Expect.equals(705, message.unpackedSint32[1]); |
| 1570 Expect.equals(706, message.unpackedSint64[1]); |
| 1571 Expect.equals(707, message.unpackedFixed32[1]); |
| 1572 Expect.equals(708, message.unpackedFixed64[1]); |
| 1573 Expect.equals(709, message.unpackedSfixed32[1]); |
| 1574 Expect.equals(710, message.unpackedSfixed64[1]); |
| 1575 Expect.approxEquals(711.0, message.unpackedFloat[1], 0.0); |
| 1576 Expect.approxEquals(712.0, message.unpackedDouble[1], 0.0); |
| 1577 Expect.equals(false, message.unpackedBool[1]); |
| 1578 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ, |
| 1579 message.unpackedEnum[1]); |
| 1580 } |
| 1581 |
| 1582 Protobuf_Unittest_TestUnpackedTypes getUnpackedSet() { |
| 1583 Protobuf_Unittest_TestUnpackedTypes_Builder builder = |
| 1584 new Protobuf_Unittest_TestUnpackedTypes_Builder(); |
| 1585 setUnpackedFields(builder); |
| 1586 return builder.build(); |
| 1587 } |
| 1588 |
| 1589 /** |
| 1590 * Set every field of [message] to a unique value. Must correspond with |
| 1591 * the values applied by [setPackedFields]. |
| 1592 */ |
| 1593 void setUnpackedFields(Protobuf_Unittest_TestUnpackedTypes_Builder message) { |
| 1594 message.unpackedInt32.add(601); |
| 1595 message.unpackedInt64.add(602); |
| 1596 message.unpackedUint32.add(603); |
| 1597 message.unpackedUint64.add(604); |
| 1598 message.unpackedSint32.add(605); |
| 1599 message.unpackedSint64.add(606); |
| 1600 message.unpackedFixed32.add(607); |
| 1601 message.unpackedFixed64.add(608); |
| 1602 message.unpackedSfixed32.add(609); |
| 1603 message.unpackedSfixed64.add(610); |
| 1604 message.unpackedFloat.add(611.0); |
| 1605 message.unpackedDouble.add(612.0); |
| 1606 message.unpackedBool.add(true); |
| 1607 message.unpackedEnum.add(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR); |
| 1608 // Add a second one of each field. |
| 1609 message.unpackedInt32.add(701); |
| 1610 message.unpackedInt64.add(702); |
| 1611 message.unpackedUint32.add(703); |
| 1612 message.unpackedUint64.add(704); |
| 1613 message.unpackedSint32.add(705); |
| 1614 message.unpackedSint64.add(706); |
| 1615 message.unpackedFixed32.add(707); |
| 1616 message.unpackedFixed64.add(708); |
| 1617 message.unpackedSfixed32.add(709); |
| 1618 message.unpackedSfixed64.add(710); |
| 1619 message.unpackedFloat.add(711.0); |
| 1620 message.unpackedDouble.add(712.0); |
| 1621 message.unpackedBool.add(false); |
| 1622 message.unpackedEnum.add(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ); |
| 1623 } |
| 1624 |
| 1625 void modifyRepeatedExtensions( |
| 1626 Protobuf_Unittest_TestAllExtensions_Builder message) { |
| 1627 message.getExtension( |
| 1628 Unittest.repeatedInt32Extension)[1] = 501; |
| 1629 message.getExtension( |
| 1630 Unittest.repeatedInt64Extension)[1] = 502; |
| 1631 message.getExtension( |
| 1632 Unittest.repeatedUint32Extension)[1] = 503; |
| 1633 message.getExtension( |
| 1634 Unittest.repeatedUint64Extension)[1] = 504; |
| 1635 message.getExtension( |
| 1636 Unittest.repeatedSint32Extension)[1] = 505; |
| 1637 message.getExtension( |
| 1638 Unittest.repeatedSint64Extension)[1] = 506; |
| 1639 message.getExtension( |
| 1640 Unittest.repeatedFixed32Extension)[1] = 507; |
| 1641 message.getExtension( |
| 1642 Unittest.repeatedFixed64Extension)[1] = 508; |
| 1643 message.getExtension( |
| 1644 Unittest.repeatedSfixed32Extension)[1] = 509; |
| 1645 message.getExtension( |
| 1646 Unittest.repeatedSfixed64Extension)[1] = 510; |
| 1647 message.getExtension( |
| 1648 Unittest.repeatedFloatExtension)[1] = 511.0; |
| 1649 message.getExtension( |
| 1650 Unittest.repeatedDoubleExtension)[1] = 512.0; |
| 1651 message.getExtension( |
| 1652 Unittest.repeatedBoolExtension)[1] = true; |
| 1653 message.getExtension( |
| 1654 Unittest.repeatedStringExtension)[1] = "515"; |
| 1655 message.getExtension( |
| 1656 Unittest.repeatedBytesExtension)[1] = "516".charCodes(); |
| 1657 |
| 1658 var builder; |
| 1659 |
| 1660 builder = new Protobuf_Unittest_RepeatedGroup_extension_Builder(); |
| 1661 builder.a = 517; |
| 1662 message.getExtension( |
| 1663 Unittest.repeatedGroupExtension)[1] = builder.build(); |
| 1664 |
| 1665 builder = new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder(); |
| 1666 builder.bb = 518; |
| 1667 message.getExtension( |
| 1668 Unittest.repeatedNestedMessageExtension)[1] = |
| 1669 builder.build(); |
| 1670 |
| 1671 builder = new Protobuf_Unittest_ForeignMessage_Builder(); |
| 1672 builder.c = 519; |
| 1673 message.getExtension( |
| 1674 Unittest.repeatedForeignMessageExtension)[1] = |
| 1675 builder.build(); |
| 1676 |
| 1677 builder = new Protobuf_Unittest_Import_ImportMessage_Builder(); |
| 1678 builder.d = 520; |
| 1679 message.getExtension( |
| 1680 Unittest.repeatedImportMessageExtension)[1] = |
| 1681 builder.build(); |
| 1682 |
| 1683 message.getExtension( |
| 1684 Unittest.repeatedNestedEnumExtension)[1] = |
| 1685 Protobuf_Unittest_TestAllTypes_NestedEnum.FOO; |
| 1686 message.getExtension( |
| 1687 Unittest.repeatedForeignEnumExtension)[1] = |
| 1688 Protobuf_Unittest_ForeignEnum.FOREIGN_FOO; |
| 1689 message.getExtension( |
| 1690 Unittest.repeatedImportEnumExtension)[1] = |
| 1691 Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO; |
| 1692 |
| 1693 message.getExtension( |
| 1694 Unittest.repeatedStringPieceExtension)[1] = "524"; |
| 1695 message.getExtension( |
| 1696 Unittest.repeatedCordExtension)[1] = "525"; |
| 1697 } |
| 1698 |
| 1699 void assertRepeatedExtensionsModified( |
| 1700 Protobuf_Unittest_TestAllExtensions message) { |
| 1701 Expect.isTrue(message.hasExtension( |
| 1702 Unittest.optionalInt32Extension)); |
| 1703 Expect.isTrue(message.hasExtension( |
| 1704 Unittest.optionalInt64Extension)); |
| 1705 Expect.isTrue(message.hasExtension( |
| 1706 Unittest.optionalUint32Extension)); |
| 1707 Expect.isTrue(message.hasExtension( |
| 1708 Unittest.optionalUint64Extension)); |
| 1709 Expect.isTrue(message.hasExtension( |
| 1710 Unittest.optionalSint32Extension)); |
| 1711 Expect.isTrue(message.hasExtension( |
| 1712 Unittest.optionalSint64Extension)); |
| 1713 Expect.isTrue(message.hasExtension( |
| 1714 Unittest.optionalFixed32Extension)); |
| 1715 Expect.isTrue(message.hasExtension( |
| 1716 Unittest.optionalFixed64Extension)); |
| 1717 Expect.isTrue(message.hasExtension( |
| 1718 Unittest.optionalSfixed32Extension)); |
| 1719 Expect.isTrue(message.hasExtension( |
| 1720 Unittest.optionalSfixed64Extension)); |
| 1721 Expect.isTrue(message.hasExtension( |
| 1722 Unittest.optionalFloatExtension)); |
| 1723 Expect.isTrue(message.hasExtension( |
| 1724 Unittest.optionalDoubleExtension)); |
| 1725 Expect.isTrue(message.hasExtension( |
| 1726 Unittest.optionalBoolExtension)); |
| 1727 Expect.isTrue(message.hasExtension( |
| 1728 Unittest.optionalStringExtension)); |
| 1729 Expect.isTrue(message.hasExtension( |
| 1730 Unittest.optionalBytesExtension)); |
| 1731 |
| 1732 Expect.isTrue(message.hasExtension( |
| 1733 Unittest.optionalGroupExtension)); |
| 1734 Expect.isTrue(message.hasExtension( |
| 1735 Unittest.optionalNestedMessageExtension)); |
| 1736 Expect.isTrue(message.hasExtension( |
| 1737 Unittest.optionalForeignMessageExtension)); |
| 1738 Expect.isTrue(message.hasExtension( |
| 1739 Unittest.optionalImportMessageExtension)); |
| 1740 |
| 1741 Expect.isTrue(message.getExtension( |
| 1742 Unittest.optionalGroupExtension).hasA()); |
| 1743 Expect.isTrue(message.getExtension( |
| 1744 Unittest.optionalNestedMessageExtension).hasBb()); |
| 1745 Expect.isTrue(message.getExtension( |
| 1746 Unittest.optionalForeignMessageExtension).hasC()); |
| 1747 Expect.isTrue(message.getExtension( |
| 1748 Unittest.optionalImportMessageExtension).hasD()); |
| 1749 |
| 1750 Expect.isTrue(message.hasExtension( |
| 1751 Unittest.optionalNestedEnumExtension)); |
| 1752 Expect.isTrue(message.hasExtension( |
| 1753 Unittest.optionalForeignEnumExtension)); |
| 1754 Expect.isTrue(message.hasExtension( |
| 1755 Unittest.optionalImportEnumExtension)); |
| 1756 |
| 1757 Expect.isTrue(message.hasExtension( |
| 1758 Unittest.optionalStringPieceExtension)); |
| 1759 Expect.isTrue(message.hasExtension( |
| 1760 Unittest.optionalCordExtension)); |
| 1761 |
| 1762 Expect.equals(101, message.getExtension( |
| 1763 Unittest.optionalInt32Extension)); |
| 1764 Expect.equals(102, message.getExtension( |
| 1765 Unittest.optionalInt64Extension)); |
| 1766 Expect.equals(103, message.getExtension( |
| 1767 Unittest.optionalUint32Extension)); |
| 1768 Expect.equals(104, message.getExtension( |
| 1769 Unittest.optionalUint64Extension)); |
| 1770 Expect.equals(105, message.getExtension( |
| 1771 Unittest.optionalSint32Extension)); |
| 1772 Expect.equals(106, message.getExtension( |
| 1773 Unittest.optionalSint64Extension)); |
| 1774 Expect.equals(107, message.getExtension( |
| 1775 Unittest.optionalFixed32Extension)); |
| 1776 Expect.equals(108, message.getExtension( |
| 1777 Unittest.optionalFixed64Extension)); |
| 1778 Expect.equals(109, message.getExtension( |
| 1779 Unittest.optionalSfixed32Extension)); |
| 1780 Expect.equals(110, message.getExtension( |
| 1781 Unittest.optionalSfixed64Extension)); |
| 1782 Expect.equals(111.0, message.getExtension( |
| 1783 Unittest.optionalFloatExtension)); |
| 1784 Expect.equals(112.0, message.getExtension( |
| 1785 Unittest.optionalDoubleExtension)); |
| 1786 Expect.equals(true, message.getExtension( |
| 1787 Unittest.optionalBoolExtension)); |
| 1788 Expect.equals("115", message.getExtension( |
| 1789 Unittest.optionalStringExtension)); |
| 1790 Expect.listEquals("116".charCodes(), message.getExtension( |
| 1791 Unittest.optionalBytesExtension)); |
| 1792 |
| 1793 Expect.equals(117, message.getExtension( |
| 1794 Unittest.optionalGroupExtension).a); |
| 1795 Expect.equals(118, message.getExtension( |
| 1796 Unittest.optionalNestedMessageExtension).bb); |
| 1797 Expect.equals(119, message.getExtension( |
| 1798 Unittest.optionalForeignMessageExtension).c); |
| 1799 Expect.equals(120, message.getExtension( |
| 1800 Unittest.optionalImportMessageExtension).d); |
| 1801 |
| 1802 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAZ, |
| 1803 message.getExtension( |
| 1804 Unittest.optionalNestedEnumExtension)); |
| 1805 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAZ, |
| 1806 message.getExtension( |
| 1807 Unittest.optionalForeignEnumExtension)); |
| 1808 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAZ, |
| 1809 message.getExtension( |
| 1810 Unittest.optionalImportEnumExtension)); |
| 1811 |
| 1812 Expect.equals("124", message.getExtension( |
| 1813 Unittest.optionalStringPieceExtension)); |
| 1814 Expect.equals("125", message.getExtension( |
| 1815 Unittest.optionalCordExtension)); |
| 1816 |
| 1817 // ----------------------------------------------------------------- |
| 1818 |
| 1819 Expect.equals(2, message.getExtensionCount( |
| 1820 Unittest.repeatedInt32Extension)); |
| 1821 Expect.equals(2, message.getExtensionCount( |
| 1822 Unittest.repeatedInt64Extension)); |
| 1823 Expect.equals(2, message.getExtensionCount( |
| 1824 Unittest.repeatedUint32Extension)); |
| 1825 Expect.equals(2, message.getExtensionCount( |
| 1826 Unittest.repeatedUint64Extension)); |
| 1827 Expect.equals(2, message.getExtensionCount( |
| 1828 Unittest.repeatedSint32Extension)); |
| 1829 Expect.equals(2, message.getExtensionCount( |
| 1830 Unittest.repeatedSint64Extension)); |
| 1831 Expect.equals(2, message.getExtensionCount( |
| 1832 Unittest.repeatedFixed32Extension)); |
| 1833 Expect.equals(2, message.getExtensionCount( |
| 1834 Unittest.repeatedFixed64Extension)); |
| 1835 Expect.equals(2, message.getExtensionCount( |
| 1836 Unittest.repeatedSfixed32Extension)); |
| 1837 Expect.equals(2, message.getExtensionCount( |
| 1838 Unittest.repeatedSfixed64Extension)); |
| 1839 Expect.equals(2, message.getExtensionCount( |
| 1840 Unittest.repeatedFloatExtension)); |
| 1841 Expect.equals(2, message.getExtensionCount( |
| 1842 Unittest.repeatedDoubleExtension)); |
| 1843 Expect.equals(2, message.getExtensionCount( |
| 1844 Unittest.repeatedBoolExtension)); |
| 1845 Expect.equals(2, message.getExtensionCount( |
| 1846 Unittest.repeatedStringExtension)); |
| 1847 Expect.equals(2, message.getExtensionCount( |
| 1848 Unittest.repeatedBytesExtension)); |
| 1849 |
| 1850 Expect.equals(2, message.getExtensionCount( |
| 1851 Unittest.repeatedGroupExtension)); |
| 1852 Expect.equals(2, message.getExtensionCount( |
| 1853 Unittest.repeatedNestedMessageExtension)); |
| 1854 Expect.equals(2, message.getExtensionCount( |
| 1855 Unittest.repeatedForeignMessageExtension)); |
| 1856 Expect.equals(2, message.getExtensionCount( |
| 1857 Unittest.repeatedImportMessageExtension)); |
| 1858 Expect.equals(2, message.getExtensionCount( |
| 1859 Unittest.repeatedNestedEnumExtension)); |
| 1860 Expect.equals(2, message.getExtensionCount( |
| 1861 Unittest.repeatedForeignEnumExtension)); |
| 1862 Expect.equals(2, message.getExtensionCount( |
| 1863 Unittest.repeatedImportEnumExtension)); |
| 1864 |
| 1865 Expect.equals(2, message.getExtensionCount( |
| 1866 Unittest.repeatedStringPieceExtension)); |
| 1867 Expect.equals(2, message.getExtensionCount( |
| 1868 Unittest.repeatedCordExtension)); |
| 1869 |
| 1870 Expect.equals(201, message.getExtension( |
| 1871 Unittest.repeatedInt32Extension)[0]); |
| 1872 Expect.equals(202, message.getExtension( |
| 1873 Unittest.repeatedInt64Extension)[0]); |
| 1874 Expect.equals(203, message.getExtension( |
| 1875 Unittest.repeatedUint32Extension)[0]); |
| 1876 Expect.equals(204, message.getExtension( |
| 1877 Unittest.repeatedUint64Extension)[0]); |
| 1878 Expect.equals(205, message.getExtension( |
| 1879 Unittest.repeatedSint32Extension)[0]); |
| 1880 Expect.equals(206, message.getExtension( |
| 1881 Unittest.repeatedSint64Extension)[0]); |
| 1882 Expect.equals(207, message.getExtension( |
| 1883 Unittest.repeatedFixed32Extension)[0]); |
| 1884 Expect.equals(208, message.getExtension( |
| 1885 Unittest.repeatedFixed64Extension)[0]); |
| 1886 Expect.equals(209, message.getExtension( |
| 1887 Unittest.repeatedSfixed32Extension)[0]); |
| 1888 Expect.equals(210, message.getExtension( |
| 1889 Unittest.repeatedSfixed64Extension)[0]); |
| 1890 Expect.equals(211.0, message.getExtension( |
| 1891 Unittest.repeatedFloatExtension)[0]); |
| 1892 Expect.equals(212.0, message.getExtension( |
| 1893 Unittest.repeatedDoubleExtension)[0]); |
| 1894 Expect.equals(true, message.getExtension( |
| 1895 Unittest.repeatedBoolExtension)[0]); |
| 1896 Expect.equals("215", message.getExtension( |
| 1897 Unittest.repeatedStringExtension)[0]); |
| 1898 Expect.listEquals("216".charCodes(), message.getExtension( |
| 1899 Unittest.repeatedBytesExtension)[0]); |
| 1900 |
| 1901 Expect.equals(217, message.getExtension( |
| 1902 Unittest.repeatedGroupExtension)[0].a); |
| 1903 Expect.equals(218, message.getExtension( |
| 1904 Unittest.repeatedNestedMessageExtension)[0].bb); |
| 1905 Expect.equals(219, message.getExtension( |
| 1906 Unittest.repeatedForeignMessageExtension)[0].c); |
| 1907 Expect.equals(220, message.getExtension( |
| 1908 Unittest.repeatedImportMessageExtension)[0].d); |
| 1909 |
| 1910 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR, |
| 1911 message.getExtension( |
| 1912 Unittest.repeatedNestedEnumExtension)[0]); |
| 1913 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR, |
| 1914 message.getExtension( |
| 1915 Unittest.repeatedForeignEnumExtension)[0]); |
| 1916 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR, |
| 1917 message.getExtension( |
| 1918 Unittest.repeatedImportEnumExtension)[0]); |
| 1919 |
| 1920 Expect.equals("224", message.getExtension( |
| 1921 Unittest.repeatedStringPieceExtension)[0]); |
| 1922 Expect.equals("225", message.getExtension( |
| 1923 Unittest.repeatedCordExtension)[0]); |
| 1924 |
| 1925 Expect.equals(501, message.getExtension( |
| 1926 Unittest.repeatedInt32Extension)[1]); |
| 1927 Expect.equals(502, message.getExtension( |
| 1928 Unittest.repeatedInt64Extension)[1]); |
| 1929 Expect.equals(503, message.getExtension( |
| 1930 Unittest.repeatedUint32Extension)[1]); |
| 1931 Expect.equals(504, message.getExtension( |
| 1932 Unittest.repeatedUint64Extension)[1]); |
| 1933 Expect.equals(505, message.getExtension( |
| 1934 Unittest.repeatedSint32Extension)[1]); |
| 1935 Expect.equals(506, message.getExtension( |
| 1936 Unittest.repeatedSint64Extension)[1]); |
| 1937 Expect.equals(507, message.getExtension( |
| 1938 Unittest.repeatedFixed32Extension)[1]); |
| 1939 Expect.equals(508, message.getExtension( |
| 1940 Unittest.repeatedFixed64Extension)[1]); |
| 1941 Expect.equals(509, message.getExtension( |
| 1942 Unittest.repeatedSfixed32Extension)[1]); |
| 1943 Expect.equals(510, message.getExtension( |
| 1944 Unittest.repeatedSfixed64Extension)[1]); |
| 1945 Expect.equals(511.0, message.getExtension( |
| 1946 Unittest.repeatedFloatExtension)[1]); |
| 1947 Expect.equals(512.0, message.getExtension( |
| 1948 Unittest.repeatedDoubleExtension)[1]); |
| 1949 Expect.equals(true, message.getExtension( |
| 1950 Unittest.repeatedBoolExtension)[1]); |
| 1951 Expect.equals("515", message.getExtension( |
| 1952 Unittest.repeatedStringExtension)[1]); |
| 1953 Expect.listEquals("516".charCodes(), message.getExtension( |
| 1954 Unittest.repeatedBytesExtension)[1]); |
| 1955 |
| 1956 Expect.equals(517, message.getExtension( |
| 1957 Unittest.repeatedGroupExtension)[1].a); |
| 1958 Expect.equals(518, message.getExtension( |
| 1959 Unittest.repeatedNestedMessageExtension)[1].bb); |
| 1960 Expect.equals(519, message.getExtension( |
| 1961 Unittest.repeatedForeignMessageExtension)[1].c); |
| 1962 Expect.equals(520, message.getExtension( |
| 1963 Unittest.repeatedImportMessageExtension)[1].d); |
| 1964 |
| 1965 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO, |
| 1966 message.getExtension( |
| 1967 Unittest.repeatedNestedEnumExtension)[1]); |
| 1968 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_FOO, |
| 1969 message.getExtension( |
| 1970 Unittest.repeatedForeignEnumExtension)[1]); |
| 1971 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO, |
| 1972 message.getExtension( |
| 1973 Unittest.repeatedImportEnumExtension)[1]); |
| 1974 |
| 1975 Expect.equals("524", message.getExtension( |
| 1976 Unittest.repeatedStringPieceExtension)[1]); |
| 1977 Expect.equals("525", message.getExtension( |
| 1978 Unittest.repeatedCordExtension)[1]); |
| 1979 |
| 1980 // ----------------------------------------------------------------- |
| 1981 |
| 1982 Expect.isTrue(message.hasExtension( |
| 1983 Unittest.defaultInt32Extension)); |
| 1984 Expect.isTrue(message.hasExtension( |
| 1985 Unittest.defaultInt64Extension)); |
| 1986 Expect.isTrue(message.hasExtension( |
| 1987 Unittest.defaultUint32Extension)); |
| 1988 Expect.isTrue(message.hasExtension( |
| 1989 Unittest.defaultUint64Extension)); |
| 1990 Expect.isTrue(message.hasExtension( |
| 1991 Unittest.defaultSint32Extension)); |
| 1992 Expect.isTrue(message.hasExtension( |
| 1993 Unittest.defaultSint64Extension)); |
| 1994 Expect.isTrue(message.hasExtension( |
| 1995 Unittest.defaultFixed32Extension)); |
| 1996 Expect.isTrue(message.hasExtension( |
| 1997 Unittest.defaultFixed64Extension)); |
| 1998 Expect.isTrue(message.hasExtension( |
| 1999 Unittest.defaultSfixed32Extension)); |
| 2000 Expect.isTrue(message.hasExtension( |
| 2001 Unittest.defaultSfixed64Extension)); |
| 2002 Expect.isTrue(message.hasExtension( |
| 2003 Unittest.defaultFloatExtension)); |
| 2004 Expect.isTrue(message.hasExtension( |
| 2005 Unittest.defaultDoubleExtension)); |
| 2006 Expect.isTrue(message.hasExtension( |
| 2007 Unittest.defaultBoolExtension)); |
| 2008 Expect.isTrue(message.hasExtension( |
| 2009 Unittest.defaultStringExtension)); |
| 2010 Expect.isTrue(message.hasExtension( |
| 2011 Unittest.defaultBytesExtension)); |
| 2012 |
| 2013 Expect.isTrue(message.hasExtension( |
| 2014 Unittest.defaultNestedEnumExtension)); |
| 2015 Expect.isTrue(message.hasExtension( |
| 2016 Unittest.defaultForeignEnumExtension)); |
| 2017 Expect.isTrue(message.hasExtension( |
| 2018 Unittest.defaultImportEnumExtension)); |
| 2019 |
| 2020 Expect.isTrue(message.hasExtension( |
| 2021 Unittest.defaultStringPieceExtension)); |
| 2022 Expect.isTrue(message.hasExtension( |
| 2023 Unittest.defaultCordExtension)); |
| 2024 |
| 2025 Expect.equals(401, message.getExtension( |
| 2026 Unittest.defaultInt32Extension)); |
| 2027 Expect.equals(402, message.getExtension( |
| 2028 Unittest.defaultInt64Extension)); |
| 2029 Expect.equals(403, message.getExtension( |
| 2030 Unittest.defaultUint32Extension)); |
| 2031 Expect.equals(404, message.getExtension( |
| 2032 Unittest.defaultUint64Extension)); |
| 2033 Expect.equals(405, message.getExtension( |
| 2034 Unittest.defaultSint32Extension)); |
| 2035 Expect.equals(406, message.getExtension( |
| 2036 Unittest.defaultSint64Extension)); |
| 2037 Expect.equals(407, message.getExtension( |
| 2038 Unittest.defaultFixed32Extension)); |
| 2039 Expect.equals(408, message.getExtension( |
| 2040 Unittest.defaultFixed64Extension)); |
| 2041 Expect.equals(409, message.getExtension( |
| 2042 Unittest.defaultSfixed32Extension)); |
| 2043 Expect.equals(410, message.getExtension( |
| 2044 Unittest.defaultSfixed64Extension)); |
| 2045 Expect.equals(411.0, message.getExtension( |
| 2046 Unittest.defaultFloatExtension)); |
| 2047 Expect.equals(412.0, message.getExtension( |
| 2048 Unittest.defaultDoubleExtension)); |
| 2049 Expect.equals(false, message.getExtension( |
| 2050 Unittest.defaultBoolExtension)); |
| 2051 Expect.equals("415", message.getExtension( |
| 2052 Unittest.defaultStringExtension)); |
| 2053 Expect.listEquals("416".charCodes(), message.getExtension( |
| 2054 Unittest.defaultBytesExtension)); |
| 2055 |
| 2056 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO, |
| 2057 message.getExtension(Unittest.defaultNestedEnumExtension)); |
| 2058 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_FOO, |
| 2059 message.getExtension(Unittest.defaultForeignEnumExtension)); |
| 2060 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO, |
| 2061 message.getExtension(Unittest.defaultImportEnumExtension)); |
| 2062 |
| 2063 Expect.equals("424", message.getExtension( |
| 2064 Unittest.defaultStringPieceExtension)); |
| 2065 Expect.equals("425", message.getExtension( |
| 2066 Unittest.defaultCordExtension)); |
| 2067 } |
| 2068 |
| 2069 void assertExtensionsClear(Protobuf_Unittest_TestAllExtensions message) { |
| 2070 // hasBlah() should initially be false for all optional fields. |
| 2071 Expect.isFalse(message.hasExtension( |
| 2072 Unittest.optionalInt32Extension )); |
| 2073 Expect.isFalse(message.hasExtension( |
| 2074 Unittest.optionalInt64Extension )); |
| 2075 Expect.isFalse(message.hasExtension( |
| 2076 Unittest.optionalUint32Extension )); |
| 2077 Expect.isFalse(message.hasExtension( |
| 2078 Unittest.optionalUint64Extension )); |
| 2079 Expect.isFalse(message.hasExtension( |
| 2080 Unittest.optionalSint32Extension )); |
| 2081 Expect.isFalse(message.hasExtension( |
| 2082 Unittest.optionalSint64Extension )); |
| 2083 Expect.isFalse(message.hasExtension( |
| 2084 Unittest.optionalFixed32Extension )); |
| 2085 Expect.isFalse(message.hasExtension( |
| 2086 Unittest.optionalFixed64Extension )); |
| 2087 Expect.isFalse(message.hasExtension( |
| 2088 Unittest.optionalSfixed32Extension)); |
| 2089 Expect.isFalse(message.hasExtension( |
| 2090 Unittest.optionalSfixed64Extension)); |
| 2091 Expect.isFalse(message.hasExtension( |
| 2092 Unittest.optionalFloatExtension )); |
| 2093 Expect.isFalse(message.hasExtension( |
| 2094 Unittest.optionalDoubleExtension )); |
| 2095 Expect.isFalse(message.hasExtension( |
| 2096 Unittest.optionalBoolExtension )); |
| 2097 Expect.isFalse(message.hasExtension( |
| 2098 Unittest.optionalStringExtension )); |
| 2099 Expect.isFalse(message.hasExtension( |
| 2100 Unittest.optionalBytesExtension )); |
| 2101 |
| 2102 Expect.isFalse(message.hasExtension( |
| 2103 Unittest.optionalGroupExtension )); |
| 2104 Expect.isFalse(message.hasExtension( |
| 2105 Unittest.optionalNestedMessageExtension )); |
| 2106 Expect.isFalse(message.hasExtension( |
| 2107 Unittest.optionalForeignMessageExtension)); |
| 2108 Expect.isFalse(message.hasExtension( |
| 2109 Unittest.optionalImportMessageExtension )); |
| 2110 |
| 2111 Expect.isFalse(message.hasExtension( |
| 2112 Unittest.optionalNestedEnumExtension )); |
| 2113 Expect.isFalse(message.hasExtension( |
| 2114 Unittest.optionalForeignEnumExtension)); |
| 2115 Expect.isFalse(message.hasExtension( |
| 2116 Unittest.optionalImportEnumExtension )); |
| 2117 |
| 2118 Expect.isFalse(message.hasExtension( |
| 2119 Unittest.optionalStringPieceExtension)); |
| 2120 Expect.isFalse(message.hasExtension( |
| 2121 Unittest.optionalCordExtension)); |
| 2122 |
| 2123 // Optional fields without defaults are set to zero or something like it. |
| 2124 Expect.equals(0, message.getExtension( |
| 2125 Unittest.optionalInt32Extension )); |
| 2126 Expect.equals(0, message.getExtension( |
| 2127 Unittest.optionalInt64Extension )); |
| 2128 Expect.equals(0, message.getExtension( |
| 2129 Unittest.optionalUint32Extension )); |
| 2130 Expect.equals(0, message.getExtension( |
| 2131 Unittest.optionalUint64Extension )); |
| 2132 Expect.equals(0, message.getExtension( |
| 2133 Unittest.optionalSint32Extension )); |
| 2134 Expect.equals(0, message.getExtension( |
| 2135 Unittest.optionalSint64Extension )); |
| 2136 Expect.equals(0, message.getExtension( |
| 2137 Unittest.optionalFixed32Extension )); |
| 2138 Expect.equals(0, message.getExtension( |
| 2139 Unittest.optionalFixed64Extension )); |
| 2140 Expect.equals(0, message.getExtension( |
| 2141 Unittest.optionalSfixed32Extension)); |
| 2142 Expect.equals(0, message.getExtension( |
| 2143 Unittest.optionalSfixed64Extension)); |
| 2144 Expect.equals(0.0, message.getExtension( |
| 2145 Unittest.optionalFloatExtension )); |
| 2146 Expect.equals(0.0, message.getExtension( |
| 2147 Unittest.optionalDoubleExtension )); |
| 2148 Expect.equals(false, message.getExtension( |
| 2149 Unittest.optionalBoolExtension )); |
| 2150 Expect.equals("", message.getExtension( |
| 2151 Unittest.optionalStringExtension )); |
| 2152 Expect.listEquals(<int>[], message.getExtension( |
| 2153 Unittest.optionalBytesExtension)); |
| 2154 |
| 2155 // Embedded messages should also be clear. |
| 2156 Expect.isFalse(message.getExtension( |
| 2157 Unittest.optionalGroupExtension).hasA()); |
| 2158 Expect.isFalse(message.getExtension( |
| 2159 Unittest.optionalNestedMessageExtension).hasBb()); |
| 2160 Expect.isFalse(message.getExtension( |
| 2161 Unittest.optionalForeignMessageExtension).hasC()); |
| 2162 Expect.isFalse(message.getExtension( |
| 2163 Unittest.optionalImportMessageExtension).hasD()); |
| 2164 |
| 2165 Expect.equals(0, message.getExtension( |
| 2166 Unittest.optionalGroupExtension).a); |
| 2167 Expect.equals(0, message.getExtension( |
| 2168 Unittest.optionalNestedMessageExtension).bb); |
| 2169 Expect.equals(0, message.getExtension( |
| 2170 Unittest.optionalForeignMessageExtension).c); |
| 2171 Expect.equals(0, message.getExtension( |
| 2172 Unittest.optionalImportMessageExtension).d); |
| 2173 |
| 2174 // Enums without defaults are set to the first value in the enum. |
| 2175 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.FOO, |
| 2176 message.getExtension( |
| 2177 Unittest.optionalNestedEnumExtension)); |
| 2178 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_FOO, |
| 2179 message.getExtension( |
| 2180 Unittest.optionalForeignEnumExtension)); |
| 2181 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO, |
| 2182 message.getExtension( |
| 2183 Unittest.optionalImportEnumExtension)); |
| 2184 |
| 2185 Expect.equals("", message.getExtension( |
| 2186 Unittest.optionalStringPieceExtension)); |
| 2187 Expect.equals("", |
| 2188 message.getExtension(Unittest.optionalCordExtension)); |
| 2189 |
| 2190 // Repeated fields are empty. |
| 2191 Expect.equals(0, message.getExtensionCount( |
| 2192 Unittest.repeatedInt32Extension)); |
| 2193 Expect.equals(0, message.getExtensionCount( |
| 2194 Unittest.repeatedInt64Extension)); |
| 2195 Expect.equals(0, message.getExtensionCount( |
| 2196 Unittest.repeatedUint32Extension)); |
| 2197 Expect.equals(0, message.getExtensionCount( |
| 2198 Unittest.repeatedUint64Extension)); |
| 2199 Expect.equals(0, message.getExtensionCount( |
| 2200 Unittest.repeatedSint32Extension)); |
| 2201 Expect.equals(0, message.getExtensionCount( |
| 2202 Unittest.repeatedSint64Extension)); |
| 2203 Expect.equals(0, message.getExtensionCount( |
| 2204 Unittest.repeatedFixed32Extension)); |
| 2205 Expect.equals(0, message.getExtensionCount( |
| 2206 Unittest.repeatedFixed64Extension)); |
| 2207 Expect.equals(0, message.getExtensionCount( |
| 2208 Unittest.repeatedSfixed32Extension)); |
| 2209 Expect.equals(0, message.getExtensionCount( |
| 2210 Unittest.repeatedSfixed64Extension)); |
| 2211 Expect.equals(0, message.getExtensionCount( |
| 2212 Unittest.repeatedFloatExtension)); |
| 2213 Expect.equals(0, message.getExtensionCount( |
| 2214 Unittest.repeatedDoubleExtension)); |
| 2215 Expect.equals(0, message.getExtensionCount( |
| 2216 Unittest.repeatedBoolExtension)); |
| 2217 Expect.equals(0, message.getExtensionCount( |
| 2218 Unittest.repeatedStringExtension)); |
| 2219 Expect.equals(0, message.getExtensionCount( |
| 2220 Unittest.repeatedBytesExtension)); |
| 2221 |
| 2222 Expect.equals(0, message.getExtensionCount( |
| 2223 Unittest.repeatedGroupExtension)); |
| 2224 Expect.equals(0, message.getExtensionCount( |
| 2225 Unittest.repeatedNestedMessageExtension)); |
| 2226 Expect.equals(0, message.getExtensionCount( |
| 2227 Unittest.repeatedForeignMessageExtension)); |
| 2228 Expect.equals(0, message.getExtensionCount( |
| 2229 Unittest.repeatedImportMessageExtension)); |
| 2230 Expect.equals(0, message.getExtensionCount( |
| 2231 Unittest.repeatedNestedEnumExtension)); |
| 2232 Expect.equals(0, message.getExtensionCount( |
| 2233 Unittest.repeatedForeignEnumExtension)); |
| 2234 Expect.equals(0, message.getExtensionCount( |
| 2235 Unittest.repeatedImportEnumExtension)); |
| 2236 |
| 2237 Expect.equals(0, message.getExtensionCount( |
| 2238 Unittest.repeatedStringPieceExtension)); |
| 2239 Expect.equals(0, message.getExtensionCount( |
| 2240 Unittest.repeatedCordExtension)); |
| 2241 |
| 2242 // Repeated fields are empty via getExtension().length. |
| 2243 Expect.equals(0, message.getExtension( |
| 2244 Unittest.repeatedInt32Extension).length); |
| 2245 Expect.equals(0, message.getExtension( |
| 2246 Unittest.repeatedInt64Extension).length); |
| 2247 Expect.equals(0, message.getExtension( |
| 2248 Unittest.repeatedUint32Extension).length); |
| 2249 Expect.equals(0, message.getExtension( |
| 2250 Unittest.repeatedUint64Extension).length); |
| 2251 Expect.equals(0, message.getExtension( |
| 2252 Unittest.repeatedSint32Extension).length); |
| 2253 Expect.equals(0, message.getExtension( |
| 2254 Unittest.repeatedSint64Extension).length); |
| 2255 Expect.equals(0, message.getExtension( |
| 2256 Unittest.repeatedFixed32Extension).length); |
| 2257 Expect.equals(0, message.getExtension( |
| 2258 Unittest.repeatedFixed64Extension).length); |
| 2259 Expect.equals(0, message.getExtension( |
| 2260 Unittest.repeatedSfixed32Extension).length); |
| 2261 Expect.equals(0, message.getExtension( |
| 2262 Unittest.repeatedSfixed64Extension).length); |
| 2263 Expect.equals(0, message.getExtension( |
| 2264 Unittest.repeatedFloatExtension).length); |
| 2265 Expect.equals(0, message.getExtension( |
| 2266 Unittest.repeatedDoubleExtension).length); |
| 2267 Expect.equals(0, message.getExtension( |
| 2268 Unittest.repeatedBoolExtension).length); |
| 2269 Expect.equals(0, message.getExtension( |
| 2270 Unittest.repeatedStringExtension).length); |
| 2271 Expect.equals(0, message.getExtension( |
| 2272 Unittest.repeatedBytesExtension).length); |
| 2273 |
| 2274 Expect.equals(0, message.getExtension( |
| 2275 Unittest.repeatedGroupExtension).length); |
| 2276 Expect.equals(0, message.getExtension( |
| 2277 Unittest.repeatedNestedMessageExtension).length); |
| 2278 Expect.equals(0, message.getExtension( |
| 2279 Unittest.repeatedForeignMessageExtension).length); |
| 2280 Expect.equals(0, message.getExtension( |
| 2281 Unittest.repeatedImportMessageExtension).length); |
| 2282 Expect.equals(0, message.getExtension( |
| 2283 Unittest.repeatedNestedEnumExtension).length); |
| 2284 Expect.equals(0, message.getExtension( |
| 2285 Unittest.repeatedForeignEnumExtension).length); |
| 2286 Expect.equals(0, message.getExtension( |
| 2287 Unittest.repeatedImportEnumExtension).length); |
| 2288 |
| 2289 Expect.equals(0, message.getExtension( |
| 2290 Unittest.repeatedStringPieceExtension).length); |
| 2291 Expect.equals(0, message.getExtension( |
| 2292 Unittest.repeatedCordExtension).length); |
| 2293 |
| 2294 // hasBlah() should also be false for all default fields. |
| 2295 Expect.isFalse(message.hasExtension( |
| 2296 Unittest.defaultInt32Extension)); |
| 2297 Expect.isFalse(message.hasExtension( |
| 2298 Unittest.defaultInt64Extension)); |
| 2299 Expect.isFalse(message.hasExtension( |
| 2300 Unittest.defaultUint32Extension)); |
| 2301 Expect.isFalse(message.hasExtension( |
| 2302 Unittest.defaultUint64Extension)); |
| 2303 Expect.isFalse(message.hasExtension( |
| 2304 Unittest.defaultSint32Extension)); |
| 2305 Expect.isFalse(message.hasExtension( |
| 2306 Unittest.defaultSint64Extension)); |
| 2307 Expect.isFalse(message.hasExtension( |
| 2308 Unittest.defaultFixed32Extension)); |
| 2309 Expect.isFalse(message.hasExtension( |
| 2310 Unittest.defaultFixed64Extension)); |
| 2311 Expect.isFalse(message.hasExtension( |
| 2312 Unittest.defaultSfixed32Extension)); |
| 2313 Expect.isFalse(message.hasExtension( |
| 2314 Unittest.defaultSfixed64Extension)); |
| 2315 Expect.isFalse(message.hasExtension( |
| 2316 Unittest.defaultFloatExtension)); |
| 2317 Expect.isFalse(message.hasExtension( |
| 2318 Unittest.defaultDoubleExtension)); |
| 2319 Expect.isFalse(message.hasExtension( |
| 2320 Unittest.defaultBoolExtension)); |
| 2321 Expect.isFalse(message.hasExtension( |
| 2322 Unittest.defaultStringExtension)); |
| 2323 Expect.isFalse(message.hasExtension( |
| 2324 Unittest.defaultBytesExtension)); |
| 2325 |
| 2326 Expect.isFalse(message.hasExtension( |
| 2327 Unittest.defaultNestedEnumExtension )); |
| 2328 Expect.isFalse(message.hasExtension( |
| 2329 Unittest.defaultForeignEnumExtension)); |
| 2330 Expect.isFalse(message.hasExtension( |
| 2331 Unittest.defaultImportEnumExtension )); |
| 2332 |
| 2333 Expect.isFalse(message.hasExtension( |
| 2334 Unittest.defaultStringPieceExtension)); |
| 2335 Expect.isFalse(message.hasExtension( |
| 2336 Unittest.defaultCordExtension)); |
| 2337 |
| 2338 // Fields with defaults have their default values (duh). |
| 2339 Expect.equals(41, message.getExtension( |
| 2340 Unittest.defaultInt32Extension)); |
| 2341 Expect.equals(42, message.getExtension( |
| 2342 Unittest.defaultInt64Extension)); |
| 2343 Expect.equals(43, message.getExtension( |
| 2344 Unittest.defaultUint32Extension)); |
| 2345 Expect.equals(44, message.getExtension( |
| 2346 Unittest.defaultUint64Extension)); |
| 2347 Expect.equals(-45, message.getExtension( |
| 2348 Unittest.defaultSint32Extension)); |
| 2349 Expect.equals(46, message.getExtension( |
| 2350 Unittest.defaultSint64Extension)); |
| 2351 Expect.equals(47, message.getExtension( |
| 2352 Unittest.defaultFixed32Extension)); |
| 2353 Expect.equals(48, message.getExtension( |
| 2354 Unittest.defaultFixed64Extension)); |
| 2355 Expect.equals(49, message.getExtension( |
| 2356 Unittest.defaultSfixed32Extension)); |
| 2357 Expect.equals(-50, message.getExtension( |
| 2358 Unittest.defaultSfixed64Extension)); |
| 2359 Expect.equals(51.5, message.getExtension( |
| 2360 Unittest.defaultFloatExtension)); |
| 2361 Expect.equals(52e3, message.getExtension( |
| 2362 Unittest.defaultDoubleExtension)); |
| 2363 Expect.equals(true, message.getExtension( |
| 2364 Unittest.defaultBoolExtension)); |
| 2365 Expect.equals("hello", message.getExtension( |
| 2366 Unittest.defaultStringExtension)); |
| 2367 Expect.listEquals("world".charCodes(), message.getExtension( |
| 2368 Unittest.defaultBytesExtension)); |
| 2369 |
| 2370 Expect.equals(Protobuf_Unittest_TestAllTypes_NestedEnum.BAR, |
| 2371 message.getExtension(Unittest.defaultNestedEnumExtension)); |
| 2372 Expect.equals(Protobuf_Unittest_ForeignEnum.FOREIGN_BAR, |
| 2373 message.getExtension(Unittest.defaultForeignEnumExtension)); |
| 2374 Expect.equals(Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR, |
| 2375 message.getExtension(Unittest.defaultImportEnumExtension)); |
| 2376 |
| 2377 Expect.equals("abc", message.getExtension( |
| 2378 Unittest.defaultStringPieceExtension)); |
| 2379 Expect.equals("123", message.getExtension( |
| 2380 Unittest.defaultCordExtension)); |
| 2381 } |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10595002:
Protocol Buffer runtime library and 'protoc' plugin (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart