third_party/protobuf/objectivec/Tests/GPBDictionaryTests+Int32.m - Issue 1322483002: Revert https://codereview.chromium.org/1291903002 (protobuf roll).

Side by Side Diff: third_party/protobuf/objectivec/Tests/GPBDictionaryTests+Int32.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+Bool.m ('k') | third_party/protobuf/objectivec/Tests/GPBDictionaryTests+Int64.m » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
1 // Protocol Buffers - Google's data interchange format

2 // Copyright 2015 Google Inc. All rights reserved.

3 // https://developers.google.com/protocol-buffers/

4 //

5 // Redistribution and use in source and binary forms, with or without

6 // modification, are permitted provided that the following conditions are

7 // met:

8 //

9 // * Redistributions of source code must retain the above copyright

10 // notice, this list of conditions and the following disclaimer.

11 // * Redistributions in binary form must reproduce the above

12 // copyright notice, this list of conditions and the following disclaimer

13 // in the documentation and/or other materials provided with the

14 // distribution.

15 // * Neither the name of Google Inc. nor the names of its

16 // contributors may be used to endorse or promote products derived from

17 // this software without specific prior written permission.

18 //

19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

30

31 #import <Foundation/Foundation.h>

32 #import <XCTest/XCTest.h>

33

34 #import "GPBDictionary.h"

35

36 #import "GPBTestUtilities.h"

37 #import "google/protobuf/UnittestRuntimeProto2.pbobjc.h"

38

39 // Pull in the macros (using an external file because expanding all tests

40 // in a single file makes a file that is failing to work with within Xcode.

41 //%PDDM-IMPORT-DEFINES GPBDictionaryTests.pddm

42

43 //%PDDM-EXPAND TEST_FOR_POD_KEY(Int32, int32_t, 11, 12, 13, 14)

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 GPBInt32EnumDictionary (TestingTweak)

48 + (instancetype)dictionaryWithValue:(int32_t)value forKey:(int32_t)key;

49 - (instancetype)initWithValues:(const int32_t [])values

