| OLD | NEW |
|---|
| (Empty) | |
| 1 // Protocol Buffers - Google's data interchange format |
| 2 // Copyright 2015 Google Inc. All rights reserved. |
| 3 // https://developers.google.com/protocol-buffers/ |
| 4 // |
| 5 // Redistribution and use in source and binary forms, with or without |
| 6 // modification, are permitted provided that the following conditions are |
| 7 // met: |
| 8 // |
| 9 // * Redistributions of source code must retain the above copyright |
| 10 // notice, this list of conditions and the following disclaimer. |
| 11 // * Redistributions in binary form must reproduce the above |
| 12 // copyright notice, this list of conditions and the following disclaimer |
| 13 // in the documentation and/or other materials provided with the |
| 14 // distribution. |
| 15 // * Neither the name of Google Inc. nor the names of its |
| 16 // contributors may be used to endorse or promote products derived from |
| 17 // this software without specific prior written permission. |
| 18 // |
| 19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 30 |
| 31 #import <Foundation/Foundation.h> |
| 32 #import <XCTest/XCTest.h> |
| 33 |
| 34 #import "GPBDictionary.h" |
| 35 |
| 36 #import "GPBTestUtilities.h" |
| 37 #import "google/protobuf/UnittestRuntimeProto2.pbobjc.h" |
| 38 |
| 39 // Pull in the macros (using an external file because expanding all tests |
| 40 // in a single file makes a file that is failing to work with within Xcode. |
| 41 //%PDDM-IMPORT-DEFINES GPBDictionaryTests.pddm |
| 42 |
| 43 //%PDDM-EXPAND TEST_FOR_POD_KEY(UInt32, uint32_t, 1U, 2U, 3U, 4U) |
| 44 // This block of code is generated, do not edit it directly. |
| 45 |
| 46 // To let the testing macros work, add some extra methods to simplify things. |
| 47 @interface GPBUInt32EnumDictionary (TestingTweak) |
| 48 + (instancetype)dictionaryWithValue:(int32_t)value forKey:(uint32_t)key; |
| 49 - (instancetype)initWithValues:(const int32_t [])values |
| 50 forKeys:(const uint32_t [])keys |
| 51 count:(NSUInteger)count; |
| 52 @end |
| 53 |
| 54 static BOOL TestingEnum_IsValidValue(int32_t value) { |
| 55 switch (value) { |
| 56 case 700: |
| 57 case 701: |
| 58 case 702: |
| 59 case 703: |
| 60 return YES; |
| 61 default: |
| 62 return NO; |
| 63 } |
| 64 } |
| 65 |
| 66 @implementation GPBUInt32EnumDictionary (TestingTweak) |
| 67 + (instancetype)dictionaryWithValue:(int32_t)value forKey:(uint32_t)key { |
| 68 // Cast is needed to compiler knows what class we are invoking initWithValues:
on to get the |
| 69 // type correct. |
| 70 return [[(GPBUInt32EnumDictionary*)[self alloc] initWithValidationFunction:Tes
tingEnum_IsValidValue |
| 71 rawValues:&va
lue |
| 72 forKeys:&ke
y |
| 73 count:1]
autorelease]; |
| 74 } |
| 75 - (instancetype)initWithValues:(const int32_t [])values |
| 76 forKeys:(const uint32_t [])keys |
| 77 count:(NSUInteger)count { |
| 78 return [self initWithValidationFunction:TestingEnum_IsValidValue |
| 79 rawValues:values |
| 80 forKeys:keys |
| 81 count:count]; |
| 82 } |
| 83 @end |
| 84 |
| 85 |
| 86 #pragma mark - UInt32 -> UInt32 |
| 87 |
| 88 @interface GPBUInt32UInt32DictionaryTests : XCTestCase |
| 89 @end |
| 90 |
| 91 @implementation GPBUInt32UInt32DictionaryTests |
| 92 |
| 93 - (void)testEmpty { |
| 94 GPBUInt32UInt32Dictionary *dict = [[GPBUInt32UInt32Dictionary alloc] init]; |
| 95 XCTAssertNotNil(dict); |
| 96 XCTAssertEqual(dict.count, 0U); |
| 97 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 98 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL
*stop) { |
| 99 #pragma unused(aKey, aValue, stop) |
| 100 XCTFail(@"Shouldn't get here!"); |
| 101 }]; |
| 102 [dict release]; |
| 103 } |
| 104 |
| 105 - (void)testOne { |
| 106 GPBUInt32UInt32Dictionary *dict = [GPBUInt32UInt32Dictionary dictionaryWithVal
ue:100U forKey:1U]; |
| 107 XCTAssertNotNil(dict); |
| 108 XCTAssertEqual(dict.count, 1U); |
| 109 uint32_t value; |
| 110 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 111 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 112 XCTAssertEqual(value, 100U); |
| 113 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 114 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL
*stop) { |
| 115 XCTAssertEqual(aKey, 1U); |
| 116 XCTAssertEqual(aValue, 100U); |
| 117 XCTAssertNotEqual(stop, NULL); |
| 118 }]; |
| 119 } |
| 120 |
| 121 - (void)testBasics { |
| 122 const uint32_t kKeys[] = { 1U, 2U, 3U }; |
| 123 const uint32_t kValues[] = { 100U, 101U, 102U }; |
| 124 GPBUInt32UInt32Dictionary *dict = |
| 125 [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues |
| 126 forKeys:kKeys |
| 127 count:GPBARRAYSIZE(kValues)]; |
| 128 XCTAssertNotNil(dict); |
| 129 XCTAssertEqual(dict.count, 3U); |
| 130 uint32_t value; |
| 131 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 132 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 133 XCTAssertEqual(value, 100U); |
| 134 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 135 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 136 XCTAssertEqual(value, 101U); |
| 137 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 138 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 139 XCTAssertEqual(value, 102U); |
| 140 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 141 |
| 142 __block NSUInteger idx = 0; |
| 143 uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); |
| 144 uint32_t *seenValues = malloc(3 * sizeof(uint32_t)); |
| 145 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL
*stop) { |
| 146 XCTAssertLessThan(idx, 3U); |
| 147 seenKeys[idx] = aKey; |
| 148 seenValues[idx] = aValue; |
| 149 XCTAssertNotEqual(stop, NULL); |
| 150 ++idx; |
| 151 }]; |
| 152 for (int i = 0; i < 3; ++i) { |
| 153 BOOL foundKey = NO; |
| 154 for (int j = 0; (j < 3) && !foundKey; ++j) { |
| 155 if (kKeys[i] == seenKeys[j]) { |
| 156 foundKey = YES; |
| 157 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j); |
| 158 } |
| 159 } |
| 160 XCTAssertTrue(foundKey, @"i = %d", i); |
| 161 } |
| 162 free(seenKeys); |
| 163 free(seenValues); |
| 164 |
| 165 // Stopping the enumeration. |
| 166 idx = 0; |
| 167 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL
*stop) { |
| 168 #pragma unused(aKey, aValue) |
| 169 if (idx == 1) *stop = YES; |
| 170 XCTAssertNotEqual(idx, 2U); |
| 171 ++idx; |
| 172 }]; |
| 173 [dict release]; |
| 174 } |
| 175 |
| 176 - (void)testEquality { |
| 177 const uint32_t kKeys1[] = { 1U, 2U, 3U, 4U }; |
| 178 const uint32_t kKeys2[] = { 2U, 1U, 4U }; |
| 179 const uint32_t kValues1[] = { 100U, 101U, 102U }; |
| 180 const uint32_t kValues2[] = { 100U, 103U, 102U }; |
| 181 const uint32_t kValues3[] = { 100U, 101U, 102U, 103U }; |
| 182 GPBUInt32UInt32Dictionary *dict1 = |
| 183 [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues1 |
| 184 forKeys:kKeys1 |
| 185 count:GPBARRAYSIZE(kValues1)]; |
| 186 XCTAssertNotNil(dict1); |
| 187 GPBUInt32UInt32Dictionary *dict1prime = |
| 188 [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues1 |
| 189 forKeys:kKeys1 |
| 190 count:GPBARRAYSIZE(kValues1)]; |
| 191 XCTAssertNotNil(dict1prime); |
| 192 GPBUInt32UInt32Dictionary *dict2 = |
| 193 [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues2 |
| 194 forKeys:kKeys1 |
| 195 count:GPBARRAYSIZE(kValues2)]; |
| 196 XCTAssertNotNil(dict2); |
| 197 GPBUInt32UInt32Dictionary *dict3 = |
| 198 [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues1 |
| 199 forKeys:kKeys2 |
| 200 count:GPBARRAYSIZE(kValues1)]; |
| 201 XCTAssertNotNil(dict3); |
| 202 GPBUInt32UInt32Dictionary *dict4 = |
| 203 [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues3 |
| 204 forKeys:kKeys1 |
| 205 count:GPBARRAYSIZE(kValues3)]; |
| 206 XCTAssertNotNil(dict4); |
| 207 |
| 208 // 1/1Prime should be different objects, but equal. |
| 209 XCTAssertNotEqual(dict1, dict1prime); |
| 210 XCTAssertEqualObjects(dict1, dict1prime); |
| 211 // Equal, so they must have same hash. |
| 212 XCTAssertEqual([dict1 hash], [dict1prime hash]); |
| 213 |
| 214 // 2 is same keys, different values; not equal. |
| 215 XCTAssertNotEqualObjects(dict1, dict2); |
| 216 |
| 217 // 3 is different keys, same values; not equal. |
| 218 XCTAssertNotEqualObjects(dict1, dict3); |
| 219 |
| 220 // 4 extra pair; not equal |
| 221 XCTAssertNotEqualObjects(dict1, dict4); |
| 222 |
| 223 [dict1 release]; |
| 224 [dict1prime release]; |
| 225 [dict2 release]; |
| 226 [dict3 release]; |
| 227 [dict4 release]; |
| 228 } |
| 229 |
| 230 - (void)testCopy { |
| 231 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 232 const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; |
| 233 GPBUInt32UInt32Dictionary *dict = |
| 234 [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues |
| 235 forKeys:kKeys |
| 236 count:GPBARRAYSIZE(kValues)]; |
| 237 XCTAssertNotNil(dict); |
| 238 |
| 239 GPBUInt32UInt32Dictionary *dict2 = [dict copy]; |
| 240 XCTAssertNotNil(dict2); |
| 241 |
| 242 // Should be new object but equal. |
| 243 XCTAssertNotEqual(dict, dict2); |
| 244 XCTAssertEqualObjects(dict, dict2); |
| 245 XCTAssertTrue([dict2 isKindOfClass:[GPBUInt32UInt32Dictionary class]]); |
| 246 |
| 247 [dict2 release]; |
| 248 [dict release]; |
| 249 } |
| 250 |
| 251 - (void)testDictionaryFromDictionary { |
| 252 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 253 const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; |
| 254 GPBUInt32UInt32Dictionary *dict = |
| 255 [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues |
| 256 forKeys:kKeys |
| 257 count:GPBARRAYSIZE(kValues)]; |
| 258 XCTAssertNotNil(dict); |
| 259 |
| 260 GPBUInt32UInt32Dictionary *dict2 = |
| 261 [GPBUInt32UInt32Dictionary dictionaryWithDictionary:dict]; |
| 262 XCTAssertNotNil(dict2); |
| 263 |
| 264 // Should be new pointer, but equal objects. |
| 265 XCTAssertNotEqual(dict, dict2); |
| 266 XCTAssertEqualObjects(dict, dict2); |
| 267 [dict release]; |
| 268 } |
| 269 |
| 270 - (void)testAdds { |
| 271 GPBUInt32UInt32Dictionary *dict = [GPBUInt32UInt32Dictionary dictionary]; |
| 272 XCTAssertNotNil(dict); |
| 273 |
| 274 XCTAssertEqual(dict.count, 0U); |
| 275 [dict setValue:100U forKey:1U]; |
| 276 XCTAssertEqual(dict.count, 1U); |
| 277 |
| 278 const uint32_t kKeys[] = { 2U, 3U, 4U }; |
| 279 const uint32_t kValues[] = { 101U, 102U, 103U }; |
| 280 GPBUInt32UInt32Dictionary *dict2 = |
| 281 [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues |
| 282 forKeys:kKeys |
| 283 count:GPBARRAYSIZE(kValues)]; |
| 284 XCTAssertNotNil(dict2); |
| 285 [dict addEntriesFromDictionary:dict2]; |
| 286 XCTAssertEqual(dict.count, 4U); |
| 287 |
| 288 uint32_t value; |
| 289 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 290 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 291 XCTAssertEqual(value, 100U); |
| 292 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 293 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 294 XCTAssertEqual(value, 101U); |
| 295 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 296 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 297 XCTAssertEqual(value, 102U); |
| 298 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 299 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 300 XCTAssertEqual(value, 103U); |
| 301 [dict2 release]; |
| 302 } |
| 303 |
| 304 - (void)testRemove { |
| 305 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 306 const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; |
| 307 GPBUInt32UInt32Dictionary *dict = |
| 308 [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues |
| 309 forKeys:kKeys |
| 310 count:GPBARRAYSIZE(kValues)]; |
| 311 XCTAssertNotNil(dict); |
| 312 XCTAssertEqual(dict.count, 4U); |
| 313 |
| 314 [dict removeValueForKey:2U]; |
| 315 XCTAssertEqual(dict.count, 3U); |
| 316 uint32_t value; |
| 317 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 318 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 319 XCTAssertEqual(value, 100U); |
| 320 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 321 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 322 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 323 XCTAssertEqual(value, 102U); |
| 324 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 325 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 326 XCTAssertEqual(value, 103U); |
| 327 |
| 328 // Remove again does nothing. |
| 329 [dict removeValueForKey:2U]; |
| 330 XCTAssertEqual(dict.count, 3U); |
| 331 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 332 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 333 XCTAssertEqual(value, 100U); |
| 334 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 335 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 336 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 337 XCTAssertEqual(value, 102U); |
| 338 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 339 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 340 XCTAssertEqual(value, 103U); |
| 341 |
| 342 [dict removeValueForKey:4U]; |
| 343 XCTAssertEqual(dict.count, 2U); |
| 344 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 345 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 346 XCTAssertEqual(value, 100U); |
| 347 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 348 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 349 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 350 XCTAssertEqual(value, 102U); |
| 351 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 352 |
| 353 [dict removeAll]; |
| 354 XCTAssertEqual(dict.count, 0U); |
| 355 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 356 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 357 XCTAssertFalse([dict valueForKey:3U value:NULL]); |
| 358 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 359 [dict release]; |
| 360 } |
| 361 |
| 362 - (void)testInplaceMutation { |
| 363 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 364 const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; |
| 365 GPBUInt32UInt32Dictionary *dict = |
| 366 [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues |
| 367 forKeys:kKeys |
| 368 count:GPBARRAYSIZE(kValues)]; |
| 369 XCTAssertNotNil(dict); |
| 370 XCTAssertEqual(dict.count, 4U); |
| 371 uint32_t value; |
| 372 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 373 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 374 XCTAssertEqual(value, 100U); |
| 375 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 376 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 377 XCTAssertEqual(value, 101U); |
| 378 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 379 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 380 XCTAssertEqual(value, 102U); |
| 381 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 382 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 383 XCTAssertEqual(value, 103U); |
| 384 |
| 385 [dict setValue:103U forKey:1U]; |
| 386 XCTAssertEqual(dict.count, 4U); |
| 387 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 388 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 389 XCTAssertEqual(value, 103U); |
| 390 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 391 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 392 XCTAssertEqual(value, 101U); |
| 393 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 394 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 395 XCTAssertEqual(value, 102U); |
| 396 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 397 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 398 XCTAssertEqual(value, 103U); |
| 399 |
| 400 [dict setValue:101U forKey:4U]; |
| 401 XCTAssertEqual(dict.count, 4U); |
| 402 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 403 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 404 XCTAssertEqual(value, 103U); |
| 405 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 406 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 407 XCTAssertEqual(value, 101U); |
| 408 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 409 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 410 XCTAssertEqual(value, 102U); |
| 411 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 412 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 413 XCTAssertEqual(value, 101U); |
| 414 |
| 415 const uint32_t kKeys2[] = { 2U, 3U }; |
| 416 const uint32_t kValues2[] = { 102U, 100U }; |
| 417 GPBUInt32UInt32Dictionary *dict2 = |
| 418 [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues2 |
| 419 forKeys:kKeys2 |
| 420 count:GPBARRAYSIZE(kValues2)]; |
| 421 XCTAssertNotNil(dict2); |
| 422 [dict addEntriesFromDictionary:dict2]; |
| 423 XCTAssertEqual(dict.count, 4U); |
| 424 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 425 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 426 XCTAssertEqual(value, 103U); |
| 427 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 428 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 429 XCTAssertEqual(value, 102U); |
| 430 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 431 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 432 XCTAssertEqual(value, 100U); |
| 433 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 434 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 435 XCTAssertEqual(value, 101U); |
| 436 |
| 437 [dict2 release]; |
| 438 [dict release]; |
| 439 } |
| 440 |
| 441 @end |
| 442 |
| 443 #pragma mark - UInt32 -> Int32 |
| 444 |
| 445 @interface GPBUInt32Int32DictionaryTests : XCTestCase |
| 446 @end |
| 447 |
| 448 @implementation GPBUInt32Int32DictionaryTests |
| 449 |
| 450 - (void)testEmpty { |
| 451 GPBUInt32Int32Dictionary *dict = [[GPBUInt32Int32Dictionary alloc] init]; |
| 452 XCTAssertNotNil(dict); |
| 453 XCTAssertEqual(dict.count, 0U); |
| 454 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 455 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *
stop) { |
| 456 #pragma unused(aKey, aValue, stop) |
| 457 XCTFail(@"Shouldn't get here!"); |
| 458 }]; |
| 459 [dict release]; |
| 460 } |
| 461 |
| 462 - (void)testOne { |
| 463 GPBUInt32Int32Dictionary *dict = [GPBUInt32Int32Dictionary dictionaryWithValue
:200 forKey:1U]; |
| 464 XCTAssertNotNil(dict); |
| 465 XCTAssertEqual(dict.count, 1U); |
| 466 int32_t value; |
| 467 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 468 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 469 XCTAssertEqual(value, 200); |
| 470 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 471 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *
stop) { |
| 472 XCTAssertEqual(aKey, 1U); |
| 473 XCTAssertEqual(aValue, 200); |
| 474 XCTAssertNotEqual(stop, NULL); |
| 475 }]; |
| 476 } |
| 477 |
| 478 - (void)testBasics { |
| 479 const uint32_t kKeys[] = { 1U, 2U, 3U }; |
| 480 const int32_t kValues[] = { 200, 201, 202 }; |
| 481 GPBUInt32Int32Dictionary *dict = |
| 482 [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues |
| 483 forKeys:kKeys |
| 484 count:GPBARRAYSIZE(kValues)]; |
| 485 XCTAssertNotNil(dict); |
| 486 XCTAssertEqual(dict.count, 3U); |
| 487 int32_t value; |
| 488 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 489 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 490 XCTAssertEqual(value, 200); |
| 491 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 492 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 493 XCTAssertEqual(value, 201); |
| 494 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 495 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 496 XCTAssertEqual(value, 202); |
| 497 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 498 |
| 499 __block NSUInteger idx = 0; |
| 500 uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); |
| 501 int32_t *seenValues = malloc(3 * sizeof(int32_t)); |
| 502 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *
stop) { |
| 503 XCTAssertLessThan(idx, 3U); |
| 504 seenKeys[idx] = aKey; |
| 505 seenValues[idx] = aValue; |
| 506 XCTAssertNotEqual(stop, NULL); |
| 507 ++idx; |
| 508 }]; |
| 509 for (int i = 0; i < 3; ++i) { |
| 510 BOOL foundKey = NO; |
| 511 for (int j = 0; (j < 3) && !foundKey; ++j) { |
| 512 if (kKeys[i] == seenKeys[j]) { |
| 513 foundKey = YES; |
| 514 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j); |
| 515 } |
| 516 } |
| 517 XCTAssertTrue(foundKey, @"i = %d", i); |
| 518 } |
| 519 free(seenKeys); |
| 520 free(seenValues); |
| 521 |
| 522 // Stopping the enumeration. |
| 523 idx = 0; |
| 524 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *
stop) { |
| 525 #pragma unused(aKey, aValue) |
| 526 if (idx == 1) *stop = YES; |
| 527 XCTAssertNotEqual(idx, 2U); |
| 528 ++idx; |
| 529 }]; |
| 530 [dict release]; |
| 531 } |
| 532 |
| 533 - (void)testEquality { |
| 534 const uint32_t kKeys1[] = { 1U, 2U, 3U, 4U }; |
| 535 const uint32_t kKeys2[] = { 2U, 1U, 4U }; |
| 536 const int32_t kValues1[] = { 200, 201, 202 }; |
| 537 const int32_t kValues2[] = { 200, 203, 202 }; |
| 538 const int32_t kValues3[] = { 200, 201, 202, 203 }; |
| 539 GPBUInt32Int32Dictionary *dict1 = |
| 540 [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues1 |
| 541 forKeys:kKeys1 |
| 542 count:GPBARRAYSIZE(kValues1)]; |
| 543 XCTAssertNotNil(dict1); |
| 544 GPBUInt32Int32Dictionary *dict1prime = |
| 545 [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues1 |
| 546 forKeys:kKeys1 |
| 547 count:GPBARRAYSIZE(kValues1)]; |
| 548 XCTAssertNotNil(dict1prime); |
| 549 GPBUInt32Int32Dictionary *dict2 = |
| 550 [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues2 |
| 551 forKeys:kKeys1 |
| 552 count:GPBARRAYSIZE(kValues2)]; |
| 553 XCTAssertNotNil(dict2); |
| 554 GPBUInt32Int32Dictionary *dict3 = |
| 555 [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues1 |
| 556 forKeys:kKeys2 |
| 557 count:GPBARRAYSIZE(kValues1)]; |
| 558 XCTAssertNotNil(dict3); |
| 559 GPBUInt32Int32Dictionary *dict4 = |
| 560 [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues3 |
| 561 forKeys:kKeys1 |
| 562 count:GPBARRAYSIZE(kValues3)]; |
| 563 XCTAssertNotNil(dict4); |
| 564 |
| 565 // 1/1Prime should be different objects, but equal. |
| 566 XCTAssertNotEqual(dict1, dict1prime); |
| 567 XCTAssertEqualObjects(dict1, dict1prime); |
| 568 // Equal, so they must have same hash. |
| 569 XCTAssertEqual([dict1 hash], [dict1prime hash]); |
| 570 |
| 571 // 2 is same keys, different values; not equal. |
| 572 XCTAssertNotEqualObjects(dict1, dict2); |
| 573 |
| 574 // 3 is different keys, same values; not equal. |
| 575 XCTAssertNotEqualObjects(dict1, dict3); |
| 576 |
| 577 // 4 extra pair; not equal |
| 578 XCTAssertNotEqualObjects(dict1, dict4); |
| 579 |
| 580 [dict1 release]; |
| 581 [dict1prime release]; |
| 582 [dict2 release]; |
| 583 [dict3 release]; |
| 584 [dict4 release]; |
| 585 } |
| 586 |
| 587 - (void)testCopy { |
| 588 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 589 const int32_t kValues[] = { 200, 201, 202, 203 }; |
| 590 GPBUInt32Int32Dictionary *dict = |
| 591 [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues |
| 592 forKeys:kKeys |
| 593 count:GPBARRAYSIZE(kValues)]; |
| 594 XCTAssertNotNil(dict); |
| 595 |
| 596 GPBUInt32Int32Dictionary *dict2 = [dict copy]; |
| 597 XCTAssertNotNil(dict2); |
| 598 |
| 599 // Should be new object but equal. |
| 600 XCTAssertNotEqual(dict, dict2); |
| 601 XCTAssertEqualObjects(dict, dict2); |
| 602 XCTAssertTrue([dict2 isKindOfClass:[GPBUInt32Int32Dictionary class]]); |
| 603 |
| 604 [dict2 release]; |
| 605 [dict release]; |
| 606 } |
| 607 |
| 608 - (void)testDictionaryFromDictionary { |
| 609 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 610 const int32_t kValues[] = { 200, 201, 202, 203 }; |
| 611 GPBUInt32Int32Dictionary *dict = |
| 612 [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues |
| 613 forKeys:kKeys |
| 614 count:GPBARRAYSIZE(kValues)]; |
| 615 XCTAssertNotNil(dict); |
| 616 |
| 617 GPBUInt32Int32Dictionary *dict2 = |
| 618 [GPBUInt32Int32Dictionary dictionaryWithDictionary:dict]; |
| 619 XCTAssertNotNil(dict2); |
| 620 |
| 621 // Should be new pointer, but equal objects. |
| 622 XCTAssertNotEqual(dict, dict2); |
| 623 XCTAssertEqualObjects(dict, dict2); |
| 624 [dict release]; |
| 625 } |
| 626 |
| 627 - (void)testAdds { |
| 628 GPBUInt32Int32Dictionary *dict = [GPBUInt32Int32Dictionary dictionary]; |
| 629 XCTAssertNotNil(dict); |
| 630 |
| 631 XCTAssertEqual(dict.count, 0U); |
| 632 [dict setValue:200 forKey:1U]; |
| 633 XCTAssertEqual(dict.count, 1U); |
| 634 |
| 635 const uint32_t kKeys[] = { 2U, 3U, 4U }; |
| 636 const int32_t kValues[] = { 201, 202, 203 }; |
| 637 GPBUInt32Int32Dictionary *dict2 = |
| 638 [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues |
| 639 forKeys:kKeys |
| 640 count:GPBARRAYSIZE(kValues)]; |
| 641 XCTAssertNotNil(dict2); |
| 642 [dict addEntriesFromDictionary:dict2]; |
| 643 XCTAssertEqual(dict.count, 4U); |
| 644 |
| 645 int32_t value; |
| 646 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 647 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 648 XCTAssertEqual(value, 200); |
| 649 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 650 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 651 XCTAssertEqual(value, 201); |
| 652 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 653 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 654 XCTAssertEqual(value, 202); |
| 655 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 656 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 657 XCTAssertEqual(value, 203); |
| 658 [dict2 release]; |
| 659 } |
| 660 |
| 661 - (void)testRemove { |
| 662 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 663 const int32_t kValues[] = { 200, 201, 202, 203 }; |
| 664 GPBUInt32Int32Dictionary *dict = |
| 665 [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues |
| 666 forKeys:kKeys |
| 667 count:GPBARRAYSIZE(kValues)]; |
| 668 XCTAssertNotNil(dict); |
| 669 XCTAssertEqual(dict.count, 4U); |
| 670 |
| 671 [dict removeValueForKey:2U]; |
| 672 XCTAssertEqual(dict.count, 3U); |
| 673 int32_t value; |
| 674 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 675 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 676 XCTAssertEqual(value, 200); |
| 677 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 678 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 679 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 680 XCTAssertEqual(value, 202); |
| 681 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 682 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 683 XCTAssertEqual(value, 203); |
| 684 |
| 685 // Remove again does nothing. |
| 686 [dict removeValueForKey:2U]; |
| 687 XCTAssertEqual(dict.count, 3U); |
| 688 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 689 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 690 XCTAssertEqual(value, 200); |
| 691 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 692 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 693 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 694 XCTAssertEqual(value, 202); |
| 695 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 696 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 697 XCTAssertEqual(value, 203); |
| 698 |
| 699 [dict removeValueForKey:4U]; |
| 700 XCTAssertEqual(dict.count, 2U); |
| 701 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 702 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 703 XCTAssertEqual(value, 200); |
| 704 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 705 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 706 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 707 XCTAssertEqual(value, 202); |
| 708 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 709 |
| 710 [dict removeAll]; |
| 711 XCTAssertEqual(dict.count, 0U); |
| 712 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 713 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 714 XCTAssertFalse([dict valueForKey:3U value:NULL]); |
| 715 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 716 [dict release]; |
| 717 } |
| 718 |
| 719 - (void)testInplaceMutation { |
| 720 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 721 const int32_t kValues[] = { 200, 201, 202, 203 }; |
| 722 GPBUInt32Int32Dictionary *dict = |
| 723 [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues |
| 724 forKeys:kKeys |
| 725 count:GPBARRAYSIZE(kValues)]; |
| 726 XCTAssertNotNil(dict); |
| 727 XCTAssertEqual(dict.count, 4U); |
| 728 int32_t value; |
| 729 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 730 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 731 XCTAssertEqual(value, 200); |
| 732 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 733 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 734 XCTAssertEqual(value, 201); |
| 735 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 736 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 737 XCTAssertEqual(value, 202); |
| 738 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 739 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 740 XCTAssertEqual(value, 203); |
| 741 |
| 742 [dict setValue:203 forKey:1U]; |
| 743 XCTAssertEqual(dict.count, 4U); |
| 744 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 745 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 746 XCTAssertEqual(value, 203); |
| 747 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 748 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 749 XCTAssertEqual(value, 201); |
| 750 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 751 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 752 XCTAssertEqual(value, 202); |
| 753 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 754 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 755 XCTAssertEqual(value, 203); |
| 756 |
| 757 [dict setValue:201 forKey:4U]; |
| 758 XCTAssertEqual(dict.count, 4U); |
| 759 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 760 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 761 XCTAssertEqual(value, 203); |
| 762 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 763 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 764 XCTAssertEqual(value, 201); |
| 765 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 766 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 767 XCTAssertEqual(value, 202); |
| 768 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 769 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 770 XCTAssertEqual(value, 201); |
| 771 |
| 772 const uint32_t kKeys2[] = { 2U, 3U }; |
| 773 const int32_t kValues2[] = { 202, 200 }; |
| 774 GPBUInt32Int32Dictionary *dict2 = |
| 775 [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues2 |
| 776 forKeys:kKeys2 |
| 777 count:GPBARRAYSIZE(kValues2)]; |
| 778 XCTAssertNotNil(dict2); |
| 779 [dict addEntriesFromDictionary:dict2]; |
| 780 XCTAssertEqual(dict.count, 4U); |
| 781 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 782 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 783 XCTAssertEqual(value, 203); |
| 784 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 785 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 786 XCTAssertEqual(value, 202); |
| 787 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 788 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 789 XCTAssertEqual(value, 200); |
| 790 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 791 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 792 XCTAssertEqual(value, 201); |
| 793 |
| 794 [dict2 release]; |
| 795 [dict release]; |
| 796 } |
| 797 |
| 798 @end |
| 799 |
| 800 #pragma mark - UInt32 -> UInt64 |
| 801 |
| 802 @interface GPBUInt32UInt64DictionaryTests : XCTestCase |
| 803 @end |
| 804 |
| 805 @implementation GPBUInt32UInt64DictionaryTests |
| 806 |
| 807 - (void)testEmpty { |
| 808 GPBUInt32UInt64Dictionary *dict = [[GPBUInt32UInt64Dictionary alloc] init]; |
| 809 XCTAssertNotNil(dict); |
| 810 XCTAssertEqual(dict.count, 0U); |
| 811 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 812 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL
*stop) { |
| 813 #pragma unused(aKey, aValue, stop) |
| 814 XCTFail(@"Shouldn't get here!"); |
| 815 }]; |
| 816 [dict release]; |
| 817 } |
| 818 |
| 819 - (void)testOne { |
| 820 GPBUInt32UInt64Dictionary *dict = [GPBUInt32UInt64Dictionary dictionaryWithVal
ue:300U forKey:1U]; |
| 821 XCTAssertNotNil(dict); |
| 822 XCTAssertEqual(dict.count, 1U); |
| 823 uint64_t value; |
| 824 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 825 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 826 XCTAssertEqual(value, 300U); |
| 827 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 828 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL
*stop) { |
| 829 XCTAssertEqual(aKey, 1U); |
| 830 XCTAssertEqual(aValue, 300U); |
| 831 XCTAssertNotEqual(stop, NULL); |
| 832 }]; |
| 833 } |
| 834 |
| 835 - (void)testBasics { |
| 836 const uint32_t kKeys[] = { 1U, 2U, 3U }; |
| 837 const uint64_t kValues[] = { 300U, 301U, 302U }; |
| 838 GPBUInt32UInt64Dictionary *dict = |
| 839 [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues |
| 840 forKeys:kKeys |
| 841 count:GPBARRAYSIZE(kValues)]; |
| 842 XCTAssertNotNil(dict); |
| 843 XCTAssertEqual(dict.count, 3U); |
| 844 uint64_t value; |
| 845 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 846 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 847 XCTAssertEqual(value, 300U); |
| 848 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 849 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 850 XCTAssertEqual(value, 301U); |
| 851 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 852 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 853 XCTAssertEqual(value, 302U); |
| 854 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 855 |
| 856 __block NSUInteger idx = 0; |
| 857 uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); |
| 858 uint64_t *seenValues = malloc(3 * sizeof(uint64_t)); |
| 859 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL
*stop) { |
| 860 XCTAssertLessThan(idx, 3U); |
| 861 seenKeys[idx] = aKey; |
| 862 seenValues[idx] = aValue; |
| 863 XCTAssertNotEqual(stop, NULL); |
| 864 ++idx; |
| 865 }]; |
| 866 for (int i = 0; i < 3; ++i) { |
| 867 BOOL foundKey = NO; |
| 868 for (int j = 0; (j < 3) && !foundKey; ++j) { |
| 869 if (kKeys[i] == seenKeys[j]) { |
| 870 foundKey = YES; |
| 871 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j); |
| 872 } |
| 873 } |
| 874 XCTAssertTrue(foundKey, @"i = %d", i); |
| 875 } |
| 876 free(seenKeys); |
| 877 free(seenValues); |
| 878 |
| 879 // Stopping the enumeration. |
| 880 idx = 0; |
| 881 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL
*stop) { |
| 882 #pragma unused(aKey, aValue) |
| 883 if (idx == 1) *stop = YES; |
| 884 XCTAssertNotEqual(idx, 2U); |
| 885 ++idx; |
| 886 }]; |
| 887 [dict release]; |
| 888 } |
| 889 |
| 890 - (void)testEquality { |
| 891 const uint32_t kKeys1[] = { 1U, 2U, 3U, 4U }; |
| 892 const uint32_t kKeys2[] = { 2U, 1U, 4U }; |
| 893 const uint64_t kValues1[] = { 300U, 301U, 302U }; |
| 894 const uint64_t kValues2[] = { 300U, 303U, 302U }; |
| 895 const uint64_t kValues3[] = { 300U, 301U, 302U, 303U }; |
| 896 GPBUInt32UInt64Dictionary *dict1 = |
| 897 [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues1 |
| 898 forKeys:kKeys1 |
| 899 count:GPBARRAYSIZE(kValues1)]; |
| 900 XCTAssertNotNil(dict1); |
| 901 GPBUInt32UInt64Dictionary *dict1prime = |
| 902 [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues1 |
| 903 forKeys:kKeys1 |
| 904 count:GPBARRAYSIZE(kValues1)]; |
| 905 XCTAssertNotNil(dict1prime); |
| 906 GPBUInt32UInt64Dictionary *dict2 = |
| 907 [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues2 |
| 908 forKeys:kKeys1 |
| 909 count:GPBARRAYSIZE(kValues2)]; |
| 910 XCTAssertNotNil(dict2); |
| 911 GPBUInt32UInt64Dictionary *dict3 = |
| 912 [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues1 |
| 913 forKeys:kKeys2 |
| 914 count:GPBARRAYSIZE(kValues1)]; |
| 915 XCTAssertNotNil(dict3); |
| 916 GPBUInt32UInt64Dictionary *dict4 = |
| 917 [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues3 |
| 918 forKeys:kKeys1 |
| 919 count:GPBARRAYSIZE(kValues3)]; |
| 920 XCTAssertNotNil(dict4); |
| 921 |
| 922 // 1/1Prime should be different objects, but equal. |
| 923 XCTAssertNotEqual(dict1, dict1prime); |
| 924 XCTAssertEqualObjects(dict1, dict1prime); |
| 925 // Equal, so they must have same hash. |
| 926 XCTAssertEqual([dict1 hash], [dict1prime hash]); |
| 927 |
| 928 // 2 is same keys, different values; not equal. |
| 929 XCTAssertNotEqualObjects(dict1, dict2); |
| 930 |
| 931 // 3 is different keys, same values; not equal. |
| 932 XCTAssertNotEqualObjects(dict1, dict3); |
| 933 |
| 934 // 4 extra pair; not equal |
| 935 XCTAssertNotEqualObjects(dict1, dict4); |
| 936 |
| 937 [dict1 release]; |
| 938 [dict1prime release]; |
| 939 [dict2 release]; |
| 940 [dict3 release]; |
| 941 [dict4 release]; |
| 942 } |
| 943 |
| 944 - (void)testCopy { |
| 945 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 946 const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; |
| 947 GPBUInt32UInt64Dictionary *dict = |
| 948 [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues |
| 949 forKeys:kKeys |
| 950 count:GPBARRAYSIZE(kValues)]; |
| 951 XCTAssertNotNil(dict); |
| 952 |
| 953 GPBUInt32UInt64Dictionary *dict2 = [dict copy]; |
| 954 XCTAssertNotNil(dict2); |
| 955 |
| 956 // Should be new object but equal. |
| 957 XCTAssertNotEqual(dict, dict2); |
| 958 XCTAssertEqualObjects(dict, dict2); |
| 959 XCTAssertTrue([dict2 isKindOfClass:[GPBUInt32UInt64Dictionary class]]); |
| 960 |
| 961 [dict2 release]; |
| 962 [dict release]; |
| 963 } |
| 964 |
| 965 - (void)testDictionaryFromDictionary { |
| 966 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 967 const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; |
| 968 GPBUInt32UInt64Dictionary *dict = |
| 969 [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues |
| 970 forKeys:kKeys |
| 971 count:GPBARRAYSIZE(kValues)]; |
| 972 XCTAssertNotNil(dict); |
| 973 |
| 974 GPBUInt32UInt64Dictionary *dict2 = |
| 975 [GPBUInt32UInt64Dictionary dictionaryWithDictionary:dict]; |
| 976 XCTAssertNotNil(dict2); |
| 977 |
| 978 // Should be new pointer, but equal objects. |
| 979 XCTAssertNotEqual(dict, dict2); |
| 980 XCTAssertEqualObjects(dict, dict2); |
| 981 [dict release]; |
| 982 } |
| 983 |
| 984 - (void)testAdds { |
| 985 GPBUInt32UInt64Dictionary *dict = [GPBUInt32UInt64Dictionary dictionary]; |
| 986 XCTAssertNotNil(dict); |
| 987 |
| 988 XCTAssertEqual(dict.count, 0U); |
| 989 [dict setValue:300U forKey:1U]; |
| 990 XCTAssertEqual(dict.count, 1U); |
| 991 |
| 992 const uint32_t kKeys[] = { 2U, 3U, 4U }; |
| 993 const uint64_t kValues[] = { 301U, 302U, 303U }; |
| 994 GPBUInt32UInt64Dictionary *dict2 = |
| 995 [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues |
| 996 forKeys:kKeys |
| 997 count:GPBARRAYSIZE(kValues)]; |
| 998 XCTAssertNotNil(dict2); |
| 999 [dict addEntriesFromDictionary:dict2]; |
| 1000 XCTAssertEqual(dict.count, 4U); |
| 1001 |
| 1002 uint64_t value; |
| 1003 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1004 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1005 XCTAssertEqual(value, 300U); |
| 1006 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1007 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1008 XCTAssertEqual(value, 301U); |
| 1009 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1010 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1011 XCTAssertEqual(value, 302U); |
| 1012 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1013 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1014 XCTAssertEqual(value, 303U); |
| 1015 [dict2 release]; |
| 1016 } |
| 1017 |
| 1018 - (void)testRemove { |
| 1019 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 1020 const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; |
| 1021 GPBUInt32UInt64Dictionary *dict = |
| 1022 [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues |
| 1023 forKeys:kKeys |
| 1024 count:GPBARRAYSIZE(kValues)]; |
| 1025 XCTAssertNotNil(dict); |
| 1026 XCTAssertEqual(dict.count, 4U); |
| 1027 |
| 1028 [dict removeValueForKey:2U]; |
| 1029 XCTAssertEqual(dict.count, 3U); |
| 1030 uint64_t value; |
| 1031 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1032 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1033 XCTAssertEqual(value, 300U); |
| 1034 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1035 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1036 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1037 XCTAssertEqual(value, 302U); |
| 1038 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1039 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1040 XCTAssertEqual(value, 303U); |
| 1041 |
| 1042 // Remove again does nothing. |
| 1043 [dict removeValueForKey:2U]; |
| 1044 XCTAssertEqual(dict.count, 3U); |
| 1045 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1046 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1047 XCTAssertEqual(value, 300U); |
| 1048 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1049 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1050 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1051 XCTAssertEqual(value, 302U); |
| 1052 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1053 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1054 XCTAssertEqual(value, 303U); |
| 1055 |
| 1056 [dict removeValueForKey:4U]; |
| 1057 XCTAssertEqual(dict.count, 2U); |
| 1058 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1059 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1060 XCTAssertEqual(value, 300U); |
| 1061 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1062 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1063 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1064 XCTAssertEqual(value, 302U); |
| 1065 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 1066 |
| 1067 [dict removeAll]; |
| 1068 XCTAssertEqual(dict.count, 0U); |
| 1069 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 1070 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1071 XCTAssertFalse([dict valueForKey:3U value:NULL]); |
| 1072 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 1073 [dict release]; |
| 1074 } |
| 1075 |
| 1076 - (void)testInplaceMutation { |
| 1077 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 1078 const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; |
| 1079 GPBUInt32UInt64Dictionary *dict = |
| 1080 [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues |
| 1081 forKeys:kKeys |
| 1082 count:GPBARRAYSIZE(kValues)]; |
| 1083 XCTAssertNotNil(dict); |
| 1084 XCTAssertEqual(dict.count, 4U); |
| 1085 uint64_t value; |
| 1086 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1087 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1088 XCTAssertEqual(value, 300U); |
| 1089 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1090 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1091 XCTAssertEqual(value, 301U); |
| 1092 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1093 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1094 XCTAssertEqual(value, 302U); |
| 1095 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1096 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1097 XCTAssertEqual(value, 303U); |
| 1098 |
| 1099 [dict setValue:303U forKey:1U]; |
| 1100 XCTAssertEqual(dict.count, 4U); |
| 1101 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1102 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1103 XCTAssertEqual(value, 303U); |
| 1104 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1105 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1106 XCTAssertEqual(value, 301U); |
| 1107 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1108 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1109 XCTAssertEqual(value, 302U); |
| 1110 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1111 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1112 XCTAssertEqual(value, 303U); |
| 1113 |
| 1114 [dict setValue:301U forKey:4U]; |
| 1115 XCTAssertEqual(dict.count, 4U); |
| 1116 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1117 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1118 XCTAssertEqual(value, 303U); |
| 1119 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1120 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1121 XCTAssertEqual(value, 301U); |
| 1122 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1123 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1124 XCTAssertEqual(value, 302U); |
| 1125 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1126 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1127 XCTAssertEqual(value, 301U); |
| 1128 |
| 1129 const uint32_t kKeys2[] = { 2U, 3U }; |
| 1130 const uint64_t kValues2[] = { 302U, 300U }; |
| 1131 GPBUInt32UInt64Dictionary *dict2 = |
| 1132 [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues2 |
| 1133 forKeys:kKeys2 |
| 1134 count:GPBARRAYSIZE(kValues2)]; |
| 1135 XCTAssertNotNil(dict2); |
| 1136 [dict addEntriesFromDictionary:dict2]; |
| 1137 XCTAssertEqual(dict.count, 4U); |
| 1138 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1139 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1140 XCTAssertEqual(value, 303U); |
| 1141 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1142 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1143 XCTAssertEqual(value, 302U); |
| 1144 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1145 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1146 XCTAssertEqual(value, 300U); |
| 1147 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1148 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1149 XCTAssertEqual(value, 301U); |
| 1150 |
| 1151 [dict2 release]; |
| 1152 [dict release]; |
| 1153 } |
| 1154 |
| 1155 @end |
| 1156 |
| 1157 #pragma mark - UInt32 -> Int64 |
| 1158 |
| 1159 @interface GPBUInt32Int64DictionaryTests : XCTestCase |
| 1160 @end |
| 1161 |
| 1162 @implementation GPBUInt32Int64DictionaryTests |
| 1163 |
| 1164 - (void)testEmpty { |
| 1165 GPBUInt32Int64Dictionary *dict = [[GPBUInt32Int64Dictionary alloc] init]; |
| 1166 XCTAssertNotNil(dict); |
| 1167 XCTAssertEqual(dict.count, 0U); |
| 1168 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 1169 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *
stop) { |
| 1170 #pragma unused(aKey, aValue, stop) |
| 1171 XCTFail(@"Shouldn't get here!"); |
| 1172 }]; |
| 1173 [dict release]; |
| 1174 } |
| 1175 |
| 1176 - (void)testOne { |
| 1177 GPBUInt32Int64Dictionary *dict = [GPBUInt32Int64Dictionary dictionaryWithValue
:400 forKey:1U]; |
| 1178 XCTAssertNotNil(dict); |
| 1179 XCTAssertEqual(dict.count, 1U); |
| 1180 int64_t value; |
| 1181 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1182 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1183 XCTAssertEqual(value, 400); |
| 1184 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1185 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *
stop) { |
| 1186 XCTAssertEqual(aKey, 1U); |
| 1187 XCTAssertEqual(aValue, 400); |
| 1188 XCTAssertNotEqual(stop, NULL); |
| 1189 }]; |
| 1190 } |
| 1191 |
| 1192 - (void)testBasics { |
| 1193 const uint32_t kKeys[] = { 1U, 2U, 3U }; |
| 1194 const int64_t kValues[] = { 400, 401, 402 }; |
| 1195 GPBUInt32Int64Dictionary *dict = |
| 1196 [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues |
| 1197 forKeys:kKeys |
| 1198 count:GPBARRAYSIZE(kValues)]; |
| 1199 XCTAssertNotNil(dict); |
| 1200 XCTAssertEqual(dict.count, 3U); |
| 1201 int64_t value; |
| 1202 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1203 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1204 XCTAssertEqual(value, 400); |
| 1205 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1206 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1207 XCTAssertEqual(value, 401); |
| 1208 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1209 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1210 XCTAssertEqual(value, 402); |
| 1211 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 1212 |
| 1213 __block NSUInteger idx = 0; |
| 1214 uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); |
| 1215 int64_t *seenValues = malloc(3 * sizeof(int64_t)); |
| 1216 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *
stop) { |
| 1217 XCTAssertLessThan(idx, 3U); |
| 1218 seenKeys[idx] = aKey; |
| 1219 seenValues[idx] = aValue; |
| 1220 XCTAssertNotEqual(stop, NULL); |
| 1221 ++idx; |
| 1222 }]; |
| 1223 for (int i = 0; i < 3; ++i) { |
| 1224 BOOL foundKey = NO; |
| 1225 for (int j = 0; (j < 3) && !foundKey; ++j) { |
| 1226 if (kKeys[i] == seenKeys[j]) { |
| 1227 foundKey = YES; |
| 1228 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j); |
| 1229 } |
| 1230 } |
| 1231 XCTAssertTrue(foundKey, @"i = %d", i); |
| 1232 } |
| 1233 free(seenKeys); |
| 1234 free(seenValues); |
| 1235 |
| 1236 // Stopping the enumeration. |
| 1237 idx = 0; |
| 1238 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *
stop) { |
| 1239 #pragma unused(aKey, aValue) |
| 1240 if (idx == 1) *stop = YES; |
| 1241 XCTAssertNotEqual(idx, 2U); |
| 1242 ++idx; |
| 1243 }]; |
| 1244 [dict release]; |
| 1245 } |
| 1246 |
| 1247 - (void)testEquality { |
| 1248 const uint32_t kKeys1[] = { 1U, 2U, 3U, 4U }; |
| 1249 const uint32_t kKeys2[] = { 2U, 1U, 4U }; |
| 1250 const int64_t kValues1[] = { 400, 401, 402 }; |
| 1251 const int64_t kValues2[] = { 400, 403, 402 }; |
| 1252 const int64_t kValues3[] = { 400, 401, 402, 403 }; |
| 1253 GPBUInt32Int64Dictionary *dict1 = |
| 1254 [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues1 |
| 1255 forKeys:kKeys1 |
| 1256 count:GPBARRAYSIZE(kValues1)]; |
| 1257 XCTAssertNotNil(dict1); |
| 1258 GPBUInt32Int64Dictionary *dict1prime = |
| 1259 [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues1 |
| 1260 forKeys:kKeys1 |
| 1261 count:GPBARRAYSIZE(kValues1)]; |
| 1262 XCTAssertNotNil(dict1prime); |
| 1263 GPBUInt32Int64Dictionary *dict2 = |
| 1264 [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues2 |
| 1265 forKeys:kKeys1 |
| 1266 count:GPBARRAYSIZE(kValues2)]; |
| 1267 XCTAssertNotNil(dict2); |
| 1268 GPBUInt32Int64Dictionary *dict3 = |
| 1269 [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues1 |
| 1270 forKeys:kKeys2 |
| 1271 count:GPBARRAYSIZE(kValues1)]; |
| 1272 XCTAssertNotNil(dict3); |
| 1273 GPBUInt32Int64Dictionary *dict4 = |
| 1274 [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues3 |
| 1275 forKeys:kKeys1 |
| 1276 count:GPBARRAYSIZE(kValues3)]; |
| 1277 XCTAssertNotNil(dict4); |
| 1278 |
| 1279 // 1/1Prime should be different objects, but equal. |
| 1280 XCTAssertNotEqual(dict1, dict1prime); |
| 1281 XCTAssertEqualObjects(dict1, dict1prime); |
| 1282 // Equal, so they must have same hash. |
| 1283 XCTAssertEqual([dict1 hash], [dict1prime hash]); |
| 1284 |
| 1285 // 2 is same keys, different values; not equal. |
| 1286 XCTAssertNotEqualObjects(dict1, dict2); |
| 1287 |
| 1288 // 3 is different keys, same values; not equal. |
| 1289 XCTAssertNotEqualObjects(dict1, dict3); |
| 1290 |
| 1291 // 4 extra pair; not equal |
| 1292 XCTAssertNotEqualObjects(dict1, dict4); |
| 1293 |
| 1294 [dict1 release]; |
| 1295 [dict1prime release]; |
| 1296 [dict2 release]; |
| 1297 [dict3 release]; |
| 1298 [dict4 release]; |
| 1299 } |
| 1300 |
| 1301 - (void)testCopy { |
| 1302 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 1303 const int64_t kValues[] = { 400, 401, 402, 403 }; |
| 1304 GPBUInt32Int64Dictionary *dict = |
| 1305 [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues |
| 1306 forKeys:kKeys |
| 1307 count:GPBARRAYSIZE(kValues)]; |
| 1308 XCTAssertNotNil(dict); |
| 1309 |
| 1310 GPBUInt32Int64Dictionary *dict2 = [dict copy]; |
| 1311 XCTAssertNotNil(dict2); |
| 1312 |
| 1313 // Should be new object but equal. |
| 1314 XCTAssertNotEqual(dict, dict2); |
| 1315 XCTAssertEqualObjects(dict, dict2); |
| 1316 XCTAssertTrue([dict2 isKindOfClass:[GPBUInt32Int64Dictionary class]]); |
| 1317 |
| 1318 [dict2 release]; |
| 1319 [dict release]; |
| 1320 } |
| 1321 |
| 1322 - (void)testDictionaryFromDictionary { |
| 1323 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 1324 const int64_t kValues[] = { 400, 401, 402, 403 }; |
| 1325 GPBUInt32Int64Dictionary *dict = |
| 1326 [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues |
| 1327 forKeys:kKeys |
| 1328 count:GPBARRAYSIZE(kValues)]; |
| 1329 XCTAssertNotNil(dict); |
| 1330 |
| 1331 GPBUInt32Int64Dictionary *dict2 = |
| 1332 [GPBUInt32Int64Dictionary dictionaryWithDictionary:dict]; |
| 1333 XCTAssertNotNil(dict2); |
| 1334 |
| 1335 // Should be new pointer, but equal objects. |
| 1336 XCTAssertNotEqual(dict, dict2); |
| 1337 XCTAssertEqualObjects(dict, dict2); |
| 1338 [dict release]; |
| 1339 } |
| 1340 |
| 1341 - (void)testAdds { |
| 1342 GPBUInt32Int64Dictionary *dict = [GPBUInt32Int64Dictionary dictionary]; |
| 1343 XCTAssertNotNil(dict); |
| 1344 |
| 1345 XCTAssertEqual(dict.count, 0U); |
| 1346 [dict setValue:400 forKey:1U]; |
| 1347 XCTAssertEqual(dict.count, 1U); |
| 1348 |
| 1349 const uint32_t kKeys[] = { 2U, 3U, 4U }; |
| 1350 const int64_t kValues[] = { 401, 402, 403 }; |
| 1351 GPBUInt32Int64Dictionary *dict2 = |
| 1352 [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues |
| 1353 forKeys:kKeys |
| 1354 count:GPBARRAYSIZE(kValues)]; |
| 1355 XCTAssertNotNil(dict2); |
| 1356 [dict addEntriesFromDictionary:dict2]; |
| 1357 XCTAssertEqual(dict.count, 4U); |
| 1358 |
| 1359 int64_t value; |
| 1360 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1361 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1362 XCTAssertEqual(value, 400); |
| 1363 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1364 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1365 XCTAssertEqual(value, 401); |
| 1366 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1367 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1368 XCTAssertEqual(value, 402); |
| 1369 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1370 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1371 XCTAssertEqual(value, 403); |
| 1372 [dict2 release]; |
| 1373 } |
| 1374 |
| 1375 - (void)testRemove { |
| 1376 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 1377 const int64_t kValues[] = { 400, 401, 402, 403 }; |
| 1378 GPBUInt32Int64Dictionary *dict = |
| 1379 [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues |
| 1380 forKeys:kKeys |
| 1381 count:GPBARRAYSIZE(kValues)]; |
| 1382 XCTAssertNotNil(dict); |
| 1383 XCTAssertEqual(dict.count, 4U); |
| 1384 |
| 1385 [dict removeValueForKey:2U]; |
| 1386 XCTAssertEqual(dict.count, 3U); |
| 1387 int64_t value; |
| 1388 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1389 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1390 XCTAssertEqual(value, 400); |
| 1391 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1392 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1393 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1394 XCTAssertEqual(value, 402); |
| 1395 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1396 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1397 XCTAssertEqual(value, 403); |
| 1398 |
| 1399 // Remove again does nothing. |
| 1400 [dict removeValueForKey:2U]; |
| 1401 XCTAssertEqual(dict.count, 3U); |
| 1402 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1403 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1404 XCTAssertEqual(value, 400); |
| 1405 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1406 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1407 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1408 XCTAssertEqual(value, 402); |
| 1409 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1410 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1411 XCTAssertEqual(value, 403); |
| 1412 |
| 1413 [dict removeValueForKey:4U]; |
| 1414 XCTAssertEqual(dict.count, 2U); |
| 1415 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1416 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1417 XCTAssertEqual(value, 400); |
| 1418 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1419 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1420 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1421 XCTAssertEqual(value, 402); |
| 1422 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 1423 |
| 1424 [dict removeAll]; |
| 1425 XCTAssertEqual(dict.count, 0U); |
| 1426 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 1427 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1428 XCTAssertFalse([dict valueForKey:3U value:NULL]); |
| 1429 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 1430 [dict release]; |
| 1431 } |
| 1432 |
| 1433 - (void)testInplaceMutation { |
| 1434 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 1435 const int64_t kValues[] = { 400, 401, 402, 403 }; |
| 1436 GPBUInt32Int64Dictionary *dict = |
| 1437 [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues |
| 1438 forKeys:kKeys |
| 1439 count:GPBARRAYSIZE(kValues)]; |
| 1440 XCTAssertNotNil(dict); |
| 1441 XCTAssertEqual(dict.count, 4U); |
| 1442 int64_t value; |
| 1443 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1444 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1445 XCTAssertEqual(value, 400); |
| 1446 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1447 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1448 XCTAssertEqual(value, 401); |
| 1449 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1450 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1451 XCTAssertEqual(value, 402); |
| 1452 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1453 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1454 XCTAssertEqual(value, 403); |
| 1455 |
| 1456 [dict setValue:403 forKey:1U]; |
| 1457 XCTAssertEqual(dict.count, 4U); |
| 1458 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1459 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1460 XCTAssertEqual(value, 403); |
| 1461 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1462 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1463 XCTAssertEqual(value, 401); |
| 1464 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1465 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1466 XCTAssertEqual(value, 402); |
| 1467 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1468 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1469 XCTAssertEqual(value, 403); |
| 1470 |
| 1471 [dict setValue:401 forKey:4U]; |
| 1472 XCTAssertEqual(dict.count, 4U); |
| 1473 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1474 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1475 XCTAssertEqual(value, 403); |
| 1476 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1477 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1478 XCTAssertEqual(value, 401); |
| 1479 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1480 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1481 XCTAssertEqual(value, 402); |
| 1482 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1483 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1484 XCTAssertEqual(value, 401); |
| 1485 |
| 1486 const uint32_t kKeys2[] = { 2U, 3U }; |
| 1487 const int64_t kValues2[] = { 402, 400 }; |
| 1488 GPBUInt32Int64Dictionary *dict2 = |
| 1489 [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues2 |
| 1490 forKeys:kKeys2 |
| 1491 count:GPBARRAYSIZE(kValues2)]; |
| 1492 XCTAssertNotNil(dict2); |
| 1493 [dict addEntriesFromDictionary:dict2]; |
| 1494 XCTAssertEqual(dict.count, 4U); |
| 1495 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1496 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1497 XCTAssertEqual(value, 403); |
| 1498 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1499 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1500 XCTAssertEqual(value, 402); |
| 1501 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1502 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1503 XCTAssertEqual(value, 400); |
| 1504 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1505 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1506 XCTAssertEqual(value, 401); |
| 1507 |
| 1508 [dict2 release]; |
| 1509 [dict release]; |
| 1510 } |
| 1511 |
| 1512 @end |
| 1513 |
| 1514 #pragma mark - UInt32 -> Bool |
| 1515 |
| 1516 @interface GPBUInt32BoolDictionaryTests : XCTestCase |
| 1517 @end |
| 1518 |
| 1519 @implementation GPBUInt32BoolDictionaryTests |
| 1520 |
| 1521 - (void)testEmpty { |
| 1522 GPBUInt32BoolDictionary *dict = [[GPBUInt32BoolDictionary alloc] init]; |
| 1523 XCTAssertNotNil(dict); |
| 1524 XCTAssertEqual(dict.count, 0U); |
| 1525 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 1526 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *sto
p) { |
| 1527 #pragma unused(aKey, aValue, stop) |
| 1528 XCTFail(@"Shouldn't get here!"); |
| 1529 }]; |
| 1530 [dict release]; |
| 1531 } |
| 1532 |
| 1533 - (void)testOne { |
| 1534 GPBUInt32BoolDictionary *dict = [GPBUInt32BoolDictionary dictionaryWithValue:Y
ES forKey:1U]; |
| 1535 XCTAssertNotNil(dict); |
| 1536 XCTAssertEqual(dict.count, 1U); |
| 1537 BOOL value; |
| 1538 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1539 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1540 XCTAssertEqual(value, YES); |
| 1541 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1542 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *sto
p) { |
| 1543 XCTAssertEqual(aKey, 1U); |
| 1544 XCTAssertEqual(aValue, YES); |
| 1545 XCTAssertNotEqual(stop, NULL); |
| 1546 }]; |
| 1547 } |
| 1548 |
| 1549 - (void)testBasics { |
| 1550 const uint32_t kKeys[] = { 1U, 2U, 3U }; |
| 1551 const BOOL kValues[] = { YES, YES, NO }; |
| 1552 GPBUInt32BoolDictionary *dict = |
| 1553 [[GPBUInt32BoolDictionary alloc] initWithValues:kValues |
| 1554 forKeys:kKeys |
| 1555 count:GPBARRAYSIZE(kValues)]; |
| 1556 XCTAssertNotNil(dict); |
| 1557 XCTAssertEqual(dict.count, 3U); |
| 1558 BOOL value; |
| 1559 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1560 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1561 XCTAssertEqual(value, YES); |
| 1562 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1563 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1564 XCTAssertEqual(value, YES); |
| 1565 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1566 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1567 XCTAssertEqual(value, NO); |
| 1568 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 1569 |
| 1570 __block NSUInteger idx = 0; |
| 1571 uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); |
| 1572 BOOL *seenValues = malloc(3 * sizeof(BOOL)); |
| 1573 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *sto
p) { |
| 1574 XCTAssertLessThan(idx, 3U); |
| 1575 seenKeys[idx] = aKey; |
| 1576 seenValues[idx] = aValue; |
| 1577 XCTAssertNotEqual(stop, NULL); |
| 1578 ++idx; |
| 1579 }]; |
| 1580 for (int i = 0; i < 3; ++i) { |
| 1581 BOOL foundKey = NO; |
| 1582 for (int j = 0; (j < 3) && !foundKey; ++j) { |
| 1583 if (kKeys[i] == seenKeys[j]) { |
| 1584 foundKey = YES; |
| 1585 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j); |
| 1586 } |
| 1587 } |
| 1588 XCTAssertTrue(foundKey, @"i = %d", i); |
| 1589 } |
| 1590 free(seenKeys); |
| 1591 free(seenValues); |
| 1592 |
| 1593 // Stopping the enumeration. |
| 1594 idx = 0; |
| 1595 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *sto
p) { |
| 1596 #pragma unused(aKey, aValue) |
| 1597 if (idx == 1) *stop = YES; |
| 1598 XCTAssertNotEqual(idx, 2U); |
| 1599 ++idx; |
| 1600 }]; |
| 1601 [dict release]; |
| 1602 } |
| 1603 |
| 1604 - (void)testEquality { |
| 1605 const uint32_t kKeys1[] = { 1U, 2U, 3U, 4U }; |
| 1606 const uint32_t kKeys2[] = { 2U, 1U, 4U }; |
| 1607 const BOOL kValues1[] = { YES, YES, NO }; |
| 1608 const BOOL kValues2[] = { YES, NO, NO }; |
| 1609 const BOOL kValues3[] = { YES, YES, NO, NO }; |
| 1610 GPBUInt32BoolDictionary *dict1 = |
| 1611 [[GPBUInt32BoolDictionary alloc] initWithValues:kValues1 |
| 1612 forKeys:kKeys1 |
| 1613 count:GPBARRAYSIZE(kValues1)]; |
| 1614 XCTAssertNotNil(dict1); |
| 1615 GPBUInt32BoolDictionary *dict1prime = |
| 1616 [[GPBUInt32BoolDictionary alloc] initWithValues:kValues1 |
| 1617 forKeys:kKeys1 |
| 1618 count:GPBARRAYSIZE(kValues1)]; |
| 1619 XCTAssertNotNil(dict1prime); |
| 1620 GPBUInt32BoolDictionary *dict2 = |
| 1621 [[GPBUInt32BoolDictionary alloc] initWithValues:kValues2 |
| 1622 forKeys:kKeys1 |
| 1623 count:GPBARRAYSIZE(kValues2)]; |
| 1624 XCTAssertNotNil(dict2); |
| 1625 GPBUInt32BoolDictionary *dict3 = |
| 1626 [[GPBUInt32BoolDictionary alloc] initWithValues:kValues1 |
| 1627 forKeys:kKeys2 |
| 1628 count:GPBARRAYSIZE(kValues1)]; |
| 1629 XCTAssertNotNil(dict3); |
| 1630 GPBUInt32BoolDictionary *dict4 = |
| 1631 [[GPBUInt32BoolDictionary alloc] initWithValues:kValues3 |
| 1632 forKeys:kKeys1 |
| 1633 count:GPBARRAYSIZE(kValues3)]; |
| 1634 XCTAssertNotNil(dict4); |
| 1635 |
| 1636 // 1/1Prime should be different objects, but equal. |
| 1637 XCTAssertNotEqual(dict1, dict1prime); |
| 1638 XCTAssertEqualObjects(dict1, dict1prime); |
| 1639 // Equal, so they must have same hash. |
| 1640 XCTAssertEqual([dict1 hash], [dict1prime hash]); |
| 1641 |
| 1642 // 2 is same keys, different values; not equal. |
| 1643 XCTAssertNotEqualObjects(dict1, dict2); |
| 1644 |
| 1645 // 3 is different keys, same values; not equal. |
| 1646 XCTAssertNotEqualObjects(dict1, dict3); |
| 1647 |
| 1648 // 4 extra pair; not equal |
| 1649 XCTAssertNotEqualObjects(dict1, dict4); |
| 1650 |
| 1651 [dict1 release]; |
| 1652 [dict1prime release]; |
| 1653 [dict2 release]; |
| 1654 [dict3 release]; |
| 1655 [dict4 release]; |
| 1656 } |
| 1657 |
| 1658 - (void)testCopy { |
| 1659 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 1660 const BOOL kValues[] = { YES, YES, NO, NO }; |
| 1661 GPBUInt32BoolDictionary *dict = |
| 1662 [[GPBUInt32BoolDictionary alloc] initWithValues:kValues |
| 1663 forKeys:kKeys |
| 1664 count:GPBARRAYSIZE(kValues)]; |
| 1665 XCTAssertNotNil(dict); |
| 1666 |
| 1667 GPBUInt32BoolDictionary *dict2 = [dict copy]; |
| 1668 XCTAssertNotNil(dict2); |
| 1669 |
| 1670 // Should be new object but equal. |
| 1671 XCTAssertNotEqual(dict, dict2); |
| 1672 XCTAssertEqualObjects(dict, dict2); |
| 1673 XCTAssertTrue([dict2 isKindOfClass:[GPBUInt32BoolDictionary class]]); |
| 1674 |
| 1675 [dict2 release]; |
| 1676 [dict release]; |
| 1677 } |
| 1678 |
| 1679 - (void)testDictionaryFromDictionary { |
| 1680 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 1681 const BOOL kValues[] = { YES, YES, NO, NO }; |
| 1682 GPBUInt32BoolDictionary *dict = |
| 1683 [[GPBUInt32BoolDictionary alloc] initWithValues:kValues |
| 1684 forKeys:kKeys |
| 1685 count:GPBARRAYSIZE(kValues)]; |
| 1686 XCTAssertNotNil(dict); |
| 1687 |
| 1688 GPBUInt32BoolDictionary *dict2 = |
| 1689 [GPBUInt32BoolDictionary dictionaryWithDictionary:dict]; |
| 1690 XCTAssertNotNil(dict2); |
| 1691 |
| 1692 // Should be new pointer, but equal objects. |
| 1693 XCTAssertNotEqual(dict, dict2); |
| 1694 XCTAssertEqualObjects(dict, dict2); |
| 1695 [dict release]; |
| 1696 } |
| 1697 |
| 1698 - (void)testAdds { |
| 1699 GPBUInt32BoolDictionary *dict = [GPBUInt32BoolDictionary dictionary]; |
| 1700 XCTAssertNotNil(dict); |
| 1701 |
| 1702 XCTAssertEqual(dict.count, 0U); |
| 1703 [dict setValue:YES forKey:1U]; |
| 1704 XCTAssertEqual(dict.count, 1U); |
| 1705 |
| 1706 const uint32_t kKeys[] = { 2U, 3U, 4U }; |
| 1707 const BOOL kValues[] = { YES, NO, NO }; |
| 1708 GPBUInt32BoolDictionary *dict2 = |
| 1709 [[GPBUInt32BoolDictionary alloc] initWithValues:kValues |
| 1710 forKeys:kKeys |
| 1711 count:GPBARRAYSIZE(kValues)]; |
| 1712 XCTAssertNotNil(dict2); |
| 1713 [dict addEntriesFromDictionary:dict2]; |
| 1714 XCTAssertEqual(dict.count, 4U); |
| 1715 |
| 1716 BOOL value; |
| 1717 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1718 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1719 XCTAssertEqual(value, YES); |
| 1720 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1721 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1722 XCTAssertEqual(value, YES); |
| 1723 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1724 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1725 XCTAssertEqual(value, NO); |
| 1726 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1727 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1728 XCTAssertEqual(value, NO); |
| 1729 [dict2 release]; |
| 1730 } |
| 1731 |
| 1732 - (void)testRemove { |
| 1733 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 1734 const BOOL kValues[] = { YES, YES, NO, NO }; |
| 1735 GPBUInt32BoolDictionary *dict = |
| 1736 [[GPBUInt32BoolDictionary alloc] initWithValues:kValues |
| 1737 forKeys:kKeys |
| 1738 count:GPBARRAYSIZE(kValues)]; |
| 1739 XCTAssertNotNil(dict); |
| 1740 XCTAssertEqual(dict.count, 4U); |
| 1741 |
| 1742 [dict removeValueForKey:2U]; |
| 1743 XCTAssertEqual(dict.count, 3U); |
| 1744 BOOL value; |
| 1745 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1746 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1747 XCTAssertEqual(value, YES); |
| 1748 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1749 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1750 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1751 XCTAssertEqual(value, NO); |
| 1752 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1753 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1754 XCTAssertEqual(value, NO); |
| 1755 |
| 1756 // Remove again does nothing. |
| 1757 [dict removeValueForKey:2U]; |
| 1758 XCTAssertEqual(dict.count, 3U); |
| 1759 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1760 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1761 XCTAssertEqual(value, YES); |
| 1762 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1763 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1764 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1765 XCTAssertEqual(value, NO); |
| 1766 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1767 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1768 XCTAssertEqual(value, NO); |
| 1769 |
| 1770 [dict removeValueForKey:4U]; |
| 1771 XCTAssertEqual(dict.count, 2U); |
| 1772 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1773 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1774 XCTAssertEqual(value, YES); |
| 1775 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1776 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1777 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1778 XCTAssertEqual(value, NO); |
| 1779 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 1780 |
| 1781 [dict removeAll]; |
| 1782 XCTAssertEqual(dict.count, 0U); |
| 1783 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 1784 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1785 XCTAssertFalse([dict valueForKey:3U value:NULL]); |
| 1786 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 1787 [dict release]; |
| 1788 } |
| 1789 |
| 1790 - (void)testInplaceMutation { |
| 1791 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 1792 const BOOL kValues[] = { YES, YES, NO, NO }; |
| 1793 GPBUInt32BoolDictionary *dict = |
| 1794 [[GPBUInt32BoolDictionary alloc] initWithValues:kValues |
| 1795 forKeys:kKeys |
| 1796 count:GPBARRAYSIZE(kValues)]; |
| 1797 XCTAssertNotNil(dict); |
| 1798 XCTAssertEqual(dict.count, 4U); |
| 1799 BOOL value; |
| 1800 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1801 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1802 XCTAssertEqual(value, YES); |
| 1803 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1804 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1805 XCTAssertEqual(value, YES); |
| 1806 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1807 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1808 XCTAssertEqual(value, NO); |
| 1809 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1810 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1811 XCTAssertEqual(value, NO); |
| 1812 |
| 1813 [dict setValue:NO forKey:1U]; |
| 1814 XCTAssertEqual(dict.count, 4U); |
| 1815 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1816 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1817 XCTAssertEqual(value, NO); |
| 1818 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1819 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1820 XCTAssertEqual(value, YES); |
| 1821 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1822 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1823 XCTAssertEqual(value, NO); |
| 1824 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1825 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1826 XCTAssertEqual(value, NO); |
| 1827 |
| 1828 [dict setValue:YES forKey:4U]; |
| 1829 XCTAssertEqual(dict.count, 4U); |
| 1830 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1831 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1832 XCTAssertEqual(value, NO); |
| 1833 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1834 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1835 XCTAssertEqual(value, YES); |
| 1836 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1837 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1838 XCTAssertEqual(value, NO); |
| 1839 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1840 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1841 XCTAssertEqual(value, YES); |
| 1842 |
| 1843 const uint32_t kKeys2[] = { 2U, 3U }; |
| 1844 const BOOL kValues2[] = { NO, YES }; |
| 1845 GPBUInt32BoolDictionary *dict2 = |
| 1846 [[GPBUInt32BoolDictionary alloc] initWithValues:kValues2 |
| 1847 forKeys:kKeys2 |
| 1848 count:GPBARRAYSIZE(kValues2)]; |
| 1849 XCTAssertNotNil(dict2); |
| 1850 [dict addEntriesFromDictionary:dict2]; |
| 1851 XCTAssertEqual(dict.count, 4U); |
| 1852 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1853 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1854 XCTAssertEqual(value, NO); |
| 1855 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1856 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1857 XCTAssertEqual(value, NO); |
| 1858 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1859 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1860 XCTAssertEqual(value, YES); |
| 1861 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 1862 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 1863 XCTAssertEqual(value, YES); |
| 1864 |
| 1865 [dict2 release]; |
| 1866 [dict release]; |
| 1867 } |
| 1868 |
| 1869 @end |
| 1870 |
| 1871 #pragma mark - UInt32 -> Float |
| 1872 |
| 1873 @interface GPBUInt32FloatDictionaryTests : XCTestCase |
| 1874 @end |
| 1875 |
| 1876 @implementation GPBUInt32FloatDictionaryTests |
| 1877 |
| 1878 - (void)testEmpty { |
| 1879 GPBUInt32FloatDictionary *dict = [[GPBUInt32FloatDictionary alloc] init]; |
| 1880 XCTAssertNotNil(dict); |
| 1881 XCTAssertEqual(dict.count, 0U); |
| 1882 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 1883 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, float aValue, BOOL *st
op) { |
| 1884 #pragma unused(aKey, aValue, stop) |
| 1885 XCTFail(@"Shouldn't get here!"); |
| 1886 }]; |
| 1887 [dict release]; |
| 1888 } |
| 1889 |
| 1890 - (void)testOne { |
| 1891 GPBUInt32FloatDictionary *dict = [GPBUInt32FloatDictionary dictionaryWithValue
:500.f forKey:1U]; |
| 1892 XCTAssertNotNil(dict); |
| 1893 XCTAssertEqual(dict.count, 1U); |
| 1894 float value; |
| 1895 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1896 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1897 XCTAssertEqual(value, 500.f); |
| 1898 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 1899 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, float aValue, BOOL *st
op) { |
| 1900 XCTAssertEqual(aKey, 1U); |
| 1901 XCTAssertEqual(aValue, 500.f); |
| 1902 XCTAssertNotEqual(stop, NULL); |
| 1903 }]; |
| 1904 } |
| 1905 |
| 1906 - (void)testBasics { |
| 1907 const uint32_t kKeys[] = { 1U, 2U, 3U }; |
| 1908 const float kValues[] = { 500.f, 501.f, 502.f }; |
| 1909 GPBUInt32FloatDictionary *dict = |
| 1910 [[GPBUInt32FloatDictionary alloc] initWithValues:kValues |
| 1911 forKeys:kKeys |
| 1912 count:GPBARRAYSIZE(kValues)]; |
| 1913 XCTAssertNotNil(dict); |
| 1914 XCTAssertEqual(dict.count, 3U); |
| 1915 float value; |
| 1916 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 1917 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 1918 XCTAssertEqual(value, 500.f); |
| 1919 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 1920 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 1921 XCTAssertEqual(value, 501.f); |
| 1922 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 1923 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 1924 XCTAssertEqual(value, 502.f); |
| 1925 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 1926 |
| 1927 __block NSUInteger idx = 0; |
| 1928 uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); |
| 1929 float *seenValues = malloc(3 * sizeof(float)); |
| 1930 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, float aValue, BOOL *st
op) { |
| 1931 XCTAssertLessThan(idx, 3U); |
| 1932 seenKeys[idx] = aKey; |
| 1933 seenValues[idx] = aValue; |
| 1934 XCTAssertNotEqual(stop, NULL); |
| 1935 ++idx; |
| 1936 }]; |
| 1937 for (int i = 0; i < 3; ++i) { |
| 1938 BOOL foundKey = NO; |
| 1939 for (int j = 0; (j < 3) && !foundKey; ++j) { |
| 1940 if (kKeys[i] == seenKeys[j]) { |
| 1941 foundKey = YES; |
| 1942 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j); |
| 1943 } |
| 1944 } |
| 1945 XCTAssertTrue(foundKey, @"i = %d", i); |
| 1946 } |
| 1947 free(seenKeys); |
| 1948 free(seenValues); |
| 1949 |
| 1950 // Stopping the enumeration. |
| 1951 idx = 0; |
| 1952 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, float aValue, BOOL *st
op) { |
| 1953 #pragma unused(aKey, aValue) |
| 1954 if (idx == 1) *stop = YES; |
| 1955 XCTAssertNotEqual(idx, 2U); |
| 1956 ++idx; |
| 1957 }]; |
| 1958 [dict release]; |
| 1959 } |
| 1960 |
| 1961 - (void)testEquality { |
| 1962 const uint32_t kKeys1[] = { 1U, 2U, 3U, 4U }; |
| 1963 const uint32_t kKeys2[] = { 2U, 1U, 4U }; |
| 1964 const float kValues1[] = { 500.f, 501.f, 502.f }; |
| 1965 const float kValues2[] = { 500.f, 503.f, 502.f }; |
| 1966 const float kValues3[] = { 500.f, 501.f, 502.f, 503.f }; |
| 1967 GPBUInt32FloatDictionary *dict1 = |
| 1968 [[GPBUInt32FloatDictionary alloc] initWithValues:kValues1 |
| 1969 forKeys:kKeys1 |
| 1970 count:GPBARRAYSIZE(kValues1)]; |
| 1971 XCTAssertNotNil(dict1); |
| 1972 GPBUInt32FloatDictionary *dict1prime = |
| 1973 [[GPBUInt32FloatDictionary alloc] initWithValues:kValues1 |
| 1974 forKeys:kKeys1 |
| 1975 count:GPBARRAYSIZE(kValues1)]; |
| 1976 XCTAssertNotNil(dict1prime); |
| 1977 GPBUInt32FloatDictionary *dict2 = |
| 1978 [[GPBUInt32FloatDictionary alloc] initWithValues:kValues2 |
| 1979 forKeys:kKeys1 |
| 1980 count:GPBARRAYSIZE(kValues2)]; |
| 1981 XCTAssertNotNil(dict2); |
| 1982 GPBUInt32FloatDictionary *dict3 = |
| 1983 [[GPBUInt32FloatDictionary alloc] initWithValues:kValues1 |
| 1984 forKeys:kKeys2 |
| 1985 count:GPBARRAYSIZE(kValues1)]; |
| 1986 XCTAssertNotNil(dict3); |
| 1987 GPBUInt32FloatDictionary *dict4 = |
| 1988 [[GPBUInt32FloatDictionary alloc] initWithValues:kValues3 |
| 1989 forKeys:kKeys1 |
| 1990 count:GPBARRAYSIZE(kValues3)]; |
| 1991 XCTAssertNotNil(dict4); |
| 1992 |
| 1993 // 1/1Prime should be different objects, but equal. |
| 1994 XCTAssertNotEqual(dict1, dict1prime); |
| 1995 XCTAssertEqualObjects(dict1, dict1prime); |
| 1996 // Equal, so they must have same hash. |
| 1997 XCTAssertEqual([dict1 hash], [dict1prime hash]); |
| 1998 |
| 1999 // 2 is same keys, different values; not equal. |
| 2000 XCTAssertNotEqualObjects(dict1, dict2); |
| 2001 |
| 2002 // 3 is different keys, same values; not equal. |
| 2003 XCTAssertNotEqualObjects(dict1, dict3); |
| 2004 |
| 2005 // 4 extra pair; not equal |
| 2006 XCTAssertNotEqualObjects(dict1, dict4); |
| 2007 |
| 2008 [dict1 release]; |
| 2009 [dict1prime release]; |
| 2010 [dict2 release]; |
| 2011 [dict3 release]; |
| 2012 [dict4 release]; |
| 2013 } |
| 2014 |
| 2015 - (void)testCopy { |
| 2016 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 2017 const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; |
| 2018 GPBUInt32FloatDictionary *dict = |
| 2019 [[GPBUInt32FloatDictionary alloc] initWithValues:kValues |
| 2020 forKeys:kKeys |
| 2021 count:GPBARRAYSIZE(kValues)]; |
| 2022 XCTAssertNotNil(dict); |
| 2023 |
| 2024 GPBUInt32FloatDictionary *dict2 = [dict copy]; |
| 2025 XCTAssertNotNil(dict2); |
| 2026 |
| 2027 // Should be new object but equal. |
| 2028 XCTAssertNotEqual(dict, dict2); |
| 2029 XCTAssertEqualObjects(dict, dict2); |
| 2030 XCTAssertTrue([dict2 isKindOfClass:[GPBUInt32FloatDictionary class]]); |
| 2031 |
| 2032 [dict2 release]; |
| 2033 [dict release]; |
| 2034 } |
| 2035 |
| 2036 - (void)testDictionaryFromDictionary { |
| 2037 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 2038 const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; |
| 2039 GPBUInt32FloatDictionary *dict = |
| 2040 [[GPBUInt32FloatDictionary alloc] initWithValues:kValues |
| 2041 forKeys:kKeys |
| 2042 count:GPBARRAYSIZE(kValues)]; |
| 2043 XCTAssertNotNil(dict); |
| 2044 |
| 2045 GPBUInt32FloatDictionary *dict2 = |
| 2046 [GPBUInt32FloatDictionary dictionaryWithDictionary:dict]; |
| 2047 XCTAssertNotNil(dict2); |
| 2048 |
| 2049 // Should be new pointer, but equal objects. |
| 2050 XCTAssertNotEqual(dict, dict2); |
| 2051 XCTAssertEqualObjects(dict, dict2); |
| 2052 [dict release]; |
| 2053 } |
| 2054 |
| 2055 - (void)testAdds { |
| 2056 GPBUInt32FloatDictionary *dict = [GPBUInt32FloatDictionary dictionary]; |
| 2057 XCTAssertNotNil(dict); |
| 2058 |
| 2059 XCTAssertEqual(dict.count, 0U); |
| 2060 [dict setValue:500.f forKey:1U]; |
| 2061 XCTAssertEqual(dict.count, 1U); |
| 2062 |
| 2063 const uint32_t kKeys[] = { 2U, 3U, 4U }; |
| 2064 const float kValues[] = { 501.f, 502.f, 503.f }; |
| 2065 GPBUInt32FloatDictionary *dict2 = |
| 2066 [[GPBUInt32FloatDictionary alloc] initWithValues:kValues |
| 2067 forKeys:kKeys |
| 2068 count:GPBARRAYSIZE(kValues)]; |
| 2069 XCTAssertNotNil(dict2); |
| 2070 [dict addEntriesFromDictionary:dict2]; |
| 2071 XCTAssertEqual(dict.count, 4U); |
| 2072 |
| 2073 float value; |
| 2074 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2075 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2076 XCTAssertEqual(value, 500.f); |
| 2077 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2078 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2079 XCTAssertEqual(value, 501.f); |
| 2080 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2081 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2082 XCTAssertEqual(value, 502.f); |
| 2083 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2084 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2085 XCTAssertEqual(value, 503.f); |
| 2086 [dict2 release]; |
| 2087 } |
| 2088 |
| 2089 - (void)testRemove { |
| 2090 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 2091 const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; |
| 2092 GPBUInt32FloatDictionary *dict = |
| 2093 [[GPBUInt32FloatDictionary alloc] initWithValues:kValues |
| 2094 forKeys:kKeys |
| 2095 count:GPBARRAYSIZE(kValues)]; |
| 2096 XCTAssertNotNil(dict); |
| 2097 XCTAssertEqual(dict.count, 4U); |
| 2098 |
| 2099 [dict removeValueForKey:2U]; |
| 2100 XCTAssertEqual(dict.count, 3U); |
| 2101 float value; |
| 2102 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2103 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2104 XCTAssertEqual(value, 500.f); |
| 2105 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2106 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2107 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2108 XCTAssertEqual(value, 502.f); |
| 2109 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2110 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2111 XCTAssertEqual(value, 503.f); |
| 2112 |
| 2113 // Remove again does nothing. |
| 2114 [dict removeValueForKey:2U]; |
| 2115 XCTAssertEqual(dict.count, 3U); |
| 2116 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2117 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2118 XCTAssertEqual(value, 500.f); |
| 2119 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2120 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2121 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2122 XCTAssertEqual(value, 502.f); |
| 2123 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2124 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2125 XCTAssertEqual(value, 503.f); |
| 2126 |
| 2127 [dict removeValueForKey:4U]; |
| 2128 XCTAssertEqual(dict.count, 2U); |
| 2129 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2130 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2131 XCTAssertEqual(value, 500.f); |
| 2132 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2133 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2134 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2135 XCTAssertEqual(value, 502.f); |
| 2136 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 2137 |
| 2138 [dict removeAll]; |
| 2139 XCTAssertEqual(dict.count, 0U); |
| 2140 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 2141 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2142 XCTAssertFalse([dict valueForKey:3U value:NULL]); |
| 2143 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 2144 [dict release]; |
| 2145 } |
| 2146 |
| 2147 - (void)testInplaceMutation { |
| 2148 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 2149 const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; |
| 2150 GPBUInt32FloatDictionary *dict = |
| 2151 [[GPBUInt32FloatDictionary alloc] initWithValues:kValues |
| 2152 forKeys:kKeys |
| 2153 count:GPBARRAYSIZE(kValues)]; |
| 2154 XCTAssertNotNil(dict); |
| 2155 XCTAssertEqual(dict.count, 4U); |
| 2156 float value; |
| 2157 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2158 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2159 XCTAssertEqual(value, 500.f); |
| 2160 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2161 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2162 XCTAssertEqual(value, 501.f); |
| 2163 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2164 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2165 XCTAssertEqual(value, 502.f); |
| 2166 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2167 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2168 XCTAssertEqual(value, 503.f); |
| 2169 |
| 2170 [dict setValue:503.f forKey:1U]; |
| 2171 XCTAssertEqual(dict.count, 4U); |
| 2172 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2173 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2174 XCTAssertEqual(value, 503.f); |
| 2175 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2176 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2177 XCTAssertEqual(value, 501.f); |
| 2178 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2179 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2180 XCTAssertEqual(value, 502.f); |
| 2181 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2182 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2183 XCTAssertEqual(value, 503.f); |
| 2184 |
| 2185 [dict setValue:501.f forKey:4U]; |
| 2186 XCTAssertEqual(dict.count, 4U); |
| 2187 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2188 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2189 XCTAssertEqual(value, 503.f); |
| 2190 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2191 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2192 XCTAssertEqual(value, 501.f); |
| 2193 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2194 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2195 XCTAssertEqual(value, 502.f); |
| 2196 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2197 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2198 XCTAssertEqual(value, 501.f); |
| 2199 |
| 2200 const uint32_t kKeys2[] = { 2U, 3U }; |
| 2201 const float kValues2[] = { 502.f, 500.f }; |
| 2202 GPBUInt32FloatDictionary *dict2 = |
| 2203 [[GPBUInt32FloatDictionary alloc] initWithValues:kValues2 |
| 2204 forKeys:kKeys2 |
| 2205 count:GPBARRAYSIZE(kValues2)]; |
| 2206 XCTAssertNotNil(dict2); |
| 2207 [dict addEntriesFromDictionary:dict2]; |
| 2208 XCTAssertEqual(dict.count, 4U); |
| 2209 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2210 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2211 XCTAssertEqual(value, 503.f); |
| 2212 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2213 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2214 XCTAssertEqual(value, 502.f); |
| 2215 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2216 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2217 XCTAssertEqual(value, 500.f); |
| 2218 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2219 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2220 XCTAssertEqual(value, 501.f); |
| 2221 |
| 2222 [dict2 release]; |
| 2223 [dict release]; |
| 2224 } |
| 2225 |
| 2226 @end |
| 2227 |
| 2228 #pragma mark - UInt32 -> Double |
| 2229 |
| 2230 @interface GPBUInt32DoubleDictionaryTests : XCTestCase |
| 2231 @end |
| 2232 |
| 2233 @implementation GPBUInt32DoubleDictionaryTests |
| 2234 |
| 2235 - (void)testEmpty { |
| 2236 GPBUInt32DoubleDictionary *dict = [[GPBUInt32DoubleDictionary alloc] init]; |
| 2237 XCTAssertNotNil(dict); |
| 2238 XCTAssertEqual(dict.count, 0U); |
| 2239 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 2240 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, double aValue, BOOL *s
top) { |
| 2241 #pragma unused(aKey, aValue, stop) |
| 2242 XCTFail(@"Shouldn't get here!"); |
| 2243 }]; |
| 2244 [dict release]; |
| 2245 } |
| 2246 |
| 2247 - (void)testOne { |
| 2248 GPBUInt32DoubleDictionary *dict = [GPBUInt32DoubleDictionary dictionaryWithVal
ue:600. forKey:1U]; |
| 2249 XCTAssertNotNil(dict); |
| 2250 XCTAssertEqual(dict.count, 1U); |
| 2251 double value; |
| 2252 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2253 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2254 XCTAssertEqual(value, 600.); |
| 2255 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2256 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, double aValue, BOOL *s
top) { |
| 2257 XCTAssertEqual(aKey, 1U); |
| 2258 XCTAssertEqual(aValue, 600.); |
| 2259 XCTAssertNotEqual(stop, NULL); |
| 2260 }]; |
| 2261 } |
| 2262 |
| 2263 - (void)testBasics { |
| 2264 const uint32_t kKeys[] = { 1U, 2U, 3U }; |
| 2265 const double kValues[] = { 600., 601., 602. }; |
| 2266 GPBUInt32DoubleDictionary *dict = |
| 2267 [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues |
| 2268 forKeys:kKeys |
| 2269 count:GPBARRAYSIZE(kValues)]; |
| 2270 XCTAssertNotNil(dict); |
| 2271 XCTAssertEqual(dict.count, 3U); |
| 2272 double value; |
| 2273 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2274 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2275 XCTAssertEqual(value, 600.); |
| 2276 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2277 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2278 XCTAssertEqual(value, 601.); |
| 2279 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2280 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2281 XCTAssertEqual(value, 602.); |
| 2282 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 2283 |
| 2284 __block NSUInteger idx = 0; |
| 2285 uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); |
| 2286 double *seenValues = malloc(3 * sizeof(double)); |
| 2287 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, double aValue, BOOL *s
top) { |
| 2288 XCTAssertLessThan(idx, 3U); |
| 2289 seenKeys[idx] = aKey; |
| 2290 seenValues[idx] = aValue; |
| 2291 XCTAssertNotEqual(stop, NULL); |
| 2292 ++idx; |
| 2293 }]; |
| 2294 for (int i = 0; i < 3; ++i) { |
| 2295 BOOL foundKey = NO; |
| 2296 for (int j = 0; (j < 3) && !foundKey; ++j) { |
| 2297 if (kKeys[i] == seenKeys[j]) { |
| 2298 foundKey = YES; |
| 2299 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j); |
| 2300 } |
| 2301 } |
| 2302 XCTAssertTrue(foundKey, @"i = %d", i); |
| 2303 } |
| 2304 free(seenKeys); |
| 2305 free(seenValues); |
| 2306 |
| 2307 // Stopping the enumeration. |
| 2308 idx = 0; |
| 2309 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, double aValue, BOOL *s
top) { |
| 2310 #pragma unused(aKey, aValue) |
| 2311 if (idx == 1) *stop = YES; |
| 2312 XCTAssertNotEqual(idx, 2U); |
| 2313 ++idx; |
| 2314 }]; |
| 2315 [dict release]; |
| 2316 } |
| 2317 |
| 2318 - (void)testEquality { |
| 2319 const uint32_t kKeys1[] = { 1U, 2U, 3U, 4U }; |
| 2320 const uint32_t kKeys2[] = { 2U, 1U, 4U }; |
| 2321 const double kValues1[] = { 600., 601., 602. }; |
| 2322 const double kValues2[] = { 600., 603., 602. }; |
| 2323 const double kValues3[] = { 600., 601., 602., 603. }; |
| 2324 GPBUInt32DoubleDictionary *dict1 = |
| 2325 [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues1 |
| 2326 forKeys:kKeys1 |
| 2327 count:GPBARRAYSIZE(kValues1)]; |
| 2328 XCTAssertNotNil(dict1); |
| 2329 GPBUInt32DoubleDictionary *dict1prime = |
| 2330 [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues1 |
| 2331 forKeys:kKeys1 |
| 2332 count:GPBARRAYSIZE(kValues1)]; |
| 2333 XCTAssertNotNil(dict1prime); |
| 2334 GPBUInt32DoubleDictionary *dict2 = |
| 2335 [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues2 |
| 2336 forKeys:kKeys1 |
| 2337 count:GPBARRAYSIZE(kValues2)]; |
| 2338 XCTAssertNotNil(dict2); |
| 2339 GPBUInt32DoubleDictionary *dict3 = |
| 2340 [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues1 |
| 2341 forKeys:kKeys2 |
| 2342 count:GPBARRAYSIZE(kValues1)]; |
| 2343 XCTAssertNotNil(dict3); |
| 2344 GPBUInt32DoubleDictionary *dict4 = |
| 2345 [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues3 |
| 2346 forKeys:kKeys1 |
| 2347 count:GPBARRAYSIZE(kValues3)]; |
| 2348 XCTAssertNotNil(dict4); |
| 2349 |
| 2350 // 1/1Prime should be different objects, but equal. |
| 2351 XCTAssertNotEqual(dict1, dict1prime); |
| 2352 XCTAssertEqualObjects(dict1, dict1prime); |
| 2353 // Equal, so they must have same hash. |
| 2354 XCTAssertEqual([dict1 hash], [dict1prime hash]); |
| 2355 |
| 2356 // 2 is same keys, different values; not equal. |
| 2357 XCTAssertNotEqualObjects(dict1, dict2); |
| 2358 |
| 2359 // 3 is different keys, same values; not equal. |
| 2360 XCTAssertNotEqualObjects(dict1, dict3); |
| 2361 |
| 2362 // 4 extra pair; not equal |
| 2363 XCTAssertNotEqualObjects(dict1, dict4); |
| 2364 |
| 2365 [dict1 release]; |
| 2366 [dict1prime release]; |
| 2367 [dict2 release]; |
| 2368 [dict3 release]; |
| 2369 [dict4 release]; |
| 2370 } |
| 2371 |
| 2372 - (void)testCopy { |
| 2373 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 2374 const double kValues[] = { 600., 601., 602., 603. }; |
| 2375 GPBUInt32DoubleDictionary *dict = |
| 2376 [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues |
| 2377 forKeys:kKeys |
| 2378 count:GPBARRAYSIZE(kValues)]; |
| 2379 XCTAssertNotNil(dict); |
| 2380 |
| 2381 GPBUInt32DoubleDictionary *dict2 = [dict copy]; |
| 2382 XCTAssertNotNil(dict2); |
| 2383 |
| 2384 // Should be new object but equal. |
| 2385 XCTAssertNotEqual(dict, dict2); |
| 2386 XCTAssertEqualObjects(dict, dict2); |
| 2387 XCTAssertTrue([dict2 isKindOfClass:[GPBUInt32DoubleDictionary class]]); |
| 2388 |
| 2389 [dict2 release]; |
| 2390 [dict release]; |
| 2391 } |
| 2392 |
| 2393 - (void)testDictionaryFromDictionary { |
| 2394 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 2395 const double kValues[] = { 600., 601., 602., 603. }; |
| 2396 GPBUInt32DoubleDictionary *dict = |
| 2397 [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues |
| 2398 forKeys:kKeys |
| 2399 count:GPBARRAYSIZE(kValues)]; |
| 2400 XCTAssertNotNil(dict); |
| 2401 |
| 2402 GPBUInt32DoubleDictionary *dict2 = |
| 2403 [GPBUInt32DoubleDictionary dictionaryWithDictionary:dict]; |
| 2404 XCTAssertNotNil(dict2); |
| 2405 |
| 2406 // Should be new pointer, but equal objects. |
| 2407 XCTAssertNotEqual(dict, dict2); |
| 2408 XCTAssertEqualObjects(dict, dict2); |
| 2409 [dict release]; |
| 2410 } |
| 2411 |
| 2412 - (void)testAdds { |
| 2413 GPBUInt32DoubleDictionary *dict = [GPBUInt32DoubleDictionary dictionary]; |
| 2414 XCTAssertNotNil(dict); |
| 2415 |
| 2416 XCTAssertEqual(dict.count, 0U); |
| 2417 [dict setValue:600. forKey:1U]; |
| 2418 XCTAssertEqual(dict.count, 1U); |
| 2419 |
| 2420 const uint32_t kKeys[] = { 2U, 3U, 4U }; |
| 2421 const double kValues[] = { 601., 602., 603. }; |
| 2422 GPBUInt32DoubleDictionary *dict2 = |
| 2423 [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues |
| 2424 forKeys:kKeys |
| 2425 count:GPBARRAYSIZE(kValues)]; |
| 2426 XCTAssertNotNil(dict2); |
| 2427 [dict addEntriesFromDictionary:dict2]; |
| 2428 XCTAssertEqual(dict.count, 4U); |
| 2429 |
| 2430 double value; |
| 2431 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2432 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2433 XCTAssertEqual(value, 600.); |
| 2434 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2435 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2436 XCTAssertEqual(value, 601.); |
| 2437 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2438 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2439 XCTAssertEqual(value, 602.); |
| 2440 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2441 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2442 XCTAssertEqual(value, 603.); |
| 2443 [dict2 release]; |
| 2444 } |
| 2445 |
| 2446 - (void)testRemove { |
| 2447 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 2448 const double kValues[] = { 600., 601., 602., 603. }; |
| 2449 GPBUInt32DoubleDictionary *dict = |
| 2450 [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues |
| 2451 forKeys:kKeys |
| 2452 count:GPBARRAYSIZE(kValues)]; |
| 2453 XCTAssertNotNil(dict); |
| 2454 XCTAssertEqual(dict.count, 4U); |
| 2455 |
| 2456 [dict removeValueForKey:2U]; |
| 2457 XCTAssertEqual(dict.count, 3U); |
| 2458 double value; |
| 2459 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2460 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2461 XCTAssertEqual(value, 600.); |
| 2462 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2463 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2464 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2465 XCTAssertEqual(value, 602.); |
| 2466 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2467 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2468 XCTAssertEqual(value, 603.); |
| 2469 |
| 2470 // Remove again does nothing. |
| 2471 [dict removeValueForKey:2U]; |
| 2472 XCTAssertEqual(dict.count, 3U); |
| 2473 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2474 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2475 XCTAssertEqual(value, 600.); |
| 2476 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2477 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2478 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2479 XCTAssertEqual(value, 602.); |
| 2480 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2481 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2482 XCTAssertEqual(value, 603.); |
| 2483 |
| 2484 [dict removeValueForKey:4U]; |
| 2485 XCTAssertEqual(dict.count, 2U); |
| 2486 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2487 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2488 XCTAssertEqual(value, 600.); |
| 2489 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2490 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2491 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2492 XCTAssertEqual(value, 602.); |
| 2493 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 2494 |
| 2495 [dict removeAll]; |
| 2496 XCTAssertEqual(dict.count, 0U); |
| 2497 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 2498 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2499 XCTAssertFalse([dict valueForKey:3U value:NULL]); |
| 2500 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 2501 [dict release]; |
| 2502 } |
| 2503 |
| 2504 - (void)testInplaceMutation { |
| 2505 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 2506 const double kValues[] = { 600., 601., 602., 603. }; |
| 2507 GPBUInt32DoubleDictionary *dict = |
| 2508 [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues |
| 2509 forKeys:kKeys |
| 2510 count:GPBARRAYSIZE(kValues)]; |
| 2511 XCTAssertNotNil(dict); |
| 2512 XCTAssertEqual(dict.count, 4U); |
| 2513 double value; |
| 2514 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2515 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2516 XCTAssertEqual(value, 600.); |
| 2517 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2518 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2519 XCTAssertEqual(value, 601.); |
| 2520 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2521 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2522 XCTAssertEqual(value, 602.); |
| 2523 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2524 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2525 XCTAssertEqual(value, 603.); |
| 2526 |
| 2527 [dict setValue:603. forKey:1U]; |
| 2528 XCTAssertEqual(dict.count, 4U); |
| 2529 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2530 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2531 XCTAssertEqual(value, 603.); |
| 2532 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2533 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2534 XCTAssertEqual(value, 601.); |
| 2535 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2536 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2537 XCTAssertEqual(value, 602.); |
| 2538 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2539 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2540 XCTAssertEqual(value, 603.); |
| 2541 |
| 2542 [dict setValue:601. forKey:4U]; |
| 2543 XCTAssertEqual(dict.count, 4U); |
| 2544 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2545 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2546 XCTAssertEqual(value, 603.); |
| 2547 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2548 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2549 XCTAssertEqual(value, 601.); |
| 2550 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2551 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2552 XCTAssertEqual(value, 602.); |
| 2553 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2554 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2555 XCTAssertEqual(value, 601.); |
| 2556 |
| 2557 const uint32_t kKeys2[] = { 2U, 3U }; |
| 2558 const double kValues2[] = { 602., 600. }; |
| 2559 GPBUInt32DoubleDictionary *dict2 = |
| 2560 [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues2 |
| 2561 forKeys:kKeys2 |
| 2562 count:GPBARRAYSIZE(kValues2)]; |
| 2563 XCTAssertNotNil(dict2); |
| 2564 [dict addEntriesFromDictionary:dict2]; |
| 2565 XCTAssertEqual(dict.count, 4U); |
| 2566 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2567 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2568 XCTAssertEqual(value, 603.); |
| 2569 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2570 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2571 XCTAssertEqual(value, 602.); |
| 2572 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2573 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2574 XCTAssertEqual(value, 600.); |
| 2575 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2576 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2577 XCTAssertEqual(value, 601.); |
| 2578 |
| 2579 [dict2 release]; |
| 2580 [dict release]; |
| 2581 } |
| 2582 |
| 2583 @end |
| 2584 |
| 2585 #pragma mark - UInt32 -> Enum |
| 2586 |
| 2587 @interface GPBUInt32EnumDictionaryTests : XCTestCase |
| 2588 @end |
| 2589 |
| 2590 @implementation GPBUInt32EnumDictionaryTests |
| 2591 |
| 2592 - (void)testEmpty { |
| 2593 GPBUInt32EnumDictionary *dict = [[GPBUInt32EnumDictionary alloc] init]; |
| 2594 XCTAssertNotNil(dict); |
| 2595 XCTAssertEqual(dict.count, 0U); |
| 2596 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 2597 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *
stop) { |
| 2598 #pragma unused(aKey, aValue, stop) |
| 2599 XCTFail(@"Shouldn't get here!"); |
| 2600 }]; |
| 2601 [dict release]; |
| 2602 } |
| 2603 |
| 2604 - (void)testOne { |
| 2605 GPBUInt32EnumDictionary *dict = [GPBUInt32EnumDictionary dictionaryWithValue:7
00 forKey:1U]; |
| 2606 XCTAssertNotNil(dict); |
| 2607 XCTAssertEqual(dict.count, 1U); |
| 2608 int32_t value; |
| 2609 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2610 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2611 XCTAssertEqual(value, 700); |
| 2612 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2613 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *
stop) { |
| 2614 XCTAssertEqual(aKey, 1U); |
| 2615 XCTAssertEqual(aValue, 700); |
| 2616 XCTAssertNotEqual(stop, NULL); |
| 2617 }]; |
| 2618 } |
| 2619 |
| 2620 - (void)testBasics { |
| 2621 const uint32_t kKeys[] = { 1U, 2U, 3U }; |
| 2622 const int32_t kValues[] = { 700, 701, 702 }; |
| 2623 GPBUInt32EnumDictionary *dict = |
| 2624 [[GPBUInt32EnumDictionary alloc] initWithValues:kValues |
| 2625 forKeys:kKeys |
| 2626 count:GPBARRAYSIZE(kValues)]; |
| 2627 XCTAssertNotNil(dict); |
| 2628 XCTAssertEqual(dict.count, 3U); |
| 2629 int32_t value; |
| 2630 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2631 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2632 XCTAssertEqual(value, 700); |
| 2633 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2634 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2635 XCTAssertEqual(value, 701); |
| 2636 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2637 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2638 XCTAssertEqual(value, 702); |
| 2639 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 2640 |
| 2641 __block NSUInteger idx = 0; |
| 2642 uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); |
| 2643 int32_t *seenValues = malloc(3 * sizeof(int32_t)); |
| 2644 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *
stop) { |
| 2645 XCTAssertLessThan(idx, 3U); |
| 2646 seenKeys[idx] = aKey; |
| 2647 seenValues[idx] = aValue; |
| 2648 XCTAssertNotEqual(stop, NULL); |
| 2649 ++idx; |
| 2650 }]; |
| 2651 for (int i = 0; i < 3; ++i) { |
| 2652 BOOL foundKey = NO; |
| 2653 for (int j = 0; (j < 3) && !foundKey; ++j) { |
| 2654 if (kKeys[i] == seenKeys[j]) { |
| 2655 foundKey = YES; |
| 2656 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j); |
| 2657 } |
| 2658 } |
| 2659 XCTAssertTrue(foundKey, @"i = %d", i); |
| 2660 } |
| 2661 free(seenKeys); |
| 2662 free(seenValues); |
| 2663 |
| 2664 // Stopping the enumeration. |
| 2665 idx = 0; |
| 2666 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *
stop) { |
| 2667 #pragma unused(aKey, aValue) |
| 2668 if (idx == 1) *stop = YES; |
| 2669 XCTAssertNotEqual(idx, 2U); |
| 2670 ++idx; |
| 2671 }]; |
| 2672 [dict release]; |
| 2673 } |
| 2674 |
| 2675 - (void)testEquality { |
| 2676 const uint32_t kKeys1[] = { 1U, 2U, 3U, 4U }; |
| 2677 const uint32_t kKeys2[] = { 2U, 1U, 4U }; |
| 2678 const int32_t kValues1[] = { 700, 701, 702 }; |
| 2679 const int32_t kValues2[] = { 700, 703, 702 }; |
| 2680 const int32_t kValues3[] = { 700, 701, 702, 703 }; |
| 2681 GPBUInt32EnumDictionary *dict1 = |
| 2682 [[GPBUInt32EnumDictionary alloc] initWithValues:kValues1 |
| 2683 forKeys:kKeys1 |
| 2684 count:GPBARRAYSIZE(kValues1)]; |
| 2685 XCTAssertNotNil(dict1); |
| 2686 GPBUInt32EnumDictionary *dict1prime = |
| 2687 [[GPBUInt32EnumDictionary alloc] initWithValues:kValues1 |
| 2688 forKeys:kKeys1 |
| 2689 count:GPBARRAYSIZE(kValues1)]; |
| 2690 XCTAssertNotNil(dict1prime); |
| 2691 GPBUInt32EnumDictionary *dict2 = |
| 2692 [[GPBUInt32EnumDictionary alloc] initWithValues:kValues2 |
| 2693 forKeys:kKeys1 |
| 2694 count:GPBARRAYSIZE(kValues2)]; |
| 2695 XCTAssertNotNil(dict2); |
| 2696 GPBUInt32EnumDictionary *dict3 = |
| 2697 [[GPBUInt32EnumDictionary alloc] initWithValues:kValues1 |
| 2698 forKeys:kKeys2 |
| 2699 count:GPBARRAYSIZE(kValues1)]; |
| 2700 XCTAssertNotNil(dict3); |
| 2701 GPBUInt32EnumDictionary *dict4 = |
| 2702 [[GPBUInt32EnumDictionary alloc] initWithValues:kValues3 |
| 2703 forKeys:kKeys1 |
| 2704 count:GPBARRAYSIZE(kValues3)]; |
| 2705 XCTAssertNotNil(dict4); |
| 2706 |
| 2707 // 1/1Prime should be different objects, but equal. |
| 2708 XCTAssertNotEqual(dict1, dict1prime); |
| 2709 XCTAssertEqualObjects(dict1, dict1prime); |
| 2710 // Equal, so they must have same hash. |
| 2711 XCTAssertEqual([dict1 hash], [dict1prime hash]); |
| 2712 |
| 2713 // 2 is same keys, different values; not equal. |
| 2714 XCTAssertNotEqualObjects(dict1, dict2); |
| 2715 |
| 2716 // 3 is different keys, same values; not equal. |
| 2717 XCTAssertNotEqualObjects(dict1, dict3); |
| 2718 |
| 2719 // 4 extra pair; not equal |
| 2720 XCTAssertNotEqualObjects(dict1, dict4); |
| 2721 |
| 2722 [dict1 release]; |
| 2723 [dict1prime release]; |
| 2724 [dict2 release]; |
| 2725 [dict3 release]; |
| 2726 [dict4 release]; |
| 2727 } |
| 2728 |
| 2729 - (void)testCopy { |
| 2730 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 2731 const int32_t kValues[] = { 700, 701, 702, 703 }; |
| 2732 GPBUInt32EnumDictionary *dict = |
| 2733 [[GPBUInt32EnumDictionary alloc] initWithValues:kValues |
| 2734 forKeys:kKeys |
| 2735 count:GPBARRAYSIZE(kValues)]; |
| 2736 XCTAssertNotNil(dict); |
| 2737 |
| 2738 GPBUInt32EnumDictionary *dict2 = [dict copy]; |
| 2739 XCTAssertNotNil(dict2); |
| 2740 |
| 2741 // Should be new object but equal. |
| 2742 XCTAssertNotEqual(dict, dict2); |
| 2743 XCTAssertEqualObjects(dict, dict2); |
| 2744 XCTAssertTrue([dict2 isKindOfClass:[GPBUInt32EnumDictionary class]]); |
| 2745 |
| 2746 [dict2 release]; |
| 2747 [dict release]; |
| 2748 } |
| 2749 |
| 2750 - (void)testDictionaryFromDictionary { |
| 2751 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 2752 const int32_t kValues[] = { 700, 701, 702, 703 }; |
| 2753 GPBUInt32EnumDictionary *dict = |
| 2754 [[GPBUInt32EnumDictionary alloc] initWithValues:kValues |
| 2755 forKeys:kKeys |
| 2756 count:GPBARRAYSIZE(kValues)]; |
| 2757 XCTAssertNotNil(dict); |
| 2758 |
| 2759 GPBUInt32EnumDictionary *dict2 = |
| 2760 [GPBUInt32EnumDictionary dictionaryWithDictionary:dict]; |
| 2761 XCTAssertNotNil(dict2); |
| 2762 |
| 2763 // Should be new pointer, but equal objects. |
| 2764 XCTAssertNotEqual(dict, dict2); |
| 2765 XCTAssertEqualObjects(dict, dict2); |
| 2766 [dict release]; |
| 2767 } |
| 2768 |
| 2769 - (void)testAdds { |
| 2770 GPBUInt32EnumDictionary *dict = [GPBUInt32EnumDictionary dictionary]; |
| 2771 XCTAssertNotNil(dict); |
| 2772 |
| 2773 XCTAssertEqual(dict.count, 0U); |
| 2774 [dict setValue:700 forKey:1U]; |
| 2775 XCTAssertEqual(dict.count, 1U); |
| 2776 |
| 2777 const uint32_t kKeys[] = { 2U, 3U, 4U }; |
| 2778 const int32_t kValues[] = { 701, 702, 703 }; |
| 2779 GPBUInt32EnumDictionary *dict2 = |
| 2780 [[GPBUInt32EnumDictionary alloc] initWithValues:kValues |
| 2781 forKeys:kKeys |
| 2782 count:GPBARRAYSIZE(kValues)]; |
| 2783 XCTAssertNotNil(dict2); |
| 2784 [dict addRawEntriesFromDictionary:dict2]; |
| 2785 XCTAssertEqual(dict.count, 4U); |
| 2786 |
| 2787 int32_t value; |
| 2788 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2789 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2790 XCTAssertEqual(value, 700); |
| 2791 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2792 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2793 XCTAssertEqual(value, 701); |
| 2794 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2795 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2796 XCTAssertEqual(value, 702); |
| 2797 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2798 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2799 XCTAssertEqual(value, 703); |
| 2800 [dict2 release]; |
| 2801 } |
| 2802 |
| 2803 - (void)testRemove { |
| 2804 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 2805 const int32_t kValues[] = { 700, 701, 702, 703 }; |
| 2806 GPBUInt32EnumDictionary *dict = |
| 2807 [[GPBUInt32EnumDictionary alloc] initWithValues:kValues |
| 2808 forKeys:kKeys |
| 2809 count:GPBARRAYSIZE(kValues)]; |
| 2810 XCTAssertNotNil(dict); |
| 2811 XCTAssertEqual(dict.count, 4U); |
| 2812 |
| 2813 [dict removeValueForKey:2U]; |
| 2814 XCTAssertEqual(dict.count, 3U); |
| 2815 int32_t value; |
| 2816 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2817 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2818 XCTAssertEqual(value, 700); |
| 2819 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2820 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2821 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2822 XCTAssertEqual(value, 702); |
| 2823 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2824 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2825 XCTAssertEqual(value, 703); |
| 2826 |
| 2827 // Remove again does nothing. |
| 2828 [dict removeValueForKey:2U]; |
| 2829 XCTAssertEqual(dict.count, 3U); |
| 2830 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2831 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2832 XCTAssertEqual(value, 700); |
| 2833 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2834 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2835 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2836 XCTAssertEqual(value, 702); |
| 2837 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2838 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2839 XCTAssertEqual(value, 703); |
| 2840 |
| 2841 [dict removeValueForKey:4U]; |
| 2842 XCTAssertEqual(dict.count, 2U); |
| 2843 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2844 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2845 XCTAssertEqual(value, 700); |
| 2846 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2847 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2848 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2849 XCTAssertEqual(value, 702); |
| 2850 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 2851 |
| 2852 [dict removeAll]; |
| 2853 XCTAssertEqual(dict.count, 0U); |
| 2854 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 2855 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 2856 XCTAssertFalse([dict valueForKey:3U value:NULL]); |
| 2857 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 2858 [dict release]; |
| 2859 } |
| 2860 |
| 2861 - (void)testInplaceMutation { |
| 2862 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 2863 const int32_t kValues[] = { 700, 701, 702, 703 }; |
| 2864 GPBUInt32EnumDictionary *dict = |
| 2865 [[GPBUInt32EnumDictionary alloc] initWithValues:kValues |
| 2866 forKeys:kKeys |
| 2867 count:GPBARRAYSIZE(kValues)]; |
| 2868 XCTAssertNotNil(dict); |
| 2869 XCTAssertEqual(dict.count, 4U); |
| 2870 int32_t value; |
| 2871 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2872 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2873 XCTAssertEqual(value, 700); |
| 2874 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2875 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2876 XCTAssertEqual(value, 701); |
| 2877 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2878 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2879 XCTAssertEqual(value, 702); |
| 2880 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2881 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2882 XCTAssertEqual(value, 703); |
| 2883 |
| 2884 [dict setValue:703 forKey:1U]; |
| 2885 XCTAssertEqual(dict.count, 4U); |
| 2886 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2887 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2888 XCTAssertEqual(value, 703); |
| 2889 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2890 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2891 XCTAssertEqual(value, 701); |
| 2892 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2893 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2894 XCTAssertEqual(value, 702); |
| 2895 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2896 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2897 XCTAssertEqual(value, 703); |
| 2898 |
| 2899 [dict setValue:701 forKey:4U]; |
| 2900 XCTAssertEqual(dict.count, 4U); |
| 2901 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2902 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2903 XCTAssertEqual(value, 703); |
| 2904 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2905 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2906 XCTAssertEqual(value, 701); |
| 2907 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2908 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2909 XCTAssertEqual(value, 702); |
| 2910 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2911 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2912 XCTAssertEqual(value, 701); |
| 2913 |
| 2914 const uint32_t kKeys2[] = { 2U, 3U }; |
| 2915 const int32_t kValues2[] = { 702, 700 }; |
| 2916 GPBUInt32EnumDictionary *dict2 = |
| 2917 [[GPBUInt32EnumDictionary alloc] initWithValues:kValues2 |
| 2918 forKeys:kKeys2 |
| 2919 count:GPBARRAYSIZE(kValues2)]; |
| 2920 XCTAssertNotNil(dict2); |
| 2921 [dict addRawEntriesFromDictionary:dict2]; |
| 2922 XCTAssertEqual(dict.count, 4U); |
| 2923 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 2924 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 2925 XCTAssertEqual(value, 703); |
| 2926 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2927 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2928 XCTAssertEqual(value, 702); |
| 2929 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 2930 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 2931 XCTAssertEqual(value, 700); |
| 2932 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 2933 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 2934 XCTAssertEqual(value, 701); |
| 2935 |
| 2936 [dict2 release]; |
| 2937 [dict release]; |
| 2938 } |
| 2939 |
| 2940 @end |
| 2941 |
| 2942 #pragma mark - UInt32 -> Enum (Unknown Enums) |
| 2943 |
| 2944 @interface GPBUInt32EnumDictionaryUnknownEnumTests : XCTestCase |
| 2945 @end |
| 2946 |
| 2947 @implementation GPBUInt32EnumDictionaryUnknownEnumTests |
| 2948 |
| 2949 - (void)testRawBasics { |
| 2950 const uint32_t kKeys[] = { 1U, 2U, 3U }; |
| 2951 const int32_t kValues[] = { 700, 801, 702 }; |
| 2952 GPBUInt32EnumDictionary *dict = |
| 2953 [[GPBUInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is
ValidValue |
| 2954 rawValues:kValues |
| 2955 forKeys:kKeys |
| 2956 count:GPBARRAYSIZE(k
Values)]; |
| 2957 XCTAssertNotNil(dict); |
| 2958 XCTAssertEqual(dict.count, 3U); |
| 2959 XCTAssertTrue(dict.validationFunc == TestingEnum_IsValidValue); // Pointer co
mparison |
| 2960 int32_t value; |
| 2961 XCTAssertTrue([dict valueForKey:1U rawValue:NULL]); |
| 2962 XCTAssertTrue([dict valueForKey:1U rawValue:&value]); |
| 2963 XCTAssertEqual(value, 700); |
| 2964 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 2965 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 2966 XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); |
| 2967 XCTAssertTrue([dict valueForKey:2U rawValue:NULL]); |
| 2968 XCTAssertTrue([dict valueForKey:2U rawValue:&value]); |
| 2969 XCTAssertEqual(value, 801); |
| 2970 XCTAssertTrue([dict valueForKey:3U rawValue:NULL]); |
| 2971 XCTAssertTrue([dict valueForKey:3U rawValue:&value]); |
| 2972 XCTAssertEqual(value, 702); |
| 2973 XCTAssertFalse([dict valueForKey:4U rawValue:NULL]); |
| 2974 |
| 2975 __block NSUInteger idx = 0; |
| 2976 uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); |
| 2977 int32_t *seenValues = malloc(3 * sizeof(int32_t)); |
| 2978 [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *
stop) { |
| 2979 XCTAssertLessThan(idx, 3U); |
| 2980 seenKeys[idx] = aKey; |
| 2981 seenValues[idx] = aValue; |
| 2982 XCTAssertNotEqual(stop, NULL); |
| 2983 ++idx; |
| 2984 }]; |
| 2985 for (int i = 0; i < 3; ++i) { |
| 2986 BOOL foundKey = NO; |
| 2987 for (int j = 0; (j < 3) && !foundKey; ++j) { |
| 2988 if (kKeys[i] == seenKeys[j]) { |
| 2989 foundKey = YES; |
| 2990 if (i == 1) { |
| 2991 XCTAssertEqual(kGPBUnrecognizedEnumeratorValue, seenValues[j], @"i = %
d, j = %d", i, j); |
| 2992 } else { |
| 2993 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j); |
| 2994 } |
| 2995 } |
| 2996 } |
| 2997 XCTAssertTrue(foundKey, @"i = %d", i); |
| 2998 } |
| 2999 idx = 0; |
| 3000 [dict enumerateKeysAndRawValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOO
L *stop) { |
| 3001 XCTAssertLessThan(idx, 3U); |
| 3002 seenKeys[idx] = aKey; |
| 3003 seenValues[idx] = aValue; |
| 3004 XCTAssertNotEqual(stop, NULL); |
| 3005 ++idx; |
| 3006 }]; |
| 3007 for (int i = 0; i < 3; ++i) { |
| 3008 BOOL foundKey = NO; |
| 3009 for (int j = 0; (j < 3) && !foundKey; ++j) { |
| 3010 if (kKeys[i] == seenKeys[j]) { |
| 3011 foundKey = YES; |
| 3012 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j); |
| 3013 } |
| 3014 } |
| 3015 XCTAssertTrue(foundKey, @"i = %d", i); |
| 3016 } |
| 3017 free(seenKeys); |
| 3018 free(seenValues); |
| 3019 |
| 3020 // Stopping the enumeration. |
| 3021 idx = 0; |
| 3022 [dict enumerateKeysAndRawValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOO
L *stop) { |
| 3023 #pragma unused(aKey, aValue) |
| 3024 if (idx == 1) *stop = YES; |
| 3025 XCTAssertNotEqual(idx, 2U); |
| 3026 ++idx; |
| 3027 }]; |
| 3028 [dict release]; |
| 3029 } |
| 3030 |
| 3031 - (void)testEqualityWithUnknowns { |
| 3032 const uint32_t kKeys1[] = { 1U, 2U, 3U, 4U }; |
| 3033 const uint32_t kKeys2[] = { 2U, 1U, 4U }; |
| 3034 const int32_t kValues1[] = { 700, 801, 702 }; // Unknown |
| 3035 const int32_t kValues2[] = { 700, 803, 702 }; // Unknown |
| 3036 const int32_t kValues3[] = { 700, 801, 702, 803 }; // Unknowns |
| 3037 GPBUInt32EnumDictionary *dict1 = |
| 3038 [[GPBUInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is
ValidValue |
| 3039 rawValues:kValues1 |
| 3040 forKeys:kKeys1 |
| 3041 count:GPBARRAYSIZE(k
Values1)]; |
| 3042 XCTAssertNotNil(dict1); |
| 3043 GPBUInt32EnumDictionary *dict1prime = |
| 3044 [[GPBUInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is
ValidValue |
| 3045 rawValues:kValues1 |
| 3046 forKeys:kKeys1 |
| 3047 count:GPBARRAYSIZE(k
Values1)]; |
| 3048 XCTAssertNotNil(dict1prime); |
| 3049 GPBUInt32EnumDictionary *dict2 = |
| 3050 [[GPBUInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is
ValidValue |
| 3051 rawValues:kValues2 |
| 3052 forKeys:kKeys1 |
| 3053 count:GPBARRAYSIZE(k
Values2)]; |
| 3054 XCTAssertNotNil(dict2); |
| 3055 GPBUInt32EnumDictionary *dict3 = |
| 3056 [[GPBUInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is
ValidValue |
| 3057 rawValues:kValues1 |
| 3058 forKeys:kKeys2 |
| 3059 count:GPBARRAYSIZE(k
Values1)]; |
| 3060 XCTAssertNotNil(dict3); |
| 3061 GPBUInt32EnumDictionary *dict4 = |
| 3062 [[GPBUInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is
ValidValue |
| 3063 rawValues:kValues3 |
| 3064 forKeys:kKeys1 |
| 3065 count:GPBARRAYSIZE(k
Values3)]; |
| 3066 XCTAssertNotNil(dict4); |
| 3067 |
| 3068 // 1/1Prime should be different objects, but equal. |
| 3069 XCTAssertNotEqual(dict1, dict1prime); |
| 3070 XCTAssertEqualObjects(dict1, dict1prime); |
| 3071 // Equal, so they must have same hash. |
| 3072 XCTAssertEqual([dict1 hash], [dict1prime hash]); |
| 3073 |
| 3074 // 2 is same keys, different values; not equal. |
| 3075 XCTAssertNotEqualObjects(dict1, dict2); |
| 3076 |
| 3077 // 3 is different keys, same values; not equal. |
| 3078 XCTAssertNotEqualObjects(dict1, dict3); |
| 3079 |
| 3080 // 4 extra pair; not equal |
| 3081 XCTAssertNotEqualObjects(dict1, dict4); |
| 3082 |
| 3083 [dict1 release]; |
| 3084 [dict1prime release]; |
| 3085 [dict2 release]; |
| 3086 [dict3 release]; |
| 3087 [dict4 release]; |
| 3088 } |
| 3089 |
| 3090 - (void)testCopyWithUnknowns { |
| 3091 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 3092 const int32_t kValues[] = { 700, 801, 702, 803 }; // Unknown |
| 3093 GPBUInt32EnumDictionary *dict = |
| 3094 [[GPBUInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is
ValidValue |
| 3095 rawValues:kValues |
| 3096 forKeys:kKeys |
| 3097 count:GPBARRAYSIZE(k
Values)]; |
| 3098 XCTAssertNotNil(dict); |
| 3099 |
| 3100 GPBUInt32EnumDictionary *dict2 = [dict copy]; |
| 3101 XCTAssertNotNil(dict2); |
| 3102 |
| 3103 // Should be new pointer, but equal objects. |
| 3104 XCTAssertNotEqual(dict, dict2); |
| 3105 XCTAssertEqual(dict.validationFunc, dict2.validationFunc); // Pointer compari
son |
| 3106 XCTAssertEqualObjects(dict, dict2); |
| 3107 |
| 3108 [dict2 release]; |
| 3109 [dict release]; |
| 3110 } |
| 3111 |
| 3112 - (void)testDictionaryFromDictionary { |
| 3113 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 3114 const int32_t kValues[] = { 700, 801, 702, 803 }; // Unknowns |
| 3115 GPBUInt32EnumDictionary *dict = |
| 3116 [[GPBUInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is
ValidValue |
| 3117 rawValues:kValues |
| 3118 forKeys:kKeys |
| 3119 count:GPBARRAYSIZE(k
Values)]; |
| 3120 XCTAssertNotNil(dict); |
| 3121 |
| 3122 GPBUInt32EnumDictionary *dict2 = |
| 3123 [GPBUInt32EnumDictionary dictionaryWithDictionary:dict]; |
| 3124 XCTAssertNotNil(dict2); |
| 3125 |
| 3126 // Should be new pointer, but equal objects. |
| 3127 XCTAssertNotEqual(dict, dict2); |
| 3128 XCTAssertEqualObjects(dict, dict2); |
| 3129 XCTAssertEqual(dict.validationFunc, dict2.validationFunc); // Pointer compari
son |
| 3130 [dict release]; |
| 3131 } |
| 3132 |
| 3133 - (void)testUnknownAdds { |
| 3134 GPBUInt32EnumDictionary *dict = |
| 3135 [GPBUInt32EnumDictionary dictionaryWithValidationFunction:TestingEnum_IsVali
dValue]; |
| 3136 XCTAssertNotNil(dict); |
| 3137 |
| 3138 XCTAssertEqual(dict.count, 0U); |
| 3139 XCTAssertThrowsSpecificNamed([dict setValue:801 forKey:2U], // Unknown |
| 3140 NSException, NSInvalidArgumentException); |
| 3141 XCTAssertEqual(dict.count, 0U); |
| 3142 [dict setRawValue:801 forKey:2U]; // Unknown |
| 3143 XCTAssertEqual(dict.count, 1U); |
| 3144 |
| 3145 const uint32_t kKeys[] = { 1U, 3U, 4U }; |
| 3146 const int32_t kValues[] = { 700, 702, 803 }; // Unknown |
| 3147 GPBUInt32EnumDictionary *dict2 = |
| 3148 [[GPBUInt32EnumDictionary alloc] initWithValues:kValues |
| 3149 forKeys:kKeys |
| 3150 count:GPBARRAYSIZE(kValues)]; |
| 3151 XCTAssertNotNil(dict2); |
| 3152 [dict addRawEntriesFromDictionary:dict2]; |
| 3153 XCTAssertEqual(dict.count, 4U); |
| 3154 |
| 3155 int32_t value; |
| 3156 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 3157 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 3158 XCTAssertEqual(value, 700); |
| 3159 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 3160 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 3161 XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); |
| 3162 XCTAssertTrue([dict valueForKey:2U rawValue:NULL]); |
| 3163 XCTAssertTrue([dict valueForKey:2U rawValue:&value]); |
| 3164 XCTAssertEqual(value, 801); |
| 3165 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 3166 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 3167 XCTAssertEqual(value, 702); |
| 3168 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 3169 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 3170 XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); |
| 3171 XCTAssertTrue([dict valueForKey:4U rawValue:NULL]); |
| 3172 XCTAssertTrue([dict valueForKey:4U rawValue:&value]); |
| 3173 XCTAssertEqual(value, 803); |
| 3174 [dict2 release]; |
| 3175 } |
| 3176 |
| 3177 - (void)testUnknownRemove { |
| 3178 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 3179 const int32_t kValues[] = { 700, 801, 702, 803 }; // Unknowns |
| 3180 GPBUInt32EnumDictionary *dict = |
| 3181 [[GPBUInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is
ValidValue |
| 3182 rawValues:kValues |
| 3183 forKeys:kKeys |
| 3184 count:GPBARRAYSIZE(k
Values)]; |
| 3185 XCTAssertNotNil(dict); |
| 3186 XCTAssertEqual(dict.count, 4U); |
| 3187 |
| 3188 [dict removeValueForKey:2U]; |
| 3189 XCTAssertEqual(dict.count, 3U); |
| 3190 int32_t value; |
| 3191 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 3192 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 3193 XCTAssertEqual(value, 700); |
| 3194 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 3195 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 3196 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 3197 XCTAssertEqual(value, 702); |
| 3198 XCTAssertTrue([dict valueForKey:4U rawValue:NULL]); |
| 3199 XCTAssertTrue([dict valueForKey:4U rawValue:&value]); |
| 3200 XCTAssertEqual(value, 803); |
| 3201 |
| 3202 // Remove again does nothing. |
| 3203 [dict removeValueForKey:2U]; |
| 3204 XCTAssertEqual(dict.count, 3U); |
| 3205 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 3206 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 3207 XCTAssertEqual(value, 700); |
| 3208 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 3209 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 3210 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 3211 XCTAssertEqual(value, 702); |
| 3212 XCTAssertTrue([dict valueForKey:4U rawValue:NULL]); |
| 3213 XCTAssertTrue([dict valueForKey:4U rawValue:&value]); |
| 3214 XCTAssertEqual(value, 803); |
| 3215 |
| 3216 [dict removeValueForKey:4U]; |
| 3217 XCTAssertEqual(dict.count, 2U); |
| 3218 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 3219 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 3220 XCTAssertEqual(value, 700); |
| 3221 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 3222 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 3223 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 3224 XCTAssertEqual(value, 702); |
| 3225 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 3226 |
| 3227 [dict removeAll]; |
| 3228 XCTAssertEqual(dict.count, 0U); |
| 3229 XCTAssertFalse([dict valueForKey:1U value:NULL]); |
| 3230 XCTAssertFalse([dict valueForKey:2U value:NULL]); |
| 3231 XCTAssertFalse([dict valueForKey:3U value:NULL]); |
| 3232 XCTAssertFalse([dict valueForKey:4U value:NULL]); |
| 3233 [dict release]; |
| 3234 } |
| 3235 |
| 3236 - (void)testInplaceMutationUnknowns { |
| 3237 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 3238 const int32_t kValues[] = { 700, 801, 702, 803 }; // Unknowns |
| 3239 GPBUInt32EnumDictionary *dict = |
| 3240 [[GPBUInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is
ValidValue |
| 3241 rawValues:kValues |
| 3242 forKeys:kKeys |
| 3243 count:GPBARRAYSIZE(k
Values)]; |
| 3244 XCTAssertNotNil(dict); |
| 3245 XCTAssertEqual(dict.count, 4U); |
| 3246 int32_t value; |
| 3247 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 3248 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 3249 XCTAssertEqual(value, 700); |
| 3250 XCTAssertTrue([dict valueForKey:2U rawValue:NULL]); |
| 3251 XCTAssertTrue([dict valueForKey:2U rawValue:&value]); |
| 3252 XCTAssertEqual(value, 801); |
| 3253 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 3254 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 3255 XCTAssertEqual(value, 702); |
| 3256 XCTAssertTrue([dict valueForKey:4U rawValue:NULL]); |
| 3257 XCTAssertTrue([dict valueForKey:4U rawValue:&value]); |
| 3258 XCTAssertEqual(value, 803); |
| 3259 |
| 3260 XCTAssertThrowsSpecificNamed([dict setValue:803 forKey:1U], // Unknown |
| 3261 NSException, NSInvalidArgumentException); |
| 3262 XCTAssertEqual(dict.count, 4U); |
| 3263 XCTAssertTrue([dict valueForKey:1U value:NULL]); |
| 3264 XCTAssertTrue([dict valueForKey:1U value:&value]); |
| 3265 XCTAssertEqual(value, 700); |
| 3266 XCTAssertTrue([dict valueForKey:2U rawValue:NULL]); |
| 3267 XCTAssertTrue([dict valueForKey:2U rawValue:&value]); |
| 3268 XCTAssertEqual(value, 801); |
| 3269 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 3270 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 3271 XCTAssertEqual(value, 702); |
| 3272 XCTAssertTrue([dict valueForKey:4U rawValue:NULL]); |
| 3273 XCTAssertTrue([dict valueForKey:4U rawValue:&value]); |
| 3274 XCTAssertEqual(value, 803); |
| 3275 |
| 3276 [dict setRawValue:803 forKey:1U]; // Unknown |
| 3277 XCTAssertEqual(dict.count, 4U); |
| 3278 XCTAssertTrue([dict valueForKey:1U rawValue:NULL]); |
| 3279 XCTAssertTrue([dict valueForKey:1U rawValue:&value]); |
| 3280 XCTAssertEqual(value, 803); |
| 3281 XCTAssertTrue([dict valueForKey:2U rawValue:NULL]); |
| 3282 XCTAssertTrue([dict valueForKey:2U rawValue:&value]); |
| 3283 XCTAssertEqual(value, 801); |
| 3284 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 3285 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 3286 XCTAssertEqual(value, 702); |
| 3287 XCTAssertTrue([dict valueForKey:4U rawValue:NULL]); |
| 3288 XCTAssertTrue([dict valueForKey:4U rawValue:&value]); |
| 3289 XCTAssertEqual(value, 803); |
| 3290 |
| 3291 [dict setRawValue:700 forKey:4U]; |
| 3292 XCTAssertEqual(dict.count, 4U); |
| 3293 XCTAssertTrue([dict valueForKey:1U rawValue:NULL]); |
| 3294 XCTAssertTrue([dict valueForKey:1U rawValue:&value]); |
| 3295 XCTAssertEqual(value, 803); |
| 3296 XCTAssertTrue([dict valueForKey:2U rawValue:NULL]); |
| 3297 XCTAssertTrue([dict valueForKey:2U rawValue:&value]); |
| 3298 XCTAssertEqual(value, 801); |
| 3299 XCTAssertTrue([dict valueForKey:3U value:NULL]); |
| 3300 XCTAssertTrue([dict valueForKey:3U value:&value]); |
| 3301 XCTAssertEqual(value, 702); |
| 3302 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 3303 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 3304 XCTAssertEqual(value, 700); |
| 3305 |
| 3306 const uint32_t kKeys2[] = { 2U, 3U }; |
| 3307 const int32_t kValues2[] = { 702, 801 }; // Unknown |
| 3308 GPBUInt32EnumDictionary *dict2 = |
| 3309 [[GPBUInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is
ValidValue |
| 3310 rawValues:kValues2 |
| 3311 forKeys:kKeys2 |
| 3312 count:GPBARRAYSIZE(k
Values2)]; |
| 3313 XCTAssertNotNil(dict2); |
| 3314 [dict addRawEntriesFromDictionary:dict2]; |
| 3315 XCTAssertEqual(dict.count, 4U); |
| 3316 XCTAssertTrue([dict valueForKey:1U rawValue:NULL]); |
| 3317 XCTAssertTrue([dict valueForKey:1U rawValue:&value]); |
| 3318 XCTAssertEqual(value, 803); |
| 3319 XCTAssertTrue([dict valueForKey:2U value:NULL]); |
| 3320 XCTAssertTrue([dict valueForKey:2U value:&value]); |
| 3321 XCTAssertEqual(value, 702); |
| 3322 XCTAssertTrue([dict valueForKey:3U rawValue:NULL]); |
| 3323 XCTAssertTrue([dict valueForKey:3U rawValue:&value]); |
| 3324 XCTAssertEqual(value, 801); |
| 3325 XCTAssertTrue([dict valueForKey:4U value:NULL]); |
| 3326 XCTAssertTrue([dict valueForKey:4U value:&value]); |
| 3327 XCTAssertEqual(value, 700); |
| 3328 |
| 3329 [dict2 release]; |
| 3330 [dict release]; |
| 3331 } |
| 3332 |
| 3333 - (void)testCopyUnknowns { |
| 3334 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 3335 const int32_t kValues[] = { 700, 801, 702, 803 }; |
| 3336 GPBUInt32EnumDictionary *dict = |
| 3337 [[GPBUInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is
ValidValue |
| 3338 rawValues:kValues |
| 3339 forKeys:kKeys |
| 3340 count:GPBARRAYSIZE(k
Values)]; |
| 3341 XCTAssertNotNil(dict); |
| 3342 |
| 3343 GPBUInt32EnumDictionary *dict2 = [dict copy]; |
| 3344 XCTAssertNotNil(dict2); |
| 3345 |
| 3346 // Should be new pointer, but equal objects. |
| 3347 XCTAssertNotEqual(dict, dict2); |
| 3348 XCTAssertEqualObjects(dict, dict2); |
| 3349 XCTAssertEqual(dict.validationFunc, dict2.validationFunc); // Pointer compari
son |
| 3350 XCTAssertTrue([dict2 isKindOfClass:[GPBUInt32EnumDictionary class]]); |
| 3351 |
| 3352 [dict2 release]; |
| 3353 [dict release]; |
| 3354 } |
| 3355 |
| 3356 @end |
| 3357 |
| 3358 #pragma mark - UInt32 -> Object |
| 3359 |
| 3360 @interface GPBUInt32ObjectDictionaryTests : XCTestCase |
| 3361 @end |
| 3362 |
| 3363 @implementation GPBUInt32ObjectDictionaryTests |
| 3364 |
| 3365 - (void)testEmpty { |
| 3366 GPBUInt32ObjectDictionary *dict = [[GPBUInt32ObjectDictionary alloc] init]; |
| 3367 XCTAssertNotNil(dict); |
| 3368 XCTAssertEqual(dict.count, 0U); |
| 3369 XCTAssertNil([dict objectForKey:1U]); |
| 3370 [dict enumerateKeysAndObjectsUsingBlock:^(uint32_t aKey, id aObject, BOOL *sto
p) { |
| 3371 #pragma unused(aKey, aObject, stop) |
| 3372 XCTFail(@"Shouldn't get here!"); |
| 3373 }]; |
| 3374 [dict release]; |
| 3375 } |
| 3376 |
| 3377 - (void)testOne { |
| 3378 GPBUInt32ObjectDictionary *dict = [GPBUInt32ObjectDictionary dictionaryWithObj
ect:@"abc" forKey:1U]; |
| 3379 XCTAssertNotNil(dict); |
| 3380 XCTAssertEqual(dict.count, 1U); |
| 3381 XCTAssertEqualObjects([dict objectForKey:1U], @"abc"); |
| 3382 XCTAssertNil([dict objectForKey:2U]); |
| 3383 [dict enumerateKeysAndObjectsUsingBlock:^(uint32_t aKey, id aObject, BOOL *sto
p) { |
| 3384 XCTAssertEqual(aKey, 1U); |
| 3385 XCTAssertEqualObjects(aObject, @"abc"); |
| 3386 XCTAssertNotEqual(stop, NULL); |
| 3387 }]; |
| 3388 } |
| 3389 |
| 3390 - (void)testBasics { |
| 3391 const uint32_t kKeys[] = { 1U, 2U, 3U }; |
| 3392 const id kObjects[] = { @"abc", @"def", @"ghi" }; |
| 3393 GPBUInt32ObjectDictionary *dict = |
| 3394 [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects |
| 3395 forKeys:kKeys |
| 3396 count:GPBARRAYSIZE(kObjects)]
; |
| 3397 XCTAssertNotNil(dict); |
| 3398 XCTAssertEqual(dict.count, 3U); |
| 3399 XCTAssertEqualObjects([dict objectForKey:1U], @"abc"); |
| 3400 XCTAssertEqualObjects([dict objectForKey:2U], @"def"); |
| 3401 XCTAssertEqualObjects([dict objectForKey:3U], @"ghi"); |
| 3402 XCTAssertNil([dict objectForKey:4U]); |
| 3403 |
| 3404 __block NSUInteger idx = 0; |
| 3405 uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); |
| 3406 id *seenObjects = malloc(3 * sizeof(id)); |
| 3407 [dict enumerateKeysAndObjectsUsingBlock:^(uint32_t aKey, id aObject, BOOL *sto
p) { |
| 3408 XCTAssertLessThan(idx, 3U); |
| 3409 seenKeys[idx] = aKey; |
| 3410 seenObjects[idx] = aObject; |
| 3411 XCTAssertNotEqual(stop, NULL); |
| 3412 ++idx; |
| 3413 }]; |
| 3414 for (int i = 0; i < 3; ++i) { |
| 3415 BOOL foundKey = NO; |
| 3416 for (int j = 0; (j < 3) && !foundKey; ++j) { |
| 3417 if (kKeys[i] == seenKeys[j]) { |
| 3418 foundKey = YES; |
| 3419 XCTAssertEqualObjects(kObjects[i], seenObjects[j], @"i = %d, j = %d", i,
j); |
| 3420 } |
| 3421 } |
| 3422 XCTAssertTrue(foundKey, @"i = %d", i); |
| 3423 } |
| 3424 free(seenKeys); |
| 3425 free(seenObjects); |
| 3426 |
| 3427 // Stopping the enumeration. |
| 3428 idx = 0; |
| 3429 [dict enumerateKeysAndObjectsUsingBlock:^(uint32_t aKey, id aObject, BOOL *sto
p) { |
| 3430 #pragma unused(aKey, aObject) |
| 3431 if (idx == 1) *stop = YES; |
| 3432 XCTAssertNotEqual(idx, 2U); |
| 3433 ++idx; |
| 3434 }]; |
| 3435 [dict release]; |
| 3436 } |
| 3437 |
| 3438 - (void)testEquality { |
| 3439 const uint32_t kKeys1[] = { 1U, 2U, 3U, 4U }; |
| 3440 const uint32_t kKeys2[] = { 2U, 1U, 4U }; |
| 3441 const id kObjects1[] = { @"abc", @"def", @"ghi" }; |
| 3442 const id kObjects2[] = { @"abc", @"jkl", @"ghi" }; |
| 3443 const id kObjects3[] = { @"abc", @"def", @"ghi", @"jkl" }; |
| 3444 GPBUInt32ObjectDictionary *dict1 = |
| 3445 [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects1 |
| 3446 forKeys:kKeys1 |
| 3447 count:GPBARRAYSIZE(kObjects1)
]; |
| 3448 XCTAssertNotNil(dict1); |
| 3449 GPBUInt32ObjectDictionary *dict1prime = |
| 3450 [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects1 |
| 3451 forKeys:kKeys1 |
| 3452 count:GPBARRAYSIZE(kObjects1)
]; |
| 3453 XCTAssertNotNil(dict1prime); |
| 3454 GPBUInt32ObjectDictionary *dict2 = |
| 3455 [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects2 |
| 3456 forKeys:kKeys1 |
| 3457 count:GPBARRAYSIZE(kObjects2)
]; |
| 3458 XCTAssertNotNil(dict2); |
| 3459 GPBUInt32ObjectDictionary *dict3 = |
| 3460 [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects1 |
| 3461 forKeys:kKeys2 |
| 3462 count:GPBARRAYSIZE(kObjects1)
]; |
| 3463 XCTAssertNotNil(dict3); |
| 3464 GPBUInt32ObjectDictionary *dict4 = |
| 3465 [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects3 |
| 3466 forKeys:kKeys1 |
| 3467 count:GPBARRAYSIZE(kObjects3)
]; |
| 3468 XCTAssertNotNil(dict4); |
| 3469 |
| 3470 // 1/1Prime should be different objects, but equal. |
| 3471 XCTAssertNotEqual(dict1, dict1prime); |
| 3472 XCTAssertEqualObjects(dict1, dict1prime); |
| 3473 // Equal, so they must have same hash. |
| 3474 XCTAssertEqual([dict1 hash], [dict1prime hash]); |
| 3475 |
| 3476 // 2 is same keys, different objects; not equal. |
| 3477 XCTAssertNotEqualObjects(dict1, dict2); |
| 3478 |
| 3479 // 3 is different keys, same objects; not equal. |
| 3480 XCTAssertNotEqualObjects(dict1, dict3); |
| 3481 |
| 3482 // 4 extra pair; not equal |
| 3483 XCTAssertNotEqualObjects(dict1, dict4); |
| 3484 |
| 3485 [dict1 release]; |
| 3486 [dict1prime release]; |
| 3487 [dict2 release]; |
| 3488 [dict3 release]; |
| 3489 [dict4 release]; |
| 3490 } |
| 3491 |
| 3492 - (void)testCopy { |
| 3493 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 3494 const id kObjects[] = { @"abc", @"def", @"ghi", @"jkl" }; |
| 3495 GPBUInt32ObjectDictionary *dict = |
| 3496 [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects |
| 3497 forKeys:kKeys |
| 3498 count:GPBARRAYSIZE(kObjects)]
; |
| 3499 XCTAssertNotNil(dict); |
| 3500 |
| 3501 GPBUInt32ObjectDictionary *dict2 = [dict copy]; |
| 3502 XCTAssertNotNil(dict2); |
| 3503 |
| 3504 // Should be new object but equal. |
| 3505 XCTAssertNotEqual(dict, dict2); |
| 3506 XCTAssertEqualObjects(dict, dict2); |
| 3507 XCTAssertTrue([dict2 isKindOfClass:[GPBUInt32ObjectDictionary class]]); |
| 3508 |
| 3509 [dict2 release]; |
| 3510 [dict release]; |
| 3511 } |
| 3512 |
| 3513 - (void)testDictionaryFromDictionary { |
| 3514 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 3515 const id kObjects[] = { @"abc", @"def", @"ghi", @"jkl" }; |
| 3516 GPBUInt32ObjectDictionary *dict = |
| 3517 [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects |
| 3518 forKeys:kKeys |
| 3519 count:GPBARRAYSIZE(kObjects)]
; |
| 3520 XCTAssertNotNil(dict); |
| 3521 |
| 3522 GPBUInt32ObjectDictionary *dict2 = |
| 3523 [GPBUInt32ObjectDictionary dictionaryWithDictionary:dict]; |
| 3524 XCTAssertNotNil(dict2); |
| 3525 |
| 3526 // Should be new pointer, but equal objects. |
| 3527 XCTAssertNotEqual(dict, dict2); |
| 3528 XCTAssertEqualObjects(dict, dict2); |
| 3529 [dict release]; |
| 3530 } |
| 3531 |
| 3532 - (void)testAdds { |
| 3533 GPBUInt32ObjectDictionary *dict = [GPBUInt32ObjectDictionary dictionary]; |
| 3534 XCTAssertNotNil(dict); |
| 3535 |
| 3536 XCTAssertEqual(dict.count, 0U); |
| 3537 [dict setObject:@"abc" forKey:1U]; |
| 3538 XCTAssertEqual(dict.count, 1U); |
| 3539 |
| 3540 const uint32_t kKeys[] = { 2U, 3U, 4U }; |
| 3541 const id kObjects[] = { @"def", @"ghi", @"jkl" }; |
| 3542 GPBUInt32ObjectDictionary *dict2 = |
| 3543 [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects |
| 3544 forKeys:kKeys |
| 3545 count:GPBARRAYSIZE(kObjects)]
; |
| 3546 XCTAssertNotNil(dict2); |
| 3547 [dict addEntriesFromDictionary:dict2]; |
| 3548 XCTAssertEqual(dict.count, 4U); |
| 3549 |
| 3550 XCTAssertEqualObjects([dict objectForKey:1U], @"abc"); |
| 3551 XCTAssertEqualObjects([dict objectForKey:2U], @"def"); |
| 3552 XCTAssertEqualObjects([dict objectForKey:3U], @"ghi"); |
| 3553 XCTAssertEqualObjects([dict objectForKey:4U], @"jkl"); |
| 3554 [dict2 release]; |
| 3555 } |
| 3556 |
| 3557 - (void)testRemove { |
| 3558 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 3559 const id kObjects[] = { @"abc", @"def", @"ghi", @"jkl" }; |
| 3560 GPBUInt32ObjectDictionary *dict = |
| 3561 [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects |
| 3562 forKeys:kKeys |
| 3563 count:GPBARRAYSIZE(kObjects)]; |
| 3564 XCTAssertNotNil(dict); |
| 3565 XCTAssertEqual(dict.count, 4U); |
| 3566 |
| 3567 [dict removeObjectForKey:2U]; |
| 3568 XCTAssertEqual(dict.count, 3U); |
| 3569 XCTAssertEqualObjects([dict objectForKey:1U], @"abc"); |
| 3570 XCTAssertNil([dict objectForKey:2U]); |
| 3571 XCTAssertEqualObjects([dict objectForKey:3U], @"ghi"); |
| 3572 XCTAssertEqualObjects([dict objectForKey:4U], @"jkl"); |
| 3573 |
| 3574 // Remove again does nothing. |
| 3575 [dict removeObjectForKey:2U]; |
| 3576 XCTAssertEqual(dict.count, 3U); |
| 3577 XCTAssertEqualObjects([dict objectForKey:1U], @"abc"); |
| 3578 XCTAssertNil([dict objectForKey:2U]); |
| 3579 XCTAssertEqualObjects([dict objectForKey:3U], @"ghi"); |
| 3580 XCTAssertEqualObjects([dict objectForKey:4U], @"jkl"); |
| 3581 |
| 3582 [dict removeObjectForKey:4U]; |
| 3583 XCTAssertEqual(dict.count, 2U); |
| 3584 XCTAssertEqualObjects([dict objectForKey:1U], @"abc"); |
| 3585 XCTAssertNil([dict objectForKey:2U]); |
| 3586 XCTAssertEqualObjects([dict objectForKey:3U], @"ghi"); |
| 3587 XCTAssertNil([dict objectForKey:4U]); |
| 3588 |
| 3589 [dict removeAll]; |
| 3590 XCTAssertEqual(dict.count, 0U); |
| 3591 XCTAssertNil([dict objectForKey:1U]); |
| 3592 XCTAssertNil([dict objectForKey:2U]); |
| 3593 XCTAssertNil([dict objectForKey:3U]); |
| 3594 XCTAssertNil([dict objectForKey:4U]); |
| 3595 [dict release]; |
| 3596 } |
| 3597 |
| 3598 - (void)testInplaceMutation { |
| 3599 const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; |
| 3600 const id kObjects[] = { @"abc", @"def", @"ghi", @"jkl" }; |
| 3601 GPBUInt32ObjectDictionary *dict = |
| 3602 [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects |
| 3603 forKeys:kKeys |
| 3604 count:GPBARRAYSIZE(kObjects)]; |
| 3605 XCTAssertNotNil(dict); |
| 3606 XCTAssertEqual(dict.count, 4U); |
| 3607 XCTAssertEqualObjects([dict objectForKey:1U], @"abc"); |
| 3608 XCTAssertEqualObjects([dict objectForKey:2U], @"def"); |
| 3609 XCTAssertEqualObjects([dict objectForKey:3U], @"ghi"); |
| 3610 XCTAssertEqualObjects([dict objectForKey:4U], @"jkl"); |
| 3611 |
| 3612 [dict setObject:@"jkl" forKey:1U]; |
| 3613 XCTAssertEqual(dict.count, 4U); |
| 3614 XCTAssertEqualObjects([dict objectForKey:1U], @"jkl"); |
| 3615 XCTAssertEqualObjects([dict objectForKey:2U], @"def"); |
| 3616 XCTAssertEqualObjects([dict objectForKey:3U], @"ghi"); |
| 3617 XCTAssertEqualObjects([dict objectForKey:4U], @"jkl"); |
| 3618 |
| 3619 [dict setObject:@"def" forKey:4U]; |
| 3620 XCTAssertEqual(dict.count, 4U); |
| 3621 XCTAssertEqualObjects([dict objectForKey:1U], @"jkl"); |
| 3622 XCTAssertEqualObjects([dict objectForKey:2U], @"def"); |
| 3623 XCTAssertEqualObjects([dict objectForKey:3U], @"ghi"); |
| 3624 XCTAssertEqualObjects([dict objectForKey:4U], @"def"); |
| 3625 |
| 3626 const uint32_t kKeys2[] = { 2U, 3U }; |
| 3627 const id kObjects2[] = { @"ghi", @"abc" }; |
| 3628 GPBUInt32ObjectDictionary *dict2 = |
| 3629 [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects2 |
| 3630 forKeys:kKeys2 |
| 3631 count:GPBARRAYSIZE(kObjects2)
]; |
| 3632 XCTAssertNotNil(dict2); |
| 3633 [dict addEntriesFromDictionary:dict2]; |
| 3634 XCTAssertEqual(dict.count, 4U); |
| 3635 XCTAssertEqualObjects([dict objectForKey:1U], @"jkl"); |
| 3636 XCTAssertEqualObjects([dict objectForKey:2U], @"ghi"); |
| 3637 XCTAssertEqualObjects([dict objectForKey:3U], @"abc"); |
| 3638 XCTAssertEqualObjects([dict objectForKey:4U], @"def"); |
| 3639 |
| 3640 [dict2 release]; |
| 3641 [dict release]; |
| 3642 } |
| 3643 |
| 3644 @end |
| 3645 |
| 3646 //%PDDM-EXPAND-END TEST_FOR_POD_KEY(UInt32, uint32_t, 1U, 2U, 3U, 4U) |
| 3647 |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1842653006:
Update //third_party/protobuf to version 3. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master