Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/protobuf/objectivec/Tests/GPBDictionaryTests+UInt64.m

Issue 1842653006: Update //third_party/protobuf to version 3. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: merge Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « third_party/protobuf/objectivec/Tests/GPBDictionaryTests+UInt32.m ('k') | third_party/protobuf/objectivec/Tests/GPBMessageTests.m » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2015 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31 #import <Foundation/Foundation.h>
32 #import <XCTest/XCTest.h>
33
34 #import "GPBDictionary.h"
35
36 #import "GPBTestUtilities.h"
37 #import "google/protobuf/UnittestRuntimeProto2.pbobjc.h"
38
39 // Pull in the macros (using an external file because expanding all tests
40 // in a single file makes a file that is failing to work with within Xcode.
41 //%PDDM-IMPORT-DEFINES GPBDictionaryTests.pddm
42
43 //%PDDM-EXPAND TEST_FOR_POD_KEY(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:Tes tingEnum_IsValidValue
71 rawValues:&va lue
72 forKeys:&ke y
73 count:1] autorelease];
74 }
75 - (instancetype)initWithValues:(const int32_t [])values
76 forKeys:(const 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 dictionaryWithVal ue: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 dictionaryWithVal ue: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 *sto p) {
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:Y ES 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 *sto p) {
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 *sto p) {
1574 XCTAssertLessThan(idx, 3U);
1575 seenKeys[idx] = aKey;
1576 seenValues[idx] = aValue;
1577 XCTAssertNotEqual(stop, NULL);
1578 ++idx;
1579 }];
1580 for (int i = 0; i < 3; ++i) {
1581 BOOL foundKey = NO;
1582 for (int j = 0; (j < 3) && !foundKey; ++j) {
1583 if (kKeys[i] == seenKeys[j]) {
1584 foundKey = YES;
1585 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j);
1586 }
1587 }
1588 XCTAssertTrue(foundKey, @"i = %d", i);
1589 }
1590 free(seenKeys);
1591 free(seenValues);
1592
1593 // Stopping the enumeration.
1594 idx = 0;
1595 [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *sto p) {
1596 #pragma unused(aKey, aValue)
1597 if (idx == 1) *stop = YES;
1598 XCTAssertNotEqual(idx, 2U);
1599 ++idx;
1600 }];
1601 [dict release];
1602 }
1603
1604 - (void)testEquality {
1605 const 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 *st op) {
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 *st op) {
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 *st op) {
1931 XCTAssertLessThan(idx, 3U);
1932 seenKeys[idx] = aKey;
1933 seenValues[idx] = aValue;
1934 XCTAssertNotEqual(stop, NULL);
1935 ++idx;
1936 }];
1937 for (int i = 0; i < 3; ++i) {
1938 BOOL foundKey = NO;
1939 for (int j = 0; (j < 3) && !foundKey; ++j) {
1940 if (kKeys[i] == seenKeys[j]) {
1941 foundKey = YES;
1942 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j);
1943 }
1944 }
1945 XCTAssertTrue(foundKey, @"i = %d", i);
1946 }
1947 free(seenKeys);
1948 free(seenValues);
1949
1950 // Stopping the enumeration.
1951 idx = 0;
1952 [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, float aValue, BOOL *st op) {
1953 #pragma unused(aKey, aValue)
1954 if (idx == 1) *stop = YES;
1955 XCTAssertNotEqual(idx, 2U);
1956 ++idx;
1957 }];
1958 [dict release];
1959 }
1960
1961 - (void)testEquality {
1962 const 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 *s top) {
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 dictionaryWithVal ue: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 *s top) {
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 *s top) {
2288 XCTAssertLessThan(idx, 3U);
2289 seenKeys[idx] = aKey;
2290 seenValues[idx] = aValue;
2291 XCTAssertNotEqual(stop, NULL);
2292 ++idx;
2293 }];
2294 for (int i = 0; i < 3; ++i) {
2295 BOOL foundKey = NO;
2296 for (int j = 0; (j < 3) && !foundKey; ++j) {
2297 if (kKeys[i] == seenKeys[j]) {
2298 foundKey = YES;
2299 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j);
2300 }
2301 }
2302 XCTAssertTrue(foundKey, @"i = %d", i);
2303 }
2304 free(seenKeys);
2305 free(seenValues);
2306
2307 // Stopping the enumeration.
2308 idx = 0;
2309 [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, double aValue, BOOL *s top) {
2310 #pragma unused(aKey, aValue)
2311 if (idx == 1) *stop = YES;
2312 XCTAssertNotEqual(idx, 2U);
2313 ++idx;
2314 }];
2315 [dict release];
2316 }
2317
2318 - (void)testEquality {
2319 const 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:7 00 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_Is ValidValue
2954 rawValues:kValues
2955 forKeys:kKeys
2956 count:GPBARRAYSIZE(k Values)];
2957 XCTAssertNotNil(dict);
2958 XCTAssertEqual(dict.count, 3U);
2959 XCTAssertTrue(dict.validationFunc == TestingEnum_IsValidValue); // Pointer co mparison
2960 int32_t value;
2961 XCTAssertTrue([dict valueForKey: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, BOO L *stop) {
3001 XCTAssertLessThan(idx, 3U);
3002 seenKeys[idx] = aKey;
3003 seenValues[idx] = aValue;
3004 XCTAssertNotEqual(stop, NULL);
3005 ++idx;
3006 }];
3007 for (int i = 0; i < 3; ++i) {
3008 BOOL foundKey = NO;
3009 for (int j = 0; (j < 3) && !foundKey; ++j) {
3010 if (kKeys[i] == seenKeys[j]) {
3011 foundKey = YES;
3012 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j);
3013 }
3014 }
3015 XCTAssertTrue(foundKey, @"i = %d", i);
3016 }
3017 free(seenKeys);
3018 free(seenValues);
3019
3020 // Stopping the enumeration.
3021 idx = 0;
3022 [dict enumerateKeysAndRawValuesUsingBlock:^(uint64_t aKey, int32_t aValue, BOO L *stop) {
3023 #pragma unused(aKey, aValue)
3024 if (idx == 1) *stop = YES;
3025 XCTAssertNotEqual(idx, 2U);
3026 ++idx;
3027 }];
3028 [dict release];
3029 }
3030
3031 - (void)testEqualityWithUnknowns {
3032 const 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_Is ValidValue
3039 rawValues:kValues1
3040 forKeys:kKeys1
3041 count:GPBARRAYSIZE(k Values1)];
3042 XCTAssertNotNil(dict1);
3043 GPBUInt64EnumDictionary *dict1prime =
3044 [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is ValidValue
3045 rawValues:kValues1
3046 forKeys:kKeys1
3047 count:GPBARRAYSIZE(k Values1)];
3048 XCTAssertNotNil(dict1prime);
3049 GPBUInt64EnumDictionary *dict2 =
3050 [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is ValidValue
3051 rawValues:kValues2
3052 forKeys:kKeys1
3053 count:GPBARRAYSIZE(k Values2)];
3054 XCTAssertNotNil(dict2);
3055 GPBUInt64EnumDictionary *dict3 =
3056 [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is ValidValue
3057 rawValues:kValues1
3058 forKeys:kKeys2
3059 count:GPBARRAYSIZE(k Values1)];
3060 XCTAssertNotNil(dict3);
3061 GPBUInt64EnumDictionary *dict4 =
3062 [[GPBUInt64EnumDictionary alloc] initWithValidationFunction:TestingEnum_Is ValidValue
3063 rawValues:kValues3
3064 forKeys:kKeys1
3065 count:GPBARRAYSIZE(k Values3)];
3066 XCTAssertNotNil(dict4);
3067
3068 // 1/1Prime should be different objects, but equal.
3069 XCTAssertNotEqual(dict1, dict1prime);
3070 XCTAssertEqualObjects(dict1, dict1prime);
3071 // Equal, so they must have same hash.
3072 XCTAssertEqual([dict1 hash], [dict1prime hash]);
3073
3074 // 2 is same keys, different values; not equal.
3075 XCTAssertNotEqualObjects(dict1, dict2);
3076
3077 // 3 is different keys, same values; not equal.
3078 XCTAssertNotEqualObjects(dict1, dict3);
3079
3080 // 4 extra pair; not equal
3081 XCTAssertNotEqualObjects(dict1, dict4);
3082
3083 [dict1 release];
3084 [dict1prime release];
3085 [dict2 release];
3086 [dict3 release];
3087 [dict4 release];
3088 }
3089
3090 - (void)testCopyWithUnknowns {
3091 const 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_Is ValidValue
3095 rawValues:kValues
3096 forKeys:kKeys
3097 count:GPBARRAYSIZE(k Values)];
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 compari son
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_Is ValidValue
3117 rawValues:kValues
3118 forKeys:kKeys
3119 count:GPBARRAYSIZE(k Values)];
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 compari son
3130 [dict release];
3131 }
3132
3133 - (void)testUnknownAdds {
3134 GPBUInt64EnumDictionary *dict =
3135 [GPBUInt64EnumDictionary dictionaryWithValidationFunction:TestingEnum_IsVali dValue];
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_Is ValidValue
3182 rawValues:kValues
3183 forKeys:kKeys
3184 count:GPBARRAYSIZE(k Values)];
3185 XCTAssertNotNil(dict);
3186 XCTAssertEqual(dict.count, 4U);
3187
3188 [dict removeValueForKey: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_Is ValidValue
3241 rawValues:kValues
3242 forKeys:kKeys
3243 count:GPBARRAYSIZE(k Values)];
3244 XCTAssertNotNil(dict);
3245 XCTAssertEqual(dict.count, 4U);
3246 int32_t value;
3247 XCTAssertTrue([dict valueForKey: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_Is ValidValue
3310 rawValues:kValues2
3311 forKeys:kKeys2
3312 count:GPBARRAYSIZE(k Values2)];
3313 XCTAssertNotNil(dict2);
3314 [dict addRawEntriesFromDictionary:dict2];
3315 XCTAssertEqual(dict.count, 4U);
3316 XCTAssertTrue([dict valueForKey: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_Is ValidValue
3338 rawValues:kValues
3339 forKeys:kKeys
3340 count:GPBARRAYSIZE(k Values)];
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 compari son
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 *dict = [[GPBUInt64ObjectDictionary alloc] init];
3367 XCTAssertNotNil(dict);
3368 XCTAssertEqual(dict.count, 0U);
3369 XCTAssertNil([dict objectForKey:31ULL]);
3370 [dict enumerateKeysAndObjectsUsingBlock:^(uint64_t aKey, id aObject, BOOL *sto p) {
3371 #pragma unused(aKey, aObject, stop)
3372 XCTFail(@"Shouldn't get here!");
3373 }];
3374 [dict release];
3375 }
3376
3377 - (void)testOne {
3378 GPBUInt64ObjectDictionary *dict = [GPBUInt64ObjectDictionary dictionaryWithObj ect:@"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, id aObject, BOOL *sto p) {
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 id kObjects[] = { @"abc", @"def", @"ghi" };
3393 GPBUInt64ObjectDictionary *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 id *seenObjects = malloc(3 * sizeof(id));
3407 [dict enumerateKeysAndObjectsUsingBlock:^(uint64_t aKey, id aObject, BOOL *sto p) {
3408 XCTAssertLessThan(idx, 3U);
3409 seenKeys[idx] = aKey;
3410 seenObjects[idx] = aObject;
3411 XCTAssertNotEqual(stop, NULL);
3412 ++idx;
3413 }];
3414 for (int i = 0; i < 3; ++i) {
3415 BOOL foundKey = NO;
3416 for (int j = 0; (j < 3) && !foundKey; ++j) {
3417 if (kKeys[i] == seenKeys[j]) {
3418 foundKey = YES;
3419 XCTAssertEqualObjects(kObjects[i], seenObjects[j], @"i = %d, j = %d", i, j);
3420 }
3421 }
3422 XCTAssertTrue(foundKey, @"i = %d", i);
3423 }
3424 free(seenKeys);
3425 free(seenObjects);
3426
3427 // Stopping the enumeration.
3428 idx = 0;
3429 [dict enumerateKeysAndObjectsUsingBlock:^(uint64_t aKey, id aObject, BOOL *sto p) {
3430 #pragma unused(aKey, aObject)
3431 if (idx == 1) *stop = YES;
3432 XCTAssertNotEqual(idx, 2U);
3433 ++idx;
3434 }];
3435 [dict release];
3436 }
3437
3438 - (void)testEquality {
3439 const uint64_t kKeys1[] = { 31ULL, 32ULL, 33ULL, 34ULL };
3440 const uint64_t kKeys2[] = { 32ULL, 31ULL, 34ULL };
3441 const id kObjects1[] = { @"abc", @"def", @"ghi" };
3442 const id kObjects2[] = { @"abc", @"jkl", @"ghi" };
3443 const id kObjects3[] = { @"abc", @"def", @"ghi", @"jkl" };
3444 GPBUInt64ObjectDictionary *dict1 =
3445 [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects1
3446 forKeys:kKeys1
3447 count:GPBARRAYSIZE(kObjects1) ];
3448 XCTAssertNotNil(dict1);
3449 GPBUInt64ObjectDictionary *dict1prime =
3450 [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects1
3451 forKeys:kKeys1
3452 count:GPBARRAYSIZE(kObjects1) ];
3453 XCTAssertNotNil(dict1prime);
3454 GPBUInt64ObjectDictionary *dict2 =
3455 [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects2
3456 forKeys:kKeys1
3457 count:GPBARRAYSIZE(kObjects2) ];
3458 XCTAssertNotNil(dict2);
3459 GPBUInt64ObjectDictionary *dict3 =
3460 [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects1
3461 forKeys:kKeys2
3462 count:GPBARRAYSIZE(kObjects1) ];
3463 XCTAssertNotNil(dict3);
3464 GPBUInt64ObjectDictionary *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 id kObjects[] = { @"abc", @"def", @"ghi", @"jkl" };
3495 GPBUInt64ObjectDictionary *dict =
3496 [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects
3497 forKeys:kKeys
3498 count:GPBARRAYSIZE(kObjects)] ;
3499 XCTAssertNotNil(dict);
3500
3501 GPBUInt64ObjectDictionary *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 id kObjects[] = { @"abc", @"def", @"ghi", @"jkl" };
3516 GPBUInt64ObjectDictionary *dict =
3517 [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects
3518 forKeys:kKeys
3519 count:GPBARRAYSIZE(kObjects)] ;
3520 XCTAssertNotNil(dict);
3521
3522 GPBUInt64ObjectDictionary *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 *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 id kObjects[] = { @"def", @"ghi", @"jkl" };
3542 GPBUInt64ObjectDictionary *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 id kObjects[] = { @"abc", @"def", @"ghi", @"jkl" };
3560 GPBUInt64ObjectDictionary *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 id kObjects[] = { @"abc", @"def", @"ghi", @"jkl" };
3601 GPBUInt64ObjectDictionary *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 id kObjects2[] = { @"ghi", @"abc" };
3628 GPBUInt64ObjectDictionary *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 )
OLDNEW
« no previous file with comments | « third_party/protobuf/objectivec/Tests/GPBDictionaryTests+UInt32.m ('k') | third_party/protobuf/objectivec/Tests/GPBMessageTests.m » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698