50 forKeys:(const int32_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 GPBInt32EnumDictionary (TestingTweak)

67 + (instancetype)dictionaryWithValue:(int32_t)value forKey:(int32_t)key {

68 // Cast is needed to compiler knows what class we are invoking initWithValues: on to get the

69 // type correct.

70 return [[(GPBInt32EnumDictionary*)[self alloc] initWithValidationFunction:Test ingEnum_IsValidValue

71 rawValues:&val ue

72 forKeys:&key

73 count:1] a utorelease];

74 }

75 - (instancetype)initWithValues:(const int32_t [])values

76 forKeys:(const int32_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 - Int32 -> UInt32

87

88 @interface GPBInt32UInt32DictionaryTests : XCTestCase

89 @end

90

91 @implementation GPBInt32UInt32DictionaryTests

92

93 - (void)testEmpty {

94 GPBInt32UInt32Dictionary *dict = [[GPBInt32UInt32Dictionary alloc] init];

95 XCTAssertNotNil(dict);

96 XCTAssertEqual(dict.count, 0U);

97 XCTAssertFalse([dict valueForKey:11 value:NULL]);

98 [dict enumerateKeysAndValuesUsingBlock:^(int32_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 GPBInt32UInt32Dictionary *dict = [GPBInt32UInt32Dictionary dictionaryWithValue :100U forKey:11];

107 XCTAssertNotNil(dict);

108 XCTAssertEqual(dict.count, 1U);

109 uint32_t value;

110 XCTAssertTrue([dict valueForKey:11 value:NULL]);

111 XCTAssertTrue([dict valueForKey:11 value:&value]);

112 XCTAssertEqual(value, 100U);

113 XCTAssertFalse([dict valueForKey:12 value:NULL]);

114 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL * stop) {

115 XCTAssertEqual(aKey, 11);

116 XCTAssertEqual(aValue, 100U);

117 XCTAssertNotEqual(stop, NULL);

118 }];

119 }

120

121 - (void)testBasics {

122 const int32_t kKeys[] = { 11, 12, 13 };

123 const uint32_t kValues[] = { 100U, 101U, 102U };

124 GPBInt32UInt32Dictionary *dict =

125 [[GPBInt32UInt32Dictionary 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:11 value:NULL]);

132 XCTAssertTrue([dict valueForKey:11 value:&value]);

133 XCTAssertEqual(value, 100U);

134 XCTAssertTrue([dict valueForKey:12 value:NULL]);

135 XCTAssertTrue([dict valueForKey:12 value:&value]);

136 XCTAssertEqual(value, 101U);

137 XCTAssertTrue([dict valueForKey:13 value:NULL]);

138 XCTAssertTrue([dict valueForKey:13 value:&value]);

139 XCTAssertEqual(value, 102U);

140 XCTAssertFalse([dict valueForKey:14 value:NULL]);

141

142 __block NSUInteger idx = 0;

143 int32_t seenKeys = malloc(3 sizeof(int32_t));

144 uint32_t seenValues = malloc(3 sizeof(uint32_t));

145 [dict enumerateKeysAndValuesUsingBlock:^(int32_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:^(int32_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 int32_t kKeys1[] = { 11, 12, 13, 14 };

178 const int32_t kKeys2[] = { 12, 11, 14 };

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 GPBInt32UInt32Dictionary *dict1 =

183 [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues1

184 forKeys:kKeys1

185 count:GPBARRAYSIZE(kValues1)];

186 XCTAssertNotNil(dict1);

187 GPBInt32UInt32Dictionary *dict1prime =

188 [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues1

189 forKeys:kKeys1

190 count:GPBARRAYSIZE(kValues1)];

191 XCTAssertNotNil(dict1prime);

192 GPBInt32UInt32Dictionary *dict2 =

193 [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues2

194 forKeys:kKeys1

195 count:GPBARRAYSIZE(kValues2)];

196 XCTAssertNotNil(dict2);

197 GPBInt32UInt32Dictionary *dict3 =

198 [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues1

199 forKeys:kKeys2

200 count:GPBARRAYSIZE(kValues1)];

201 XCTAssertNotNil(dict3);

202 GPBInt32UInt32Dictionary *dict4 =

203 [[GPBInt32UInt32Dictionary 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 save keys, different values; not equal.

215 XCTAssertNotEqualObjects(dict1, dict2);

216

217 // 3 is different keys, samae 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 int32_t kKeys[] = { 11, 12, 13, 14 };

232 const uint32_t kValues[] = { 100U, 101U, 102U, 103U };

233 GPBInt32UInt32Dictionary *dict =

234 [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues

235 forKeys:kKeys

236 count:GPBARRAYSIZE(kValues)];

237 XCTAssertNotNil(dict);

238

239 GPBInt32UInt32Dictionary *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:[GPBInt32UInt32Dictionary class]]);

246

247 [dict2 release];

248 [dict release];

249 }

250

251 - (void)testDictionaryFromDictionary {

252 const int32_t kKeys[] = { 11, 12, 13, 14 };

253 const uint32_t kValues[] = { 100U, 101U, 102U, 103U };

254 GPBInt32UInt32Dictionary *dict =

255 [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues

256 forKeys:kKeys

257 count:GPBARRAYSIZE(kValues)];

258 XCTAssertNotNil(dict);

259

260 GPBInt32UInt32Dictionary *dict2 =

261 [GPBInt32UInt32Dictionary 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 GPBInt32UInt32Dictionary *dict = [GPBInt32UInt32Dictionary dictionary];

272 XCTAssertNotNil(dict);

273

274 XCTAssertEqual(dict.count, 0U);

275 [dict setValue:100U forKey:11];

276 XCTAssertEqual(dict.count, 1U);

277

278 const int32_t kKeys[] = { 12, 13, 14 };

279 const uint32_t kValues[] = { 101U, 102U, 103U };

280 GPBInt32UInt32Dictionary *dict2 =

281 [[GPBInt32UInt32Dictionary 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:11 value:NULL]);

290 XCTAssertTrue([dict valueForKey:11 value:&value]);

291 XCTAssertEqual(value, 100U);

292 XCTAssertTrue([dict valueForKey:12 value:NULL]);

293 XCTAssertTrue([dict valueForKey:12 value:&value]);

294 XCTAssertEqual(value, 101U);

295 XCTAssertTrue([dict valueForKey:13 value:NULL]);

296 XCTAssertTrue([dict valueForKey:13 value:&value]);

297 XCTAssertEqual(value, 102U);

298 XCTAssertTrue([dict valueForKey:14 value:NULL]);

299 XCTAssertTrue([dict valueForKey:14 value:&value]);

300 XCTAssertEqual(value, 103U);

301 [dict2 release];

302 }

303

304 - (void)testRemove {

305 const int32_t kKeys[] = { 11, 12, 13, 14 };

306 const uint32_t kValues[] = { 100U, 101U, 102U, 103U };

307 GPBInt32UInt32Dictionary *dict =

308 [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues

309 forKeys:kKeys

310 count:GPBARRAYSIZE(kValues)];

311 XCTAssertNotNil(dict);

312 XCTAssertEqual(dict.count, 4U);

313

314 [dict removeValueForKey:12];

315 XCTAssertEqual(dict.count, 3U);

316 uint32_t value;

317 XCTAssertTrue([dict valueForKey:11 value:NULL]);

318 XCTAssertTrue([dict valueForKey:11 value:&value]);

319 XCTAssertEqual(value, 100U);

320 XCTAssertFalse([dict valueForKey:12 value:NULL]);

321 XCTAssertTrue([dict valueForKey:13 value:NULL]);

322 XCTAssertTrue([dict valueForKey:13 value:&value]);

323 XCTAssertEqual(value, 102U);

324 XCTAssertTrue([dict valueForKey:14 value:NULL]);

325 XCTAssertTrue([dict valueForKey:14 value:&value]);

326 XCTAssertEqual(value, 103U);

327

328 // Remove again does nothing.

329 [dict removeValueForKey:12];

330 XCTAssertEqual(dict.count, 3U);

331 XCTAssertTrue([dict valueForKey:11 value:NULL]);

332 XCTAssertTrue([dict valueForKey:11 value:&value]);

333 XCTAssertEqual(value, 100U);

334 XCTAssertFalse([dict valueForKey:12 value:NULL]);

335 XCTAssertTrue([dict valueForKey:13 value:NULL]);

336 XCTAssertTrue([dict valueForKey:13 value:&value]);

337 XCTAssertEqual(value, 102U);

338 XCTAssertTrue([dict valueForKey:14 value:NULL]);

339 XCTAssertTrue([dict valueForKey:14 value:&value]);

340 XCTAssertEqual(value, 103U);

341

342 [dict removeValueForKey:14];

343 XCTAssertEqual(dict.count, 2U);

344 XCTAssertTrue([dict valueForKey:11 value:NULL]);

345 XCTAssertTrue([dict valueForKey:11 value:&value]);

346 XCTAssertEqual(value, 100U);

347 XCTAssertFalse([dict valueForKey:12 value:NULL]);

348 XCTAssertTrue([dict valueForKey:13 value:NULL]);

349 XCTAssertTrue([dict valueForKey:13 value:&value]);

350 XCTAssertEqual(value, 102U);

351 XCTAssertFalse([dict valueForKey:14 value:NULL]);

352

353 [dict removeAll];

354 XCTAssertEqual(dict.count, 0U);

355 XCTAssertFalse([dict valueForKey:11 value:NULL]);

356 XCTAssertFalse([dict valueForKey:12 value:NULL]);

357 XCTAssertFalse([dict valueForKey:13 value:NULL]);

358 XCTAssertFalse([dict valueForKey:14 value:NULL]);

359 [dict release];

360 }

361

362 - (void)testInplaceMutation {

363 const int32_t kKeys[] = { 11, 12, 13, 14 };

364 const uint32_t kValues[] = { 100U, 101U, 102U, 103U };

365 GPBInt32UInt32Dictionary *dict =

366 [[GPBInt32UInt32Dictionary 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:11 value:NULL]);

373 XCTAssertTrue([dict valueForKey:11 value:&value]);

374 XCTAssertEqual(value, 100U);

375 XCTAssertTrue([dict valueForKey:12 value:NULL]);

376 XCTAssertTrue([dict valueForKey:12 value:&value]);

377 XCTAssertEqual(value, 101U);

378 XCTAssertTrue([dict valueForKey:13 value:NULL]);

379 XCTAssertTrue([dict valueForKey:13 value:&value]);

380 XCTAssertEqual(value, 102U);

381 XCTAssertTrue([dict valueForKey:14 value:NULL]);

382 XCTAssertTrue([dict valueForKey:14 value:&value]);

383 XCTAssertEqual(value, 103U);

384

385 [dict setValue:103U forKey:11];

386 XCTAssertEqual(dict.count, 4U);

387 XCTAssertTrue([dict valueForKey:11 value:NULL]);

388 XCTAssertTrue([dict valueForKey:11 value:&value]);

389 XCTAssertEqual(value, 103U);

390 XCTAssertTrue([dict valueForKey:12 value:NULL]);

391 XCTAssertTrue([dict valueForKey:12 value:&value]);

392 XCTAssertEqual(value, 101U);

393 XCTAssertTrue([dict valueForKey:13 value:NULL]);

394 XCTAssertTrue([dict valueForKey:13 value:&value]);

395 XCTAssertEqual(value, 102U);

396 XCTAssertTrue([dict valueForKey:14 value:NULL]);

397 XCTAssertTrue([dict valueForKey:14 value:&value]);

398 XCTAssertEqual(value, 103U);

399

400 [dict setValue:101U forKey:14];

401 XCTAssertEqual(dict.count, 4U);

402 XCTAssertTrue([dict valueForKey:11 value:NULL]);

403 XCTAssertTrue([dict valueForKey:11 value:&value]);

404 XCTAssertEqual(value, 103U);

405 XCTAssertTrue([dict valueForKey:12 value:NULL]);

406 XCTAssertTrue([dict valueForKey:12 value:&value]);

407 XCTAssertEqual(value, 101U);

408 XCTAssertTrue([dict valueForKey:13 value:NULL]);

409 XCTAssertTrue([dict valueForKey:13 value:&value]);

410 XCTAssertEqual(value, 102U);

411 XCTAssertTrue([dict valueForKey:14 value:NULL]);

412 XCTAssertTrue([dict valueForKey:14 value:&value]);

413 XCTAssertEqual(value, 101U);

414

415 const int32_t kKeys2[] = { 12, 13 };

416 const uint32_t kValues2[] = { 102U, 100U };

417 GPBInt32UInt32Dictionary *dict2 =

418 [[GPBInt32UInt32Dictionary 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:11 value:NULL]);

425 XCTAssertTrue([dict valueForKey:11 value:&value]);

426 XCTAssertEqual(value, 103U);

427 XCTAssertTrue([dict valueForKey:12 value:NULL]);

428 XCTAssertTrue([dict valueForKey:12 value:&value]);

429 XCTAssertEqual(value, 102U);

430 XCTAssertTrue([dict valueForKey:13 value:NULL]);

431 XCTAssertTrue([dict valueForKey:13 value:&value]);

432 XCTAssertEqual(value, 100U);

433 XCTAssertTrue([dict valueForKey:14 value:NULL]);

434 XCTAssertTrue([dict valueForKey:14 value:&value]);

435 XCTAssertEqual(value, 101U);

436

437 [dict2 release];

438 [dict release];

439 }

440

441 @end

442

443 #pragma mark - Int32 -> Int32

444

445 @interface GPBInt32Int32DictionaryTests : XCTestCase

446 @end

447

448 @implementation GPBInt32Int32DictionaryTests

449

450 - (void)testEmpty {

451 GPBInt32Int32Dictionary *dict = [[GPBInt32Int32Dictionary alloc] init];

452 XCTAssertNotNil(dict);

453 XCTAssertEqual(dict.count, 0U);

454 XCTAssertFalse([dict valueForKey:11 value:NULL]);

455 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *s top) {

456 #pragma unused(aKey, aValue, stop)

457 XCTFail(@"Shouldn't get here!");

458 }];

459 [dict release];

460 }

461

462 - (void)testOne {

463 GPBInt32Int32Dictionary *dict = [GPBInt32Int32Dictionary dictionaryWithValue:2 00 forKey:11];

464 XCTAssertNotNil(dict);

465 XCTAssertEqual(dict.count, 1U);

466 int32_t value;

467 XCTAssertTrue([dict valueForKey:11 value:NULL]);

468 XCTAssertTrue([dict valueForKey:11 value:&value]);

469 XCTAssertEqual(value, 200);

470 XCTAssertFalse([dict valueForKey:12 value:NULL]);

471 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *s top) {

472 XCTAssertEqual(aKey, 11);

473 XCTAssertEqual(aValue, 200);

474 XCTAssertNotEqual(stop, NULL);

475 }];

476 }

477

478 - (void)testBasics {

479 const int32_t kKeys[] = { 11, 12, 13 };

480 const int32_t kValues[] = { 200, 201, 202 };

481 GPBInt32Int32Dictionary *dict =

482 [[GPBInt32Int32Dictionary 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:11 value:NULL]);

489 XCTAssertTrue([dict valueForKey:11 value:&value]);

490 XCTAssertEqual(value, 200);

491 XCTAssertTrue([dict valueForKey:12 value:NULL]);

492 XCTAssertTrue([dict valueForKey:12 value:&value]);

493 XCTAssertEqual(value, 201);

494 XCTAssertTrue([dict valueForKey:13 value:NULL]);

495 XCTAssertTrue([dict valueForKey:13 value:&value]);

496 XCTAssertEqual(value, 202);

497 XCTAssertFalse([dict valueForKey:14 value:NULL]);

498

499 __block NSUInteger idx = 0;

500 int32_t seenKeys = malloc(3 sizeof(int32_t));

501 int32_t seenValues = malloc(3 sizeof(int32_t));

502 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *s top) {

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:^(int32_t aKey, int32_t aValue, BOOL *s top) {

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 int32_t kKeys1[] = { 11, 12, 13, 14 };

535 const int32_t kKeys2[] = { 12, 11, 14 };

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 GPBInt32Int32Dictionary *dict1 =

540 [[GPBInt32Int32Dictionary alloc] initWithValues:kValues1

541 forKeys:kKeys1

542 count:GPBARRAYSIZE(kValues1)];

543 XCTAssertNotNil(dict1);

544 GPBInt32Int32Dictionary *dict1prime =

545 [[GPBInt32Int32Dictionary alloc] initWithValues:kValues1

546 forKeys:kKeys1

547 count:GPBARRAYSIZE(kValues1)];

548 XCTAssertNotNil(dict1prime);

549 GPBInt32Int32Dictionary *dict2 =

550 [[GPBInt32Int32Dictionary alloc] initWithValues:kValues2

551 forKeys:kKeys1

552 count:GPBARRAYSIZE(kValues2)];

553 XCTAssertNotNil(dict2);

554 GPBInt32Int32Dictionary *dict3 =

555 [[GPBInt32Int32Dictionary alloc] initWithValues:kValues1

556 forKeys:kKeys2

557 count:GPBARRAYSIZE(kValues1)];

558 XCTAssertNotNil(dict3);

559 GPBInt32Int32Dictionary *dict4 =

560 [[GPBInt32Int32Dictionary 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 save keys, different values; not equal.

572 XCTAssertNotEqualObjects(dict1, dict2);

573

574 // 3 is different keys, samae 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 int32_t kKeys[] = { 11, 12, 13, 14 };

589 const int32_t kValues[] = { 200, 201, 202, 203 };

590 GPBInt32Int32Dictionary *dict =

591 [[GPBInt32Int32Dictionary alloc] initWithValues:kValues

592 forKeys:kKeys

593 count:GPBARRAYSIZE(kValues)];

594 XCTAssertNotNil(dict);

595

596 GPBInt32Int32Dictionary *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:[GPBInt32Int32Dictionary class]]);

603

604 [dict2 release];

605 [dict release];

606 }

607

608 - (void)testDictionaryFromDictionary {

609 const int32_t kKeys[] = { 11, 12, 13, 14 };

610 const int32_t kValues[] = { 200, 201, 202, 203 };

611 GPBInt32Int32Dictionary *dict =

612 [[GPBInt32Int32Dictionary alloc] initWithValues:kValues

613 forKeys:kKeys

614 count:GPBARRAYSIZE(kValues)];

615 XCTAssertNotNil(dict);

616

617 GPBInt32Int32Dictionary *dict2 =

618 [GPBInt32Int32Dictionary 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 GPBInt32Int32Dictionary *dict = [GPBInt32Int32Dictionary dictionary];

629 XCTAssertNotNil(dict);

630

631 XCTAssertEqual(dict.count, 0U);

632 [dict setValue:200 forKey:11];

633 XCTAssertEqual(dict.count, 1U);

634

635 const int32_t kKeys[] = { 12, 13, 14 };

636 const int32_t kValues[] = { 201, 202, 203 };

637 GPBInt32Int32Dictionary *dict2 =

638 [[GPBInt32Int32Dictionary 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:11 value:NULL]);

647 XCTAssertTrue([dict valueForKey:11 value:&value]);

648 XCTAssertEqual(value, 200);

649 XCTAssertTrue([dict valueForKey:12 value:NULL]);

650 XCTAssertTrue([dict valueForKey:12 value:&value]);

651 XCTAssertEqual(value, 201);

652 XCTAssertTrue([dict valueForKey:13 value:NULL]);

653 XCTAssertTrue([dict valueForKey:13 value:&value]);

654 XCTAssertEqual(value, 202);

655 XCTAssertTrue([dict valueForKey:14 value:NULL]);

656 XCTAssertTrue([dict valueForKey:14 value:&value]);

657 XCTAssertEqual(value, 203);

658 [dict2 release];

659 }

660

661 - (void)testRemove {

662 const int32_t kKeys[] = { 11, 12, 13, 14 };

663 const int32_t kValues[] = { 200, 201, 202, 203 };

664 GPBInt32Int32Dictionary *dict =

665 [[GPBInt32Int32Dictionary alloc] initWithValues:kValues

666 forKeys:kKeys

667 count:GPBARRAYSIZE(kValues)];

668 XCTAssertNotNil(dict);

669 XCTAssertEqual(dict.count, 4U);

670

671 [dict removeValueForKey:12];

672 XCTAssertEqual(dict.count, 3U);

673 int32_t value;

674 XCTAssertTrue([dict valueForKey:11 value:NULL]);

675 XCTAssertTrue([dict valueForKey:11 value:&value]);

676 XCTAssertEqual(value, 200);

677 XCTAssertFalse([dict valueForKey:12 value:NULL]);

678 XCTAssertTrue([dict valueForKey:13 value:NULL]);

679 XCTAssertTrue([dict valueForKey:13 value:&value]);

680 XCTAssertEqual(value, 202);

681 XCTAssertTrue([dict valueForKey:14 value:NULL]);

682 XCTAssertTrue([dict valueForKey:14 value:&value]);

683 XCTAssertEqual(value, 203);

684

685 // Remove again does nothing.

686 [dict removeValueForKey:12];

687 XCTAssertEqual(dict.count, 3U);

688 XCTAssertTrue([dict valueForKey:11 value:NULL]);

689 XCTAssertTrue([dict valueForKey:11 value:&value]);

690 XCTAssertEqual(value, 200);

691 XCTAssertFalse([dict valueForKey:12 value:NULL]);

692 XCTAssertTrue([dict valueForKey:13 value:NULL]);

693 XCTAssertTrue([dict valueForKey:13 value:&value]);

694 XCTAssertEqual(value, 202);

695 XCTAssertTrue([dict valueForKey:14 value:NULL]);

696 XCTAssertTrue([dict valueForKey:14 value:&value]);

697 XCTAssertEqual(value, 203);

698

699 [dict removeValueForKey:14];

700 XCTAssertEqual(dict.count, 2U);

701 XCTAssertTrue([dict valueForKey:11 value:NULL]);

702 XCTAssertTrue([dict valueForKey:11 value:&value]);

703 XCTAssertEqual(value, 200);

704 XCTAssertFalse([dict valueForKey:12 value:NULL]);

705 XCTAssertTrue([dict valueForKey:13 value:NULL]);

706 XCTAssertTrue([dict valueForKey:13 value:&value]);

707 XCTAssertEqual(value, 202);

708 XCTAssertFalse([dict valueForKey:14 value:NULL]);

709

710 [dict removeAll];

711 XCTAssertEqual(dict.count, 0U);

712 XCTAssertFalse([dict valueForKey:11 value:NULL]);

713 XCTAssertFalse([dict valueForKey:12 value:NULL]);

714 XCTAssertFalse([dict valueForKey:13 value:NULL]);

715 XCTAssertFalse([dict valueForKey:14 value:NULL]);

716 [dict release];

717 }

718

719 - (void)testInplaceMutation {

720 const int32_t kKeys[] = { 11, 12, 13, 14 };

721 const int32_t kValues[] = { 200, 201, 202, 203 };

722 GPBInt32Int32Dictionary *dict =

723 [[GPBInt32Int32Dictionary 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:11 value:NULL]);

730 XCTAssertTrue([dict valueForKey:11 value:&value]);

731 XCTAssertEqual(value, 200);

732 XCTAssertTrue([dict valueForKey:12 value:NULL]);

733 XCTAssertTrue([dict valueForKey:12 value:&value]);

734 XCTAssertEqual(value, 201);

735 XCTAssertTrue([dict valueForKey:13 value:NULL]);

736 XCTAssertTrue([dict valueForKey:13 value:&value]);

737 XCTAssertEqual(value, 202);

738 XCTAssertTrue([dict valueForKey:14 value:NULL]);

739 XCTAssertTrue([dict valueForKey:14 value:&value]);

740 XCTAssertEqual(value, 203);

741

742 [dict setValue:203 forKey:11];

743 XCTAssertEqual(dict.count, 4U);

744 XCTAssertTrue([dict valueForKey:11 value:NULL]);

745 XCTAssertTrue([dict valueForKey:11 value:&value]);

746 XCTAssertEqual(value, 203);

747 XCTAssertTrue([dict valueForKey:12 value:NULL]);

748 XCTAssertTrue([dict valueForKey:12 value:&value]);

749 XCTAssertEqual(value, 201);

750 XCTAssertTrue([dict valueForKey:13 value:NULL]);

751 XCTAssertTrue([dict valueForKey:13 value:&value]);

752 XCTAssertEqual(value, 202);

753 XCTAssertTrue([dict valueForKey:14 value:NULL]);

754 XCTAssertTrue([dict valueForKey:14 value:&value]);

755 XCTAssertEqual(value, 203);

756

757 [dict setValue:201 forKey:14];

758 XCTAssertEqual(dict.count, 4U);

759 XCTAssertTrue([dict valueForKey:11 value:NULL]);

760 XCTAssertTrue([dict valueForKey:11 value:&value]);

761 XCTAssertEqual(value, 203);

762 XCTAssertTrue([dict valueForKey:12 value:NULL]);

763 XCTAssertTrue([dict valueForKey:12 value:&value]);

764 XCTAssertEqual(value, 201);

765 XCTAssertTrue([dict valueForKey:13 value:NULL]);

766 XCTAssertTrue([dict valueForKey:13 value:&value]);

767 XCTAssertEqual(value, 202);

768 XCTAssertTrue([dict valueForKey:14 value:NULL]);

769 XCTAssertTrue([dict valueForKey:14 value:&value]);

770 XCTAssertEqual(value, 201);

771

772 const int32_t kKeys2[] = { 12, 13 };

773 const int32_t kValues2[] = { 202, 200 };

774 GPBInt32Int32Dictionary *dict2 =

775 [[GPBInt32Int32Dictionary 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:11 value:NULL]);

782 XCTAssertTrue([dict valueForKey:11 value:&value]);

783 XCTAssertEqual(value, 203);

784 XCTAssertTrue([dict valueForKey:12 value:NULL]);

785 XCTAssertTrue([dict valueForKey:12 value:&value]);

786 XCTAssertEqual(value, 202);

787 XCTAssertTrue([dict valueForKey:13 value:NULL]);

788 XCTAssertTrue([dict valueForKey:13 value:&value]);

789 XCTAssertEqual(value, 200);

790 XCTAssertTrue([dict valueForKey:14 value:NULL]);

791 XCTAssertTrue([dict valueForKey:14 value:&value]);

792 XCTAssertEqual(value, 201);

793

794 [dict2 release];

795 [dict release];

796 }

797

798 @end

799

800 #pragma mark - Int32 -> UInt64

801

802 @interface GPBInt32UInt64DictionaryTests : XCTestCase

803 @end

804

805 @implementation GPBInt32UInt64DictionaryTests

806

807 - (void)testEmpty {

808 GPBInt32UInt64Dictionary *dict = [[GPBInt32UInt64Dictionary alloc] init];

809 XCTAssertNotNil(dict);

810 XCTAssertEqual(dict.count, 0U);

811 XCTAssertFalse([dict valueForKey:11 value:NULL]);

812 [dict enumerateKeysAndValuesUsingBlock:^(int32_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 GPBInt32UInt64Dictionary *dict = [GPBInt32UInt64Dictionary dictionaryWithValue :300U forKey:11];

821 XCTAssertNotNil(dict);

822 XCTAssertEqual(dict.count, 1U);

823 uint64_t value;

824 XCTAssertTrue([dict valueForKey:11 value:NULL]);

825 XCTAssertTrue([dict valueForKey:11 value:&value]);

826 XCTAssertEqual(value, 300U);

827 XCTAssertFalse([dict valueForKey:12 value:NULL]);

828 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL * stop) {

829 XCTAssertEqual(aKey, 11);

830 XCTAssertEqual(aValue, 300U);

831 XCTAssertNotEqual(stop, NULL);

832 }];

833 }

834

835 - (void)testBasics {

836 const int32_t kKeys[] = { 11, 12, 13 };

837 const uint64_t kValues[] = { 300U, 301U, 302U };

838 GPBInt32UInt64Dictionary *dict =

839 [[GPBInt32UInt64Dictionary 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:11 value:NULL]);

846 XCTAssertTrue([dict valueForKey:11 value:&value]);

847 XCTAssertEqual(value, 300U);

848 XCTAssertTrue([dict valueForKey:12 value:NULL]);

849 XCTAssertTrue([dict valueForKey:12 value:&value]);

850 XCTAssertEqual(value, 301U);

851 XCTAssertTrue([dict valueForKey:13 value:NULL]);

852 XCTAssertTrue([dict valueForKey:13 value:&value]);

853 XCTAssertEqual(value, 302U);

854 XCTAssertFalse([dict valueForKey:14 value:NULL]);

855

856 __block NSUInteger idx = 0;

857 int32_t seenKeys = malloc(3 sizeof(int32_t));

858 uint64_t seenValues = malloc(3 sizeof(uint64_t));

859 [dict enumerateKeysAndValuesUsingBlock:^(int32_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:^(int32_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 int32_t kKeys1[] = { 11, 12, 13, 14 };

892 const int32_t kKeys2[] = { 12, 11, 14 };

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 GPBInt32UInt64Dictionary *dict1 =

897 [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues1

898 forKeys:kKeys1

899 count:GPBARRAYSIZE(kValues1)];

900 XCTAssertNotNil(dict1);

901 GPBInt32UInt64Dictionary *dict1prime =

902 [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues1

903 forKeys:kKeys1

904 count:GPBARRAYSIZE(kValues1)];

905 XCTAssertNotNil(dict1prime);

906 GPBInt32UInt64Dictionary *dict2 =

907 [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues2

908 forKeys:kKeys1

909 count:GPBARRAYSIZE(kValues2)];

910 XCTAssertNotNil(dict2);

911 GPBInt32UInt64Dictionary *dict3 =

912 [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues1

913 forKeys:kKeys2

914 count:GPBARRAYSIZE(kValues1)];

915 XCTAssertNotNil(dict3);

916 GPBInt32UInt64Dictionary *dict4 =

917 [[GPBInt32UInt64Dictionary 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 save keys, different values; not equal.

929 XCTAssertNotEqualObjects(dict1, dict2);

930

931 // 3 is different keys, samae 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 int32_t kKeys[] = { 11, 12, 13, 14 };

946 const uint64_t kValues[] = { 300U, 301U, 302U, 303U };

947 GPBInt32UInt64Dictionary *dict =

948 [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues

949 forKeys:kKeys

950 count:GPBARRAYSIZE(kValues)];

951 XCTAssertNotNil(dict);

952

953 GPBInt32UInt64Dictionary *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:[GPBInt32UInt64Dictionary class]]);

960

961 [dict2 release];

962 [dict release];

963 }

964

965 - (void)testDictionaryFromDictionary {

966 const int32_t kKeys[] = { 11, 12, 13, 14 };

967 const uint64_t kValues[] = { 300U, 301U, 302U, 303U };

968 GPBInt32UInt64Dictionary *dict =

969 [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues

970 forKeys:kKeys

971 count:GPBARRAYSIZE(kValues)];

972 XCTAssertNotNil(dict);

973

974 GPBInt32UInt64Dictionary *dict2 =

975 [GPBInt32UInt64Dictionary 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 GPBInt32UInt64Dictionary *dict = [GPBInt32UInt64Dictionary dictionary];

986 XCTAssertNotNil(dict);

987

988 XCTAssertEqual(dict.count, 0U);

989 [dict setValue:300U forKey:11];

990 XCTAssertEqual(dict.count, 1U);

991

992 const int32_t kKeys[] = { 12, 13, 14 };

993 const uint64_t kValues[] = { 301U, 302U, 303U };

994 GPBInt32UInt64Dictionary *dict2 =

995 [[GPBInt32UInt64Dictionary 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:11 value:NULL]);

1004 XCTAssertTrue([dict valueForKey:11 value:&value]);

1005 XCTAssertEqual(value, 300U);

1006 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1007 XCTAssertTrue([dict valueForKey:12 value:&value]);

1008 XCTAssertEqual(value, 301U);

1009 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1010 XCTAssertTrue([dict valueForKey:13 value:&value]);

1011 XCTAssertEqual(value, 302U);

1012 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1013 XCTAssertTrue([dict valueForKey:14 value:&value]);

1014 XCTAssertEqual(value, 303U);

1015 [dict2 release];

1016 }

1017

1018 - (void)testRemove {

1019 const int32_t kKeys[] = { 11, 12, 13, 14 };

1020 const uint64_t kValues[] = { 300U, 301U, 302U, 303U };

1021 GPBInt32UInt64Dictionary *dict =

1022 [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues

1023 forKeys:kKeys

1024 count:GPBARRAYSIZE(kValues)];

1025 XCTAssertNotNil(dict);

1026 XCTAssertEqual(dict.count, 4U);

1027

1028 [dict removeValueForKey:12];

1029 XCTAssertEqual(dict.count, 3U);

1030 uint64_t value;

1031 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1032 XCTAssertTrue([dict valueForKey:11 value:&value]);

1033 XCTAssertEqual(value, 300U);

1034 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1035 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1036 XCTAssertTrue([dict valueForKey:13 value:&value]);

1037 XCTAssertEqual(value, 302U);

1038 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1039 XCTAssertTrue([dict valueForKey:14 value:&value]);

1040 XCTAssertEqual(value, 303U);

1041

1042 // Remove again does nothing.

1043 [dict removeValueForKey:12];

1044 XCTAssertEqual(dict.count, 3U);

1045 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1046 XCTAssertTrue([dict valueForKey:11 value:&value]);

1047 XCTAssertEqual(value, 300U);

1048 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1049 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1050 XCTAssertTrue([dict valueForKey:13 value:&value]);

1051 XCTAssertEqual(value, 302U);

1052 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1053 XCTAssertTrue([dict valueForKey:14 value:&value]);

1054 XCTAssertEqual(value, 303U);

1055

1056 [dict removeValueForKey:14];

1057 XCTAssertEqual(dict.count, 2U);

1058 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1059 XCTAssertTrue([dict valueForKey:11 value:&value]);

1060 XCTAssertEqual(value, 300U);

1061 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1062 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1063 XCTAssertTrue([dict valueForKey:13 value:&value]);

1064 XCTAssertEqual(value, 302U);

1065 XCTAssertFalse([dict valueForKey:14 value:NULL]);

1066

1067 [dict removeAll];

1068 XCTAssertEqual(dict.count, 0U);

1069 XCTAssertFalse([dict valueForKey:11 value:NULL]);

1070 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1071 XCTAssertFalse([dict valueForKey:13 value:NULL]);

1072 XCTAssertFalse([dict valueForKey:14 value:NULL]);

1073 [dict release];

1074 }

1075

1076 - (void)testInplaceMutation {

1077 const int32_t kKeys[] = { 11, 12, 13, 14 };

1078 const uint64_t kValues[] = { 300U, 301U, 302U, 303U };

1079 GPBInt32UInt64Dictionary *dict =

1080 [[GPBInt32UInt64Dictionary 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:11 value:NULL]);

1087 XCTAssertTrue([dict valueForKey:11 value:&value]);

1088 XCTAssertEqual(value, 300U);

1089 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1090 XCTAssertTrue([dict valueForKey:12 value:&value]);

1091 XCTAssertEqual(value, 301U);

1092 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1093 XCTAssertTrue([dict valueForKey:13 value:&value]);

1094 XCTAssertEqual(value, 302U);

1095 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1096 XCTAssertTrue([dict valueForKey:14 value:&value]);

1097 XCTAssertEqual(value, 303U);

1098

1099 [dict setValue:303U forKey:11];

1100 XCTAssertEqual(dict.count, 4U);

1101 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1102 XCTAssertTrue([dict valueForKey:11 value:&value]);

1103 XCTAssertEqual(value, 303U);

1104 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1105 XCTAssertTrue([dict valueForKey:12 value:&value]);

1106 XCTAssertEqual(value, 301U);

1107 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1108 XCTAssertTrue([dict valueForKey:13 value:&value]);

1109 XCTAssertEqual(value, 302U);

1110 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1111 XCTAssertTrue([dict valueForKey:14 value:&value]);

1112 XCTAssertEqual(value, 303U);

1113

1114 [dict setValue:301U forKey:14];

1115 XCTAssertEqual(dict.count, 4U);

1116 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1117 XCTAssertTrue([dict valueForKey:11 value:&value]);

1118 XCTAssertEqual(value, 303U);

1119 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1120 XCTAssertTrue([dict valueForKey:12 value:&value]);

1121 XCTAssertEqual(value, 301U);

1122 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1123 XCTAssertTrue([dict valueForKey:13 value:&value]);

1124 XCTAssertEqual(value, 302U);

1125 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1126 XCTAssertTrue([dict valueForKey:14 value:&value]);

1127 XCTAssertEqual(value, 301U);

1128

1129 const int32_t kKeys2[] = { 12, 13 };

1130 const uint64_t kValues2[] = { 302U, 300U };

1131 GPBInt32UInt64Dictionary *dict2 =

1132 [[GPBInt32UInt64Dictionary 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:11 value:NULL]);

1139 XCTAssertTrue([dict valueForKey:11 value:&value]);

1140 XCTAssertEqual(value, 303U);

1141 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1142 XCTAssertTrue([dict valueForKey:12 value:&value]);

1143 XCTAssertEqual(value, 302U);

1144 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1145 XCTAssertTrue([dict valueForKey:13 value:&value]);

1146 XCTAssertEqual(value, 300U);

1147 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1148 XCTAssertTrue([dict valueForKey:14 value:&value]);

1149 XCTAssertEqual(value, 301U);

1150

1151 [dict2 release];

1152 [dict release];

1153 }

1154

1155 @end

1156

1157 #pragma mark - Int32 -> Int64

1158

1159 @interface GPBInt32Int64DictionaryTests : XCTestCase

1160 @end

1161

1162 @implementation GPBInt32Int64DictionaryTests

1163

1164 - (void)testEmpty {

1165 GPBInt32Int64Dictionary *dict = [[GPBInt32Int64Dictionary alloc] init];

1166 XCTAssertNotNil(dict);

1167 XCTAssertEqual(dict.count, 0U);

1168 XCTAssertFalse([dict valueForKey:11 value:NULL]);

1169 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *s top) {

1170 #pragma unused(aKey, aValue, stop)

1171 XCTFail(@"Shouldn't get here!");

1172 }];

1173 [dict release];

1174 }

1175

1176 - (void)testOne {

1177 GPBInt32Int64Dictionary *dict = [GPBInt32Int64Dictionary dictionaryWithValue:4 00 forKey:11];

1178 XCTAssertNotNil(dict);

1179 XCTAssertEqual(dict.count, 1U);

1180 int64_t value;

1181 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1182 XCTAssertTrue([dict valueForKey:11 value:&value]);

1183 XCTAssertEqual(value, 400);

1184 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1185 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *s top) {

1186 XCTAssertEqual(aKey, 11);

1187 XCTAssertEqual(aValue, 400);

1188 XCTAssertNotEqual(stop, NULL);

1189 }];

1190 }

1191

1192 - (void)testBasics {

1193 const int32_t kKeys[] = { 11, 12, 13 };

1194 const int64_t kValues[] = { 400, 401, 402 };

1195 GPBInt32Int64Dictionary *dict =

1196 [[GPBInt32Int64Dictionary 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:11 value:NULL]);

1203 XCTAssertTrue([dict valueForKey:11 value:&value]);

1204 XCTAssertEqual(value, 400);

1205 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1206 XCTAssertTrue([dict valueForKey:12 value:&value]);

1207 XCTAssertEqual(value, 401);

1208 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1209 XCTAssertTrue([dict valueForKey:13 value:&value]);

1210 XCTAssertEqual(value, 402);

1211 XCTAssertFalse([dict valueForKey:14 value:NULL]);

1212

1213 __block NSUInteger idx = 0;

1214 int32_t seenKeys = malloc(3 sizeof(int32_t));

1215 int64_t seenValues = malloc(3 sizeof(int64_t));

1216 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *s top) {

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:^(int32_t aKey, int64_t aValue, BOOL *s top) {

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 int32_t kKeys1[] = { 11, 12, 13, 14 };

1249 const int32_t kKeys2[] = { 12, 11, 14 };

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 GPBInt32Int64Dictionary *dict1 =

1254 [[GPBInt32Int64Dictionary alloc] initWithValues:kValues1

1255 forKeys:kKeys1

1256 count:GPBARRAYSIZE(kValues1)];

1257 XCTAssertNotNil(dict1);

1258 GPBInt32Int64Dictionary *dict1prime =

1259 [[GPBInt32Int64Dictionary alloc] initWithValues:kValues1

1260 forKeys:kKeys1

1261 count:GPBARRAYSIZE(kValues1)];

1262 XCTAssertNotNil(dict1prime);

1263 GPBInt32Int64Dictionary *dict2 =

1264 [[GPBInt32Int64Dictionary alloc] initWithValues:kValues2

1265 forKeys:kKeys1

1266 count:GPBARRAYSIZE(kValues2)];

1267 XCTAssertNotNil(dict2);

1268 GPBInt32Int64Dictionary *dict3 =

1269 [[GPBInt32Int64Dictionary alloc] initWithValues:kValues1

1270 forKeys:kKeys2

1271 count:GPBARRAYSIZE(kValues1)];

1272 XCTAssertNotNil(dict3);

1273 GPBInt32Int64Dictionary *dict4 =

1274 [[GPBInt32Int64Dictionary 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 save keys, different values; not equal.

1286 XCTAssertNotEqualObjects(dict1, dict2);

1287

1288 // 3 is different keys, samae 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 int32_t kKeys[] = { 11, 12, 13, 14 };

1303 const int64_t kValues[] = { 400, 401, 402, 403 };

1304 GPBInt32Int64Dictionary *dict =

1305 [[GPBInt32Int64Dictionary alloc] initWithValues:kValues

1306 forKeys:kKeys

1307 count:GPBARRAYSIZE(kValues)];

1308 XCTAssertNotNil(dict);

1309

1310 GPBInt32Int64Dictionary *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:[GPBInt32Int64Dictionary class]]);

1317

1318 [dict2 release];

1319 [dict release];

1320 }

1321

1322 - (void)testDictionaryFromDictionary {

1323 const int32_t kKeys[] = { 11, 12, 13, 14 };

1324 const int64_t kValues[] = { 400, 401, 402, 403 };

1325 GPBInt32Int64Dictionary *dict =

1326 [[GPBInt32Int64Dictionary alloc] initWithValues:kValues

1327 forKeys:kKeys

1328 count:GPBARRAYSIZE(kValues)];

1329 XCTAssertNotNil(dict);

1330

1331 GPBInt32Int64Dictionary *dict2 =

1332 [GPBInt32Int64Dictionary 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 GPBInt32Int64Dictionary *dict = [GPBInt32Int64Dictionary dictionary];

1343 XCTAssertNotNil(dict);

1344

1345 XCTAssertEqual(dict.count, 0U);

1346 [dict setValue:400 forKey:11];

1347 XCTAssertEqual(dict.count, 1U);

1348

1349 const int32_t kKeys[] = { 12, 13, 14 };

1350 const int64_t kValues[] = { 401, 402, 403 };

1351 GPBInt32Int64Dictionary *dict2 =

1352 [[GPBInt32Int64Dictionary 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:11 value:NULL]);

1361 XCTAssertTrue([dict valueForKey:11 value:&value]);

1362 XCTAssertEqual(value, 400);

1363 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1364 XCTAssertTrue([dict valueForKey:12 value:&value]);

1365 XCTAssertEqual(value, 401);

1366 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1367 XCTAssertTrue([dict valueForKey:13 value:&value]);

1368 XCTAssertEqual(value, 402);

1369 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1370 XCTAssertTrue([dict valueForKey:14 value:&value]);

1371 XCTAssertEqual(value, 403);

1372 [dict2 release];

1373 }

1374

1375 - (void)testRemove {

1376 const int32_t kKeys[] = { 11, 12, 13, 14 };

1377 const int64_t kValues[] = { 400, 401, 402, 403 };

1378 GPBInt32Int64Dictionary *dict =

1379 [[GPBInt32Int64Dictionary alloc] initWithValues:kValues

1380 forKeys:kKeys

1381 count:GPBARRAYSIZE(kValues)];

1382 XCTAssertNotNil(dict);

1383 XCTAssertEqual(dict.count, 4U);

1384

1385 [dict removeValueForKey:12];

1386 XCTAssertEqual(dict.count, 3U);

1387 int64_t value;

1388 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1389 XCTAssertTrue([dict valueForKey:11 value:&value]);

1390 XCTAssertEqual(value, 400);

1391 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1392 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1393 XCTAssertTrue([dict valueForKey:13 value:&value]);

1394 XCTAssertEqual(value, 402);

1395 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1396 XCTAssertTrue([dict valueForKey:14 value:&value]);

1397 XCTAssertEqual(value, 403);

1398

1399 // Remove again does nothing.

1400 [dict removeValueForKey:12];

1401 XCTAssertEqual(dict.count, 3U);

1402 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1403 XCTAssertTrue([dict valueForKey:11 value:&value]);

1404 XCTAssertEqual(value, 400);

1405 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1406 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1407 XCTAssertTrue([dict valueForKey:13 value:&value]);

1408 XCTAssertEqual(value, 402);

1409 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1410 XCTAssertTrue([dict valueForKey:14 value:&value]);

1411 XCTAssertEqual(value, 403);

1412

1413 [dict removeValueForKey:14];

1414 XCTAssertEqual(dict.count, 2U);

1415 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1416 XCTAssertTrue([dict valueForKey:11 value:&value]);

1417 XCTAssertEqual(value, 400);

1418 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1419 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1420 XCTAssertTrue([dict valueForKey:13 value:&value]);

1421 XCTAssertEqual(value, 402);

1422 XCTAssertFalse([dict valueForKey:14 value:NULL]);

1423

1424 [dict removeAll];

1425 XCTAssertEqual(dict.count, 0U);

1426 XCTAssertFalse([dict valueForKey:11 value:NULL]);

1427 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1428 XCTAssertFalse([dict valueForKey:13 value:NULL]);

1429 XCTAssertFalse([dict valueForKey:14 value:NULL]);

1430 [dict release];

1431 }

1432

1433 - (void)testInplaceMutation {

1434 const int32_t kKeys[] = { 11, 12, 13, 14 };

1435 const int64_t kValues[] = { 400, 401, 402, 403 };

1436 GPBInt32Int64Dictionary *dict =

1437 [[GPBInt32Int64Dictionary 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:11 value:NULL]);

1444 XCTAssertTrue([dict valueForKey:11 value:&value]);

1445 XCTAssertEqual(value, 400);

1446 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1447 XCTAssertTrue([dict valueForKey:12 value:&value]);

1448 XCTAssertEqual(value, 401);

1449 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1450 XCTAssertTrue([dict valueForKey:13 value:&value]);

1451 XCTAssertEqual(value, 402);

1452 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1453 XCTAssertTrue([dict valueForKey:14 value:&value]);

1454 XCTAssertEqual(value, 403);

1455

1456 [dict setValue:403 forKey:11];

1457 XCTAssertEqual(dict.count, 4U);

1458 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1459 XCTAssertTrue([dict valueForKey:11 value:&value]);

1460 XCTAssertEqual(value, 403);

1461 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1462 XCTAssertTrue([dict valueForKey:12 value:&value]);

1463 XCTAssertEqual(value, 401);

1464 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1465 XCTAssertTrue([dict valueForKey:13 value:&value]);

1466 XCTAssertEqual(value, 402);

1467 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1468 XCTAssertTrue([dict valueForKey:14 value:&value]);

1469 XCTAssertEqual(value, 403);

1470

1471 [dict setValue:401 forKey:14];

1472 XCTAssertEqual(dict.count, 4U);

1473 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1474 XCTAssertTrue([dict valueForKey:11 value:&value]);

1475 XCTAssertEqual(value, 403);

1476 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1477 XCTAssertTrue([dict valueForKey:12 value:&value]);

1478 XCTAssertEqual(value, 401);

1479 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1480 XCTAssertTrue([dict valueForKey:13 value:&value]);

1481 XCTAssertEqual(value, 402);

1482 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1483 XCTAssertTrue([dict valueForKey:14 value:&value]);

1484 XCTAssertEqual(value, 401);

1485

1486 const int32_t kKeys2[] = { 12, 13 };

1487 const int64_t kValues2[] = { 402, 400 };

1488 GPBInt32Int64Dictionary *dict2 =

1489 [[GPBInt32Int64Dictionary 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:11 value:NULL]);

1496 XCTAssertTrue([dict valueForKey:11 value:&value]);

1497 XCTAssertEqual(value, 403);

1498 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1499 XCTAssertTrue([dict valueForKey:12 value:&value]);

1500 XCTAssertEqual(value, 402);

1501 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1502 XCTAssertTrue([dict valueForKey:13 value:&value]);

1503 XCTAssertEqual(value, 400);

1504 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1505 XCTAssertTrue([dict valueForKey:14 value:&value]);

1506 XCTAssertEqual(value, 401);

1507

1508 [dict2 release];

1509 [dict release];

1510 }

1511

1512 @end

1513

1514 #pragma mark - Int32 -> Bool

1515

1516 @interface GPBInt32BoolDictionaryTests : XCTestCase

1517 @end

1518

1519 @implementation GPBInt32BoolDictionaryTests

1520

1521 - (void)testEmpty {

1522 GPBInt32BoolDictionary *dict = [[GPBInt32BoolDictionary alloc] init];

1523 XCTAssertNotNil(dict);

1524 XCTAssertEqual(dict.count, 0U);

1525 XCTAssertFalse([dict valueForKey:11 value:NULL]);

1526 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop ) {

1527 #pragma unused(aKey, aValue, stop)

1528 XCTFail(@"Shouldn't get here!");

1529 }];

1530 [dict release];

1531 }

1532

1533 - (void)testOne {

1534 GPBInt32BoolDictionary *dict = [GPBInt32BoolDictionary dictionaryWithValue:YES forKey:11];

1535 XCTAssertNotNil(dict);

1536 XCTAssertEqual(dict.count, 1U);

1537 BOOL value;

1538 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1539 XCTAssertTrue([dict valueForKey:11 value:&value]);

1540 XCTAssertEqual(value, YES);

1541 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1542 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop ) {

1543 XCTAssertEqual(aKey, 11);

1544 XCTAssertEqual(aValue, YES);

1545 XCTAssertNotEqual(stop, NULL);

1546 }];

1547 }

1548

1549 - (void)testBasics {

1550 const int32_t kKeys[] = { 11, 12, 13 };

1551 const BOOL kValues[] = { YES, YES, NO };

1552 GPBInt32BoolDictionary *dict =

1553 [[GPBInt32BoolDictionary 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:11 value:NULL]);

1560 XCTAssertTrue([dict valueForKey:11 value:&value]);

1561 XCTAssertEqual(value, YES);

1562 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1563 XCTAssertTrue([dict valueForKey:12 value:&value]);

1564 XCTAssertEqual(value, YES);

1565 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1566 XCTAssertTrue([dict valueForKey:13 value:&value]);

1567 XCTAssertEqual(value, NO);

1568 XCTAssertFalse([dict valueForKey:14 value:NULL]);

1569

1570 __block NSUInteger idx = 0;

1571 int32_t seenKeys = malloc(3 sizeof(int32_t));

1572 BOOL seenValues = malloc(3 sizeof(BOOL));

1573 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop ) {

1574 XCTAssertLessThan(idx, 3U);

1575 seenKeys[idx] = aKey;

1576 seenValues[idx] = aValue;

1577 XCTAssertNotEqual(stop, NULL);

1578 ++idx;

1579 }];

1580 for (int i = 0; i < 3; ++i) {

1581 BOOL foundKey = NO;

1582 for (int j = 0; (j < 3) && !foundKey; ++j) {

1583 if (kKeys[i] == seenKeys[j]) {

1584 foundKey = YES;

1585 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j);

1586 }

1587 }

1588 XCTAssertTrue(foundKey, @"i = %d", i);

1589 }

