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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 1322483002: Revert https://codereview.chromium.org/1291903002 (protobuf roll). (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 3 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.pddm ('k') | third_party/protobuf/objectivec/Tests/GPBDictionaryTests+Int32.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 BOOL_TESTS_FOR_POD_VALUE(UInt32, uint32_t, 100U, 101U)
44 // This block of code is generated, do not edit it directly.
45
46 #pragma mark - Bool -> UInt32
47
48 @interface GPBBoolUInt32DictionaryTests : XCTestCase
49 @end
50
51 @implementation GPBBoolUInt32DictionaryTests
52
53 - (void)testEmpty {
54 GPBBoolUInt32Dictionary *dict = [[GPBBoolUInt32Dictionary alloc] init];
55 XCTAssertNotNil(dict);
56 XCTAssertEqual(dict.count, 0U);
57 XCTAssertFalse([dict valueForKey:YES value:NULL]);
58 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *sto p) {
59 #pragma unused(aKey, aValue, stop)
60 XCTFail(@"Shouldn't get here!");
61 }];
62 [dict release];
63 }
64
65 - (void)testOne {
66 GPBBoolUInt32Dictionary *dict = [GPBBoolUInt32Dictionary dictionaryWithValue:1 00U forKey:YES];
67 XCTAssertNotNil(dict);
68 XCTAssertEqual(dict.count, 1U);
69 uint32_t value;
70 XCTAssertTrue([dict valueForKey:YES value:NULL]);
71 XCTAssertTrue([dict valueForKey:YES value:&value]);
72 XCTAssertEqual(value, 100U);
73 XCTAssertFalse([dict valueForKey:NO value:NULL]);
74 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *sto p) {
75 XCTAssertEqual(aKey, YES);
76 XCTAssertEqual(aValue, 100U);
77 XCTAssertNotEqual(stop, NULL);
78 }];
79 }
80
81 - (void)testBasics {
82 const BOOL kKeys[] = { YES, NO };
83 const uint32_t kValues[] = { 100U, 101U };
84 GPBBoolUInt32Dictionary *dict =
85 [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues
86 forKeys:kKeys
87 count:GPBARRAYSIZE(kValues)];
88 XCTAssertNotNil(dict);
89 XCTAssertEqual(dict.count, 2U);
90 uint32_t value;
91 XCTAssertTrue([dict valueForKey:YES value:NULL]);
92 XCTAssertTrue([dict valueForKey:YES value:&value]);
93 XCTAssertEqual(value, 100U);
94 XCTAssertTrue([dict valueForKey:NO value:NULL]);
95 XCTAssertTrue([dict valueForKey:NO value:&value]);
96 XCTAssertEqual(value, 101U);
97
98 __block NSUInteger idx = 0;
99 BOOL *seenKeys = malloc(2 * sizeof(BOOL));
100 uint32_t *seenValues = malloc(2 * sizeof(uint32_t));
101 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *sto p) {
102 XCTAssertLessThan(idx, 2U);
103 seenKeys[idx] = aKey;
104 seenValues[idx] = aValue;
105 XCTAssertNotEqual(stop, NULL);
106 ++idx;
107 }];
108 for (int i = 0; i < 2; ++i) {
109 BOOL foundKey = NO;
110 for (int j = 0; (j < 2) && !foundKey; ++j) {
111 if (kKeys[i] == seenKeys[j]) {
112 foundKey = YES;
113 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j);
114 }
115 }
116 XCTAssertTrue(foundKey, @"i = %d", i);
117 }
118 free(seenKeys);
119 free(seenValues);
120
121 // Stopping the enumeration.
122 idx = 0;
123 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *sto p) {
124 #pragma unused(aKey, aValue)
125 if (idx == 0) *stop = YES;
126 XCTAssertNotEqual(idx, 2U);
127 ++idx;
128 }];
129 [dict release];
130 }
131
132 - (void)testEquality {
133 const BOOL kKeys1[] = { YES, NO };
134 const BOOL kKeys2[] = { NO, YES };
135 const uint32_t kValues1[] = { 100U, 101U };
136 const uint32_t kValues2[] = { 101U, 100U };
137 const uint32_t kValues3[] = { 101U };
138 GPBBoolUInt32Dictionary *dict1 =
139 [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues1
140 forKeys:kKeys1
141 count:GPBARRAYSIZE(kValues1)];
142 XCTAssertNotNil(dict1);
143 GPBBoolUInt32Dictionary *dict1prime =
144 [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues1
145 forKeys:kKeys1
146 count:GPBARRAYSIZE(kValues1)];
147 XCTAssertNotNil(dict1prime);
148 GPBBoolUInt32Dictionary *dict2 =
149 [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues2
150 forKeys:kKeys1
151 count:GPBARRAYSIZE(kValues2)];
152 XCTAssertNotNil(dict2);
153 GPBBoolUInt32Dictionary *dict3 =
154 [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues1
155 forKeys:kKeys2
156 count:GPBARRAYSIZE(kValues1)];
157 XCTAssertNotNil(dict3);
158 GPBBoolUInt32Dictionary *dict4 =
159 [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues3
160 forKeys:kKeys1
161 count:GPBARRAYSIZE(kValues3)];
162 XCTAssertNotNil(dict4);
163
164 // 1/1Prime should be different objects, but equal.
165 XCTAssertNotEqual(dict1, dict1prime);
166 XCTAssertEqualObjects(dict1, dict1prime);
167 // Equal, so they must have same hash.
168 XCTAssertEqual([dict1 hash], [dict1prime hash]);
169
170 // 2 is save keys, different values; not equal.
171 XCTAssertNotEqualObjects(dict1, dict2);
172
173 // 3 is different keys, samae values; not equal.
174 XCTAssertNotEqualObjects(dict1, dict3);
175
176 // 4 Fewer pairs; not equal
177 XCTAssertNotEqualObjects(dict1, dict4);
178
179 [dict1 release];
180 [dict1prime release];
181 [dict2 release];
182 [dict3 release];
183 [dict4 release];
184 }
185
186 - (void)testCopy {
187 const BOOL kKeys[] = { YES, NO };
188 const uint32_t kValues[] = { 100U, 101U };
189 GPBBoolUInt32Dictionary *dict =
190 [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues
191 forKeys:kKeys
192 count:GPBARRAYSIZE(kValues)];
193 XCTAssertNotNil(dict);
194
195 GPBBoolUInt32Dictionary *dict2 = [dict copy];
196 XCTAssertNotNil(dict2);
197
198 // Should be new object but equal.
199 XCTAssertNotEqual(dict, dict2);
200 XCTAssertEqualObjects(dict, dict2);
201 XCTAssertTrue([dict2 isKindOfClass:[GPBBoolUInt32Dictionary class]]);
202
203 [dict2 release];
204 [dict release];
205 }
206
207 - (void)testDictionaryFromDictionary {
208 const BOOL kKeys[] = { YES, NO };
209 const uint32_t kValues[] = { 100U, 101U };
210 GPBBoolUInt32Dictionary *dict =
211 [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues
212 forKeys:kKeys
213 count:GPBARRAYSIZE(kValues)];
214 XCTAssertNotNil(dict);
215
216 GPBBoolUInt32Dictionary *dict2 =
217 [GPBBoolUInt32Dictionary dictionaryWithDictionary:dict];
218 XCTAssertNotNil(dict2);
219
220 // Should be new pointer, but equal objects.
221 XCTAssertNotEqual(dict, dict2);
222 XCTAssertEqualObjects(dict, dict2);
223 [dict release];
224 }
225
226 - (void)testAdds {
227 GPBBoolUInt32Dictionary *dict = [GPBBoolUInt32Dictionary dictionary];
228 XCTAssertNotNil(dict);
229
230 XCTAssertEqual(dict.count, 0U);
231 [dict setValue:100U forKey:YES];
232 XCTAssertEqual(dict.count, 1U);
233
234 const BOOL kKeys[] = { NO };
235 const uint32_t kValues[] = { 101U };
236 GPBBoolUInt32Dictionary *dict2 =
237 [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues
238 forKeys:kKeys
239 count:GPBARRAYSIZE(kValues)];
240 XCTAssertNotNil(dict2);
241 [dict addEntriesFromDictionary:dict2];
242 XCTAssertEqual(dict.count, 2U);
243
244 uint32_t value;
245 XCTAssertTrue([dict valueForKey:YES value:NULL]);
246 XCTAssertTrue([dict valueForKey:YES value:&value]);
247 XCTAssertEqual(value, 100U);
248 XCTAssertTrue([dict valueForKey:NO value:NULL]);
249 XCTAssertTrue([dict valueForKey:NO value:&value]);
250 XCTAssertEqual(value, 101U);
251 [dict2 release];
252 }
253
254 - (void)testRemove {
255 const BOOL kKeys[] = { YES, NO};
256 const uint32_t kValues[] = { 100U, 101U };
257 GPBBoolUInt32Dictionary *dict =
258 [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues
259 forKeys:kKeys
260 count:GPBARRAYSIZE(kValues)];
261 XCTAssertNotNil(dict);
262 XCTAssertEqual(dict.count, 2U);
263
264 [dict removeValueForKey:NO];
265 XCTAssertEqual(dict.count, 1U);
266 uint32_t value;
267 XCTAssertTrue([dict valueForKey:YES value:NULL]);
268 XCTAssertTrue([dict valueForKey:YES value:&value]);
269 XCTAssertEqual(value, 100U);
270 XCTAssertFalse([dict valueForKey:NO value:NULL]);
271
272 // Remove again does nothing.
273 [dict removeValueForKey:NO];
274 XCTAssertEqual(dict.count, 1U);
275 XCTAssertTrue([dict valueForKey:YES value:NULL]);
276 XCTAssertTrue([dict valueForKey:YES value:&value]);
277 XCTAssertEqual(value, 100U);
278 XCTAssertFalse([dict valueForKey:NO value:NULL]);
279
280 [dict removeAll];
281 XCTAssertEqual(dict.count, 0U);
282 XCTAssertFalse([dict valueForKey:YES value:NULL]);
283 XCTAssertFalse([dict valueForKey:NO value:NULL]);
284 [dict release];
285 }
286
287 - (void)testInplaceMutation {
288 const BOOL kKeys[] = { YES, NO };
289 const uint32_t kValues[] = { 100U, 101U };
290 GPBBoolUInt32Dictionary *dict =
291 [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues
292 forKeys:kKeys
293 count:GPBARRAYSIZE(kValues)];
294 XCTAssertNotNil(dict);
295 XCTAssertEqual(dict.count, 2U);
296 uint32_t value;
297 XCTAssertTrue([dict valueForKey:YES value:NULL]);
298 XCTAssertTrue([dict valueForKey:YES value:&value]);
299 XCTAssertEqual(value, 100U);
300 XCTAssertTrue([dict valueForKey:NO value:NULL]);
301 XCTAssertTrue([dict valueForKey:NO value:&value]);
302 XCTAssertEqual(value, 101U);
303
304 [dict setValue:101U forKey:YES];
305 XCTAssertEqual(dict.count, 2U);
306 XCTAssertTrue([dict valueForKey:YES value:NULL]);
307 XCTAssertTrue([dict valueForKey:YES value:&value]);
308 XCTAssertEqual(value, 101U);
309 XCTAssertTrue([dict valueForKey:NO value:NULL]);
310 XCTAssertTrue([dict valueForKey:NO value:&value]);
311 XCTAssertEqual(value, 101U);
312
313 [dict setValue:100U forKey:NO];
314 XCTAssertEqual(dict.count, 2U);
315 XCTAssertTrue([dict valueForKey:YES value:NULL]);
316 XCTAssertTrue([dict valueForKey:YES value:&value]);
317 XCTAssertEqual(value, 101U);
318 XCTAssertTrue([dict valueForKey:NO value:NULL]);
319 XCTAssertTrue([dict valueForKey:NO value:&value]);
320 XCTAssertEqual(value, 100U);
321
322 const BOOL kKeys2[] = { NO, YES };
323 const uint32_t kValues2[] = { 101U, 100U };
324 GPBBoolUInt32Dictionary *dict2 =
325 [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues2
326 forKeys:kKeys2
327 count:GPBARRAYSIZE(kValues2)];
328 XCTAssertNotNil(dict2);
329 [dict addEntriesFromDictionary:dict2];
330 XCTAssertEqual(dict.count, 2U);
331 XCTAssertTrue([dict valueForKey:YES value:NULL]);
332 XCTAssertTrue([dict valueForKey:YES value:&value]);
333 XCTAssertEqual(value, 100U);
334 XCTAssertTrue([dict valueForKey:NO value:NULL]);
335 XCTAssertTrue([dict valueForKey:NO value:&value]);
336 XCTAssertEqual(value, 101U);
337
338 [dict2 release];
339 [dict release];
340 }
341
342 @end
343
344 //%PDDM-EXPAND BOOL_TESTS_FOR_POD_VALUE(Int32, int32_t, 200, 201)
345 // This block of code is generated, do not edit it directly.
346
347 #pragma mark - Bool -> Int32
348
349 @interface GPBBoolInt32DictionaryTests : XCTestCase
350 @end
351
352 @implementation GPBBoolInt32DictionaryTests
353
354 - (void)testEmpty {
355 GPBBoolInt32Dictionary *dict = [[GPBBoolInt32Dictionary alloc] init];
356 XCTAssertNotNil(dict);
357 XCTAssertEqual(dict.count, 0U);
358 XCTAssertFalse([dict valueForKey:YES value:NULL]);
359 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop ) {
360 #pragma unused(aKey, aValue, stop)
361 XCTFail(@"Shouldn't get here!");
362 }];
363 [dict release];
364 }
365
366 - (void)testOne {
367 GPBBoolInt32Dictionary *dict = [GPBBoolInt32Dictionary dictionaryWithValue:200 forKey:YES];
368 XCTAssertNotNil(dict);
369 XCTAssertEqual(dict.count, 1U);
370 int32_t value;
371 XCTAssertTrue([dict valueForKey:YES value:NULL]);
372 XCTAssertTrue([dict valueForKey:YES value:&value]);
373 XCTAssertEqual(value, 200);
374 XCTAssertFalse([dict valueForKey:NO value:NULL]);
375 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop ) {
376 XCTAssertEqual(aKey, YES);
377 XCTAssertEqual(aValue, 200);
378 XCTAssertNotEqual(stop, NULL);
379 }];
380 }
381
382 - (void)testBasics {
383 const BOOL kKeys[] = { YES, NO };
384 const int32_t kValues[] = { 200, 201 };
385 GPBBoolInt32Dictionary *dict =
386 [[GPBBoolInt32Dictionary alloc] initWithValues:kValues
387 forKeys:kKeys
388 count:GPBARRAYSIZE(kValues)];
389 XCTAssertNotNil(dict);
390 XCTAssertEqual(dict.count, 2U);
391 int32_t value;
392 XCTAssertTrue([dict valueForKey:YES value:NULL]);
393 XCTAssertTrue([dict valueForKey:YES value:&value]);
394 XCTAssertEqual(value, 200);
395 XCTAssertTrue([dict valueForKey:NO value:NULL]);
396 XCTAssertTrue([dict valueForKey:NO value:&value]);
397 XCTAssertEqual(value, 201);
398
399 __block NSUInteger idx = 0;
400 BOOL *seenKeys = malloc(2 * sizeof(BOOL));
401 int32_t *seenValues = malloc(2 * sizeof(int32_t));
402 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop ) {
403 XCTAssertLessThan(idx, 2U);
404 seenKeys[idx] = aKey;
405 seenValues[idx] = aValue;
406 XCTAssertNotEqual(stop, NULL);
407 ++idx;
408 }];
409 for (int i = 0; i < 2; ++i) {
410 BOOL foundKey = NO;
411 for (int j = 0; (j < 2) && !foundKey; ++j) {
412 if (kKeys[i] == seenKeys[j]) {
413 foundKey = YES;
414 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j);
415 }
416 }
417 XCTAssertTrue(foundKey, @"i = %d", i);
418 }
419 free(seenKeys);
420 free(seenValues);
421
422 // Stopping the enumeration.
423 idx = 0;
424 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop ) {
425 #pragma unused(aKey, aValue)
426 if (idx == 0) *stop = YES;
427 XCTAssertNotEqual(idx, 2U);
428 ++idx;
429 }];
430 [dict release];
431 }
432
433 - (void)testEquality {
434 const BOOL kKeys1[] = { YES, NO };
435 const BOOL kKeys2[] = { NO, YES };
436 const int32_t kValues1[] = { 200, 201 };
437 const int32_t kValues2[] = { 201, 200 };
438 const int32_t kValues3[] = { 201 };
439 GPBBoolInt32Dictionary *dict1 =
440 [[GPBBoolInt32Dictionary alloc] initWithValues:kValues1
441 forKeys:kKeys1
442 count:GPBARRAYSIZE(kValues1)];
443 XCTAssertNotNil(dict1);
444 GPBBoolInt32Dictionary *dict1prime =
445 [[GPBBoolInt32Dictionary alloc] initWithValues:kValues1
446 forKeys:kKeys1
447 count:GPBARRAYSIZE(kValues1)];
448 XCTAssertNotNil(dict1prime);
449 GPBBoolInt32Dictionary *dict2 =
450 [[GPBBoolInt32Dictionary alloc] initWithValues:kValues2
451 forKeys:kKeys1
452 count:GPBARRAYSIZE(kValues2)];
453 XCTAssertNotNil(dict2);
454 GPBBoolInt32Dictionary *dict3 =
455 [[GPBBoolInt32Dictionary alloc] initWithValues:kValues1
456 forKeys:kKeys2
457 count:GPBARRAYSIZE(kValues1)];
458 XCTAssertNotNil(dict3);
459 GPBBoolInt32Dictionary *dict4 =
460 [[GPBBoolInt32Dictionary alloc] initWithValues:kValues3
461 forKeys:kKeys1
462 count:GPBARRAYSIZE(kValues3)];
463 XCTAssertNotNil(dict4);
464
465 // 1/1Prime should be different objects, but equal.
466 XCTAssertNotEqual(dict1, dict1prime);
467 XCTAssertEqualObjects(dict1, dict1prime);
468 // Equal, so they must have same hash.
469 XCTAssertEqual([dict1 hash], [dict1prime hash]);
470
471 // 2 is save keys, different values; not equal.
472 XCTAssertNotEqualObjects(dict1, dict2);
473
474 // 3 is different keys, samae values; not equal.
475 XCTAssertNotEqualObjects(dict1, dict3);
476
477 // 4 Fewer pairs; not equal
478 XCTAssertNotEqualObjects(dict1, dict4);
479
480 [dict1 release];
481 [dict1prime release];
482 [dict2 release];
483 [dict3 release];
484 [dict4 release];
485 }
486
487 - (void)testCopy {
488 const BOOL kKeys[] = { YES, NO };
489 const int32_t kValues[] = { 200, 201 };
490 GPBBoolInt32Dictionary *dict =
491 [[GPBBoolInt32Dictionary alloc] initWithValues:kValues
492 forKeys:kKeys
493 count:GPBARRAYSIZE(kValues)];
494 XCTAssertNotNil(dict);
495
496 GPBBoolInt32Dictionary *dict2 = [dict copy];
497 XCTAssertNotNil(dict2);
498
499 // Should be new object but equal.
500 XCTAssertNotEqual(dict, dict2);
501 XCTAssertEqualObjects(dict, dict2);
502 XCTAssertTrue([dict2 isKindOfClass:[GPBBoolInt32Dictionary class]]);
503
504 [dict2 release];
505 [dict release];
506 }
507
508 - (void)testDictionaryFromDictionary {
509 const BOOL kKeys[] = { YES, NO };
510 const int32_t kValues[] = { 200, 201 };
511 GPBBoolInt32Dictionary *dict =
512 [[GPBBoolInt32Dictionary alloc] initWithValues:kValues
513 forKeys:kKeys
514 count:GPBARRAYSIZE(kValues)];
515 XCTAssertNotNil(dict);
516
517 GPBBoolInt32Dictionary *dict2 =
518 [GPBBoolInt32Dictionary dictionaryWithDictionary:dict];
519 XCTAssertNotNil(dict2);
520
521 // Should be new pointer, but equal objects.
522 XCTAssertNotEqual(dict, dict2);
523 XCTAssertEqualObjects(dict, dict2);
524 [dict release];
525 }
526
527 - (void)testAdds {
528 GPBBoolInt32Dictionary *dict = [GPBBoolInt32Dictionary dictionary];
529 XCTAssertNotNil(dict);
530
531 XCTAssertEqual(dict.count, 0U);
532 [dict setValue:200 forKey:YES];
533 XCTAssertEqual(dict.count, 1U);
534
535 const BOOL kKeys[] = { NO };
536 const int32_t kValues[] = { 201 };
537 GPBBoolInt32Dictionary *dict2 =
538 [[GPBBoolInt32Dictionary alloc] initWithValues:kValues
539 forKeys:kKeys
540 count:GPBARRAYSIZE(kValues)];
541 XCTAssertNotNil(dict2);
542 [dict addEntriesFromDictionary:dict2];
543 XCTAssertEqual(dict.count, 2U);
544
545 int32_t value;
546 XCTAssertTrue([dict valueForKey:YES value:NULL]);
547 XCTAssertTrue([dict valueForKey:YES value:&value]);
548 XCTAssertEqual(value, 200);
549 XCTAssertTrue([dict valueForKey:NO value:NULL]);
550 XCTAssertTrue([dict valueForKey:NO value:&value]);
551 XCTAssertEqual(value, 201);
552 [dict2 release];
553 }
554
555 - (void)testRemove {
556 const BOOL kKeys[] = { YES, NO};
557 const int32_t kValues[] = { 200, 201 };
558 GPBBoolInt32Dictionary *dict =
559 [[GPBBoolInt32Dictionary alloc] initWithValues:kValues
560 forKeys:kKeys
561 count:GPBARRAYSIZE(kValues)];
562 XCTAssertNotNil(dict);
563 XCTAssertEqual(dict.count, 2U);
564
565 [dict removeValueForKey:NO];
566 XCTAssertEqual(dict.count, 1U);
567 int32_t value;
568 XCTAssertTrue([dict valueForKey:YES value:NULL]);
569 XCTAssertTrue([dict valueForKey:YES value:&value]);
570 XCTAssertEqual(value, 200);
571 XCTAssertFalse([dict valueForKey:NO value:NULL]);
572
573 // Remove again does nothing.
574 [dict removeValueForKey:NO];
575 XCTAssertEqual(dict.count, 1U);
576 XCTAssertTrue([dict valueForKey:YES value:NULL]);
577 XCTAssertTrue([dict valueForKey:YES value:&value]);
578 XCTAssertEqual(value, 200);
579 XCTAssertFalse([dict valueForKey:NO value:NULL]);
580
581 [dict removeAll];
582 XCTAssertEqual(dict.count, 0U);
583 XCTAssertFalse([dict valueForKey:YES value:NULL]);
584 XCTAssertFalse([dict valueForKey:NO value:NULL]);
585 [dict release];
586 }
587
588 - (void)testInplaceMutation {
589 const BOOL kKeys[] = { YES, NO };
590 const int32_t kValues[] = { 200, 201 };
591 GPBBoolInt32Dictionary *dict =
592 [[GPBBoolInt32Dictionary alloc] initWithValues:kValues
593 forKeys:kKeys
594 count:GPBARRAYSIZE(kValues)];
595 XCTAssertNotNil(dict);
596 XCTAssertEqual(dict.count, 2U);
597 int32_t value;
598 XCTAssertTrue([dict valueForKey:YES value:NULL]);
599 XCTAssertTrue([dict valueForKey:YES value:&value]);
600 XCTAssertEqual(value, 200);
601 XCTAssertTrue([dict valueForKey:NO value:NULL]);
602 XCTAssertTrue([dict valueForKey:NO value:&value]);
603 XCTAssertEqual(value, 201);
604
605 [dict setValue:201 forKey:YES];
606 XCTAssertEqual(dict.count, 2U);
607 XCTAssertTrue([dict valueForKey:YES value:NULL]);
608 XCTAssertTrue([dict valueForKey:YES value:&value]);
609 XCTAssertEqual(value, 201);
610 XCTAssertTrue([dict valueForKey:NO value:NULL]);
611 XCTAssertTrue([dict valueForKey:NO value:&value]);
612 XCTAssertEqual(value, 201);
613
614 [dict setValue:200 forKey:NO];
615 XCTAssertEqual(dict.count, 2U);
616 XCTAssertTrue([dict valueForKey:YES value:NULL]);
617 XCTAssertTrue([dict valueForKey:YES value:&value]);
618 XCTAssertEqual(value, 201);
619 XCTAssertTrue([dict valueForKey:NO value:NULL]);
620 XCTAssertTrue([dict valueForKey:NO value:&value]);
621 XCTAssertEqual(value, 200);
622
623 const BOOL kKeys2[] = { NO, YES };
624 const int32_t kValues2[] = { 201, 200 };
625 GPBBoolInt32Dictionary *dict2 =
626 [[GPBBoolInt32Dictionary alloc] initWithValues:kValues2
627 forKeys:kKeys2
628 count:GPBARRAYSIZE(kValues2)];
629 XCTAssertNotNil(dict2);
630 [dict addEntriesFromDictionary:dict2];
631 XCTAssertEqual(dict.count, 2U);
632 XCTAssertTrue([dict valueForKey:YES value:NULL]);
633 XCTAssertTrue([dict valueForKey:YES value:&value]);
634 XCTAssertEqual(value, 200);
635 XCTAssertTrue([dict valueForKey:NO value:NULL]);
636 XCTAssertTrue([dict valueForKey:NO value:&value]);
637 XCTAssertEqual(value, 201);
638
639 [dict2 release];
640 [dict release];
641 }
642
643 @end
644
645 //%PDDM-EXPAND BOOL_TESTS_FOR_POD_VALUE(UInt64, uint64_t, 300U, 301U)
646 // This block of code is generated, do not edit it directly.
647
648 #pragma mark - Bool -> UInt64
649
650 @interface GPBBoolUInt64DictionaryTests : XCTestCase
651 @end
652
653 @implementation GPBBoolUInt64DictionaryTests
654
655 - (void)testEmpty {
656 GPBBoolUInt64Dictionary *dict = [[GPBBoolUInt64Dictionary alloc] init];
657 XCTAssertNotNil(dict);
658 XCTAssertEqual(dict.count, 0U);
659 XCTAssertFalse([dict valueForKey:YES value:NULL]);
660 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *sto p) {
661 #pragma unused(aKey, aValue, stop)
662 XCTFail(@"Shouldn't get here!");
663 }];
664 [dict release];
665 }
666
667 - (void)testOne {
668 GPBBoolUInt64Dictionary *dict = [GPBBoolUInt64Dictionary dictionaryWithValue:3 00U forKey:YES];
669 XCTAssertNotNil(dict);
670 XCTAssertEqual(dict.count, 1U);
671 uint64_t value;
672 XCTAssertTrue([dict valueForKey:YES value:NULL]);
673 XCTAssertTrue([dict valueForKey:YES value:&value]);
674 XCTAssertEqual(value, 300U);
675 XCTAssertFalse([dict valueForKey:NO value:NULL]);
676 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *sto p) {
677 XCTAssertEqual(aKey, YES);
678 XCTAssertEqual(aValue, 300U);
679 XCTAssertNotEqual(stop, NULL);
680 }];
681 }
682
683 - (void)testBasics {
684 const BOOL kKeys[] = { YES, NO };
685 const uint64_t kValues[] = { 300U, 301U };
686 GPBBoolUInt64Dictionary *dict =
687 [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues
688 forKeys:kKeys
689 count:GPBARRAYSIZE(kValues)];
690 XCTAssertNotNil(dict);
691 XCTAssertEqual(dict.count, 2U);
692 uint64_t value;
693 XCTAssertTrue([dict valueForKey:YES value:NULL]);
694 XCTAssertTrue([dict valueForKey:YES value:&value]);
695 XCTAssertEqual(value, 300U);
696 XCTAssertTrue([dict valueForKey:NO value:NULL]);
697 XCTAssertTrue([dict valueForKey:NO value:&value]);
698 XCTAssertEqual(value, 301U);
699
700 __block NSUInteger idx = 0;
701 BOOL *seenKeys = malloc(2 * sizeof(BOOL));
702 uint64_t *seenValues = malloc(2 * sizeof(uint64_t));
703 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *sto p) {
704 XCTAssertLessThan(idx, 2U);
705 seenKeys[idx] = aKey;
706 seenValues[idx] = aValue;
707 XCTAssertNotEqual(stop, NULL);
708 ++idx;
709 }];
710 for (int i = 0; i < 2; ++i) {
711 BOOL foundKey = NO;
712 for (int j = 0; (j < 2) && !foundKey; ++j) {
713 if (kKeys[i] == seenKeys[j]) {
714 foundKey = YES;
715 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j);
716 }
717 }
718 XCTAssertTrue(foundKey, @"i = %d", i);
719 }
720 free(seenKeys);
721 free(seenValues);
722
723 // Stopping the enumeration.
724 idx = 0;
725 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *sto p) {
726 #pragma unused(aKey, aValue)
727 if (idx == 0) *stop = YES;
728 XCTAssertNotEqual(idx, 2U);
729 ++idx;
730 }];
731 [dict release];
732 }
733
734 - (void)testEquality {
735 const BOOL kKeys1[] = { YES, NO };
736 const BOOL kKeys2[] = { NO, YES };
737 const uint64_t kValues1[] = { 300U, 301U };
738 const uint64_t kValues2[] = { 301U, 300U };
739 const uint64_t kValues3[] = { 301U };
740 GPBBoolUInt64Dictionary *dict1 =
741 [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues1
742 forKeys:kKeys1
743 count:GPBARRAYSIZE(kValues1)];
744 XCTAssertNotNil(dict1);
745 GPBBoolUInt64Dictionary *dict1prime =
746 [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues1
747 forKeys:kKeys1
748 count:GPBARRAYSIZE(kValues1)];
749 XCTAssertNotNil(dict1prime);
750 GPBBoolUInt64Dictionary *dict2 =
751 [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues2
752 forKeys:kKeys1
753 count:GPBARRAYSIZE(kValues2)];
754 XCTAssertNotNil(dict2);
755 GPBBoolUInt64Dictionary *dict3 =
756 [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues1
757 forKeys:kKeys2
758 count:GPBARRAYSIZE(kValues1)];
759 XCTAssertNotNil(dict3);
760 GPBBoolUInt64Dictionary *dict4 =
761 [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues3
762 forKeys:kKeys1
763 count:GPBARRAYSIZE(kValues3)];
764 XCTAssertNotNil(dict4);
765
766 // 1/1Prime should be different objects, but equal.
767 XCTAssertNotEqual(dict1, dict1prime);
768 XCTAssertEqualObjects(dict1, dict1prime);
769 // Equal, so they must have same hash.
770 XCTAssertEqual([dict1 hash], [dict1prime hash]);
771
772 // 2 is save keys, different values; not equal.
773 XCTAssertNotEqualObjects(dict1, dict2);
774
775 // 3 is different keys, samae values; not equal.
776 XCTAssertNotEqualObjects(dict1, dict3);
777
778 // 4 Fewer pairs; not equal
779 XCTAssertNotEqualObjects(dict1, dict4);
780
781 [dict1 release];
782 [dict1prime release];
783 [dict2 release];
784 [dict3 release];
785 [dict4 release];
786 }
787
788 - (void)testCopy {
789 const BOOL kKeys[] = { YES, NO };
790 const uint64_t kValues[] = { 300U, 301U };
791 GPBBoolUInt64Dictionary *dict =
792 [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues
793 forKeys:kKeys
794 count:GPBARRAYSIZE(kValues)];
795 XCTAssertNotNil(dict);
796
797 GPBBoolUInt64Dictionary *dict2 = [dict copy];
798 XCTAssertNotNil(dict2);
799
800 // Should be new object but equal.
801 XCTAssertNotEqual(dict, dict2);
802 XCTAssertEqualObjects(dict, dict2);
803 XCTAssertTrue([dict2 isKindOfClass:[GPBBoolUInt64Dictionary class]]);
804
805 [dict2 release];
806 [dict release];
807 }
808
809 - (void)testDictionaryFromDictionary {
810 const BOOL kKeys[] = { YES, NO };
811 const uint64_t kValues[] = { 300U, 301U };
812 GPBBoolUInt64Dictionary *dict =
813 [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues
814 forKeys:kKeys
815 count:GPBARRAYSIZE(kValues)];
816 XCTAssertNotNil(dict);
817
818 GPBBoolUInt64Dictionary *dict2 =
819 [GPBBoolUInt64Dictionary dictionaryWithDictionary:dict];
820 XCTAssertNotNil(dict2);
821
822 // Should be new pointer, but equal objects.
823 XCTAssertNotEqual(dict, dict2);
824 XCTAssertEqualObjects(dict, dict2);
825 [dict release];
826 }
827
828 - (void)testAdds {
829 GPBBoolUInt64Dictionary *dict = [GPBBoolUInt64Dictionary dictionary];
830 XCTAssertNotNil(dict);
831
832 XCTAssertEqual(dict.count, 0U);
833 [dict setValue:300U forKey:YES];
834 XCTAssertEqual(dict.count, 1U);
835
836 const BOOL kKeys[] = { NO };
837 const uint64_t kValues[] = { 301U };
838 GPBBoolUInt64Dictionary *dict2 =
839 [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues
840 forKeys:kKeys
841 count:GPBARRAYSIZE(kValues)];
842 XCTAssertNotNil(dict2);
843 [dict addEntriesFromDictionary:dict2];
844 XCTAssertEqual(dict.count, 2U);
845
846 uint64_t value;
847 XCTAssertTrue([dict valueForKey:YES value:NULL]);
848 XCTAssertTrue([dict valueForKey:YES value:&value]);
849 XCTAssertEqual(value, 300U);
850 XCTAssertTrue([dict valueForKey:NO value:NULL]);
851 XCTAssertTrue([dict valueForKey:NO value:&value]);
852 XCTAssertEqual(value, 301U);
853 [dict2 release];
854 }
855
856 - (void)testRemove {
857 const BOOL kKeys[] = { YES, NO};
858 const uint64_t kValues[] = { 300U, 301U };
859 GPBBoolUInt64Dictionary *dict =
860 [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues
861 forKeys:kKeys
862 count:GPBARRAYSIZE(kValues)];
863 XCTAssertNotNil(dict);
864 XCTAssertEqual(dict.count, 2U);
865
866 [dict removeValueForKey:NO];
867 XCTAssertEqual(dict.count, 1U);
868 uint64_t value;
869 XCTAssertTrue([dict valueForKey:YES value:NULL]);
870 XCTAssertTrue([dict valueForKey:YES value:&value]);
871 XCTAssertEqual(value, 300U);
872 XCTAssertFalse([dict valueForKey:NO value:NULL]);
873
874 // Remove again does nothing.
875 [dict removeValueForKey:NO];
876 XCTAssertEqual(dict.count, 1U);
877 XCTAssertTrue([dict valueForKey:YES value:NULL]);
878 XCTAssertTrue([dict valueForKey:YES value:&value]);
879 XCTAssertEqual(value, 300U);
880 XCTAssertFalse([dict valueForKey:NO value:NULL]);
881
882 [dict removeAll];
883 XCTAssertEqual(dict.count, 0U);
884 XCTAssertFalse([dict valueForKey:YES value:NULL]);
885 XCTAssertFalse([dict valueForKey:NO value:NULL]);
886 [dict release];
887 }
888
889 - (void)testInplaceMutation {
890 const BOOL kKeys[] = { YES, NO };
891 const uint64_t kValues[] = { 300U, 301U };
892 GPBBoolUInt64Dictionary *dict =
893 [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues
894 forKeys:kKeys
895 count:GPBARRAYSIZE(kValues)];
896 XCTAssertNotNil(dict);
897 XCTAssertEqual(dict.count, 2U);
898 uint64_t value;
899 XCTAssertTrue([dict valueForKey:YES value:NULL]);
900 XCTAssertTrue([dict valueForKey:YES value:&value]);
901 XCTAssertEqual(value, 300U);
902 XCTAssertTrue([dict valueForKey:NO value:NULL]);
903 XCTAssertTrue([dict valueForKey:NO value:&value]);
904 XCTAssertEqual(value, 301U);
905
906 [dict setValue:301U forKey:YES];
907 XCTAssertEqual(dict.count, 2U);
908 XCTAssertTrue([dict valueForKey:YES value:NULL]);
909 XCTAssertTrue([dict valueForKey:YES value:&value]);
910 XCTAssertEqual(value, 301U);
911 XCTAssertTrue([dict valueForKey:NO value:NULL]);
912 XCTAssertTrue([dict valueForKey:NO value:&value]);
913 XCTAssertEqual(value, 301U);
914
915 [dict setValue:300U forKey:NO];
916 XCTAssertEqual(dict.count, 2U);
917 XCTAssertTrue([dict valueForKey:YES value:NULL]);
918 XCTAssertTrue([dict valueForKey:YES value:&value]);
919 XCTAssertEqual(value, 301U);
920 XCTAssertTrue([dict valueForKey:NO value:NULL]);
921 XCTAssertTrue([dict valueForKey:NO value:&value]);
922 XCTAssertEqual(value, 300U);
923
924 const BOOL kKeys2[] = { NO, YES };
925 const uint64_t kValues2[] = { 301U, 300U };
926 GPBBoolUInt64Dictionary *dict2 =
927 [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues2
928 forKeys:kKeys2
929 count:GPBARRAYSIZE(kValues2)];
930 XCTAssertNotNil(dict2);
931 [dict addEntriesFromDictionary:dict2];
932 XCTAssertEqual(dict.count, 2U);
933 XCTAssertTrue([dict valueForKey:YES value:NULL]);
934 XCTAssertTrue([dict valueForKey:YES value:&value]);
935 XCTAssertEqual(value, 300U);
936 XCTAssertTrue([dict valueForKey:NO value:NULL]);
937 XCTAssertTrue([dict valueForKey:NO value:&value]);
938 XCTAssertEqual(value, 301U);
939
940 [dict2 release];
941 [dict release];
942 }
943
944 @end
945
946 //%PDDM-EXPAND BOOL_TESTS_FOR_POD_VALUE(Int64, int64_t, 400, 401)
947 // This block of code is generated, do not edit it directly.
948
949 #pragma mark - Bool -> Int64
950
951 @interface GPBBoolInt64DictionaryTests : XCTestCase
952 @end
953
954 @implementation GPBBoolInt64DictionaryTests
955
956 - (void)testEmpty {
957 GPBBoolInt64Dictionary *dict = [[GPBBoolInt64Dictionary alloc] init];
958 XCTAssertNotNil(dict);
959 XCTAssertEqual(dict.count, 0U);
960 XCTAssertFalse([dict valueForKey:YES value:NULL]);
961 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop ) {
962 #pragma unused(aKey, aValue, stop)
963 XCTFail(@"Shouldn't get here!");
964 }];
965 [dict release];
966 }
967
968 - (void)testOne {
969 GPBBoolInt64Dictionary *dict = [GPBBoolInt64Dictionary dictionaryWithValue:400 forKey:YES];
970 XCTAssertNotNil(dict);
971 XCTAssertEqual(dict.count, 1U);
972 int64_t value;
973 XCTAssertTrue([dict valueForKey:YES value:NULL]);
974 XCTAssertTrue([dict valueForKey:YES value:&value]);
975 XCTAssertEqual(value, 400);
976 XCTAssertFalse([dict valueForKey:NO value:NULL]);
977 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop ) {
978 XCTAssertEqual(aKey, YES);
979 XCTAssertEqual(aValue, 400);
980 XCTAssertNotEqual(stop, NULL);
981 }];
982 }
983
984 - (void)testBasics {
985 const BOOL kKeys[] = { YES, NO };
986 const int64_t kValues[] = { 400, 401 };
987 GPBBoolInt64Dictionary *dict =
988 [[GPBBoolInt64Dictionary alloc] initWithValues:kValues
989 forKeys:kKeys
990 count:GPBARRAYSIZE(kValues)];
991 XCTAssertNotNil(dict);
992 XCTAssertEqual(dict.count, 2U);
993 int64_t value;
994 XCTAssertTrue([dict valueForKey:YES value:NULL]);
995 XCTAssertTrue([dict valueForKey:YES value:&value]);
996 XCTAssertEqual(value, 400);
997 XCTAssertTrue([dict valueForKey:NO value:NULL]);
998 XCTAssertTrue([dict valueForKey:NO value:&value]);
999 XCTAssertEqual(value, 401);
1000
1001 __block NSUInteger idx = 0;
1002 BOOL *seenKeys = malloc(2 * sizeof(BOOL));
1003 int64_t *seenValues = malloc(2 * sizeof(int64_t));
1004 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop ) {
1005 XCTAssertLessThan(idx, 2U);
1006 seenKeys[idx] = aKey;
1007 seenValues[idx] = aValue;
1008 XCTAssertNotEqual(stop, NULL);
1009 ++idx;
1010 }];
1011 for (int i = 0; i < 2; ++i) {
1012 BOOL foundKey = NO;
1013 for (int j = 0; (j < 2) && !foundKey; ++j) {
1014 if (kKeys[i] == seenKeys[j]) {
1015 foundKey = YES;
1016 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j);
1017 }
1018 }
1019 XCTAssertTrue(foundKey, @"i = %d", i);
1020 }
1021 free(seenKeys);
1022 free(seenValues);
1023
1024 // Stopping the enumeration.
1025 idx = 0;
1026 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop ) {
1027 #pragma unused(aKey, aValue)
1028 if (idx == 0) *stop = YES;
1029 XCTAssertNotEqual(idx, 2U);
1030 ++idx;
1031 }];
1032 [dict release];
1033 }
1034
1035 - (void)testEquality {
1036 const BOOL kKeys1[] = { YES, NO };
1037 const BOOL kKeys2[] = { NO, YES };
1038 const int64_t kValues1[] = { 400, 401 };
1039 const int64_t kValues2[] = { 401, 400 };
1040 const int64_t kValues3[] = { 401 };
1041 GPBBoolInt64Dictionary *dict1 =
1042 [[GPBBoolInt64Dictionary alloc] initWithValues:kValues1
1043 forKeys:kKeys1
1044 count:GPBARRAYSIZE(kValues1)];
1045 XCTAssertNotNil(dict1);
1046 GPBBoolInt64Dictionary *dict1prime =
1047 [[GPBBoolInt64Dictionary alloc] initWithValues:kValues1
1048 forKeys:kKeys1
1049 count:GPBARRAYSIZE(kValues1)];
1050 XCTAssertNotNil(dict1prime);
1051 GPBBoolInt64Dictionary *dict2 =
1052 [[GPBBoolInt64Dictionary alloc] initWithValues:kValues2
1053 forKeys:kKeys1
1054 count:GPBARRAYSIZE(kValues2)];
1055 XCTAssertNotNil(dict2);
1056 GPBBoolInt64Dictionary *dict3 =
1057 [[GPBBoolInt64Dictionary alloc] initWithValues:kValues1
1058 forKeys:kKeys2
1059 count:GPBARRAYSIZE(kValues1)];
1060 XCTAssertNotNil(dict3);
1061 GPBBoolInt64Dictionary *dict4 =
1062 [[GPBBoolInt64Dictionary alloc] initWithValues:kValues3
1063 forKeys:kKeys1
1064 count:GPBARRAYSIZE(kValues3)];
1065 XCTAssertNotNil(dict4);
1066
1067 // 1/1Prime should be different objects, but equal.
1068 XCTAssertNotEqual(dict1, dict1prime);
1069 XCTAssertEqualObjects(dict1, dict1prime);
1070 // Equal, so they must have same hash.
1071 XCTAssertEqual([dict1 hash], [dict1prime hash]);
1072
1073 // 2 is save keys, different values; not equal.
1074 XCTAssertNotEqualObjects(dict1, dict2);
1075
1076 // 3 is different keys, samae values; not equal.
1077 XCTAssertNotEqualObjects(dict1, dict3);
1078
1079 // 4 Fewer pairs; not equal
1080 XCTAssertNotEqualObjects(dict1, dict4);
1081
1082 [dict1 release];
1083 [dict1prime release];
1084 [dict2 release];
1085 [dict3 release];
1086 [dict4 release];
1087 }
1088
1089 - (void)testCopy {
1090 const BOOL kKeys[] = { YES, NO };
1091 const int64_t kValues[] = { 400, 401 };
1092 GPBBoolInt64Dictionary *dict =
1093 [[GPBBoolInt64Dictionary alloc] initWithValues:kValues
1094 forKeys:kKeys
1095 count:GPBARRAYSIZE(kValues)];
1096 XCTAssertNotNil(dict);
1097
1098 GPBBoolInt64Dictionary *dict2 = [dict copy];
1099 XCTAssertNotNil(dict2);
1100
1101 // Should be new object but equal.
1102 XCTAssertNotEqual(dict, dict2);
1103 XCTAssertEqualObjects(dict, dict2);
1104 XCTAssertTrue([dict2 isKindOfClass:[GPBBoolInt64Dictionary class]]);
1105
1106 [dict2 release];
1107 [dict release];
1108 }
1109
1110 - (void)testDictionaryFromDictionary {
1111 const BOOL kKeys[] = { YES, NO };
1112 const int64_t kValues[] = { 400, 401 };
1113 GPBBoolInt64Dictionary *dict =
1114 [[GPBBoolInt64Dictionary alloc] initWithValues:kValues
1115 forKeys:kKeys
1116 count:GPBARRAYSIZE(kValues)];
1117 XCTAssertNotNil(dict);
1118
1119 GPBBoolInt64Dictionary *dict2 =
1120 [GPBBoolInt64Dictionary dictionaryWithDictionary:dict];
1121 XCTAssertNotNil(dict2);
1122
1123 // Should be new pointer, but equal objects.
1124 XCTAssertNotEqual(dict, dict2);
1125 XCTAssertEqualObjects(dict, dict2);
1126 [dict release];
1127 }
1128
1129 - (void)testAdds {
1130 GPBBoolInt64Dictionary *dict = [GPBBoolInt64Dictionary dictionary];
1131 XCTAssertNotNil(dict);
1132
1133 XCTAssertEqual(dict.count, 0U);
1134 [dict setValue:400 forKey:YES];
1135 XCTAssertEqual(dict.count, 1U);
1136
1137 const BOOL kKeys[] = { NO };
1138 const int64_t kValues[] = { 401 };
1139 GPBBoolInt64Dictionary *dict2 =
1140 [[GPBBoolInt64Dictionary alloc] initWithValues:kValues
1141 forKeys:kKeys
1142 count:GPBARRAYSIZE(kValues)];
1143 XCTAssertNotNil(dict2);
1144 [dict addEntriesFromDictionary:dict2];
1145 XCTAssertEqual(dict.count, 2U);
1146
1147 int64_t value;
1148 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1149 XCTAssertTrue([dict valueForKey:YES value:&value]);
1150 XCTAssertEqual(value, 400);
1151 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1152 XCTAssertTrue([dict valueForKey:NO value:&value]);
1153 XCTAssertEqual(value, 401);
1154 [dict2 release];
1155 }
1156
1157 - (void)testRemove {
1158 const BOOL kKeys[] = { YES, NO};
1159 const int64_t kValues[] = { 400, 401 };
1160 GPBBoolInt64Dictionary *dict =
1161 [[GPBBoolInt64Dictionary alloc] initWithValues:kValues
1162 forKeys:kKeys
1163 count:GPBARRAYSIZE(kValues)];
1164 XCTAssertNotNil(dict);
1165 XCTAssertEqual(dict.count, 2U);
1166
1167 [dict removeValueForKey:NO];
1168 XCTAssertEqual(dict.count, 1U);
1169 int64_t value;
1170 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1171 XCTAssertTrue([dict valueForKey:YES value:&value]);
1172 XCTAssertEqual(value, 400);
1173 XCTAssertFalse([dict valueForKey:NO value:NULL]);
1174
1175 // Remove again does nothing.
1176 [dict removeValueForKey:NO];
1177 XCTAssertEqual(dict.count, 1U);
1178 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1179 XCTAssertTrue([dict valueForKey:YES value:&value]);
1180 XCTAssertEqual(value, 400);
1181 XCTAssertFalse([dict valueForKey:NO value:NULL]);
1182
1183 [dict removeAll];
1184 XCTAssertEqual(dict.count, 0U);
1185 XCTAssertFalse([dict valueForKey:YES value:NULL]);
1186 XCTAssertFalse([dict valueForKey:NO value:NULL]);
1187 [dict release];
1188 }
1189
1190 - (void)testInplaceMutation {
1191 const BOOL kKeys[] = { YES, NO };
1192 const int64_t kValues[] = { 400, 401 };
1193 GPBBoolInt64Dictionary *dict =
1194 [[GPBBoolInt64Dictionary alloc] initWithValues:kValues
1195 forKeys:kKeys
1196 count:GPBARRAYSIZE(kValues)];
1197 XCTAssertNotNil(dict);
1198 XCTAssertEqual(dict.count, 2U);
1199 int64_t value;
1200 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1201 XCTAssertTrue([dict valueForKey:YES value:&value]);
1202 XCTAssertEqual(value, 400);
1203 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1204 XCTAssertTrue([dict valueForKey:NO value:&value]);
1205 XCTAssertEqual(value, 401);
1206
1207 [dict setValue:401 forKey:YES];
1208 XCTAssertEqual(dict.count, 2U);
1209 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1210 XCTAssertTrue([dict valueForKey:YES value:&value]);
1211 XCTAssertEqual(value, 401);
1212 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1213 XCTAssertTrue([dict valueForKey:NO value:&value]);
1214 XCTAssertEqual(value, 401);
1215
1216 [dict setValue:400 forKey:NO];
1217 XCTAssertEqual(dict.count, 2U);
1218 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1219 XCTAssertTrue([dict valueForKey:YES value:&value]);
1220 XCTAssertEqual(value, 401);
1221 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1222 XCTAssertTrue([dict valueForKey:NO value:&value]);
1223 XCTAssertEqual(value, 400);
1224
1225 const BOOL kKeys2[] = { NO, YES };
1226 const int64_t kValues2[] = { 401, 400 };
1227 GPBBoolInt64Dictionary *dict2 =
1228 [[GPBBoolInt64Dictionary alloc] initWithValues:kValues2
1229 forKeys:kKeys2
1230 count:GPBARRAYSIZE(kValues2)];
1231 XCTAssertNotNil(dict2);
1232 [dict addEntriesFromDictionary:dict2];
1233 XCTAssertEqual(dict.count, 2U);
1234 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1235 XCTAssertTrue([dict valueForKey:YES value:&value]);
1236 XCTAssertEqual(value, 400);
1237 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1238 XCTAssertTrue([dict valueForKey:NO value:&value]);
1239 XCTAssertEqual(value, 401);
1240
1241 [dict2 release];
1242 [dict release];
1243 }
1244
1245 @end
1246
1247 //%PDDM-EXPAND BOOL_TESTS_FOR_POD_VALUE(Bool, BOOL, NO, YES)
1248 // This block of code is generated, do not edit it directly.
1249
1250 #pragma mark - Bool -> Bool
1251
1252 @interface GPBBoolBoolDictionaryTests : XCTestCase
1253 @end
1254
1255 @implementation GPBBoolBoolDictionaryTests
1256
1257 - (void)testEmpty {
1258 GPBBoolBoolDictionary *dict = [[GPBBoolBoolDictionary alloc] init];
1259 XCTAssertNotNil(dict);
1260 XCTAssertEqual(dict.count, 0U);
1261 XCTAssertFalse([dict valueForKey:YES value:NULL]);
1262 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) {
1263 #pragma unused(aKey, aValue, stop)
1264 XCTFail(@"Shouldn't get here!");
1265 }];
1266 [dict release];
1267 }
1268
1269 - (void)testOne {
1270 GPBBoolBoolDictionary *dict = [GPBBoolBoolDictionary dictionaryWithValue:NO fo rKey:YES];
1271 XCTAssertNotNil(dict);
1272 XCTAssertEqual(dict.count, 1U);
1273 BOOL value;
1274 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1275 XCTAssertTrue([dict valueForKey:YES value:&value]);
1276 XCTAssertEqual(value, NO);
1277 XCTAssertFalse([dict valueForKey:NO value:NULL]);
1278 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) {
1279 XCTAssertEqual(aKey, YES);
1280 XCTAssertEqual(aValue, NO);
1281 XCTAssertNotEqual(stop, NULL);
1282 }];
1283 }
1284
1285 - (void)testBasics {
1286 const BOOL kKeys[] = { YES, NO };
1287 const BOOL kValues[] = { NO, YES };
1288 GPBBoolBoolDictionary *dict =
1289 [[GPBBoolBoolDictionary alloc] initWithValues:kValues
1290 forKeys:kKeys
1291 count:GPBARRAYSIZE(kValues)];
1292 XCTAssertNotNil(dict);
1293 XCTAssertEqual(dict.count, 2U);
1294 BOOL value;
1295 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1296 XCTAssertTrue([dict valueForKey:YES value:&value]);
1297 XCTAssertEqual(value, NO);
1298 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1299 XCTAssertTrue([dict valueForKey:NO value:&value]);
1300 XCTAssertEqual(value, YES);
1301
1302 __block NSUInteger idx = 0;
1303 BOOL *seenKeys = malloc(2 * sizeof(BOOL));
1304 BOOL *seenValues = malloc(2 * sizeof(BOOL));
1305 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) {
1306 XCTAssertLessThan(idx, 2U);
1307 seenKeys[idx] = aKey;
1308 seenValues[idx] = aValue;
1309 XCTAssertNotEqual(stop, NULL);
1310 ++idx;
1311 }];
1312 for (int i = 0; i < 2; ++i) {
1313 BOOL foundKey = NO;
1314 for (int j = 0; (j < 2) && !foundKey; ++j) {
1315 if (kKeys[i] == seenKeys[j]) {
1316 foundKey = YES;
1317 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j);
1318 }
1319 }
1320 XCTAssertTrue(foundKey, @"i = %d", i);
1321 }
1322 free(seenKeys);
1323 free(seenValues);
1324
1325 // Stopping the enumeration.
1326 idx = 0;
1327 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) {
1328 #pragma unused(aKey, aValue)
1329 if (idx == 0) *stop = YES;
1330 XCTAssertNotEqual(idx, 2U);
1331 ++idx;
1332 }];
1333 [dict release];
1334 }
1335
1336 - (void)testEquality {
1337 const BOOL kKeys1[] = { YES, NO };
1338 const BOOL kKeys2[] = { NO, YES };
1339 const BOOL kValues1[] = { NO, YES };
1340 const BOOL kValues2[] = { YES, NO };
1341 const BOOL kValues3[] = { YES };
1342 GPBBoolBoolDictionary *dict1 =
1343 [[GPBBoolBoolDictionary alloc] initWithValues:kValues1
1344 forKeys:kKeys1
1345 count:GPBARRAYSIZE(kValues1)];
1346 XCTAssertNotNil(dict1);
1347 GPBBoolBoolDictionary *dict1prime =
1348 [[GPBBoolBoolDictionary alloc] initWithValues:kValues1
1349 forKeys:kKeys1
1350 count:GPBARRAYSIZE(kValues1)];
1351 XCTAssertNotNil(dict1prime);
1352 GPBBoolBoolDictionary *dict2 =
1353 [[GPBBoolBoolDictionary alloc] initWithValues:kValues2
1354 forKeys:kKeys1
1355 count:GPBARRAYSIZE(kValues2)];
1356 XCTAssertNotNil(dict2);
1357 GPBBoolBoolDictionary *dict3 =
1358 [[GPBBoolBoolDictionary alloc] initWithValues:kValues1
1359 forKeys:kKeys2
1360 count:GPBARRAYSIZE(kValues1)];
1361 XCTAssertNotNil(dict3);
1362 GPBBoolBoolDictionary *dict4 =
1363 [[GPBBoolBoolDictionary alloc] initWithValues:kValues3
1364 forKeys:kKeys1
1365 count:GPBARRAYSIZE(kValues3)];
1366 XCTAssertNotNil(dict4);
1367
1368 // 1/1Prime should be different objects, but equal.
1369 XCTAssertNotEqual(dict1, dict1prime);
1370 XCTAssertEqualObjects(dict1, dict1prime);
1371 // Equal, so they must have same hash.
1372 XCTAssertEqual([dict1 hash], [dict1prime hash]);
1373
1374 // 2 is save keys, different values; not equal.
1375 XCTAssertNotEqualObjects(dict1, dict2);
1376
1377 // 3 is different keys, samae values; not equal.
1378 XCTAssertNotEqualObjects(dict1, dict3);
1379
1380 // 4 Fewer pairs; not equal
1381 XCTAssertNotEqualObjects(dict1, dict4);
1382
1383 [dict1 release];
1384 [dict1prime release];
1385 [dict2 release];
1386 [dict3 release];
1387 [dict4 release];
1388 }
1389
1390 - (void)testCopy {
1391 const BOOL kKeys[] = { YES, NO };
1392 const BOOL kValues[] = { NO, YES };
1393 GPBBoolBoolDictionary *dict =
1394 [[GPBBoolBoolDictionary alloc] initWithValues:kValues
1395 forKeys:kKeys
1396 count:GPBARRAYSIZE(kValues)];
1397 XCTAssertNotNil(dict);
1398
1399 GPBBoolBoolDictionary *dict2 = [dict copy];
1400 XCTAssertNotNil(dict2);
1401
1402 // Should be new object but equal.
1403 XCTAssertNotEqual(dict, dict2);
1404 XCTAssertEqualObjects(dict, dict2);
1405 XCTAssertTrue([dict2 isKindOfClass:[GPBBoolBoolDictionary class]]);
1406
1407 [dict2 release];
1408 [dict release];
1409 }
1410
1411 - (void)testDictionaryFromDictionary {
1412 const BOOL kKeys[] = { YES, NO };
1413 const BOOL kValues[] = { NO, YES };
1414 GPBBoolBoolDictionary *dict =
1415 [[GPBBoolBoolDictionary alloc] initWithValues:kValues
1416 forKeys:kKeys
1417 count:GPBARRAYSIZE(kValues)];
1418 XCTAssertNotNil(dict);
1419
1420 GPBBoolBoolDictionary *dict2 =
1421 [GPBBoolBoolDictionary dictionaryWithDictionary:dict];
1422 XCTAssertNotNil(dict2);
1423
1424 // Should be new pointer, but equal objects.
1425 XCTAssertNotEqual(dict, dict2);
1426 XCTAssertEqualObjects(dict, dict2);
1427 [dict release];
1428 }
1429
1430 - (void)testAdds {
1431 GPBBoolBoolDictionary *dict = [GPBBoolBoolDictionary dictionary];
1432 XCTAssertNotNil(dict);
1433
1434 XCTAssertEqual(dict.count, 0U);
1435 [dict setValue:NO forKey:YES];
1436 XCTAssertEqual(dict.count, 1U);
1437
1438 const BOOL kKeys[] = { NO };
1439 const BOOL kValues[] = { YES };
1440 GPBBoolBoolDictionary *dict2 =
1441 [[GPBBoolBoolDictionary alloc] initWithValues:kValues
1442 forKeys:kKeys
1443 count:GPBARRAYSIZE(kValues)];
1444 XCTAssertNotNil(dict2);
1445 [dict addEntriesFromDictionary:dict2];
1446 XCTAssertEqual(dict.count, 2U);
1447
1448 BOOL value;
1449 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1450 XCTAssertTrue([dict valueForKey:YES value:&value]);
1451 XCTAssertEqual(value, NO);
1452 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1453 XCTAssertTrue([dict valueForKey:NO value:&value]);
1454 XCTAssertEqual(value, YES);
1455 [dict2 release];
1456 }
1457
1458 - (void)testRemove {
1459 const BOOL kKeys[] = { YES, NO};
1460 const BOOL kValues[] = { NO, YES };
1461 GPBBoolBoolDictionary *dict =
1462 [[GPBBoolBoolDictionary alloc] initWithValues:kValues
1463 forKeys:kKeys
1464 count:GPBARRAYSIZE(kValues)];
1465 XCTAssertNotNil(dict);
1466 XCTAssertEqual(dict.count, 2U);
1467
1468 [dict removeValueForKey:NO];
1469 XCTAssertEqual(dict.count, 1U);
1470 BOOL value;
1471 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1472 XCTAssertTrue([dict valueForKey:YES value:&value]);
1473 XCTAssertEqual(value, NO);
1474 XCTAssertFalse([dict valueForKey:NO value:NULL]);
1475
1476 // Remove again does nothing.
1477 [dict removeValueForKey:NO];
1478 XCTAssertEqual(dict.count, 1U);
1479 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1480 XCTAssertTrue([dict valueForKey:YES value:&value]);
1481 XCTAssertEqual(value, NO);
1482 XCTAssertFalse([dict valueForKey:NO value:NULL]);
1483
1484 [dict removeAll];
1485 XCTAssertEqual(dict.count, 0U);
1486 XCTAssertFalse([dict valueForKey:YES value:NULL]);
1487 XCTAssertFalse([dict valueForKey:NO value:NULL]);
1488 [dict release];
1489 }
1490
1491 - (void)testInplaceMutation {
1492 const BOOL kKeys[] = { YES, NO };
1493 const BOOL kValues[] = { NO, YES };
1494 GPBBoolBoolDictionary *dict =
1495 [[GPBBoolBoolDictionary alloc] initWithValues:kValues
1496 forKeys:kKeys
1497 count:GPBARRAYSIZE(kValues)];
1498 XCTAssertNotNil(dict);
1499 XCTAssertEqual(dict.count, 2U);
1500 BOOL value;
1501 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1502 XCTAssertTrue([dict valueForKey:YES value:&value]);
1503 XCTAssertEqual(value, NO);
1504 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1505 XCTAssertTrue([dict valueForKey:NO value:&value]);
1506 XCTAssertEqual(value, YES);
1507
1508 [dict setValue:YES forKey:YES];
1509 XCTAssertEqual(dict.count, 2U);
1510 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1511 XCTAssertTrue([dict valueForKey:YES value:&value]);
1512 XCTAssertEqual(value, YES);
1513 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1514 XCTAssertTrue([dict valueForKey:NO value:&value]);
1515 XCTAssertEqual(value, YES);
1516
1517 [dict setValue:NO forKey:NO];
1518 XCTAssertEqual(dict.count, 2U);
1519 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1520 XCTAssertTrue([dict valueForKey:YES value:&value]);
1521 XCTAssertEqual(value, YES);
1522 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1523 XCTAssertTrue([dict valueForKey:NO value:&value]);
1524 XCTAssertEqual(value, NO);
1525
1526 const BOOL kKeys2[] = { NO, YES };
1527 const BOOL kValues2[] = { YES, NO };
1528 GPBBoolBoolDictionary *dict2 =
1529 [[GPBBoolBoolDictionary alloc] initWithValues:kValues2
1530 forKeys:kKeys2
1531 count:GPBARRAYSIZE(kValues2)];
1532 XCTAssertNotNil(dict2);
1533 [dict addEntriesFromDictionary:dict2];
1534 XCTAssertEqual(dict.count, 2U);
1535 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1536 XCTAssertTrue([dict valueForKey:YES value:&value]);
1537 XCTAssertEqual(value, NO);
1538 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1539 XCTAssertTrue([dict valueForKey:NO value:&value]);
1540 XCTAssertEqual(value, YES);
1541
1542 [dict2 release];
1543 [dict release];
1544 }
1545
1546 @end
1547
1548 //%PDDM-EXPAND BOOL_TESTS_FOR_POD_VALUE(Float, float, 500.f, 501.f)
1549 // This block of code is generated, do not edit it directly.
1550
1551 #pragma mark - Bool -> Float
1552
1553 @interface GPBBoolFloatDictionaryTests : XCTestCase
1554 @end
1555
1556 @implementation GPBBoolFloatDictionaryTests
1557
1558 - (void)testEmpty {
1559 GPBBoolFloatDictionary *dict = [[GPBBoolFloatDictionary alloc] init];
1560 XCTAssertNotNil(dict);
1561 XCTAssertEqual(dict.count, 0U);
1562 XCTAssertFalse([dict valueForKey:YES value:NULL]);
1563 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) {
1564 #pragma unused(aKey, aValue, stop)
1565 XCTFail(@"Shouldn't get here!");
1566 }];
1567 [dict release];
1568 }
1569
1570 - (void)testOne {
1571 GPBBoolFloatDictionary *dict = [GPBBoolFloatDictionary dictionaryWithValue:500 .f forKey:YES];
1572 XCTAssertNotNil(dict);
1573 XCTAssertEqual(dict.count, 1U);
1574 float value;
1575 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1576 XCTAssertTrue([dict valueForKey:YES value:&value]);
1577 XCTAssertEqual(value, 500.f);
1578 XCTAssertFalse([dict valueForKey:NO value:NULL]);
1579 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) {
1580 XCTAssertEqual(aKey, YES);
1581 XCTAssertEqual(aValue, 500.f);
1582 XCTAssertNotEqual(stop, NULL);
1583 }];
1584 }
1585
1586 - (void)testBasics {
1587 const BOOL kKeys[] = { YES, NO };
1588 const float kValues[] = { 500.f, 501.f };
1589 GPBBoolFloatDictionary *dict =
1590 [[GPBBoolFloatDictionary alloc] initWithValues:kValues
1591 forKeys:kKeys
1592 count:GPBARRAYSIZE(kValues)];
1593 XCTAssertNotNil(dict);
1594 XCTAssertEqual(dict.count, 2U);
1595 float value;
1596 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1597 XCTAssertTrue([dict valueForKey:YES value:&value]);
1598 XCTAssertEqual(value, 500.f);
1599 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1600 XCTAssertTrue([dict valueForKey:NO value:&value]);
1601 XCTAssertEqual(value, 501.f);
1602
1603 __block NSUInteger idx = 0;
1604 BOOL *seenKeys = malloc(2 * sizeof(BOOL));
1605 float *seenValues = malloc(2 * sizeof(float));
1606 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) {
1607 XCTAssertLessThan(idx, 2U);
1608 seenKeys[idx] = aKey;
1609 seenValues[idx] = aValue;
1610 XCTAssertNotEqual(stop, NULL);
1611 ++idx;
1612 }];
1613 for (int i = 0; i < 2; ++i) {
1614 BOOL foundKey = NO;
1615 for (int j = 0; (j < 2) && !foundKey; ++j) {
1616 if (kKeys[i] == seenKeys[j]) {
1617 foundKey = YES;
1618 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j);
1619 }
1620 }
1621 XCTAssertTrue(foundKey, @"i = %d", i);
1622 }
1623 free(seenKeys);
1624 free(seenValues);
1625
1626 // Stopping the enumeration.
1627 idx = 0;
1628 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) {
1629 #pragma unused(aKey, aValue)
1630 if (idx == 0) *stop = YES;
1631 XCTAssertNotEqual(idx, 2U);
1632 ++idx;
1633 }];
1634 [dict release];
1635 }
1636
1637 - (void)testEquality {
1638 const BOOL kKeys1[] = { YES, NO };
1639 const BOOL kKeys2[] = { NO, YES };
1640 const float kValues1[] = { 500.f, 501.f };
1641 const float kValues2[] = { 501.f, 500.f };
1642 const float kValues3[] = { 501.f };
1643 GPBBoolFloatDictionary *dict1 =
1644 [[GPBBoolFloatDictionary alloc] initWithValues:kValues1
1645 forKeys:kKeys1
1646 count:GPBARRAYSIZE(kValues1)];
1647 XCTAssertNotNil(dict1);
1648 GPBBoolFloatDictionary *dict1prime =
1649 [[GPBBoolFloatDictionary alloc] initWithValues:kValues1
1650 forKeys:kKeys1
1651 count:GPBARRAYSIZE(kValues1)];
1652 XCTAssertNotNil(dict1prime);
1653 GPBBoolFloatDictionary *dict2 =
1654 [[GPBBoolFloatDictionary alloc] initWithValues:kValues2
1655 forKeys:kKeys1
1656 count:GPBARRAYSIZE(kValues2)];
1657 XCTAssertNotNil(dict2);
1658 GPBBoolFloatDictionary *dict3 =
1659 [[GPBBoolFloatDictionary alloc] initWithValues:kValues1
1660 forKeys:kKeys2
1661 count:GPBARRAYSIZE(kValues1)];
1662 XCTAssertNotNil(dict3);
1663 GPBBoolFloatDictionary *dict4 =
1664 [[GPBBoolFloatDictionary alloc] initWithValues:kValues3
1665 forKeys:kKeys1
1666 count:GPBARRAYSIZE(kValues3)];
1667 XCTAssertNotNil(dict4);
1668
1669 // 1/1Prime should be different objects, but equal.
1670 XCTAssertNotEqual(dict1, dict1prime);
1671 XCTAssertEqualObjects(dict1, dict1prime);
1672 // Equal, so they must have same hash.
1673 XCTAssertEqual([dict1 hash], [dict1prime hash]);
1674
1675 // 2 is save keys, different values; not equal.
1676 XCTAssertNotEqualObjects(dict1, dict2);
1677
1678 // 3 is different keys, samae values; not equal.
1679 XCTAssertNotEqualObjects(dict1, dict3);
1680
1681 // 4 Fewer pairs; not equal
1682 XCTAssertNotEqualObjects(dict1, dict4);
1683
1684 [dict1 release];
1685 [dict1prime release];
1686 [dict2 release];
1687 [dict3 release];
1688 [dict4 release];
1689 }
1690
1691 - (void)testCopy {
1692 const BOOL kKeys[] = { YES, NO };
1693 const float kValues[] = { 500.f, 501.f };
1694 GPBBoolFloatDictionary *dict =
1695 [[GPBBoolFloatDictionary alloc] initWithValues:kValues
1696 forKeys:kKeys
1697 count:GPBARRAYSIZE(kValues)];
1698 XCTAssertNotNil(dict);
1699
1700 GPBBoolFloatDictionary *dict2 = [dict copy];
1701 XCTAssertNotNil(dict2);
1702
1703 // Should be new object but equal.
1704 XCTAssertNotEqual(dict, dict2);
1705 XCTAssertEqualObjects(dict, dict2);
1706 XCTAssertTrue([dict2 isKindOfClass:[GPBBoolFloatDictionary class]]);
1707
1708 [dict2 release];
1709 [dict release];
1710 }
1711
1712 - (void)testDictionaryFromDictionary {
1713 const BOOL kKeys[] = { YES, NO };
1714 const float kValues[] = { 500.f, 501.f };
1715 GPBBoolFloatDictionary *dict =
1716 [[GPBBoolFloatDictionary alloc] initWithValues:kValues
1717 forKeys:kKeys
1718 count:GPBARRAYSIZE(kValues)];
1719 XCTAssertNotNil(dict);
1720
1721 GPBBoolFloatDictionary *dict2 =
1722 [GPBBoolFloatDictionary dictionaryWithDictionary:dict];
1723 XCTAssertNotNil(dict2);
1724
1725 // Should be new pointer, but equal objects.
1726 XCTAssertNotEqual(dict, dict2);
1727 XCTAssertEqualObjects(dict, dict2);
1728 [dict release];
1729 }
1730
1731 - (void)testAdds {
1732 GPBBoolFloatDictionary *dict = [GPBBoolFloatDictionary dictionary];
1733 XCTAssertNotNil(dict);
1734
1735 XCTAssertEqual(dict.count, 0U);
1736 [dict setValue:500.f forKey:YES];
1737 XCTAssertEqual(dict.count, 1U);
1738
1739 const BOOL kKeys[] = { NO };
1740 const float kValues[] = { 501.f };
1741 GPBBoolFloatDictionary *dict2 =
1742 [[GPBBoolFloatDictionary alloc] initWithValues:kValues
1743 forKeys:kKeys
1744 count:GPBARRAYSIZE(kValues)];
1745 XCTAssertNotNil(dict2);
1746 [dict addEntriesFromDictionary:dict2];
1747 XCTAssertEqual(dict.count, 2U);
1748
1749 float value;
1750 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1751 XCTAssertTrue([dict valueForKey:YES value:&value]);
1752 XCTAssertEqual(value, 500.f);
1753 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1754 XCTAssertTrue([dict valueForKey:NO value:&value]);
1755 XCTAssertEqual(value, 501.f);
1756 [dict2 release];
1757 }
1758
1759 - (void)testRemove {
1760 const BOOL kKeys[] = { YES, NO};
1761 const float kValues[] = { 500.f, 501.f };
1762 GPBBoolFloatDictionary *dict =
1763 [[GPBBoolFloatDictionary alloc] initWithValues:kValues
1764 forKeys:kKeys
1765 count:GPBARRAYSIZE(kValues)];
1766 XCTAssertNotNil(dict);
1767 XCTAssertEqual(dict.count, 2U);
1768
1769 [dict removeValueForKey:NO];
1770 XCTAssertEqual(dict.count, 1U);
1771 float value;
1772 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1773 XCTAssertTrue([dict valueForKey:YES value:&value]);
1774 XCTAssertEqual(value, 500.f);
1775 XCTAssertFalse([dict valueForKey:NO value:NULL]);
1776
1777 // Remove again does nothing.
1778 [dict removeValueForKey:NO];
1779 XCTAssertEqual(dict.count, 1U);
1780 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1781 XCTAssertTrue([dict valueForKey:YES value:&value]);
1782 XCTAssertEqual(value, 500.f);
1783 XCTAssertFalse([dict valueForKey:NO value:NULL]);
1784
1785 [dict removeAll];
1786 XCTAssertEqual(dict.count, 0U);
1787 XCTAssertFalse([dict valueForKey:YES value:NULL]);
1788 XCTAssertFalse([dict valueForKey:NO value:NULL]);
1789 [dict release];
1790 }
1791
1792 - (void)testInplaceMutation {
1793 const BOOL kKeys[] = { YES, NO };
1794 const float kValues[] = { 500.f, 501.f };
1795 GPBBoolFloatDictionary *dict =
1796 [[GPBBoolFloatDictionary alloc] initWithValues:kValues
1797 forKeys:kKeys
1798 count:GPBARRAYSIZE(kValues)];
1799 XCTAssertNotNil(dict);
1800 XCTAssertEqual(dict.count, 2U);
1801 float value;
1802 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1803 XCTAssertTrue([dict valueForKey:YES value:&value]);
1804 XCTAssertEqual(value, 500.f);
1805 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1806 XCTAssertTrue([dict valueForKey:NO value:&value]);
1807 XCTAssertEqual(value, 501.f);
1808
1809 [dict setValue:501.f forKey:YES];
1810 XCTAssertEqual(dict.count, 2U);
1811 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1812 XCTAssertTrue([dict valueForKey:YES value:&value]);
1813 XCTAssertEqual(value, 501.f);
1814 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1815 XCTAssertTrue([dict valueForKey:NO value:&value]);
1816 XCTAssertEqual(value, 501.f);
1817
1818 [dict setValue:500.f forKey:NO];
1819 XCTAssertEqual(dict.count, 2U);
1820 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1821 XCTAssertTrue([dict valueForKey:YES value:&value]);
1822 XCTAssertEqual(value, 501.f);
1823 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1824 XCTAssertTrue([dict valueForKey:NO value:&value]);
1825 XCTAssertEqual(value, 500.f);
1826
1827 const BOOL kKeys2[] = { NO, YES };
1828 const float kValues2[] = { 501.f, 500.f };
1829 GPBBoolFloatDictionary *dict2 =
1830 [[GPBBoolFloatDictionary alloc] initWithValues:kValues2
1831 forKeys:kKeys2
1832 count:GPBARRAYSIZE(kValues2)];
1833 XCTAssertNotNil(dict2);
1834 [dict addEntriesFromDictionary:dict2];
1835 XCTAssertEqual(dict.count, 2U);
1836 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1837 XCTAssertTrue([dict valueForKey:YES value:&value]);
1838 XCTAssertEqual(value, 500.f);
1839 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1840 XCTAssertTrue([dict valueForKey:NO value:&value]);
1841 XCTAssertEqual(value, 501.f);
1842
1843 [dict2 release];
1844 [dict release];
1845 }
1846
1847 @end
1848
1849 //%PDDM-EXPAND BOOL_TESTS_FOR_POD_VALUE(Double, double, 600., 601.)
1850 // This block of code is generated, do not edit it directly.
1851
1852 #pragma mark - Bool -> Double
1853
1854 @interface GPBBoolDoubleDictionaryTests : XCTestCase
1855 @end
1856
1857 @implementation GPBBoolDoubleDictionaryTests
1858
1859 - (void)testEmpty {
1860 GPBBoolDoubleDictionary *dict = [[GPBBoolDoubleDictionary alloc] init];
1861 XCTAssertNotNil(dict);
1862 XCTAssertEqual(dict.count, 0U);
1863 XCTAssertFalse([dict valueForKey:YES value:NULL]);
1864 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) {
1865 #pragma unused(aKey, aValue, stop)
1866 XCTFail(@"Shouldn't get here!");
1867 }];
1868 [dict release];
1869 }
1870
1871 - (void)testOne {
1872 GPBBoolDoubleDictionary *dict = [GPBBoolDoubleDictionary dictionaryWithValue:6 00. forKey:YES];
1873 XCTAssertNotNil(dict);
1874 XCTAssertEqual(dict.count, 1U);
1875 double value;
1876 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1877 XCTAssertTrue([dict valueForKey:YES value:&value]);
1878 XCTAssertEqual(value, 600.);
1879 XCTAssertFalse([dict valueForKey:NO value:NULL]);
1880 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) {
1881 XCTAssertEqual(aKey, YES);
1882 XCTAssertEqual(aValue, 600.);
1883 XCTAssertNotEqual(stop, NULL);
1884 }];
1885 }
1886
1887 - (void)testBasics {
1888 const BOOL kKeys[] = { YES, NO };
1889 const double kValues[] = { 600., 601. };
1890 GPBBoolDoubleDictionary *dict =
1891 [[GPBBoolDoubleDictionary alloc] initWithValues:kValues
1892 forKeys:kKeys
1893 count:GPBARRAYSIZE(kValues)];
1894 XCTAssertNotNil(dict);
1895 XCTAssertEqual(dict.count, 2U);
1896 double value;
1897 XCTAssertTrue([dict valueForKey:YES value:NULL]);
1898 XCTAssertTrue([dict valueForKey:YES value:&value]);
1899 XCTAssertEqual(value, 600.);
1900 XCTAssertTrue([dict valueForKey:NO value:NULL]);
1901 XCTAssertTrue([dict valueForKey:NO value:&value]);
1902 XCTAssertEqual(value, 601.);
1903
1904 __block NSUInteger idx = 0;
1905 BOOL *seenKeys = malloc(2 * sizeof(BOOL));
1906 double *seenValues = malloc(2 * sizeof(double));
1907 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) {
1908 XCTAssertLessThan(idx, 2U);
1909 seenKeys[idx] = aKey;
1910 seenValues[idx] = aValue;
1911 XCTAssertNotEqual(stop, NULL);
1912 ++idx;
1913 }];
1914 for (int i = 0; i < 2; ++i) {
1915 BOOL foundKey = NO;
1916 for (int j = 0; (j < 2) && !foundKey; ++j) {
1917 if (kKeys[i] == seenKeys[j]) {
1918 foundKey = YES;
1919 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j);
1920 }
1921 }
1922 XCTAssertTrue(foundKey, @"i = %d", i);
1923 }
1924 free(seenKeys);
1925 free(seenValues);
1926
1927 // Stopping the enumeration.
1928 idx = 0;
1929 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) {
1930 #pragma unused(aKey, aValue)
1931 if (idx == 0) *stop = YES;
1932 XCTAssertNotEqual(idx, 2U);
1933 ++idx;
1934 }];
1935 [dict release];
1936 }
1937
1938 - (void)testEquality {
1939 const BOOL kKeys1[] = { YES, NO };
1940 const BOOL kKeys2[] = { NO, YES };
1941 const double kValues1[] = { 600., 601. };
1942 const double kValues2[] = { 601., 600. };
1943 const double kValues3[] = { 601. };
1944 GPBBoolDoubleDictionary *dict1 =
1945 [[GPBBoolDoubleDictionary alloc] initWithValues:kValues1
1946 forKeys:kKeys1
1947 count:GPBARRAYSIZE(kValues1)];
1948 XCTAssertNotNil(dict1);
1949 GPBBoolDoubleDictionary *dict1prime =
1950 [[GPBBoolDoubleDictionary alloc] initWithValues:kValues1
1951 forKeys:kKeys1
1952 count:GPBARRAYSIZE(kValues1)];
1953 XCTAssertNotNil(dict1prime);
1954 GPBBoolDoubleDictionary *dict2 =
1955 [[GPBBoolDoubleDictionary alloc] initWithValues:kValues2
1956 forKeys:kKeys1
1957 count:GPBARRAYSIZE(kValues2)];
1958 XCTAssertNotNil(dict2);
1959 GPBBoolDoubleDictionary *dict3 =
1960 [[GPBBoolDoubleDictionary alloc] initWithValues:kValues1
1961 forKeys:kKeys2
1962 count:GPBARRAYSIZE(kValues1)];
1963 XCTAssertNotNil(dict3);
1964 GPBBoolDoubleDictionary *dict4 =
1965 [[GPBBoolDoubleDictionary alloc] initWithValues:kValues3
1966 forKeys:kKeys1
1967 count:GPBARRAYSIZE(kValues3)];
1968 XCTAssertNotNil(dict4);
1969
1970 // 1/1Prime should be different objects, but equal.
1971 XCTAssertNotEqual(dict1, dict1prime);
1972 XCTAssertEqualObjects(dict1, dict1prime);
1973 // Equal, so they must have same hash.
1974 XCTAssertEqual([dict1 hash], [dict1prime hash]);
1975
1976 // 2 is save keys, different values; not equal.
1977 XCTAssertNotEqualObjects(dict1, dict2);
1978
1979 // 3 is different keys, samae values; not equal.
1980 XCTAssertNotEqualObjects(dict1, dict3);
1981
1982 // 4 Fewer pairs; not equal
1983 XCTAssertNotEqualObjects(dict1, dict4);
1984
1985 [dict1 release];
1986 [dict1prime release];
1987 [dict2 release];
1988 [dict3 release];
1989 [dict4 release];
1990 }
1991
1992 - (void)testCopy {
1993 const BOOL kKeys[] = { YES, NO };
1994 const double kValues[] = { 600., 601. };
1995 GPBBoolDoubleDictionary *dict =
1996 [[GPBBoolDoubleDictionary alloc] initWithValues:kValues
1997 forKeys:kKeys
1998 count:GPBARRAYSIZE(kValues)];
1999 XCTAssertNotNil(dict);
2000
2001 GPBBoolDoubleDictionary *dict2 = [dict copy];
2002 XCTAssertNotNil(dict2);
2003
2004 // Should be new object but equal.
2005 XCTAssertNotEqual(dict, dict2);
2006 XCTAssertEqualObjects(dict, dict2);
2007 XCTAssertTrue([dict2 isKindOfClass:[GPBBoolDoubleDictionary class]]);
2008
2009 [dict2 release];
2010 [dict release];
2011 }
2012
2013 - (void)testDictionaryFromDictionary {
2014 const BOOL kKeys[] = { YES, NO };
2015 const double kValues[] = { 600., 601. };
2016 GPBBoolDoubleDictionary *dict =
2017 [[GPBBoolDoubleDictionary alloc] initWithValues:kValues
2018 forKeys:kKeys
2019 count:GPBARRAYSIZE(kValues)];
2020 XCTAssertNotNil(dict);
2021
2022 GPBBoolDoubleDictionary *dict2 =
2023 [GPBBoolDoubleDictionary dictionaryWithDictionary:dict];
2024 XCTAssertNotNil(dict2);
2025
2026 // Should be new pointer, but equal objects.
2027 XCTAssertNotEqual(dict, dict2);
2028 XCTAssertEqualObjects(dict, dict2);
2029 [dict release];
2030 }
2031
2032 - (void)testAdds {
2033 GPBBoolDoubleDictionary *dict = [GPBBoolDoubleDictionary dictionary];
2034 XCTAssertNotNil(dict);
2035
2036 XCTAssertEqual(dict.count, 0U);
2037 [dict setValue:600. forKey:YES];
2038 XCTAssertEqual(dict.count, 1U);
2039
2040 const BOOL kKeys[] = { NO };
2041 const double kValues[] = { 601. };
2042 GPBBoolDoubleDictionary *dict2 =
2043 [[GPBBoolDoubleDictionary alloc] initWithValues:kValues
2044 forKeys:kKeys
2045 count:GPBARRAYSIZE(kValues)];
2046 XCTAssertNotNil(dict2);
2047 [dict addEntriesFromDictionary:dict2];
2048 XCTAssertEqual(dict.count, 2U);
2049
2050 double value;
2051 XCTAssertTrue([dict valueForKey:YES value:NULL]);
2052 XCTAssertTrue([dict valueForKey:YES value:&value]);
2053 XCTAssertEqual(value, 600.);
2054 XCTAssertTrue([dict valueForKey:NO value:NULL]);
2055 XCTAssertTrue([dict valueForKey:NO value:&value]);
2056 XCTAssertEqual(value, 601.);
2057 [dict2 release];
2058 }
2059
2060 - (void)testRemove {
2061 const BOOL kKeys[] = { YES, NO};
2062 const double kValues[] = { 600., 601. };
2063 GPBBoolDoubleDictionary *dict =
2064 [[GPBBoolDoubleDictionary alloc] initWithValues:kValues
2065 forKeys:kKeys
2066 count:GPBARRAYSIZE(kValues)];
2067 XCTAssertNotNil(dict);
2068 XCTAssertEqual(dict.count, 2U);
2069
2070 [dict removeValueForKey:NO];
2071 XCTAssertEqual(dict.count, 1U);
2072 double value;
2073 XCTAssertTrue([dict valueForKey:YES value:NULL]);
2074 XCTAssertTrue([dict valueForKey:YES value:&value]);
2075 XCTAssertEqual(value, 600.);
2076 XCTAssertFalse([dict valueForKey:NO value:NULL]);
2077
2078 // Remove again does nothing.
2079 [dict removeValueForKey:NO];
2080 XCTAssertEqual(dict.count, 1U);
2081 XCTAssertTrue([dict valueForKey:YES value:NULL]);
2082 XCTAssertTrue([dict valueForKey:YES value:&value]);
2083 XCTAssertEqual(value, 600.);
2084 XCTAssertFalse([dict valueForKey:NO value:NULL]);
2085
2086 [dict removeAll];
2087 XCTAssertEqual(dict.count, 0U);
2088 XCTAssertFalse([dict valueForKey:YES value:NULL]);
2089 XCTAssertFalse([dict valueForKey:NO value:NULL]);
2090 [dict release];
2091 }
2092
2093 - (void)testInplaceMutation {
2094 const BOOL kKeys[] = { YES, NO };
2095 const double kValues[] = { 600., 601. };
2096 GPBBoolDoubleDictionary *dict =
2097 [[GPBBoolDoubleDictionary alloc] initWithValues:kValues
2098 forKeys:kKeys
2099 count:GPBARRAYSIZE(kValues)];
2100 XCTAssertNotNil(dict);
2101 XCTAssertEqual(dict.count, 2U);
2102 double value;
2103 XCTAssertTrue([dict valueForKey:YES value:NULL]);
2104 XCTAssertTrue([dict valueForKey:YES value:&value]);
2105 XCTAssertEqual(value, 600.);
2106 XCTAssertTrue([dict valueForKey:NO value:NULL]);
2107 XCTAssertTrue([dict valueForKey:NO value:&value]);
2108 XCTAssertEqual(value, 601.);
2109
2110 [dict setValue:601. forKey:YES];
2111 XCTAssertEqual(dict.count, 2U);
2112 XCTAssertTrue([dict valueForKey:YES value:NULL]);
2113 XCTAssertTrue([dict valueForKey:YES value:&value]);
2114 XCTAssertEqual(value, 601.);
2115 XCTAssertTrue([dict valueForKey:NO value:NULL]);
2116 XCTAssertTrue([dict valueForKey:NO value:&value]);
2117 XCTAssertEqual(value, 601.);
2118
2119 [dict setValue:600. forKey:NO];
2120 XCTAssertEqual(dict.count, 2U);
2121 XCTAssertTrue([dict valueForKey:YES value:NULL]);
2122 XCTAssertTrue([dict valueForKey:YES value:&value]);
2123 XCTAssertEqual(value, 601.);
2124 XCTAssertTrue([dict valueForKey:NO value:NULL]);
2125 XCTAssertTrue([dict valueForKey:NO value:&value]);
2126 XCTAssertEqual(value, 600.);
2127
2128 const BOOL kKeys2[] = { NO, YES };
2129 const double kValues2[] = { 601., 600. };
2130 GPBBoolDoubleDictionary *dict2 =
2131 [[GPBBoolDoubleDictionary alloc] initWithValues:kValues2
2132 forKeys:kKeys2
2133 count:GPBARRAYSIZE(kValues2)];
2134 XCTAssertNotNil(dict2);
2135 [dict addEntriesFromDictionary:dict2];
2136 XCTAssertEqual(dict.count, 2U);
2137 XCTAssertTrue([dict valueForKey:YES value:NULL]);
2138 XCTAssertTrue([dict valueForKey:YES value:&value]);
2139 XCTAssertEqual(value, 600.);
2140 XCTAssertTrue([dict valueForKey:NO value:NULL]);
2141 XCTAssertTrue([dict valueForKey:NO value:&value]);
2142 XCTAssertEqual(value, 601.);
2143
2144 [dict2 release];
2145 [dict release];
2146 }
2147
2148 @end
2149
2150 //%PDDM-EXPAND TESTS_FOR_BOOL_KEY_OBJECT_VALUE(Object, id, @"abc", @"def")
2151 // This block of code is generated, do not edit it directly.
2152
2153 #pragma mark - Bool -> Object
2154
2155 @interface GPBBoolObjectDictionaryTests : XCTestCase
2156 @end
2157
2158 @implementation GPBBoolObjectDictionaryTests
2159
2160 - (void)testEmpty {
2161 GPBBoolObjectDictionary *dict = [[GPBBoolObjectDictionary alloc] init];
2162 XCTAssertNotNil(dict);
2163 XCTAssertEqual(dict.count, 0U);
2164 XCTAssertNil([dict valueForKey:YES]);
2165 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, id aValue, BOOL *stop) {
2166 #pragma unused(aKey, aValue, stop)
2167 XCTFail(@"Shouldn't get here!");
2168 }];
2169 [dict release];
2170 }
2171
2172 - (void)testOne {
2173 GPBBoolObjectDictionary *dict = [GPBBoolObjectDictionary dictionaryWithValue:@ "abc" forKey:YES];
2174 XCTAssertNotNil(dict);
2175 XCTAssertEqual(dict.count, 1U);
2176 XCTAssertEqualObjects([dict valueForKey:YES], @"abc");
2177 XCTAssertNil([dict valueForKey:NO]);
2178 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, id aValue, BOOL *stop) {
2179 XCTAssertEqual(aKey, YES);
2180 XCTAssertEqualObjects(aValue, @"abc");
2181 XCTAssertNotEqual(stop, NULL);
2182 }];
2183 }
2184
2185 - (void)testBasics {
2186 const BOOL kKeys[] = { YES, NO };
2187 const id kValues[] = { @"abc", @"def" };
2188 GPBBoolObjectDictionary *dict =
2189 [[GPBBoolObjectDictionary alloc] initWithValues:kValues
2190 forKeys:kKeys
2191 count:GPBARRAYSIZE(kValues)];
2192 XCTAssertNotNil(dict);
2193 XCTAssertEqual(dict.count, 2U);
2194 XCTAssertEqualObjects([dict valueForKey:YES], @"abc");
2195 XCTAssertEqualObjects([dict valueForKey:NO], @"def");
2196
2197 __block NSUInteger idx = 0;
2198 BOOL *seenKeys = malloc(2 * sizeof(BOOL));
2199 id *seenValues = malloc(2 * sizeof(id));
2200 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, id aValue, BOOL *stop) {
2201 XCTAssertLessThan(idx, 2U);
2202 seenKeys[idx] = aKey;
2203 seenValues[idx] = aValue;
2204 XCTAssertNotEqual(stop, NULL);
2205 ++idx;
2206 }];
2207 for (int i = 0; i < 2; ++i) {
2208 BOOL foundKey = NO;
2209 for (int j = 0; (j < 2) && !foundKey; ++j) {
2210 if (kKeys[i] == seenKeys[j]) {
2211 foundKey = YES;
2212 XCTAssertEqualObjects(kValues[i], seenValues[j], @"i = %d, j = %d", i, j );
2213 }
2214 }
2215 XCTAssertTrue(foundKey, @"i = %d", i);
2216 }
2217 free(seenKeys);
2218 free(seenValues);
2219
2220 // Stopping the enumeration.
2221 idx = 0;
2222 [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, id aValue, BOOL *stop) {
2223 #pragma unused(aKey, aValue)
2224 if (idx == 0) *stop = YES;
2225 XCTAssertNotEqual(idx, 2U);
2226 ++idx;
2227 }];
2228 [dict release];
2229 }
2230
2231 - (void)testEquality {
2232 const BOOL kKeys1[] = { YES, NO };
2233 const BOOL kKeys2[] = { NO, YES };
2234 const id kValues1[] = { @"abc", @"def" };
2235 const id kValues2[] = { @"def", @"abc" };
2236 const id kValues3[] = { @"def" };
2237 GPBBoolObjectDictionary *dict1 =
2238 [[GPBBoolObjectDictionary alloc] initWithValues:kValues1
2239 forKeys:kKeys1
2240 count:GPBARRAYSIZE(kValues1)];
2241 XCTAssertNotNil(dict1);
2242 GPBBoolObjectDictionary *dict1prime =
2243 [[GPBBoolObjectDictionary alloc] initWithValues:kValues1
2244 forKeys:kKeys1
2245 count:GPBARRAYSIZE(kValues1)];
2246 XCTAssertNotNil(dict1prime);
2247 GPBBoolObjectDictionary *dict2 =
2248 [[GPBBoolObjectDictionary alloc] initWithValues:kValues2
2249 forKeys:kKeys1
2250 count:GPBARRAYSIZE(kValues2)];
2251 XCTAssertNotNil(dict2);
2252 GPBBoolObjectDictionary *dict3 =
2253 [[GPBBoolObjectDictionary alloc] initWithValues:kValues1
2254 forKeys:kKeys2
2255 count:GPBARRAYSIZE(kValues1)];
2256 XCTAssertNotNil(dict3);
2257 GPBBoolObjectDictionary *dict4 =
2258 [[GPBBoolObjectDictionary alloc] initWithValues:kValues3
2259 forKeys:kKeys1
2260 count:GPBARRAYSIZE(kValues3)];
2261 XCTAssertNotNil(dict4);
2262
2263 // 1/1Prime should be different objects, but equal.
2264 XCTAssertNotEqual(dict1, dict1prime);
2265 XCTAssertEqualObjects(dict1, dict1prime);
2266 // Equal, so they must have same hash.
2267 XCTAssertEqual([dict1 hash], [dict1prime hash]);
2268
2269 // 2 is save keys, different values; not equal.
2270 XCTAssertNotEqualObjects(dict1, dict2);
2271
2272 // 3 is different keys, samae values; not equal.
2273 XCTAssertNotEqualObjects(dict1, dict3);
2274
2275 // 4 Fewer pairs; not equal
2276 XCTAssertNotEqualObjects(dict1, dict4);
2277
2278 [dict1 release];
2279 [dict1prime release];
2280 [dict2 release];
2281 [dict3 release];
2282 [dict4 release];
2283 }
2284
2285 - (void)testCopy {
2286 const BOOL kKeys[] = { YES, NO };
2287 const id kValues[] = { @"abc", @"def" };
2288 GPBBoolObjectDictionary *dict =
2289 [[GPBBoolObjectDictionary alloc] initWithValues:kValues
2290 forKeys:kKeys
2291 count:GPBARRAYSIZE(kValues)];
2292 XCTAssertNotNil(dict);
2293
2294 GPBBoolObjectDictionary *dict2 = [dict copy];
2295 XCTAssertNotNil(dict2);
2296
2297 // Should be new object but equal.
2298 XCTAssertNotEqual(dict, dict2);
2299 XCTAssertEqualObjects(dict, dict2);
2300 XCTAssertTrue([dict2 isKindOfClass:[GPBBoolObjectDictionary class]]);
2301
2302 [dict2 release];
2303 [dict release];
2304 }
2305
2306 - (void)testDictionaryFromDictionary {
2307 const BOOL kKeys[] = { YES, NO };
2308 const id kValues[] = { @"abc", @"def" };
2309 GPBBoolObjectDictionary *dict =
2310 [[GPBBoolObjectDictionary alloc] initWithValues:kValues
2311 forKeys:kKeys
2312 count:GPBARRAYSIZE(kValues)];
2313 XCTAssertNotNil(dict);
2314
2315 GPBBoolObjectDictionary *dict2 =
2316 [GPBBoolObjectDictionary dictionaryWithDictionary:dict];
2317 XCTAssertNotNil(dict2);
2318
2319 // Should be new pointer, but equal objects.
2320 XCTAssertNotEqual(dict, dict2);
2321 XCTAssertEqualObjects(dict, dict2);
2322 [dict release];
2323 }
2324
2325 - (void)testAdds {
2326 GPBBoolObjectDictionary *dict = [GPBBoolObjectDictionary dictionary];
2327 XCTAssertNotNil(dict);
2328
2329 XCTAssertEqual(dict.count, 0U);
2330 [dict setValue:@"abc" forKey:YES];
2331 XCTAssertEqual(dict.count, 1U);
2332
2333 const BOOL kKeys[] = { NO };
2334 const id kValues[] = { @"def" };
2335 GPBBoolObjectDictionary *dict2 =
2336 [[GPBBoolObjectDictionary alloc] initWithValues:kValues
2337 forKeys:kKeys
2338 count:GPBARRAYSIZE(kValues)];
2339 XCTAssertNotNil(dict2);
2340 [dict addEntriesFromDictionary:dict2];
2341 XCTAssertEqual(dict.count, 2U);
2342
2343 XCTAssertEqualObjects([dict valueForKey:YES], @"abc");
2344 XCTAssertEqualObjects([dict valueForKey:NO], @"def");
2345 [dict2 release];
2346 }
2347
2348 - (void)testRemove {
2349 const BOOL kKeys[] = { YES, NO};
2350 const id kValues[] = { @"abc", @"def" };
2351 GPBBoolObjectDictionary *dict =
2352 [[GPBBoolObjectDictionary alloc] initWithValues:kValues
2353 forKeys:kKeys
2354 count:GPBARRAYSIZE(kValues)];
2355 XCTAssertNotNil(dict);
2356 XCTAssertEqual(dict.count, 2U);
2357
2358 [dict removeValueForKey:NO];
2359 XCTAssertEqual(dict.count, 1U);
2360 XCTAssertEqualObjects([dict valueForKey:YES], @"abc");
2361 XCTAssertNil([dict valueForKey:NO]);
2362
2363 // Remove again does nothing.
2364 [dict removeValueForKey:NO];
2365 XCTAssertEqual(dict.count, 1U);
2366 XCTAssertEqualObjects([dict valueForKey:YES], @"abc");
2367 XCTAssertNil([dict valueForKey:NO]);
2368
2369 [dict removeAll];
2370 XCTAssertEqual(dict.count, 0U);
2371 XCTAssertNil([dict valueForKey:YES]);
2372 XCTAssertNil([dict valueForKey:NO]);
2373 [dict release];
2374 }
2375
2376 - (void)testInplaceMutation {
2377 const BOOL kKeys[] = { YES, NO };
2378 const id kValues[] = { @"abc", @"def" };
2379 GPBBoolObjectDictionary *dict =
2380 [[GPBBoolObjectDictionary alloc] initWithValues:kValues
2381 forKeys:kKeys
2382 count:GPBARRAYSIZE(kValues)];
2383 XCTAssertNotNil(dict);
2384 XCTAssertEqual(dict.count, 2U);
2385 XCTAssertEqualObjects([dict valueForKey:YES], @"abc");
2386 XCTAssertEqualObjects([dict valueForKey:NO], @"def");
2387
2388 [dict setValue:@"def" forKey:YES];
2389 XCTAssertEqual(dict.count, 2U);
2390 XCTAssertEqualObjects([dict valueForKey:YES], @"def");
2391 XCTAssertEqualObjects([dict valueForKey:NO], @"def");
2392
2393 [dict setValue:@"abc" forKey:NO];
2394 XCTAssertEqual(dict.count, 2U);
2395 XCTAssertEqualObjects([dict valueForKey:YES], @"def");
2396 XCTAssertEqualObjects([dict valueForKey:NO], @"abc");
2397
2398 const BOOL kKeys2[] = { NO, YES };
2399 const id kValues2[] = { @"def", @"abc" };
2400 GPBBoolObjectDictionary *dict2 =
2401 [[GPBBoolObjectDictionary alloc] initWithValues:kValues2
2402 forKeys:kKeys2
2403 count:GPBARRAYSIZE(kValues2)];
2404 XCTAssertNotNil(dict2);
2405 [dict addEntriesFromDictionary:dict2];
2406 XCTAssertEqual(dict.count, 2U);
2407 XCTAssertEqualObjects([dict valueForKey:YES], @"abc");
2408 XCTAssertEqualObjects([dict valueForKey:NO], @"def");
2409
2410 [dict2 release];
2411 [dict release];
2412 }
2413
2414 @end
2415
2416 //%PDDM-EXPAND-END (8 expansions)
2417
2418
OLDNEW
« no previous file with comments | « third_party/protobuf/objectivec/Tests/GPBDictionaryTests.pddm ('k') | third_party/protobuf/objectivec/Tests/GPBDictionaryTests+Int32.m » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698