Home | History | Annotate | Download | only in Tests
      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(UInt64, uint64_t, 31ULL, 32ULL, 33ULL, 34ULL)
     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 GPBUInt64EnumDictionary (TestingTweak)
     48 + (instancetype)dictionaryWithValue:(int32_t)value forKey:(uint64_t)key;
     49 - (instancetype)initWithValues:(const int32_t [])values
     50                        forKeys:(const uint64_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 GPBUInt64EnumDictionary (TestingTweak)
     67 + (instancetype)dictionaryWithValue:(int32_t)value forKey:(uint64_t)key {
     68   // Cast is needed to compiler knows what class we are invoking initWithValues: on to get the
     69   // type correct.
     70   return [[(GPBUInt64EnumDictionary*)[self alloc] initWithValidationFunction:TestingEnum_IsValidValue
     71                                                                    rawValues:&value
     72                                                                      forKeys:&key
     73                                                                        count:1] autorelease];
     74 }
     75 - (instancetype)initWithValues:(const int32_t [])values
     76                        forKeys:(const uint64_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 - UInt64 -> UInt32
     87 
     88 @interface GPBUInt64UInt32DictionaryTests : XCTestCase
     89 @end
     90 
     91 @implementation GPBUInt64UInt32DictionaryTests
     92 
     93 - (void)testEmpty {
     94   GPBUInt64UInt32Dictionary *dict = [[GPBUInt64UInt32Dictionary alloc] init];
     95   XCTAssertNotNil(dict);
     96   XCTAssertEqual(dict.count, 0U);
     97   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
     98   [dict enumerateKeysAndValuesUsingBlock:^(uint64_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   GPBUInt64UInt32Dictionary *dict = [GPBUInt64UInt32Dictionary dictionaryWithValue:100U forKey:31ULL];
    107   XCTAssertNotNil(dict);
    108   XCTAssertEqual(dict.count, 1U);
    109   uint32_t value;
    110   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
    111   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    112   XCTAssertEqual(value, 100U);
    113   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
    114   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, uint32_t aValue, BOOL *stop) {
    115     XCTAssertEqual(aKey, 31ULL);
    116     XCTAssertEqual(aValue, 100U);
    117     XCTAssertNotEqual(stop, NULL);
    118   }];
    119 }
    120 
    121 - (void)testBasics {
    122   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL };
    123   const uint32_t kValues[] = { 100U, 101U, 102U };
    124   GPBUInt64UInt32Dictionary *dict =
    125       [[GPBUInt64UInt32Dictionary 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:31ULL value:NULL]);
    132   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    133   XCTAssertEqual(value, 100U);
    134   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
    135   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
    136   XCTAssertEqual(value, 101U);
    137   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    138   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    139   XCTAssertEqual(value, 102U);
    140   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
    141 
    142   __block NSUInteger idx = 0;
    143   uint64_t *seenKeys = malloc(3 * sizeof(uint64_t));
    144   uint32_t *seenValues = malloc(3 * sizeof(uint32_t));
    145   [dict enumerateKeysAndValuesUsingBlock:^(uint64_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:^(uint64_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 uint64_t kKeys1[] = { 31ULL, 32ULL, 33ULL, 34ULL };
    178   const uint64_t kKeys2[] = { 32ULL, 31ULL, 34ULL };
    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   GPBUInt64UInt32Dictionary *dict1 =
    183       [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues1
    184                                                 forKeys:kKeys1
    185                                                   count:GPBARRAYSIZE(kValues1)];
    186   XCTAssertNotNil(dict1);
    187   GPBUInt64UInt32Dictionary *dict1prime =
    188       [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues1
    189                                                 forKeys:kKeys1
    190                                                   count:GPBARRAYSIZE(kValues1)];
    191   XCTAssertNotNil(dict1prime);
    192   GPBUInt64UInt32Dictionary *dict2 =
    193       [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues2
    194                                                 forKeys:kKeys1
    195                                                   count:GPBARRAYSIZE(kValues2)];
    196   XCTAssertNotNil(dict2);
    197   GPBUInt64UInt32Dictionary *dict3 =
    198       [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues1
    199                                                 forKeys:kKeys2
    200                                                   count:GPBARRAYSIZE(kValues1)];
    201   XCTAssertNotNil(dict3);
    202   GPBUInt64UInt32Dictionary *dict4 =
    203       [[GPBUInt64UInt32Dictionary 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 uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
    232   const uint32_t kValues[] = { 100U, 101U, 102U, 103U };
    233   GPBUInt64UInt32Dictionary *dict =
    234       [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues
    235                                                 forKeys:kKeys
    236                                                   count:GPBARRAYSIZE(kValues)];
    237   XCTAssertNotNil(dict);
    238 
    239   GPBUInt64UInt32Dictionary *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:[GPBUInt64UInt32Dictionary class]]);
    246 
    247   [dict2 release];
    248   [dict release];
    249 }
    250 
    251 - (void)testDictionaryFromDictionary {
    252   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
    253   const uint32_t kValues[] = { 100U, 101U, 102U, 103U };
    254   GPBUInt64UInt32Dictionary *dict =
    255       [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues
    256                                                 forKeys:kKeys
    257                                                   count:GPBARRAYSIZE(kValues)];
    258   XCTAssertNotNil(dict);
    259 
    260   GPBUInt64UInt32Dictionary *dict2 =
    261       [GPBUInt64UInt32Dictionary 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   GPBUInt64UInt32Dictionary *dict = [GPBUInt64UInt32Dictionary dictionary];
    272   XCTAssertNotNil(dict);
    273 
    274   XCTAssertEqual(dict.count, 0U);
    275   [dict setValue:100U forKey:31ULL];
    276   XCTAssertEqual(dict.count, 1U);
    277 
    278   const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL };
    279   const uint32_t kValues[] = { 101U, 102U, 103U };
    280   GPBUInt64UInt32Dictionary *dict2 =
    281       [[GPBUInt64UInt32Dictionary 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:31ULL value:NULL]);
    290   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    291   XCTAssertEqual(value, 100U);
    292   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
    293   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
    294   XCTAssertEqual(value, 101U);
    295   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    296   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    297   XCTAssertEqual(value, 102U);
    298   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    299   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    300   XCTAssertEqual(value, 103U);
    301   [dict2 release];
    302 }
    303 
    304 - (void)testRemove {
    305   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
    306   const uint32_t kValues[] = { 100U, 101U, 102U, 103U };
    307   GPBUInt64UInt32Dictionary *dict =
    308       [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues
    309                                          forKeys:kKeys
    310                                            count:GPBARRAYSIZE(kValues)];
    311   XCTAssertNotNil(dict);
    312   XCTAssertEqual(dict.count, 4U);
    313 
    314   [dict removeValueForKey:32ULL];
    315   XCTAssertEqual(dict.count, 3U);
    316   uint32_t value;
    317   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
    318   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    319   XCTAssertEqual(value, 100U);
    320   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
    321   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    322   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    323   XCTAssertEqual(value, 102U);
    324   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    325   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    326   XCTAssertEqual(value, 103U);
    327 
    328   // Remove again does nothing.
    329   [dict removeValueForKey:32ULL];
    330   XCTAssertEqual(dict.count, 3U);
    331   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
    332   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    333   XCTAssertEqual(value, 100U);
    334   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
    335   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    336   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    337   XCTAssertEqual(value, 102U);
    338   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    339   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    340   XCTAssertEqual(value, 103U);
    341 
    342   [dict removeValueForKey:34ULL];
    343   XCTAssertEqual(dict.count, 2U);
    344   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
    345   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    346   XCTAssertEqual(value, 100U);
    347   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
    348   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    349   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    350   XCTAssertEqual(value, 102U);
    351   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
    352 
    353   [dict removeAll];
    354   XCTAssertEqual(dict.count, 0U);
    355   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
    356   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
    357   XCTAssertFalse([dict valueForKey:33ULL value:NULL]);
    358   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
    359   [dict release];
    360 }
    361 
    362 - (void)testInplaceMutation {
    363   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
    364   const uint32_t kValues[] = { 100U, 101U, 102U, 103U };
    365   GPBUInt64UInt32Dictionary *dict =
    366       [[GPBUInt64UInt32Dictionary 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:31ULL value:NULL]);
    373   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    374   XCTAssertEqual(value, 100U);
    375   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
    376   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
    377   XCTAssertEqual(value, 101U);
    378   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    379   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    380   XCTAssertEqual(value, 102U);
    381   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    382   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    383   XCTAssertEqual(value, 103U);
    384 
    385   [dict setValue:103U forKey:31ULL];
    386   XCTAssertEqual(dict.count, 4U);
    387   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
    388   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    389   XCTAssertEqual(value, 103U);
    390   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
    391   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
    392   XCTAssertEqual(value, 101U);
    393   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    394   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    395   XCTAssertEqual(value, 102U);
    396   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    397   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    398   XCTAssertEqual(value, 103U);
    399 
    400   [dict setValue:101U forKey:34ULL];
    401   XCTAssertEqual(dict.count, 4U);
    402   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
    403   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    404   XCTAssertEqual(value, 103U);
    405   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
    406   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
    407   XCTAssertEqual(value, 101U);
    408   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    409   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    410   XCTAssertEqual(value, 102U);
    411   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    412   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    413   XCTAssertEqual(value, 101U);
    414 
    415   const uint64_t kKeys2[] = { 32ULL, 33ULL };
    416   const uint32_t kValues2[] = { 102U, 100U };
    417   GPBUInt64UInt32Dictionary *dict2 =
    418       [[GPBUInt64UInt32Dictionary 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:31ULL value:NULL]);
    425   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    426   XCTAssertEqual(value, 103U);
    427   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
    428   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
    429   XCTAssertEqual(value, 102U);
    430   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    431   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    432   XCTAssertEqual(value, 100U);
    433   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    434   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    435   XCTAssertEqual(value, 101U);
    436 
    437   [dict2 release];
    438   [dict release];
    439 }
    440 
    441 @end
    442 
    443 #pragma mark - UInt64 -> Int32
    444 
    445 @interface GPBUInt64Int32DictionaryTests : XCTestCase
    446 @end
    447 
    448 @implementation GPBUInt64Int32DictionaryTests
    449 
    450 - (void)testEmpty {
    451   GPBUInt64Int32Dictionary *dict = [[GPBUInt64Int32Dictionary alloc] init];
    452   XCTAssertNotNil(dict);
    453   XCTAssertEqual(dict.count, 0U);
    454   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
    455   [dict enumerateKeysAndValuesUsingBlock:^(uint64_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   GPBUInt64Int32Dictionary *dict = [GPBUInt64Int32Dictionary dictionaryWithValue:200 forKey:31ULL];
    464   XCTAssertNotNil(dict);
    465   XCTAssertEqual(dict.count, 1U);
    466   int32_t value;
    467   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
    468   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    469   XCTAssertEqual(value, 200);
    470   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
    471   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) {
    472     XCTAssertEqual(aKey, 31ULL);
    473     XCTAssertEqual(aValue, 200);
    474     XCTAssertNotEqual(stop, NULL);
    475   }];
    476 }
    477 
    478 - (void)testBasics {
    479   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL };
    480   const int32_t kValues[] = { 200, 201, 202 };
    481   GPBUInt64Int32Dictionary *dict =
    482       [[GPBUInt64Int32Dictionary 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:31ULL value:NULL]);
    489   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    490   XCTAssertEqual(value, 200);
    491   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
    492   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
    493   XCTAssertEqual(value, 201);
    494   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    495   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    496   XCTAssertEqual(value, 202);
    497   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
    498 
    499   __block NSUInteger idx = 0;
    500   uint64_t *seenKeys = malloc(3 * sizeof(uint64_t));
    501   int32_t *seenValues = malloc(3 * sizeof(int32_t));
    502   [dict enumerateKeysAndValuesUsingBlock:^(uint64_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:^(uint64_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 uint64_t kKeys1[] = { 31ULL, 32ULL, 33ULL, 34ULL };
    535   const uint64_t kKeys2[] = { 32ULL, 31ULL, 34ULL };
    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   GPBUInt64Int32Dictionary *dict1 =
    540       [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues1
    541                                                forKeys:kKeys1
    542                                                  count:GPBARRAYSIZE(kValues1)];
    543   XCTAssertNotNil(dict1);
    544   GPBUInt64Int32Dictionary *dict1prime =
    545       [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues1
    546                                                forKeys:kKeys1
    547                                                  count:GPBARRAYSIZE(kValues1)];
    548   XCTAssertNotNil(dict1prime);
    549   GPBUInt64Int32Dictionary *dict2 =
    550       [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues2
    551                                                forKeys:kKeys1
    552                                                  count:GPBARRAYSIZE(kValues2)];
    553   XCTAssertNotNil(dict2);
    554   GPBUInt64Int32Dictionary *dict3 =
    555       [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues1
    556                                                forKeys:kKeys2
    557                                                  count:GPBARRAYSIZE(kValues1)];
    558   XCTAssertNotNil(dict3);
    559   GPBUInt64Int32Dictionary *dict4 =
    560       [[GPBUInt64Int32Dictionary 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 uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
    589   const int32_t kValues[] = { 200, 201, 202, 203 };
    590   GPBUInt64Int32Dictionary *dict =
    591       [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues
    592                                                forKeys:kKeys
    593                                                  count:GPBARRAYSIZE(kValues)];
    594   XCTAssertNotNil(dict);
    595 
    596   GPBUInt64Int32Dictionary *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:[GPBUInt64Int32Dictionary class]]);
    603 
    604   [dict2 release];
    605   [dict release];
    606 }
    607 
    608 - (void)testDictionaryFromDictionary {
    609   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
    610   const int32_t kValues[] = { 200, 201, 202, 203 };
    611   GPBUInt64Int32Dictionary *dict =
    612       [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues
    613                                                forKeys:kKeys
    614                                                  count:GPBARRAYSIZE(kValues)];
    615   XCTAssertNotNil(dict);
    616 
    617   GPBUInt64Int32Dictionary *dict2 =
    618       [GPBUInt64Int32Dictionary 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   GPBUInt64Int32Dictionary *dict = [GPBUInt64Int32Dictionary dictionary];
    629   XCTAssertNotNil(dict);
    630 
    631   XCTAssertEqual(dict.count, 0U);
    632   [dict setValue:200 forKey:31ULL];
    633   XCTAssertEqual(dict.count, 1U);
    634 
    635   const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL };
    636   const int32_t kValues[] = { 201, 202, 203 };
    637   GPBUInt64Int32Dictionary *dict2 =
    638       [[GPBUInt64Int32Dictionary 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:31ULL value:NULL]);
    647   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    648   XCTAssertEqual(value, 200);
    649   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
    650   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
    651   XCTAssertEqual(value, 201);
    652   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    653   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    654   XCTAssertEqual(value, 202);
    655   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    656   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    657   XCTAssertEqual(value, 203);
    658   [dict2 release];
    659 }
    660 
    661 - (void)testRemove {
    662   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
    663   const int32_t kValues[] = { 200, 201, 202, 203 };
    664   GPBUInt64Int32Dictionary *dict =
    665       [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues
    666                                         forKeys:kKeys
    667                                           count:GPBARRAYSIZE(kValues)];
    668   XCTAssertNotNil(dict);
    669   XCTAssertEqual(dict.count, 4U);
    670 
    671   [dict removeValueForKey:32ULL];
    672   XCTAssertEqual(dict.count, 3U);
    673   int32_t value;
    674   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
    675   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    676   XCTAssertEqual(value, 200);
    677   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
    678   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    679   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    680   XCTAssertEqual(value, 202);
    681   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    682   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    683   XCTAssertEqual(value, 203);
    684 
    685   // Remove again does nothing.
    686   [dict removeValueForKey:32ULL];
    687   XCTAssertEqual(dict.count, 3U);
    688   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
    689   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    690   XCTAssertEqual(value, 200);
    691   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
    692   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    693   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    694   XCTAssertEqual(value, 202);
    695   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    696   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    697   XCTAssertEqual(value, 203);
    698 
    699   [dict removeValueForKey:34ULL];
    700   XCTAssertEqual(dict.count, 2U);
    701   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
    702   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    703   XCTAssertEqual(value, 200);
    704   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
    705   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    706   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    707   XCTAssertEqual(value, 202);
    708   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
    709 
    710   [dict removeAll];
    711   XCTAssertEqual(dict.count, 0U);
    712   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
    713   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
    714   XCTAssertFalse([dict valueForKey:33ULL value:NULL]);
    715   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
    716   [dict release];
    717 }
    718 
    719 - (void)testInplaceMutation {
    720   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
    721   const int32_t kValues[] = { 200, 201, 202, 203 };
    722   GPBUInt64Int32Dictionary *dict =
    723       [[GPBUInt64Int32Dictionary 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:31ULL value:NULL]);
    730   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    731   XCTAssertEqual(value, 200);
    732   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
    733   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
    734   XCTAssertEqual(value, 201);
    735   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    736   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    737   XCTAssertEqual(value, 202);
    738   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    739   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    740   XCTAssertEqual(value, 203);
    741 
    742   [dict setValue:203 forKey:31ULL];
    743   XCTAssertEqual(dict.count, 4U);
    744   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
    745   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    746   XCTAssertEqual(value, 203);
    747   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
    748   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
    749   XCTAssertEqual(value, 201);
    750   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    751   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    752   XCTAssertEqual(value, 202);
    753   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    754   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    755   XCTAssertEqual(value, 203);
    756 
    757   [dict setValue:201 forKey:34ULL];
    758   XCTAssertEqual(dict.count, 4U);
    759   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
    760   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    761   XCTAssertEqual(value, 203);
    762   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
    763   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
    764   XCTAssertEqual(value, 201);
    765   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    766   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    767   XCTAssertEqual(value, 202);
    768   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    769   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    770   XCTAssertEqual(value, 201);
    771 
    772   const uint64_t kKeys2[] = { 32ULL, 33ULL };
    773   const int32_t kValues2[] = { 202, 200 };
    774   GPBUInt64Int32Dictionary *dict2 =
    775       [[GPBUInt64Int32Dictionary 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:31ULL value:NULL]);
    782   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    783   XCTAssertEqual(value, 203);
    784   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
    785   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
    786   XCTAssertEqual(value, 202);
    787   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    788   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    789   XCTAssertEqual(value, 200);
    790   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
    791   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
    792   XCTAssertEqual(value, 201);
    793 
    794   [dict2 release];
    795   [dict release];
    796 }
    797 
    798 @end
    799 
    800 #pragma mark - UInt64 -> UInt64
    801 
    802 @interface GPBUInt64UInt64DictionaryTests : XCTestCase
    803 @end
    804 
    805 @implementation GPBUInt64UInt64DictionaryTests
    806 
    807 - (void)testEmpty {
    808   GPBUInt64UInt64Dictionary *dict = [[GPBUInt64UInt64Dictionary alloc] init];
    809   XCTAssertNotNil(dict);
    810   XCTAssertEqual(dict.count, 0U);
    811   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
    812   [dict enumerateKeysAndValuesUsingBlock:^(uint64_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   GPBUInt64UInt64Dictionary *dict = [GPBUInt64UInt64Dictionary dictionaryWithValue:300U forKey:31ULL];
    821   XCTAssertNotNil(dict);
    822   XCTAssertEqual(dict.count, 1U);
    823   uint64_t value;
    824   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
    825   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    826   XCTAssertEqual(value, 300U);
    827   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
    828   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, uint64_t aValue, BOOL *stop) {
    829     XCTAssertEqual(aKey, 31ULL);
    830     XCTAssertEqual(aValue, 300U);
    831     XCTAssertNotEqual(stop, NULL);
    832   }];
    833 }
    834 
    835 - (void)testBasics {
    836   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL };
    837   const uint64_t kValues[] = { 300U, 301U, 302U };
    838   GPBUInt64UInt64Dictionary *dict =
    839       [[GPBUInt64UInt64Dictionary 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:31ULL value:NULL]);
    846   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
    847   XCTAssertEqual(value, 300U);
    848   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
    849   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
    850   XCTAssertEqual(value, 301U);
    851   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
    852   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
    853   XCTAssertEqual(value, 302U);
    854   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
    855 
    856   __block NSUInteger idx = 0;
    857   uint64_t *seenKeys = malloc(3 * sizeof(uint64_t));
    858   uint64_t *seenValues = malloc(3 * sizeof(uint64_t));
    859   [dict enumerateKeysAndValuesUsingBlock:^(uint64_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:^(uint64_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 uint64_t kKeys1[] = { 31ULL, 32ULL, 33ULL, 34ULL };
    892   const uint64_t kKeys2[] = { 32ULL, 31ULL, 34ULL };
    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   GPBUInt64UInt64Dictionary *dict1 =
    897       [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues1
    898                                                 forKeys:kKeys1
    899                                                   count:GPBARRAYSIZE(kValues1)];
    900   XCTAssertNotNil(dict1);
    901   GPBUInt64UInt64Dictionary *dict1prime =
    902       [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues1
    903                                                 forKeys:kKeys1
    904                                                   count:GPBARRAYSIZE(kValues1)];
    905   XCTAssertNotNil(dict1prime);
    906   GPBUInt64UInt64Dictionary *dict2 =
    907       [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues2
    908                                                 forKeys:kKeys1
    909                                                   count:GPBARRAYSIZE(kValues2)];
    910   XCTAssertNotNil(dict2);
    911   GPBUInt64UInt64Dictionary *dict3 =
    912       [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues1
    913                                                 forKeys:kKeys2
    914                                                   count:GPBARRAYSIZE(kValues1)];
    915   XCTAssertNotNil(dict3);
    916   GPBUInt64UInt64Dictionary *dict4 =
    917       [[GPBUInt64UInt64Dictionary 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 uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
    946   const uint64_t kValues[] = { 300U, 301U, 302U, 303U };
    947   GPBUInt64UInt64Dictionary *dict =
    948       [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues
    949                                                 forKeys:kKeys
    950                                                   count:GPBARRAYSIZE(kValues)];
    951   XCTAssertNotNil(dict);
    952 
    953   GPBUInt64UInt64Dictionary *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:[GPBUInt64UInt64Dictionary class]]);
    960 
    961   [dict2 release];
    962   [dict release];
    963 }
    964 
    965 - (void)testDictionaryFromDictionary {
    966   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
    967   const uint64_t kValues[] = { 300U, 301U, 302U, 303U };
    968   GPBUInt64UInt64Dictionary *dict =
    969       [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues
    970                                                 forKeys:kKeys
    971                                                   count:GPBARRAYSIZE(kValues)];
    972   XCTAssertNotNil(dict);
    973 
    974   GPBUInt64UInt64Dictionary *dict2 =
    975       [GPBUInt64UInt64Dictionary 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   GPBUInt64UInt64Dictionary *dict = [GPBUInt64UInt64Dictionary dictionary];
    986   XCTAssertNotNil(dict);
    987 
    988   XCTAssertEqual(dict.count, 0U);
    989   [dict setValue:300U forKey:31ULL];
    990   XCTAssertEqual(dict.count, 1U);
    991 
    992   const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL };
    993   const uint64_t kValues[] = { 301U, 302U, 303U };
    994   GPBUInt64UInt64Dictionary *dict2 =
    995       [[GPBUInt64UInt64Dictionary 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:31ULL value:NULL]);
   1004   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1005   XCTAssertEqual(value, 300U);
   1006   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1007   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1008   XCTAssertEqual(value, 301U);
   1009   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1010   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1011   XCTAssertEqual(value, 302U);
   1012   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1013   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1014   XCTAssertEqual(value, 303U);
   1015   [dict2 release];
   1016 }
   1017 
   1018 - (void)testRemove {
   1019   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   1020   const uint64_t kValues[] = { 300U, 301U, 302U, 303U };
   1021   GPBUInt64UInt64Dictionary *dict =
   1022       [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues
   1023                                          forKeys:kKeys
   1024                                            count:GPBARRAYSIZE(kValues)];
   1025   XCTAssertNotNil(dict);
   1026   XCTAssertEqual(dict.count, 4U);
   1027 
   1028   [dict removeValueForKey:32ULL];
   1029   XCTAssertEqual(dict.count, 3U);
   1030   uint64_t value;
   1031   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1032   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1033   XCTAssertEqual(value, 300U);
   1034   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1035   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1036   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1037   XCTAssertEqual(value, 302U);
   1038   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1039   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1040   XCTAssertEqual(value, 303U);
   1041 
   1042   // Remove again does nothing.
   1043   [dict removeValueForKey:32ULL];
   1044   XCTAssertEqual(dict.count, 3U);
   1045   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1046   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1047   XCTAssertEqual(value, 300U);
   1048   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1049   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1050   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1051   XCTAssertEqual(value, 302U);
   1052   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1053   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1054   XCTAssertEqual(value, 303U);
   1055 
   1056   [dict removeValueForKey:34ULL];
   1057   XCTAssertEqual(dict.count, 2U);
   1058   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1059   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1060   XCTAssertEqual(value, 300U);
   1061   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1062   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1063   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1064   XCTAssertEqual(value, 302U);
   1065   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   1066 
   1067   [dict removeAll];
   1068   XCTAssertEqual(dict.count, 0U);
   1069   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
   1070   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1071   XCTAssertFalse([dict valueForKey:33ULL value:NULL]);
   1072   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   1073   [dict release];
   1074 }
   1075 
   1076 - (void)testInplaceMutation {
   1077   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   1078   const uint64_t kValues[] = { 300U, 301U, 302U, 303U };
   1079   GPBUInt64UInt64Dictionary *dict =
   1080       [[GPBUInt64UInt64Dictionary 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:31ULL value:NULL]);
   1087   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1088   XCTAssertEqual(value, 300U);
   1089   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1090   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1091   XCTAssertEqual(value, 301U);
   1092   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1093   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1094   XCTAssertEqual(value, 302U);
   1095   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1096   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1097   XCTAssertEqual(value, 303U);
   1098 
   1099   [dict setValue:303U forKey:31ULL];
   1100   XCTAssertEqual(dict.count, 4U);
   1101   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1102   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1103   XCTAssertEqual(value, 303U);
   1104   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1105   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1106   XCTAssertEqual(value, 301U);
   1107   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1108   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1109   XCTAssertEqual(value, 302U);
   1110   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1111   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1112   XCTAssertEqual(value, 303U);
   1113 
   1114   [dict setValue:301U forKey:34ULL];
   1115   XCTAssertEqual(dict.count, 4U);
   1116   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1117   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1118   XCTAssertEqual(value, 303U);
   1119   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1120   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1121   XCTAssertEqual(value, 301U);
   1122   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1123   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1124   XCTAssertEqual(value, 302U);
   1125   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1126   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1127   XCTAssertEqual(value, 301U);
   1128 
   1129   const uint64_t kKeys2[] = { 32ULL, 33ULL };
   1130   const uint64_t kValues2[] = { 302U, 300U };
   1131   GPBUInt64UInt64Dictionary *dict2 =
   1132       [[GPBUInt64UInt64Dictionary 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:31ULL value:NULL]);
   1139   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1140   XCTAssertEqual(value, 303U);
   1141   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1142   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1143   XCTAssertEqual(value, 302U);
   1144   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1145   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1146   XCTAssertEqual(value, 300U);
   1147   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1148   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1149   XCTAssertEqual(value, 301U);
   1150 
   1151   [dict2 release];
   1152   [dict release];
   1153 }
   1154 
   1155 @end
   1156 
   1157 #pragma mark - UInt64 -> Int64
   1158 
   1159 @interface GPBUInt64Int64DictionaryTests : XCTestCase
   1160 @end
   1161 
   1162 @implementation GPBUInt64Int64DictionaryTests
   1163 
   1164 - (void)testEmpty {
   1165   GPBUInt64Int64Dictionary *dict = [[GPBUInt64Int64Dictionary alloc] init];
   1166   XCTAssertNotNil(dict);
   1167   XCTAssertEqual(dict.count, 0U);
   1168   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
   1169   [dict enumerateKeysAndValuesUsingBlock:^(uint64_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   GPBUInt64Int64Dictionary *dict = [GPBUInt64Int64Dictionary dictionaryWithValue:400 forKey:31ULL];
   1178   XCTAssertNotNil(dict);
   1179   XCTAssertEqual(dict.count, 1U);
   1180   int64_t value;
   1181   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1182   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1183   XCTAssertEqual(value, 400);
   1184   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1185   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int64_t aValue, BOOL *stop) {
   1186     XCTAssertEqual(aKey, 31ULL);
   1187     XCTAssertEqual(aValue, 400);
   1188     XCTAssertNotEqual(stop, NULL);
   1189   }];
   1190 }
   1191 
   1192 - (void)testBasics {
   1193   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL };
   1194   const int64_t kValues[] = { 400, 401, 402 };
   1195   GPBUInt64Int64Dictionary *dict =
   1196       [[GPBUInt64Int64Dictionary 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:31ULL value:NULL]);
   1203   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1204   XCTAssertEqual(value, 400);
   1205   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1206   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1207   XCTAssertEqual(value, 401);
   1208   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1209   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1210   XCTAssertEqual(value, 402);
   1211   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   1212 
   1213   __block NSUInteger idx = 0;
   1214   uint64_t *seenKeys = malloc(3 * sizeof(uint64_t));
   1215   int64_t *seenValues = malloc(3 * sizeof(int64_t));
   1216   [dict enumerateKeysAndValuesUsingBlock:^(uint64_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:^(uint64_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 uint64_t kKeys1[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   1249   const uint64_t kKeys2[] = { 32ULL, 31ULL, 34ULL };
   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   GPBUInt64Int64Dictionary *dict1 =
   1254       [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues1
   1255                                                forKeys:kKeys1
   1256                                                  count:GPBARRAYSIZE(kValues1)];
   1257   XCTAssertNotNil(dict1);
   1258   GPBUInt64Int64Dictionary *dict1prime =
   1259       [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues1
   1260                                                forKeys:kKeys1
   1261                                                  count:GPBARRAYSIZE(kValues1)];
   1262   XCTAssertNotNil(dict1prime);
   1263   GPBUInt64Int64Dictionary *dict2 =
   1264       [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues2
   1265                                                forKeys:kKeys1
   1266                                                  count:GPBARRAYSIZE(kValues2)];
   1267   XCTAssertNotNil(dict2);
   1268   GPBUInt64Int64Dictionary *dict3 =
   1269       [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues1
   1270                                                forKeys:kKeys2
   1271                                                  count:GPBARRAYSIZE(kValues1)];
   1272   XCTAssertNotNil(dict3);
   1273   GPBUInt64Int64Dictionary *dict4 =
   1274       [[GPBUInt64Int64Dictionary 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 uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   1303   const int64_t kValues[] = { 400, 401, 402, 403 };
   1304   GPBUInt64Int64Dictionary *dict =
   1305       [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues
   1306                                                forKeys:kKeys
   1307                                                  count:GPBARRAYSIZE(kValues)];
   1308   XCTAssertNotNil(dict);
   1309 
   1310   GPBUInt64Int64Dictionary *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:[GPBUInt64Int64Dictionary class]]);
   1317 
   1318   [dict2 release];
   1319   [dict release];
   1320 }
   1321 
   1322 - (void)testDictionaryFromDictionary {
   1323   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   1324   const int64_t kValues[] = { 400, 401, 402, 403 };
   1325   GPBUInt64Int64Dictionary *dict =
   1326       [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues
   1327                                                forKeys:kKeys
   1328                                                  count:GPBARRAYSIZE(kValues)];
   1329   XCTAssertNotNil(dict);
   1330 
   1331   GPBUInt64Int64Dictionary *dict2 =
   1332       [GPBUInt64Int64Dictionary 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   GPBUInt64Int64Dictionary *dict = [GPBUInt64Int64Dictionary dictionary];
   1343   XCTAssertNotNil(dict);
   1344 
   1345   XCTAssertEqual(dict.count, 0U);
   1346   [dict setValue:400 forKey:31ULL];
   1347   XCTAssertEqual(dict.count, 1U);
   1348 
   1349   const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL };
   1350   const int64_t kValues[] = { 401, 402, 403 };
   1351   GPBUInt64Int64Dictionary *dict2 =
   1352       [[GPBUInt64Int64Dictionary 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:31ULL value:NULL]);
   1361   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1362   XCTAssertEqual(value, 400);
   1363   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1364   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1365   XCTAssertEqual(value, 401);
   1366   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1367   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1368   XCTAssertEqual(value, 402);
   1369   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1370   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1371   XCTAssertEqual(value, 403);
   1372   [dict2 release];
   1373 }
   1374 
   1375 - (void)testRemove {
   1376   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   1377   const int64_t kValues[] = { 400, 401, 402, 403 };
   1378   GPBUInt64Int64Dictionary *dict =
   1379       [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues
   1380                                         forKeys:kKeys
   1381                                           count:GPBARRAYSIZE(kValues)];
   1382   XCTAssertNotNil(dict);
   1383   XCTAssertEqual(dict.count, 4U);
   1384 
   1385   [dict removeValueForKey:32ULL];
   1386   XCTAssertEqual(dict.count, 3U);
   1387   int64_t value;
   1388   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1389   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1390   XCTAssertEqual(value, 400);
   1391   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1392   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1393   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1394   XCTAssertEqual(value, 402);
   1395   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1396   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1397   XCTAssertEqual(value, 403);
   1398 
   1399   // Remove again does nothing.
   1400   [dict removeValueForKey:32ULL];
   1401   XCTAssertEqual(dict.count, 3U);
   1402   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1403   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1404   XCTAssertEqual(value, 400);
   1405   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1406   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1407   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1408   XCTAssertEqual(value, 402);
   1409   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1410   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1411   XCTAssertEqual(value, 403);
   1412 
   1413   [dict removeValueForKey:34ULL];
   1414   XCTAssertEqual(dict.count, 2U);
   1415   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1416   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1417   XCTAssertEqual(value, 400);
   1418   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1419   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1420   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1421   XCTAssertEqual(value, 402);
   1422   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   1423 
   1424   [dict removeAll];
   1425   XCTAssertEqual(dict.count, 0U);
   1426   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
   1427   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1428   XCTAssertFalse([dict valueForKey:33ULL value:NULL]);
   1429   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   1430   [dict release];
   1431 }
   1432 
   1433 - (void)testInplaceMutation {
   1434   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   1435   const int64_t kValues[] = { 400, 401, 402, 403 };
   1436   GPBUInt64Int64Dictionary *dict =
   1437       [[GPBUInt64Int64Dictionary 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:31ULL value:NULL]);
   1444   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1445   XCTAssertEqual(value, 400);
   1446   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1447   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1448   XCTAssertEqual(value, 401);
   1449   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1450   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1451   XCTAssertEqual(value, 402);
   1452   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1453   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1454   XCTAssertEqual(value, 403);
   1455 
   1456   [dict setValue:403 forKey:31ULL];
   1457   XCTAssertEqual(dict.count, 4U);
   1458   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1459   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1460   XCTAssertEqual(value, 403);
   1461   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1462   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1463   XCTAssertEqual(value, 401);
   1464   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1465   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1466   XCTAssertEqual(value, 402);
   1467   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1468   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1469   XCTAssertEqual(value, 403);
   1470 
   1471   [dict setValue:401 forKey:34ULL];
   1472   XCTAssertEqual(dict.count, 4U);
   1473   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1474   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1475   XCTAssertEqual(value, 403);
   1476   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1477   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1478   XCTAssertEqual(value, 401);
   1479   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1480   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1481   XCTAssertEqual(value, 402);
   1482   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1483   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1484   XCTAssertEqual(value, 401);
   1485 
   1486   const uint64_t kKeys2[] = { 32ULL, 33ULL };
   1487   const int64_t kValues2[] = { 402, 400 };
   1488   GPBUInt64Int64Dictionary *dict2 =
   1489       [[GPBUInt64Int64Dictionary 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:31ULL value:NULL]);
   1496   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1497   XCTAssertEqual(value, 403);
   1498   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1499   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1500   XCTAssertEqual(value, 402);
   1501   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1502   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1503   XCTAssertEqual(value, 400);
   1504   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1505   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1506   XCTAssertEqual(value, 401);
   1507 
   1508   [dict2 release];
   1509   [dict release];
   1510 }
   1511 
   1512 @end
   1513 
   1514 #pragma mark - UInt64 -> Bool
   1515 
   1516 @interface GPBUInt64BoolDictionaryTests : XCTestCase
   1517 @end
   1518 
   1519 @implementation GPBUInt64BoolDictionaryTests
   1520 
   1521 - (void)testEmpty {
   1522   GPBUInt64BoolDictionary *dict = [[GPBUInt64BoolDictionary alloc] init];
   1523   XCTAssertNotNil(dict);
   1524   XCTAssertEqual(dict.count, 0U);
   1525   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
   1526   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *stop) {
   1527     #pragma unused(aKey, aValue, stop)
   1528     XCTFail(@"Shouldn't get here!");
   1529   }];
   1530   [dict release];
   1531 }
   1532 
   1533 - (void)testOne {
   1534   GPBUInt64BoolDictionary *dict = [GPBUInt64BoolDictionary dictionaryWithValue:YES forKey:31ULL];
   1535   XCTAssertNotNil(dict);
   1536   XCTAssertEqual(dict.count, 1U);
   1537   BOOL value;
   1538   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1539   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1540   XCTAssertEqual(value, YES);
   1541   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1542   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *stop) {
   1543     XCTAssertEqual(aKey, 31ULL);
   1544     XCTAssertEqual(aValue, YES);
   1545     XCTAssertNotEqual(stop, NULL);
   1546   }];
   1547 }
   1548 
   1549 - (void)testBasics {
   1550   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL };
   1551   const BOOL kValues[] = { YES, YES, NO };
   1552   GPBUInt64BoolDictionary *dict =
   1553       [[GPBUInt64BoolDictionary 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:31ULL value:NULL]);
   1560   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1561   XCTAssertEqual(value, YES);
   1562   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1563   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1564   XCTAssertEqual(value, YES);
   1565   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1566   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1567   XCTAssertEqual(value, NO);
   1568   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   1569 
   1570   __block NSUInteger idx = 0;
   1571   uint64_t *seenKeys = malloc(3 * sizeof(uint64_t));
   1572   BOOL *seenValues = malloc(3 * sizeof(BOOL));
   1573   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *stop) {
   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:^(uint64_t aKey, BOOL aValue, BOOL *stop) {
   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 uint64_t kKeys1[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   1606   const uint64_t kKeys2[] = { 32ULL, 31ULL, 34ULL };
   1607   const BOOL kValues1[] = { YES, YES, NO };
   1608   const BOOL kValues2[] = { YES, NO, NO };
   1609   const BOOL kValues3[] = { YES, YES, NO, NO };
   1610   GPBUInt64BoolDictionary *dict1 =
   1611       [[GPBUInt64BoolDictionary alloc] initWithValues:kValues1
   1612                                               forKeys:kKeys1
   1613                                                 count:GPBARRAYSIZE(kValues1)];
   1614   XCTAssertNotNil(dict1);
   1615   GPBUInt64BoolDictionary *dict1prime =
   1616       [[GPBUInt64BoolDictionary alloc] initWithValues:kValues1
   1617                                               forKeys:kKeys1
   1618                                                 count:GPBARRAYSIZE(kValues1)];
   1619   XCTAssertNotNil(dict1prime);
   1620   GPBUInt64BoolDictionary *dict2 =
   1621       [[GPBUInt64BoolDictionary alloc] initWithValues:kValues2
   1622                                               forKeys:kKeys1
   1623                                                 count:GPBARRAYSIZE(kValues2)];
   1624   XCTAssertNotNil(dict2);
   1625   GPBUInt64BoolDictionary *dict3 =
   1626       [[GPBUInt64BoolDictionary alloc] initWithValues:kValues1
   1627                                               forKeys:kKeys2
   1628                                                 count:GPBARRAYSIZE(kValues1)];
   1629   XCTAssertNotNil(dict3);
   1630   GPBUInt64BoolDictionary *dict4 =
   1631       [[GPBUInt64BoolDictionary 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 uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   1660   const BOOL kValues[] = { YES, YES, NO, NO };
   1661   GPBUInt64BoolDictionary *dict =
   1662       [[GPBUInt64BoolDictionary alloc] initWithValues:kValues
   1663                                               forKeys:kKeys
   1664                                                 count:GPBARRAYSIZE(kValues)];
   1665   XCTAssertNotNil(dict);
   1666 
   1667   GPBUInt64BoolDictionary *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:[GPBUInt64BoolDictionary class]]);
   1674 
   1675   [dict2 release];
   1676   [dict release];
   1677 }
   1678 
   1679 - (void)testDictionaryFromDictionary {
   1680   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   1681   const BOOL kValues[] = { YES, YES, NO, NO };
   1682   GPBUInt64BoolDictionary *dict =
   1683       [[GPBUInt64BoolDictionary alloc] initWithValues:kValues
   1684                                               forKeys:kKeys
   1685                                                 count:GPBARRAYSIZE(kValues)];
   1686   XCTAssertNotNil(dict);
   1687 
   1688   GPBUInt64BoolDictionary *dict2 =
   1689       [GPBUInt64BoolDictionary 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   GPBUInt64BoolDictionary *dict = [GPBUInt64BoolDictionary dictionary];
   1700   XCTAssertNotNil(dict);
   1701 
   1702   XCTAssertEqual(dict.count, 0U);
   1703   [dict setValue:YES forKey:31ULL];
   1704   XCTAssertEqual(dict.count, 1U);
   1705 
   1706   const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL };
   1707   const BOOL kValues[] = { YES, NO, NO };
   1708   GPBUInt64BoolDictionary *dict2 =
   1709       [[GPBUInt64BoolDictionary 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:31ULL value:NULL]);
   1718   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1719   XCTAssertEqual(value, YES);
   1720   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1721   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1722   XCTAssertEqual(value, YES);
   1723   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1724   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1725   XCTAssertEqual(value, NO);
   1726   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1727   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1728   XCTAssertEqual(value, NO);
   1729   [dict2 release];
   1730 }
   1731 
   1732 - (void)testRemove {
   1733   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   1734   const BOOL kValues[] = { YES, YES, NO, NO };
   1735   GPBUInt64BoolDictionary *dict =
   1736       [[GPBUInt64BoolDictionary alloc] initWithValues:kValues
   1737                                        forKeys:kKeys
   1738                                          count:GPBARRAYSIZE(kValues)];
   1739   XCTAssertNotNil(dict);
   1740   XCTAssertEqual(dict.count, 4U);
   1741 
   1742   [dict removeValueForKey:32ULL];
   1743   XCTAssertEqual(dict.count, 3U);
   1744   BOOL value;
   1745   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1746   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1747   XCTAssertEqual(value, YES);
   1748   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1749   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1750   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1751   XCTAssertEqual(value, NO);
   1752   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1753   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1754   XCTAssertEqual(value, NO);
   1755 
   1756   // Remove again does nothing.
   1757   [dict removeValueForKey:32ULL];
   1758   XCTAssertEqual(dict.count, 3U);
   1759   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1760   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1761   XCTAssertEqual(value, YES);
   1762   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1763   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1764   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1765   XCTAssertEqual(value, NO);
   1766   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1767   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1768   XCTAssertEqual(value, NO);
   1769 
   1770   [dict removeValueForKey:34ULL];
   1771   XCTAssertEqual(dict.count, 2U);
   1772   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1773   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1774   XCTAssertEqual(value, YES);
   1775   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1776   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1777   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1778   XCTAssertEqual(value, NO);
   1779   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   1780 
   1781   [dict removeAll];
   1782   XCTAssertEqual(dict.count, 0U);
   1783   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
   1784   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1785   XCTAssertFalse([dict valueForKey:33ULL value:NULL]);
   1786   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   1787   [dict release];
   1788 }
   1789 
   1790 - (void)testInplaceMutation {
   1791   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   1792   const BOOL kValues[] = { YES, YES, NO, NO };
   1793   GPBUInt64BoolDictionary *dict =
   1794       [[GPBUInt64BoolDictionary 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:31ULL value:NULL]);
   1801   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1802   XCTAssertEqual(value, YES);
   1803   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1804   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1805   XCTAssertEqual(value, YES);
   1806   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1807   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1808   XCTAssertEqual(value, NO);
   1809   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1810   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1811   XCTAssertEqual(value, NO);
   1812 
   1813   [dict setValue:NO forKey:31ULL];
   1814   XCTAssertEqual(dict.count, 4U);
   1815   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1816   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1817   XCTAssertEqual(value, NO);
   1818   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1819   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1820   XCTAssertEqual(value, YES);
   1821   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1822   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1823   XCTAssertEqual(value, NO);
   1824   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1825   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1826   XCTAssertEqual(value, NO);
   1827 
   1828   [dict setValue:YES forKey:34ULL];
   1829   XCTAssertEqual(dict.count, 4U);
   1830   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1831   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1832   XCTAssertEqual(value, NO);
   1833   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1834   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1835   XCTAssertEqual(value, YES);
   1836   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1837   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1838   XCTAssertEqual(value, NO);
   1839   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1840   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1841   XCTAssertEqual(value, YES);
   1842 
   1843   const uint64_t kKeys2[] = { 32ULL, 33ULL };
   1844   const BOOL kValues2[] = { NO, YES };
   1845   GPBUInt64BoolDictionary *dict2 =
   1846       [[GPBUInt64BoolDictionary 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:31ULL value:NULL]);
   1853   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1854   XCTAssertEqual(value, NO);
   1855   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1856   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1857   XCTAssertEqual(value, NO);
   1858   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1859   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1860   XCTAssertEqual(value, YES);
   1861   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   1862   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   1863   XCTAssertEqual(value, YES);
   1864 
   1865   [dict2 release];
   1866   [dict release];
   1867 }
   1868 
   1869 @end
   1870 
   1871 #pragma mark - UInt64 -> Float
   1872 
   1873 @interface GPBUInt64FloatDictionaryTests : XCTestCase
   1874 @end
   1875 
   1876 @implementation GPBUInt64FloatDictionaryTests
   1877 
   1878 - (void)testEmpty {
   1879   GPBUInt64FloatDictionary *dict = [[GPBUInt64FloatDictionary alloc] init];
   1880   XCTAssertNotNil(dict);
   1881   XCTAssertEqual(dict.count, 0U);
   1882   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
   1883   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, float aValue, BOOL *stop) {
   1884     #pragma unused(aKey, aValue, stop)
   1885     XCTFail(@"Shouldn't get here!");
   1886   }];
   1887   [dict release];
   1888 }
   1889 
   1890 - (void)testOne {
   1891   GPBUInt64FloatDictionary *dict = [GPBUInt64FloatDictionary dictionaryWithValue:500.f forKey:31ULL];
   1892   XCTAssertNotNil(dict);
   1893   XCTAssertEqual(dict.count, 1U);
   1894   float value;
   1895   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   1896   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1897   XCTAssertEqual(value, 500.f);
   1898   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   1899   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, float aValue, BOOL *stop) {
   1900     XCTAssertEqual(aKey, 31ULL);
   1901     XCTAssertEqual(aValue, 500.f);
   1902     XCTAssertNotEqual(stop, NULL);
   1903   }];
   1904 }
   1905 
   1906 - (void)testBasics {
   1907   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL };
   1908   const float kValues[] = { 500.f, 501.f, 502.f };
   1909   GPBUInt64FloatDictionary *dict =
   1910       [[GPBUInt64FloatDictionary 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:31ULL value:NULL]);
   1917   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   1918   XCTAssertEqual(value, 500.f);
   1919   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   1920   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   1921   XCTAssertEqual(value, 501.f);
   1922   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   1923   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   1924   XCTAssertEqual(value, 502.f);
   1925   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   1926 
   1927   __block NSUInteger idx = 0;
   1928   uint64_t *seenKeys = malloc(3 * sizeof(uint64_t));
   1929   float *seenValues = malloc(3 * sizeof(float));
   1930   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, float aValue, BOOL *stop) {
   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:^(uint64_t aKey, float aValue, BOOL *stop) {
   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 uint64_t kKeys1[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   1963   const uint64_t kKeys2[] = { 32ULL, 31ULL, 34ULL };
   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   GPBUInt64FloatDictionary *dict1 =
   1968       [[GPBUInt64FloatDictionary alloc] initWithValues:kValues1
   1969                                                forKeys:kKeys1
   1970                                                  count:GPBARRAYSIZE(kValues1)];
   1971   XCTAssertNotNil(dict1);
   1972   GPBUInt64FloatDictionary *dict1prime =
   1973       [[GPBUInt64FloatDictionary alloc] initWithValues:kValues1
   1974                                                forKeys:kKeys1
   1975                                                  count:GPBARRAYSIZE(kValues1)];
   1976   XCTAssertNotNil(dict1prime);
   1977   GPBUInt64FloatDictionary *dict2 =
   1978       [[GPBUInt64FloatDictionary alloc] initWithValues:kValues2
   1979                                                forKeys:kKeys1
   1980                                                  count:GPBARRAYSIZE(kValues2)];
   1981   XCTAssertNotNil(dict2);
   1982   GPBUInt64FloatDictionary *dict3 =
   1983       [[GPBUInt64FloatDictionary alloc] initWithValues:kValues1
   1984                                                forKeys:kKeys2
   1985                                                  count:GPBARRAYSIZE(kValues1)];
   1986   XCTAssertNotNil(dict3);
   1987   GPBUInt64FloatDictionary *dict4 =
   1988       [[GPBUInt64FloatDictionary 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 uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2017   const float kValues[] = { 500.f, 501.f, 502.f, 503.f };
   2018   GPBUInt64FloatDictionary *dict =
   2019       [[GPBUInt64FloatDictionary alloc] initWithValues:kValues
   2020                                                forKeys:kKeys
   2021                                                  count:GPBARRAYSIZE(kValues)];
   2022   XCTAssertNotNil(dict);
   2023 
   2024   GPBUInt64FloatDictionary *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:[GPBUInt64FloatDictionary class]]);
   2031 
   2032   [dict2 release];
   2033   [dict release];
   2034 }
   2035 
   2036 - (void)testDictionaryFromDictionary {
   2037   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2038   const float kValues[] = { 500.f, 501.f, 502.f, 503.f };
   2039   GPBUInt64FloatDictionary *dict =
   2040       [[GPBUInt64FloatDictionary alloc] initWithValues:kValues
   2041                                                forKeys:kKeys
   2042                                                  count:GPBARRAYSIZE(kValues)];
   2043   XCTAssertNotNil(dict);
   2044 
   2045   GPBUInt64FloatDictionary *dict2 =
   2046       [GPBUInt64FloatDictionary 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   GPBUInt64FloatDictionary *dict = [GPBUInt64FloatDictionary dictionary];
   2057   XCTAssertNotNil(dict);
   2058 
   2059   XCTAssertEqual(dict.count, 0U);
   2060   [dict setValue:500.f forKey:31ULL];
   2061   XCTAssertEqual(dict.count, 1U);
   2062 
   2063   const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL };
   2064   const float kValues[] = { 501.f, 502.f, 503.f };
   2065   GPBUInt64FloatDictionary *dict2 =
   2066       [[GPBUInt64FloatDictionary 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:31ULL value:NULL]);
   2075   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2076   XCTAssertEqual(value, 500.f);
   2077   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2078   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2079   XCTAssertEqual(value, 501.f);
   2080   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2081   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2082   XCTAssertEqual(value, 502.f);
   2083   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2084   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2085   XCTAssertEqual(value, 503.f);
   2086   [dict2 release];
   2087 }
   2088 
   2089 - (void)testRemove {
   2090   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2091   const float kValues[] = { 500.f, 501.f, 502.f, 503.f };
   2092   GPBUInt64FloatDictionary *dict =
   2093       [[GPBUInt64FloatDictionary alloc] initWithValues:kValues
   2094                                         forKeys:kKeys
   2095                                           count:GPBARRAYSIZE(kValues)];
   2096   XCTAssertNotNil(dict);
   2097   XCTAssertEqual(dict.count, 4U);
   2098 
   2099   [dict removeValueForKey:32ULL];
   2100   XCTAssertEqual(dict.count, 3U);
   2101   float value;
   2102   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2103   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2104   XCTAssertEqual(value, 500.f);
   2105   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2106   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2107   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2108   XCTAssertEqual(value, 502.f);
   2109   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2110   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2111   XCTAssertEqual(value, 503.f);
   2112 
   2113   // Remove again does nothing.
   2114   [dict removeValueForKey:32ULL];
   2115   XCTAssertEqual(dict.count, 3U);
   2116   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2117   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2118   XCTAssertEqual(value, 500.f);
   2119   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2120   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2121   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2122   XCTAssertEqual(value, 502.f);
   2123   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2124   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2125   XCTAssertEqual(value, 503.f);
   2126 
   2127   [dict removeValueForKey:34ULL];
   2128   XCTAssertEqual(dict.count, 2U);
   2129   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2130   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2131   XCTAssertEqual(value, 500.f);
   2132   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2133   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2134   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2135   XCTAssertEqual(value, 502.f);
   2136   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   2137 
   2138   [dict removeAll];
   2139   XCTAssertEqual(dict.count, 0U);
   2140   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
   2141   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2142   XCTAssertFalse([dict valueForKey:33ULL value:NULL]);
   2143   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   2144   [dict release];
   2145 }
   2146 
   2147 - (void)testInplaceMutation {
   2148   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2149   const float kValues[] = { 500.f, 501.f, 502.f, 503.f };
   2150   GPBUInt64FloatDictionary *dict =
   2151       [[GPBUInt64FloatDictionary 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:31ULL value:NULL]);
   2158   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2159   XCTAssertEqual(value, 500.f);
   2160   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2161   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2162   XCTAssertEqual(value, 501.f);
   2163   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2164   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2165   XCTAssertEqual(value, 502.f);
   2166   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2167   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2168   XCTAssertEqual(value, 503.f);
   2169 
   2170   [dict setValue:503.f forKey:31ULL];
   2171   XCTAssertEqual(dict.count, 4U);
   2172   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2173   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2174   XCTAssertEqual(value, 503.f);
   2175   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2176   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2177   XCTAssertEqual(value, 501.f);
   2178   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2179   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2180   XCTAssertEqual(value, 502.f);
   2181   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2182   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2183   XCTAssertEqual(value, 503.f);
   2184 
   2185   [dict setValue:501.f forKey:34ULL];
   2186   XCTAssertEqual(dict.count, 4U);
   2187   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2188   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2189   XCTAssertEqual(value, 503.f);
   2190   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2191   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2192   XCTAssertEqual(value, 501.f);
   2193   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2194   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2195   XCTAssertEqual(value, 502.f);
   2196   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2197   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2198   XCTAssertEqual(value, 501.f);
   2199 
   2200   const uint64_t kKeys2[] = { 32ULL, 33ULL };
   2201   const float kValues2[] = { 502.f, 500.f };
   2202   GPBUInt64FloatDictionary *dict2 =
   2203       [[GPBUInt64FloatDictionary 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:31ULL value:NULL]);
   2210   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2211   XCTAssertEqual(value, 503.f);
   2212   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2213   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2214   XCTAssertEqual(value, 502.f);
   2215   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2216   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2217   XCTAssertEqual(value, 500.f);
   2218   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2219   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2220   XCTAssertEqual(value, 501.f);
   2221 
   2222   [dict2 release];
   2223   [dict release];
   2224 }
   2225 
   2226 @end
   2227 
   2228 #pragma mark - UInt64 -> Double
   2229 
   2230 @interface GPBUInt64DoubleDictionaryTests : XCTestCase
   2231 @end
   2232 
   2233 @implementation GPBUInt64DoubleDictionaryTests
   2234 
   2235 - (void)testEmpty {
   2236   GPBUInt64DoubleDictionary *dict = [[GPBUInt64DoubleDictionary alloc] init];
   2237   XCTAssertNotNil(dict);
   2238   XCTAssertEqual(dict.count, 0U);
   2239   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
   2240   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, double aValue, BOOL *stop) {
   2241     #pragma unused(aKey, aValue, stop)
   2242     XCTFail(@"Shouldn't get here!");
   2243   }];
   2244   [dict release];
   2245 }
   2246 
   2247 - (void)testOne {
   2248   GPBUInt64DoubleDictionary *dict = [GPBUInt64DoubleDictionary dictionaryWithValue:600. forKey:31ULL];
   2249   XCTAssertNotNil(dict);
   2250   XCTAssertEqual(dict.count, 1U);
   2251   double value;
   2252   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2253   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2254   XCTAssertEqual(value, 600.);
   2255   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2256   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, double aValue, BOOL *stop) {
   2257     XCTAssertEqual(aKey, 31ULL);
   2258     XCTAssertEqual(aValue, 600.);
   2259     XCTAssertNotEqual(stop, NULL);
   2260   }];
   2261 }
   2262 
   2263 - (void)testBasics {
   2264   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL };
   2265   const double kValues[] = { 600., 601., 602. };
   2266   GPBUInt64DoubleDictionary *dict =
   2267       [[GPBUInt64DoubleDictionary 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:31ULL value:NULL]);
   2274   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2275   XCTAssertEqual(value, 600.);
   2276   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2277   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2278   XCTAssertEqual(value, 601.);
   2279   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2280   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2281   XCTAssertEqual(value, 602.);
   2282   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   2283 
   2284   __block NSUInteger idx = 0;
   2285   uint64_t *seenKeys = malloc(3 * sizeof(uint64_t));
   2286   double *seenValues = malloc(3 * sizeof(double));
   2287   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, double aValue, BOOL *stop) {
   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:^(uint64_t aKey, double aValue, BOOL *stop) {
   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 uint64_t kKeys1[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2320   const uint64_t kKeys2[] = { 32ULL, 31ULL, 34ULL };
   2321   const double kValues1[] = { 600., 601., 602. };
   2322   const double kValues2[] = { 600., 603., 602. };
   2323   const double kValues3[] = { 600., 601., 602., 603. };
   2324   GPBUInt64DoubleDictionary *dict1 =
   2325       [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues1
   2326                                                 forKeys:kKeys1
   2327                                                   count:GPBARRAYSIZE(kValues1)];
   2328   XCTAssertNotNil(dict1);
   2329   GPBUInt64DoubleDictionary *dict1prime =
   2330       [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues1
   2331                                                 forKeys:kKeys1
   2332                                                   count:GPBARRAYSIZE(kValues1)];
   2333   XCTAssertNotNil(dict1prime);
   2334   GPBUInt64DoubleDictionary *dict2 =
   2335       [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues2
   2336                                                 forKeys:kKeys1
   2337                                                   count:GPBARRAYSIZE(kValues2)];
   2338   XCTAssertNotNil(dict2);
   2339   GPBUInt64DoubleDictionary *dict3 =
   2340       [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues1
   2341                                                 forKeys:kKeys2
   2342                                                   count:GPBARRAYSIZE(kValues1)];
   2343   XCTAssertNotNil(dict3);
   2344   GPBUInt64DoubleDictionary *dict4 =
   2345       [[GPBUInt64DoubleDictionary 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 uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2374   const double kValues[] = { 600., 601., 602., 603. };
   2375   GPBUInt64DoubleDictionary *dict =
   2376       [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues
   2377                                                 forKeys:kKeys
   2378                                                   count:GPBARRAYSIZE(kValues)];
   2379   XCTAssertNotNil(dict);
   2380 
   2381   GPBUInt64DoubleDictionary *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:[GPBUInt64DoubleDictionary class]]);
   2388 
   2389   [dict2 release];
   2390   [dict release];
   2391 }
   2392 
   2393 - (void)testDictionaryFromDictionary {
   2394   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2395   const double kValues[] = { 600., 601., 602., 603. };
   2396   GPBUInt64DoubleDictionary *dict =
   2397       [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues
   2398                                                 forKeys:kKeys
   2399                                                   count:GPBARRAYSIZE(kValues)];
   2400   XCTAssertNotNil(dict);
   2401 
   2402   GPBUInt64DoubleDictionary *dict2 =
   2403       [GPBUInt64DoubleDictionary 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   GPBUInt64DoubleDictionary *dict = [GPBUInt64DoubleDictionary dictionary];
   2414   XCTAssertNotNil(dict);
   2415 
   2416   XCTAssertEqual(dict.count, 0U);
   2417   [dict setValue:600. forKey:31ULL];
   2418   XCTAssertEqual(dict.count, 1U);
   2419 
   2420   const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL };
   2421   const double kValues[] = { 601., 602., 603. };
   2422   GPBUInt64DoubleDictionary *dict2 =
   2423       [[GPBUInt64DoubleDictionary 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:31ULL value:NULL]);
   2432   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2433   XCTAssertEqual(value, 600.);
   2434   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2435   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2436   XCTAssertEqual(value, 601.);
   2437   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2438   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2439   XCTAssertEqual(value, 602.);
   2440   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2441   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2442   XCTAssertEqual(value, 603.);
   2443   [dict2 release];
   2444 }
   2445 
   2446 - (void)testRemove {
   2447   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2448   const double kValues[] = { 600., 601., 602., 603. };
   2449   GPBUInt64DoubleDictionary *dict =
   2450       [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues
   2451                                          forKeys:kKeys
   2452                                            count:GPBARRAYSIZE(kValues)];
   2453   XCTAssertNotNil(dict);
   2454   XCTAssertEqual(dict.count, 4U);
   2455 
   2456   [dict removeValueForKey:32ULL];
   2457   XCTAssertEqual(dict.count, 3U);
   2458   double value;
   2459   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2460   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2461   XCTAssertEqual(value, 600.);
   2462   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2463   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2464   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2465   XCTAssertEqual(value, 602.);
   2466   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2467   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2468   XCTAssertEqual(value, 603.);
   2469 
   2470   // Remove again does nothing.
   2471   [dict removeValueForKey:32ULL];
   2472   XCTAssertEqual(dict.count, 3U);
   2473   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2474   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2475   XCTAssertEqual(value, 600.);
   2476   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2477   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2478   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2479   XCTAssertEqual(value, 602.);
   2480   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2481   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2482   XCTAssertEqual(value, 603.);
   2483 
   2484   [dict removeValueForKey:34ULL];
   2485   XCTAssertEqual(dict.count, 2U);
   2486   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2487   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2488   XCTAssertEqual(value, 600.);
   2489   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2490   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2491   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2492   XCTAssertEqual(value, 602.);
   2493   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   2494 
   2495   [dict removeAll];
   2496   XCTAssertEqual(dict.count, 0U);
   2497   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
   2498   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2499   XCTAssertFalse([dict valueForKey:33ULL value:NULL]);
   2500   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   2501   [dict release];
   2502 }
   2503 
   2504 - (void)testInplaceMutation {
   2505   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2506   const double kValues[] = { 600., 601., 602., 603. };
   2507   GPBUInt64DoubleDictionary *dict =
   2508       [[GPBUInt64DoubleDictionary 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:31ULL value:NULL]);
   2515   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2516   XCTAssertEqual(value, 600.);
   2517   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2518   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2519   XCTAssertEqual(value, 601.);
   2520   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2521   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2522   XCTAssertEqual(value, 602.);
   2523   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2524   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2525   XCTAssertEqual(value, 603.);
   2526 
   2527   [dict setValue:603. forKey:31ULL];
   2528   XCTAssertEqual(dict.count, 4U);
   2529   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2530   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2531   XCTAssertEqual(value, 603.);
   2532   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2533   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2534   XCTAssertEqual(value, 601.);
   2535   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2536   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2537   XCTAssertEqual(value, 602.);
   2538   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2539   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2540   XCTAssertEqual(value, 603.);
   2541 
   2542   [dict setValue:601. forKey:34ULL];
   2543   XCTAssertEqual(dict.count, 4U);
   2544   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2545   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2546   XCTAssertEqual(value, 603.);
   2547   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2548   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2549   XCTAssertEqual(value, 601.);
   2550   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2551   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2552   XCTAssertEqual(value, 602.);
   2553   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2554   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2555   XCTAssertEqual(value, 601.);
   2556 
   2557   const uint64_t kKeys2[] = { 32ULL, 33ULL };
   2558   const double kValues2[] = { 602., 600. };
   2559   GPBUInt64DoubleDictionary *dict2 =
   2560       [[GPBUInt64DoubleDictionary 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:31ULL value:NULL]);
   2567   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2568   XCTAssertEqual(value, 603.);
   2569   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2570   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2571   XCTAssertEqual(value, 602.);
   2572   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2573   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2574   XCTAssertEqual(value, 600.);
   2575   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2576   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2577   XCTAssertEqual(value, 601.);
   2578 
   2579   [dict2 release];
   2580   [dict release];
   2581 }
   2582 
   2583 @end
   2584 
   2585 #pragma mark - UInt64 -> Enum
   2586 
   2587 @interface GPBUInt64EnumDictionaryTests : XCTestCase
   2588 @end
   2589 
   2590 @implementation GPBUInt64EnumDictionaryTests
   2591 
   2592 - (void)testEmpty {
   2593   GPBUInt64EnumDictionary *dict = [[GPBUInt64EnumDictionary alloc] init];
   2594   XCTAssertNotNil(dict);
   2595   XCTAssertEqual(dict.count, 0U);
   2596   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
   2597   [dict enumerateKeysAndValuesUsingBlock:^(uint64_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   GPBUInt64EnumDictionary *dict = [GPBUInt64EnumDictionary dictionaryWithValue:700 forKey:31ULL];
   2606   XCTAssertNotNil(dict);
   2607   XCTAssertEqual(dict.count, 1U);
   2608   int32_t value;
   2609   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2610   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2611   XCTAssertEqual(value, 700);
   2612   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2613   [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) {
   2614     XCTAssertEqual(aKey, 31ULL);
   2615     XCTAssertEqual(aValue, 700);
   2616     XCTAssertNotEqual(stop, NULL);
   2617   }];
   2618 }
   2619 
   2620 - (void)testBasics {
   2621   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL };
   2622   const int32_t kValues[] = { 700, 701, 702 };
   2623   GPBUInt64EnumDictionary *dict =
   2624       [[GPBUInt64EnumDictionary 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:31ULL value:NULL]);
   2631   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2632   XCTAssertEqual(value, 700);
   2633   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2634   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2635   XCTAssertEqual(value, 701);
   2636   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2637   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2638   XCTAssertEqual(value, 702);
   2639   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   2640 
   2641   __block NSUInteger idx = 0;
   2642   uint64_t *seenKeys = malloc(3 * sizeof(uint64_t));
   2643   int32_t *seenValues = malloc(3 * sizeof(int32_t));
   2644   [dict enumerateKeysAndValuesUsingBlock:^(uint64_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:^(uint64_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 uint64_t kKeys1[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2677   const uint64_t kKeys2[] = { 32ULL, 31ULL, 34ULL };
   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   GPBUInt64EnumDictionary *dict1 =
   2682       [[GPBUInt64EnumDictionary alloc] initWithValues:kValues1
   2683                                               forKeys:kKeys1
   2684                                                 count:GPBARRAYSIZE(kValues1)];
   2685   XCTAssertNotNil(dict1);
   2686   GPBUInt64EnumDictionary *dict1prime =
   2687       [[GPBUInt64EnumDictionary alloc] initWithValues:kValues1
   2688                                               forKeys:kKeys1
   2689                                                 count:GPBARRAYSIZE(kValues1)];
   2690   XCTAssertNotNil(dict1prime);
   2691   GPBUInt64EnumDictionary *dict2 =
   2692       [[GPBUInt64EnumDictionary alloc] initWithValues:kValues2
   2693                                               forKeys:kKeys1
   2694                                                 count:GPBARRAYSIZE(kValues2)];
   2695   XCTAssertNotNil(dict2);
   2696   GPBUInt64EnumDictionary *dict3 =
   2697       [[GPBUInt64EnumDictionary alloc] initWithValues:kValues1
   2698                                               forKeys:kKeys2
   2699                                                 count:GPBARRAYSIZE(kValues1)];
   2700   XCTAssertNotNil(dict3);
   2701   GPBUInt64EnumDictionary *dict4 =
   2702       [[GPBUInt64EnumDictionary 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 uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2731   const int32_t kValues[] = { 700, 701, 702, 703 };
   2732   GPBUInt64EnumDictionary *dict =
   2733       [[GPBUInt64EnumDictionary alloc] initWithValues:kValues
   2734                                               forKeys:kKeys
   2735                                                 count:GPBARRAYSIZE(kValues)];
   2736   XCTAssertNotNil(dict);
   2737 
   2738   GPBUInt64EnumDictionary *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:[GPBUInt64EnumDictionary class]]);
   2745 
   2746   [dict2 release];
   2747   [dict release];
   2748 }
   2749 
   2750 - (void)testDictionaryFromDictionary {
   2751   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2752   const int32_t kValues[] = { 700, 701, 702, 703 };
   2753   GPBUInt64EnumDictionary *dict =
   2754       [[GPBUInt64EnumDictionary alloc] initWithValues:kValues
   2755                                               forKeys:kKeys
   2756                                                 count:GPBARRAYSIZE(kValues)];
   2757   XCTAssertNotNil(dict);
   2758 
   2759   GPBUInt64EnumDictionary *dict2 =
   2760       [GPBUInt64EnumDictionary 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   GPBUInt64EnumDictionary *dict = [GPBUInt64EnumDictionary dictionary];
   2771   XCTAssertNotNil(dict);
   2772 
   2773   XCTAssertEqual(dict.count, 0U);
   2774   [dict setValue:700 forKey:31ULL];
   2775   XCTAssertEqual(dict.count, 1U);
   2776 
   2777   const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL };
   2778   const int32_t kValues[] = { 701, 702, 703 };
   2779   GPBUInt64EnumDictionary *dict2 =
   2780       [[GPBUInt64EnumDictionary 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:31ULL value:NULL]);
   2789   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2790   XCTAssertEqual(value, 700);
   2791   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2792   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2793   XCTAssertEqual(value, 701);
   2794   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2795   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2796   XCTAssertEqual(value, 702);
   2797   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2798   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2799   XCTAssertEqual(value, 703);
   2800   [dict2 release];
   2801 }
   2802 
   2803 - (void)testRemove {
   2804   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2805   const int32_t kValues[] = { 700, 701, 702, 703 };
   2806   GPBUInt64EnumDictionary *dict =
   2807       [[GPBUInt64EnumDictionary alloc] initWithValues:kValues
   2808                                        forKeys:kKeys
   2809                                          count:GPBARRAYSIZE(kValues)];
   2810   XCTAssertNotNil(dict);
   2811   XCTAssertEqual(dict.count, 4U);
   2812 
   2813   [dict removeValueForKey:32ULL];
   2814   XCTAssertEqual(dict.count, 3U);
   2815   int32_t value;
   2816   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2817   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2818   XCTAssertEqual(value, 700);
   2819   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2820   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2821   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2822   XCTAssertEqual(value, 702);
   2823   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2824   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2825   XCTAssertEqual(value, 703);
   2826 
   2827   // Remove again does nothing.
   2828   [dict removeValueForKey:32ULL];
   2829   XCTAssertEqual(dict.count, 3U);
   2830   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2831   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2832   XCTAssertEqual(value, 700);
   2833   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2834   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2835   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2836   XCTAssertEqual(value, 702);
   2837   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2838   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2839   XCTAssertEqual(value, 703);
   2840 
   2841   [dict removeValueForKey:34ULL];
   2842   XCTAssertEqual(dict.count, 2U);
   2843   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2844   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2845   XCTAssertEqual(value, 700);
   2846   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2847   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2848   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2849   XCTAssertEqual(value, 702);
   2850   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   2851 
   2852   [dict removeAll];
   2853   XCTAssertEqual(dict.count, 0U);
   2854   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
   2855   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   2856   XCTAssertFalse([dict valueForKey:33ULL value:NULL]);
   2857   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   2858   [dict release];
   2859 }
   2860 
   2861 - (void)testInplaceMutation {
   2862   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   2863   const int32_t kValues[] = { 700, 701, 702, 703 };
   2864   GPBUInt64EnumDictionary *dict =
   2865       [[GPBUInt64EnumDictionary 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:31ULL value:NULL]);
   2872   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2873   XCTAssertEqual(value, 700);
   2874   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2875   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2876   XCTAssertEqual(value, 701);
   2877   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2878   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2879   XCTAssertEqual(value, 702);
   2880   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2881   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2882   XCTAssertEqual(value, 703);
   2883 
   2884   [dict setValue:703 forKey:31ULL];
   2885   XCTAssertEqual(dict.count, 4U);
   2886   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2887   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2888   XCTAssertEqual(value, 703);
   2889   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2890   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2891   XCTAssertEqual(value, 701);
   2892   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2893   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2894   XCTAssertEqual(value, 702);
   2895   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2896   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2897   XCTAssertEqual(value, 703);
   2898 
   2899   [dict setValue:701 forKey:34ULL];
   2900   XCTAssertEqual(dict.count, 4U);
   2901   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   2902   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2903   XCTAssertEqual(value, 703);
   2904   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2905   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2906   XCTAssertEqual(value, 701);
   2907   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2908   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2909   XCTAssertEqual(value, 702);
   2910   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2911   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2912   XCTAssertEqual(value, 701);
   2913 
   2914   const uint64_t kKeys2[] = { 32ULL, 33ULL };
   2915   const int32_t kValues2[] = { 702, 700 };
   2916   GPBUInt64EnumDictionary *dict2 =
   2917       [[GPBUInt64EnumDictionary 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:31ULL value:NULL]);
   2924   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   2925   XCTAssertEqual(value, 703);
   2926   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2927   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2928   XCTAssertEqual(value, 702);
   2929   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   2930   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   2931   XCTAssertEqual(value, 700);
   2932   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   2933   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   2934   XCTAssertEqual(value, 701);
   2935 
   2936   [dict2 release];
   2937   [dict release];
   2938 }
   2939 
   2940 @end
   2941 
   2942 #pragma mark - UInt64 -> Enum (Unknown Enums)
   2943 
   2944 @interface GPBUInt64EnumDictionaryUnknownEnumTests : XCTestCase
   2945 @end
   2946 
   2947 @implementation GPBUInt64EnumDictionaryUnknownEnumTests
   2948 
   2949 - (void)testRawBasics {
   2950   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL };
   2951   const int32_t kValues[] = { 700, 801, 702 };
   2952   GPBUInt64EnumDictionary *dict =
   2953       [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsValidValue
   2954                                                         rawValues:kValues
   2955                                                           forKeys:kKeys
   2956                                                             count:GPBARRAYSIZE(kValues)];
   2957   XCTAssertNotNil(dict);
   2958   XCTAssertEqual(dict.count, 3U);
   2959   XCTAssertTrue(dict.validationFunc == TestingEnum_IsValidValue);  // Pointer comparison
   2960   int32_t value;
   2961   XCTAssertTrue([dict valueForKey:31ULL rawValue:NULL]);
   2962   XCTAssertTrue([dict valueForKey:31ULL rawValue:&value]);
   2963   XCTAssertEqual(value, 700);
   2964   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   2965   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   2966   XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue);
   2967   XCTAssertTrue([dict valueForKey:32ULL rawValue:NULL]);
   2968   XCTAssertTrue([dict valueForKey:32ULL rawValue:&value]);
   2969   XCTAssertEqual(value, 801);
   2970   XCTAssertTrue([dict valueForKey:33ULL rawValue:NULL]);
   2971   XCTAssertTrue([dict valueForKey:33ULL rawValue:&value]);
   2972   XCTAssertEqual(value, 702);
   2973   XCTAssertFalse([dict valueForKey:34ULL rawValue:NULL]);
   2974 
   2975   __block NSUInteger idx = 0;
   2976   uint64_t *seenKeys = malloc(3 * sizeof(uint64_t));
   2977   int32_t *seenValues = malloc(3 * sizeof(int32_t));
   2978   [dict enumerateKeysAndValuesUsingBlock:^(uint64_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:^(uint64_t aKey, int32_t aValue, BOOL *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:^(uint64_t aKey, int32_t aValue, BOOL *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 uint64_t kKeys1[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   3033   const uint64_t kKeys2[] = { 32ULL, 31ULL, 34ULL };
   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   GPBUInt64EnumDictionary *dict1 =
   3038       [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsValidValue
   3039                                                         rawValues:kValues1
   3040                                                           forKeys:kKeys1
   3041                                                             count:GPBARRAYSIZE(kValues1)];
   3042   XCTAssertNotNil(dict1);
   3043   GPBUInt64EnumDictionary *dict1prime =
   3044       [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsValidValue
   3045                                                         rawValues:kValues1
   3046                                                           forKeys:kKeys1
   3047                                                             count:GPBARRAYSIZE(kValues1)];
   3048   XCTAssertNotNil(dict1prime);
   3049   GPBUInt64EnumDictionary *dict2 =
   3050       [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsValidValue
   3051                                                         rawValues:kValues2
   3052                                                           forKeys:kKeys1
   3053                                                             count:GPBARRAYSIZE(kValues2)];
   3054   XCTAssertNotNil(dict2);
   3055   GPBUInt64EnumDictionary *dict3 =
   3056       [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsValidValue
   3057                                                         rawValues:kValues1
   3058                                                           forKeys:kKeys2
   3059                                                             count:GPBARRAYSIZE(kValues1)];
   3060   XCTAssertNotNil(dict3);
   3061   GPBUInt64EnumDictionary *dict4 =
   3062       [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsValidValue
   3063                                                         rawValues:kValues3
   3064                                                           forKeys:kKeys1
   3065                                                             count:GPBARRAYSIZE(kValues3)];
   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 uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   3092   const int32_t kValues[] = { 700, 801, 702, 803 };  // Unknown
   3093   GPBUInt64EnumDictionary *dict =
   3094       [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsValidValue
   3095                                                         rawValues:kValues
   3096                                                           forKeys:kKeys
   3097                                                             count:GPBARRAYSIZE(kValues)];
   3098   XCTAssertNotNil(dict);
   3099 
   3100   GPBUInt64EnumDictionary *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 comparison
   3106   XCTAssertEqualObjects(dict, dict2);
   3107 
   3108   [dict2 release];
   3109   [dict release];
   3110 }
   3111 
   3112 - (void)testDictionaryFromDictionary {
   3113   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   3114   const int32_t kValues[] = { 700, 801, 702, 803 };  // Unknowns
   3115   GPBUInt64EnumDictionary *dict =
   3116       [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsValidValue
   3117                                                         rawValues:kValues
   3118                                                           forKeys:kKeys
   3119                                                             count:GPBARRAYSIZE(kValues)];
   3120   XCTAssertNotNil(dict);
   3121 
   3122   GPBUInt64EnumDictionary *dict2 =
   3123       [GPBUInt64EnumDictionary 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 comparison
   3130   [dict release];
   3131 }
   3132 
   3133 - (void)testUnknownAdds {
   3134   GPBUInt64EnumDictionary *dict =
   3135     [GPBUInt64EnumDictionary dictionaryWithValidationFunction:TestingEnum_IsValidValue];
   3136   XCTAssertNotNil(dict);
   3137 
   3138   XCTAssertEqual(dict.count, 0U);
   3139   XCTAssertThrowsSpecificNamed([dict setValue:801 forKey:32ULL],  // Unknown
   3140                                NSException, NSInvalidArgumentException);
   3141   XCTAssertEqual(dict.count, 0U);
   3142   [dict setRawValue:801 forKey:32ULL];  // Unknown
   3143   XCTAssertEqual(dict.count, 1U);
   3144 
   3145   const uint64_t kKeys[] = { 31ULL, 33ULL, 34ULL };
   3146   const int32_t kValues[] = { 700, 702, 803 };  // Unknown
   3147   GPBUInt64EnumDictionary *dict2 =
   3148       [[GPBUInt64EnumDictionary 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:31ULL value:NULL]);
   3157   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   3158   XCTAssertEqual(value, 700);
   3159   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   3160   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   3161   XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue);
   3162   XCTAssertTrue([dict valueForKey:32ULL rawValue:NULL]);
   3163   XCTAssertTrue([dict valueForKey:32ULL rawValue:&value]);
   3164   XCTAssertEqual(value, 801);
   3165   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   3166   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   3167   XCTAssertEqual(value, 702);
   3168   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   3169   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   3170   XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue);
   3171   XCTAssertTrue([dict valueForKey:34ULL rawValue:NULL]);
   3172   XCTAssertTrue([dict valueForKey:34ULL rawValue:&value]);
   3173   XCTAssertEqual(value, 803);
   3174   [dict2 release];
   3175 }
   3176 
   3177 - (void)testUnknownRemove {
   3178   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   3179   const int32_t kValues[] = { 700, 801, 702, 803 };  // Unknowns
   3180   GPBUInt64EnumDictionary *dict =
   3181       [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsValidValue
   3182                                                         rawValues:kValues
   3183                                                           forKeys:kKeys
   3184                                                             count:GPBARRAYSIZE(kValues)];
   3185   XCTAssertNotNil(dict);
   3186   XCTAssertEqual(dict.count, 4U);
   3187 
   3188   [dict removeValueForKey:32ULL];
   3189   XCTAssertEqual(dict.count, 3U);
   3190   int32_t value;
   3191   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   3192   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   3193   XCTAssertEqual(value, 700);
   3194   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   3195   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   3196   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   3197   XCTAssertEqual(value, 702);
   3198   XCTAssertTrue([dict valueForKey:34ULL rawValue:NULL]);
   3199   XCTAssertTrue([dict valueForKey:34ULL rawValue:&value]);
   3200   XCTAssertEqual(value, 803);
   3201 
   3202   // Remove again does nothing.
   3203   [dict removeValueForKey:32ULL];
   3204   XCTAssertEqual(dict.count, 3U);
   3205   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   3206   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   3207   XCTAssertEqual(value, 700);
   3208   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   3209   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   3210   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   3211   XCTAssertEqual(value, 702);
   3212   XCTAssertTrue([dict valueForKey:34ULL rawValue:NULL]);
   3213   XCTAssertTrue([dict valueForKey:34ULL rawValue:&value]);
   3214   XCTAssertEqual(value, 803);
   3215 
   3216   [dict removeValueForKey:34ULL];
   3217   XCTAssertEqual(dict.count, 2U);
   3218   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   3219   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   3220   XCTAssertEqual(value, 700);
   3221   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   3222   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   3223   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   3224   XCTAssertEqual(value, 702);
   3225   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   3226 
   3227   [dict removeAll];
   3228   XCTAssertEqual(dict.count, 0U);
   3229   XCTAssertFalse([dict valueForKey:31ULL value:NULL]);
   3230   XCTAssertFalse([dict valueForKey:32ULL value:NULL]);
   3231   XCTAssertFalse([dict valueForKey:33ULL value:NULL]);
   3232   XCTAssertFalse([dict valueForKey:34ULL value:NULL]);
   3233   [dict release];
   3234 }
   3235 
   3236 - (void)testInplaceMutationUnknowns {
   3237   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   3238   const int32_t kValues[] = { 700, 801, 702, 803 };  // Unknowns
   3239   GPBUInt64EnumDictionary *dict =
   3240       [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsValidValue
   3241                                                         rawValues:kValues
   3242                                                           forKeys:kKeys
   3243                                                             count:GPBARRAYSIZE(kValues)];
   3244   XCTAssertNotNil(dict);
   3245   XCTAssertEqual(dict.count, 4U);
   3246   int32_t value;
   3247   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   3248   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   3249   XCTAssertEqual(value, 700);
   3250   XCTAssertTrue([dict valueForKey:32ULL rawValue:NULL]);
   3251   XCTAssertTrue([dict valueForKey:32ULL rawValue:&value]);
   3252   XCTAssertEqual(value, 801);
   3253   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   3254   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   3255   XCTAssertEqual(value, 702);
   3256   XCTAssertTrue([dict valueForKey:34ULL rawValue:NULL]);
   3257   XCTAssertTrue([dict valueForKey:34ULL rawValue:&value]);
   3258   XCTAssertEqual(value, 803);
   3259 
   3260   XCTAssertThrowsSpecificNamed([dict setValue:803 forKey:31ULL],  // Unknown
   3261                                NSException, NSInvalidArgumentException);
   3262   XCTAssertEqual(dict.count, 4U);
   3263   XCTAssertTrue([dict valueForKey:31ULL value:NULL]);
   3264   XCTAssertTrue([dict valueForKey:31ULL value:&value]);
   3265   XCTAssertEqual(value, 700);
   3266   XCTAssertTrue([dict valueForKey:32ULL rawValue:NULL]);
   3267   XCTAssertTrue([dict valueForKey:32ULL rawValue:&value]);
   3268   XCTAssertEqual(value, 801);
   3269   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   3270   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   3271   XCTAssertEqual(value, 702);
   3272   XCTAssertTrue([dict valueForKey:34ULL rawValue:NULL]);
   3273   XCTAssertTrue([dict valueForKey:34ULL rawValue:&value]);
   3274   XCTAssertEqual(value, 803);
   3275 
   3276   [dict setRawValue:803 forKey:31ULL];  // Unknown
   3277   XCTAssertEqual(dict.count, 4U);
   3278   XCTAssertTrue([dict valueForKey:31ULL rawValue:NULL]);
   3279   XCTAssertTrue([dict valueForKey:31ULL rawValue:&value]);
   3280   XCTAssertEqual(value, 803);
   3281   XCTAssertTrue([dict valueForKey:32ULL rawValue:NULL]);
   3282   XCTAssertTrue([dict valueForKey:32ULL rawValue:&value]);
   3283   XCTAssertEqual(value, 801);
   3284   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   3285   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   3286   XCTAssertEqual(value, 702);
   3287   XCTAssertTrue([dict valueForKey:34ULL rawValue:NULL]);
   3288   XCTAssertTrue([dict valueForKey:34ULL rawValue:&value]);
   3289   XCTAssertEqual(value, 803);
   3290 
   3291   [dict setRawValue:700 forKey:34ULL];
   3292   XCTAssertEqual(dict.count, 4U);
   3293   XCTAssertTrue([dict valueForKey:31ULL rawValue:NULL]);
   3294   XCTAssertTrue([dict valueForKey:31ULL rawValue:&value]);
   3295   XCTAssertEqual(value, 803);
   3296   XCTAssertTrue([dict valueForKey:32ULL rawValue:NULL]);
   3297   XCTAssertTrue([dict valueForKey:32ULL rawValue:&value]);
   3298   XCTAssertEqual(value, 801);
   3299   XCTAssertTrue([dict valueForKey:33ULL value:NULL]);
   3300   XCTAssertTrue([dict valueForKey:33ULL value:&value]);
   3301   XCTAssertEqual(value, 702);
   3302   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   3303   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   3304   XCTAssertEqual(value, 700);
   3305 
   3306   const uint64_t kKeys2[] = { 32ULL, 33ULL };
   3307   const int32_t kValues2[] = { 702, 801 };  // Unknown
   3308   GPBUInt64EnumDictionary *dict2 =
   3309       [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsValidValue
   3310                                                         rawValues:kValues2
   3311                                                           forKeys:kKeys2
   3312                                                             count:GPBARRAYSIZE(kValues2)];
   3313   XCTAssertNotNil(dict2);
   3314   [dict addRawEntriesFromDictionary:dict2];
   3315   XCTAssertEqual(dict.count, 4U);
   3316   XCTAssertTrue([dict valueForKey:31ULL rawValue:NULL]);
   3317   XCTAssertTrue([dict valueForKey:31ULL rawValue:&value]);
   3318   XCTAssertEqual(value, 803);
   3319   XCTAssertTrue([dict valueForKey:32ULL value:NULL]);
   3320   XCTAssertTrue([dict valueForKey:32ULL value:&value]);
   3321   XCTAssertEqual(value, 702);
   3322   XCTAssertTrue([dict valueForKey:33ULL rawValue:NULL]);
   3323   XCTAssertTrue([dict valueForKey:33ULL rawValue:&value]);
   3324   XCTAssertEqual(value, 801);
   3325   XCTAssertTrue([dict valueForKey:34ULL value:NULL]);
   3326   XCTAssertTrue([dict valueForKey:34ULL value:&value]);
   3327   XCTAssertEqual(value, 700);
   3328 
   3329   [dict2 release];
   3330   [dict release];
   3331 }
   3332 
   3333 - (void)testCopyUnknowns {
   3334   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   3335   const int32_t kValues[] = { 700, 801, 702, 803 };
   3336   GPBUInt64EnumDictionary *dict =
   3337       [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsValidValue
   3338                                                         rawValues:kValues
   3339                                                           forKeys:kKeys
   3340                                                             count:GPBARRAYSIZE(kValues)];
   3341   XCTAssertNotNil(dict);
   3342 
   3343   GPBUInt64EnumDictionary *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 comparison
   3350   XCTAssertTrue([dict2 isKindOfClass:[GPBUInt64EnumDictionary class]]);
   3351 
   3352   [dict2 release];
   3353   [dict release];
   3354 }
   3355 
   3356 @end
   3357 
   3358 #pragma mark - UInt64 -> Object
   3359 
   3360 @interface GPBUInt64ObjectDictionaryTests : XCTestCase
   3361 @end
   3362 
   3363 @implementation GPBUInt64ObjectDictionaryTests
   3364 
   3365 - (void)testEmpty {
   3366   GPBUInt64ObjectDictionary<NSString*> *dict = [[GPBUInt64ObjectDictionary alloc] init];
   3367   XCTAssertNotNil(dict);
   3368   XCTAssertEqual(dict.count, 0U);
   3369   XCTAssertNil([dict objectForKey:31ULL]);
   3370   [dict enumerateKeysAndObjectsUsingBlock:^(uint64_t aKey, NSString* aObject, BOOL *stop) {
   3371     #pragma unused(aKey, aObject, stop)
   3372     XCTFail(@"Shouldn't get here!");
   3373   }];
   3374   [dict release];
   3375 }
   3376 
   3377 - (void)testOne {
   3378   GPBUInt64ObjectDictionary<NSString*> *dict = [GPBUInt64ObjectDictionary dictionaryWithObject:@"abc" forKey:31ULL];
   3379   XCTAssertNotNil(dict);
   3380   XCTAssertEqual(dict.count, 1U);
   3381   XCTAssertEqualObjects([dict objectForKey:31ULL], @"abc");
   3382   XCTAssertNil([dict objectForKey:32ULL]);
   3383   [dict enumerateKeysAndObjectsUsingBlock:^(uint64_t aKey, NSString* aObject, BOOL *stop) {
   3384     XCTAssertEqual(aKey, 31ULL);
   3385     XCTAssertEqualObjects(aObject, @"abc");
   3386     XCTAssertNotEqual(stop, NULL);
   3387   }];
   3388 }
   3389 
   3390 - (void)testBasics {
   3391   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL };
   3392   const NSString* kObjects[] = { @"abc", @"def", @"ghi" };
   3393   GPBUInt64ObjectDictionary<NSString*> *dict =
   3394       [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects
   3395                                                  forKeys:kKeys
   3396                                                    count:GPBARRAYSIZE(kObjects)];
   3397   XCTAssertNotNil(dict);
   3398   XCTAssertEqual(dict.count, 3U);
   3399   XCTAssertEqualObjects([dict objectForKey:31ULL], @"abc");
   3400   XCTAssertEqualObjects([dict objectForKey:32ULL], @"def");
   3401   XCTAssertEqualObjects([dict objectForKey:33ULL], @"ghi");
   3402   XCTAssertNil([dict objectForKey:34ULL]);
   3403 
   3404   __block NSUInteger idx = 0;
   3405   uint64_t *seenKeys = malloc(3 * sizeof(uint64_t));
   3406   NSString* *seenObjects = malloc(3 * sizeof(NSString*));
   3407   [dict enumerateKeysAndObjectsUsingBlock:^(uint64_t aKey, NSString* aObject, BOOL *stop) {
   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:^(uint64_t aKey, NSString* aObject, BOOL *stop) {
   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 uint64_t kKeys1[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   3440   const uint64_t kKeys2[] = { 32ULL, 31ULL, 34ULL };
   3441   const NSString* kObjects1[] = { @"abc", @"def", @"ghi" };
   3442   const NSString* kObjects2[] = { @"abc", @"jkl", @"ghi" };
   3443   const NSString* kObjects3[] = { @"abc", @"def", @"ghi", @"jkl" };
   3444   GPBUInt64ObjectDictionary<NSString*> *dict1 =
   3445       [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects1
   3446                                                  forKeys:kKeys1
   3447                                                    count:GPBARRAYSIZE(kObjects1)];
   3448   XCTAssertNotNil(dict1);
   3449   GPBUInt64ObjectDictionary<NSString*> *dict1prime =
   3450       [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects1
   3451                                                  forKeys:kKeys1
   3452                                                    count:GPBARRAYSIZE(kObjects1)];
   3453   XCTAssertNotNil(dict1prime);
   3454   GPBUInt64ObjectDictionary<NSString*> *dict2 =
   3455       [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects2
   3456                                                  forKeys:kKeys1
   3457                                                    count:GPBARRAYSIZE(kObjects2)];
   3458   XCTAssertNotNil(dict2);
   3459   GPBUInt64ObjectDictionary<NSString*> *dict3 =
   3460       [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects1
   3461                                                  forKeys:kKeys2
   3462                                                    count:GPBARRAYSIZE(kObjects1)];
   3463   XCTAssertNotNil(dict3);
   3464   GPBUInt64ObjectDictionary<NSString*> *dict4 =
   3465       [[GPBUInt64ObjectDictionary 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 uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   3494   const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" };
   3495   GPBUInt64ObjectDictionary<NSString*> *dict =
   3496       [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects
   3497                                                  forKeys:kKeys
   3498                                                    count:GPBARRAYSIZE(kObjects)];
   3499   XCTAssertNotNil(dict);
   3500 
   3501   GPBUInt64ObjectDictionary<NSString*> *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:[GPBUInt64ObjectDictionary class]]);
   3508 
   3509   [dict2 release];
   3510   [dict release];
   3511 }
   3512 
   3513 - (void)testDictionaryFromDictionary {
   3514   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   3515   const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" };
   3516   GPBUInt64ObjectDictionary<NSString*> *dict =
   3517       [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects
   3518                                                  forKeys:kKeys
   3519                                                    count:GPBARRAYSIZE(kObjects)];
   3520   XCTAssertNotNil(dict);
   3521 
   3522   GPBUInt64ObjectDictionary<NSString*> *dict2 =
   3523       [GPBUInt64ObjectDictionary 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   GPBUInt64ObjectDictionary<NSString*> *dict = [GPBUInt64ObjectDictionary dictionary];
   3534   XCTAssertNotNil(dict);
   3535 
   3536   XCTAssertEqual(dict.count, 0U);
   3537   [dict setObject:@"abc" forKey:31ULL];
   3538   XCTAssertEqual(dict.count, 1U);
   3539 
   3540   const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL };
   3541   const NSString* kObjects[] = { @"def", @"ghi", @"jkl" };
   3542   GPBUInt64ObjectDictionary<NSString*> *dict2 =
   3543       [[GPBUInt64ObjectDictionary 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:31ULL], @"abc");
   3551   XCTAssertEqualObjects([dict objectForKey:32ULL], @"def");
   3552   XCTAssertEqualObjects([dict objectForKey:33ULL], @"ghi");
   3553   XCTAssertEqualObjects([dict objectForKey:34ULL], @"jkl");
   3554   [dict2 release];
   3555 }
   3556 
   3557 - (void)testRemove {
   3558   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   3559   const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" };
   3560   GPBUInt64ObjectDictionary<NSString*> *dict =
   3561       [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects
   3562                                           forKeys:kKeys
   3563                                             count:GPBARRAYSIZE(kObjects)];
   3564   XCTAssertNotNil(dict);
   3565   XCTAssertEqual(dict.count, 4U);
   3566 
   3567   [dict removeObjectForKey:32ULL];
   3568   XCTAssertEqual(dict.count, 3U);
   3569   XCTAssertEqualObjects([dict objectForKey:31ULL], @"abc");
   3570   XCTAssertNil([dict objectForKey:32ULL]);
   3571   XCTAssertEqualObjects([dict objectForKey:33ULL], @"ghi");
   3572   XCTAssertEqualObjects([dict objectForKey:34ULL], @"jkl");
   3573 
   3574   // Remove again does nothing.
   3575   [dict removeObjectForKey:32ULL];
   3576   XCTAssertEqual(dict.count, 3U);
   3577   XCTAssertEqualObjects([dict objectForKey:31ULL], @"abc");
   3578   XCTAssertNil([dict objectForKey:32ULL]);
   3579   XCTAssertEqualObjects([dict objectForKey:33ULL], @"ghi");
   3580   XCTAssertEqualObjects([dict objectForKey:34ULL], @"jkl");
   3581 
   3582   [dict removeObjectForKey:34ULL];
   3583   XCTAssertEqual(dict.count, 2U);
   3584   XCTAssertEqualObjects([dict objectForKey:31ULL], @"abc");
   3585   XCTAssertNil([dict objectForKey:32ULL]);
   3586   XCTAssertEqualObjects([dict objectForKey:33ULL], @"ghi");
   3587   XCTAssertNil([dict objectForKey:34ULL]);
   3588 
   3589   [dict removeAll];
   3590   XCTAssertEqual(dict.count, 0U);
   3591   XCTAssertNil([dict objectForKey:31ULL]);
   3592   XCTAssertNil([dict objectForKey:32ULL]);
   3593   XCTAssertNil([dict objectForKey:33ULL]);
   3594   XCTAssertNil([dict objectForKey:34ULL]);
   3595   [dict release];
   3596 }
   3597 
   3598 - (void)testInplaceMutation {
   3599   const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL };
   3600   const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" };
   3601   GPBUInt64ObjectDictionary<NSString*> *dict =
   3602       [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects
   3603                                           forKeys:kKeys
   3604                                             count:GPBARRAYSIZE(kObjects)];
   3605   XCTAssertNotNil(dict);
   3606   XCTAssertEqual(dict.count, 4U);
   3607   XCTAssertEqualObjects([dict objectForKey:31ULL], @"abc");
   3608   XCTAssertEqualObjects([dict objectForKey:32ULL], @"def");
   3609   XCTAssertEqualObjects([dict objectForKey:33ULL], @"ghi");
   3610   XCTAssertEqualObjects([dict objectForKey:34ULL], @"jkl");
   3611 
   3612   [dict setObject:@"jkl" forKey:31ULL];
   3613   XCTAssertEqual(dict.count, 4U);
   3614   XCTAssertEqualObjects([dict objectForKey:31ULL], @"jkl");
   3615   XCTAssertEqualObjects([dict objectForKey:32ULL], @"def");
   3616   XCTAssertEqualObjects([dict objectForKey:33ULL], @"ghi");
   3617   XCTAssertEqualObjects([dict objectForKey:34ULL], @"jkl");
   3618 
   3619   [dict setObject:@"def" forKey:34ULL];
   3620   XCTAssertEqual(dict.count, 4U);
   3621   XCTAssertEqualObjects([dict objectForKey:31ULL], @"jkl");
   3622   XCTAssertEqualObjects([dict objectForKey:32ULL], @"def");
   3623   XCTAssertEqualObjects([dict objectForKey:33ULL], @"ghi");
   3624   XCTAssertEqualObjects([dict objectForKey:34ULL], @"def");
   3625 
   3626   const uint64_t kKeys2[] = { 32ULL, 33ULL };
   3627   const NSString* kObjects2[] = { @"ghi", @"abc" };
   3628   GPBUInt64ObjectDictionary<NSString*> *dict2 =
   3629       [[GPBUInt64ObjectDictionary 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:31ULL], @"jkl");
   3636   XCTAssertEqualObjects([dict objectForKey:32ULL], @"ghi");
   3637   XCTAssertEqualObjects([dict objectForKey:33ULL], @"abc");
   3638   XCTAssertEqualObjects([dict objectForKey:34ULL], @"def");
   3639 
   3640   [dict2 release];
   3641   [dict release];
   3642 }
   3643 
   3644 @end
   3645 
   3646 //%PDDM-EXPAND-END TEST_FOR_POD_KEY(UInt64, uint64_t, 31ULL, 32ULL, 33ULL, 34ULL)
   3647