1590 free(seenKeys);

1591 free(seenValues);

1592

1593 // Stopping the enumeration.

1594 idx = 0;

1595 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop ) {

1596 #pragma unused(aKey, aValue)

1597 if (idx == 1) *stop = YES;

1598 XCTAssertNotEqual(idx, 2U);

1599 ++idx;

1600 }];

1601 [dict release];

1602 }

1603

1604 - (void)testEquality {

1605 const int32_t kKeys1[] = { 11, 12, 13, 14 };

1606 const int32_t kKeys2[] = { 12, 11, 14 };

1607 const BOOL kValues1[] = { YES, YES, NO };

1608 const BOOL kValues2[] = { YES, NO, NO };

1609 const BOOL kValues3[] = { YES, YES, NO, NO };

1610 GPBInt32BoolDictionary *dict1 =

1611 [[GPBInt32BoolDictionary alloc] initWithValues:kValues1

1612 forKeys:kKeys1

1613 count:GPBARRAYSIZE(kValues1)];

1614 XCTAssertNotNil(dict1);

1615 GPBInt32BoolDictionary *dict1prime =

1616 [[GPBInt32BoolDictionary alloc] initWithValues:kValues1

1617 forKeys:kKeys1

1618 count:GPBARRAYSIZE(kValues1)];

1619 XCTAssertNotNil(dict1prime);

1620 GPBInt32BoolDictionary *dict2 =

1621 [[GPBInt32BoolDictionary alloc] initWithValues:kValues2

1622 forKeys:kKeys1

1623 count:GPBARRAYSIZE(kValues2)];

1624 XCTAssertNotNil(dict2);

1625 GPBInt32BoolDictionary *dict3 =

1626 [[GPBInt32BoolDictionary alloc] initWithValues:kValues1

1627 forKeys:kKeys2

1628 count:GPBARRAYSIZE(kValues1)];

1629 XCTAssertNotNil(dict3);

1630 GPBInt32BoolDictionary *dict4 =

1631 [[GPBInt32BoolDictionary 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 save keys, different values; not equal.

1643 XCTAssertNotEqualObjects(dict1, dict2);

1644

1645 // 3 is different keys, samae 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 int32_t kKeys[] = { 11, 12, 13, 14 };

1660 const BOOL kValues[] = { YES, YES, NO, NO };

1661 GPBInt32BoolDictionary *dict =

1662 [[GPBInt32BoolDictionary alloc] initWithValues:kValues

1663 forKeys:kKeys

1664 count:GPBARRAYSIZE(kValues)];

1665 XCTAssertNotNil(dict);

1666

1667 GPBInt32BoolDictionary *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:[GPBInt32BoolDictionary class]]);

1674

1675 [dict2 release];

1676 [dict release];

1677 }

