| OLD | NEW |
|---|
| (Empty) |
| 1 // Protocol Buffers - Google's data interchange format | |
| 2 // Copyright 2008 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 "google/protobuf/MapUnittest.pbobjc.h" | |
| 34 #import "google/protobuf/Unittest.pbobjc.h" | |
| 35 #import "google/protobuf/UnittestImport.pbobjc.h" | |
| 36 | |
| 37 const uint32_t kGPBDefaultRepeatCount = 2; | |
| 38 | |
| 39 // Small category to easily turn a CString into an NSData. | |
| 40 @interface NSData (GPBTestCase) | |
| 41 + (NSData *)gpbtu_dataWithCString:(char *)buffer; | |
| 42 + (instancetype)gpbtu_dataWithEmbeddedNulls; | |
| 43 @end | |
| 44 | |
| 45 @implementation NSData (GPBTestCase) | |
| 46 + (NSData *)gpbtu_dataWithCString:(char *)buffer { | |
| 47 return [NSData dataWithBytes:buffer length:strlen(buffer)]; | |
| 48 } | |
| 49 | |
| 50 + (instancetype)gpbtu_dataWithUint32:(uint32_t)value { | |
| 51 return [[[self alloc] initWithUint32_gpbtu:value] autorelease]; | |
| 52 } | |
| 53 | |
| 54 - (instancetype)initWithUint32_gpbtu:(uint32_t)value { | |
| 55 value = CFSwapInt32HostToLittle(value); | |
| 56 return [self initWithBytes:&value length:sizeof(value)]; | |
| 57 } | |
| 58 | |
| 59 + (instancetype)gpbtu_dataWithEmbeddedNulls { | |
| 60 char bytes[6] = "\1\0\2\3\0\5"; | |
| 61 return [self dataWithBytes:bytes length:sizeof(bytes)]; | |
| 62 } | |
| 63 @end | |
| 64 | |
| 65 @implementation GPBTestCase | |
| 66 | |
| 67 // Return data for name. Optionally (based on #if setting) write out dataToWrite | |
| 68 // to replace that data. Useful for setting golden masters. | |
| 69 - (NSData *)getDataFileNamed:(NSString *)name | |
| 70 dataToWrite:(NSData *)dataToWrite { | |
| 71 NSBundle *bundle = [NSBundle bundleForClass:[self class]]; | |
| 72 NSString *path = [bundle pathForResource:[name stringByDeletingPathExtension] | |
| 73 ofType:[name pathExtension]]; | |
| 74 XCTAssertNotNil(path, @"Unable to find %@", name); | |
| 75 NSData *data = [NSData dataWithContentsOfFile:path]; | |
| 76 XCTAssertNotNil(data, @"Unable to load from %@", path); | |
| 77 #if 0 | |
| 78 // Enable to write out golden master files. | |
| 79 if (!path) { | |
| 80 path = [[bundle resourcePath] stringByAppendingPathComponent:name]; | |
| 81 } | |
| 82 NSError *error = nil; | |
| 83 BOOL wrote = [dataToWrite writeToFile:path options:NSDataWritingAtomic error:&
error]; | |
| 84 XCTAssertTrue(wrote, @"Unable to write %@ (%@)", path, error); | |
| 85 NSLog(@"Wrote data file to %@", path); | |
| 86 #else | |
| 87 // Kill off the unused variable warning. | |
| 88 dataToWrite = dataToWrite; | |
| 89 #endif | |
| 90 return data; | |
| 91 } | |
| 92 | |
| 93 // ------------------------------------------------------------------- | |
| 94 | |
| 95 - (void)modifyRepeatedExtensions:(TestAllExtensions *)message { | |
| 96 [message setExtension:[UnittestRoot repeatedInt32Extension] | |
| 97 index:1 | |
| 98 value:@501]; | |
| 99 [message setExtension:[UnittestRoot repeatedInt64Extension] | |
| 100 index:1 | |
| 101 value:@502]; | |
| 102 [message setExtension:[UnittestRoot repeatedUint32Extension] | |
| 103 index:1 | |
| 104 value:@503]; | |
| 105 [message setExtension:[UnittestRoot repeatedUint64Extension] | |
| 106 index:1 | |
| 107 value:@504]; | |
| 108 [message setExtension:[UnittestRoot repeatedSint32Extension] | |
| 109 index:1 | |
| 110 value:@505]; | |
| 111 [message setExtension:[UnittestRoot repeatedSint64Extension] | |
| 112 index:1 | |
| 113 value:@506]; | |
| 114 [message setExtension:[UnittestRoot repeatedFixed32Extension] | |
| 115 index:1 | |
| 116 value:@507]; | |
| 117 [message setExtension:[UnittestRoot repeatedFixed64Extension] | |
| 118 index:1 | |
| 119 value:@508]; | |
| 120 [message setExtension:[UnittestRoot repeatedSfixed32Extension] | |
| 121 index:1 | |
| 122 value:@509]; | |
| 123 [message setExtension:[UnittestRoot repeatedSfixed64Extension] | |
| 124 index:1 | |
| 125 value:@510]; | |
| 126 [message setExtension:[UnittestRoot repeatedFloatExtension] | |
| 127 index:1 | |
| 128 value:@511.0f]; | |
| 129 [message setExtension:[UnittestRoot repeatedDoubleExtension] | |
| 130 index:1 | |
| 131 value:@512.0]; | |
| 132 [message setExtension:[UnittestRoot repeatedBoolExtension] | |
| 133 index:1 | |
| 134 value:@YES]; | |
| 135 [message setExtension:[UnittestRoot repeatedStringExtension] | |
| 136 index:1 | |
| 137 value:@"515"]; | |
| 138 [message setExtension:[UnittestRoot repeatedBytesExtension] | |
| 139 index:1 | |
| 140 value:[NSData gpbtu_dataWithUint32:516]]; | |
| 141 | |
| 142 RepeatedGroup_extension *repeatedGroup = [RepeatedGroup_extension message]; | |
| 143 [repeatedGroup setA:517]; | |
| 144 [message setExtension:[UnittestRoot repeatedGroupExtension] | |
| 145 index:1 | |
| 146 value:repeatedGroup]; | |
| 147 TestAllTypes_NestedMessage *nestedMessage = | |
| 148 [TestAllTypes_NestedMessage message]; | |
| 149 [nestedMessage setBb:518]; | |
| 150 [message setExtension:[UnittestRoot repeatedNestedMessageExtension] | |
| 151 index:1 | |
| 152 value:nestedMessage]; | |
| 153 ForeignMessage *foreignMessage = [ForeignMessage message]; | |
| 154 [foreignMessage setC:519]; | |
| 155 [message setExtension:[UnittestRoot repeatedForeignMessageExtension] | |
| 156 index:1 | |
| 157 value:foreignMessage]; | |
| 158 ImportMessage *importMessage = [ImportMessage message]; | |
| 159 [importMessage setD:520]; | |
| 160 [message setExtension:[UnittestRoot repeatedImportMessageExtension] | |
| 161 index:1 | |
| 162 value:importMessage]; | |
| 163 | |
| 164 [message setExtension:[UnittestRoot repeatedNestedEnumExtension] | |
| 165 index:1 | |
| 166 value:@(TestAllTypes_NestedEnum_Foo)]; | |
| 167 [message setExtension:[UnittestRoot repeatedForeignEnumExtension] | |
| 168 index:1 | |
| 169 value:@(ForeignEnum_ForeignFoo)]; | |
| 170 [message setExtension:[UnittestRoot repeatedImportEnumExtension] | |
| 171 index:1 | |
| 172 value:@(ImportEnum_ImportFoo)]; | |
| 173 | |
| 174 [message setExtension:[UnittestRoot repeatedStringPieceExtension] | |
| 175 index:1 | |
| 176 value:@"524"]; | |
| 177 [message setExtension:[UnittestRoot repeatedCordExtension] | |
| 178 index:1 | |
| 179 value:@"525"]; | |
| 180 } | |
| 181 | |
| 182 - (void)assertAllExtensionsSet:(TestAllExtensions *)message | |
| 183 repeatedCount:(uint32_t)count { | |
| 184 XCTAssertTrue([message hasExtension:[UnittestRoot optionalInt32Extension]]); | |
| 185 XCTAssertTrue([message hasExtension:[UnittestRoot optionalInt64Extension]]); | |
| 186 XCTAssertTrue([message hasExtension:[UnittestRoot optionalUint32Extension]]); | |
| 187 XCTAssertTrue([message hasExtension:[UnittestRoot optionalUint64Extension]]); | |
| 188 XCTAssertTrue([message hasExtension:[UnittestRoot optionalSint32Extension]]); | |
| 189 XCTAssertTrue([message hasExtension:[UnittestRoot optionalSint64Extension]]); | |
| 190 XCTAssertTrue([message hasExtension:[UnittestRoot optionalFixed32Extension]]); | |
| 191 XCTAssertTrue([message hasExtension:[UnittestRoot optionalFixed64Extension]]); | |
| 192 XCTAssertTrue([message hasExtension:[UnittestRoot optionalSfixed32Extension]])
; | |
| 193 XCTAssertTrue([message hasExtension:[UnittestRoot optionalSfixed64Extension]])
; | |
| 194 XCTAssertTrue([message hasExtension:[UnittestRoot optionalFloatExtension]]); | |
| 195 XCTAssertTrue([message hasExtension:[UnittestRoot optionalDoubleExtension]]); | |
| 196 XCTAssertTrue([message hasExtension:[UnittestRoot optionalBoolExtension]]); | |
| 197 XCTAssertTrue([message hasExtension:[UnittestRoot optionalStringExtension]]); | |
| 198 XCTAssertTrue([message hasExtension:[UnittestRoot optionalBytesExtension]]); | |
| 199 | |
| 200 XCTAssertTrue([message hasExtension:[UnittestRoot optionalGroupExtension]]); | |
| 201 XCTAssertTrue([message hasExtension:[UnittestRoot optionalNestedMessageExtensi
on]]); | |
| 202 XCTAssertTrue([message hasExtension:[UnittestRoot optionalForeignMessageExtens
ion]]); | |
| 203 XCTAssertTrue([message hasExtension:[UnittestRoot optionalImportMessageExtensi
on]]); | |
| 204 | |
| 205 XCTAssertTrue([[message getExtension:[UnittestRoot optionalGroupExtension]] ha
sA]); | |
| 206 XCTAssertTrue([[message getExtension:[UnittestRoot optionalNestedMessageExtens
ion]] hasBb]); | |
| 207 XCTAssertTrue([[message getExtension:[UnittestRoot optionalForeignMessageExten
sion]] hasC]); | |
| 208 XCTAssertTrue([[message getExtension:[UnittestRoot optionalImportMessageExtens
ion]] hasD]); | |
| 209 | |
| 210 XCTAssertTrue([message hasExtension:[UnittestRoot optionalNestedEnumExtension]
]); | |
| 211 XCTAssertTrue([message hasExtension:[UnittestRoot optionalForeignEnumExtension
]]); | |
| 212 XCTAssertTrue([message hasExtension:[UnittestRoot optionalImportEnumExtension]
]); | |
| 213 | |
| 214 XCTAssertTrue([message hasExtension:[UnittestRoot optionalStringPieceExtension
]]); | |
| 215 XCTAssertTrue([message hasExtension:[UnittestRoot optionalCordExtension]]); | |
| 216 | |
| 217 XCTAssertTrue([message hasExtension:[UnittestRoot defaultInt32Extension]]); | |
| 218 XCTAssertTrue([message hasExtension:[UnittestRoot defaultInt64Extension]]); | |
| 219 XCTAssertTrue([message hasExtension:[UnittestRoot defaultUint32Extension]]); | |
| 220 XCTAssertTrue([message hasExtension:[UnittestRoot defaultUint64Extension]]); | |
| 221 XCTAssertTrue([message hasExtension:[UnittestRoot defaultSint32Extension]]); | |
| 222 XCTAssertTrue([message hasExtension:[UnittestRoot defaultSint64Extension]]); | |
| 223 XCTAssertTrue([message hasExtension:[UnittestRoot defaultFixed32Extension]]); | |
| 224 XCTAssertTrue([message hasExtension:[UnittestRoot defaultFixed64Extension]]); | |
| 225 XCTAssertTrue([message hasExtension:[UnittestRoot defaultSfixed32Extension]]); | |
| 226 XCTAssertTrue([message hasExtension:[UnittestRoot defaultSfixed64Extension]]); | |
| 227 XCTAssertTrue([message hasExtension:[UnittestRoot defaultFloatExtension]]); | |
| 228 XCTAssertTrue([message hasExtension:[UnittestRoot defaultDoubleExtension]]); | |
| 229 XCTAssertTrue([message hasExtension:[UnittestRoot defaultBoolExtension]]); | |
| 230 XCTAssertTrue([message hasExtension:[UnittestRoot defaultStringExtension]]); | |
| 231 XCTAssertTrue([message hasExtension:[UnittestRoot defaultBytesExtension]]); | |
| 232 | |
| 233 XCTAssertTrue([message hasExtension:[UnittestRoot defaultNestedEnumExtension]]
); | |
| 234 XCTAssertTrue([message hasExtension:[UnittestRoot defaultForeignEnumExtension]
]); | |
| 235 XCTAssertTrue([message hasExtension:[UnittestRoot defaultImportEnumExtension]]
); | |
| 236 | |
| 237 XCTAssertTrue([message hasExtension:[UnittestRoot defaultStringPieceExtension]
]); | |
| 238 XCTAssertTrue([message hasExtension:[UnittestRoot defaultCordExtension]]); | |
| 239 | |
| 240 XCTAssertEqual(101, [[message getExtension:[UnittestRoot optionalInt32Extensio
n]] intValue]); | |
| 241 XCTAssertEqual(102LL, [[message getExtension:[UnittestRoot optionalInt64Extens
ion]] longLongValue]); | |
| 242 XCTAssertEqual(103U, [[message getExtension:[UnittestRoot optionalUint32Extens
ion]] unsignedIntValue]); | |
| 243 XCTAssertEqual(104ULL, [[message getExtension:[UnittestRoot optionalUint64Exte
nsion]] unsignedLongLongValue]); | |
| 244 XCTAssertEqual(105, [[message getExtension:[UnittestRoot optionalSint32Extensi
on]] intValue]); | |
| 245 XCTAssertEqual(106LL, [[message getExtension:[UnittestRoot optionalSint64Exten
sion]] longLongValue]); | |
| 246 XCTAssertEqual(107U, [[message getExtension:[UnittestRoot optionalFixed32Exten
sion]] unsignedIntValue]); | |
| 247 XCTAssertEqual(108ULL, [[message getExtension:[UnittestRoot optionalFixed64Ext
ension]] unsignedLongLongValue]); | |
| 248 XCTAssertEqual(109, [[message getExtension:[UnittestRoot optionalSfixed32Exten
sion]] intValue]); | |
| 249 XCTAssertEqual(110LL, [[message getExtension:[UnittestRoot optionalSfixed64Ext
ension]] longLongValue]); | |
| 250 XCTAssertEqualWithAccuracy(111.0f, [[message getExtension:[UnittestRoot option
alFloatExtension]] floatValue], 0.01); | |
| 251 XCTAssertEqualWithAccuracy(112.0, [[message getExtension:[UnittestRoot optiona
lDoubleExtension]] doubleValue], 0.01); | |
| 252 XCTAssertTrue([[message getExtension:[UnittestRoot optionalBoolExtension]] boo
lValue]); | |
| 253 XCTAssertEqualObjects(@"115", [message getExtension:[UnittestRoot optionalStri
ngExtension]]); | |
| 254 XCTAssertEqualObjects([NSData gpbtu_dataWithEmbeddedNulls], [message getExtens
ion:[UnittestRoot optionalBytesExtension]]); | |
| 255 | |
| 256 XCTAssertEqual(117, [(TestAllTypes_OptionalGroup*)[message getExtension:[Unitt
estRoot optionalGroupExtension]] a]); | |
| 257 XCTAssertEqual(118, [(TestAllTypes_NestedMessage*)[message getExtension:[Unitt
estRoot optionalNestedMessageExtension]] bb]); | |
| 258 XCTAssertEqual(119, [[message getExtension:[UnittestRoot optionalForeignMessag
eExtension]] c]); | |
| 259 XCTAssertEqual(120, [[message getExtension:[UnittestRoot optionalImportMessage
Extension]] d]); | |
| 260 | |
| 261 XCTAssertEqual(TestAllTypes_NestedEnum_Baz, [[message getExtension:[UnittestRo
ot optionalNestedEnumExtension]] intValue]); | |
| 262 XCTAssertEqual(ForeignEnum_ForeignBaz, [[message getExtension:[UnittestRoot op
tionalForeignEnumExtension]] intValue]); | |
| 263 XCTAssertEqual(ImportEnum_ImportBaz, [[message getExtension:[UnittestRoot opti
onalImportEnumExtension]] intValue]); | |
| 264 | |
| 265 XCTAssertEqualObjects(@"124", [message getExtension:[UnittestRoot optionalStri
ngPieceExtension]]); | |
| 266 XCTAssertEqualObjects(@"125", [message getExtension:[UnittestRoot optionalCord
Extension]]); | |
| 267 | |
| 268 // ----------------------------------------------------------------- | |
| 269 | |
| 270 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedInt32Extens
ion]] count]); | |
| 271 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedInt64Extens
ion]] count]); | |
| 272 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedUint32Exten
sion]] count]); | |
| 273 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedUint64Exten
sion]] count]); | |
| 274 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSint32Exten
sion]] count]); | |
| 275 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSint64Exten
sion]] count]); | |
| 276 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedFixed32Exte
nsion]] count]); | |
| 277 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedFixed64Exte
nsion]] count]); | |
| 278 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSfixed32Ext
ension]] count]); | |
| 279 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSfixed64Ext
ension]] count]); | |
| 280 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedFloatExtens
ion]] count]); | |
| 281 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedDoubleExten
sion]] count]); | |
| 282 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedBoolExtensi
on]] count]); | |
| 283 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedStringExten
sion]] count]); | |
| 284 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedBytesExtens
ion]] count]); | |
| 285 | |
| 286 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedGroupExtens
ion]] count]); | |
| 287 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedNestedMessa
geExtension]] count]); | |
| 288 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedForeignMess
ageExtension]] count]); | |
| 289 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedImportMessa
geExtension]] count]); | |
| 290 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedNestedEnumE
xtension]] count]); | |
| 291 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedForeignEnum
Extension]] count]); | |
| 292 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedImportEnumE
xtension]] count]); | |
| 293 | |
| 294 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedStringPiece
Extension]] count]); | |
| 295 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedCordExtensi
on]] count]); | |
| 296 | |
| 297 for (uint32_t i = 0; i < count; ++i) { | |
| 298 id extension = [message getExtension:[UnittestRoot repeatedInt32Extension]]; | |
| 299 XCTAssertEqual((int)(201 + i * 100), [extension[i] intValue]); | |
| 300 extension = [message getExtension:[UnittestRoot repeatedInt64Extension]]; | |
| 301 XCTAssertEqual(202 + i * 100, [extension[i] longLongValue]); | |
| 302 extension = [message getExtension:[UnittestRoot repeatedUint32Extension]]; | |
| 303 XCTAssertEqual(203 + i * 100, [extension[i] unsignedIntValue]); | |
| 304 extension = [message getExtension:[UnittestRoot repeatedUint64Extension]]; | |
| 305 XCTAssertEqual(204 + i * 100, [extension[i] unsignedLongLongValue]); | |
| 306 extension = [message getExtension:[UnittestRoot repeatedSint32Extension]]; | |
| 307 XCTAssertEqual((int)(205 + i * 100), [extension[i] intValue]); | |
| 308 extension = [message getExtension:[UnittestRoot repeatedSint64Extension]]; | |
| 309 XCTAssertEqual(206 + i * 100, [extension[i] longLongValue]); | |
| 310 extension = [message getExtension:[UnittestRoot repeatedFixed32Extension]]; | |
| 311 XCTAssertEqual(207 + i * 100, [extension[i] unsignedIntValue]); | |
| 312 extension = [message getExtension:[UnittestRoot repeatedFixed64Extension]]; | |
| 313 XCTAssertEqual(208 + i * 100, [extension[i] unsignedLongLongValue]); | |
| 314 extension = [message getExtension:[UnittestRoot repeatedSfixed32Extension]]; | |
| 315 XCTAssertEqual((int)(209 + i * 100), [extension[i] intValue]); | |
| 316 extension = [message getExtension:[UnittestRoot repeatedSfixed64Extension]]; | |
| 317 XCTAssertEqual(210 + i * 100, [extension[i] longLongValue]); | |
| 318 extension = [message getExtension:[UnittestRoot repeatedFloatExtension]]; | |
| 319 XCTAssertEqualWithAccuracy(211 + i * 100, [extension[i] floatValue], 0.01); | |
| 320 extension = [message getExtension:[UnittestRoot repeatedDoubleExtension]]; | |
| 321 XCTAssertEqualWithAccuracy(212 + i * 100, [extension[i] doubleValue], 0.01); | |
| 322 extension = [message getExtension:[UnittestRoot repeatedBoolExtension]]; | |
| 323 XCTAssertEqual((i % 2) ? YES : NO, [extension[i] boolValue]); | |
| 324 | |
| 325 NSString *string = [[NSString alloc] initWithFormat:@"%d", 215 + i * 100]; | |
| 326 extension = [message getExtension:[UnittestRoot repeatedStringExtension]]; | |
| 327 XCTAssertEqualObjects(string, extension[i]); | |
| 328 [string release]; | |
| 329 | |
| 330 NSData *data = [[NSData alloc] initWithUint32_gpbtu:216 + i * 100]; | |
| 331 extension = [message getExtension:[UnittestRoot repeatedBytesExtension]]; | |
| 332 XCTAssertEqualObjects(data, extension[i]); | |
| 333 [data release]; | |
| 334 | |
| 335 extension = [message getExtension:[UnittestRoot repeatedGroupExtension]]; | |
| 336 XCTAssertEqual((int)(217 + i * 100), [(TestAllTypes_OptionalGroup*)extension
[i] a]); | |
| 337 extension = [message getExtension:[UnittestRoot repeatedNestedMessageExtensi
on]]; | |
| 338 XCTAssertEqual((int)(218 + i * 100), [(TestAllTypes_NestedMessage*)extension
[i] bb]); | |
| 339 extension = [message getExtension:[UnittestRoot repeatedForeignMessageExtens
ion]]; | |
| 340 XCTAssertEqual((int)(219 + i * 100), [extension[i] c]); | |
| 341 extension = [message getExtension:[UnittestRoot repeatedImportMessageExtensi
on]]; | |
| 342 XCTAssertEqual((int)(220 + i * 100), [extension[i] d]); | |
| 343 | |
| 344 extension = [message getExtension:[UnittestRoot repeatedNestedEnumExtension]
]; | |
| 345 XCTAssertEqual((i % 2) ? TestAllTypes_NestedEnum_Bar : TestAllTypes_NestedEn
um_Baz, [extension[i] intValue]); | |
| 346 extension = [message getExtension:[UnittestRoot repeatedForeignEnumExtension
]]; | |
| 347 XCTAssertEqual((i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz, [e
xtension[i] intValue]); | |
| 348 extension = [message getExtension:[UnittestRoot repeatedImportEnumExtension]
]; | |
| 349 XCTAssertEqual((i % 2) ? ImportEnum_ImportBar : ImportEnum_ImportBaz, [exten
sion[i] intValue]); | |
| 350 | |
| 351 string = [[NSString alloc] initWithFormat:@"%d", 224 + i * 100]; | |
| 352 extension = [message getExtension:[UnittestRoot repeatedStringPieceExtension
]]; | |
| 353 XCTAssertEqualObjects(string, extension[i]); | |
| 354 [string release]; | |
| 355 | |
| 356 string = [[NSString alloc] initWithFormat:@"%d", 225 + i * 100]; | |
| 357 extension = [message getExtension:[UnittestRoot repeatedCordExtension]]; | |
| 358 XCTAssertEqualObjects(string, extension[i]); | |
| 359 [string release]; | |
| 360 } | |
| 361 | |
| 362 // ----------------------------------------------------------------- | |
| 363 | |
| 364 XCTAssertTrue([message hasExtension:[UnittestRoot defaultInt32Extension]]); | |
| 365 XCTAssertTrue([message hasExtension:[UnittestRoot defaultInt64Extension]]); | |
| 366 XCTAssertTrue([message hasExtension:[UnittestRoot defaultUint32Extension]]); | |
| 367 XCTAssertTrue([message hasExtension:[UnittestRoot defaultUint64Extension]]); | |
| 368 XCTAssertTrue([message hasExtension:[UnittestRoot defaultSint32Extension]]); | |
| 369 XCTAssertTrue([message hasExtension:[UnittestRoot defaultSint64Extension]]); | |
| 370 XCTAssertTrue([message hasExtension:[UnittestRoot defaultFixed32Extension]]); | |
| 371 XCTAssertTrue([message hasExtension:[UnittestRoot defaultFixed64Extension]]); | |
| 372 XCTAssertTrue([message hasExtension:[UnittestRoot defaultSfixed32Extension]]); | |
| 373 XCTAssertTrue([message hasExtension:[UnittestRoot defaultSfixed64Extension]]); | |
| 374 XCTAssertTrue([message hasExtension:[UnittestRoot defaultFloatExtension]]); | |
| 375 XCTAssertTrue([message hasExtension:[UnittestRoot defaultDoubleExtension]]); | |
| 376 XCTAssertTrue([message hasExtension:[UnittestRoot defaultBoolExtension]]); | |
| 377 XCTAssertTrue([message hasExtension:[UnittestRoot defaultStringExtension]]); | |
| 378 XCTAssertTrue([message hasExtension:[UnittestRoot defaultBytesExtension]]); | |
| 379 | |
| 380 XCTAssertTrue([message hasExtension:[UnittestRoot defaultNestedEnumExtension]]
); | |
| 381 XCTAssertTrue([message hasExtension:[UnittestRoot defaultForeignEnumExtension]
]); | |
| 382 XCTAssertTrue([message hasExtension:[UnittestRoot defaultImportEnumExtension]]
); | |
| 383 | |
| 384 XCTAssertTrue([message hasExtension:[UnittestRoot defaultStringPieceExtension]
]); | |
| 385 XCTAssertTrue([message hasExtension:[UnittestRoot defaultCordExtension]]); | |
| 386 | |
| 387 XCTAssertEqual(401, [[message getExtension:[UnittestRoot defaultInt32Extension
]] intValue]); | |
| 388 XCTAssertEqual(402LL, [[message getExtension:[UnittestRoot defaultInt64Extensi
on]] longLongValue]); | |
| 389 XCTAssertEqual(403U, [[message getExtension:[UnittestRoot defaultUint32Extensi
on]] unsignedIntValue]); | |
| 390 XCTAssertEqual(404ULL, [[message getExtension:[UnittestRoot defaultUint64Exten
sion]] unsignedLongLongValue]); | |
| 391 XCTAssertEqual(405, [[message getExtension:[UnittestRoot defaultSint32Extensio
n]] intValue]); | |
| 392 XCTAssertEqual(406LL, [[message getExtension:[UnittestRoot defaultSint64Extens
ion]] longLongValue]); | |
| 393 XCTAssertEqual(407U, [[message getExtension:[UnittestRoot defaultFixed32Extens
ion]] unsignedIntValue]); | |
| 394 XCTAssertEqual(408ULL, [[message getExtension:[UnittestRoot defaultFixed64Exte
nsion]] unsignedLongLongValue]); | |
| 395 XCTAssertEqual(409, [[message getExtension:[UnittestRoot defaultSfixed32Extens
ion]] intValue]); | |
| 396 XCTAssertEqual(410LL,[[message getExtension:[UnittestRoot defaultSfixed64Exten
sion]] longLongValue]); | |
| 397 XCTAssertEqualWithAccuracy(411.0f, [[message getExtension:[UnittestRoot defaul
tFloatExtension]] floatValue], 0.01); | |
| 398 XCTAssertEqualWithAccuracy(412.0, [[message getExtension:[UnittestRoot default
DoubleExtension]] doubleValue], 0.01); | |
| 399 XCTAssertFalse([[message getExtension:[UnittestRoot defaultBoolExtension]] boo
lValue]); | |
| 400 XCTAssertEqualObjects(@"415", [message getExtension:[UnittestRoot defaultStrin
gExtension]]); | |
| 401 XCTAssertEqualObjects([NSData gpbtu_dataWithUint32:416], [message getExtension
:[UnittestRoot defaultBytesExtension]]); | |
| 402 | |
| 403 XCTAssertEqual(TestAllTypes_NestedEnum_Foo, [[message getExtension:[UnittestRo
ot defaultNestedEnumExtension]] intValue]); | |
| 404 XCTAssertEqual(ForeignEnum_ForeignFoo, [[message getExtension:[UnittestRoot de
faultForeignEnumExtension]] intValue]); | |
| 405 XCTAssertEqual(ImportEnum_ImportFoo, [[message getExtension:[UnittestRoot defa
ultImportEnumExtension]] intValue]); | |
| 406 | |
| 407 XCTAssertEqualObjects(@"424", [message getExtension:[UnittestRoot defaultStrin
gPieceExtension]]); | |
| 408 XCTAssertEqualObjects(@"425", [message getExtension:[UnittestRoot defaultCordE
xtension]]); | |
| 409 } | |
| 410 | |
| 411 - (void)assertRepeatedExtensionsModified:(TestAllExtensions *)message | |
| 412 repeatedCount:(uint32_t)count { | |
| 413 // ModifyRepeatedFields only sets the second repeated element of each | |
| 414 // field. In addition to verifying this, we also verify that the first | |
| 415 // element and size were *not* modified. | |
| 416 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedInt32Extens
ion]] count]); | |
| 417 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedInt64Extens
ion]] count]); | |
| 418 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedUint32Exten
sion]] count]); | |
| 419 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedUint64Exten
sion]] count]); | |
| 420 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSint32Exten
sion]] count]); | |
| 421 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSint64Exten
sion]] count]); | |
| 422 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedFixed32Exte
nsion]] count]); | |
| 423 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedFixed64Exte
nsion]] count]); | |
| 424 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSfixed32Ext
ension]] count]); | |
| 425 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSfixed64Ext
ension]] count]); | |
| 426 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedFloatExtens
ion]] count]); | |
| 427 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedDoubleExten
sion]] count]); | |
| 428 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedBoolExtensi
on]] count]); | |
| 429 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedStringExten
sion]] count]); | |
| 430 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedBytesExtens
ion]] count]); | |
| 431 | |
| 432 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedGroupExtens
ion]] count]); | |
| 433 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedNestedMessa
geExtension]] count]); | |
| 434 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedForeignMess
ageExtension]] count]); | |
| 435 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedImportMessa
geExtension]] count]); | |
| 436 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedNestedEnumE
xtension]] count]); | |
| 437 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedForeignEnum
Extension]] count]); | |
| 438 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedImportEnumE
xtension]] count]); | |
| 439 | |
| 440 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedStringPiece
Extension]] count]); | |
| 441 XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedCordExtensi
on]] count]); | |
| 442 | |
| 443 XCTAssertEqual(201,[[message getExtension:[UnittestRoot repeatedInt32Extension
]][0] intValue]); | |
| 444 XCTAssertEqual(202LL, [[message getExtension:[UnittestRoot repeatedInt64Extens
ion]][0] longLongValue]); | |
| 445 XCTAssertEqual(203U, [[message getExtension:[UnittestRoot repeatedUint32Extens
ion]][0] unsignedIntValue]); | |
| 446 XCTAssertEqual(204ULL, [[message getExtension:[UnittestRoot repeatedUint64Exte
nsion]][0] unsignedLongLongValue]); | |
| 447 XCTAssertEqual(205, [[message getExtension:[UnittestRoot repeatedSint32Extensi
on]][0] intValue]); | |
| 448 XCTAssertEqual(206LL, [[message getExtension:[UnittestRoot repeatedSint64Exten
sion]][0] longLongValue]); | |
| 449 XCTAssertEqual(207U, [[message getExtension:[UnittestRoot repeatedFixed32Exten
sion]][0] unsignedIntValue]); | |
| 450 XCTAssertEqual(208ULL, [[message getExtension:[UnittestRoot repeatedFixed64Ext
ension]][0] unsignedLongLongValue]); | |
| 451 XCTAssertEqual(209, [[message getExtension:[UnittestRoot repeatedSfixed32Exten
sion]][0] intValue]); | |
| 452 XCTAssertEqual(210LL, [[message getExtension:[UnittestRoot repeatedSfixed64Ext
ension]][0] longLongValue]); | |
| 453 XCTAssertEqualWithAccuracy(211.0f, [[message getExtension:[UnittestRoot repeat
edFloatExtension]][0] floatValue], 0.01); | |
| 454 XCTAssertEqualWithAccuracy(212.0, [[message getExtension:[UnittestRoot repeate
dDoubleExtension]][0] doubleValue], 0.01); | |
| 455 XCTAssertFalse([[message getExtension:[UnittestRoot repeatedBoolExtension]][0]
boolValue]); | |
| 456 XCTAssertEqualObjects(@"215", [message getExtension:[UnittestRoot repeatedStri
ngExtension]][0]); | |
| 457 XCTAssertEqualObjects([NSData gpbtu_dataWithUint32:216], [message getExtension
:[UnittestRoot repeatedBytesExtension]][0]); | |
| 458 | |
| 459 XCTAssertEqual(217, [(TestAllTypes_OptionalGroup*)[message getExtension:[Unitt
estRoot repeatedGroupExtension]][0] a]); | |
| 460 XCTAssertEqual(218, [(TestAllTypes_NestedMessage*)[message getExtension:[Unitt
estRoot repeatedNestedMessageExtension]][0] bb]); | |
| 461 XCTAssertEqual(219, [[message getExtension:[UnittestRoot repeatedForeignMessag
eExtension]][0] c]); | |
| 462 XCTAssertEqual(220, [[message getExtension:[UnittestRoot repeatedImportMessage
Extension]][0] d]); | |
| 463 | |
| 464 XCTAssertEqual(TestAllTypes_NestedEnum_Baz, | |
| 465 [[message getExtension:[UnittestRoot repeatedNestedEnumExtensio
n]][0] intValue]); | |
| 466 XCTAssertEqual(ForeignEnum_ForeignBaz, | |
| 467 [[message getExtension:[UnittestRoot repeatedForeignEnumExtensi
on]][0] intValue]); | |
| 468 XCTAssertEqual(ImportEnum_ImportBaz, | |
| 469 [[message getExtension:[UnittestRoot repeatedImportEnumExtensio
n]][0] intValue]); | |
| 470 | |
| 471 XCTAssertEqualObjects(@"224", [message getExtension:[UnittestRoot repeatedStri
ngPieceExtension]][0]); | |
| 472 XCTAssertEqualObjects(@"225", [message getExtension:[UnittestRoot repeatedCord
Extension]][0]); | |
| 473 | |
| 474 // Actually verify the second (modified) elements now. | |
| 475 XCTAssertEqual(501, [[message getExtension:[UnittestRoot repeatedInt32Extensio
n]][1] intValue]); | |
| 476 XCTAssertEqual(502LL, [[message getExtension:[UnittestRoot repeatedInt64Extens
ion]][1] longLongValue]); | |
| 477 XCTAssertEqual(503U, [[message getExtension:[UnittestRoot repeatedUint32Extens
ion]][1] unsignedIntValue]); | |
| 478 XCTAssertEqual(504ULL, [[message getExtension:[UnittestRoot repeatedUint64Exte
nsion]][1] unsignedLongLongValue]); | |
| 479 XCTAssertEqual(505, [[message getExtension:[UnittestRoot repeatedSint32Extensi
on]][1] intValue]); | |
| 480 XCTAssertEqual(506LL, [[message getExtension:[UnittestRoot repeatedSint64Exten
sion]][1] longLongValue]); | |
| 481 XCTAssertEqual(507U, [[message getExtension:[UnittestRoot repeatedFixed32Exten
sion]][1] unsignedIntValue]); | |
| 482 XCTAssertEqual(508ULL, [[message getExtension:[UnittestRoot repeatedFixed64Ext
ension]][1] unsignedLongLongValue]); | |
| 483 XCTAssertEqual(509, [[message getExtension:[UnittestRoot repeatedSfixed32Exten
sion]][1] intValue]); | |
| 484 XCTAssertEqual(510LL, [[message getExtension:[UnittestRoot repeatedSfixed64Ext
ension]][1] longLongValue]); | |
| 485 XCTAssertEqualWithAccuracy(511.0f, [[message getExtension:[UnittestRoot repeat
edFloatExtension]][1] floatValue], 0.01); | |
| 486 XCTAssertEqualWithAccuracy(512.0, [[message getExtension:[UnittestRoot repeate
dDoubleExtension]][1] doubleValue], 0.01); | |
| 487 XCTAssertTrue([[message getExtension:[UnittestRoot repeatedBoolExtension]][1]
boolValue]); | |
| 488 XCTAssertEqualObjects(@"515", [message getExtension:[UnittestRoot repeatedStri
ngExtension]][1]); | |
| 489 XCTAssertEqualObjects([NSData gpbtu_dataWithUint32:516], [message getExtension
:[UnittestRoot repeatedBytesExtension]][1]); | |
| 490 | |
| 491 XCTAssertEqual(517, [(TestAllTypes_OptionalGroup*)[message getExtension:[Unitt
estRoot repeatedGroupExtension]][1] a]); | |
| 492 XCTAssertEqual(518, [(TestAllTypes_NestedMessage*)[message getExtension:[Unitt
estRoot repeatedNestedMessageExtension]][1] bb]); | |
| 493 XCTAssertEqual(519, [[message getExtension:[UnittestRoot repeatedForeignMessag
eExtension]][1] c]); | |
| 494 XCTAssertEqual(520, [[message getExtension:[UnittestRoot repeatedImportMessage
Extension]][1] d]); | |
| 495 | |
| 496 XCTAssertEqual(TestAllTypes_NestedEnum_Foo, | |
| 497 [[message getExtension:[UnittestRoot repeatedNestedEnumExtensio
n]][1] intValue]); | |
| 498 XCTAssertEqual(ForeignEnum_ForeignFoo, | |
| 499 [[message getExtension:[UnittestRoot repeatedForeignEnumExtensi
on]][1] intValue]); | |
| 500 XCTAssertEqual(ImportEnum_ImportFoo, | |
| 501 [[message getExtension:[UnittestRoot repeatedImportEnumExtensio
n]][1] intValue]); | |
| 502 | |
| 503 XCTAssertEqualObjects(@"524", [message getExtension:[UnittestRoot repeatedStri
ngPieceExtension]][1]); | |
| 504 XCTAssertEqualObjects(@"525", [message getExtension:[UnittestRoot repeatedCord
Extension]][1]); | |
| 505 } | |
| 506 | |
| 507 // ------------------------------------------------------------------- | |
| 508 | |
| 509 - (void)assertAllFieldsSet:(TestAllTypes *)message | |
| 510 repeatedCount:(uint32_t)count { | |
| 511 XCTAssertTrue(message.hasOptionalInt32); | |
| 512 XCTAssertTrue(message.hasOptionalInt64); | |
| 513 XCTAssertTrue(message.hasOptionalUint32); | |
| 514 XCTAssertTrue(message.hasOptionalUint64); | |
| 515 XCTAssertTrue(message.hasOptionalSint32); | |
| 516 XCTAssertTrue(message.hasOptionalSint64); | |
| 517 XCTAssertTrue(message.hasOptionalFixed32); | |
| 518 XCTAssertTrue(message.hasOptionalFixed64); | |
| 519 XCTAssertTrue(message.hasOptionalSfixed32); | |
| 520 XCTAssertTrue(message.hasOptionalSfixed64); | |
| 521 XCTAssertTrue(message.hasOptionalFloat); | |
| 522 XCTAssertTrue(message.hasOptionalDouble); | |
| 523 XCTAssertTrue(message.hasOptionalBool); | |
| 524 XCTAssertTrue(message.hasOptionalString); | |
| 525 XCTAssertTrue(message.hasOptionalBytes); | |
| 526 | |
| 527 XCTAssertTrue(message.hasOptionalGroup); | |
| 528 XCTAssertTrue(message.hasOptionalNestedMessage); | |
| 529 XCTAssertTrue(message.hasOptionalForeignMessage); | |
| 530 XCTAssertTrue(message.hasOptionalImportMessage); | |
| 531 | |
| 532 XCTAssertTrue(message.optionalGroup.hasA); | |
| 533 XCTAssertTrue(message.optionalNestedMessage.hasBb); | |
| 534 XCTAssertTrue(message.optionalForeignMessage.hasC); | |
| 535 XCTAssertTrue(message.optionalImportMessage.hasD); | |
| 536 | |
| 537 XCTAssertTrue(message.hasOptionalNestedEnum); | |
| 538 XCTAssertTrue(message.hasOptionalForeignEnum); | |
| 539 XCTAssertTrue(message.hasOptionalImportEnum); | |
| 540 | |
| 541 XCTAssertTrue(message.hasOptionalStringPiece); | |
| 542 XCTAssertTrue(message.hasOptionalCord); | |
| 543 | |
| 544 XCTAssertEqual(101, message.optionalInt32); | |
| 545 XCTAssertEqual(102LL, message.optionalInt64); | |
| 546 XCTAssertEqual(103U, message.optionalUint32); | |
| 547 XCTAssertEqual(104ULL, message.optionalUint64); | |
| 548 XCTAssertEqual(105, message.optionalSint32); | |
| 549 XCTAssertEqual(106LL, message.optionalSint64); | |
| 550 XCTAssertEqual(107U, message.optionalFixed32); | |
| 551 XCTAssertEqual(108ULL, message.optionalFixed64); | |
| 552 XCTAssertEqual(109, message.optionalSfixed32); | |
| 553 XCTAssertEqual(110LL, message.optionalSfixed64); | |
| 554 XCTAssertEqualWithAccuracy(111.0f, message.optionalFloat, 0.1); | |
| 555 XCTAssertEqualWithAccuracy(112.0, message.optionalDouble, 0.1); | |
| 556 XCTAssertTrue(message.optionalBool); | |
| 557 XCTAssertEqualObjects(@"115", message.optionalString); | |
| 558 XCTAssertEqualObjects([NSData gpbtu_dataWithEmbeddedNulls], | |
| 559 message.optionalBytes); | |
| 560 | |
| 561 XCTAssertEqual(117, message.optionalGroup.a); | |
| 562 XCTAssertEqual(118, message.optionalNestedMessage.bb); | |
| 563 XCTAssertEqual(119, message.optionalForeignMessage.c); | |
| 564 XCTAssertEqual(120, message.optionalImportMessage.d); | |
| 565 | |
| 566 XCTAssertEqual(TestAllTypes_NestedEnum_Baz, message.optionalNestedEnum); | |
| 567 XCTAssertEqual(ForeignEnum_ForeignBaz, message.optionalForeignEnum); | |
| 568 XCTAssertEqual(ImportEnum_ImportBaz, message.optionalImportEnum); | |
| 569 | |
| 570 XCTAssertEqualObjects(@"124", message.optionalStringPiece); | |
| 571 XCTAssertEqualObjects(@"125", message.optionalCord); | |
| 572 | |
| 573 // ----------------------------------------------------------------- | |
| 574 | |
| 575 XCTAssertEqual(count, message.repeatedInt32Array.count); | |
| 576 XCTAssertEqual(count, message.repeatedInt64Array.count); | |
| 577 XCTAssertEqual(count, message.repeatedUint32Array.count); | |
| 578 XCTAssertEqual(count, message.repeatedUint64Array.count); | |
| 579 XCTAssertEqual(count, message.repeatedSint32Array.count); | |
| 580 XCTAssertEqual(count, message.repeatedSint64Array.count); | |
| 581 XCTAssertEqual(count, message.repeatedFixed32Array.count); | |
| 582 XCTAssertEqual(count, message.repeatedFixed64Array.count); | |
| 583 XCTAssertEqual(count, message.repeatedSfixed32Array.count); | |
| 584 XCTAssertEqual(count, message.repeatedSfixed64Array.count); | |
| 585 XCTAssertEqual(count, message.repeatedFloatArray.count); | |
| 586 XCTAssertEqual(count, message.repeatedDoubleArray.count); | |
| 587 XCTAssertEqual(count, message.repeatedBoolArray.count); | |
| 588 XCTAssertEqual(count, message.repeatedStringArray.count); | |
| 589 XCTAssertEqual(count, message.repeatedBytesArray.count); | |
| 590 | |
| 591 XCTAssertEqual(count, message.repeatedGroupArray.count); | |
| 592 XCTAssertEqual(count, message.repeatedNestedMessageArray.count); | |
| 593 XCTAssertEqual(count, message.repeatedForeignMessageArray.count); | |
| 594 XCTAssertEqual(count, message.repeatedImportMessageArray.count); | |
| 595 XCTAssertEqual(count, message.repeatedNestedEnumArray.count); | |
| 596 XCTAssertEqual(count, message.repeatedForeignEnumArray.count); | |
| 597 XCTAssertEqual(count, message.repeatedImportEnumArray.count); | |
| 598 | |
| 599 XCTAssertEqual(count, message.repeatedStringPieceArray.count); | |
| 600 XCTAssertEqual(count, message.repeatedCordArray.count); | |
| 601 | |
| 602 XCTAssertEqual(count, message.repeatedInt32Array_Count); | |
| 603 XCTAssertEqual(count, message.repeatedInt64Array_Count); | |
| 604 XCTAssertEqual(count, message.repeatedUint32Array_Count); | |
| 605 XCTAssertEqual(count, message.repeatedUint64Array_Count); | |
| 606 XCTAssertEqual(count, message.repeatedSint32Array_Count); | |
| 607 XCTAssertEqual(count, message.repeatedSint64Array_Count); | |
| 608 XCTAssertEqual(count, message.repeatedFixed32Array_Count); | |
| 609 XCTAssertEqual(count, message.repeatedFixed64Array_Count); | |
| 610 XCTAssertEqual(count, message.repeatedSfixed32Array_Count); | |
| 611 XCTAssertEqual(count, message.repeatedSfixed64Array_Count); | |
| 612 XCTAssertEqual(count, message.repeatedFloatArray_Count); | |
| 613 XCTAssertEqual(count, message.repeatedDoubleArray_Count); | |
| 614 XCTAssertEqual(count, message.repeatedBoolArray_Count); | |
| 615 XCTAssertEqual(count, message.repeatedStringArray_Count); | |
| 616 XCTAssertEqual(count, message.repeatedBytesArray_Count); | |
| 617 | |
| 618 XCTAssertEqual(count, message.repeatedGroupArray_Count); | |
| 619 XCTAssertEqual(count, message.repeatedNestedMessageArray_Count); | |
| 620 XCTAssertEqual(count, message.repeatedForeignMessageArray_Count); | |
| 621 XCTAssertEqual(count, message.repeatedImportMessageArray_Count); | |
| 622 XCTAssertEqual(count, message.repeatedNestedEnumArray_Count); | |
| 623 XCTAssertEqual(count, message.repeatedForeignEnumArray_Count); | |
| 624 XCTAssertEqual(count, message.repeatedImportEnumArray_Count); | |
| 625 | |
| 626 XCTAssertEqual(count, message.repeatedStringPieceArray_Count); | |
| 627 XCTAssertEqual(count, message.repeatedCordArray_Count); | |
| 628 | |
| 629 for (uint32_t i = 0; i < count; ++i) { | |
| 630 XCTAssertEqual((int)(201 + i * 100), | |
| 631 [message.repeatedInt32Array valueAtIndex:i]); | |
| 632 XCTAssertEqual(202 + i * 100, [message.repeatedInt64Array valueAtIndex:i]); | |
| 633 XCTAssertEqual(203 + i * 100, [message.repeatedUint32Array valueAtIndex:i]); | |
| 634 XCTAssertEqual(204 + i * 100, [message.repeatedUint64Array valueAtIndex:i]); | |
| 635 XCTAssertEqual((int)(205 + i * 100), | |
| 636 [message.repeatedSint32Array valueAtIndex:i]); | |
| 637 XCTAssertEqual(206 + i * 100, [message.repeatedSint64Array valueAtIndex:i]); | |
| 638 XCTAssertEqual(207 + i * 100, | |
| 639 [message.repeatedFixed32Array valueAtIndex:i]); | |
| 640 XCTAssertEqual(208 + i * 100, | |
| 641 [message.repeatedFixed64Array valueAtIndex:i]); | |
| 642 XCTAssertEqual((int)(209 + i * 100), | |
| 643 [message.repeatedSfixed32Array valueAtIndex:i]); | |
| 644 XCTAssertEqual(210 + i * 100, | |
| 645 [message.repeatedSfixed64Array valueAtIndex:i]); | |
| 646 XCTAssertEqualWithAccuracy( | |
| 647 211 + i * 100, [message.repeatedFloatArray valueAtIndex:i], 0.1); | |
| 648 XCTAssertEqualWithAccuracy( | |
| 649 212 + i * 100, [message.repeatedDoubleArray valueAtIndex:i], 0.1); | |
| 650 XCTAssertEqual((i % 2) ? YES : NO, | |
| 651 [message.repeatedBoolArray valueAtIndex:i]); | |
| 652 | |
| 653 NSString *string = [[NSString alloc] initWithFormat:@"%d", 215 + i * 100]; | |
| 654 XCTAssertEqualObjects(string, message.repeatedStringArray[i]); | |
| 655 [string release]; | |
| 656 | |
| 657 NSData *data = [[NSData alloc] initWithUint32_gpbtu:216 + i * 100]; | |
| 658 XCTAssertEqualObjects(data, message.repeatedBytesArray[i]); | |
| 659 [data release]; | |
| 660 | |
| 661 XCTAssertEqual((int)(217 + i * 100), ((TestAllTypes_RepeatedGroup*)message.r
epeatedGroupArray[i]).a); | |
| 662 XCTAssertEqual((int)(218 + i * 100), ((TestAllTypes_NestedMessage*)message.r
epeatedNestedMessageArray[i]).bb); | |
| 663 XCTAssertEqual((int)(219 + i * 100), ((ForeignMessage*)message.repeatedForei
gnMessageArray[i]).c); | |
| 664 XCTAssertEqual((int)(220 + i * 100), ((ImportMessage*)message.repeatedImport
MessageArray[i]).d); | |
| 665 | |
| 666 XCTAssertEqual((i % 2) ? TestAllTypes_NestedEnum_Bar : TestAllTypes_NestedEn
um_Baz, [message.repeatedNestedEnumArray valueAtIndex:i]); | |
| 667 XCTAssertEqual((i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz, [m
essage.repeatedForeignEnumArray valueAtIndex:i]); | |
| 668 XCTAssertEqual((i % 2) ? ImportEnum_ImportBar : ImportEnum_ImportBaz, [messa
ge.repeatedImportEnumArray valueAtIndex:i]); | |
| 669 | |
| 670 string = [[NSString alloc] initWithFormat:@"%d", 224 + i * 100]; | |
| 671 XCTAssertEqualObjects(string, message.repeatedStringPieceArray[i]); | |
| 672 [string release]; | |
| 673 | |
| 674 string = [[NSString alloc] initWithFormat:@"%d", 225 + i * 100]; | |
| 675 XCTAssertEqualObjects(string, message.repeatedCordArray[i]); | |
| 676 [string release]; | |
| 677 } | |
| 678 | |
| 679 // ----------------------------------------------------------------- | |
| 680 | |
| 681 XCTAssertTrue(message.hasDefaultInt32); | |
| 682 XCTAssertTrue(message.hasDefaultInt64); | |
| 683 XCTAssertTrue(message.hasDefaultUint32); | |
| 684 XCTAssertTrue(message.hasDefaultUint64); | |
| 685 XCTAssertTrue(message.hasDefaultSint32); | |
| 686 XCTAssertTrue(message.hasDefaultSint64); | |
| 687 XCTAssertTrue(message.hasDefaultFixed32); | |
| 688 XCTAssertTrue(message.hasDefaultFixed64); | |
| 689 XCTAssertTrue(message.hasDefaultSfixed32); | |
| 690 XCTAssertTrue(message.hasDefaultSfixed64); | |
| 691 XCTAssertTrue(message.hasDefaultFloat); | |
| 692 XCTAssertTrue(message.hasDefaultDouble); | |
| 693 XCTAssertTrue(message.hasDefaultBool); | |
| 694 XCTAssertTrue(message.hasDefaultString); | |
| 695 XCTAssertTrue(message.hasDefaultBytes); | |
| 696 | |
| 697 XCTAssertTrue(message.hasDefaultNestedEnum); | |
| 698 XCTAssertTrue(message.hasDefaultForeignEnum); | |
| 699 XCTAssertTrue(message.hasDefaultImportEnum); | |
| 700 | |
| 701 XCTAssertTrue(message.hasDefaultStringPiece); | |
| 702 XCTAssertTrue(message.hasDefaultCord); | |
| 703 | |
| 704 XCTAssertEqual(401, message.defaultInt32); | |
| 705 XCTAssertEqual(402LL, message.defaultInt64); | |
| 706 XCTAssertEqual(403U, message.defaultUint32); | |
| 707 XCTAssertEqual(404ULL, message.defaultUint64); | |
| 708 XCTAssertEqual(405, message.defaultSint32); | |
| 709 XCTAssertEqual(406LL, message.defaultSint64); | |
| 710 XCTAssertEqual(407U, message.defaultFixed32); | |
| 711 XCTAssertEqual(408ULL, message.defaultFixed64); | |
| 712 XCTAssertEqual(409, message.defaultSfixed32); | |
| 713 XCTAssertEqual(410LL, message.defaultSfixed64); | |
| 714 XCTAssertEqualWithAccuracy(411.0f, message.defaultFloat, 0.1); | |
| 715 XCTAssertEqualWithAccuracy(412.0, message.defaultDouble, 0.1); | |
| 716 XCTAssertFalse(message.defaultBool); | |
| 717 XCTAssertEqualObjects(@"415", message.defaultString); | |
| 718 XCTAssertEqualObjects([NSData gpbtu_dataWithUint32:416], | |
| 719 message.defaultBytes); | |
| 720 | |
| 721 XCTAssertEqual(TestAllTypes_NestedEnum_Foo, message.defaultNestedEnum); | |
| 722 XCTAssertEqual(ForeignEnum_ForeignFoo, message.defaultForeignEnum); | |
| 723 XCTAssertEqual(ImportEnum_ImportFoo, message.defaultImportEnum); | |
| 724 | |
| 725 XCTAssertEqualObjects(@"424", message.defaultStringPiece); | |
| 726 XCTAssertEqualObjects(@"425", message.defaultCord); | |
| 727 } | |
| 728 | |
| 729 - (void)setAllFields:(TestAllTypes *)message repeatedCount:(uint32_t)count { | |
| 730 [message setOptionalInt32:101]; | |
| 731 [message setOptionalInt64:102]; | |
| 732 [message setOptionalUint32:103]; | |
| 733 [message setOptionalUint64:104]; | |
| 734 [message setOptionalSint32:105]; | |
| 735 [message setOptionalSint64:106]; | |
| 736 [message setOptionalFixed32:107]; | |
| 737 [message setOptionalFixed64:108]; | |
| 738 [message setOptionalSfixed32:109]; | |
| 739 [message setOptionalSfixed64:110]; | |
| 740 [message setOptionalFloat:111]; | |
| 741 [message setOptionalDouble:112]; | |
| 742 [message setOptionalBool:YES]; | |
| 743 [message setOptionalString:@"115"]; | |
| 744 [message setOptionalBytes:[NSData gpbtu_dataWithEmbeddedNulls]]; | |
| 745 | |
| 746 TestAllTypes_OptionalGroup *allTypes = [TestAllTypes_OptionalGroup message]; | |
| 747 [allTypes setA:117]; | |
| 748 [message setOptionalGroup:allTypes]; | |
| 749 TestAllTypes_NestedMessage *nestedMessage = | |
| 750 [TestAllTypes_NestedMessage message]; | |
| 751 [nestedMessage setBb:118]; | |
| 752 [message setOptionalNestedMessage:nestedMessage]; | |
| 753 ForeignMessage *foreignMessage = [ForeignMessage message]; | |
| 754 [foreignMessage setC:119]; | |
| 755 [message setOptionalForeignMessage:foreignMessage]; | |
| 756 ImportMessage *importMessage = [ImportMessage message]; | |
| 757 [importMessage setD:120]; | |
| 758 [message setOptionalImportMessage:importMessage]; | |
| 759 | |
| 760 [message setOptionalNestedEnum:TestAllTypes_NestedEnum_Baz]; | |
| 761 [message setOptionalForeignEnum:ForeignEnum_ForeignBaz]; | |
| 762 [message setOptionalImportEnum:ImportEnum_ImportBaz]; | |
| 763 | |
| 764 [message setOptionalStringPiece:@"124"]; | |
| 765 [message setOptionalCord:@"125"]; | |
| 766 | |
| 767 // ----------------------------------------------------------------- | |
| 768 | |
| 769 for (uint32_t i = 0; i < count; i++) { | |
| 770 [message.repeatedInt32Array addValue:201 + i * 100]; | |
| 771 [message.repeatedInt64Array addValue:202 + i * 100]; | |
| 772 [message.repeatedUint32Array addValue:203 + i * 100]; | |
| 773 [message.repeatedUint64Array addValue:204 + i * 100]; | |
| 774 [message.repeatedSint32Array addValue:205 + i * 100]; | |
| 775 [message.repeatedSint64Array addValue:206 + i * 100]; | |
| 776 [message.repeatedFixed32Array addValue:207 + i * 100]; | |
| 777 [message.repeatedFixed64Array addValue:208 + i * 100]; | |
| 778 [message.repeatedSfixed32Array addValue:209 + i * 100]; | |
| 779 [message.repeatedSfixed64Array addValue:210 + i * 100]; | |
| 780 [message.repeatedFloatArray addValue:211 + i * 100]; | |
| 781 [message.repeatedDoubleArray addValue:212 + i * 100]; | |
| 782 [message.repeatedBoolArray addValue:(i % 2)]; | |
| 783 NSString *string = [[NSString alloc] initWithFormat:@"%d", 215 + i * 100]; | |
| 784 [message.repeatedStringArray addObject:string]; | |
| 785 [string release]; | |
| 786 | |
| 787 NSData *data = [[NSData alloc] initWithUint32_gpbtu:216 + i * 100]; | |
| 788 [message.repeatedBytesArray addObject:data]; | |
| 789 [data release]; | |
| 790 | |
| 791 TestAllTypes_RepeatedGroup *testAll = | |
| 792 [[TestAllTypes_RepeatedGroup alloc] init]; | |
| 793 [testAll setA:217 + i * 100]; | |
| 794 [message.repeatedGroupArray addObject:testAll]; | |
| 795 [testAll release]; | |
| 796 | |
| 797 nestedMessage = [[TestAllTypes_NestedMessage alloc] init]; | |
| 798 [nestedMessage setBb:218 + i * 100]; | |
| 799 [message.repeatedNestedMessageArray addObject:nestedMessage]; | |
| 800 [nestedMessage release]; | |
| 801 | |
| 802 foreignMessage = [[ForeignMessage alloc] init]; | |
| 803 [foreignMessage setC:219 + i * 100]; | |
| 804 [message.repeatedForeignMessageArray addObject:foreignMessage]; | |
| 805 [foreignMessage release]; | |
| 806 | |
| 807 importMessage = [[ImportMessage alloc] init]; | |
| 808 [importMessage setD:220 + i * 100]; | |
| 809 [message.repeatedImportMessageArray addObject:importMessage]; | |
| 810 [importMessage release]; | |
| 811 | |
| 812 [message.repeatedNestedEnumArray addValue:(i % 2) ? TestAllTypes_NestedEnum_
Bar : TestAllTypes_NestedEnum_Baz]; | |
| 813 | |
| 814 [message.repeatedForeignEnumArray addValue:(i % 2) ? ForeignEnum_ForeignBar
: ForeignEnum_ForeignBaz]; | |
| 815 [message.repeatedImportEnumArray addValue:(i % 2) ? ImportEnum_ImportBar : I
mportEnum_ImportBaz]; | |
| 816 | |
| 817 string = [[NSString alloc] initWithFormat:@"%d", 224 + i * 100]; | |
| 818 [message.repeatedStringPieceArray addObject:string]; | |
| 819 [string release]; | |
| 820 | |
| 821 string = [[NSString alloc] initWithFormat:@"%d", 225 + i * 100]; | |
| 822 [message.repeatedCordArray addObject:string]; | |
| 823 [string release]; | |
| 824 } | |
| 825 // ----------------------------------------------------------------- | |
| 826 | |
| 827 message.defaultInt32 = 401; | |
| 828 message.defaultInt64 = 402; | |
| 829 message.defaultUint32 = 403; | |
| 830 message.defaultUint64 = 404; | |
| 831 message.defaultSint32 = 405; | |
| 832 message.defaultSint64 = 406; | |
| 833 message.defaultFixed32 = 407; | |
| 834 message.defaultFixed64 = 408; | |
| 835 message.defaultSfixed32 = 409; | |
| 836 message.defaultSfixed64 = 410; | |
| 837 message.defaultFloat = 411; | |
| 838 message.defaultDouble = 412; | |
| 839 message.defaultBool = NO; | |
| 840 message.defaultString = @"415"; | |
| 841 message.defaultBytes = [NSData gpbtu_dataWithUint32:416]; | |
| 842 | |
| 843 message.defaultNestedEnum = TestAllTypes_NestedEnum_Foo; | |
| 844 message.defaultForeignEnum = ForeignEnum_ForeignFoo; | |
| 845 message.defaultImportEnum = ImportEnum_ImportFoo; | |
| 846 | |
| 847 message.defaultStringPiece = @"424"; | |
| 848 message.defaultCord = @"425"; | |
| 849 } | |
| 850 | |
| 851 - (void)clearAllFields:(TestAllTypes *)message { | |
| 852 message.hasOptionalInt32 = NO; | |
| 853 message.hasOptionalInt64 = NO; | |
| 854 message.hasOptionalUint32 = NO; | |
| 855 message.hasOptionalUint64 = NO; | |
| 856 message.hasOptionalSint32 = NO; | |
| 857 message.hasOptionalSint64 = NO; | |
| 858 message.hasOptionalFixed32 = NO; | |
| 859 message.hasOptionalFixed64 = NO; | |
| 860 message.hasOptionalSfixed32 = NO; | |
| 861 message.hasOptionalSfixed64 = NO; | |
| 862 message.hasOptionalFloat = NO; | |
| 863 message.hasOptionalDouble = NO; | |
| 864 message.hasOptionalBool = NO; | |
| 865 message.hasOptionalString = NO; | |
| 866 message.hasOptionalBytes = NO; | |
| 867 | |
| 868 message.hasOptionalGroup = NO; | |
| 869 message.hasOptionalNestedMessage = NO; | |
| 870 message.hasOptionalForeignMessage = NO; | |
| 871 message.hasOptionalImportMessage = NO; | |
| 872 | |
| 873 message.hasOptionalNestedEnum = NO; | |
| 874 message.hasOptionalForeignEnum = NO; | |
| 875 message.hasOptionalImportEnum = NO; | |
| 876 | |
| 877 message.hasOptionalStringPiece = NO; | |
| 878 message.hasOptionalCord = NO; | |
| 879 | |
| 880 // ----------------------------------------------------------------- | |
| 881 | |
| 882 [message.repeatedInt32Array removeAll]; | |
| 883 [message.repeatedInt64Array removeAll]; | |
| 884 [message.repeatedUint32Array removeAll]; | |
| 885 [message.repeatedUint64Array removeAll]; | |
| 886 [message.repeatedSint32Array removeAll]; | |
| 887 [message.repeatedSint64Array removeAll]; | |
| 888 [message.repeatedFixed32Array removeAll]; | |
| 889 [message.repeatedFixed64Array removeAll]; | |
| 890 [message.repeatedSfixed32Array removeAll]; | |
| 891 [message.repeatedSfixed64Array removeAll]; | |
| 892 [message.repeatedFloatArray removeAll]; | |
| 893 [message.repeatedDoubleArray removeAll]; | |
| 894 [message.repeatedBoolArray removeAll]; | |
| 895 [message.repeatedStringArray removeAllObjects]; | |
| 896 [message.repeatedBytesArray removeAllObjects]; | |
| 897 | |
| 898 [message.repeatedGroupArray removeAllObjects]; | |
| 899 [message.repeatedNestedMessageArray removeAllObjects]; | |
| 900 [message.repeatedForeignMessageArray removeAllObjects]; | |
| 901 [message.repeatedImportMessageArray removeAllObjects]; | |
| 902 | |
| 903 [message.repeatedNestedEnumArray removeAll]; | |
| 904 [message.repeatedForeignEnumArray removeAll]; | |
| 905 [message.repeatedImportEnumArray removeAll]; | |
| 906 | |
| 907 [message.repeatedStringPieceArray removeAllObjects]; | |
| 908 [message.repeatedCordArray removeAllObjects]; | |
| 909 | |
| 910 // ----------------------------------------------------------------- | |
| 911 | |
| 912 message.hasDefaultInt32 = NO; | |
| 913 message.hasDefaultInt64 = NO; | |
| 914 message.hasDefaultUint32 = NO; | |
| 915 message.hasDefaultUint64 = NO; | |
| 916 message.hasDefaultSint32 = NO; | |
| 917 message.hasDefaultSint64 = NO; | |
| 918 message.hasDefaultFixed32 = NO; | |
| 919 message.hasDefaultFixed64 = NO; | |
| 920 message.hasDefaultSfixed32 = NO; | |
| 921 message.hasDefaultSfixed64 = NO; | |
| 922 message.hasDefaultFloat = NO; | |
| 923 message.hasDefaultDouble = NO; | |
| 924 message.hasDefaultBool = NO; | |
| 925 message.hasDefaultString = NO; | |
| 926 message.hasDefaultBytes = NO; | |
| 927 | |
| 928 message.hasDefaultNestedEnum = NO; | |
| 929 message.hasDefaultForeignEnum = NO; | |
| 930 message.hasDefaultImportEnum = NO; | |
| 931 | |
| 932 message.hasDefaultStringPiece = NO; | |
| 933 message.hasDefaultCord = NO; | |
| 934 } | |
| 935 | |
| 936 - (void)setAllExtensions:(TestAllExtensions *)message | |
| 937 repeatedCount:(uint32_t)count { | |
| 938 [message setExtension:[UnittestRoot optionalInt32Extension] value:@101]; | |
| 939 [message setExtension:[UnittestRoot optionalInt64Extension] value:@102L]; | |
| 940 [message setExtension:[UnittestRoot optionalUint32Extension] value:@103]; | |
| 941 [message setExtension:[UnittestRoot optionalUint64Extension] value:@104L]; | |
| 942 [message setExtension:[UnittestRoot optionalSint32Extension] value:@105]; | |
| 943 [message setExtension:[UnittestRoot optionalSint64Extension] value:@106L]; | |
| 944 [message setExtension:[UnittestRoot optionalFixed32Extension] value:@107]; | |
| 945 [message setExtension:[UnittestRoot optionalFixed64Extension] value:@108L]; | |
| 946 [message setExtension:[UnittestRoot optionalSfixed32Extension] value:@109]; | |
| 947 [message setExtension:[UnittestRoot optionalSfixed64Extension] value:@110L]; | |
| 948 [message setExtension:[UnittestRoot optionalFloatExtension] value:@111.0f]; | |
| 949 [message setExtension:[UnittestRoot optionalDoubleExtension] value:@112.0]; | |
| 950 [message setExtension:[UnittestRoot optionalBoolExtension] value:@YES]; | |
| 951 [message setExtension:[UnittestRoot optionalStringExtension] value:@"115"]; | |
| 952 [message setExtension:[UnittestRoot optionalBytesExtension] | |
| 953 value:[NSData gpbtu_dataWithEmbeddedNulls]]; | |
| 954 | |
| 955 OptionalGroup_extension *optionalGroup = [OptionalGroup_extension message]; | |
| 956 [optionalGroup setA:117]; | |
| 957 [message setExtension:[UnittestRoot optionalGroupExtension] | |
| 958 value:optionalGroup]; | |
| 959 TestAllTypes_NestedMessage *nestedMessage = | |
| 960 [TestAllTypes_NestedMessage message]; | |
| 961 [nestedMessage setBb:118]; | |
| 962 [message setExtension:[UnittestRoot optionalNestedMessageExtension] | |
| 963 value:nestedMessage]; | |
| 964 ForeignMessage *foreignMessage = [ForeignMessage message]; | |
| 965 [foreignMessage setC:119]; | |
| 966 [message setExtension:[UnittestRoot optionalForeignMessageExtension] | |
| 967 value:foreignMessage]; | |
| 968 ImportMessage *importMessage = [ImportMessage message]; | |
| 969 [importMessage setD:120]; | |
| 970 [message setExtension:[UnittestRoot optionalImportMessageExtension] | |
| 971 value:importMessage]; | |
| 972 | |
| 973 [message setExtension:[UnittestRoot optionalNestedEnumExtension] | |
| 974 value:@(TestAllTypes_NestedEnum_Baz)]; | |
| 975 [message setExtension:[UnittestRoot optionalForeignEnumExtension] | |
| 976 value:@(ForeignEnum_ForeignBaz)]; | |
| 977 [message setExtension:[UnittestRoot optionalImportEnumExtension] | |
| 978 value:@(ImportEnum_ImportBaz)]; | |
| 979 | |
| 980 [message setExtension:[UnittestRoot optionalStringPieceExtension] | |
| 981 value:@"124"]; | |
| 982 [message setExtension:[UnittestRoot optionalCordExtension] value:@"125"]; | |
| 983 | |
| 984 for (uint32_t i = 0; i < count; ++i) { | |
| 985 [message addExtension:[UnittestRoot repeatedInt32Extension] | |
| 986 value:@(201 + i * 100)]; | |
| 987 [message addExtension:[UnittestRoot repeatedInt64Extension] | |
| 988 value:@(202 + i * 100)]; | |
| 989 [message addExtension:[UnittestRoot repeatedUint32Extension] | |
| 990 value:@(203 + i * 100)]; | |
| 991 [message addExtension:[UnittestRoot repeatedUint64Extension] | |
| 992 value:@(204 + i * 100)]; | |
| 993 [message addExtension:[UnittestRoot repeatedSint32Extension] | |
| 994 value:@(205 + i * 100)]; | |
| 995 [message addExtension:[UnittestRoot repeatedSint64Extension] | |
| 996 value:@(206 + i * 100)]; | |
| 997 [message addExtension:[UnittestRoot repeatedFixed32Extension] | |
| 998 value:@(207 + i * 100)]; | |
| 999 [message addExtension:[UnittestRoot repeatedFixed64Extension] | |
| 1000 value:@(208 + i * 100)]; | |
| 1001 [message addExtension:[UnittestRoot repeatedSfixed32Extension] | |
| 1002 value:@(209 + i * 100)]; | |
| 1003 [message addExtension:[UnittestRoot repeatedSfixed64Extension] | |
| 1004 value:@(210 + i * 100)]; | |
| 1005 [message addExtension:[UnittestRoot repeatedFloatExtension] | |
| 1006 value:@(211 + i * 100)]; | |
| 1007 [message addExtension:[UnittestRoot repeatedDoubleExtension] | |
| 1008 value:@(212 + i * 100)]; | |
| 1009 [message addExtension:[UnittestRoot repeatedBoolExtension] | |
| 1010 value:@((i % 2) ? YES : NO)]; | |
| 1011 NSString *string = [[NSString alloc] initWithFormat:@"%d", 215 + i * 100]; | |
| 1012 [message addExtension:[UnittestRoot repeatedStringExtension] value:string]; | |
| 1013 [string release]; | |
| 1014 NSData *data = [[NSData alloc] initWithUint32_gpbtu:216 + i * 100]; | |
| 1015 [message addExtension:[UnittestRoot repeatedBytesExtension] value:data]; | |
| 1016 [data release]; | |
| 1017 | |
| 1018 RepeatedGroup_extension *repeatedGroup = | |
| 1019 [[RepeatedGroup_extension alloc] init]; | |
| 1020 [repeatedGroup setA:217 + i * 100]; | |
| 1021 [message addExtension:[UnittestRoot repeatedGroupExtension] | |
| 1022 value:repeatedGroup]; | |
| 1023 [repeatedGroup release]; | |
| 1024 nestedMessage = [[TestAllTypes_NestedMessage alloc] init]; | |
| 1025 [nestedMessage setBb:218 + i * 100]; | |
| 1026 [message addExtension:[UnittestRoot repeatedNestedMessageExtension] | |
| 1027 value:nestedMessage]; | |
| 1028 [nestedMessage release]; | |
| 1029 foreignMessage = [[ForeignMessage alloc] init]; | |
| 1030 [foreignMessage setC:219 + i * 100]; | |
| 1031 [message addExtension:[UnittestRoot repeatedForeignMessageExtension] | |
| 1032 value:foreignMessage]; | |
| 1033 [foreignMessage release]; | |
| 1034 importMessage = [[ImportMessage alloc] init]; | |
| 1035 [importMessage setD:220 + i * 100]; | |
| 1036 [message addExtension:[UnittestRoot repeatedImportMessageExtension] | |
| 1037 value:importMessage]; | |
| 1038 [importMessage release]; | |
| 1039 [message addExtension:[UnittestRoot repeatedNestedEnumExtension] | |
| 1040 value:@((i % 2) ? TestAllTypes_NestedEnum_Bar | |
| 1041 : TestAllTypes_NestedEnum_Baz)]; | |
| 1042 [message addExtension:[UnittestRoot repeatedForeignEnumExtension] | |
| 1043 value:@((i % 2) ? ForeignEnum_ForeignBar | |
| 1044 : ForeignEnum_ForeignBaz)]; | |
| 1045 [message | |
| 1046 addExtension:[UnittestRoot repeatedImportEnumExtension] | |
| 1047 value:@((i % 2) ? ImportEnum_ImportBar : ImportEnum_ImportBaz)]; | |
| 1048 | |
| 1049 string = [[NSString alloc] initWithFormat:@"%d", 224 + i * 100]; | |
| 1050 [message addExtension:[UnittestRoot repeatedStringPieceExtension] | |
| 1051 value:string]; | |
| 1052 [string release]; | |
| 1053 | |
| 1054 string = [[NSString alloc] initWithFormat:@"%d", 225 + i * 100]; | |
| 1055 [message addExtension:[UnittestRoot repeatedCordExtension] value:string]; | |
| 1056 [string release]; | |
| 1057 } | |
| 1058 | |
| 1059 // ----------------------------------------------------------------- | |
| 1060 | |
| 1061 [message setExtension:[UnittestRoot defaultInt32Extension] value:@401]; | |
| 1062 [message setExtension:[UnittestRoot defaultInt64Extension] value:@402L]; | |
| 1063 [message setExtension:[UnittestRoot defaultUint32Extension] value:@403]; | |
| 1064 [message setExtension:[UnittestRoot defaultUint64Extension] value:@404L]; | |
| 1065 [message setExtension:[UnittestRoot defaultSint32Extension] value:@405]; | |
| 1066 [message setExtension:[UnittestRoot defaultSint64Extension] value:@406L]; | |
| 1067 [message setExtension:[UnittestRoot defaultFixed32Extension] value:@407]; | |
| 1068 [message setExtension:[UnittestRoot defaultFixed64Extension] value:@408L]; | |
| 1069 [message setExtension:[UnittestRoot defaultSfixed32Extension] value:@409]; | |
| 1070 [message setExtension:[UnittestRoot defaultSfixed64Extension] value:@410L]; | |
| 1071 [message setExtension:[UnittestRoot defaultFloatExtension] value:@411.0f]; | |
| 1072 [message setExtension:[UnittestRoot defaultDoubleExtension] value:@412.0]; | |
| 1073 [message setExtension:[UnittestRoot defaultBoolExtension] value:@NO]; | |
| 1074 [message setExtension:[UnittestRoot defaultStringExtension] value:@"415"]; | |
| 1075 [message setExtension:[UnittestRoot defaultBytesExtension] | |
| 1076 value:[NSData gpbtu_dataWithUint32:416]]; | |
| 1077 | |
| 1078 [message setExtension:[UnittestRoot defaultNestedEnumExtension] | |
| 1079 value:@(TestAllTypes_NestedEnum_Foo)]; | |
| 1080 [message setExtension:[UnittestRoot defaultForeignEnumExtension] | |
| 1081 value:@(ForeignEnum_ForeignFoo)]; | |
| 1082 [message setExtension:[UnittestRoot defaultImportEnumExtension] | |
| 1083 value:@(ImportEnum_ImportFoo)]; | |
| 1084 | |
| 1085 [message setExtension:[UnittestRoot defaultStringPieceExtension] | |
| 1086 value:@"424"]; | |
| 1087 [message setExtension:[UnittestRoot defaultCordExtension] value:@"425"]; | |
| 1088 } | |
| 1089 | |
| 1090 - (void)setAllMapFields:(TestMap *)message numEntries:(uint32_t)count { | |
| 1091 for (uint32_t i = 0; i < count; i++) { | |
| 1092 [message.mapInt32Int32 setValue:(i + 1) forKey:100 + i * 100]; | |
| 1093 [message.mapInt64Int64 setValue:(i + 1) forKey:101 + i * 100]; | |
| 1094 [message.mapUint32Uint32 setValue:(i + 1) forKey:102 + i * 100]; | |
| 1095 [message.mapUint64Uint64 setValue:(i + 1) forKey:103 + i * 100]; | |
| 1096 [message.mapSint32Sint32 setValue:(i + 1) forKey:104 + i * 100]; | |
| 1097 [message.mapSint64Sint64 setValue:(i + 1) forKey:105 + i * 100]; | |
| 1098 [message.mapFixed32Fixed32 setValue:(i + 1) forKey:106 + i * 100]; | |
| 1099 [message.mapFixed64Fixed64 setValue:(i + 1) forKey:107 + i * 100]; | |
| 1100 [message.mapSfixed32Sfixed32 setValue:(i + 1) forKey:108 + i * 100]; | |
| 1101 [message.mapSfixed64Sfixed64 setValue:(i + 1) forKey:109 + i * 100]; | |
| 1102 [message.mapInt32Float setValue:(i + 1) forKey:110 + i * 100]; | |
| 1103 [message.mapInt32Double setValue:(i + 1) forKey:111 + i * 100]; | |
| 1104 [message.mapBoolBool setValue:((i % 2) == 1) forKey:((i % 2) == 0)]; | |
| 1105 | |
| 1106 NSString *keyStr = [[NSString alloc] initWithFormat:@"%d", 112 + i * 100]; | |
| 1107 NSString *dataStr = [[NSString alloc] initWithFormat:@"%d", i + 1]; | |
| 1108 [message.mapStringString setObject:dataStr forKey:keyStr]; | |
| 1109 [keyStr release]; | |
| 1110 [dataStr release]; | |
| 1111 | |
| 1112 NSData *data = [[NSData alloc] initWithUint32_gpbtu:i + 1]; | |
| 1113 [message.mapInt32Bytes setValue:data forKey:113 + i * 100]; | |
| 1114 [data release]; | |
| 1115 | |
| 1116 [message.mapInt32Enum | |
| 1117 setValue:(i % 2) ? MapEnum_MapEnumBar : MapEnum_MapEnumBaz | |
| 1118 forKey:114 + i * 100]; | |
| 1119 | |
| 1120 ForeignMessage *subMsg = [[ForeignMessage alloc] init]; | |
| 1121 subMsg.c = i + 1; | |
| 1122 [message.mapInt32ForeignMessage setValue:subMsg forKey:115 + i * 100]; | |
| 1123 [subMsg release]; | |
| 1124 } | |
| 1125 } | |
| 1126 | |
| 1127 - (void)setAllTestPackedFields:(TestPackedTypes *)message { | |
| 1128 // Must match -setAllTestUnpackedFields: | |
| 1129 [message.packedInt32Array addValue:101]; | |
| 1130 [message.packedInt64Array addValue:102]; | |
| 1131 [message.packedUint32Array addValue:103]; | |
| 1132 [message.packedUint64Array addValue:104]; | |
| 1133 [message.packedSint32Array addValue:105]; | |
| 1134 [message.packedSint64Array addValue:106]; | |
| 1135 [message.packedFixed32Array addValue:107]; | |
| 1136 [message.packedFixed64Array addValue:108]; | |
| 1137 [message.packedSfixed32Array addValue:109]; | |
| 1138 [message.packedSfixed64Array addValue:110]; | |
| 1139 [message.packedFloatArray addValue:111.f]; | |
| 1140 [message.packedDoubleArray addValue:112.]; | |
| 1141 [message.packedBoolArray addValue:YES]; | |
| 1142 [message.packedEnumArray addValue:ForeignEnum_ForeignBar]; | |
| 1143 | |
| 1144 [message.packedInt32Array addValue:201]; | |
| 1145 [message.packedInt64Array addValue:302]; | |
| 1146 [message.packedUint32Array addValue:203]; | |
| 1147 [message.packedUint64Array addValue:204]; | |
| 1148 [message.packedSint32Array addValue:205]; | |
| 1149 [message.packedSint64Array addValue:206]; | |
| 1150 [message.packedFixed32Array addValue:207]; | |
| 1151 [message.packedFixed64Array addValue:208]; | |
| 1152 [message.packedSfixed32Array addValue:209]; | |
| 1153 [message.packedSfixed64Array addValue:210]; | |
| 1154 [message.packedFloatArray addValue:211.f]; | |
| 1155 [message.packedDoubleArray addValue:212.]; | |
| 1156 [message.packedBoolArray addValue:NO]; | |
| 1157 [message.packedEnumArray addValue:ForeignEnum_ForeignBaz]; | |
| 1158 } | |
| 1159 | |
| 1160 - (void)setAllTestUnpackedFields:(TestUnpackedTypes *)message { | |
| 1161 // Must match -setAllTestPackedFields: | |
| 1162 [message.unpackedInt32Array addValue:101]; | |
| 1163 [message.unpackedInt64Array addValue:102]; | |
| 1164 [message.unpackedUint32Array addValue:103]; | |
| 1165 [message.unpackedUint64Array addValue:104]; | |
| 1166 [message.unpackedSint32Array addValue:105]; | |
| 1167 [message.unpackedSint64Array addValue:106]; | |
| 1168 [message.unpackedFixed32Array addValue:107]; | |
| 1169 [message.unpackedFixed64Array addValue:108]; | |
| 1170 [message.unpackedSfixed32Array addValue:109]; | |
| 1171 [message.unpackedSfixed64Array addValue:110]; | |
| 1172 [message.unpackedFloatArray addValue:111.f]; | |
| 1173 [message.unpackedDoubleArray addValue:112.]; | |
| 1174 [message.unpackedBoolArray addValue:YES]; | |
| 1175 [message.unpackedEnumArray addValue:ForeignEnum_ForeignBar]; | |
| 1176 | |
| 1177 [message.unpackedInt32Array addValue:201]; | |
| 1178 [message.unpackedInt64Array addValue:302]; | |
| 1179 [message.unpackedUint32Array addValue:203]; | |
| 1180 [message.unpackedUint64Array addValue:204]; | |
| 1181 [message.unpackedSint32Array addValue:205]; | |
| 1182 [message.unpackedSint64Array addValue:206]; | |
| 1183 [message.unpackedFixed32Array addValue:207]; | |
| 1184 [message.unpackedFixed64Array addValue:208]; | |
| 1185 [message.unpackedSfixed32Array addValue:209]; | |
| 1186 [message.unpackedSfixed64Array addValue:210]; | |
| 1187 [message.unpackedFloatArray addValue:211.f]; | |
| 1188 [message.unpackedDoubleArray addValue:212.]; | |
| 1189 [message.unpackedBoolArray addValue:NO]; | |
| 1190 [message.unpackedEnumArray addValue:ForeignEnum_ForeignBaz]; | |
| 1191 } | |
| 1192 | |
| 1193 - (GPBExtensionRegistry *)extensionRegistry { | |
| 1194 return [UnittestRoot extensionRegistry]; | |
| 1195 } | |
| 1196 | |
| 1197 - (TestAllTypes *)allSetRepeatedCount:(uint32_t)count { | |
| 1198 TestAllTypes *message = [TestAllTypes message]; | |
| 1199 [self setAllFields:message repeatedCount:count]; | |
| 1200 return message; | |
| 1201 } | |
| 1202 | |
| 1203 - (TestAllExtensions *)allExtensionsSetRepeatedCount:(uint32_t)count { | |
| 1204 TestAllExtensions *message = [TestAllExtensions message]; | |
| 1205 [self setAllExtensions:message repeatedCount:count]; | |
| 1206 return message; | |
| 1207 } | |
| 1208 | |
| 1209 - (TestPackedTypes *)packedSetRepeatedCount:(uint32_t)count { | |
| 1210 TestPackedTypes *message = [TestPackedTypes message]; | |
| 1211 [self setPackedFields:message repeatedCount:count]; | |
| 1212 return message; | |
| 1213 } | |
| 1214 | |
| 1215 - (TestPackedExtensions *)packedExtensionsSetRepeatedCount:(uint32_t)count { | |
| 1216 TestPackedExtensions *message = [TestPackedExtensions message]; | |
| 1217 [self setPackedExtensions:message repeatedCount:count]; | |
| 1218 return message; | |
| 1219 } | |
| 1220 | |
| 1221 // ------------------------------------------------------------------- | |
| 1222 | |
| 1223 - (void)assertClear:(TestAllTypes *)message { | |
| 1224 // hasBlah() should initially be NO for all optional fields. | |
| 1225 XCTAssertFalse(message.hasOptionalInt32); | |
| 1226 XCTAssertFalse(message.hasOptionalInt64); | |
| 1227 XCTAssertFalse(message.hasOptionalUint32); | |
| 1228 XCTAssertFalse(message.hasOptionalUint64); | |
| 1229 XCTAssertFalse(message.hasOptionalSint32); | |
| 1230 XCTAssertFalse(message.hasOptionalSint64); | |
| 1231 XCTAssertFalse(message.hasOptionalFixed32); | |
| 1232 XCTAssertFalse(message.hasOptionalFixed64); | |
| 1233 XCTAssertFalse(message.hasOptionalSfixed32); | |
| 1234 XCTAssertFalse(message.hasOptionalSfixed64); | |
| 1235 XCTAssertFalse(message.hasOptionalFloat); | |
| 1236 XCTAssertFalse(message.hasOptionalDouble); | |
| 1237 XCTAssertFalse(message.hasOptionalBool); | |
| 1238 XCTAssertFalse(message.hasOptionalString); | |
| 1239 XCTAssertFalse(message.hasOptionalBytes); | |
| 1240 | |
| 1241 XCTAssertFalse(message.hasOptionalGroup); | |
| 1242 XCTAssertFalse(message.hasOptionalNestedMessage); | |
| 1243 XCTAssertFalse(message.hasOptionalForeignMessage); | |
| 1244 XCTAssertFalse(message.hasOptionalImportMessage); | |
| 1245 | |
| 1246 XCTAssertFalse(message.hasOptionalNestedEnum); | |
| 1247 XCTAssertFalse(message.hasOptionalForeignEnum); | |
| 1248 XCTAssertFalse(message.hasOptionalImportEnum); | |
| 1249 | |
| 1250 XCTAssertFalse(message.hasOptionalStringPiece); | |
| 1251 XCTAssertFalse(message.hasOptionalCord); | |
| 1252 | |
| 1253 // Optional fields without defaults are set to zero or something like it. | |
| 1254 XCTAssertEqual(0, message.optionalInt32); | |
| 1255 XCTAssertEqual(0LL, message.optionalInt64); | |
| 1256 XCTAssertEqual(0U, message.optionalUint32); | |
| 1257 XCTAssertEqual(0ULL, message.optionalUint64); | |
| 1258 XCTAssertEqual(0, message.optionalSint32); | |
| 1259 XCTAssertEqual(0LL, message.optionalSint64); | |
| 1260 XCTAssertEqual(0U, message.optionalFixed32); | |
| 1261 XCTAssertEqual(0ULL, message.optionalFixed64); | |
| 1262 XCTAssertEqual(0, message.optionalSfixed32); | |
| 1263 XCTAssertEqual(0LL, message.optionalSfixed64); | |
| 1264 XCTAssertEqual(0.0f, message.optionalFloat); | |
| 1265 XCTAssertEqual(0.0, message.optionalDouble); | |
| 1266 XCTAssertFalse(message.optionalBool); | |
| 1267 XCTAssertEqualObjects(message.optionalString, @""); | |
| 1268 XCTAssertEqualObjects(message.optionalBytes, GPBEmptyNSData()); | |
| 1269 | |
| 1270 // Embedded messages should also be clear. | |
| 1271 XCTAssertFalse(message.hasOptionalGroup); | |
| 1272 XCTAssertFalse(message.hasOptionalNestedMessage); | |
| 1273 XCTAssertFalse(message.hasOptionalForeignMessage); | |
| 1274 XCTAssertFalse(message.hasOptionalImportMessage); | |
| 1275 | |
| 1276 // Enums without defaults are set to the first value in the enum. | |
| 1277 XCTAssertEqual(TestAllTypes_NestedEnum_Foo, message.optionalNestedEnum); | |
| 1278 XCTAssertEqual(ForeignEnum_ForeignFoo, message.optionalForeignEnum); | |
| 1279 XCTAssertEqual(ImportEnum_ImportFoo, message.optionalImportEnum); | |
| 1280 | |
| 1281 XCTAssertEqualObjects(message.optionalStringPiece, @""); | |
| 1282 XCTAssertEqualObjects(message.optionalCord, @""); | |
| 1283 | |
| 1284 // Repeated fields are empty. | |
| 1285 | |
| 1286 XCTAssertEqual(0U, message.repeatedInt32Array.count); | |
| 1287 XCTAssertEqual(0U, message.repeatedInt64Array.count); | |
| 1288 XCTAssertEqual(0U, message.repeatedUint32Array.count); | |
| 1289 XCTAssertEqual(0U, message.repeatedUint64Array.count); | |
| 1290 XCTAssertEqual(0U, message.repeatedSint32Array.count); | |
| 1291 XCTAssertEqual(0U, message.repeatedSint64Array.count); | |
| 1292 XCTAssertEqual(0U, message.repeatedFixed32Array.count); | |
| 1293 XCTAssertEqual(0U, message.repeatedFixed64Array.count); | |
| 1294 XCTAssertEqual(0U, message.repeatedSfixed32Array.count); | |
| 1295 XCTAssertEqual(0U, message.repeatedSfixed64Array.count); | |
| 1296 XCTAssertEqual(0U, message.repeatedFloatArray.count); | |
| 1297 XCTAssertEqual(0U, message.repeatedDoubleArray.count); | |
| 1298 XCTAssertEqual(0U, message.repeatedBoolArray.count); | |
| 1299 XCTAssertEqual(0U, message.repeatedStringArray.count); | |
| 1300 XCTAssertEqual(0U, message.repeatedBytesArray.count); | |
| 1301 | |
| 1302 XCTAssertEqual(0U, message.repeatedGroupArray.count); | |
| 1303 XCTAssertEqual(0U, message.repeatedNestedMessageArray.count); | |
| 1304 XCTAssertEqual(0U, message.repeatedForeignMessageArray.count); | |
| 1305 XCTAssertEqual(0U, message.repeatedImportMessageArray.count); | |
| 1306 XCTAssertEqual(0U, message.repeatedNestedEnumArray.count); | |
| 1307 XCTAssertEqual(0U, message.repeatedForeignEnumArray.count); | |
| 1308 XCTAssertEqual(0U, message.repeatedImportEnumArray.count); | |
| 1309 | |
| 1310 XCTAssertEqual(0U, message.repeatedStringPieceArray.count); | |
| 1311 XCTAssertEqual(0U, message.repeatedCordArray.count); | |
| 1312 | |
| 1313 XCTAssertEqual(0U, message.repeatedInt32Array_Count); | |
| 1314 XCTAssertEqual(0U, message.repeatedInt64Array_Count); | |
| 1315 XCTAssertEqual(0U, message.repeatedUint32Array_Count); | |
| 1316 XCTAssertEqual(0U, message.repeatedUint64Array_Count); | |
| 1317 XCTAssertEqual(0U, message.repeatedSint32Array_Count); | |
| 1318 XCTAssertEqual(0U, message.repeatedSint64Array_Count); | |
| 1319 XCTAssertEqual(0U, message.repeatedFixed32Array_Count); | |
| 1320 XCTAssertEqual(0U, message.repeatedFixed64Array_Count); | |
| 1321 XCTAssertEqual(0U, message.repeatedSfixed32Array_Count); | |
| 1322 XCTAssertEqual(0U, message.repeatedSfixed64Array_Count); | |
| 1323 XCTAssertEqual(0U, message.repeatedFloatArray_Count); | |
| 1324 XCTAssertEqual(0U, message.repeatedDoubleArray_Count); | |
| 1325 XCTAssertEqual(0U, message.repeatedBoolArray_Count); | |
| 1326 XCTAssertEqual(0U, message.repeatedStringArray_Count); | |
| 1327 XCTAssertEqual(0U, message.repeatedBytesArray_Count); | |
| 1328 | |
| 1329 XCTAssertEqual(0U, message.repeatedGroupArray_Count); | |
| 1330 XCTAssertEqual(0U, message.repeatedNestedMessageArray_Count); | |
| 1331 XCTAssertEqual(0U, message.repeatedForeignMessageArray_Count); | |
| 1332 XCTAssertEqual(0U, message.repeatedImportMessageArray_Count); | |
| 1333 XCTAssertEqual(0U, message.repeatedNestedEnumArray_Count); | |
| 1334 XCTAssertEqual(0U, message.repeatedForeignEnumArray_Count); | |
| 1335 XCTAssertEqual(0U, message.repeatedImportEnumArray_Count); | |
| 1336 | |
| 1337 XCTAssertEqual(0U, message.repeatedStringPieceArray_Count); | |
| 1338 XCTAssertEqual(0U, message.repeatedCordArray_Count); | |
| 1339 | |
| 1340 // hasBlah() should also be NO for all default fields. | |
| 1341 XCTAssertFalse(message.hasDefaultInt32); | |
| 1342 XCTAssertFalse(message.hasDefaultInt64); | |
| 1343 XCTAssertFalse(message.hasDefaultUint32); | |
| 1344 XCTAssertFalse(message.hasDefaultUint64); | |
| 1345 XCTAssertFalse(message.hasDefaultSint32); | |
| 1346 XCTAssertFalse(message.hasDefaultSint64); | |
| 1347 XCTAssertFalse(message.hasDefaultFixed32); | |
| 1348 XCTAssertFalse(message.hasDefaultFixed64); | |
| 1349 XCTAssertFalse(message.hasDefaultSfixed32); | |
| 1350 XCTAssertFalse(message.hasDefaultSfixed64); | |
| 1351 XCTAssertFalse(message.hasDefaultFloat); | |
| 1352 XCTAssertFalse(message.hasDefaultDouble); | |
| 1353 XCTAssertFalse(message.hasDefaultBool); | |
| 1354 XCTAssertFalse(message.hasDefaultString); | |
| 1355 XCTAssertFalse(message.hasDefaultBytes); | |
| 1356 | |
| 1357 XCTAssertFalse(message.hasDefaultNestedEnum); | |
| 1358 XCTAssertFalse(message.hasDefaultForeignEnum); | |
| 1359 XCTAssertFalse(message.hasDefaultImportEnum); | |
| 1360 | |
| 1361 XCTAssertFalse(message.hasDefaultStringPiece); | |
| 1362 XCTAssertFalse(message.hasDefaultCord); | |
| 1363 | |
| 1364 // Fields with defaults have their default values (duh). | |
| 1365 XCTAssertEqual(41, message.defaultInt32); | |
| 1366 XCTAssertEqual(42LL, message.defaultInt64); | |
| 1367 XCTAssertEqual(43U, message.defaultUint32); | |
| 1368 XCTAssertEqual(44ULL, message.defaultUint64); | |
| 1369 XCTAssertEqual(-45, message.defaultSint32); | |
| 1370 XCTAssertEqual(46LL, message.defaultSint64); | |
| 1371 XCTAssertEqual(47U, message.defaultFixed32); | |
| 1372 XCTAssertEqual(48ULL, message.defaultFixed64); | |
| 1373 XCTAssertEqual(49, message.defaultSfixed32); | |
| 1374 XCTAssertEqual(-50LL, message.defaultSfixed64); | |
| 1375 XCTAssertEqualWithAccuracy(51.5f, message.defaultFloat, 0.1); | |
| 1376 XCTAssertEqualWithAccuracy(52e3, message.defaultDouble, 0.1); | |
| 1377 XCTAssertTrue(message.defaultBool); | |
| 1378 XCTAssertEqualObjects(@"hello", message.defaultString); | |
| 1379 XCTAssertEqualObjects([NSData gpbtu_dataWithCString:"world"], | |
| 1380 message.defaultBytes); | |
| 1381 | |
| 1382 XCTAssertEqual(TestAllTypes_NestedEnum_Bar, message.defaultNestedEnum); | |
| 1383 XCTAssertEqual(ForeignEnum_ForeignBar, message.defaultForeignEnum); | |
| 1384 XCTAssertEqual(ImportEnum_ImportBar, message.defaultImportEnum); | |
| 1385 | |
| 1386 XCTAssertEqualObjects(@"abc", message.defaultStringPiece); | |
| 1387 XCTAssertEqualObjects(@"123", message.defaultCord); | |
| 1388 } | |
| 1389 | |
| 1390 - (void)assertExtensionsClear:(TestAllExtensions *)message { | |
| 1391 // hasBlah() should initially be NO for all optional fields. | |
| 1392 XCTAssertFalse([message hasExtension:[UnittestRoot optionalInt32Extension]]); | |
| 1393 XCTAssertFalse([message hasExtension:[UnittestRoot optionalInt64Extension]]); | |
| 1394 XCTAssertFalse([message hasExtension:[UnittestRoot optionalUint32Extension]]); | |
| 1395 XCTAssertFalse([message hasExtension:[UnittestRoot optionalUint64Extension]]); | |
| 1396 XCTAssertFalse([message hasExtension:[UnittestRoot optionalSint32Extension]]); | |
| 1397 XCTAssertFalse([message hasExtension:[UnittestRoot optionalSint64Extension]]); | |
| 1398 XCTAssertFalse([message hasExtension:[UnittestRoot optionalFixed32Extension]])
; | |
| 1399 XCTAssertFalse([message hasExtension:[UnittestRoot optionalFixed64Extension]])
; | |
| 1400 XCTAssertFalse([message hasExtension:[UnittestRoot optionalSfixed32Extension]]
); | |
| 1401 XCTAssertFalse([message hasExtension:[UnittestRoot optionalSfixed64Extension]]
); | |
| 1402 XCTAssertFalse([message hasExtension:[UnittestRoot optionalFloatExtension]]); | |
| 1403 XCTAssertFalse([message hasExtension:[UnittestRoot optionalDoubleExtension]]); | |
| 1404 XCTAssertFalse([message hasExtension:[UnittestRoot optionalBoolExtension]]); | |
| 1405 XCTAssertFalse([message hasExtension:[UnittestRoot optionalStringExtension]]); | |
| 1406 XCTAssertFalse([message hasExtension:[UnittestRoot optionalBytesExtension]]); | |
| 1407 | |
| 1408 XCTAssertFalse([message hasExtension:[UnittestRoot optionalGroupExtension]]); | |
| 1409 XCTAssertFalse([message hasExtension:[UnittestRoot optionalNestedMessageExtens
ion]]); | |
| 1410 XCTAssertFalse([message hasExtension:[UnittestRoot optionalForeignMessageExten
sion]]); | |
| 1411 XCTAssertFalse([message hasExtension:[UnittestRoot optionalImportMessageExtens
ion]]); | |
| 1412 | |
| 1413 XCTAssertFalse([message hasExtension:[UnittestRoot optionalNestedEnumExtension
]]); | |
| 1414 XCTAssertFalse([message hasExtension:[UnittestRoot optionalForeignEnumExtensio
n]]); | |
| 1415 XCTAssertFalse([message hasExtension:[UnittestRoot optionalImportEnumExtension
]]); | |
| 1416 | |
| 1417 XCTAssertFalse([message hasExtension:[UnittestRoot optionalStringPieceExtensio
n]]); | |
| 1418 XCTAssertFalse([message hasExtension:[UnittestRoot optionalCordExtension]]); | |
| 1419 | |
| 1420 // Optional fields without defaults are set to zero or something like it. | |
| 1421 XCTAssertEqual(0, [[message getExtension:[UnittestRoot optionalInt32Extension]
] intValue]); | |
| 1422 XCTAssertEqual(0LL,[[message getExtension:[UnittestRoot optionalInt64Extension
]] longLongValue]); | |
| 1423 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot optionalUint32Extensio
n]] unsignedIntValue]); | |
| 1424 XCTAssertEqual(0ULL, [[message getExtension:[UnittestRoot optionalUint64Extens
ion]] unsignedLongLongValue]); | |
| 1425 XCTAssertEqual(0, [[message getExtension:[UnittestRoot optionalSint32Extension
]] intValue]); | |
| 1426 XCTAssertEqual(0LL, [[message getExtension:[UnittestRoot optionalSint64Extensi
on]] longLongValue]); | |
| 1427 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot optionalFixed32Extensi
on]] unsignedIntValue]); | |
| 1428 XCTAssertEqual(0ULL, [[message getExtension:[UnittestRoot optionalFixed64Exten
sion]] unsignedLongLongValue]); | |
| 1429 XCTAssertEqual(0, [[message getExtension:[UnittestRoot optionalSfixed32Extensi
on]] intValue]); | |
| 1430 XCTAssertEqual(0LL, [[message getExtension:[UnittestRoot optionalSfixed64Exten
sion]] longLongValue]); | |
| 1431 XCTAssertEqualWithAccuracy(0.0f, [[message getExtension:[UnittestRoot optional
FloatExtension]] floatValue], 0.01); | |
| 1432 XCTAssertEqualWithAccuracy(0.0, [[message getExtension:[UnittestRoot optionalD
oubleExtension]] doubleValue], 0.01); | |
| 1433 XCTAssertFalse([[message getExtension:[UnittestRoot optionalBoolExtension]] bo
olValue]); | |
| 1434 XCTAssertEqualObjects(@"", [message getExtension:[UnittestRoot optionalStringE
xtension]]); | |
| 1435 XCTAssertEqualObjects(GPBEmptyNSData(), [message getExtension:[UnittestRoot op
tionalBytesExtension]]); | |
| 1436 | |
| 1437 // Embedded messages should also be clear. | |
| 1438 | |
| 1439 XCTAssertFalse([[message getExtension:[UnittestRoot optionalGroupExtension]] h
asA]); | |
| 1440 XCTAssertFalse([[message getExtension:[UnittestRoot optionalNestedMessageExten
sion]] hasBb]); | |
| 1441 XCTAssertFalse([[message getExtension:[UnittestRoot optionalForeignMessageExte
nsion]] hasC]); | |
| 1442 XCTAssertFalse([[message getExtension:[UnittestRoot optionalImportMessageExten
sion]] hasD]); | |
| 1443 | |
| 1444 XCTAssertEqual(0, [(TestAllTypes_OptionalGroup*)[message getExtension:[Unittes
tRoot optionalGroupExtension]] a]); | |
| 1445 XCTAssertEqual(0, [(TestAllTypes_NestedMessage*)[message getExtension:[Unittes
tRoot optionalNestedMessageExtension]] bb]); | |
| 1446 XCTAssertEqual(0, [[message getExtension:[UnittestRoot optionalForeignMessageE
xtension]] c]); | |
| 1447 XCTAssertEqual(0, [[message getExtension:[UnittestRoot optionalImportMessageEx
tension]] d]); | |
| 1448 | |
| 1449 // Enums without defaults are set to the first value in the enum. | |
| 1450 XCTAssertEqual(TestAllTypes_NestedEnum_Foo, | |
| 1451 [[message getExtension:[UnittestRoot optionalNestedEnumExtension]
] intValue]); | |
| 1452 XCTAssertEqual(ForeignEnum_ForeignFoo, | |
| 1453 [[message getExtension:[UnittestRoot optionalForeignEnumExtension
]] intValue]); | |
| 1454 XCTAssertEqual(ImportEnum_ImportFoo, | |
| 1455 [[message getExtension:[UnittestRoot optionalImportEnumExtension]
] intValue]); | |
| 1456 | |
| 1457 XCTAssertEqualObjects(@"", [message getExtension:[UnittestRoot optionalStringP
ieceExtension]]); | |
| 1458 XCTAssertEqualObjects(@"", [message getExtension:[UnittestRoot optionalCordExt
ension]]); | |
| 1459 | |
| 1460 // Repeated fields are empty. | |
| 1461 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedInt32Extension
]] count]); | |
| 1462 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedInt64Extension
]] count]); | |
| 1463 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedUint32Extensio
n]] count]); | |
| 1464 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedUint64Extensio
n]] count]); | |
| 1465 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedSint32Extensio
n]] count]); | |
| 1466 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedSint64Extensio
n]] count]); | |
| 1467 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedFixed32Extensi
on]] count]); | |
| 1468 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedFixed64Extensi
on]] count]); | |
| 1469 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedSfixed32Extens
ion]] count]); | |
| 1470 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedSfixed64Extens
ion]] count]); | |
| 1471 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedFloatExtension
]] count]); | |
| 1472 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedDoubleExtensio
n]] count]); | |
| 1473 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedBoolExtension]
] count]); | |
| 1474 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedStringExtensio
n]] count]); | |
| 1475 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedBytesExtension
]] count]); | |
| 1476 | |
| 1477 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedGroupExtension
]] count]); | |
| 1478 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedNestedMessageE
xtension]] count]); | |
| 1479 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedForeignMessage
Extension]] count]); | |
| 1480 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedImportMessageE
xtension]] count]); | |
| 1481 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedNestedEnumExte
nsion]] count]); | |
| 1482 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedForeignEnumExt
ension]] count]); | |
| 1483 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedImportEnumExte
nsion]] count]); | |
| 1484 | |
| 1485 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedStringPieceExt
ension]] count]); | |
| 1486 XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedCordExtension]
] count]); | |
| 1487 | |
| 1488 // hasBlah() should also be NO for all default fields. | |
| 1489 XCTAssertFalse([message hasExtension:[UnittestRoot defaultInt32Extension]]); | |
| 1490 XCTAssertFalse([message hasExtension:[UnittestRoot defaultInt64Extension]]); | |
| 1491 XCTAssertFalse([message hasExtension:[UnittestRoot defaultUint32Extension]]); | |
| 1492 XCTAssertFalse([message hasExtension:[UnittestRoot defaultUint64Extension]]); | |
| 1493 XCTAssertFalse([message hasExtension:[UnittestRoot defaultSint32Extension]]); | |
| 1494 XCTAssertFalse([message hasExtension:[UnittestRoot defaultSint64Extension]]); | |
| 1495 XCTAssertFalse([message hasExtension:[UnittestRoot defaultFixed32Extension]]); | |
| 1496 XCTAssertFalse([message hasExtension:[UnittestRoot defaultFixed64Extension]]); | |
| 1497 XCTAssertFalse([message hasExtension:[UnittestRoot defaultSfixed32Extension]])
; | |
| 1498 XCTAssertFalse([message hasExtension:[UnittestRoot defaultSfixed64Extension]])
; | |
| 1499 XCTAssertFalse([message hasExtension:[UnittestRoot defaultFloatExtension]]); | |
| 1500 XCTAssertFalse([message hasExtension:[UnittestRoot defaultDoubleExtension]]); | |
| 1501 XCTAssertFalse([message hasExtension:[UnittestRoot defaultBoolExtension]]); | |
| 1502 XCTAssertFalse([message hasExtension:[UnittestRoot defaultStringExtension]]); | |
| 1503 XCTAssertFalse([message hasExtension:[UnittestRoot defaultBytesExtension]]); | |
| 1504 | |
| 1505 XCTAssertFalse([message hasExtension:[UnittestRoot defaultNestedEnumExtension]
]); | |
| 1506 XCTAssertFalse([message hasExtension:[UnittestRoot defaultForeignEnumExtension
]]); | |
| 1507 XCTAssertFalse([message hasExtension:[UnittestRoot defaultImportEnumExtension]
]); | |
| 1508 | |
| 1509 XCTAssertFalse([message hasExtension:[UnittestRoot defaultStringPieceExtension
]]); | |
| 1510 XCTAssertFalse([message hasExtension:[UnittestRoot defaultCordExtension]]); | |
| 1511 | |
| 1512 // Fields with defaults have their default values (duh). | |
| 1513 XCTAssertEqual( 41, [[message getExtension:[UnittestRoot defaultInt32Extension
]] intValue]); | |
| 1514 XCTAssertEqual( 42LL, [[message getExtension:[UnittestRoot defaultInt64Extensi
on]] longLongValue]); | |
| 1515 XCTAssertEqual( 43U, [[message getExtension:[UnittestRoot defaultUint32Extensi
on]] unsignedIntValue]); | |
| 1516 XCTAssertEqual( 44ULL, [[message getExtension:[UnittestRoot defaultUint64Exten
sion]] unsignedLongLongValue]); | |
| 1517 XCTAssertEqual(-45, [[message getExtension:[UnittestRoot defaultSint32Extensio
n]] intValue]); | |
| 1518 XCTAssertEqual( 46LL, [[message getExtension:[UnittestRoot defaultSint64Extens
ion]] longLongValue]); | |
| 1519 XCTAssertEqual( 47, [[message getExtension:[UnittestRoot defaultFixed32Extensi
on]] intValue]); | |
| 1520 XCTAssertEqual( 48ULL, [[message getExtension:[UnittestRoot defaultFixed64Exte
nsion]] unsignedLongLongValue]); | |
| 1521 XCTAssertEqual( 49, [[message getExtension:[UnittestRoot defaultSfixed32Extens
ion]] intValue]); | |
| 1522 XCTAssertEqual(-50LL, [[message getExtension:[UnittestRoot defaultSfixed64Exte
nsion]] longLongValue]); | |
| 1523 XCTAssertEqualWithAccuracy( 51.5f, [[message getExtension:[UnittestRoot defaul
tFloatExtension]] floatValue], 0.01); | |
| 1524 XCTAssertEqualWithAccuracy( 52e3, [[message getExtension:[UnittestRoot default
DoubleExtension]] doubleValue], 0.01); | |
| 1525 XCTAssertTrue([[message getExtension:[UnittestRoot defaultBoolExtension]] bool
Value]); | |
| 1526 XCTAssertEqualObjects(@"hello", [message getExtension:[UnittestRoot defaultStr
ingExtension]]); | |
| 1527 XCTAssertEqualObjects([NSData gpbtu_dataWithCString:"world"], [message getExte
nsion:[UnittestRoot defaultBytesExtension]]); | |
| 1528 | |
| 1529 XCTAssertEqual(TestAllTypes_NestedEnum_Bar, | |
| 1530 [[message getExtension:[UnittestRoot defaultNestedEnumExtension]]
intValue]); | |
| 1531 XCTAssertEqual(ForeignEnum_ForeignBar, | |
| 1532 [[message getExtension:[UnittestRoot defaultForeignEnumExtension]
] intValue]); | |
| 1533 XCTAssertEqual(ImportEnum_ImportBar, | |
| 1534 [[message getExtension:[UnittestRoot defaultImportEnumExtension]]
intValue]); | |
| 1535 | |
| 1536 XCTAssertEqualObjects(@"abc", [message getExtension:[UnittestRoot defaultStrin
gPieceExtension]]); | |
| 1537 XCTAssertEqualObjects(@"123", [message getExtension:[UnittestRoot defaultCordE
xtension]]); | |
| 1538 } | |
| 1539 | |
| 1540 - (void)modifyRepeatedFields:(TestAllTypes *)message { | |
| 1541 [message.repeatedInt32Array replaceValueAtIndex:1 withValue:501]; | |
| 1542 [message.repeatedInt64Array replaceValueAtIndex:1 withValue:502]; | |
| 1543 [message.repeatedUint32Array replaceValueAtIndex:1 withValue:503]; | |
| 1544 [message.repeatedUint64Array replaceValueAtIndex:1 withValue:504]; | |
| 1545 [message.repeatedSint32Array replaceValueAtIndex:1 withValue:505]; | |
| 1546 [message.repeatedSint64Array replaceValueAtIndex:1 withValue:506]; | |
| 1547 [message.repeatedFixed32Array replaceValueAtIndex:1 withValue:507]; | |
| 1548 [message.repeatedFixed64Array replaceValueAtIndex:1 withValue:508]; | |
| 1549 [message.repeatedSfixed32Array replaceValueAtIndex:1 withValue:509]; | |
| 1550 [message.repeatedSfixed64Array replaceValueAtIndex:1 withValue:510]; | |
| 1551 [message.repeatedFloatArray replaceValueAtIndex:1 withValue:511]; | |
| 1552 [message.repeatedDoubleArray replaceValueAtIndex:1 withValue:512]; | |
| 1553 [message.repeatedBoolArray replaceValueAtIndex:1 withValue:YES]; | |
| 1554 [message.repeatedStringArray replaceObjectAtIndex:1 withObject:@"515"]; | |
| 1555 | |
| 1556 NSData *data = [[NSData alloc] initWithUint32_gpbtu:516]; | |
| 1557 [message.repeatedBytesArray replaceObjectAtIndex:1 withObject:data]; | |
| 1558 [data release]; | |
| 1559 | |
| 1560 TestAllTypes_RepeatedGroup *testAll = | |
| 1561 [[TestAllTypes_RepeatedGroup alloc] init]; | |
| 1562 [testAll setA:517]; | |
| 1563 [message.repeatedGroupArray replaceObjectAtIndex:1 withObject:testAll]; | |
| 1564 [testAll release]; | |
| 1565 | |
| 1566 TestAllTypes_NestedMessage *nestedMessage = | |
| 1567 [[TestAllTypes_NestedMessage alloc] init]; | |
| 1568 [nestedMessage setBb:518]; | |
| 1569 [message.repeatedNestedMessageArray replaceObjectAtIndex:1 | |
| 1570 withObject:nestedMessage]; | |
| 1571 [nestedMessage release]; | |
| 1572 | |
| 1573 ForeignMessage *foreignMessage = [[ForeignMessage alloc] init]; | |
| 1574 [foreignMessage setC:519]; | |
| 1575 [message.repeatedForeignMessageArray replaceObjectAtIndex:1 | |
| 1576 withObject:foreignMessage]; | |
| 1577 [foreignMessage release]; | |
| 1578 | |
| 1579 ImportMessage *importMessage = [[ImportMessage alloc] init]; | |
| 1580 [importMessage setD:520]; | |
| 1581 [message.repeatedImportMessageArray replaceObjectAtIndex:1 | |
| 1582 withObject:importMessage]; | |
| 1583 [importMessage release]; | |
| 1584 | |
| 1585 [message.repeatedNestedEnumArray replaceValueAtIndex:1 withValue:TestAllTypes_
NestedEnum_Foo]; | |
| 1586 [message.repeatedForeignEnumArray replaceValueAtIndex:1 withValue:ForeignEnum_
ForeignFoo]; | |
| 1587 [message.repeatedImportEnumArray replaceValueAtIndex:1 withValue:ImportEnum_Im
portFoo]; | |
| 1588 | |
| 1589 [message.repeatedStringPieceArray replaceObjectAtIndex:1 withObject:@"524"]; | |
| 1590 [message.repeatedCordArray replaceObjectAtIndex:1 withObject:@"525"]; | |
| 1591 } | |
| 1592 | |
| 1593 - (void)assertRepeatedFieldsModified:(TestAllTypes *)message | |
| 1594 repeatedCount:(uint32_t)count { | |
| 1595 // ModifyRepeatedFields only sets the second repeated element of each | |
| 1596 // field. In addition to verifying this, we also verify that the first | |
| 1597 // element and size were *not* modified. | |
| 1598 | |
| 1599 XCTAssertEqual(count, message.repeatedInt32Array.count); | |
| 1600 XCTAssertEqual(count, message.repeatedInt64Array.count); | |
| 1601 XCTAssertEqual(count, message.repeatedUint32Array.count); | |
| 1602 XCTAssertEqual(count, message.repeatedUint64Array.count); | |
| 1603 XCTAssertEqual(count, message.repeatedSint32Array.count); | |
| 1604 XCTAssertEqual(count, message.repeatedSint64Array.count); | |
| 1605 XCTAssertEqual(count, message.repeatedFixed32Array.count); | |
| 1606 XCTAssertEqual(count, message.repeatedFixed64Array.count); | |
| 1607 XCTAssertEqual(count, message.repeatedSfixed32Array.count); | |
| 1608 XCTAssertEqual(count, message.repeatedSfixed64Array.count); | |
| 1609 XCTAssertEqual(count, message.repeatedFloatArray.count); | |
| 1610 XCTAssertEqual(count, message.repeatedDoubleArray.count); | |
| 1611 XCTAssertEqual(count, message.repeatedBoolArray.count); | |
| 1612 XCTAssertEqual(count, message.repeatedStringArray.count); | |
| 1613 XCTAssertEqual(count, message.repeatedBytesArray.count); | |
| 1614 | |
| 1615 XCTAssertEqual(count, message.repeatedGroupArray.count); | |
| 1616 XCTAssertEqual(count, message.repeatedNestedMessageArray.count); | |
| 1617 XCTAssertEqual(count, message.repeatedForeignMessageArray.count); | |
| 1618 XCTAssertEqual(count, message.repeatedImportMessageArray.count); | |
| 1619 XCTAssertEqual(count, message.repeatedNestedEnumArray.count); | |
| 1620 XCTAssertEqual(count, message.repeatedForeignEnumArray.count); | |
| 1621 XCTAssertEqual(count, message.repeatedImportEnumArray.count); | |
| 1622 | |
| 1623 XCTAssertEqual(count, message.repeatedStringPieceArray.count); | |
| 1624 XCTAssertEqual(count, message.repeatedCordArray.count); | |
| 1625 | |
| 1626 XCTAssertEqual(count, message.repeatedInt32Array_Count); | |
| 1627 XCTAssertEqual(count, message.repeatedInt64Array_Count); | |
| 1628 XCTAssertEqual(count, message.repeatedUint32Array_Count); | |
| 1629 XCTAssertEqual(count, message.repeatedUint64Array_Count); | |
| 1630 XCTAssertEqual(count, message.repeatedSint32Array_Count); | |
| 1631 XCTAssertEqual(count, message.repeatedSint64Array_Count); | |
| 1632 XCTAssertEqual(count, message.repeatedFixed32Array_Count); | |
| 1633 XCTAssertEqual(count, message.repeatedFixed64Array_Count); | |
| 1634 XCTAssertEqual(count, message.repeatedSfixed32Array_Count); | |
| 1635 XCTAssertEqual(count, message.repeatedSfixed64Array_Count); | |
| 1636 XCTAssertEqual(count, message.repeatedFloatArray_Count); | |
| 1637 XCTAssertEqual(count, message.repeatedDoubleArray_Count); | |
| 1638 XCTAssertEqual(count, message.repeatedBoolArray_Count); | |
| 1639 XCTAssertEqual(count, message.repeatedStringArray_Count); | |
| 1640 XCTAssertEqual(count, message.repeatedBytesArray_Count); | |
| 1641 | |
| 1642 XCTAssertEqual(count, message.repeatedGroupArray_Count); | |
| 1643 XCTAssertEqual(count, message.repeatedNestedMessageArray_Count); | |
| 1644 XCTAssertEqual(count, message.repeatedForeignMessageArray_Count); | |
| 1645 XCTAssertEqual(count, message.repeatedImportMessageArray_Count); | |
| 1646 XCTAssertEqual(count, message.repeatedNestedEnumArray_Count); | |
| 1647 XCTAssertEqual(count, message.repeatedForeignEnumArray_Count); | |
| 1648 XCTAssertEqual(count, message.repeatedImportEnumArray_Count); | |
| 1649 | |
| 1650 XCTAssertEqual(count, message.repeatedStringPieceArray_Count); | |
| 1651 XCTAssertEqual(count, message.repeatedCordArray_Count); | |
| 1652 | |
| 1653 XCTAssertEqual(201, [message.repeatedInt32Array valueAtIndex:0]); | |
| 1654 XCTAssertEqual(202LL, [message.repeatedInt64Array valueAtIndex:0]); | |
| 1655 XCTAssertEqual(203U, [message.repeatedUint32Array valueAtIndex:0]); | |
| 1656 XCTAssertEqual(204ULL, [message.repeatedUint64Array valueAtIndex:0]); | |
| 1657 XCTAssertEqual(205, [message.repeatedSint32Array valueAtIndex:0]); | |
| 1658 XCTAssertEqual(206LL, [message.repeatedSint64Array valueAtIndex:0]); | |
| 1659 XCTAssertEqual(207U, [message.repeatedFixed32Array valueAtIndex:0]); | |
| 1660 XCTAssertEqual(208ULL, [message.repeatedFixed64Array valueAtIndex:0]); | |
| 1661 XCTAssertEqual(209, [message.repeatedSfixed32Array valueAtIndex:0]); | |
| 1662 XCTAssertEqual(210LL, [message.repeatedSfixed64Array valueAtIndex:0]); | |
| 1663 XCTAssertEqualWithAccuracy(211.0f, [message.repeatedFloatArray valueAtIndex:0]
, 0.01); | |
| 1664 XCTAssertEqualWithAccuracy(212.0, [message.repeatedDoubleArray valueAtIndex:0]
, 0.01); | |
| 1665 XCTAssertFalse([message.repeatedBoolArray valueAtIndex:0]); | |
| 1666 XCTAssertEqualObjects(@"215", message.repeatedStringArray[0]); | |
| 1667 XCTAssertEqualObjects([NSData gpbtu_dataWithUint32:216], | |
| 1668 message.repeatedBytesArray[0]); | |
| 1669 | |
| 1670 XCTAssertEqual(217, ((TestAllTypes_RepeatedGroup*)message.repeatedGroupArray[0
]).a); | |
| 1671 XCTAssertEqual(218, ((TestAllTypes_NestedMessage*)message.repeatedNestedMessag
eArray[0]).bb); | |
| 1672 XCTAssertEqual(219, ((ForeignMessage*)message.repeatedForeignMessageArray[0]).
c); | |
| 1673 XCTAssertEqual(220, ((ImportMessage*)message.repeatedImportMessageArray[0]).d)
; | |
| 1674 | |
| 1675 XCTAssertEqual(TestAllTypes_NestedEnum_Baz, [message.repeatedNestedEnumArray v
alueAtIndex:0]); | |
| 1676 XCTAssertEqual(ForeignEnum_ForeignBaz, [message.repeatedForeignEnumArray value
AtIndex:0]); | |
| 1677 XCTAssertEqual(ImportEnum_ImportBaz, [message.repeatedImportEnumArray valueAtI
ndex:0]); | |
| 1678 | |
| 1679 XCTAssertEqualObjects(@"224", message.repeatedStringPieceArray[0]); | |
| 1680 XCTAssertEqualObjects(@"225", message.repeatedCordArray[0]); | |
| 1681 | |
| 1682 // Actually verify the second (modified) elements now. | |
| 1683 XCTAssertEqual(501, [message.repeatedInt32Array valueAtIndex:1]); | |
| 1684 XCTAssertEqual(502LL, [message.repeatedInt64Array valueAtIndex:1]); | |
| 1685 XCTAssertEqual(503U, [message.repeatedUint32Array valueAtIndex:1]); | |
| 1686 XCTAssertEqual(504ULL, [message.repeatedUint64Array valueAtIndex:1]); | |
| 1687 XCTAssertEqual(505, [message.repeatedSint32Array valueAtIndex:1]); | |
| 1688 XCTAssertEqual(506LL, [message.repeatedSint64Array valueAtIndex:1]); | |
| 1689 XCTAssertEqual(507U, [message.repeatedFixed32Array valueAtIndex:1]); | |
| 1690 XCTAssertEqual(508ULL, [message.repeatedFixed64Array valueAtIndex:1]); | |
| 1691 XCTAssertEqual(509, [message.repeatedSfixed32Array valueAtIndex:1]); | |
| 1692 XCTAssertEqual(510LL, [message.repeatedSfixed64Array valueAtIndex:1]); | |
| 1693 XCTAssertEqualWithAccuracy(511.0f, [message.repeatedFloatArray valueAtIndex:1]
, 0.01); | |
| 1694 XCTAssertEqualWithAccuracy(512.0, [message.repeatedDoubleArray valueAtIndex:1]
, 0.01); | |
| 1695 XCTAssertTrue([message.repeatedBoolArray valueAtIndex:1]); | |
| 1696 XCTAssertEqualObjects(@"515", message.repeatedStringArray[1]); | |
| 1697 XCTAssertEqualObjects([NSData gpbtu_dataWithUint32:516], | |
| 1698 message.repeatedBytesArray[1]); | |
| 1699 | |
| 1700 XCTAssertEqual(517, ((TestAllTypes_RepeatedGroup*)message.repeatedGroupArray[1
]).a); | |
| 1701 XCTAssertEqual(518, ((TestAllTypes_NestedMessage*)message.repeatedNestedMessag
eArray[1]).bb); | |
| 1702 XCTAssertEqual(519, ((ForeignMessage*)message.repeatedForeignMessageArray[1]).
c); | |
| 1703 XCTAssertEqual(520, ((ImportMessage*)message.repeatedImportMessageArray[1]).d)
; | |
| 1704 | |
| 1705 XCTAssertEqual(TestAllTypes_NestedEnum_Foo, [message.repeatedNestedEnumArray v
alueAtIndex:1]); | |
| 1706 XCTAssertEqual(ForeignEnum_ForeignFoo, [message.repeatedForeignEnumArray value
AtIndex:1]); | |
| 1707 XCTAssertEqual(ImportEnum_ImportFoo, [message.repeatedImportEnumArray valueAtI
ndex:1]); | |
| 1708 | |
| 1709 XCTAssertEqualObjects(@"524", message.repeatedStringPieceArray[1]); | |
| 1710 XCTAssertEqualObjects(@"525", message.repeatedCordArray[1]); | |
| 1711 } | |
| 1712 | |
| 1713 - (void)setPackedFields:(TestPackedTypes *)message | |
| 1714 repeatedCount:(uint32_t)count { | |
| 1715 // Must match -setUnpackedFields:repeatedCount: | |
| 1716 // Must match -setPackedExtensions:repeatedCount: | |
| 1717 // Must match -setUnpackedExtensions:repeatedCount: | |
| 1718 for (uint32_t i = 0; i < count; ++i) { | |
| 1719 [message.packedInt32Array addValue:601 + i * 100]; | |
| 1720 } | |
| 1721 for (uint32_t i = 0; i < count; ++i) { | |
| 1722 [message.packedInt64Array addValue:602 + i * 100]; | |
| 1723 } | |
| 1724 for (uint32_t i = 0; i < count; ++i) { | |
| 1725 [message.packedUint32Array addValue:603 + i * 100]; | |
| 1726 } | |
| 1727 for (uint32_t i = 0; i < count; ++i) { | |
| 1728 [message.packedUint64Array addValue:604 + i * 100]; | |
| 1729 } | |
| 1730 for (uint32_t i = 0; i < count; ++i) { | |
| 1731 [message.packedSint32Array addValue:605 + i * 100]; | |
| 1732 } | |
| 1733 for (uint32_t i = 0; i < count; ++i) { | |
| 1734 [message.packedSint64Array addValue:606 + i * 100]; | |
| 1735 } | |
| 1736 for (uint32_t i = 0; i < count; ++i) { | |
| 1737 [message.packedFixed32Array addValue:607 + i * 100]; | |
| 1738 } | |
| 1739 for (uint32_t i = 0; i < count; ++i) { | |
| 1740 [message.packedFixed64Array addValue:608 + i * 100]; | |
| 1741 } | |
| 1742 for (uint32_t i = 0; i < count; ++i) { | |
| 1743 [message.packedSfixed32Array addValue:609 + i * 100]; | |
| 1744 } | |
| 1745 for (uint32_t i = 0; i < count; ++i) { | |
| 1746 [message.packedSfixed64Array addValue:610 + i * 100]; | |
| 1747 } | |
| 1748 for (uint32_t i = 0; i < count; ++i) { | |
| 1749 [message.packedFloatArray addValue:611 + i * 100]; | |
| 1750 } | |
| 1751 for (uint32_t i = 0; i < count; ++i) { | |
| 1752 [message.packedDoubleArray addValue:612 + i * 100]; | |
| 1753 } | |
| 1754 for (uint32_t i = 0; i < count; ++i) { | |
| 1755 [message.packedBoolArray addValue:(i % 2) ? YES : NO]; | |
| 1756 } | |
| 1757 for (uint32_t i = 0; i < count; ++i) { | |
| 1758 [message.packedEnumArray | |
| 1759 addValue:(i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz]; | |
| 1760 } | |
| 1761 } | |
| 1762 | |
| 1763 - (void)setUnpackedFields:(TestUnpackedTypes *)message | |
| 1764 repeatedCount:(uint32_t)count { | |
| 1765 // Must match -setPackedFields:repeatedCount: | |
| 1766 // Must match -setPackedExtensions:repeatedCount: | |
| 1767 // Must match -setUnpackedExtensions:repeatedCount: | |
| 1768 for (uint32_t i = 0; i < count; ++i) { | |
| 1769 [message.unpackedInt32Array addValue:601 + i * 100]; | |
| 1770 } | |
| 1771 for (uint32_t i = 0; i < count; ++i) { | |
| 1772 [message.unpackedInt64Array addValue:602 + i * 100]; | |
| 1773 } | |
| 1774 for (uint32_t i = 0; i < count; ++i) { | |
| 1775 [message.unpackedUint32Array addValue:603 + i * 100]; | |
| 1776 } | |
| 1777 for (uint32_t i = 0; i < count; ++i) { | |
| 1778 [message.unpackedUint64Array addValue:604 + i * 100]; | |
| 1779 } | |
| 1780 for (uint32_t i = 0; i < count; ++i) { | |
| 1781 [message.unpackedSint32Array addValue:605 + i * 100]; | |
| 1782 } | |
| 1783 for (uint32_t i = 0; i < count; ++i) { | |
| 1784 [message.unpackedSint64Array addValue:606 + i * 100]; | |
| 1785 } | |
| 1786 for (uint32_t i = 0; i < count; ++i) { | |
| 1787 [message.unpackedFixed32Array addValue:607 + i * 100]; | |
| 1788 } | |
| 1789 for (uint32_t i = 0; i < count; ++i) { | |
| 1790 [message.unpackedFixed64Array addValue:608 + i * 100]; | |
| 1791 } | |
| 1792 for (uint32_t i = 0; i < count; ++i) { | |
| 1793 [message.unpackedSfixed32Array addValue:609 + i * 100]; | |
| 1794 } | |
| 1795 for (uint32_t i = 0; i < count; ++i) { | |
| 1796 [message.unpackedSfixed64Array addValue:610 + i * 100]; | |
| 1797 } | |
| 1798 for (uint32_t i = 0; i < count; ++i) { | |
| 1799 [message.unpackedFloatArray addValue:611 + i * 100]; | |
| 1800 } | |
| 1801 for (uint32_t i = 0; i < count; ++i) { | |
| 1802 [message.unpackedDoubleArray addValue:612 + i * 100]; | |
| 1803 } | |
| 1804 for (uint32_t i = 0; i < count; ++i) { | |
| 1805 [message.unpackedBoolArray addValue:(i % 2) ? YES : NO]; | |
| 1806 } | |
| 1807 for (uint32_t i = 0; i < count; ++i) { | |
| 1808 [message.unpackedEnumArray | |
| 1809 addValue:(i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz]; | |
| 1810 } | |
| 1811 } | |
| 1812 | |
| 1813 - (void)assertPackedFieldsSet:(TestPackedTypes *)message | |
| 1814 repeatedCount:(uint32_t)count { | |
| 1815 XCTAssertEqual(count, message.packedInt32Array.count); | |
| 1816 XCTAssertEqual(count, message.packedInt64Array.count); | |
| 1817 XCTAssertEqual(count, message.packedUint32Array.count); | |
| 1818 XCTAssertEqual(count, message.packedUint64Array.count); | |
| 1819 XCTAssertEqual(count, message.packedSint32Array.count); | |
| 1820 XCTAssertEqual(count, message.packedSint64Array.count); | |
| 1821 XCTAssertEqual(count, message.packedFixed32Array.count); | |
| 1822 XCTAssertEqual(count, message.packedFixed64Array.count); | |
| 1823 XCTAssertEqual(count, message.packedSfixed32Array.count); | |
| 1824 XCTAssertEqual(count, message.packedSfixed64Array.count); | |
| 1825 XCTAssertEqual(count, message.packedFloatArray.count); | |
| 1826 XCTAssertEqual(count, message.packedDoubleArray.count); | |
| 1827 XCTAssertEqual(count, message.packedBoolArray.count); | |
| 1828 XCTAssertEqual(count, message.packedEnumArray.count); | |
| 1829 for (uint32_t i = 0; i < count; ++i) { | |
| 1830 XCTAssertEqual((int)(601 + i * 100), | |
| 1831 [message.packedInt32Array valueAtIndex:i]); | |
| 1832 XCTAssertEqual(602 + i * 100, [message.packedInt64Array valueAtIndex:i]); | |
| 1833 XCTAssertEqual(603 + i * 100, [message.packedUint32Array valueAtIndex:i]); | |
| 1834 XCTAssertEqual(604 + i * 100, [message.packedUint64Array valueAtIndex:i]); | |
| 1835 XCTAssertEqual((int)(605 + i * 100), | |
| 1836 [message.packedSint32Array valueAtIndex:i]); | |
| 1837 XCTAssertEqual(606 + i * 100, [message.packedSint64Array valueAtIndex:i]); | |
| 1838 XCTAssertEqual(607 + i * 100, [message.packedFixed32Array valueAtIndex:i]); | |
| 1839 XCTAssertEqual(608 + i * 100, [message.packedFixed64Array valueAtIndex:i]); | |
| 1840 XCTAssertEqual((int)(609 + i * 100), | |
| 1841 [message.packedSfixed32Array valueAtIndex:i]); | |
| 1842 XCTAssertEqual(610 + i * 100, [message.packedSfixed64Array valueAtIndex:i]); | |
| 1843 XCTAssertEqualWithAccuracy(611 + i * 100, | |
| 1844 [message.packedFloatArray valueAtIndex:i], 0.01); | |
| 1845 XCTAssertEqualWithAccuracy( | |
| 1846 612 + i * 100, [message.packedDoubleArray valueAtIndex:i], 0.01); | |
| 1847 XCTAssertEqual((i % 2) ? YES : NO, | |
| 1848 [message.packedBoolArray valueAtIndex:i]); | |
| 1849 XCTAssertEqual((i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz, | |
| 1850 [message.packedEnumArray valueAtIndex:i]); | |
| 1851 } | |
| 1852 } | |
| 1853 | |
| 1854 - (void)setPackedExtensions:(TestPackedExtensions *)message | |
| 1855 repeatedCount:(uint32_t)count { | |
| 1856 // Must match -setPackedFields:repeatedCount: | |
| 1857 // Must match -setUnpackedFields:repeatedCount: | |
| 1858 // Must match -setUnpackedExtensions:repeatedCount: | |
| 1859 for (uint32_t i = 0; i < count; i++) { | |
| 1860 [message addExtension:[UnittestRoot packedInt32Extension] | |
| 1861 value:@(601 + i * 100)]; | |
| 1862 [message addExtension:[UnittestRoot packedInt64Extension] | |
| 1863 value:@(602 + i * 100)]; | |
| 1864 [message addExtension:[UnittestRoot packedUint32Extension] | |
| 1865 value:@(603 + i * 100)]; | |
| 1866 [message addExtension:[UnittestRoot packedUint64Extension] | |
| 1867 value:@(604 + i * 100)]; | |
| 1868 [message addExtension:[UnittestRoot packedSint32Extension] | |
| 1869 value:@(605 + i * 100)]; | |
| 1870 [message addExtension:[UnittestRoot packedSint64Extension] | |
| 1871 value:@(606 + i * 100)]; | |
| 1872 [message addExtension:[UnittestRoot packedFixed32Extension] | |
| 1873 value:@(607 + i * 100)]; | |
| 1874 [message addExtension:[UnittestRoot packedFixed64Extension] | |
| 1875 value:@(608 + i * 100)]; | |
| 1876 [message addExtension:[UnittestRoot packedSfixed32Extension] | |
| 1877 value:@(609 + i * 100)]; | |
| 1878 [message addExtension:[UnittestRoot packedSfixed64Extension] | |
| 1879 value:@(610 + i * 100)]; | |
| 1880 [message addExtension:[UnittestRoot packedFloatExtension] | |
| 1881 value:@(611 + i * 100)]; | |
| 1882 [message addExtension:[UnittestRoot packedDoubleExtension] | |
| 1883 value:@(612 + i * 100)]; | |
| 1884 [message addExtension:[UnittestRoot packedBoolExtension] | |
| 1885 value:@((i % 2) ? YES : NO)]; | |
| 1886 [message addExtension:[UnittestRoot packedEnumExtension] | |
| 1887 value:@((i % 2) ? ForeignEnum_ForeignBar | |
| 1888 : ForeignEnum_ForeignBaz)]; | |
| 1889 } | |
| 1890 } | |
| 1891 | |
| 1892 - (void)setUnpackedExtensions:(TestUnpackedExtensions *)message | |
| 1893 repeatedCount:(uint32_t)count { | |
| 1894 // Must match -setPackedFields:repeatedCount: | |
| 1895 // Must match -setUnpackedFields:repeatedCount: | |
| 1896 // Must match -setPackedExtensions:repeatedCount: | |
| 1897 for (uint32_t i = 0; i < count; i++) { | |
| 1898 [message addExtension:[UnittestRoot unpackedInt32Extension] | |
| 1899 value:@(601 + i * 100)]; | |
| 1900 [message addExtension:[UnittestRoot unpackedInt64Extension] | |
| 1901 value:@(602 + i * 100)]; | |
| 1902 [message addExtension:[UnittestRoot unpackedUint32Extension] | |
| 1903 value:@(603 + i * 100)]; | |
| 1904 [message addExtension:[UnittestRoot unpackedUint64Extension] | |
| 1905 value:@(604 + i * 100)]; | |
| 1906 [message addExtension:[UnittestRoot unpackedSint32Extension] | |
| 1907 value:@(605 + i * 100)]; | |
| 1908 [message addExtension:[UnittestRoot unpackedSint64Extension] | |
| 1909 value:@(606 + i * 100)]; | |
| 1910 [message addExtension:[UnittestRoot unpackedFixed32Extension] | |
| 1911 value:@(607 + i * 100)]; | |
| 1912 [message addExtension:[UnittestRoot unpackedFixed64Extension] | |
| 1913 value:@(608 + i * 100)]; | |
| 1914 [message addExtension:[UnittestRoot unpackedSfixed32Extension] | |
| 1915 value:@(609 + i * 100)]; | |
| 1916 [message addExtension:[UnittestRoot unpackedSfixed64Extension] | |
| 1917 value:@(610 + i * 100)]; | |
| 1918 [message addExtension:[UnittestRoot unpackedFloatExtension] | |
| 1919 value:@(611 + i * 100)]; | |
| 1920 [message addExtension:[UnittestRoot unpackedDoubleExtension] | |
| 1921 value:@(612 + i * 100)]; | |
| 1922 [message addExtension:[UnittestRoot unpackedBoolExtension] | |
| 1923 value:@((i % 2) ? YES : NO)]; | |
| 1924 [message addExtension:[UnittestRoot unpackedEnumExtension] | |
| 1925 value:@((i % 2) ? ForeignEnum_ForeignBar | |
| 1926 : ForeignEnum_ForeignBaz)]; | |
| 1927 } | |
| 1928 } | |
| 1929 | |
| 1930 - (void)assertPackedExtensionsSet:(TestPackedExtensions *)message | |
| 1931 repeatedCount:(uint32_t)count{ | |
| 1932 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedInt32Extensio
n]] count]); | |
| 1933 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedInt64Extensio
n]] count]); | |
| 1934 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedUint32Extensi
on]] count]); | |
| 1935 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedUint64Extensi
on]] count]); | |
| 1936 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedSint32Extensi
on]] count]); | |
| 1937 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedSint64Extensi
on]] count]); | |
| 1938 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedFixed32Extens
ion]] count]); | |
| 1939 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedFixed64Extens
ion]] count]); | |
| 1940 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedSfixed32Exten
sion]] count]); | |
| 1941 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedSfixed64Exten
sion]] count]); | |
| 1942 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedFloatExtensio
n]] count]); | |
| 1943 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedDoubleExtensi
on]] count]); | |
| 1944 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedBoolExtension
]] count]); | |
| 1945 XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedEnumExtension
]] count]); | |
| 1946 | |
| 1947 for (uint32_t i = 0; i < count; ++i) { | |
| 1948 id extension = [message getExtension:[UnittestRoot packedInt32Extension]]; | |
| 1949 XCTAssertEqual((int)(601 + i * 100), [extension[i] intValue]); | |
| 1950 extension = [message getExtension:[UnittestRoot packedInt64Extension]]; | |
| 1951 XCTAssertEqual(602 + i * 100, [extension[i] longLongValue]); | |
| 1952 extension = [message getExtension:[UnittestRoot packedUint32Extension]]; | |
| 1953 XCTAssertEqual(603 + i * 100, [extension[i] unsignedIntValue]); | |
| 1954 extension = [message getExtension:[UnittestRoot packedUint64Extension]]; | |
| 1955 XCTAssertEqual(604 + i * 100, [extension[i] unsignedLongLongValue]); | |
| 1956 extension = [message getExtension:[UnittestRoot packedSint32Extension]]; | |
| 1957 XCTAssertEqual((int)(605 + i * 100), [extension[i] intValue]); | |
| 1958 extension = [message getExtension:[UnittestRoot packedSint64Extension]]; | |
| 1959 XCTAssertEqual(606 + i * 100, [extension[i] longLongValue]); | |
| 1960 extension = [message getExtension:[UnittestRoot packedFixed32Extension]]; | |
| 1961 XCTAssertEqual(607 + i * 100, [extension[i] unsignedIntValue]); | |
| 1962 extension = [message getExtension:[UnittestRoot packedFixed64Extension]]; | |
| 1963 XCTAssertEqual(608 + i * 100, [extension[i] unsignedLongLongValue]); | |
| 1964 extension = [message getExtension:[UnittestRoot packedSfixed32Extension]]; | |
| 1965 XCTAssertEqual((int)(609 + i * 100), [extension[i] intValue]); | |
| 1966 extension = [message getExtension:[UnittestRoot packedSfixed64Extension]]; | |
| 1967 XCTAssertEqual(610 + i * 100, [extension[i] longLongValue]); | |
| 1968 extension = [message getExtension:[UnittestRoot packedFloatExtension]]; | |
| 1969 XCTAssertEqualWithAccuracy(611 + i * 100, [extension[i] floatValue], 0.01); | |
| 1970 extension = [message getExtension:[UnittestRoot packedDoubleExtension]]; | |
| 1971 XCTAssertEqualWithAccuracy(612 + i * 100, [extension[i] doubleValue], 0.01); | |
| 1972 extension = [message getExtension:[UnittestRoot packedBoolExtension]]; | |
| 1973 XCTAssertEqual((i % 2) ? YES : NO, [extension[i] boolValue]); | |
| 1974 extension = [message getExtension:[UnittestRoot packedEnumExtension]]; | |
| 1975 XCTAssertEqual((i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz, | |
| 1976 [extension[i] intValue]); | |
| 1977 } | |
| 1978 } | |
| 1979 | |
| 1980 - (void)assertAllFieldsKVCMatch:(TestAllTypes *)message { | |
| 1981 XCTAssertEqualObjects([message valueForKey:@"hasOptionalInt32"], @YES); | |
| 1982 XCTAssertEqualObjects(@(message.optionalInt32), [message valueForKey:@"optiona
lInt32"]); | |
| 1983 XCTAssertEqualObjects([message valueForKey:@"hasOptionalInt64"], @YES); | |
| 1984 XCTAssertEqualObjects(@(message.optionalInt64), [message valueForKey:@"optiona
lInt64"]); | |
| 1985 XCTAssertEqualObjects([message valueForKey:@"hasOptionalUint32"], @YES); | |
| 1986 XCTAssertEqualObjects(@(message.optionalUint32), [message valueForKey:@"option
alUint32"]); | |
| 1987 XCTAssertEqualObjects([message valueForKey:@"hasOptionalUint64"], @YES); | |
| 1988 XCTAssertEqualObjects(@(message.optionalUint64), [message valueForKey:@"option
alUint64"]); | |
| 1989 XCTAssertEqualObjects([message valueForKey:@"hasOptionalSint32"], @YES); | |
| 1990 XCTAssertEqualObjects(@(message.optionalSint32), [message valueForKey:@"option
alSint32"]); | |
| 1991 XCTAssertEqualObjects([message valueForKey:@"hasOptionalSint64"], @YES); | |
| 1992 XCTAssertEqualObjects(@(message.optionalSint64), [message valueForKey:@"option
alSint64"]); | |
| 1993 XCTAssertEqualObjects([message valueForKey:@"hasOptionalFixed32"], @YES); | |
| 1994 XCTAssertEqualObjects(@(message.optionalFixed32), [message valueForKey:@"optio
nalFixed32"]); | |
| 1995 XCTAssertEqualObjects([message valueForKey:@"hasOptionalFixed64"], @YES); | |
| 1996 XCTAssertEqualObjects(@(message.optionalFixed64), [message valueForKey:@"optio
nalFixed64"]); | |
| 1997 XCTAssertEqualObjects([message valueForKey:@"hasOptionalSfixed32"], @YES); | |
| 1998 XCTAssertEqualObjects(@(message.optionalSfixed32), [message valueForKey:@"opti
onalSfixed32"]); | |
| 1999 XCTAssertEqualObjects([message valueForKey:@"hasOptionalSfixed64"], @YES); | |
| 2000 XCTAssertEqualObjects(@(message.optionalSfixed64), [message valueForKey:@"opti
onalSfixed64"]); | |
| 2001 XCTAssertEqualObjects([message valueForKey:@"hasOptionalFloat"], @YES); | |
| 2002 XCTAssertEqualObjects(@(message.optionalFloat), [message valueForKey:@"optiona
lFloat"]); | |
| 2003 XCTAssertEqualObjects([message valueForKey:@"hasOptionalDouble"], @YES); | |
| 2004 XCTAssertEqualObjects(@(message.optionalDouble), [message valueForKey:@"option
alDouble"]); | |
| 2005 XCTAssertEqualObjects([message valueForKey:@"hasOptionalBool"], @YES); | |
| 2006 XCTAssertEqualObjects(@(message.optionalBool), [message valueForKey:@"optional
Bool"]); | |
| 2007 XCTAssertEqualObjects([message valueForKey:@"hasOptionalString"], @YES); | |
| 2008 XCTAssertEqualObjects(message.optionalString, [message valueForKey:@"optionalS
tring"]); | |
| 2009 XCTAssertEqualObjects([message valueForKey:@"hasOptionalBytes"], @YES); | |
| 2010 XCTAssertEqualObjects(message.optionalBytes, [message valueForKey:@"optionalBy
tes"]); | |
| 2011 | |
| 2012 XCTAssertEqualObjects([message valueForKey:@"hasOptionalGroup"], @YES); | |
| 2013 XCTAssertNotNil(message.optionalGroup); | |
| 2014 XCTAssertEqualObjects([message valueForKeyPath:@"optionalGroup.hasA"], @YES); | |
| 2015 XCTAssertEqualObjects(@(message.optionalGroup.a), [message valueForKeyPath:@"o
ptionalGroup.a"]); | |
| 2016 XCTAssertEqualObjects([message valueForKey:@"hasOptionalNestedMessage"], @YES)
; | |
| 2017 XCTAssertNotNil(message.optionalNestedMessage); | |
| 2018 XCTAssertEqualObjects([message valueForKeyPath:@"optionalNestedMessage.hasBb"]
, @YES); | |
| 2019 XCTAssertEqualObjects(@(message.optionalNestedMessage.bb), [message valueForKe
yPath:@"optionalNestedMessage.bb"]); | |
| 2020 XCTAssertEqualObjects([message valueForKey:@"hasOptionalForeignMessage"], @YES
); | |
| 2021 XCTAssertNotNil(message.optionalForeignMessage); | |
| 2022 XCTAssertEqualObjects([message valueForKeyPath:@"optionalForeignMessage.hasC"]
, @YES); | |
| 2023 XCTAssertEqualObjects(@(message.optionalForeignMessage.c), [message valueForKe
yPath:@"optionalForeignMessage.c"]); | |
| 2024 XCTAssertEqualObjects([message valueForKey:@"hasOptionalImportMessage"], @YES)
; | |
| 2025 XCTAssertNotNil(message.optionalForeignMessage); | |
| 2026 XCTAssertEqualObjects([message valueForKeyPath:@"optionalImportMessage.hasD"],
@YES); | |
| 2027 XCTAssertEqualObjects(@(message.optionalImportMessage.d), [message valueForKey
Path:@"optionalImportMessage.d"]); | |
| 2028 | |
| 2029 XCTAssertEqualObjects([message valueForKey:@"hasOptionalNestedEnum"], @YES); | |
| 2030 XCTAssertEqualObjects(@(message.optionalNestedEnum), [message valueForKey:@"op
tionalNestedEnum"]); | |
| 2031 XCTAssertEqualObjects([message valueForKey:@"hasOptionalForeignEnum"], @YES); | |
| 2032 XCTAssertEqualObjects(@(message.optionalForeignEnum), [message valueForKey:@"o
ptionalForeignEnum"]); | |
| 2033 XCTAssertEqualObjects([message valueForKey:@"hasOptionalImportEnum"], @YES); | |
| 2034 XCTAssertEqualObjects(@(message.optionalImportEnum), [message valueForKey:@"op
tionalImportEnum"]); | |
| 2035 | |
| 2036 XCTAssertEqualObjects([message valueForKey:@"hasOptionalStringPiece"], @YES); | |
| 2037 XCTAssertEqualObjects(message.optionalStringPiece, [message valueForKey:@"opti
onalStringPiece"]); | |
| 2038 XCTAssertEqualObjects([message valueForKey:@"hasOptionalCord"], @YES); | |
| 2039 XCTAssertEqualObjects(message.optionalCord, [message valueForKey:@"optionalCor
d"]); | |
| 2040 | |
| 2041 // ----------------------------------------------------------------- | |
| 2042 | |
| 2043 // GPBArray interface for repeated | |
| 2044 | |
| 2045 XCTAssertEqualObjects(message.repeatedInt32Array, [message valueForKey:@"repea
tedInt32Array"]); | |
| 2046 XCTAssertEqualObjects(message.repeatedInt64Array, [message valueForKey:@"repea
tedInt64Array"]); | |
| 2047 XCTAssertEqualObjects(message.repeatedUint32Array, [message valueForKey:@"repe
atedUint32Array"]); | |
| 2048 XCTAssertEqualObjects(message.repeatedUint64Array, [message valueForKey:@"repe
atedUint64Array"]); | |
| 2049 XCTAssertEqualObjects(message.repeatedSint32Array, [message valueForKey:@"repe
atedSint32Array"]); | |
| 2050 XCTAssertEqualObjects(message.repeatedSint64Array, [message valueForKey:@"repe
atedSint64Array"]); | |
| 2051 XCTAssertEqualObjects(message.repeatedFixed32Array, [message valueForKey:@"rep
eatedFixed32Array"]); | |
| 2052 XCTAssertEqualObjects(message.repeatedFixed64Array, [message valueForKey:@"rep
eatedFixed64Array"]); | |
| 2053 XCTAssertEqualObjects(message.repeatedSfixed32Array, [message valueForKey:@"re
peatedSfixed32Array"]); | |
| 2054 XCTAssertEqualObjects(message.repeatedSfixed64Array, [message valueForKey:@"re
peatedSfixed64Array"]); | |
| 2055 XCTAssertEqualObjects(message.repeatedFloatArray, [message valueForKey:@"repea
tedFloatArray"]); | |
| 2056 XCTAssertEqualObjects(message.repeatedDoubleArray, [message valueForKey:@"repe
atedDoubleArray"]); | |
| 2057 XCTAssertEqualObjects(message.repeatedBoolArray, [message valueForKey:@"repeat
edBoolArray"]); | |
| 2058 XCTAssertEqualObjects(message.repeatedStringArray, [message valueForKey:@"repe
atedStringArray"]); | |
| 2059 XCTAssertEqualObjects(message.repeatedBytesArray, [message valueForKey:@"repea
tedBytesArray"]); | |
| 2060 | |
| 2061 XCTAssertEqualObjects(message.repeatedGroupArray, [message valueForKey:@"repea
tedGroupArray"]); | |
| 2062 XCTAssertEqualObjects(message.repeatedNestedMessageArray, [message valueForKey
:@"repeatedNestedMessageArray"]); | |
| 2063 XCTAssertEqualObjects(message.repeatedForeignMessageArray, [message valueForKe
y:@"repeatedForeignMessageArray"]); | |
| 2064 XCTAssertEqualObjects(message.repeatedImportMessageArray, [message valueForKey
:@"repeatedImportMessageArray"]); | |
| 2065 | |
| 2066 XCTAssertEqualObjects(message.repeatedNestedEnumArray, [message valueForKey:@"
repeatedNestedEnumArray"]); | |
| 2067 XCTAssertEqualObjects(message.repeatedForeignEnumArray, [message valueForKey:@
"repeatedForeignEnumArray"]); | |
| 2068 XCTAssertEqualObjects(message.repeatedImportEnumArray, [message valueForKey:@"
repeatedImportEnumArray"]); | |
| 2069 | |
| 2070 XCTAssertEqualObjects(message.repeatedStringPieceArray, [message valueForKey:@
"repeatedStringPieceArray"]); | |
| 2071 XCTAssertEqualObjects(message.repeatedCordArray, [message valueForKey:@"repeat
edCordArray"]); | |
| 2072 | |
| 2073 XCTAssertEqualObjects(@(message.repeatedInt32Array_Count), [message valueForKe
y:@"repeatedInt32Array_Count"]); | |
| 2074 XCTAssertEqualObjects(@(message.repeatedInt64Array_Count), [message valueForKe
y:@"repeatedInt64Array_Count"]); | |
| 2075 XCTAssertEqualObjects(@(message.repeatedUint32Array_Count), [message valueForK
ey:@"repeatedUint32Array_Count"]); | |
| 2076 XCTAssertEqualObjects(@(message.repeatedUint64Array_Count), [message valueForK
ey:@"repeatedUint64Array_Count"]); | |
| 2077 XCTAssertEqualObjects(@(message.repeatedSint32Array_Count), [message valueForK
ey:@"repeatedSint32Array_Count"]); | |
| 2078 XCTAssertEqualObjects(@(message.repeatedSint64Array_Count), [message valueForK
ey:@"repeatedSint64Array_Count"]); | |
| 2079 XCTAssertEqualObjects(@(message.repeatedFixed32Array_Count), [message valueFor
Key:@"repeatedFixed32Array_Count"]); | |
| 2080 XCTAssertEqualObjects(@(message.repeatedFixed64Array_Count), [message valueFor
Key:@"repeatedFixed64Array_Count"]); | |
| 2081 XCTAssertEqualObjects(@(message.repeatedSfixed32Array_Count), [message valueFo
rKey:@"repeatedSfixed32Array_Count"]); | |
| 2082 XCTAssertEqualObjects(@(message.repeatedSfixed64Array_Count), [message valueFo
rKey:@"repeatedSfixed64Array_Count"]); | |
| 2083 XCTAssertEqualObjects(@(message.repeatedFloatArray_Count), [message valueForKe
y:@"repeatedFloatArray_Count"]); | |
| 2084 XCTAssertEqualObjects(@(message.repeatedDoubleArray_Count), [message valueForK
ey:@"repeatedDoubleArray_Count"]); | |
| 2085 XCTAssertEqualObjects(@(message.repeatedBoolArray_Count), [message valueForKey
:@"repeatedBoolArray_Count"]); | |
| 2086 XCTAssertEqualObjects(@(message.repeatedStringArray_Count), [message valueForK
ey:@"repeatedStringArray_Count"]); | |
| 2087 XCTAssertEqualObjects(@(message.repeatedBytesArray_Count), [message valueForKe
y:@"repeatedBytesArray_Count"]); | |
| 2088 | |
| 2089 XCTAssertEqualObjects(@(message.repeatedGroupArray_Count), [message valueForKe
y:@"repeatedGroupArray_Count"]); | |
| 2090 XCTAssertEqualObjects(@(message.repeatedNestedMessageArray_Count), [message va
lueForKey:@"repeatedNestedMessageArray_Count"]); | |
| 2091 XCTAssertEqualObjects(@(message.repeatedForeignMessageArray_Count), [message v
alueForKey:@"repeatedForeignMessageArray_Count"]); | |
| 2092 XCTAssertEqualObjects(@(message.repeatedImportMessageArray_Count), [message va
lueForKey:@"repeatedImportMessageArray_Count"]); | |
| 2093 | |
| 2094 XCTAssertEqualObjects(@(message.repeatedNestedEnumArray_Count), [message value
ForKey:@"repeatedNestedEnumArray_Count"]); | |
| 2095 XCTAssertEqualObjects(@(message.repeatedForeignEnumArray_Count), [message valu
eForKey:@"repeatedForeignEnumArray_Count"]); | |
| 2096 XCTAssertEqualObjects(@(message.repeatedImportEnumArray_Count), [message value
ForKey:@"repeatedImportEnumArray_Count"]); | |
| 2097 | |
| 2098 XCTAssertEqualObjects(@(message.repeatedStringPieceArray_Count), [message valu
eForKey:@"repeatedStringPieceArray_Count"]); | |
| 2099 XCTAssertEqualObjects(@(message.repeatedCordArray_Count), [message valueForKey
:@"repeatedCordArray_Count"]); | |
| 2100 | |
| 2101 // ----------------------------------------------------------------- | |
| 2102 | |
| 2103 XCTAssertEqualObjects([message valueForKey:@"hasDefaultInt32"], @YES); | |
| 2104 XCTAssertEqualObjects(@(message.defaultInt32), [message valueForKey:@"defaultI
nt32"]); | |
| 2105 XCTAssertEqualObjects([message valueForKey:@"hasDefaultInt64"], @YES); | |
| 2106 XCTAssertEqualObjects(@(message.defaultInt64), [message valueForKey:@"defaultI
nt64"]); | |
| 2107 XCTAssertEqualObjects([message valueForKey:@"hasDefaultUint32"], @YES); | |
| 2108 XCTAssertEqualObjects(@(message.defaultUint32), [message valueForKey:@"default
Uint32"]); | |
| 2109 XCTAssertEqualObjects([message valueForKey:@"hasDefaultUint64"], @YES); | |
| 2110 XCTAssertEqualObjects(@(message.defaultUint64), [message valueForKey:@"default
Uint64"]); | |
| 2111 XCTAssertEqualObjects([message valueForKey:@"hasDefaultSint32"], @YES); | |
| 2112 XCTAssertEqualObjects(@(message.defaultSint32), [message valueForKey:@"default
Sint32"]); | |
| 2113 XCTAssertEqualObjects([message valueForKey:@"hasDefaultSint64"], @YES); | |
| 2114 XCTAssertEqualObjects(@(message.defaultSint64), [message valueForKey:@"default
Sint64"]); | |
| 2115 XCTAssertEqualObjects([message valueForKey:@"hasDefaultFixed32"], @YES); | |
| 2116 XCTAssertEqualObjects(@(message.defaultFixed32), [message valueForKey:@"defaul
tFixed32"]); | |
| 2117 XCTAssertEqualObjects([message valueForKey:@"hasDefaultFixed64"], @YES); | |
| 2118 XCTAssertEqualObjects(@(message.defaultFixed64), [message valueForKey:@"defaul
tFixed64"]); | |
| 2119 XCTAssertEqualObjects([message valueForKey:@"hasDefaultSfixed32"], @YES); | |
| 2120 XCTAssertEqualObjects(@(message.defaultSfixed32), [message valueForKey:@"defau
ltSfixed32"]); | |
| 2121 XCTAssertEqualObjects([message valueForKey:@"hasDefaultSfixed64"], @YES); | |
| 2122 XCTAssertEqualObjects(@(message.defaultSfixed64), [message valueForKey:@"defau
ltSfixed64"]); | |
| 2123 XCTAssertEqualObjects([message valueForKey:@"hasDefaultFloat"], @YES); | |
| 2124 XCTAssertEqualObjects(@(message.defaultFloat), [message valueForKey:@"defaultF
loat"]); | |
| 2125 XCTAssertEqualObjects([message valueForKey:@"hasDefaultDouble"], @YES); | |
| 2126 XCTAssertEqualObjects(@(message.defaultDouble), [message valueForKey:@"default
Double"]); | |
| 2127 XCTAssertEqualObjects([message valueForKey:@"hasDefaultBool"], @YES); | |
| 2128 XCTAssertEqualObjects(@(message.defaultBool), [message valueForKey:@"defaultBo
ol"]); | |
| 2129 XCTAssertEqualObjects([message valueForKey:@"hasDefaultString"], @YES); | |
| 2130 XCTAssertEqualObjects(message.defaultString, [message valueForKey:@"defaultStr
ing"]); | |
| 2131 XCTAssertEqualObjects([message valueForKey:@"hasDefaultBytes"], @YES); | |
| 2132 XCTAssertEqualObjects(message.defaultBytes, [message valueForKey:@"defaultByte
s"]); | |
| 2133 | |
| 2134 XCTAssertEqualObjects([message valueForKey:@"hasDefaultNestedEnum"], @YES); | |
| 2135 XCTAssertEqualObjects(@(message.defaultNestedEnum), [message valueForKey:@"def
aultNestedEnum"]); | |
| 2136 XCTAssertEqualObjects([message valueForKey:@"hasDefaultForeignEnum"], @YES); | |
| 2137 XCTAssertEqualObjects(@(message.defaultForeignEnum), [message valueForKey:@"de
faultForeignEnum"]); | |
| 2138 XCTAssertEqualObjects([message valueForKey:@"hasDefaultImportEnum"], @YES); | |
| 2139 XCTAssertEqualObjects(@(message.defaultImportEnum), [message valueForKey:@"def
aultImportEnum"]); | |
| 2140 | |
| 2141 XCTAssertEqualObjects([message valueForKey:@"hasDefaultStringPiece"], @YES); | |
| 2142 XCTAssertEqualObjects(message.defaultStringPiece, [message valueForKey:@"defau
ltStringPiece"]); | |
| 2143 XCTAssertEqualObjects([message valueForKey:@"hasDefaultCord"], @YES); | |
| 2144 XCTAssertEqualObjects(message.defaultCord, [message valueForKey:@"defaultCord"
]); | |
| 2145 } | |
| 2146 | |
| 2147 - (void)setAllFieldsViaKVC:(TestAllTypes *)message | |
| 2148 repeatedCount:(uint32_t)count { | |
| 2149 [message setValue:@101 forKey:@"optionalInt32"]; | |
| 2150 [message setValue:@102 forKey:@"optionalInt64"]; | |
| 2151 [message setValue:@103 forKey:@"optionalUint32"]; | |
| 2152 [message setValue:@104 forKey:@"optionalUint64"]; | |
| 2153 [message setValue:@105 forKey:@"optionalSint32"]; | |
| 2154 [message setValue:@106 forKey:@"optionalSint64"]; | |
| 2155 [message setValue:@107 forKey:@"optionalFixed32"]; | |
| 2156 [message setValue:@108 forKey:@"optionalFixed64"]; | |
| 2157 [message setValue:@109 forKey:@"optionalSfixed32"]; | |
| 2158 [message setValue:@110 forKey:@"optionalSfixed64"]; | |
| 2159 [message setValue:@111 forKey:@"optionalFloat"]; | |
| 2160 [message setValue:@112 forKey:@"optionalDouble"]; | |
| 2161 [message setValue:@YES forKey:@"optionalBool"]; | |
| 2162 [message setValue:@"115" forKey:@"optionalString"]; | |
| 2163 [message setValue:[NSData gpbtu_dataWithEmbeddedNulls] | |
| 2164 forKey:@"optionalBytes"]; | |
| 2165 | |
| 2166 TestAllTypes_OptionalGroup *allTypes = [TestAllTypes_OptionalGroup message]; | |
| 2167 [allTypes setValue:@117 forKey:@"a"]; | |
| 2168 [message setValue:allTypes forKey:@"optionalGroup"]; | |
| 2169 TestAllTypes_NestedMessage *nestedMessage = | |
| 2170 [TestAllTypes_NestedMessage message]; | |
| 2171 [nestedMessage setValue:@118 forKey:@"bb"]; | |
| 2172 [message setValue:nestedMessage forKey:@"optionalNestedMessage"]; | |
| 2173 ForeignMessage *foreignMessage = [ForeignMessage message]; | |
| 2174 [foreignMessage setValue:@119 forKey:@"c"]; | |
| 2175 [message setValue:foreignMessage forKey:@"optionalForeignMessage"]; | |
| 2176 ImportMessage *importMessage = [ImportMessage message]; | |
| 2177 [importMessage setValue:@120 forKey:@"d"]; | |
| 2178 [message setValue:importMessage forKey:@"optionalImportMessage"]; | |
| 2179 | |
| 2180 [message setValue:@(TestAllTypes_NestedEnum_Baz) | |
| 2181 forKey:@"optionalNestedEnum"]; | |
| 2182 [message setValue:@(ForeignEnum_ForeignBaz) forKey:@"optionalForeignEnum"]; | |
| 2183 [message setValue:@(ImportEnum_ImportBaz) forKey:@"optionalImportEnum"]; | |
| 2184 | |
| 2185 [message setValue:@"124" forKey:@"optionalStringPiece"]; | |
| 2186 [message setValue:@"125" forKey:@"optionalCord"]; | |
| 2187 | |
| 2188 // ----------------------------------------------------------------- | |
| 2189 | |
| 2190 { | |
| 2191 GPBInt32Array *scratch = [GPBInt32Array array]; | |
| 2192 for (uint32_t i = 0; i < count; ++i) { | |
| 2193 [scratch addValue:201 + i * 100]; | |
| 2194 } | |
| 2195 [message setValue:scratch forKey:@"repeatedInt32Array"]; | |
| 2196 } | |
| 2197 { | |
| 2198 GPBInt64Array *scratch = [GPBInt64Array array]; | |
| 2199 for (uint32_t i = 0; i < count; ++i) { | |
| 2200 [scratch addValue:202 + i * 100]; | |
| 2201 } | |
| 2202 [message setValue:scratch forKey:@"repeatedInt64Array"]; | |
| 2203 } | |
| 2204 { | |
| 2205 GPBUInt32Array *scratch = [GPBUInt32Array array]; | |
| 2206 for (uint32_t i = 0; i < count; ++i) { | |
| 2207 [scratch addValue:203 + i * 100]; | |
| 2208 } | |
| 2209 [message setValue:scratch forKey:@"repeatedUint32Array"]; | |
| 2210 } | |
| 2211 { | |
| 2212 GPBUInt64Array *scratch = [GPBUInt64Array array]; | |
| 2213 for (uint32_t i = 0; i < count; ++i) { | |
| 2214 [scratch addValue:204 + i * 100]; | |
| 2215 } | |
| 2216 [message setValue:scratch forKey:@"repeatedUint64Array"]; | |
| 2217 } | |
| 2218 { | |
| 2219 GPBInt32Array *scratch = [GPBInt32Array array]; | |
| 2220 for (uint32_t i = 0; i < count; ++i) { | |
| 2221 [scratch addValue:205 + i * 100]; | |
| 2222 } | |
| 2223 [message setValue:scratch forKey:@"repeatedSint32Array"]; | |
| 2224 } | |
| 2225 { | |
| 2226 GPBInt64Array *scratch = [GPBInt64Array array]; | |
| 2227 for (uint32_t i = 0; i < count; ++i) { | |
| 2228 [scratch addValue:206 + i * 100]; | |
| 2229 } | |
| 2230 [message setValue:scratch forKey:@"repeatedSint64Array"]; | |
| 2231 } | |
| 2232 { | |
| 2233 GPBUInt32Array *scratch = [GPBUInt32Array array]; | |
| 2234 for (uint32_t i = 0; i < count; ++i) { | |
| 2235 [scratch addValue:207 + i * 100]; | |
| 2236 } | |
| 2237 [message setValue:scratch forKey:@"repeatedFixed32Array"]; | |
| 2238 } | |
| 2239 { | |
| 2240 GPBUInt64Array *scratch = [GPBUInt64Array array]; | |
| 2241 for (uint32_t i = 0; i < count; ++i) { | |
| 2242 [scratch addValue:208 + i * 100]; | |
| 2243 } | |
| 2244 [message setValue:scratch forKey:@"repeatedFixed64Array"]; | |
| 2245 } | |
| 2246 { | |
| 2247 GPBInt32Array *scratch = [GPBInt32Array array]; | |
| 2248 for (uint32_t i = 0; i < count; ++i) { | |
| 2249 [scratch addValue:209 + i * 100]; | |
| 2250 } | |
| 2251 [message setValue:scratch forKey:@"repeatedSfixed32Array"]; | |
| 2252 } | |
| 2253 { | |
| 2254 GPBInt64Array *scratch = [GPBInt64Array array]; | |
| 2255 for (uint32_t i = 0; i < count; ++i) { | |
| 2256 [scratch addValue:210 + i * 100]; | |
| 2257 } | |
| 2258 [message setValue:scratch forKey:@"repeatedSfixed64Array"]; | |
| 2259 } | |
| 2260 { | |
| 2261 GPBFloatArray *scratch = [GPBFloatArray array]; | |
| 2262 for (uint32_t i = 0; i < count; ++i) { | |
| 2263 [scratch addValue:211 + i * 100]; | |
| 2264 } | |
| 2265 [message setValue:scratch forKey:@"repeatedFloatArray"]; | |
| 2266 } | |
| 2267 { | |
| 2268 GPBDoubleArray *scratch = [GPBDoubleArray array]; | |
| 2269 for (uint32_t i = 0; i < count; ++i) { | |
| 2270 [scratch addValue:212 + i * 100]; | |
| 2271 } | |
| 2272 [message setValue:scratch forKey:@"repeatedDoubleArray"]; | |
| 2273 } | |
| 2274 { | |
| 2275 GPBBoolArray *scratch = [GPBBoolArray array]; | |
| 2276 for (uint32_t i = 0; i < count; ++i) { | |
| 2277 [scratch addValue:(i % 2) ? YES : NO]; | |
| 2278 } | |
| 2279 [message setValue:scratch forKey:@"repeatedBoolArray"]; | |
| 2280 } | |
| 2281 | |
| 2282 NSMutableArray *array = [[NSMutableArray alloc] initWithCapacity:count]; | |
| 2283 for (uint32_t i = 0; i < count; ++i) { | |
| 2284 NSString *string = [[NSString alloc] initWithFormat:@"%d", 215 + i * 100]; | |
| 2285 [array addObject:string]; | |
| 2286 [string release]; | |
| 2287 } | |
| 2288 [message setValue:array forKey:@"repeatedStringArray"]; | |
| 2289 [array release]; | |
| 2290 | |
| 2291 array = [[NSMutableArray alloc] initWithCapacity:count]; | |
| 2292 for (uint32_t i = 0; i < count; ++i) { | |
| 2293 NSData *data = [[NSData alloc] initWithUint32_gpbtu:216 + i * 100]; | |
| 2294 [array addObject:data]; | |
| 2295 [data release]; | |
| 2296 } | |
| 2297 [message setValue:array forKey:@"repeatedBytesArray"]; | |
| 2298 [array release]; | |
| 2299 | |
| 2300 array = [[NSMutableArray alloc] initWithCapacity:count]; | |
| 2301 for (uint32_t i = 0; i < count; ++i) { | |
| 2302 TestAllTypes_RepeatedGroup *testAll = | |
| 2303 [[TestAllTypes_RepeatedGroup alloc] init]; | |
| 2304 [testAll setA:217 + i * 100]; | |
| 2305 [array addObject:testAll]; | |
| 2306 [testAll release]; | |
| 2307 } | |
| 2308 [message setValue:array forKey:@"repeatedGroupArray"]; | |
| 2309 [array release]; | |
| 2310 | |
| 2311 array = [[NSMutableArray alloc] initWithCapacity:count]; | |
| 2312 for (uint32_t i = 0; i < count; ++i) { | |
| 2313 nestedMessage = [[TestAllTypes_NestedMessage alloc] init]; | |
| 2314 [nestedMessage setBb:218 + i * 100]; | |
| 2315 [array addObject:nestedMessage]; | |
| 2316 [nestedMessage release]; | |
| 2317 } | |
| 2318 [message setValue:array forKey:@"repeatedNestedMessageArray"]; | |
| 2319 [array release]; | |
| 2320 | |
| 2321 array = [[NSMutableArray alloc] initWithCapacity:count]; | |
| 2322 for (uint32_t i = 0; i < count; ++i) { | |
| 2323 foreignMessage = [[ForeignMessage alloc] init]; | |
| 2324 [foreignMessage setC:219 + i * 100]; | |
| 2325 [array addObject:foreignMessage]; | |
| 2326 [foreignMessage release]; | |
| 2327 } | |
| 2328 [message setValue:array forKey:@"repeatedForeignMessageArray"]; | |
| 2329 [array release]; | |
| 2330 | |
| 2331 array = [[NSMutableArray alloc] initWithCapacity:count]; | |
| 2332 for (uint32_t i = 0; i < count; ++i) { | |
| 2333 importMessage = [[ImportMessage alloc] init]; | |
| 2334 [importMessage setD:220 + i * 100]; | |
| 2335 [array addObject:importMessage]; | |
| 2336 [importMessage release]; | |
| 2337 } | |
| 2338 [message setValue:array forKey:@"repeatedImportMessageArray"]; | |
| 2339 [array release]; | |
| 2340 | |
| 2341 { | |
| 2342 GPBEnumArray *scratch = [GPBEnumArray | |
| 2343 arrayWithValidationFunction:TestAllTypes_NestedEnum_IsValidValue]; | |
| 2344 for (uint32_t i = 0; i < count; ++i) { | |
| 2345 [scratch addValue:(i % 2) ? TestAllTypes_NestedEnum_Bar | |
| 2346 : TestAllTypes_NestedEnum_Baz]; | |
| 2347 } | |
| 2348 [message setValue:scratch forKey:@"repeatedNestedEnumArray"]; | |
| 2349 } | |
| 2350 { | |
| 2351 GPBEnumArray *scratch = | |
| 2352 [GPBEnumArray arrayWithValidationFunction:ForeignEnum_IsValidValue]; | |
| 2353 for (uint32_t i = 0; i < count; ++i) { | |
| 2354 [scratch | |
| 2355 addValue:(i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz]; | |
| 2356 } | |
| 2357 [message setValue:scratch forKey:@"repeatedForeignEnumArray"]; | |
| 2358 } | |
| 2359 { | |
| 2360 GPBEnumArray *scratch = | |
| 2361 [GPBEnumArray arrayWithValidationFunction:ImportEnum_IsValidValue]; | |
| 2362 for (uint32_t i = 0; i < count; ++i) { | |
| 2363 [scratch addValue:(i % 2) ? ImportEnum_ImportBar : ImportEnum_ImportBaz]; | |
| 2364 } | |
| 2365 [message setValue:scratch forKey:@"repeatedImportEnumArray"]; | |
| 2366 } | |
| 2367 | |
| 2368 array = [[NSMutableArray alloc] initWithCapacity:count]; | |
| 2369 for (uint32_t i = 0; i < count; ++i) { | |
| 2370 NSString *string = [[NSString alloc] initWithFormat:@"%d", 224 + i * 100]; | |
| 2371 [array addObject:string]; | |
| 2372 [string release]; | |
| 2373 } | |
| 2374 [message setValue:array forKey:@"repeatedStringPieceArray"]; | |
| 2375 [array release]; | |
| 2376 | |
| 2377 array = [[NSMutableArray alloc] initWithCapacity:count]; | |
| 2378 for (uint32_t i = 0; i < count; ++i) { | |
| 2379 NSString *string = [[NSString alloc] initWithFormat:@"%d", 225 + i * 100]; | |
| 2380 [array addObject:string]; | |
| 2381 [string release]; | |
| 2382 } | |
| 2383 [message setValue:array forKey:@"repeatedCordArray"]; | |
| 2384 [array release]; | |
| 2385 | |
| 2386 // ----------------------------------------------------------------- | |
| 2387 | |
| 2388 [message setValue:@401 forKey:@"defaultInt32"]; | |
| 2389 [message setValue:@402 forKey:@"defaultInt64"]; | |
| 2390 [message setValue:@403 forKey:@"defaultUint32"]; | |
| 2391 [message setValue:@404 forKey:@"defaultUint64"]; | |
| 2392 [message setValue:@405 forKey:@"defaultSint32"]; | |
| 2393 [message setValue:@406 forKey:@"defaultSint64"]; | |
| 2394 [message setValue:@407 forKey:@"defaultFixed32"]; | |
| 2395 [message setValue:@408 forKey:@"defaultFixed64"]; | |
| 2396 [message setValue:@409 forKey:@"defaultSfixed32"]; | |
| 2397 [message setValue:@410 forKey:@"defaultSfixed64"]; | |
| 2398 [message setValue:@411 forKey:@"defaultFloat"]; | |
| 2399 [message setValue:@412 forKey:@"defaultDouble"]; | |
| 2400 [message setValue:@NO forKey:@"defaultBool"]; | |
| 2401 [message setValue:@"415" forKey:@"defaultString"]; | |
| 2402 [message setValue:[NSData gpbtu_dataWithUint32:416] forKey:@"defaultBytes"]; | |
| 2403 | |
| 2404 [message setValue:@(TestAllTypes_NestedEnum_Foo) forKey:@"defaultNestedEnum"]; | |
| 2405 [message setValue:@(ForeignEnum_ForeignFoo) forKey:@"defaultForeignEnum"]; | |
| 2406 [message setValue:@(ImportEnum_ImportFoo) forKey:@"defaultImportEnum"]; | |
| 2407 | |
| 2408 [message setValue:@"424" forKey:@"defaultStringPiece"]; | |
| 2409 [message setValue:@"425" forKey:@"defaultCord"]; | |
| 2410 } | |
| 2411 | |
| 2412 - (void)assertClearKVC:(TestAllTypes *)message { | |
| 2413 XCTAssertEqualObjects([message valueForKey:@"hasOptionalInt32"], @NO); | |
| 2414 XCTAssertEqualObjects([message valueForKey:@"hasOptionalInt64"], @NO); | |
| 2415 XCTAssertEqualObjects([message valueForKey:@"hasOptionalUint32"], @NO); | |
| 2416 XCTAssertEqualObjects([message valueForKey:@"hasOptionalUint64"], @NO); | |
| 2417 XCTAssertEqualObjects([message valueForKey:@"hasOptionalSint32"], @NO); | |
| 2418 XCTAssertEqualObjects([message valueForKey:@"hasOptionalSint64"], @NO); | |
| 2419 XCTAssertEqualObjects([message valueForKey:@"hasOptionalFixed32"], @NO); | |
| 2420 XCTAssertEqualObjects([message valueForKey:@"hasOptionalFixed64"], @NO); | |
| 2421 XCTAssertEqualObjects([message valueForKey:@"hasOptionalSfixed32"], @NO); | |
| 2422 XCTAssertEqualObjects([message valueForKey:@"hasOptionalSfixed64"], @NO); | |
| 2423 XCTAssertEqualObjects([message valueForKey:@"hasOptionalFloat"], @NO); | |
| 2424 XCTAssertEqualObjects([message valueForKey:@"hasOptionalDouble"], @NO); | |
| 2425 XCTAssertEqualObjects([message valueForKey:@"hasOptionalBool"], @NO); | |
| 2426 XCTAssertEqualObjects([message valueForKey:@"hasOptionalString"], @NO); | |
| 2427 XCTAssertEqualObjects([message valueForKey:@"hasOptionalBytes"], @NO); | |
| 2428 | |
| 2429 XCTAssertEqualObjects([message valueForKey:@"hasOptionalGroup"], @NO); | |
| 2430 XCTAssertEqualObjects([message valueForKey:@"hasOptionalNestedMessage"], @NO); | |
| 2431 XCTAssertEqualObjects([message valueForKey:@"hasOptionalForeignMessage"], | |
| 2432 @NO); | |
| 2433 XCTAssertEqualObjects([message valueForKey:@"hasOptionalImportMessage"], @NO); | |
| 2434 | |
| 2435 XCTAssertEqualObjects([message valueForKey:@"hasOptionalNestedEnum"], @NO); | |
| 2436 XCTAssertEqualObjects([message valueForKey:@"hasOptionalForeignEnum"], @NO); | |
| 2437 XCTAssertEqualObjects([message valueForKey:@"hasOptionalImportEnum"], @NO); | |
| 2438 | |
| 2439 XCTAssertEqualObjects([message valueForKey:@"hasOptionalStringPiece"], @NO); | |
| 2440 XCTAssertEqualObjects([message valueForKey:@"hasOptionalCord"], @NO); | |
| 2441 | |
| 2442 // Optional fields without defaults are set to zero or something like it. | |
| 2443 XCTAssertEqualObjects([message valueForKey:@"optionalInt32"], @0); | |
| 2444 XCTAssertEqualObjects([message valueForKey:@"optionalInt64"], @0); | |
| 2445 XCTAssertEqualObjects([message valueForKey:@"optionalUint32"], @0); | |
| 2446 XCTAssertEqualObjects([message valueForKey:@"optionalUint64"], @0); | |
| 2447 XCTAssertEqualObjects([message valueForKey:@"optionalSint32"], @0); | |
| 2448 XCTAssertEqualObjects([message valueForKey:@"optionalSint64"], @0); | |
| 2449 XCTAssertEqualObjects([message valueForKey:@"optionalFixed32"], @0); | |
| 2450 XCTAssertEqualObjects([message valueForKey:@"optionalFixed64"], @0); | |
| 2451 XCTAssertEqualObjects([message valueForKey:@"optionalSfixed32"], @0); | |
| 2452 XCTAssertEqualObjects([message valueForKey:@"optionalSfixed64"], @0); | |
| 2453 XCTAssertEqualObjects([message valueForKey:@"optionalFloat"], @0); | |
| 2454 XCTAssertEqualObjects([message valueForKey:@"optionalDouble"], @0); | |
| 2455 XCTAssertEqualObjects([message valueForKey:@"optionalBool"], @NO); | |
| 2456 XCTAssertEqualObjects([message valueForKey:@"optionalString"], @""); | |
| 2457 XCTAssertEqualObjects([message valueForKey:@"optionalBytes"], | |
| 2458 GPBEmptyNSData()); | |
| 2459 | |
| 2460 // Embedded messages should also be exist, but be clear. | |
| 2461 XCTAssertNotNil([message valueForKeyPath:@"optionalGroup"]); | |
| 2462 XCTAssertNotNil([message valueForKeyPath:@"optionalNestedMessage"]); | |
| 2463 XCTAssertNotNil([message valueForKeyPath:@"optionalForeignMessage"]); | |
| 2464 XCTAssertNotNil([message valueForKeyPath:@"optionalImportMessage"]); | |
| 2465 XCTAssertEqualObjects([message valueForKeyPath:@"optionalGroup.hasA"], @NO); | |
| 2466 XCTAssertEqualObjects( | |
| 2467 [message valueForKeyPath:@"optionalNestedMessage.hasBb"], @NO); | |
| 2468 XCTAssertEqualObjects( | |
| 2469 [message valueForKeyPath:@"optionalForeignMessage.hasC"], @NO); | |
| 2470 XCTAssertEqualObjects([message valueForKeyPath:@"optionalImportMessage.hasD"], | |
| 2471 @NO); | |
| 2472 | |
| 2473 XCTAssertEqualObjects([message valueForKeyPath:@"optionalGroup.a"], @0); | |
| 2474 XCTAssertEqualObjects([message valueForKeyPath:@"optionalNestedMessage.bb"], | |
| 2475 @0); | |
| 2476 XCTAssertEqualObjects([message valueForKeyPath:@"optionalForeignMessage.c"], | |
| 2477 @0); | |
| 2478 XCTAssertEqualObjects([message valueForKeyPath:@"optionalImportMessage.d"], | |
| 2479 @0); | |
| 2480 | |
| 2481 // Enums without defaults are set to the first value in the enum. | |
| 2482 XCTAssertEqualObjects([message valueForKey:@"optionalNestedEnum"], | |
| 2483 @(TestAllTypes_NestedEnum_Foo)); | |
| 2484 XCTAssertEqualObjects([message valueForKey:@"optionalForeignEnum"], | |
| 2485 @(ForeignEnum_ForeignFoo)); | |
| 2486 XCTAssertEqualObjects([message valueForKey:@"optionalImportEnum"], | |
| 2487 @(ImportEnum_ImportFoo)); | |
| 2488 | |
| 2489 XCTAssertEqualObjects([message valueForKey:@"optionalStringPiece"], @""); | |
| 2490 XCTAssertEqualObjects([message valueForKey:@"optionalCord"], @""); | |
| 2491 | |
| 2492 // NSArray interface for repeated doesn't have has*, nil means no value. | |
| 2493 | |
| 2494 XCTAssertEqualObjects([message valueForKey:@"hasDefaultInt32"], @NO); | |
| 2495 XCTAssertEqualObjects([message valueForKey:@"hasDefaultInt64"], @NO); | |
| 2496 XCTAssertEqualObjects([message valueForKey:@"hasDefaultUint32"], @NO); | |
| 2497 XCTAssertEqualObjects([message valueForKey:@"hasDefaultUint64"], @NO); | |
| 2498 XCTAssertEqualObjects([message valueForKey:@"hasDefaultSint32"], @NO); | |
| 2499 XCTAssertEqualObjects([message valueForKey:@"hasDefaultSint64"], @NO); | |
| 2500 XCTAssertEqualObjects([message valueForKey:@"hasDefaultFixed32"], @NO); | |
| 2501 XCTAssertEqualObjects([message valueForKey:@"hasDefaultFixed64"], @NO); | |
| 2502 XCTAssertEqualObjects([message valueForKey:@"hasDefaultSfixed32"], @NO); | |
| 2503 XCTAssertEqualObjects([message valueForKey:@"hasDefaultSfixed64"], @NO); | |
| 2504 XCTAssertEqualObjects([message valueForKey:@"hasDefaultFloat"], @NO); | |
| 2505 XCTAssertEqualObjects([message valueForKey:@"hasDefaultDouble"], @NO); | |
| 2506 XCTAssertEqualObjects([message valueForKey:@"hasDefaultBool"], @NO); | |
| 2507 XCTAssertEqualObjects([message valueForKey:@"hasDefaultString"], @NO); | |
| 2508 XCTAssertEqualObjects([message valueForKey:@"hasDefaultBytes"], @NO); | |
| 2509 | |
| 2510 XCTAssertEqualObjects([message valueForKey:@"hasDefaultNestedEnum"], @NO); | |
| 2511 XCTAssertEqualObjects([message valueForKey:@"hasDefaultForeignEnum"], @NO); | |
| 2512 XCTAssertEqualObjects([message valueForKey:@"hasDefaultImportEnum"], @NO); | |
| 2513 | |
| 2514 XCTAssertEqualObjects([message valueForKey:@"hasDefaultStringPiece"], @NO); | |
| 2515 XCTAssertEqualObjects([message valueForKey:@"hasDefaultCord"], @NO); | |
| 2516 | |
| 2517 // Fields with defaults have their default values (duh). | |
| 2518 XCTAssertEqualObjects([message valueForKey:@"defaultInt32"], @41); | |
| 2519 XCTAssertEqualObjects([message valueForKey:@"defaultInt64"], @42); | |
| 2520 XCTAssertEqualObjects([message valueForKey:@"defaultUint32"], @43); | |
| 2521 XCTAssertEqualObjects([message valueForKey:@"defaultUint64"], @44); | |
| 2522 XCTAssertEqualObjects([message valueForKey:@"defaultSint32"], @-45); | |
| 2523 XCTAssertEqualObjects([message valueForKey:@"defaultSint64"], @46); | |
| 2524 XCTAssertEqualObjects([message valueForKey:@"defaultFixed32"], @47); | |
| 2525 XCTAssertEqualObjects([message valueForKey:@"defaultFixed64"], @48); | |
| 2526 XCTAssertEqualObjects([message valueForKey:@"defaultSfixed32"], @49); | |
| 2527 XCTAssertEqualObjects([message valueForKey:@"defaultSfixed64"], @-50); | |
| 2528 XCTAssertEqualObjects([message valueForKey:@"defaultFloat"], @51.5); | |
| 2529 XCTAssertEqualObjects([message valueForKey:@"defaultDouble"], @52e3); | |
| 2530 XCTAssertEqualObjects([message valueForKey:@"defaultBool"], @YES); | |
| 2531 XCTAssertEqualObjects([message valueForKey:@"defaultString"], @"hello"); | |
| 2532 XCTAssertEqualObjects([message valueForKey:@"defaultBytes"], | |
| 2533 [NSData gpbtu_dataWithCString:"world"]); | |
| 2534 | |
| 2535 XCTAssertEqualObjects([message valueForKey:@"defaultNestedEnum"], | |
| 2536 @(TestAllTypes_NestedEnum_Bar)); | |
| 2537 XCTAssertEqualObjects([message valueForKey:@"defaultForeignEnum"], | |
| 2538 @(ForeignEnum_ForeignBar)); | |
| 2539 XCTAssertEqualObjects([message valueForKey:@"defaultImportEnum"], | |
| 2540 @(ImportEnum_ImportBar)); | |
| 2541 | |
| 2542 XCTAssertEqualObjects([message valueForKey:@"defaultStringPiece"], @"abc"); | |
| 2543 XCTAssertEqualObjects([message valueForKey:@"defaultCord"], @"123"); | |
| 2544 } | |
| 2545 | |
| 2546 @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