| OLD | NEW |
|---|
| (Empty) |
| 1 // Protocol Buffers - Google's data interchange format | |
| 2 // Copyright 2015 Google Inc. All rights reserved. | |
| 3 // https://developers.google.com/protocol-buffers/ | |
| 4 // | |
| 5 // Redistribution and use in source and binary forms, with or without | |
| 6 // modification, are permitted provided that the following conditions are | |
| 7 // met: | |
| 8 // | |
| 9 // * Redistributions of source code must retain the above copyright | |
| 10 // notice, this list of conditions and the following disclaimer. | |
| 11 // * Redistributions in binary form must reproduce the above | |
| 12 // copyright notice, this list of conditions and the following disclaimer | |
| 13 // in the documentation and/or other materials provided with the | |
| 14 // distribution. | |
| 15 // * Neither the name of Google Inc. nor the names of its | |
| 16 // contributors may be used to endorse or promote products derived from | |
| 17 // this software without specific prior written permission. | |
| 18 // | |
| 19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 30 | |
| 31 #import "GPBTestUtilities.h" | |
| 32 | |
| 33 #import <objc/runtime.h> | |
| 34 | |
| 35 #import "GPBMessage.h" | |
| 36 | |
| 37 #import "google/protobuf/MapProto2Unittest.pbobjc.h" | |
| 38 #import "google/protobuf/MapUnittest.pbobjc.h" | |
| 39 #import "google/protobuf/Unittest.pbobjc.h" | |
| 40 #import "google/protobuf/UnittestDropUnknownFields.pbobjc.h" | |
| 41 #import "google/protobuf/UnittestPreserveUnknownEnum.pbobjc.h" | |
| 42 #import "google/protobuf/UnittestRuntimeProto2.pbobjc.h" | |
| 43 #import "google/protobuf/UnittestRuntimeProto3.pbobjc.h" | |
| 44 | |
| 45 static NSData *DataFromCStr(const char *str) { | |
| 46 return [NSData dataWithBytes:str length:strlen(str)]; | |
| 47 } | |
| 48 | |
| 49 @interface MessageSerializationTests : GPBTestCase | |
| 50 @end | |
| 51 | |
| 52 @implementation MessageSerializationTests | |
| 53 | |
| 54 // TODO(thomasvl): Pull tests over from GPBMessageTests that are serialization | |
| 55 // specific. | |
| 56 | |
| 57 - (void)testProto3SerializationHandlingDefaults { | |
| 58 // Proto2 covered in other tests. | |
| 59 | |
| 60 Message3 *msg = [[Message3 alloc] init]; | |
| 61 | |
| 62 // Add defaults, no output. | |
| 63 | |
| 64 NSData *data = [msg data]; | |
| 65 XCTAssertEqual([data length], 0U); | |
| 66 | |
| 67 // All zeros, still nothing. | |
| 68 | |
| 69 msg.optionalInt32 = 0; | |
| 70 msg.optionalInt64 = 0; | |
| 71 msg.optionalUint32 = 0; | |
| 72 msg.optionalUint64 = 0; | |
| 73 msg.optionalSint32 = 0; | |
| 74 msg.optionalSint64 = 0; | |
| 75 msg.optionalFixed32 = 0; | |
| 76 msg.optionalFixed64 = 0; | |
| 77 msg.optionalSfixed32 = 0; | |
| 78 msg.optionalSfixed64 = 0; | |
| 79 msg.optionalFloat = 0.0f; | |
| 80 msg.optionalDouble = 0.0; | |
| 81 msg.optionalBool = NO; | |
| 82 msg.optionalString = @""; | |
| 83 msg.optionalBytes = [NSData data]; | |
| 84 msg.optionalEnum = Message3_Enum_Foo; // first value | |
| 85 | |
| 86 data = [msg data]; | |
| 87 XCTAssertEqual([data length], 0U); | |
| 88 | |
| 89 // The two that also take nil as nothing. | |
| 90 | |
| 91 msg.optionalString = nil; | |
| 92 msg.optionalBytes = nil; | |
| 93 | |
| 94 data = [msg data]; | |
| 95 XCTAssertEqual([data length], 0U); | |
| 96 | |
| 97 // Set one field... | |
| 98 | |
| 99 msg.optionalInt32 = 1; | |
| 100 | |
| 101 data = [msg data]; | |
| 102 const uint8_t expectedBytes[] = {0x08, 0x01}; | |
| 103 NSData *expected = [NSData dataWithBytes:expectedBytes length:2]; | |
| 104 XCTAssertEqualObjects(data, expected); | |
| 105 | |
| 106 // Back to zero... | |
| 107 | |
| 108 msg.optionalInt32 = 0; | |
| 109 | |
| 110 data = [msg data]; | |
| 111 XCTAssertEqual([data length], 0U); | |
| 112 | |
| 113 [msg release]; | |
| 114 } | |
| 115 | |
| 116 - (void)testProto3DroppingUnknownFields { | |
| 117 DropUnknownsFooWithExtraFields *fooWithExtras = | |
| 118 [[DropUnknownsFooWithExtraFields alloc] init]; | |
| 119 | |
| 120 fooWithExtras.int32Value = 1; | |
| 121 fooWithExtras.enumValue = DropUnknownsFooWithExtraFields_NestedEnum_Baz; | |
| 122 fooWithExtras.extraInt32Value = 2; | |
| 123 | |
| 124 DropUnknownsFoo *foo = | |
| 125 [DropUnknownsFoo parseFromData:[fooWithExtras data] error:NULL]; | |
| 126 | |
| 127 XCTAssertEqual(foo.int32Value, 1); | |
| 128 XCTAssertEqual(foo.enumValue, DropUnknownsFoo_NestedEnum_Baz); | |
| 129 // Nothing should end up in the unknowns. | |
| 130 XCTAssertEqual([foo.unknownFields countOfFields], 0U); | |
| 131 | |
| 132 [fooWithExtras release]; | |
| 133 fooWithExtras = | |
| 134 [DropUnknownsFooWithExtraFields parseFromData:[foo data] error:NULL]; | |
| 135 XCTAssertEqual(fooWithExtras.int32Value, 1); | |
| 136 XCTAssertEqual(fooWithExtras.enumValue, | |
| 137 DropUnknownsFooWithExtraFields_NestedEnum_Baz); | |
| 138 // And the extra value is gone (back to the default). | |
| 139 XCTAssertEqual(fooWithExtras.extraInt32Value, 0); | |
| 140 XCTAssertEqual([foo.unknownFields countOfFields], 0U); | |
| 141 } | |
| 142 | |
| 143 - (void)testProto2UnknownEnumToUnknownField { | |
| 144 Message3 *orig = [[Message3 alloc] init]; | |
| 145 | |
| 146 orig.optionalEnum = Message3_Enum_Extra3; | |
| 147 orig.repeatedEnumArray = | |
| 148 [GPBEnumArray arrayWithValidationFunction:Message3_Enum_IsValidValue | |
| 149 rawValue:Message3_Enum_Extra3]; | |
| 150 orig.oneofEnum = Message3_Enum_Extra3; | |
| 151 | |
| 152 Message2 *msg = [[Message2 alloc] initWithData:[orig data] error:NULL]; | |
| 153 | |
| 154 // None of the fields should be set. | |
| 155 | |
| 156 XCTAssertFalse(msg.hasOptionalEnum); | |
| 157 XCTAssertEqual(msg.repeatedEnumArray.count, 0U); | |
| 158 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase); | |
| 159 | |
| 160 // All the values should be in unknown fields. | |
| 161 | |
| 162 GPBUnknownFieldSet *unknownFields = msg.unknownFields; | |
| 163 | |
| 164 XCTAssertEqual([unknownFields countOfFields], 3U); | |
| 165 XCTAssertTrue([unknownFields hasField:Message2_FieldNumber_OptionalEnum]); | |
| 166 XCTAssertTrue( | |
| 167 [unknownFields hasField:Message2_FieldNumber_RepeatedEnumArray]); | |
| 168 XCTAssertTrue([unknownFields hasField:Message2_FieldNumber_OneofEnum]); | |
| 169 | |
| 170 GPBUnknownField *field = | |
| 171 [unknownFields getField:Message2_FieldNumber_OptionalEnum]; | |
| 172 XCTAssertEqual(field.varintList.count, 1U); | |
| 173 XCTAssertEqual([field.varintList valueAtIndex:0], | |
| 174 (uint64_t)Message3_Enum_Extra3); | |
| 175 | |
| 176 field = [unknownFields getField:Message2_FieldNumber_RepeatedEnumArray]; | |
| 177 XCTAssertEqual(field.varintList.count, 1U); | |
| 178 XCTAssertEqual([field.varintList valueAtIndex:0], (uint64_t)Message3_Enum_Extr
a3); | |
| 179 | |
| 180 field = [unknownFields getField:Message2_FieldNumber_OneofEnum]; | |
| 181 XCTAssertEqual(field.varintList.count, 1U); | |
| 182 XCTAssertEqual([field.varintList valueAtIndex:0], | |
| 183 (uint64_t)Message3_Enum_Extra3); | |
| 184 | |
| 185 [msg release]; | |
| 186 [orig release]; | |
| 187 } | |
| 188 | |
| 189 - (void)testProto3UnknownEnumPreserving { | |
| 190 UnknownEnumsMyMessagePlusExtra *orig = | |
| 191 [UnknownEnumsMyMessagePlusExtra message]; | |
| 192 | |
| 193 orig.e = UnknownEnumsMyEnumPlusExtra_EExtra; | |
| 194 orig.repeatedEArray = [GPBEnumArray | |
| 195 arrayWithValidationFunction:UnknownEnumsMyEnumPlusExtra_IsValidValue | |
| 196 rawValue:UnknownEnumsMyEnumPlusExtra_EExtra]; | |
| 197 orig.repeatedPackedEArray = [GPBEnumArray | |
| 198 arrayWithValidationFunction:UnknownEnumsMyEnumPlusExtra_IsValidValue | |
| 199 rawValue:UnknownEnumsMyEnumPlusExtra_EExtra]; | |
| 200 orig.oneofE1 = UnknownEnumsMyEnumPlusExtra_EExtra; | |
| 201 | |
| 202 // Everything should be there via raw values. | |
| 203 | |
| 204 UnknownEnumsMyMessage *msg = | |
| 205 [UnknownEnumsMyMessage parseFromData:[orig data] error:NULL]; | |
| 206 | |
| 207 XCTAssertEqual(msg.e, UnknownEnumsMyEnum_GPBUnrecognizedEnumeratorValue); | |
| 208 XCTAssertEqual(UnknownEnumsMyMessage_E_RawValue(msg), | |
| 209 UnknownEnumsMyEnumPlusExtra_EExtra); | |
| 210 XCTAssertEqual(msg.repeatedEArray.count, 1U); | |
| 211 XCTAssertEqual([msg.repeatedEArray valueAtIndex:0], | |
| 212 UnknownEnumsMyEnum_GPBUnrecognizedEnumeratorValue); | |
| 213 XCTAssertEqual([msg.repeatedEArray rawValueAtIndex:0], | |
| 214 (UnknownEnumsMyEnum)UnknownEnumsMyEnumPlusExtra_EExtra); | |
| 215 XCTAssertEqual(msg.repeatedPackedEArray.count, 1U); | |
| 216 XCTAssertEqual([msg.repeatedPackedEArray valueAtIndex:0], | |
| 217 UnknownEnumsMyEnum_GPBUnrecognizedEnumeratorValue); | |
| 218 XCTAssertEqual([msg.repeatedPackedEArray rawValueAtIndex:0], | |
| 219 (UnknownEnumsMyEnum)UnknownEnumsMyEnumPlusExtra_EExtra); | |
| 220 XCTAssertEqual(msg.oneofE1, | |
| 221 UnknownEnumsMyEnum_GPBUnrecognizedEnumeratorValue); | |
| 222 XCTAssertEqual(UnknownEnumsMyMessage_OneofE1_RawValue(msg), | |
| 223 UnknownEnumsMyEnumPlusExtra_EExtra); | |
| 224 | |
| 225 // Everything should go out and come back. | |
| 226 | |
| 227 orig = [UnknownEnumsMyMessagePlusExtra parseFromData:[msg data] error:NULL]; | |
| 228 | |
| 229 XCTAssertEqual(orig.e, UnknownEnumsMyEnumPlusExtra_EExtra); | |
| 230 XCTAssertEqual(orig.repeatedEArray.count, 1U); | |
| 231 XCTAssertEqual([orig.repeatedEArray valueAtIndex:0], | |
| 232 UnknownEnumsMyEnumPlusExtra_EExtra); | |
| 233 XCTAssertEqual(orig.repeatedPackedEArray.count, 1U); | |
| 234 XCTAssertEqual([orig.repeatedPackedEArray valueAtIndex:0], | |
| 235 UnknownEnumsMyEnumPlusExtra_EExtra); | |
| 236 XCTAssertEqual(orig.oneofE1, UnknownEnumsMyEnumPlusExtra_EExtra); | |
| 237 } | |
| 238 | |
| 239 //%PDDM-DEFINE TEST_ROUNDTRIP_ONEOF(MESSAGE, FIELD, VALUE) | |
| 240 //%TEST_ROUNDTRIP_ONEOF_ADV(MESSAGE, FIELD, VALUE, ) | |
| 241 //%PDDM-DEFINE TEST_ROUNDTRIP_ONEOF_ADV(MESSAGE, FIELD, VALUE, EQ_SUFFIX) | |
| 242 //% { // oneof##FIELD | |
| 243 //% MESSAGE *orig = [[MESSAGE alloc] init]; | |
| 244 //% orig.oneof##FIELD = VALUE; | |
| 245 //% XCTAssertEqual(orig.oOneOfCase, MESSAGE##_O_OneOfCase_Oneof##FIELD); | |
| 246 //% MESSAGE *msg = [MESSAGE parseFromData:[orig data] error:NULL]; | |
| 247 //% XCTAssertEqual(msg.oOneOfCase, MESSAGE##_O_OneOfCase_Oneof##FIELD); | |
| 248 //% XCTAssertEqual##EQ_SUFFIX(msg.oneof##FIELD, VALUE); | |
| 249 //% [orig release]; | |
| 250 //% } | |
| 251 //% | |
| 252 //%PDDM-DEFINE TEST_ROUNDTRIP_ONEOFS(SYNTAX, BOOL_NON_DEFAULT) | |
| 253 //%- (void)testProto##SYNTAX##RoundTripOneof { | |
| 254 //% | |
| 255 //%GROUP_INIT##SYNTAX() Message##SYNTAX *subMessage = [[Message##SYNTAX alloc]
init]; | |
| 256 //% XCTAssertNotNil(subMessage); | |
| 257 //% subMessage.optionalInt32 = 666; | |
| 258 //% | |
| 259 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Int32, 1) | |
| 260 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Int64, 2) | |
| 261 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Uint32, 3U) | |
| 262 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Uint64, 4U) | |
| 263 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Sint32, 5) | |
| 264 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Sint64, 6) | |
| 265 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Fixed32, 7U) | |
| 266 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Fixed64, 8U) | |
| 267 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Sfixed32, 9) | |
| 268 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Sfixed64, 10) | |
| 269 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Float, 11.0f) | |
| 270 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Double, 12.0) | |
| 271 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Bool, BOOL_NON_DEFAULT) | |
| 272 //%TEST_ROUNDTRIP_ONEOF_ADV(Message##SYNTAX, String, @"foo", Objects) | |
| 273 //%TEST_ROUNDTRIP_ONEOF_ADV(Message##SYNTAX, Bytes, [@"bar" dataUsingEncoding:NS
UTF8StringEncoding], Objects) | |
| 274 //%GROUP_TEST##SYNTAX()TEST_ROUNDTRIP_ONEOF_ADV(Message##SYNTAX, Message, subMes
sage, Objects) | |
| 275 //%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Enum, Message2_Enum_Bar) | |
| 276 //%GROUP_CLEANUP##SYNTAX() [subMessage release]; | |
| 277 //%} | |
| 278 //% | |
| 279 //%PDDM-DEFINE GROUP_INIT2() | |
| 280 //% Message2_OneofGroup *group = [[Message2_OneofGroup alloc] init]; | |
| 281 //% XCTAssertNotNil(group); | |
| 282 //% group.a = 777; | |
| 283 //% | |
| 284 //%PDDM-DEFINE GROUP_CLEANUP2() | |
| 285 //% [group release]; | |
| 286 //% | |
| 287 //%PDDM-DEFINE GROUP_TEST2() | |
| 288 //%TEST_ROUNDTRIP_ONEOF_ADV(Message2, Group, group, Objects) | |
| 289 //% | |
| 290 //%PDDM-DEFINE GROUP_INIT3() | |
| 291 // Empty | |
| 292 //%PDDM-DEFINE GROUP_CLEANUP3() | |
| 293 // Empty | |
| 294 //%PDDM-DEFINE GROUP_TEST3() | |
| 295 //% // Not "group" in proto3. | |
| 296 //% | |
| 297 //% | |
| 298 //%PDDM-EXPAND TEST_ROUNDTRIP_ONEOFS(2, NO) | |
| 299 // This block of code is generated, do not edit it directly. | |
| 300 | |
| 301 - (void)testProto2RoundTripOneof { | |
| 302 | |
| 303 Message2_OneofGroup *group = [[Message2_OneofGroup alloc] init]; | |
| 304 XCTAssertNotNil(group); | |
| 305 group.a = 777; | |
| 306 Message2 *subMessage = [[Message2 alloc] init]; | |
| 307 XCTAssertNotNil(subMessage); | |
| 308 subMessage.optionalInt32 = 666; | |
| 309 | |
| 310 { // oneofInt32 | |
| 311 Message2 *orig = [[Message2 alloc] init]; | |
| 312 orig.oneofInt32 = 1; | |
| 313 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofInt32); | |
| 314 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 315 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt32); | |
| 316 XCTAssertEqual(msg.oneofInt32, 1); | |
| 317 [orig release]; | |
| 318 } | |
| 319 | |
| 320 { // oneofInt64 | |
| 321 Message2 *orig = [[Message2 alloc] init]; | |
| 322 orig.oneofInt64 = 2; | |
| 323 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofInt64); | |
| 324 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 325 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt64); | |
| 326 XCTAssertEqual(msg.oneofInt64, 2); | |
| 327 [orig release]; | |
| 328 } | |
| 329 | |
| 330 { // oneofUint32 | |
| 331 Message2 *orig = [[Message2 alloc] init]; | |
| 332 orig.oneofUint32 = 3U; | |
| 333 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofUint32); | |
| 334 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 335 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint32); | |
| 336 XCTAssertEqual(msg.oneofUint32, 3U); | |
| 337 [orig release]; | |
| 338 } | |
| 339 | |
| 340 { // oneofUint64 | |
| 341 Message2 *orig = [[Message2 alloc] init]; | |
| 342 orig.oneofUint64 = 4U; | |
| 343 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofUint64); | |
| 344 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 345 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint64); | |
| 346 XCTAssertEqual(msg.oneofUint64, 4U); | |
| 347 [orig release]; | |
| 348 } | |
| 349 | |
| 350 { // oneofSint32 | |
| 351 Message2 *orig = [[Message2 alloc] init]; | |
| 352 orig.oneofSint32 = 5; | |
| 353 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofSint32); | |
| 354 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 355 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint32); | |
| 356 XCTAssertEqual(msg.oneofSint32, 5); | |
| 357 [orig release]; | |
| 358 } | |
| 359 | |
| 360 { // oneofSint64 | |
| 361 Message2 *orig = [[Message2 alloc] init]; | |
| 362 orig.oneofSint64 = 6; | |
| 363 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofSint64); | |
| 364 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 365 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint64); | |
| 366 XCTAssertEqual(msg.oneofSint64, 6); | |
| 367 [orig release]; | |
| 368 } | |
| 369 | |
| 370 { // oneofFixed32 | |
| 371 Message2 *orig = [[Message2 alloc] init]; | |
| 372 orig.oneofFixed32 = 7U; | |
| 373 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofFixed32); | |
| 374 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 375 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed32); | |
| 376 XCTAssertEqual(msg.oneofFixed32, 7U); | |
| 377 [orig release]; | |
| 378 } | |
| 379 | |
| 380 { // oneofFixed64 | |
| 381 Message2 *orig = [[Message2 alloc] init]; | |
| 382 orig.oneofFixed64 = 8U; | |
| 383 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofFixed64); | |
| 384 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 385 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed64); | |
| 386 XCTAssertEqual(msg.oneofFixed64, 8U); | |
| 387 [orig release]; | |
| 388 } | |
| 389 | |
| 390 { // oneofSfixed32 | |
| 391 Message2 *orig = [[Message2 alloc] init]; | |
| 392 orig.oneofSfixed32 = 9; | |
| 393 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32); | |
| 394 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 395 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32); | |
| 396 XCTAssertEqual(msg.oneofSfixed32, 9); | |
| 397 [orig release]; | |
| 398 } | |
| 399 | |
| 400 { // oneofSfixed64 | |
| 401 Message2 *orig = [[Message2 alloc] init]; | |
| 402 orig.oneofSfixed64 = 10; | |
| 403 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64); | |
| 404 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 405 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64); | |
| 406 XCTAssertEqual(msg.oneofSfixed64, 10); | |
| 407 [orig release]; | |
| 408 } | |
| 409 | |
| 410 { // oneofFloat | |
| 411 Message2 *orig = [[Message2 alloc] init]; | |
| 412 orig.oneofFloat = 11.0f; | |
| 413 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofFloat); | |
| 414 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 415 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFloat); | |
| 416 XCTAssertEqual(msg.oneofFloat, 11.0f); | |
| 417 [orig release]; | |
| 418 } | |
| 419 | |
| 420 { // oneofDouble | |
| 421 Message2 *orig = [[Message2 alloc] init]; | |
| 422 orig.oneofDouble = 12.0; | |
| 423 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofDouble); | |
| 424 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 425 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofDouble); | |
| 426 XCTAssertEqual(msg.oneofDouble, 12.0); | |
| 427 [orig release]; | |
| 428 } | |
| 429 | |
| 430 { // oneofBool | |
| 431 Message2 *orig = [[Message2 alloc] init]; | |
| 432 orig.oneofBool = NO; | |
| 433 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofBool); | |
| 434 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 435 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBool); | |
| 436 XCTAssertEqual(msg.oneofBool, NO); | |
| 437 [orig release]; | |
| 438 } | |
| 439 | |
| 440 { // oneofString | |
| 441 Message2 *orig = [[Message2 alloc] init]; | |
| 442 orig.oneofString = @"foo"; | |
| 443 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofString); | |
| 444 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 445 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofString); | |
| 446 XCTAssertEqualObjects(msg.oneofString, @"foo"); | |
| 447 [orig release]; | |
| 448 } | |
| 449 | |
| 450 { // oneofBytes | |
| 451 Message2 *orig = [[Message2 alloc] init]; | |
| 452 orig.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding]; | |
| 453 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofBytes); | |
| 454 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 455 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBytes); | |
| 456 XCTAssertEqualObjects(msg.oneofBytes, [@"bar" dataUsingEncoding:NSUTF8String
Encoding]); | |
| 457 [orig release]; | |
| 458 } | |
| 459 | |
| 460 { // oneofGroup | |
| 461 Message2 *orig = [[Message2 alloc] init]; | |
| 462 orig.oneofGroup = group; | |
| 463 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofGroup); | |
| 464 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 465 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofGroup); | |
| 466 XCTAssertEqualObjects(msg.oneofGroup, group); | |
| 467 [orig release]; | |
| 468 } | |
| 469 | |
| 470 { // oneofMessage | |
| 471 Message2 *orig = [[Message2 alloc] init]; | |
| 472 orig.oneofMessage = subMessage; | |
| 473 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofMessage); | |
| 474 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 475 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofMessage); | |
| 476 XCTAssertEqualObjects(msg.oneofMessage, subMessage); | |
| 477 [orig release]; | |
| 478 } | |
| 479 | |
| 480 { // oneofEnum | |
| 481 Message2 *orig = [[Message2 alloc] init]; | |
| 482 orig.oneofEnum = Message2_Enum_Bar; | |
| 483 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofEnum); | |
| 484 Message2 *msg = [Message2 parseFromData:[orig data] error:NULL]; | |
| 485 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofEnum); | |
| 486 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Bar); | |
| 487 [orig release]; | |
| 488 } | |
| 489 | |
| 490 [group release]; | |
| 491 [subMessage release]; | |
| 492 } | |
| 493 | |
| 494 //%PDDM-EXPAND TEST_ROUNDTRIP_ONEOFS(3, YES) | |
| 495 // This block of code is generated, do not edit it directly. | |
| 496 | |
| 497 - (void)testProto3RoundTripOneof { | |
| 498 | |
| 499 Message3 *subMessage = [[Message3 alloc] init]; | |
| 500 XCTAssertNotNil(subMessage); | |
| 501 subMessage.optionalInt32 = 666; | |
| 502 | |
| 503 { // oneofInt32 | |
| 504 Message3 *orig = [[Message3 alloc] init]; | |
| 505 orig.oneofInt32 = 1; | |
| 506 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofInt32); | |
| 507 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 508 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt32); | |
| 509 XCTAssertEqual(msg.oneofInt32, 1); | |
| 510 [orig release]; | |
| 511 } | |
| 512 | |
| 513 { // oneofInt64 | |
| 514 Message3 *orig = [[Message3 alloc] init]; | |
| 515 orig.oneofInt64 = 2; | |
| 516 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofInt64); | |
| 517 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 518 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt64); | |
| 519 XCTAssertEqual(msg.oneofInt64, 2); | |
| 520 [orig release]; | |
| 521 } | |
| 522 | |
| 523 { // oneofUint32 | |
| 524 Message3 *orig = [[Message3 alloc] init]; | |
| 525 orig.oneofUint32 = 3U; | |
| 526 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofUint32); | |
| 527 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 528 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint32); | |
| 529 XCTAssertEqual(msg.oneofUint32, 3U); | |
| 530 [orig release]; | |
| 531 } | |
| 532 | |
| 533 { // oneofUint64 | |
| 534 Message3 *orig = [[Message3 alloc] init]; | |
| 535 orig.oneofUint64 = 4U; | |
| 536 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofUint64); | |
| 537 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 538 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint64); | |
| 539 XCTAssertEqual(msg.oneofUint64, 4U); | |
| 540 [orig release]; | |
| 541 } | |
| 542 | |
| 543 { // oneofSint32 | |
| 544 Message3 *orig = [[Message3 alloc] init]; | |
| 545 orig.oneofSint32 = 5; | |
| 546 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofSint32); | |
| 547 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 548 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint32); | |
| 549 XCTAssertEqual(msg.oneofSint32, 5); | |
| 550 [orig release]; | |
| 551 } | |
| 552 | |
| 553 { // oneofSint64 | |
| 554 Message3 *orig = [[Message3 alloc] init]; | |
| 555 orig.oneofSint64 = 6; | |
| 556 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofSint64); | |
| 557 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 558 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint64); | |
| 559 XCTAssertEqual(msg.oneofSint64, 6); | |
| 560 [orig release]; | |
| 561 } | |
| 562 | |
| 563 { // oneofFixed32 | |
| 564 Message3 *orig = [[Message3 alloc] init]; | |
| 565 orig.oneofFixed32 = 7U; | |
| 566 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofFixed32); | |
| 567 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 568 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed32); | |
| 569 XCTAssertEqual(msg.oneofFixed32, 7U); | |
| 570 [orig release]; | |
| 571 } | |
| 572 | |
| 573 { // oneofFixed64 | |
| 574 Message3 *orig = [[Message3 alloc] init]; | |
| 575 orig.oneofFixed64 = 8U; | |
| 576 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofFixed64); | |
| 577 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 578 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed64); | |
| 579 XCTAssertEqual(msg.oneofFixed64, 8U); | |
| 580 [orig release]; | |
| 581 } | |
| 582 | |
| 583 { // oneofSfixed32 | |
| 584 Message3 *orig = [[Message3 alloc] init]; | |
| 585 orig.oneofSfixed32 = 9; | |
| 586 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32); | |
| 587 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 588 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32); | |
| 589 XCTAssertEqual(msg.oneofSfixed32, 9); | |
| 590 [orig release]; | |
| 591 } | |
| 592 | |
| 593 { // oneofSfixed64 | |
| 594 Message3 *orig = [[Message3 alloc] init]; | |
| 595 orig.oneofSfixed64 = 10; | |
| 596 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64); | |
| 597 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 598 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64); | |
| 599 XCTAssertEqual(msg.oneofSfixed64, 10); | |
| 600 [orig release]; | |
| 601 } | |
| 602 | |
| 603 { // oneofFloat | |
| 604 Message3 *orig = [[Message3 alloc] init]; | |
| 605 orig.oneofFloat = 11.0f; | |
| 606 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofFloat); | |
| 607 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 608 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFloat); | |
| 609 XCTAssertEqual(msg.oneofFloat, 11.0f); | |
| 610 [orig release]; | |
| 611 } | |
| 612 | |
| 613 { // oneofDouble | |
| 614 Message3 *orig = [[Message3 alloc] init]; | |
| 615 orig.oneofDouble = 12.0; | |
| 616 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofDouble); | |
| 617 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 618 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofDouble); | |
| 619 XCTAssertEqual(msg.oneofDouble, 12.0); | |
| 620 [orig release]; | |
| 621 } | |
| 622 | |
| 623 { // oneofBool | |
| 624 Message3 *orig = [[Message3 alloc] init]; | |
| 625 orig.oneofBool = YES; | |
| 626 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofBool); | |
| 627 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 628 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBool); | |
| 629 XCTAssertEqual(msg.oneofBool, YES); | |
| 630 [orig release]; | |
| 631 } | |
| 632 | |
| 633 { // oneofString | |
| 634 Message3 *orig = [[Message3 alloc] init]; | |
| 635 orig.oneofString = @"foo"; | |
| 636 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofString); | |
| 637 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 638 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofString); | |
| 639 XCTAssertEqualObjects(msg.oneofString, @"foo"); | |
| 640 [orig release]; | |
| 641 } | |
| 642 | |
| 643 { // oneofBytes | |
| 644 Message3 *orig = [[Message3 alloc] init]; | |
| 645 orig.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding]; | |
| 646 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofBytes); | |
| 647 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 648 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBytes); | |
| 649 XCTAssertEqualObjects(msg.oneofBytes, [@"bar" dataUsingEncoding:NSUTF8String
Encoding]); | |
| 650 [orig release]; | |
| 651 } | |
| 652 | |
| 653 // Not "group" in proto3. | |
| 654 | |
| 655 { // oneofMessage | |
| 656 Message3 *orig = [[Message3 alloc] init]; | |
| 657 orig.oneofMessage = subMessage; | |
| 658 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofMessage); | |
| 659 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 660 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofMessage); | |
| 661 XCTAssertEqualObjects(msg.oneofMessage, subMessage); | |
| 662 [orig release]; | |
| 663 } | |
| 664 | |
| 665 { // oneofEnum | |
| 666 Message3 *orig = [[Message3 alloc] init]; | |
| 667 orig.oneofEnum = Message2_Enum_Bar; | |
| 668 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofEnum); | |
| 669 Message3 *msg = [Message3 parseFromData:[orig data] error:NULL]; | |
| 670 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofEnum); | |
| 671 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Bar); | |
| 672 [orig release]; | |
| 673 } | |
| 674 | |
| 675 [subMessage release]; | |
| 676 } | |
| 677 | |
| 678 //%PDDM-EXPAND-END (2 expansions) | |
| 679 | |
| 680 - (void)testPackedUnpackedMessageParsing { | |
| 681 // packed is optional, a repeated field should parse when packed or unpacked. | |
| 682 | |
| 683 TestPackedTypes *packedOrig = [TestPackedTypes message]; | |
| 684 TestUnpackedTypes *unpackedOrig = [TestUnpackedTypes message]; | |
| 685 [self setPackedFields:packedOrig repeatedCount:4]; | |
| 686 [self setUnpackedFields:unpackedOrig repeatedCount:4]; | |
| 687 | |
| 688 NSData *packedData = [packedOrig data]; | |
| 689 NSData *unpackedData = [unpackedOrig data]; | |
| 690 XCTAssertNotNil(packedData); | |
| 691 XCTAssertNotNil(unpackedData); | |
| 692 XCTAssertNotEqualObjects(packedData, unpackedData, | |
| 693 @"Data should differ (packed vs unpacked) use"); | |
| 694 | |
| 695 NSError *error = nil; | |
| 696 TestPackedTypes *packedParse = | |
| 697 [TestPackedTypes parseFromData:unpackedData error:&error]; | |
| 698 XCTAssertNotNil(packedParse); | |
| 699 XCTAssertNil(error); | |
| 700 XCTAssertEqualObjects(packedParse, packedOrig); | |
| 701 | |
| 702 error = nil; | |
| 703 TestUnpackedTypes *unpackedParsed = | |
| 704 [TestUnpackedTypes parseFromData:packedData error:&error]; | |
| 705 XCTAssertNotNil(unpackedParsed); | |
| 706 XCTAssertNil(error); | |
| 707 XCTAssertEqualObjects(unpackedParsed, unpackedOrig); | |
| 708 } | |
| 709 | |
| 710 - (void)testPackedUnpackedExtensionParsing { | |
| 711 // packed is optional, a repeated extension should parse when packed or | |
| 712 // unpacked. | |
| 713 | |
| 714 TestPackedExtensions *packedOrig = [TestPackedExtensions message]; | |
| 715 TestUnpackedExtensions *unpackedOrig = [TestUnpackedExtensions message]; | |
| 716 [self setPackedExtensions:packedOrig repeatedCount:kGPBDefaultRepeatCount]; | |
| 717 [self setUnpackedExtensions:unpackedOrig repeatedCount:kGPBDefaultRepeatCount]
; | |
| 718 | |
| 719 NSData *packedData = [packedOrig data]; | |
| 720 NSData *unpackedData = [unpackedOrig data]; | |
| 721 XCTAssertNotNil(packedData); | |
| 722 XCTAssertNotNil(unpackedData); | |
| 723 XCTAssertNotEqualObjects(packedData, unpackedData, | |
| 724 @"Data should differ (packed vs unpacked) use"); | |
| 725 | |
| 726 NSError *error = nil; | |
| 727 TestPackedExtensions *packedParse = | |
| 728 [TestPackedExtensions parseFromData:unpackedData | |
| 729 extensionRegistry:[UnittestRoot extensionRegistry] | |
| 730 error:&error]; | |
| 731 XCTAssertNotNil(packedParse); | |
| 732 XCTAssertNil(error); | |
| 733 XCTAssertEqualObjects(packedParse, packedOrig); | |
| 734 | |
| 735 error = nil; | |
| 736 TestUnpackedExtensions *unpackedParsed = | |
| 737 [TestUnpackedExtensions parseFromData:packedData | |
| 738 extensionRegistry:[UnittestRoot extensionRegistry] | |
| 739 error:&error]; | |
| 740 XCTAssertNotNil(unpackedParsed); | |
| 741 XCTAssertNil(error); | |
| 742 XCTAssertEqualObjects(unpackedParsed, unpackedOrig); | |
| 743 } | |
| 744 | |
| 745 - (void)testPackedExtensionVsFieldParsing { | |
| 746 // Extensions and fields end up on the wire the same way, so they can parse | |
| 747 // each other. | |
| 748 | |
| 749 TestPackedTypes *fieldsOrig = [TestPackedTypes message]; | |
| 750 TestPackedExtensions *extsOrig = [TestPackedExtensions message]; | |
| 751 [self setPackedFields:fieldsOrig repeatedCount:kGPBDefaultRepeatCount]; | |
| 752 [self setPackedExtensions:extsOrig repeatedCount:kGPBDefaultRepeatCount]; | |
| 753 | |
| 754 NSData *fieldsData = [fieldsOrig data]; | |
| 755 NSData *extsData = [extsOrig data]; | |
| 756 XCTAssertNotNil(fieldsData); | |
| 757 XCTAssertNotNil(extsData); | |
| 758 XCTAssertEqualObjects(fieldsData, extsData); | |
| 759 | |
| 760 NSError *error = nil; | |
| 761 TestPackedTypes *fieldsParse = | |
| 762 [TestPackedTypes parseFromData:extsData error:&error]; | |
| 763 XCTAssertNotNil(fieldsParse); | |
| 764 XCTAssertNil(error); | |
| 765 XCTAssertEqualObjects(fieldsParse, fieldsOrig); | |
| 766 | |
| 767 error = nil; | |
| 768 TestPackedExtensions *extsParse = | |
| 769 [TestPackedExtensions parseFromData:fieldsData | |
| 770 extensionRegistry:[UnittestRoot extensionRegistry] | |
| 771 error:&error]; | |
| 772 XCTAssertNotNil(extsParse); | |
| 773 XCTAssertNil(error); | |
| 774 XCTAssertEqualObjects(extsParse, extsOrig); | |
| 775 } | |
| 776 | |
| 777 - (void)testUnpackedExtensionVsFieldParsing { | |
| 778 // Extensions and fields end up on the wire the same way, so they can parse | |
| 779 // each other. | |
| 780 | |
| 781 TestUnpackedTypes *fieldsOrig = [TestUnpackedTypes message]; | |
| 782 TestUnpackedExtensions *extsOrig = [TestUnpackedExtensions message]; | |
| 783 [self setUnpackedFields:fieldsOrig repeatedCount:3]; | |
| 784 [self setUnpackedExtensions:extsOrig repeatedCount:3]; | |
| 785 | |
| 786 NSData *fieldsData = [fieldsOrig data]; | |
| 787 NSData *extsData = [extsOrig data]; | |
| 788 XCTAssertNotNil(fieldsData); | |
| 789 XCTAssertNotNil(extsData); | |
| 790 XCTAssertEqualObjects(fieldsData, extsData); | |
| 791 | |
| 792 TestUnpackedTypes *fieldsParse = | |
| 793 [TestUnpackedTypes parseFromData:extsData error:NULL]; | |
| 794 XCTAssertNotNil(fieldsParse); | |
| 795 XCTAssertEqualObjects(fieldsParse, fieldsOrig); | |
| 796 | |
| 797 TestUnpackedExtensions *extsParse = | |
| 798 [TestUnpackedExtensions parseFromData:fieldsData | |
| 799 extensionRegistry:[UnittestRoot extensionRegistry] | |
| 800 error:NULL]; | |
| 801 XCTAssertNotNil(extsParse); | |
| 802 XCTAssertEqualObjects(extsParse, extsOrig); | |
| 803 } | |
| 804 | |
| 805 #pragma mark - Subset from from map_tests.cc | |
| 806 | |
| 807 // TEST(GeneratedMapFieldTest, StandardWireFormat) | |
| 808 - (void)testMap_StandardWireFormat { | |
| 809 NSData *data = DataFromCStr("\x0A\x04\x08\x01\x10\x01"); | |
| 810 | |
| 811 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | |
| 812 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | |
| 813 int32_t val = 666; | |
| 814 XCTAssertTrue([msg.mapInt32Int32 valueForKey:1 value:&val]); | |
| 815 XCTAssertEqual(val, 1); | |
| 816 | |
| 817 [msg release]; | |
| 818 } | |
| 819 | |
| 820 // TEST(GeneratedMapFieldTest, UnorderedWireFormat) | |
| 821 - (void)testMap_UnorderedWireFormat { | |
| 822 // put value before key in wire format | |
| 823 NSData *data = DataFromCStr("\x0A\x04\x10\x01\x08\x02"); | |
| 824 | |
| 825 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | |
| 826 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | |
| 827 int32_t val = 666; | |
| 828 XCTAssertTrue([msg.mapInt32Int32 valueForKey:2 value:&val]); | |
| 829 XCTAssertEqual(val, 1); | |
| 830 | |
| 831 [msg release]; | |
| 832 } | |
| 833 | |
| 834 // TEST(GeneratedMapFieldTest, DuplicatedKeyWireFormat) | |
| 835 - (void)testMap_DuplicatedKeyWireFormat { | |
| 836 // Two key fields in wire format | |
| 837 NSData *data = DataFromCStr("\x0A\x06\x08\x01\x08\x02\x10\x01"); | |
| 838 | |
| 839 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | |
| 840 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | |
| 841 int32_t val = 666; | |
| 842 XCTAssertTrue([msg.mapInt32Int32 valueForKey:2 value:&val]); | |
| 843 XCTAssertEqual(val, 1); | |
| 844 | |
| 845 [msg release]; | |
| 846 } | |
| 847 | |
| 848 // TEST(GeneratedMapFieldTest, DuplicatedValueWireFormat) | |
| 849 - (void)testMap_DuplicatedValueWireFormat { | |
| 850 // Two value fields in wire format | |
| 851 NSData *data = DataFromCStr("\x0A\x06\x08\x01\x10\x01\x10\x02"); | |
| 852 | |
| 853 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | |
| 854 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | |
| 855 int32_t val = 666; | |
| 856 XCTAssertTrue([msg.mapInt32Int32 valueForKey:1 value:&val]); | |
| 857 XCTAssertEqual(val, 2); | |
| 858 | |
| 859 [msg release]; | |
| 860 } | |
| 861 | |
| 862 // TEST(GeneratedMapFieldTest, MissedKeyWireFormat) | |
| 863 - (void)testMap_MissedKeyWireFormat { | |
| 864 // No key field in wire format | |
| 865 NSData *data = DataFromCStr("\x0A\x02\x10\x01"); | |
| 866 | |
| 867 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | |
| 868 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | |
| 869 int32_t val = 666; | |
| 870 XCTAssertTrue([msg.mapInt32Int32 valueForKey:0 value:&val]); | |
| 871 XCTAssertEqual(val, 1); | |
| 872 | |
| 873 [msg release]; | |
| 874 } | |
| 875 | |
| 876 // TEST(GeneratedMapFieldTest, MissedValueWireFormat) | |
| 877 - (void)testMap_MissedValueWireFormat { | |
| 878 // No value field in wire format | |
| 879 NSData *data = DataFromCStr("\x0A\x02\x08\x01"); | |
| 880 | |
| 881 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | |
| 882 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | |
| 883 int32_t val = 666; | |
| 884 XCTAssertTrue([msg.mapInt32Int32 valueForKey:1 value:&val]); | |
| 885 XCTAssertEqual(val, 0); | |
| 886 | |
| 887 [msg release]; | |
| 888 } | |
| 889 | |
| 890 // TEST(GeneratedMapFieldTest, UnknownFieldWireFormat) | |
| 891 - (void)testMap_UnknownFieldWireFormat { | |
| 892 // Unknown field in wire format | |
| 893 NSData *data = DataFromCStr("\x0A\x06\x08\x02\x10\x03\x18\x01"); | |
| 894 | |
| 895 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | |
| 896 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | |
| 897 int32_t val = 666; | |
| 898 XCTAssertTrue([msg.mapInt32Int32 valueForKey:2 value:&val]); | |
| 899 XCTAssertEqual(val, 3); | |
| 900 | |
| 901 [msg release]; | |
| 902 } | |
| 903 | |
| 904 // TEST(GeneratedMapFieldTest, CorruptedWireFormat) | |
| 905 - (void)testMap_CorruptedWireFormat { | |
| 906 // corrupted data in wire format | |
| 907 NSData *data = DataFromCStr("\x0A\x06\x08\x02\x11\x03"); | |
| 908 | |
| 909 NSError *error = nil; | |
| 910 TestMap *msg = [TestMap parseFromData:data error:&error]; | |
| 911 XCTAssertNil(msg); | |
| 912 XCTAssertNotNil(error); | |
| 913 XCTAssertEqualObjects(error.domain, GPBMessageErrorDomain); | |
| 914 XCTAssertEqual(error.code, GPBMessageErrorCodeMalformedData); | |
| 915 } | |
| 916 | |
| 917 // TEST(GeneratedMapFieldTest, Proto2UnknownEnum) | |
| 918 - (void)testMap_Proto2UnknownEnum { | |
| 919 TestEnumMapPlusExtra *orig = [[TestEnumMapPlusExtra alloc] init]; | |
| 920 | |
| 921 orig.knownMapField = [GPBInt32EnumDictionary | |
| 922 dictionaryWithValidationFunction:Proto2MapEnumPlusExtra_IsValidValue]; | |
| 923 orig.unknownMapField = [GPBInt32EnumDictionary | |
| 924 dictionaryWithValidationFunction:Proto2MapEnumPlusExtra_IsValidValue]; | |
| 925 [orig.knownMapField setValue:Proto2MapEnumPlusExtra_EProto2MapEnumFoo | |
| 926 forKey:0]; | |
| 927 [orig.unknownMapField setValue:Proto2MapEnumPlusExtra_EProto2MapEnumExtra | |
| 928 forKey:0]; | |
| 929 | |
| 930 TestEnumMap *msg1 = [TestEnumMap parseFromData:[orig data] error:NULL]; | |
| 931 XCTAssertEqual(msg1.knownMapField.count, 1U); | |
| 932 int32_t val = -1; | |
| 933 XCTAssertTrue([msg1.knownMapField valueForKey:0 value:&val]); | |
| 934 XCTAssertEqual(val, Proto2MapEnum_Proto2MapEnumFoo); | |
| 935 XCTAssertEqual(msg1.unknownFields.countOfFields, 1U); | |
| 936 | |
| 937 TestEnumMapPlusExtra *msg2 = | |
| 938 [TestEnumMapPlusExtra parseFromData:[msg1 data] error:NULL]; | |
| 939 val = -1; | |
| 940 XCTAssertEqual(msg2.knownMapField.count, 1U); | |
| 941 XCTAssertTrue([msg2.knownMapField valueForKey:0 value:&val]); | |
| 942 XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumFoo); | |
| 943 val = -1; | |
| 944 XCTAssertEqual(msg2.unknownMapField.count, 1U); | |
| 945 XCTAssertTrue([msg2.unknownMapField valueForKey:0 value:&val]); | |
| 946 XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumExtra); | |
| 947 XCTAssertEqual(msg2.unknownFields.countOfFields, 0U); | |
| 948 | |
| 949 XCTAssertEqualObjects(orig, msg2); | |
| 950 | |
| 951 [orig release]; | |
| 952 } | |
| 953 | |
| 954 #pragma mark - Map Round Tripping | |
| 955 | |
| 956 - (void)testProto2MapRoundTripping { | |
| 957 Message2 *msg = [[Message2 alloc] init]; | |
| 958 | |
| 959 // Key/Value data should result in different byte lengths on wire to ensure | |
| 960 // everything is right. | |
| 961 [msg.mapInt32Int32 setValue:1000 forKey:200]; | |
| 962 [msg.mapInt32Int32 setValue:101 forKey:2001]; | |
| 963 [msg.mapInt64Int64 setValue:1002 forKey:202]; | |
| 964 [msg.mapInt64Int64 setValue:103 forKey:2003]; | |
| 965 [msg.mapUint32Uint32 setValue:1004 forKey:204]; | |
| 966 [msg.mapUint32Uint32 setValue:105 forKey:2005]; | |
| 967 [msg.mapUint64Uint64 setValue:1006 forKey:206]; | |
| 968 [msg.mapUint64Uint64 setValue:107 forKey:2007]; | |
| 969 [msg.mapSint32Sint32 setValue:1008 forKey:208]; | |
| 970 [msg.mapSint32Sint32 setValue:109 forKey:2009]; | |
| 971 [msg.mapSint64Sint64 setValue:1010 forKey:210]; | |
| 972 [msg.mapSint64Sint64 setValue:111 forKey:2011]; | |
| 973 [msg.mapFixed32Fixed32 setValue:1012 forKey:212]; | |
| 974 [msg.mapFixed32Fixed32 setValue:113 forKey:2013]; | |
| 975 [msg.mapFixed64Fixed64 setValue:1014 forKey:214]; | |
| 976 [msg.mapFixed64Fixed64 setValue:115 forKey:2015]; | |
| 977 [msg.mapSfixed32Sfixed32 setValue:1016 forKey:216]; | |
| 978 [msg.mapSfixed32Sfixed32 setValue:117 forKey:2017]; | |
| 979 [msg.mapSfixed64Sfixed64 setValue:1018 forKey:218]; | |
| 980 [msg.mapSfixed64Sfixed64 setValue:119 forKey:2019]; | |
| 981 [msg.mapInt32Float setValue:1020.f forKey:220]; | |
| 982 [msg.mapInt32Float setValue:121.f forKey:2021]; | |
| 983 [msg.mapInt32Double setValue:1022. forKey:222]; | |
| 984 [msg.mapInt32Double setValue:123. forKey:2023]; | |
| 985 [msg.mapBoolBool setValue:false forKey:true]; | |
| 986 [msg.mapBoolBool setValue:true forKey:false]; | |
| 987 msg.mapStringString[@"224"] = @"1024"; | |
| 988 msg.mapStringString[@"2025"] = @"125"; | |
| 989 msg.mapStringBytes[@"226"] = DataFromCStr("1026"); | |
| 990 msg.mapStringBytes[@"2027"] = DataFromCStr("127"); | |
| 991 Message2 *val1 = [[Message2 alloc] init]; | |
| 992 val1.optionalInt32 = 1028; | |
| 993 Message2 *val2 = [[Message2 alloc] init]; | |
| 994 val2.optionalInt32 = 129; | |
| 995 [msg.mapStringMessage setValue:val1 forKey:@"228"]; | |
| 996 [msg.mapStringMessage setValue:val2 forKey:@"2029"]; | |
| 997 [msg.mapInt32Bytes setValue:DataFromCStr("1030 bytes") forKey:230]; | |
| 998 [msg.mapInt32Bytes setValue:DataFromCStr("131") forKey:2031]; | |
| 999 [msg.mapInt32Enum setValue:Message2_Enum_Bar forKey:232]; | |
| 1000 [msg.mapInt32Enum setValue:Message2_Enum_Baz forKey:2033]; | |
| 1001 Message2 *val3 = [[Message2 alloc] init]; | |
| 1002 val3.optionalInt32 = 1034; | |
| 1003 Message2 *val4 = [[Message2 alloc] init]; | |
| 1004 val4.optionalInt32 = 135; | |
| 1005 [msg.mapInt32Message setValue:val3 forKey:234]; | |
| 1006 [msg.mapInt32Message setValue:val4 forKey:2035]; | |
| 1007 | |
| 1008 NSData *data = [msg data]; | |
| 1009 Message2 *msg2 = [[Message2 alloc] initWithData:data error:NULL]; | |
| 1010 | |
| 1011 XCTAssertNotEqual(msg2, msg); // Pointer comparison | |
| 1012 XCTAssertEqualObjects(msg2, msg); | |
| 1013 | |
| 1014 [val4 release]; | |
| 1015 [val3 release]; | |
| 1016 [val2 release]; | |
| 1017 [val1 release]; | |
| 1018 [msg2 release]; | |
| 1019 [msg release]; | |
| 1020 } | |
| 1021 | |
| 1022 @end | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1322483002:
Revert https://codereview.chromium.org/1291903002 (protobuf roll). (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master