1678

1679 - (void)testDictionaryFromDictionary {

1680 const int32_t kKeys[] = { 11, 12, 13, 14 };

1681 const BOOL kValues[] = { YES, YES, NO, NO };

1682 GPBInt32BoolDictionary *dict =

1683 [[GPBInt32BoolDictionary alloc] initWithValues:kValues

1684 forKeys:kKeys

1685 count:GPBARRAYSIZE(kValues)];

1686 XCTAssertNotNil(dict);

1687

1688 GPBInt32BoolDictionary *dict2 =

1689 [GPBInt32BoolDictionary 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 GPBInt32BoolDictionary *dict = [GPBInt32BoolDictionary dictionary];

1700 XCTAssertNotNil(dict);

1701

1702 XCTAssertEqual(dict.count, 0U);

1703 [dict setValue:YES forKey:11];

1704 XCTAssertEqual(dict.count, 1U);

1705

1706 const int32_t kKeys[] = { 12, 13, 14 };

1707 const BOOL kValues[] = { YES, NO, NO };

1708 GPBInt32BoolDictionary *dict2 =

1709 [[GPBInt32BoolDictionary 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:11 value:NULL]);

1718 XCTAssertTrue([dict valueForKey:11 value:&value]);

1719 XCTAssertEqual(value, YES);

1720 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1721 XCTAssertTrue([dict valueForKey:12 value:&value]);

1722 XCTAssertEqual(value, YES);

1723 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1724 XCTAssertTrue([dict valueForKey:13 value:&value]);

1725 XCTAssertEqual(value, NO);

1726 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1727 XCTAssertTrue([dict valueForKey:14 value:&value]);

1728 XCTAssertEqual(value, NO);

1729 [dict2 release];

1730 }

1731

1732 - (void)testRemove {

1733 const int32_t kKeys[] = { 11, 12, 13, 14 };

1734 const BOOL kValues[] = { YES, YES, NO, NO };

1735 GPBInt32BoolDictionary *dict =

1736 [[GPBInt32BoolDictionary alloc] initWithValues:kValues

1737 forKeys:kKeys

1738 count:GPBARRAYSIZE(kValues)];

1739 XCTAssertNotNil(dict);

1740 XCTAssertEqual(dict.count, 4U);

1741

1742 [dict removeValueForKey:12];

1743 XCTAssertEqual(dict.count, 3U);

1744 BOOL value;

1745 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1746 XCTAssertTrue([dict valueForKey:11 value:&value]);

1747 XCTAssertEqual(value, YES);

1748 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1749 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1750 XCTAssertTrue([dict valueForKey:13 value:&value]);

1751 XCTAssertEqual(value, NO);

1752 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1753 XCTAssertTrue([dict valueForKey:14 value:&value]);

1754 XCTAssertEqual(value, NO);

1755

1756 // Remove again does nothing.

1757 [dict removeValueForKey:12];

1758 XCTAssertEqual(dict.count, 3U);

1759 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1760 XCTAssertTrue([dict valueForKey:11 value:&value]);

1761 XCTAssertEqual(value, YES);

1762 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1763 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1764 XCTAssertTrue([dict valueForKey:13 value:&value]);

1765 XCTAssertEqual(value, NO);

1766 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1767 XCTAssertTrue([dict valueForKey:14 value:&value]);

1768 XCTAssertEqual(value, NO);

1769

1770 [dict removeValueForKey:14];

1771 XCTAssertEqual(dict.count, 2U);

1772 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1773 XCTAssertTrue([dict valueForKey:11 value:&value]);

1774 XCTAssertEqual(value, YES);

1775 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1776 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1777 XCTAssertTrue([dict valueForKey:13 value:&value]);

1778 XCTAssertEqual(value, NO);

1779 XCTAssertFalse([dict valueForKey:14 value:NULL]);

1780

1781 [dict removeAll];

1782 XCTAssertEqual(dict.count, 0U);

1783 XCTAssertFalse([dict valueForKey:11 value:NULL]);

1784 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1785 XCTAssertFalse([dict valueForKey:13 value:NULL]);

1786 XCTAssertFalse([dict valueForKey:14 value:NULL]);

1787 [dict release];

1788 }

1789

1790 - (void)testInplaceMutation {

1791 const int32_t kKeys[] = { 11, 12, 13, 14 };

1792 const BOOL kValues[] = { YES, YES, NO, NO };

1793 GPBInt32BoolDictionary *dict =

1794 [[GPBInt32BoolDictionary 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:11 value:NULL]);

1801 XCTAssertTrue([dict valueForKey:11 value:&value]);

1802 XCTAssertEqual(value, YES);

1803 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1804 XCTAssertTrue([dict valueForKey:12 value:&value]);

1805 XCTAssertEqual(value, YES);

1806 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1807 XCTAssertTrue([dict valueForKey:13 value:&value]);

1808 XCTAssertEqual(value, NO);

1809 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1810 XCTAssertTrue([dict valueForKey:14 value:&value]);

1811 XCTAssertEqual(value, NO);

1812

1813 [dict setValue:NO forKey:11];

1814 XCTAssertEqual(dict.count, 4U);

1815 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1816 XCTAssertTrue([dict valueForKey:11 value:&value]);

1817 XCTAssertEqual(value, NO);

1818 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1819 XCTAssertTrue([dict valueForKey:12 value:&value]);

1820 XCTAssertEqual(value, YES);

1821 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1822 XCTAssertTrue([dict valueForKey:13 value:&value]);

1823 XCTAssertEqual(value, NO);

1824 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1825 XCTAssertTrue([dict valueForKey:14 value:&value]);

1826 XCTAssertEqual(value, NO);

1827

1828 [dict setValue:YES forKey:14];

1829 XCTAssertEqual(dict.count, 4U);

1830 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1831 XCTAssertTrue([dict valueForKey:11 value:&value]);

1832 XCTAssertEqual(value, NO);

1833 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1834 XCTAssertTrue([dict valueForKey:12 value:&value]);

1835 XCTAssertEqual(value, YES);

1836 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1837 XCTAssertTrue([dict valueForKey:13 value:&value]);

1838 XCTAssertEqual(value, NO);

1839 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1840 XCTAssertTrue([dict valueForKey:14 value:&value]);

1841 XCTAssertEqual(value, YES);

1842

1843 const int32_t kKeys2[] = { 12, 13 };

1844 const BOOL kValues2[] = { NO, YES };

1845 GPBInt32BoolDictionary *dict2 =

1846 [[GPBInt32BoolDictionary 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:11 value:NULL]);

1853 XCTAssertTrue([dict valueForKey:11 value:&value]);

1854 XCTAssertEqual(value, NO);

1855 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1856 XCTAssertTrue([dict valueForKey:12 value:&value]);

1857 XCTAssertEqual(value, NO);

1858 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1859 XCTAssertTrue([dict valueForKey:13 value:&value]);

1860 XCTAssertEqual(value, YES);

1861 XCTAssertTrue([dict valueForKey:14 value:NULL]);

1862 XCTAssertTrue([dict valueForKey:14 value:&value]);

1863 XCTAssertEqual(value, YES);

1864

1865 [dict2 release];

1866 [dict release];

1867 }

1868

1869 @end

1870

1871 #pragma mark - Int32 -> Float

1872

1873 @interface GPBInt32FloatDictionaryTests : XCTestCase

1874 @end

1875

1876 @implementation GPBInt32FloatDictionaryTests

1877

1878 - (void)testEmpty {

1879 GPBInt32FloatDictionary *dict = [[GPBInt32FloatDictionary alloc] init];

1880 XCTAssertNotNil(dict);

1881 XCTAssertEqual(dict.count, 0U);

1882 XCTAssertFalse([dict valueForKey:11 value:NULL]);

1883 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, float aValue, BOOL *sto p) {

1884 #pragma unused(aKey, aValue, stop)

1885 XCTFail(@"Shouldn't get here!");

1886 }];

1887 [dict release];

1888 }

1889

1890 - (void)testOne {

1891 GPBInt32FloatDictionary *dict = [GPBInt32FloatDictionary dictionaryWithValue:5 00.f forKey:11];

1892 XCTAssertNotNil(dict);

1893 XCTAssertEqual(dict.count, 1U);

1894 float value;

1895 XCTAssertTrue([dict valueForKey:11 value:NULL]);

1896 XCTAssertTrue([dict valueForKey:11 value:&value]);

1897 XCTAssertEqual(value, 500.f);

1898 XCTAssertFalse([dict valueForKey:12 value:NULL]);

1899 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, float aValue, BOOL *sto p) {

1900 XCTAssertEqual(aKey, 11);

1901 XCTAssertEqual(aValue, 500.f);

1902 XCTAssertNotEqual(stop, NULL);

1903 }];

1904 }

1905

1906 - (void)testBasics {

1907 const int32_t kKeys[] = { 11, 12, 13 };

1908 const float kValues[] = { 500.f, 501.f, 502.f };

1909 GPBInt32FloatDictionary *dict =

1910 [[GPBInt32FloatDictionary 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:11 value:NULL]);

1917 XCTAssertTrue([dict valueForKey:11 value:&value]);

1918 XCTAssertEqual(value, 500.f);

1919 XCTAssertTrue([dict valueForKey:12 value:NULL]);

1920 XCTAssertTrue([dict valueForKey:12 value:&value]);

1921 XCTAssertEqual(value, 501.f);

1922 XCTAssertTrue([dict valueForKey:13 value:NULL]);

1923 XCTAssertTrue([dict valueForKey:13 value:&value]);

1924 XCTAssertEqual(value, 502.f);

1925 XCTAssertFalse([dict valueForKey:14 value:NULL]);

1926

1927 __block NSUInteger idx = 0;

1928 int32_t seenKeys = malloc(3 sizeof(int32_t));

1929 float seenValues = malloc(3 sizeof(float));

1930 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, float aValue, BOOL *sto p) {

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:^(int32_t aKey, float aValue, BOOL *sto p) {

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 int32_t kKeys1[] = { 11, 12, 13, 14 };

1963 const int32_t kKeys2[] = { 12, 11, 14 };

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 GPBInt32FloatDictionary *dict1 =

1968 [[GPBInt32FloatDictionary alloc] initWithValues:kValues1

1969 forKeys:kKeys1

1970 count:GPBARRAYSIZE(kValues1)];

1971 XCTAssertNotNil(dict1);

1972 GPBInt32FloatDictionary *dict1prime =

1973 [[GPBInt32FloatDictionary alloc] initWithValues:kValues1

1974 forKeys:kKeys1

1975 count:GPBARRAYSIZE(kValues1)];

1976 XCTAssertNotNil(dict1prime);

1977 GPBInt32FloatDictionary *dict2 =

1978 [[GPBInt32FloatDictionary alloc] initWithValues:kValues2

1979 forKeys:kKeys1

1980 count:GPBARRAYSIZE(kValues2)];

1981 XCTAssertNotNil(dict2);

1982 GPBInt32FloatDictionary *dict3 =

1983 [[GPBInt32FloatDictionary alloc] initWithValues:kValues1

1984 forKeys:kKeys2

1985 count:GPBARRAYSIZE(kValues1)];

1986 XCTAssertNotNil(dict3);

1987 GPBInt32FloatDictionary *dict4 =

1988 [[GPBInt32FloatDictionary 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 save keys, different values; not equal.

2000 XCTAssertNotEqualObjects(dict1, dict2);

2001

2002 // 3 is different keys, samae 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 int32_t kKeys[] = { 11, 12, 13, 14 };

2017 const float kValues[] = { 500.f, 501.f, 502.f, 503.f };

2018 GPBInt32FloatDictionary *dict =

2019 [[GPBInt32FloatDictionary alloc] initWithValues:kValues

2020 forKeys:kKeys

2021 count:GPBARRAYSIZE(kValues)];

2022 XCTAssertNotNil(dict);

2023

2024 GPBInt32FloatDictionary *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:[GPBInt32FloatDictionary class]]);

2031

2032 [dict2 release];

2033 [dict release];

2034 }

2035

2036 - (void)testDictionaryFromDictionary {

2037 const int32_t kKeys[] = { 11, 12, 13, 14 };

2038 const float kValues[] = { 500.f, 501.f, 502.f, 503.f };

2039 GPBInt32FloatDictionary *dict =

2040 [[GPBInt32FloatDictionary alloc] initWithValues:kValues

2041 forKeys:kKeys

2042 count:GPBARRAYSIZE(kValues)];

2043 XCTAssertNotNil(dict);

2044

2045 GPBInt32FloatDictionary *dict2 =

2046 [GPBInt32FloatDictionary 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 GPBInt32FloatDictionary *dict = [GPBInt32FloatDictionary dictionary];

2057 XCTAssertNotNil(dict);

2058

2059 XCTAssertEqual(dict.count, 0U);

2060 [dict setValue:500.f forKey:11];

2061 XCTAssertEqual(dict.count, 1U);

2062

2063 const int32_t kKeys[] = { 12, 13, 14 };

2064 const float kValues[] = { 501.f, 502.f, 503.f };

2065 GPBInt32FloatDictionary *dict2 =

2066 [[GPBInt32FloatDictionary 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:11 value:NULL]);

2075 XCTAssertTrue([dict valueForKey:11 value:&value]);

2076 XCTAssertEqual(value, 500.f);

2077 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2078 XCTAssertTrue([dict valueForKey:12 value:&value]);

2079 XCTAssertEqual(value, 501.f);

2080 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2081 XCTAssertTrue([dict valueForKey:13 value:&value]);

2082 XCTAssertEqual(value, 502.f);

2083 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2084 XCTAssertTrue([dict valueForKey:14 value:&value]);

2085 XCTAssertEqual(value, 503.f);

2086 [dict2 release];

2087 }

2088

2089 - (void)testRemove {

2090 const int32_t kKeys[] = { 11, 12, 13, 14 };

2091 const float kValues[] = { 500.f, 501.f, 502.f, 503.f };

2092 GPBInt32FloatDictionary *dict =

2093 [[GPBInt32FloatDictionary alloc] initWithValues:kValues

2094 forKeys:kKeys

2095 count:GPBARRAYSIZE(kValues)];

2096 XCTAssertNotNil(dict);

2097 XCTAssertEqual(dict.count, 4U);

2098

2099 [dict removeValueForKey:12];

2100 XCTAssertEqual(dict.count, 3U);

2101 float value;

2102 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2103 XCTAssertTrue([dict valueForKey:11 value:&value]);

2104 XCTAssertEqual(value, 500.f);

2105 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2106 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2107 XCTAssertTrue([dict valueForKey:13 value:&value]);

2108 XCTAssertEqual(value, 502.f);

2109 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2110 XCTAssertTrue([dict valueForKey:14 value:&value]);

2111 XCTAssertEqual(value, 503.f);

2112

2113 // Remove again does nothing.

2114 [dict removeValueForKey:12];

2115 XCTAssertEqual(dict.count, 3U);

2116 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2117 XCTAssertTrue([dict valueForKey:11 value:&value]);

2118 XCTAssertEqual(value, 500.f);

2119 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2120 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2121 XCTAssertTrue([dict valueForKey:13 value:&value]);

2122 XCTAssertEqual(value, 502.f);

2123 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2124 XCTAssertTrue([dict valueForKey:14 value:&value]);

2125 XCTAssertEqual(value, 503.f);

2126

2127 [dict removeValueForKey:14];

2128 XCTAssertEqual(dict.count, 2U);

2129 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2130 XCTAssertTrue([dict valueForKey:11 value:&value]);

2131 XCTAssertEqual(value, 500.f);

2132 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2133 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2134 XCTAssertTrue([dict valueForKey:13 value:&value]);

2135 XCTAssertEqual(value, 502.f);

2136 XCTAssertFalse([dict valueForKey:14 value:NULL]);

2137

2138 [dict removeAll];

2139 XCTAssertEqual(dict.count, 0U);

2140 XCTAssertFalse([dict valueForKey:11 value:NULL]);

2141 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2142 XCTAssertFalse([dict valueForKey:13 value:NULL]);

2143 XCTAssertFalse([dict valueForKey:14 value:NULL]);

2144 [dict release];

2145 }

2146

2147 - (void)testInplaceMutation {

2148 const int32_t kKeys[] = { 11, 12, 13, 14 };

2149 const float kValues[] = { 500.f, 501.f, 502.f, 503.f };

2150 GPBInt32FloatDictionary *dict =

2151 [[GPBInt32FloatDictionary 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:11 value:NULL]);

2158 XCTAssertTrue([dict valueForKey:11 value:&value]);

2159 XCTAssertEqual(value, 500.f);

2160 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2161 XCTAssertTrue([dict valueForKey:12 value:&value]);

2162 XCTAssertEqual(value, 501.f);

2163 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2164 XCTAssertTrue([dict valueForKey:13 value:&value]);

2165 XCTAssertEqual(value, 502.f);

2166 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2167 XCTAssertTrue([dict valueForKey:14 value:&value]);

2168 XCTAssertEqual(value, 503.f);

2169

2170 [dict setValue:503.f forKey:11];

2171 XCTAssertEqual(dict.count, 4U);

2172 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2173 XCTAssertTrue([dict valueForKey:11 value:&value]);

2174 XCTAssertEqual(value, 503.f);

2175 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2176 XCTAssertTrue([dict valueForKey:12 value:&value]);

2177 XCTAssertEqual(value, 501.f);

2178 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2179 XCTAssertTrue([dict valueForKey:13 value:&value]);

2180 XCTAssertEqual(value, 502.f);

2181 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2182 XCTAssertTrue([dict valueForKey:14 value:&value]);

2183 XCTAssertEqual(value, 503.f);

2184

2185 [dict setValue:501.f forKey:14];

2186 XCTAssertEqual(dict.count, 4U);

2187 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2188 XCTAssertTrue([dict valueForKey:11 value:&value]);

2189 XCTAssertEqual(value, 503.f);

2190 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2191 XCTAssertTrue([dict valueForKey:12 value:&value]);

2192 XCTAssertEqual(value, 501.f);

2193 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2194 XCTAssertTrue([dict valueForKey:13 value:&value]);

2195 XCTAssertEqual(value, 502.f);

2196 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2197 XCTAssertTrue([dict valueForKey:14 value:&value]);

2198 XCTAssertEqual(value, 501.f);

2199

2200 const int32_t kKeys2[] = { 12, 13 };

2201 const float kValues2[] = { 502.f, 500.f };

2202 GPBInt32FloatDictionary *dict2 =

2203 [[GPBInt32FloatDictionary 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:11 value:NULL]);

2210 XCTAssertTrue([dict valueForKey:11 value:&value]);

2211 XCTAssertEqual(value, 503.f);

2212 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2213 XCTAssertTrue([dict valueForKey:12 value:&value]);

2214 XCTAssertEqual(value, 502.f);

2215 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2216 XCTAssertTrue([dict valueForKey:13 value:&value]);

2217 XCTAssertEqual(value, 500.f);

2218 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2219 XCTAssertTrue([dict valueForKey:14 value:&value]);

2220 XCTAssertEqual(value, 501.f);

2221

2222 [dict2 release];

2223 [dict release];

2224 }

2225

2226 @end

2227

2228 #pragma mark - Int32 -> Double

2229

2230 @interface GPBInt32DoubleDictionaryTests : XCTestCase

2231 @end

2232

2233 @implementation GPBInt32DoubleDictionaryTests

2234

2235 - (void)testEmpty {

2236 GPBInt32DoubleDictionary *dict = [[GPBInt32DoubleDictionary alloc] init];

2237 XCTAssertNotNil(dict);

2238 XCTAssertEqual(dict.count, 0U);

2239 XCTAssertFalse([dict valueForKey:11 value:NULL]);

2240 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, double aValue, BOOL *st op) {

2241 #pragma unused(aKey, aValue, stop)

2242 XCTFail(@"Shouldn't get here!");

2243 }];

2244 [dict release];

2245 }

2246

2247 - (void)testOne {

2248 GPBInt32DoubleDictionary *dict = [GPBInt32DoubleDictionary dictionaryWithValue :600. forKey:11];

2249 XCTAssertNotNil(dict);

2250 XCTAssertEqual(dict.count, 1U);

2251 double value;

2252 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2253 XCTAssertTrue([dict valueForKey:11 value:&value]);

2254 XCTAssertEqual(value, 600.);

2255 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2256 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, double aValue, BOOL *st op) {

2257 XCTAssertEqual(aKey, 11);

2258 XCTAssertEqual(aValue, 600.);

2259 XCTAssertNotEqual(stop, NULL);

2260 }];

2261 }

2262

2263 - (void)testBasics {

2264 const int32_t kKeys[] = { 11, 12, 13 };

2265 const double kValues[] = { 600., 601., 602. };

2266 GPBInt32DoubleDictionary *dict =

2267 [[GPBInt32DoubleDictionary 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:11 value:NULL]);

2274 XCTAssertTrue([dict valueForKey:11 value:&value]);

2275 XCTAssertEqual(value, 600.);

2276 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2277 XCTAssertTrue([dict valueForKey:12 value:&value]);

2278 XCTAssertEqual(value, 601.);

2279 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2280 XCTAssertTrue([dict valueForKey:13 value:&value]);

2281 XCTAssertEqual(value, 602.);

2282 XCTAssertFalse([dict valueForKey:14 value:NULL]);

2283

2284 __block NSUInteger idx = 0;

2285 int32_t seenKeys = malloc(3 sizeof(int32_t));

2286 double seenValues = malloc(3 sizeof(double));

2287 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, double aValue, BOOL *st op) {

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:^(int32_t aKey, double aValue, BOOL *st op) {

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 int32_t kKeys1[] = { 11, 12, 13, 14 };

2320 const int32_t kKeys2[] = { 12, 11, 14 };

2321 const double kValues1[] = { 600., 601., 602. };

2322 const double kValues2[] = { 600., 603., 602. };

2323 const double kValues3[] = { 600., 601., 602., 603. };

2324 GPBInt32DoubleDictionary *dict1 =

2325 [[GPBInt32DoubleDictionary alloc] initWithValues:kValues1

2326 forKeys:kKeys1

2327 count:GPBARRAYSIZE(kValues1)];

2328 XCTAssertNotNil(dict1);

2329 GPBInt32DoubleDictionary *dict1prime =

2330 [[GPBInt32DoubleDictionary alloc] initWithValues:kValues1

2331 forKeys:kKeys1

2332 count:GPBARRAYSIZE(kValues1)];

2333 XCTAssertNotNil(dict1prime);

2334 GPBInt32DoubleDictionary *dict2 =

2335 [[GPBInt32DoubleDictionary alloc] initWithValues:kValues2

2336 forKeys:kKeys1

2337 count:GPBARRAYSIZE(kValues2)];

2338 XCTAssertNotNil(dict2);

2339 GPBInt32DoubleDictionary *dict3 =

2340 [[GPBInt32DoubleDictionary alloc] initWithValues:kValues1

2341 forKeys:kKeys2

2342 count:GPBARRAYSIZE(kValues1)];

2343 XCTAssertNotNil(dict3);

2344 GPBInt32DoubleDictionary *dict4 =

2345 [[GPBInt32DoubleDictionary 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 save keys, different values; not equal.

2357 XCTAssertNotEqualObjects(dict1, dict2);

2358

2359 // 3 is different keys, samae 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 int32_t kKeys[] = { 11, 12, 13, 14 };

2374 const double kValues[] = { 600., 601., 602., 603. };

2375 GPBInt32DoubleDictionary *dict =

2376 [[GPBInt32DoubleDictionary alloc] initWithValues:kValues

2377 forKeys:kKeys

2378 count:GPBARRAYSIZE(kValues)];

2379 XCTAssertNotNil(dict);

2380

2381 GPBInt32DoubleDictionary *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:[GPBInt32DoubleDictionary class]]);

2388

2389 [dict2 release];

2390 [dict release];

2391 }

2392

2393 - (void)testDictionaryFromDictionary {

2394 const int32_t kKeys[] = { 11, 12, 13, 14 };

2395 const double kValues[] = { 600., 601., 602., 603. };

2396 GPBInt32DoubleDictionary *dict =

2397 [[GPBInt32DoubleDictionary alloc] initWithValues:kValues

2398 forKeys:kKeys

2399 count:GPBARRAYSIZE(kValues)];

2400 XCTAssertNotNil(dict);

2401

2402 GPBInt32DoubleDictionary *dict2 =

2403 [GPBInt32DoubleDictionary 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 GPBInt32DoubleDictionary *dict = [GPBInt32DoubleDictionary dictionary];

2414 XCTAssertNotNil(dict);

2415

2416 XCTAssertEqual(dict.count, 0U);

2417 [dict setValue:600. forKey:11];

2418 XCTAssertEqual(dict.count, 1U);

2419

2420 const int32_t kKeys[] = { 12, 13, 14 };

2421 const double kValues[] = { 601., 602., 603. };

2422 GPBInt32DoubleDictionary *dict2 =

2423 [[GPBInt32DoubleDictionary 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:11 value:NULL]);

2432 XCTAssertTrue([dict valueForKey:11 value:&value]);

2433 XCTAssertEqual(value, 600.);

2434 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2435 XCTAssertTrue([dict valueForKey:12 value:&value]);

2436 XCTAssertEqual(value, 601.);

2437 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2438 XCTAssertTrue([dict valueForKey:13 value:&value]);

2439 XCTAssertEqual(value, 602.);

2440 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2441 XCTAssertTrue([dict valueForKey:14 value:&value]);

2442 XCTAssertEqual(value, 603.);

2443 [dict2 release];

2444 }

2445

2446 - (void)testRemove {

2447 const int32_t kKeys[] = { 11, 12, 13, 14 };

2448 const double kValues[] = { 600., 601., 602., 603. };

2449 GPBInt32DoubleDictionary *dict =

2450 [[GPBInt32DoubleDictionary alloc] initWithValues:kValues

2451 forKeys:kKeys

2452 count:GPBARRAYSIZE(kValues)];

2453 XCTAssertNotNil(dict);

2454 XCTAssertEqual(dict.count, 4U);

2455

2456 [dict removeValueForKey:12];

2457 XCTAssertEqual(dict.count, 3U);

2458 double value;

2459 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2460 XCTAssertTrue([dict valueForKey:11 value:&value]);

2461 XCTAssertEqual(value, 600.);

2462 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2463 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2464 XCTAssertTrue([dict valueForKey:13 value:&value]);

2465 XCTAssertEqual(value, 602.);

2466 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2467 XCTAssertTrue([dict valueForKey:14 value:&value]);

2468 XCTAssertEqual(value, 603.);

2469

2470 // Remove again does nothing.

2471 [dict removeValueForKey:12];

2472 XCTAssertEqual(dict.count, 3U);

2473 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2474 XCTAssertTrue([dict valueForKey:11 value:&value]);

2475 XCTAssertEqual(value, 600.);

2476 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2477 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2478 XCTAssertTrue([dict valueForKey:13 value:&value]);

2479 XCTAssertEqual(value, 602.);

2480 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2481 XCTAssertTrue([dict valueForKey:14 value:&value]);

2482 XCTAssertEqual(value, 603.);

2483

2484 [dict removeValueForKey:14];

2485 XCTAssertEqual(dict.count, 2U);

2486 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2487 XCTAssertTrue([dict valueForKey:11 value:&value]);

2488 XCTAssertEqual(value, 600.);

2489 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2490 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2491 XCTAssertTrue([dict valueForKey:13 value:&value]);

2492 XCTAssertEqual(value, 602.);

2493 XCTAssertFalse([dict valueForKey:14 value:NULL]);

2494

2495 [dict removeAll];

2496 XCTAssertEqual(dict.count, 0U);

2497 XCTAssertFalse([dict valueForKey:11 value:NULL]);

2498 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2499 XCTAssertFalse([dict valueForKey:13 value:NULL]);

2500 XCTAssertFalse([dict valueForKey:14 value:NULL]);

2501 [dict release];

2502 }

2503

2504 - (void)testInplaceMutation {

2505 const int32_t kKeys[] = { 11, 12, 13, 14 };

2506 const double kValues[] = { 600., 601., 602., 603. };

2507 GPBInt32DoubleDictionary *dict =

2508 [[GPBInt32DoubleDictionary 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:11 value:NULL]);

2515 XCTAssertTrue([dict valueForKey:11 value:&value]);

2516 XCTAssertEqual(value, 600.);

2517 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2518 XCTAssertTrue([dict valueForKey:12 value:&value]);

2519 XCTAssertEqual(value, 601.);

2520 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2521 XCTAssertTrue([dict valueForKey:13 value:&value]);

2522 XCTAssertEqual(value, 602.);

2523 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2524 XCTAssertTrue([dict valueForKey:14 value:&value]);

2525 XCTAssertEqual(value, 603.);

2526

2527 [dict setValue:603. forKey:11];

2528 XCTAssertEqual(dict.count, 4U);

2529 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2530 XCTAssertTrue([dict valueForKey:11 value:&value]);

2531 XCTAssertEqual(value, 603.);

2532 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2533 XCTAssertTrue([dict valueForKey:12 value:&value]);

2534 XCTAssertEqual(value, 601.);

2535 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2536 XCTAssertTrue([dict valueForKey:13 value:&value]);

2537 XCTAssertEqual(value, 602.);

2538 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2539 XCTAssertTrue([dict valueForKey:14 value:&value]);

2540 XCTAssertEqual(value, 603.);

2541

2542 [dict setValue:601. forKey:14];

2543 XCTAssertEqual(dict.count, 4U);

2544 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2545 XCTAssertTrue([dict valueForKey:11 value:&value]);

2546 XCTAssertEqual(value, 603.);

2547 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2548 XCTAssertTrue([dict valueForKey:12 value:&value]);

2549 XCTAssertEqual(value, 601.);

2550 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2551 XCTAssertTrue([dict valueForKey:13 value:&value]);

2552 XCTAssertEqual(value, 602.);

2553 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2554 XCTAssertTrue([dict valueForKey:14 value:&value]);

2555 XCTAssertEqual(value, 601.);

2556

2557 const int32_t kKeys2[] = { 12, 13 };

2558 const double kValues2[] = { 602., 600. };

2559 GPBInt32DoubleDictionary *dict2 =

2560 [[GPBInt32DoubleDictionary 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:11 value:NULL]);

2567 XCTAssertTrue([dict valueForKey:11 value:&value]);

2568 XCTAssertEqual(value, 603.);

2569 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2570 XCTAssertTrue([dict valueForKey:12 value:&value]);

2571 XCTAssertEqual(value, 602.);

2572 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2573 XCTAssertTrue([dict valueForKey:13 value:&value]);

2574 XCTAssertEqual(value, 600.);

2575 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2576 XCTAssertTrue([dict valueForKey:14 value:&value]);

2577 XCTAssertEqual(value, 601.);

2578

2579 [dict2 release];

2580 [dict release];

2581 }

2582

2583 @end

2584

2585 #pragma mark - Int32 -> Enum

2586

2587 @interface GPBInt32EnumDictionaryTests : XCTestCase

2588 @end

2589

2590 @implementation GPBInt32EnumDictionaryTests

2591

2592 - (void)testEmpty {

2593 GPBInt32EnumDictionary *dict = [[GPBInt32EnumDictionary alloc] init];

2594 XCTAssertNotNil(dict);

2595 XCTAssertEqual(dict.count, 0U);

2596 XCTAssertFalse([dict valueForKey:11 value:NULL]);

2597 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *s top) {

2598 #pragma unused(aKey, aValue, stop)

2599 XCTFail(@"Shouldn't get here!");

2600 }];

2601 [dict release];

2602 }

2603

2604 - (void)testOne {

2605 GPBInt32EnumDictionary *dict = [GPBInt32EnumDictionary dictionaryWithValue:700 forKey:11];

2606 XCTAssertNotNil(dict);

2607 XCTAssertEqual(dict.count, 1U);

2608 int32_t value;

2609 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2610 XCTAssertTrue([dict valueForKey:11 value:&value]);

2611 XCTAssertEqual(value, 700);

2612 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2613 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *s top) {

2614 XCTAssertEqual(aKey, 11);

2615 XCTAssertEqual(aValue, 700);

2616 XCTAssertNotEqual(stop, NULL);

2617 }];

2618 }

2619

2620 - (void)testBasics {

2621 const int32_t kKeys[] = { 11, 12, 13 };

2622 const int32_t kValues[] = { 700, 701, 702 };

2623 GPBInt32EnumDictionary *dict =

2624 [[GPBInt32EnumDictionary 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:11 value:NULL]);

2631 XCTAssertTrue([dict valueForKey:11 value:&value]);

2632 XCTAssertEqual(value, 700);

2633 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2634 XCTAssertTrue([dict valueForKey:12 value:&value]);

2635 XCTAssertEqual(value, 701);

2636 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2637 XCTAssertTrue([dict valueForKey:13 value:&value]);

2638 XCTAssertEqual(value, 702);

2639 XCTAssertFalse([dict valueForKey:14 value:NULL]);

2640

2641 __block NSUInteger idx = 0;

2642 int32_t seenKeys = malloc(3 sizeof(int32_t));

2643 int32_t seenValues = malloc(3 sizeof(int32_t));

2644 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *s top) {

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:^(int32_t aKey, int32_t aValue, BOOL *s top) {

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 int32_t kKeys1[] = { 11, 12, 13, 14 };

2677 const int32_t kKeys2[] = { 12, 11, 14 };

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 GPBInt32EnumDictionary *dict1 =

2682 [[GPBInt32EnumDictionary alloc] initWithValues:kValues1

2683 forKeys:kKeys1

2684 count:GPBARRAYSIZE(kValues1)];

2685 XCTAssertNotNil(dict1);

2686 GPBInt32EnumDictionary *dict1prime =

2687 [[GPBInt32EnumDictionary alloc] initWithValues:kValues1

2688 forKeys:kKeys1

2689 count:GPBARRAYSIZE(kValues1)];

2690 XCTAssertNotNil(dict1prime);

2691 GPBInt32EnumDictionary *dict2 =

2692 [[GPBInt32EnumDictionary alloc] initWithValues:kValues2

2693 forKeys:kKeys1

2694 count:GPBARRAYSIZE(kValues2)];

2695 XCTAssertNotNil(dict2);

2696 GPBInt32EnumDictionary *dict3 =

2697 [[GPBInt32EnumDictionary alloc] initWithValues:kValues1

2698 forKeys:kKeys2

2699 count:GPBARRAYSIZE(kValues1)];

2700 XCTAssertNotNil(dict3);

2701 GPBInt32EnumDictionary *dict4 =

2702 [[GPBInt32EnumDictionary 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 save keys, different values; not equal.

2714 XCTAssertNotEqualObjects(dict1, dict2);

2715

2716 // 3 is different keys, samae 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 int32_t kKeys[] = { 11, 12, 13, 14 };

2731 const int32_t kValues[] = { 700, 701, 702, 703 };

2732 GPBInt32EnumDictionary *dict =

2733 [[GPBInt32EnumDictionary alloc] initWithValues:kValues

2734 forKeys:kKeys

2735 count:GPBARRAYSIZE(kValues)];

2736 XCTAssertNotNil(dict);

2737

2738 GPBInt32EnumDictionary *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:[GPBInt32EnumDictionary class]]);

2745

2746 [dict2 release];

2747 [dict release];

2748 }

2749

2750 - (void)testDictionaryFromDictionary {

2751 const int32_t kKeys[] = { 11, 12, 13, 14 };

2752 const int32_t kValues[] = { 700, 701, 702, 703 };

2753 GPBInt32EnumDictionary *dict =

2754 [[GPBInt32EnumDictionary alloc] initWithValues:kValues

2755 forKeys:kKeys

2756 count:GPBARRAYSIZE(kValues)];

2757 XCTAssertNotNil(dict);

2758

2759 GPBInt32EnumDictionary *dict2 =

2760 [GPBInt32EnumDictionary 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 GPBInt32EnumDictionary *dict = [GPBInt32EnumDictionary dictionary];

2771 XCTAssertNotNil(dict);

2772

2773 XCTAssertEqual(dict.count, 0U);

2774 [dict setValue:700 forKey:11];

2775 XCTAssertEqual(dict.count, 1U);

2776

2777 const int32_t kKeys[] = { 12, 13, 14 };

2778 const int32_t kValues[] = { 701, 702, 703 };

2779 GPBInt32EnumDictionary *dict2 =

2780 [[GPBInt32EnumDictionary 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:11 value:NULL]);

2789 XCTAssertTrue([dict valueForKey:11 value:&value]);

2790 XCTAssertEqual(value, 700);

2791 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2792 XCTAssertTrue([dict valueForKey:12 value:&value]);

2793 XCTAssertEqual(value, 701);

2794 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2795 XCTAssertTrue([dict valueForKey:13 value:&value]);

2796 XCTAssertEqual(value, 702);

2797 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2798 XCTAssertTrue([dict valueForKey:14 value:&value]);

2799 XCTAssertEqual(value, 703);

2800 [dict2 release];

2801 }

2802

2803 - (void)testRemove {

2804 const int32_t kKeys[] = { 11, 12, 13, 14 };

2805 const int32_t kValues[] = { 700, 701, 702, 703 };

2806 GPBInt32EnumDictionary *dict =

2807 [[GPBInt32EnumDictionary alloc] initWithValues:kValues

2808 forKeys:kKeys

2809 count:GPBARRAYSIZE(kValues)];

2810 XCTAssertNotNil(dict);

2811 XCTAssertEqual(dict.count, 4U);

2812

2813 [dict removeValueForKey:12];

2814 XCTAssertEqual(dict.count, 3U);

2815 int32_t value;

2816 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2817 XCTAssertTrue([dict valueForKey:11 value:&value]);

2818 XCTAssertEqual(value, 700);

2819 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2820 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2821 XCTAssertTrue([dict valueForKey:13 value:&value]);

2822 XCTAssertEqual(value, 702);

2823 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2824 XCTAssertTrue([dict valueForKey:14 value:&value]);

2825 XCTAssertEqual(value, 703);

2826

2827 // Remove again does nothing.

2828 [dict removeValueForKey:12];

2829 XCTAssertEqual(dict.count, 3U);

2830 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2831 XCTAssertTrue([dict valueForKey:11 value:&value]);

2832 XCTAssertEqual(value, 700);

2833 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2834 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2835 XCTAssertTrue([dict valueForKey:13 value:&value]);

2836 XCTAssertEqual(value, 702);

2837 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2838 XCTAssertTrue([dict valueForKey:14 value:&value]);

2839 XCTAssertEqual(value, 703);

2840

2841 [dict removeValueForKey:14];

2842 XCTAssertEqual(dict.count, 2U);

2843 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2844 XCTAssertTrue([dict valueForKey:11 value:&value]);

2845 XCTAssertEqual(value, 700);

2846 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2847 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2848 XCTAssertTrue([dict valueForKey:13 value:&value]);

2849 XCTAssertEqual(value, 702);

2850 XCTAssertFalse([dict valueForKey:14 value:NULL]);

2851

2852 [dict removeAll];

2853 XCTAssertEqual(dict.count, 0U);

2854 XCTAssertFalse([dict valueForKey:11 value:NULL]);

2855 XCTAssertFalse([dict valueForKey:12 value:NULL]);

2856 XCTAssertFalse([dict valueForKey:13 value:NULL]);

2857 XCTAssertFalse([dict valueForKey:14 value:NULL]);

2858 [dict release];

2859 }

2860

2861 - (void)testInplaceMutation {

2862 const int32_t kKeys[] = { 11, 12, 13, 14 };

2863 const int32_t kValues[] = { 700, 701, 702, 703 };

2864 GPBInt32EnumDictionary *dict =

2865 [[GPBInt32EnumDictionary 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:11 value:NULL]);

2872 XCTAssertTrue([dict valueForKey:11 value:&value]);

2873 XCTAssertEqual(value, 700);

2874 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2875 XCTAssertTrue([dict valueForKey:12 value:&value]);

2876 XCTAssertEqual(value, 701);

2877 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2878 XCTAssertTrue([dict valueForKey:13 value:&value]);

2879 XCTAssertEqual(value, 702);

2880 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2881 XCTAssertTrue([dict valueForKey:14 value:&value]);

2882 XCTAssertEqual(value, 703);

2883

2884 [dict setValue:703 forKey:11];

2885 XCTAssertEqual(dict.count, 4U);

2886 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2887 XCTAssertTrue([dict valueForKey:11 value:&value]);

2888 XCTAssertEqual(value, 703);

2889 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2890 XCTAssertTrue([dict valueForKey:12 value:&value]);

2891 XCTAssertEqual(value, 701);

2892 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2893 XCTAssertTrue([dict valueForKey:13 value:&value]);

2894 XCTAssertEqual(value, 702);

2895 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2896 XCTAssertTrue([dict valueForKey:14 value:&value]);

2897 XCTAssertEqual(value, 703);

2898

2899 [dict setValue:701 forKey:14];

2900 XCTAssertEqual(dict.count, 4U);

2901 XCTAssertTrue([dict valueForKey:11 value:NULL]);

2902 XCTAssertTrue([dict valueForKey:11 value:&value]);

2903 XCTAssertEqual(value, 703);

2904 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2905 XCTAssertTrue([dict valueForKey:12 value:&value]);

2906 XCTAssertEqual(value, 701);

2907 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2908 XCTAssertTrue([dict valueForKey:13 value:&value]);

2909 XCTAssertEqual(value, 702);

2910 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2911 XCTAssertTrue([dict valueForKey:14 value:&value]);

2912 XCTAssertEqual(value, 701);

2913

2914 const int32_t kKeys2[] = { 12, 13 };

2915 const int32_t kValues2[] = { 702, 700 };

2916 GPBInt32EnumDictionary *dict2 =

2917 [[GPBInt32EnumDictionary 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:11 value:NULL]);

2924 XCTAssertTrue([dict valueForKey:11 value:&value]);

2925 XCTAssertEqual(value, 703);

2926 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2927 XCTAssertTrue([dict valueForKey:12 value:&value]);

2928 XCTAssertEqual(value, 702);

2929 XCTAssertTrue([dict valueForKey:13 value:NULL]);

2930 XCTAssertTrue([dict valueForKey:13 value:&value]);

2931 XCTAssertEqual(value, 700);

2932 XCTAssertTrue([dict valueForKey:14 value:NULL]);

2933 XCTAssertTrue([dict valueForKey:14 value:&value]);

2934 XCTAssertEqual(value, 701);

2935

2936 [dict2 release];

2937 [dict release];

2938 }

2939

2940 @end

2941

2942 #pragma mark - Int32 -> Enum (Unknown Enums)

2943

2944 @interface GPBInt32EnumDictionaryUnknownEnumTests : XCTestCase

2945 @end

2946

2947 @implementation GPBInt32EnumDictionaryUnknownEnumTests

2948

2949 - (void)testRawBasics {

2950 const int32_t kKeys[] = { 11, 12, 13 };

2951 const int32_t kValues[] = { 700, 801, 702 };

2952 GPBInt32EnumDictionary *dict =

2953 [[GPBInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsV alidValue

2954 rawValues:kValues

2955 forKeys:kKeys

2956 count:GPBARRAYSIZE(kV alues)];

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:11 rawValue:NULL]);

2962 XCTAssertTrue([dict valueForKey:11 rawValue:&value]);

2963 XCTAssertEqual(value, 700);

2964 XCTAssertTrue([dict valueForKey:12 value:NULL]);

2965 XCTAssertTrue([dict valueForKey:12 value:&value]);

2966 XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue);

2967 XCTAssertTrue([dict valueForKey:12 rawValue:NULL]);

2968 XCTAssertTrue([dict valueForKey:12 rawValue:&value]);

2969 XCTAssertEqual(value, 801);

2970 XCTAssertTrue([dict valueForKey:13 rawValue:NULL]);

2971 XCTAssertTrue([dict valueForKey:13 rawValue:&value]);

2972 XCTAssertEqual(value, 702);

2973 XCTAssertFalse([dict valueForKey:14 rawValue:NULL]);

2974

2975 __block NSUInteger idx = 0;

2976 int32_t seenKeys = malloc(3 sizeof(int32_t));

2977 int32_t seenValues = malloc(3 sizeof(int32_t));

2978 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *s top) {

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:^(int32_t aKey, int32_t aValue, BOOL *stop) {

3001 XCTAssertLessThan(idx, 3U);

3002 seenKeys[idx] = aKey;

3003 seenValues[idx] = aValue;

3004 XCTAssertNotEqual(stop, NULL);

3005 ++idx;

3006 }];

3007 for (int i = 0; i < 3; ++i) {

3008 BOOL foundKey = NO;

3009 for (int j = 0; (j < 3) && !foundKey; ++j) {

3010 if (kKeys[i] == seenKeys[j]) {

3011 foundKey = YES;

3012 XCTAssertEqual(kValues[i], seenValues[j], @"i = %d, j = %d", i, j);

3013 }

3014 }

3015 XCTAssertTrue(foundKey, @"i = %d", i);

3016 }

3017 free(seenKeys);

3018 free(seenValues);

3019

3020 // Stopping the enumeration.

3021 idx = 0;

3022 [dict enumerateKeysAndRawValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {

3023 #pragma unused(aKey, aValue)

3024 if (idx == 1) *stop = YES;

3025 XCTAssertNotEqual(idx, 2U);

3026 ++idx;

3027 }];

3028 [dict release];

3029 }

3030

3031 - (void)testEqualityWithUnknowns {

3032 const int32_t kKeys1[] = { 11, 12, 13, 14 };

3033 const int32_t kKeys2[] = { 12, 11, 14 };

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 GPBInt32EnumDictionary *dict1 =

3038 [[GPBInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsV alidValue

3039 rawValues:kValues1

3040 forKeys:kKeys1

3041 count:GPBARRAYSIZE(kV alues1)];

3042 XCTAssertNotNil(dict1);

3043 GPBInt32EnumDictionary *dict1prime =

3044 [[GPBInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsV alidValue

3045 rawValues:kValues1

3046 forKeys:kKeys1

3047 count:GPBARRAYSIZE(kV alues1)];

3048 XCTAssertNotNil(dict1prime);

3049 GPBInt32EnumDictionary *dict2 =

3050 [[GPBInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsV alidValue

3051 rawValues:kValues2

3052 forKeys:kKeys1

3053 count:GPBARRAYSIZE(kV alues2)];

3054 XCTAssertNotNil(dict2);

3055 GPBInt32EnumDictionary *dict3 =

3056 [[GPBInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsV alidValue

3057 rawValues:kValues1

3058 forKeys:kKeys2

3059 count:GPBARRAYSIZE(kV alues1)];

3060 XCTAssertNotNil(dict3);

3061 GPBInt32EnumDictionary *dict4 =

3062 [[GPBInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsV alidValue

3063 rawValues:kValues3

3064 forKeys:kKeys1

3065 count:GPBARRAYSIZE(kV alues3)];

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 save keys, different values; not equal.

3075 XCTAssertNotEqualObjects(dict1, dict2);

3076

3077 // 3 is different keys, samae 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 int32_t kKeys[] = { 11, 12, 13, 14 };

3092 const int32_t kValues[] = { 700, 801, 702, 803 }; // Unknown

3093 GPBInt32EnumDictionary *dict =

3094 [[GPBInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsV alidValue

3095 rawValues:kValues

3096 forKeys:kKeys

3097 count:GPBARRAYSIZE(kV alues)];

3098 XCTAssertNotNil(dict);

3099

3100 GPBInt32EnumDictionary *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 int32_t kKeys[] = { 11, 12, 13, 14 };

3114 const int32_t kValues[] = { 700, 801, 702, 803 }; // Unknowns

3115 GPBInt32EnumDictionary *dict =

3116 [[GPBInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsV alidValue

3117 rawValues:kValues

3118 forKeys:kKeys

3119 count:GPBARRAYSIZE(kV alues)];

3120 XCTAssertNotNil(dict);

3121

3122 GPBInt32EnumDictionary *dict2 =

3123 [GPBInt32EnumDictionary 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 GPBInt32EnumDictionary *dict =

3135 [GPBInt32EnumDictionary dictionaryWithValidationFunction:TestingEnum_IsValid Value];

3136 XCTAssertNotNil(dict);

3137

3138 XCTAssertEqual(dict.count, 0U);

3139 XCTAssertThrowsSpecificNamed([dict setValue:801 forKey:12], // Unknown

3140 NSException, NSInvalidArgumentException);

3141 XCTAssertEqual(dict.count, 0U);

3142 [dict setRawValue:801 forKey:12]; // Unknown

3143 XCTAssertEqual(dict.count, 1U);

3144

3145 const int32_t kKeys[] = { 11, 13, 14 };

3146 const int32_t kValues[] = { 700, 702, 803 }; // Unknown

3147 GPBInt32EnumDictionary *dict2 =

3148 [[GPBInt32EnumDictionary 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:11 value:NULL]);

3157 XCTAssertTrue([dict valueForKey:11 value:&value]);

3158 XCTAssertEqual(value, 700);

3159 XCTAssertTrue([dict valueForKey:12 value:NULL]);

3160 XCTAssertTrue([dict valueForKey:12 value:&value]);

3161 XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue);

3162 XCTAssertTrue([dict valueForKey:12 rawValue:NULL]);

3163 XCTAssertTrue([dict valueForKey:12 rawValue:&value]);

3164 XCTAssertEqual(value, 801);

3165 XCTAssertTrue([dict valueForKey:13 value:NULL]);

3166 XCTAssertTrue([dict valueForKey:13 value:&value]);

3167 XCTAssertEqual(value, 702);

3168 XCTAssertTrue([dict valueForKey:14 value:NULL]);

3169 XCTAssertTrue([dict valueForKey:14 value:&value]);

3170 XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue);

3171 XCTAssertTrue([dict valueForKey:14 rawValue:NULL]);

3172 XCTAssertTrue([dict valueForKey:14 rawValue:&value]);

3173 XCTAssertEqual(value, 803);

3174 [dict2 release];

3175 }

3176

3177 - (void)testUnknownRemove {

3178 const int32_t kKeys[] = { 11, 12, 13, 14 };

3179 const int32_t kValues[] = { 700, 801, 702, 803 }; // Unknowns

3180 GPBInt32EnumDictionary *dict =

3181 [[GPBInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsV alidValue

3182 rawValues:kValues

3183 forKeys:kKeys

3184 count:GPBARRAYSIZE(kV alues)];

3185 XCTAssertNotNil(dict);

3186 XCTAssertEqual(dict.count, 4U);

3187

3188 [dict removeValueForKey:12];

3189 XCTAssertEqual(dict.count, 3U);

3190 int32_t value;

3191 XCTAssertTrue([dict valueForKey:11 value:NULL]);

3192 XCTAssertTrue([dict valueForKey:11 value:&value]);

3193 XCTAssertEqual(value, 700);

3194 XCTAssertFalse([dict valueForKey:12 value:NULL]);

3195 XCTAssertTrue([dict valueForKey:13 value:NULL]);

3196 XCTAssertTrue([dict valueForKey:13 value:&value]);

3197 XCTAssertEqual(value, 702);

3198 XCTAssertTrue([dict valueForKey:14 rawValue:NULL]);

3199 XCTAssertTrue([dict valueForKey:14 rawValue:&value]);

3200 XCTAssertEqual(value, 803);

3201

3202 // Remove again does nothing.

3203 [dict removeValueForKey:12];

3204 XCTAssertEqual(dict.count, 3U);

3205 XCTAssertTrue([dict valueForKey:11 value:NULL]);

3206 XCTAssertTrue([dict valueForKey:11 value:&value]);

3207 XCTAssertEqual(value, 700);

3208 XCTAssertFalse([dict valueForKey:12 value:NULL]);

3209 XCTAssertTrue([dict valueForKey:13 value:NULL]);

3210 XCTAssertTrue([dict valueForKey:13 value:&value]);

3211 XCTAssertEqual(value, 702);

3212 XCTAssertTrue([dict valueForKey:14 rawValue:NULL]);

3213 XCTAssertTrue([dict valueForKey:14 rawValue:&value]);

3214 XCTAssertEqual(value, 803);

3215

3216 [dict removeValueForKey:14];

3217 XCTAssertEqual(dict.count, 2U);

3218 XCTAssertTrue([dict valueForKey:11 value:NULL]);

3219 XCTAssertTrue([dict valueForKey:11 value:&value]);

3220 XCTAssertEqual(value, 700);

3221 XCTAssertFalse([dict valueForKey:12 value:NULL]);

3222 XCTAssertTrue([dict valueForKey:13 value:NULL]);

3223 XCTAssertTrue([dict valueForKey:13 value:&value]);

3224 XCTAssertEqual(value, 702);

3225 XCTAssertFalse([dict valueForKey:14 value:NULL]);

3226

3227 [dict removeAll];

3228 XCTAssertEqual(dict.count, 0U);

3229 XCTAssertFalse([dict valueForKey:11 value:NULL]);

3230 XCTAssertFalse([dict valueForKey:12 value:NULL]);

3231 XCTAssertFalse([dict valueForKey:13 value:NULL]);

3232 XCTAssertFalse([dict valueForKey:14 value:NULL]);

3233 [dict release];

3234 }

3235

3236 - (void)testInplaceMutationUnknowns {

3237 const int32_t kKeys[] = { 11, 12, 13, 14 };

3238 const int32_t kValues[] = { 700, 801, 702, 803 }; // Unknowns

3239 GPBInt32EnumDictionary *dict =

3240 [[GPBInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsV alidValue

3241 rawValues:kValues

3242 forKeys:kKeys

3243 count:GPBARRAYSIZE(kV alues)];

3244 XCTAssertNotNil(dict);

3245 XCTAssertEqual(dict.count, 4U);

3246 int32_t value;

3247 XCTAssertTrue([dict valueForKey:11 value:NULL]);

3248 XCTAssertTrue([dict valueForKey:11 value:&value]);

3249 XCTAssertEqual(value, 700);

3250 XCTAssertTrue([dict valueForKey:12 rawValue:NULL]);

3251 XCTAssertTrue([dict valueForKey:12 rawValue:&value]);

3252 XCTAssertEqual(value, 801);

3253 XCTAssertTrue([dict valueForKey:13 value:NULL]);

3254 XCTAssertTrue([dict valueForKey:13 value:&value]);

3255 XCTAssertEqual(value, 702);

3256 XCTAssertTrue([dict valueForKey:14 rawValue:NULL]);

3257 XCTAssertTrue([dict valueForKey:14 rawValue:&value]);

3258 XCTAssertEqual(value, 803);

3259

3260 XCTAssertThrowsSpecificNamed([dict setValue:803 forKey:11], // Unknown

3261 NSException, NSInvalidArgumentException);

3262 XCTAssertEqual(dict.count, 4U);

3263 XCTAssertTrue([dict valueForKey:11 value:NULL]);

3264 XCTAssertTrue([dict valueForKey:11 value:&value]);

3265 XCTAssertEqual(value, 700);

3266 XCTAssertTrue([dict valueForKey:12 rawValue:NULL]);

3267 XCTAssertTrue([dict valueForKey:12 rawValue:&value]);

3268 XCTAssertEqual(value, 801);

3269 XCTAssertTrue([dict valueForKey:13 value:NULL]);

3270 XCTAssertTrue([dict valueForKey:13 value:&value]);

3271 XCTAssertEqual(value, 702);

3272 XCTAssertTrue([dict valueForKey:14 rawValue:NULL]);

3273 XCTAssertTrue([dict valueForKey:14 rawValue:&value]);

3274 XCTAssertEqual(value, 803);

3275

3276 [dict setRawValue:803 forKey:11]; // Unknown

3277 XCTAssertEqual(dict.count, 4U);

3278 XCTAssertTrue([dict valueForKey:11 rawValue:NULL]);

3279 XCTAssertTrue([dict valueForKey:11 rawValue:&value]);

3280 XCTAssertEqual(value, 803);

3281 XCTAssertTrue([dict valueForKey:12 rawValue:NULL]);

3282 XCTAssertTrue([dict valueForKey:12 rawValue:&value]);

3283 XCTAssertEqual(value, 801);

3284 XCTAssertTrue([dict valueForKey:13 value:NULL]);

3285 XCTAssertTrue([dict valueForKey:13 value:&value]);

3286 XCTAssertEqual(value, 702);

3287 XCTAssertTrue([dict valueForKey:14 rawValue:NULL]);

3288 XCTAssertTrue([dict valueForKey:14 rawValue:&value]);

3289 XCTAssertEqual(value, 803);

3290

3291 [dict setRawValue:700 forKey:14];

3292 XCTAssertEqual(dict.count, 4U);

3293 XCTAssertTrue([dict valueForKey:11 rawValue:NULL]);

3294 XCTAssertTrue([dict valueForKey:11 rawValue:&value]);

3295 XCTAssertEqual(value, 803);

3296 XCTAssertTrue([dict valueForKey:12 rawValue:NULL]);

3297 XCTAssertTrue([dict valueForKey:12 rawValue:&value]);

3298 XCTAssertEqual(value, 801);

3299 XCTAssertTrue([dict valueForKey:13 value:NULL]);

3300 XCTAssertTrue([dict valueForKey:13 value:&value]);

3301 XCTAssertEqual(value, 702);

3302 XCTAssertTrue([dict valueForKey:14 value:NULL]);

3303 XCTAssertTrue([dict valueForKey:14 value:&value]);

3304 XCTAssertEqual(value, 700);

3305

3306 const int32_t kKeys2[] = { 12, 13 };

3307 const int32_t kValues2[] = { 702, 801 }; // Unknown

3308 GPBInt32EnumDictionary *dict2 =

3309 [[GPBInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsV alidValue

3310 rawValues:kValues2

3311 forKeys:kKeys2

3312 count:GPBARRAYSIZE(kV alues2)];

3313 XCTAssertNotNil(dict2);

3314 [dict addRawEntriesFromDictionary:dict2];

3315 XCTAssertEqual(dict.count, 4U);

3316 XCTAssertTrue([dict valueForKey:11 rawValue:NULL]);

3317 XCTAssertTrue([dict valueForKey:11 rawValue:&value]);

3318 XCTAssertEqual(value, 803);

3319 XCTAssertTrue([dict valueForKey:12 value:NULL]);

3320 XCTAssertTrue([dict valueForKey:12 value:&value]);

3321 XCTAssertEqual(value, 702);

3322 XCTAssertTrue([dict valueForKey:13 rawValue:NULL]);

3323 XCTAssertTrue([dict valueForKey:13 rawValue:&value]);

3324 XCTAssertEqual(value, 801);

3325 XCTAssertTrue([dict valueForKey:14 value:NULL]);

3326 XCTAssertTrue([dict valueForKey:14 value:&value]);

3327 XCTAssertEqual(value, 700);

3328

3329 [dict2 release];

3330 [dict release];

3331 }

3332

3333 - (void)testCopyUnknowns {

3334 const int32_t kKeys[] = { 11, 12, 13, 14 };

3335 const int32_t kValues[] = { 700, 801, 702, 803 };

3336 GPBInt32EnumDictionary *dict =

3337 [[GPBInt32EnumDictionary alloc] initWithValidationFunction:TestingEnum_IsV alidValue

3338 rawValues:kValues

3339 forKeys:kKeys

3340 count:GPBARRAYSIZE(kV alues)];

3341 XCTAssertNotNil(dict);

3342

3343 GPBInt32EnumDictionary *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:[GPBInt32EnumDictionary class]]);

3351

3352 [dict2 release];

3353 [dict release];

3354 }

3355

3356 @end

3357

3358 #pragma mark - Int32 -> Object

3359

3360 @interface GPBInt32ObjectDictionaryTests : XCTestCase

3361 @end

3362

3363 @implementation GPBInt32ObjectDictionaryTests

3364

3365 - (void)testEmpty {

3366 GPBInt32ObjectDictionary *dict = [[GPBInt32ObjectDictionary alloc] init];

3367 XCTAssertNotNil(dict);

3368 XCTAssertEqual(dict.count, 0U);

3369 XCTAssertNil([dict valueForKey:11]);

3370 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, id aValue, BOOL *stop) {

3371 #pragma unused(aKey, aValue, stop)

3372 XCTFail(@"Shouldn't get here!");

3373 }];

3374 [dict release];

3375 }

3376

3377 - (void)testOne {

3378 GPBInt32ObjectDictionary *dict = [GPBInt32ObjectDictionary dictionaryWithValue :@"abc" forKey:11];

3379 XCTAssertNotNil(dict);

3380 XCTAssertEqual(dict.count, 1U);

3381 XCTAssertEqualObjects([dict valueForKey:11], @"abc");

3382 XCTAssertNil([dict valueForKey:12]);

3383 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, id aValue, BOOL *stop) {

3384 XCTAssertEqual(aKey, 11);

3385 XCTAssertEqualObjects(aValue, @"abc");

3386 XCTAssertNotEqual(stop, NULL);

3387 }];

3388 }

3389

3390 - (void)testBasics {

3391 const int32_t kKeys[] = { 11, 12, 13 };

3392 const id kValues[] = { @"abc", @"def", @"ghi" };

3393 GPBInt32ObjectDictionary *dict =

3394 [[GPBInt32ObjectDictionary alloc] initWithValues:kValues

3395 forKeys:kKeys

3396 count:GPBARRAYSIZE(kValues)];

3397 XCTAssertNotNil(dict);

3398 XCTAssertEqual(dict.count, 3U);

3399 XCTAssertEqualObjects([dict valueForKey:11], @"abc");

3400 XCTAssertEqualObjects([dict valueForKey:12], @"def");

3401 XCTAssertEqualObjects([dict valueForKey:13], @"ghi");

3402 XCTAssertNil([dict valueForKey:14]);

3403

3404 __block NSUInteger idx = 0;

3405 int32_t seenKeys = malloc(3 sizeof(int32_t));

3406 id seenValues = malloc(3 sizeof(id));

3407 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, id aValue, BOOL *stop) {

3408 XCTAssertLessThan(idx, 3U);

3409 seenKeys[idx] = aKey;

3410 seenValues[idx] = aValue;

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(kValues[i], seenValues[j], @"i = %d, j = %d", i, j );

3420 }

3421 }

3422 XCTAssertTrue(foundKey, @"i = %d", i);

3423 }

3424 free(seenKeys);

3425 free(seenValues);

3426

3427 // Stopping the enumeration.

3428 idx = 0;

3429 [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, id aValue, BOOL *stop) {

3430 #pragma unused(aKey, aValue)

3431 if (idx == 1) *stop = YES;

3432 XCTAssertNotEqual(idx, 2U);

3433 ++idx;

3434 }];

3435 [dict release];

3436 }

3437

3438 - (void)testEquality {

3439 const int32_t kKeys1[] = { 11, 12, 13, 14 };

3440 const int32_t kKeys2[] = { 12, 11, 14 };

3441 const id kValues1[] = { @"abc", @"def", @"ghi" };

3442 const id kValues2[] = { @"abc", @"jkl", @"ghi" };

3443 const id kValues3[] = { @"abc", @"def", @"ghi", @"jkl" };

3444 GPBInt32ObjectDictionary *dict1 =

3445 [[GPBInt32ObjectDictionary alloc] initWithValues:kValues1

3446 forKeys:kKeys1

3447 count:GPBARRAYSIZE(kValues1)];

3448 XCTAssertNotNil(dict1);

3449 GPBInt32ObjectDictionary *dict1prime =

3450 [[GPBInt32ObjectDictionary alloc] initWithValues:kValues1

3451 forKeys:kKeys1

3452 count:GPBARRAYSIZE(kValues1)];

3453 XCTAssertNotNil(dict1prime);

3454 GPBInt32ObjectDictionary *dict2 =

3455 [[GPBInt32ObjectDictionary alloc] initWithValues:kValues2

3456 forKeys:kKeys1

3457 count:GPBARRAYSIZE(kValues2)];

3458 XCTAssertNotNil(dict2);

3459 GPBInt32ObjectDictionary *dict3 =

3460 [[GPBInt32ObjectDictionary alloc] initWithValues:kValues1

3461 forKeys:kKeys2

3462 count:GPBARRAYSIZE(kValues1)];

3463 XCTAssertNotNil(dict3);

3464 GPBInt32ObjectDictionary *dict4 =

3465 [[GPBInt32ObjectDictionary alloc] initWithValues:kValues3

3466 forKeys:kKeys1

3467 count:GPBARRAYSIZE(kValues3)];

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 save keys, different values; not equal.

3477 XCTAssertNotEqualObjects(dict1, dict2);

3478

3479 // 3 is different keys, samae values; 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 int32_t kKeys[] = { 11, 12, 13, 14 };

3494 const id kValues[] = { @"abc", @"def", @"ghi", @"jkl" };

3495 GPBInt32ObjectDictionary *dict =

3496 [[GPBInt32ObjectDictionary alloc] initWithValues:kValues

3497 forKeys:kKeys

3498 count:GPBARRAYSIZE(kValues)];

3499 XCTAssertNotNil(dict);

3500

3501 GPBInt32ObjectDictionary *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:[GPBInt32ObjectDictionary class]]);

3508

3509 [dict2 release];

3510 [dict release];

3511 }

3512

3513 - (void)testDictionaryFromDictionary {

3514 const int32_t kKeys[] = { 11, 12, 13, 14 };

3515 const id kValues[] = { @"abc", @"def", @"ghi", @"jkl" };

3516 GPBInt32ObjectDictionary *dict =

3517 [[GPBInt32ObjectDictionary alloc] initWithValues:kValues

3518 forKeys:kKeys

3519 count:GPBARRAYSIZE(kValues)];

3520 XCTAssertNotNil(dict);

3521

3522 GPBInt32ObjectDictionary *dict2 =

3523 [GPBInt32ObjectDictionary 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 GPBInt32ObjectDictionary *dict = [GPBInt32ObjectDictionary dictionary];

3534 XCTAssertNotNil(dict);

3535

3536 XCTAssertEqual(dict.count, 0U);

3537 [dict setValue:@"abc" forKey:11];

3538 XCTAssertEqual(dict.count, 1U);

3539

3540 const int32_t kKeys[] = { 12, 13, 14 };

3541 const id kValues[] = { @"def", @"ghi", @"jkl" };

3542 GPBInt32ObjectDictionary *dict2 =

3543 [[GPBInt32ObjectDictionary alloc] initWithValues:kValues

3544 forKeys:kKeys

3545 count:GPBARRAYSIZE(kValues)];

3546 XCTAssertNotNil(dict2);

3547 [dict addEntriesFromDictionary:dict2];

3548 XCTAssertEqual(dict.count, 4U);

3549

3550 XCTAssertEqualObjects([dict valueForKey:11], @"abc");

3551 XCTAssertEqualObjects([dict valueForKey:12], @"def");

3552 XCTAssertEqualObjects([dict valueForKey:13], @"ghi");

3553 XCTAssertEqualObjects([dict valueForKey:14], @"jkl");

3554 [dict2 release];

3555 }

3556

3557 - (void)testRemove {

3558 const int32_t kKeys[] = { 11, 12, 13, 14 };

3559 const id kValues[] = { @"abc", @"def", @"ghi", @"jkl" };

3560 GPBInt32ObjectDictionary *dict =

3561 [[GPBInt32ObjectDictionary alloc] initWithValues:kValues

3562 forKeys:kKeys

3563 count:GPBARRAYSIZE(kValues)];

3564 XCTAssertNotNil(dict);

3565 XCTAssertEqual(dict.count, 4U);

3566

3567 [dict removeValueForKey:12];

3568 XCTAssertEqual(dict.count, 3U);

3569 XCTAssertEqualObjects([dict valueForKey:11], @"abc");

3570 XCTAssertNil([dict valueForKey:12]);

3571 XCTAssertEqualObjects([dict valueForKey:13], @"ghi");

3572 XCTAssertEqualObjects([dict valueForKey:14], @"jkl");

3573

3574 // Remove again does nothing.

3575 [dict removeValueForKey:12];

3576 XCTAssertEqual(dict.count, 3U);

3577 XCTAssertEqualObjects([dict valueForKey:11], @"abc");

3578 XCTAssertNil([dict valueForKey:12]);

3579 XCTAssertEqualObjects([dict valueForKey:13], @"ghi");

3580 XCTAssertEqualObjects([dict valueForKey:14], @"jkl");

3581

3582 [dict removeValueForKey:14];

3583 XCTAssertEqual(dict.count, 2U);

3584 XCTAssertEqualObjects([dict valueForKey:11], @"abc");

3585 XCTAssertNil([dict valueForKey:12]);

3586 XCTAssertEqualObjects([dict valueForKey:13], @"ghi");

3587 XCTAssertNil([dict valueForKey:14]);

3588

3589 [dict removeAll];

3590 XCTAssertEqual(dict.count, 0U);

3591 XCTAssertNil([dict valueForKey:11]);

3592 XCTAssertNil([dict valueForKey:12]);

3593 XCTAssertNil([dict valueForKey:13]);

3594 XCTAssertNil([dict valueForKey:14]);

3595 [dict release];

3596 }

3597

3598 - (void)testInplaceMutation {

3599 const int32_t kKeys[] = { 11, 12, 13, 14 };

3600 const id kValues[] = { @"abc", @"def", @"ghi", @"jkl" };

3601 GPBInt32ObjectDictionary *dict =

3602 [[GPBInt32ObjectDictionary alloc] initWithValues:kValues

3603 forKeys:kKeys

3604 count:GPBARRAYSIZE(kValues)];

3605 XCTAssertNotNil(dict);

3606 XCTAssertEqual(dict.count, 4U);

3607 XCTAssertEqualObjects([dict valueForKey:11], @"abc");

3608 XCTAssertEqualObjects([dict valueForKey:12], @"def");

3609 XCTAssertEqualObjects([dict valueForKey:13], @"ghi");

3610 XCTAssertEqualObjects([dict valueForKey:14], @"jkl");

3611

3612 [dict setValue:@"jkl" forKey:11];

3613 XCTAssertEqual(dict.count, 4U);

3614 XCTAssertEqualObjects([dict valueForKey:11], @"jkl");

3615 XCTAssertEqualObjects([dict valueForKey:12], @"def");

3616 XCTAssertEqualObjects([dict valueForKey:13], @"ghi");

3617 XCTAssertEqualObjects([dict valueForKey:14], @"jkl");

3618

3619 [dict setValue:@"def" forKey:14];

3620 XCTAssertEqual(dict.count, 4U);

3621 XCTAssertEqualObjects([dict valueForKey:11], @"jkl");

3622 XCTAssertEqualObjects([dict valueForKey:12], @"def");

3623 XCTAssertEqualObjects([dict valueForKey:13], @"ghi");

3624 XCTAssertEqualObjects([dict valueForKey:14], @"def");

3625

3626 const int32_t kKeys2[] = { 12, 13 };

3627 const id kValues2[] = { @"ghi", @"abc" };

3628 GPBInt32ObjectDictionary *dict2 =

3629 [[GPBInt32ObjectDictionary alloc] initWithValues:kValues2

3630 forKeys:kKeys2

3631 count:GPBARRAYSIZE(kValues2)];

3632 XCTAssertNotNil(dict2);

3633 [dict addEntriesFromDictionary:dict2];

3634 XCTAssertEqual(dict.count, 4U);

3635 XCTAssertEqualObjects([dict valueForKey:11], @"jkl");

3636 XCTAssertEqualObjects([dict valueForKey:12], @"ghi");

3637 XCTAssertEqualObjects([dict valueForKey:13], @"abc");

3638 XCTAssertEqualObjects([dict valueForKey:14], @"def");

3639

3640 [dict2 release];

3641 [dict release];

3642 }

3643

3644 @end

3645

3646 //%PDDM-EXPAND-END TEST_FOR_POD_KEY(Int32, int32_t, 11, 12, 13, 14)

3647

OLD	NEW