| Index: third_party/protobuf/objectivec/Tests/GPBDictionaryTests+Int32.m
|
| diff --git a/third_party/protobuf/objectivec/Tests/GPBDictionaryTests+Int32.m b/third_party/protobuf/objectivec/Tests/GPBDictionaryTests+Int32.m
|
| index c539bdc2edf87dec9a89ef454326e7cda21c9697..54dd2ed7c2382e5d15c41551cae78df18494f0c1 100644
|
| --- a/third_party/protobuf/objectivec/Tests/GPBDictionaryTests+Int32.m
|
| +++ b/third_party/protobuf/objectivec/Tests/GPBDictionaryTests+Int32.m
|
| @@ -45,10 +45,10 @@
|
|
|
| // To let the testing macros work, add some extra methods to simplify things.
|
| @interface GPBInt32EnumDictionary (TestingTweak)
|
| -+ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(int32_t)key;
|
| -- (instancetype)initWithEnums:(const int32_t [])values
|
| - forKeys:(const int32_t [])keys
|
| - count:(NSUInteger)count;
|
| ++ (instancetype)dictionaryWithValue:(int32_t)value forKey:(int32_t)key;
|
| +- (instancetype)initWithValues:(const int32_t [])values
|
| + forKeys:(const int32_t [])keys
|
| + count:(NSUInteger)count;
|
| @end
|
|
|
| static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| @@ -64,7 +64,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| }
|
|
|
| @implementation GPBInt32EnumDictionary (TestingTweak)
|
| -+ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(int32_t)key {
|
| ++ (instancetype)dictionaryWithValue:(int32_t)value forKey:(int32_t)key {
|
| // Cast is needed to compiler knows what class we are invoking initWithValues: on to get the
|
| // type correct.
|
| return [[(GPBInt32EnumDictionary*)[self alloc] initWithValidationFunction:TestingEnum_IsValidValue
|
| @@ -72,9 +72,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| forKeys:&key
|
| count:1] autorelease];
|
| }
|
| -- (instancetype)initWithEnums:(const int32_t [])values
|
| - forKeys:(const int32_t [])keys
|
| - count:(NSUInteger)count {
|
| +- (instancetype)initWithValues:(const int32_t [])values
|
| + forKeys:(const int32_t [])keys
|
| + count:(NSUInteger)count {
|
| return [self initWithValidationFunction:TestingEnum_IsValidValue
|
| rawValues:values
|
| forKeys:keys
|
| @@ -94,8 +94,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| GPBInt32UInt32Dictionary *dict = [[GPBInt32UInt32Dictionary alloc] init];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getUInt32:NULL forKey:11]);
|
| - [dict enumerateKeysAndUInt32sUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue, stop)
|
| XCTFail(@"Shouldn't get here!");
|
| }];
|
| @@ -103,15 +103,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| }
|
|
|
| - (void)testOne {
|
| - GPBInt32UInt32Dictionary *dict = [GPBInt32UInt32Dictionary dictionaryWithUInt32:100U forKey:11];
|
| + GPBInt32UInt32Dictionary *dict = [GPBInt32UInt32Dictionary dictionaryWithValue:100U forKey:11];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 1U);
|
| uint32_t value;
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 100U);
|
| - XCTAssertFalse([dict getUInt32:NULL forKey:12]);
|
| - [dict enumerateKeysAndUInt32sUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) {
|
| XCTAssertEqual(aKey, 11);
|
| XCTAssertEqual(aValue, 100U);
|
| XCTAssertNotEqual(stop, NULL);
|
| @@ -122,27 +122,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13 };
|
| const uint32_t kValues[] = { 100U, 101U, 102U };
|
| GPBInt32UInt32Dictionary *dict =
|
| - [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 3U);
|
| uint32_t value;
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 100U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 101U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 102U);
|
| - XCTAssertFalse([dict getUInt32:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| __block NSUInteger idx = 0;
|
| int32_t *seenKeys = malloc(3 * sizeof(int32_t));
|
| uint32_t *seenValues = malloc(3 * sizeof(uint32_t));
|
| - [dict enumerateKeysAndUInt32sUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) {
|
| XCTAssertLessThan(idx, 3U);
|
| seenKeys[idx] = aKey;
|
| seenValues[idx] = aValue;
|
| @@ -164,7 +164,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
|
|
| // Stopping the enumeration.
|
| idx = 0;
|
| - [dict enumerateKeysAndUInt32sUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue)
|
| if (idx == 1) *stop = YES;
|
| XCTAssertNotEqual(idx, 2U);
|
| @@ -180,29 +180,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const uint32_t kValues2[] = { 100U, 103U, 102U };
|
| const uint32_t kValues3[] = { 100U, 101U, 102U, 103U };
|
| GPBInt32UInt32Dictionary *dict1 =
|
| - [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues1
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1);
|
| GPBInt32UInt32Dictionary *dict1prime =
|
| - [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues1
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1prime);
|
| GPBInt32UInt32Dictionary *dict2 =
|
| - [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues2
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues2)];
|
| + [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues2
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| GPBInt32UInt32Dictionary *dict3 =
|
| - [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues1
|
| - forKeys:kKeys2
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys2
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict3);
|
| GPBInt32UInt32Dictionary *dict4 =
|
| - [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues3
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues3)];
|
| + [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues3
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues3)];
|
| XCTAssertNotNil(dict4);
|
|
|
| // 1/1Prime should be different objects, but equal.
|
| @@ -231,9 +231,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const uint32_t kValues[] = { 100U, 101U, 102U, 103U };
|
| GPBInt32UInt32Dictionary *dict =
|
| - [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
|
|
| GPBInt32UInt32Dictionary *dict2 = [dict copy];
|
| @@ -252,9 +252,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const uint32_t kValues[] = { 100U, 101U, 102U, 103U };
|
| GPBInt32UInt32Dictionary *dict =
|
| - [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
|
|
| GPBInt32UInt32Dictionary *dict2 =
|
| @@ -272,31 +272,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertNotNil(dict);
|
|
|
| XCTAssertEqual(dict.count, 0U);
|
| - [dict setUInt32:100U forKey:11];
|
| + [dict setValue:100U forKey:11];
|
| XCTAssertEqual(dict.count, 1U);
|
|
|
| const int32_t kKeys[] = { 12, 13, 14 };
|
| const uint32_t kValues[] = { 101U, 102U, 103U };
|
| GPBInt32UInt32Dictionary *dict2 =
|
| - [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict2);
|
| [dict addEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| uint32_t value;
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 100U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 101U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 102U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 103U);
|
| [dict2 release];
|
| }
|
| @@ -305,57 +305,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const uint32_t kValues[] = { 100U, 101U, 102U, 103U };
|
| GPBInt32UInt32Dictionary *dict =
|
| - [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| - [dict removeUInt32ForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| uint32_t value;
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 100U);
|
| - XCTAssertFalse([dict getUInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 102U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 103U);
|
|
|
| // Remove again does nothing.
|
| - [dict removeUInt32ForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 100U);
|
| - XCTAssertFalse([dict getUInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 102U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 103U);
|
|
|
| - [dict removeUInt32ForKey:14];
|
| + [dict removeValueForKey:14];
|
| XCTAssertEqual(dict.count, 2U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 100U);
|
| - XCTAssertFalse([dict getUInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 102U);
|
| - XCTAssertFalse([dict getUInt32:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| [dict removeAll];
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getUInt32:NULL forKey:11]);
|
| - XCTAssertFalse([dict getUInt32:NULL forKey:12]);
|
| - XCTAssertFalse([dict getUInt32:NULL forKey:13]);
|
| - XCTAssertFalse([dict getUInt32:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:13 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
| [dict release];
|
| }
|
|
|
| @@ -363,75 +363,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const uint32_t kValues[] = { 100U, 101U, 102U, 103U };
|
| GPBInt32UInt32Dictionary *dict =
|
| - [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
| uint32_t value;
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 100U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 101U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 102U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 103U);
|
|
|
| - [dict setUInt32:103U forKey:11];
|
| + [dict setValue:103U forKey:11];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 103U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 101U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 102U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 103U);
|
|
|
| - [dict setUInt32:101U forKey:14];
|
| + [dict setValue:101U forKey:14];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 103U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 101U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 102U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 101U);
|
|
|
| const int32_t kKeys2[] = { 12, 13 };
|
| const uint32_t kValues2[] = { 102U, 100U };
|
| GPBInt32UInt32Dictionary *dict2 =
|
| - [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues2
|
| - forKeys:kKeys2
|
| - count:GPBARRAYSIZE(kValues2)];
|
| + [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues2
|
| + forKeys:kKeys2
|
| + count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| [dict addEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 103U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 102U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 100U);
|
| - XCTAssertTrue([dict getUInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 101U);
|
|
|
| [dict2 release];
|
| @@ -451,8 +451,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| GPBInt32Int32Dictionary *dict = [[GPBInt32Int32Dictionary alloc] init];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getInt32:NULL forKey:11]);
|
| - [dict enumerateKeysAndInt32sUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue, stop)
|
| XCTFail(@"Shouldn't get here!");
|
| }];
|
| @@ -460,15 +460,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| }
|
|
|
| - (void)testOne {
|
| - GPBInt32Int32Dictionary *dict = [GPBInt32Int32Dictionary dictionaryWithInt32:200 forKey:11];
|
| + GPBInt32Int32Dictionary *dict = [GPBInt32Int32Dictionary dictionaryWithValue:200 forKey:11];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 1U);
|
| int32_t value;
|
| - XCTAssertTrue([dict getInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 200);
|
| - XCTAssertFalse([dict getInt32:NULL forKey:12]);
|
| - [dict enumerateKeysAndInt32sUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| XCTAssertEqual(aKey, 11);
|
| XCTAssertEqual(aValue, 200);
|
| XCTAssertNotEqual(stop, NULL);
|
| @@ -479,27 +479,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13 };
|
| const int32_t kValues[] = { 200, 201, 202 };
|
| GPBInt32Int32Dictionary *dict =
|
| - [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues
|
| + [[GPBInt32Int32Dictionary alloc] initWithValues:kValues
|
| forKeys:kKeys
|
| count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 3U);
|
| int32_t value;
|
| - XCTAssertTrue([dict getInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 200);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 201);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 202);
|
| - XCTAssertFalse([dict getInt32:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| __block NSUInteger idx = 0;
|
| int32_t *seenKeys = malloc(3 * sizeof(int32_t));
|
| int32_t *seenValues = malloc(3 * sizeof(int32_t));
|
| - [dict enumerateKeysAndInt32sUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| XCTAssertLessThan(idx, 3U);
|
| seenKeys[idx] = aKey;
|
| seenValues[idx] = aValue;
|
| @@ -521,7 +521,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
|
|
| // Stopping the enumeration.
|
| idx = 0;
|
| - [dict enumerateKeysAndInt32sUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue)
|
| if (idx == 1) *stop = YES;
|
| XCTAssertNotEqual(idx, 2U);
|
| @@ -537,27 +537,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kValues2[] = { 200, 203, 202 };
|
| const int32_t kValues3[] = { 200, 201, 202, 203 };
|
| GPBInt32Int32Dictionary *dict1 =
|
| - [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues1
|
| + [[GPBInt32Int32Dictionary alloc] initWithValues:kValues1
|
| forKeys:kKeys1
|
| count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1);
|
| GPBInt32Int32Dictionary *dict1prime =
|
| - [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues1
|
| + [[GPBInt32Int32Dictionary alloc] initWithValues:kValues1
|
| forKeys:kKeys1
|
| count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1prime);
|
| GPBInt32Int32Dictionary *dict2 =
|
| - [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues2
|
| + [[GPBInt32Int32Dictionary alloc] initWithValues:kValues2
|
| forKeys:kKeys1
|
| count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| GPBInt32Int32Dictionary *dict3 =
|
| - [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues1
|
| + [[GPBInt32Int32Dictionary alloc] initWithValues:kValues1
|
| forKeys:kKeys2
|
| count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict3);
|
| GPBInt32Int32Dictionary *dict4 =
|
| - [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues3
|
| + [[GPBInt32Int32Dictionary alloc] initWithValues:kValues3
|
| forKeys:kKeys1
|
| count:GPBARRAYSIZE(kValues3)];
|
| XCTAssertNotNil(dict4);
|
| @@ -588,7 +588,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const int32_t kValues[] = { 200, 201, 202, 203 };
|
| GPBInt32Int32Dictionary *dict =
|
| - [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues
|
| + [[GPBInt32Int32Dictionary alloc] initWithValues:kValues
|
| forKeys:kKeys
|
| count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| @@ -609,7 +609,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const int32_t kValues[] = { 200, 201, 202, 203 };
|
| GPBInt32Int32Dictionary *dict =
|
| - [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues
|
| + [[GPBInt32Int32Dictionary alloc] initWithValues:kValues
|
| forKeys:kKeys
|
| count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| @@ -629,13 +629,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertNotNil(dict);
|
|
|
| XCTAssertEqual(dict.count, 0U);
|
| - [dict setInt32:200 forKey:11];
|
| + [dict setValue:200 forKey:11];
|
| XCTAssertEqual(dict.count, 1U);
|
|
|
| const int32_t kKeys[] = { 12, 13, 14 };
|
| const int32_t kValues[] = { 201, 202, 203 };
|
| GPBInt32Int32Dictionary *dict2 =
|
| - [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues
|
| + [[GPBInt32Int32Dictionary alloc] initWithValues:kValues
|
| forKeys:kKeys
|
| count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict2);
|
| @@ -643,17 +643,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| int32_t value;
|
| - XCTAssertTrue([dict getInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 200);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 201);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 202);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 203);
|
| [dict2 release];
|
| }
|
| @@ -662,57 +662,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const int32_t kValues[] = { 200, 201, 202, 203 };
|
| GPBInt32Int32Dictionary *dict =
|
| - [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32Int32Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| - [dict removeInt32ForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| int32_t value;
|
| - XCTAssertTrue([dict getInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 200);
|
| - XCTAssertFalse([dict getInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 202);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 203);
|
|
|
| // Remove again does nothing.
|
| - [dict removeInt32ForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 200);
|
| - XCTAssertFalse([dict getInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 202);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 203);
|
|
|
| - [dict removeInt32ForKey:14];
|
| + [dict removeValueForKey:14];
|
| XCTAssertEqual(dict.count, 2U);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 200);
|
| - XCTAssertFalse([dict getInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 202);
|
| - XCTAssertFalse([dict getInt32:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| [dict removeAll];
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getInt32:NULL forKey:11]);
|
| - XCTAssertFalse([dict getInt32:NULL forKey:12]);
|
| - XCTAssertFalse([dict getInt32:NULL forKey:13]);
|
| - XCTAssertFalse([dict getInt32:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:13 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
| [dict release];
|
| }
|
|
|
| @@ -720,75 +720,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const int32_t kValues[] = { 200, 201, 202, 203 };
|
| GPBInt32Int32Dictionary *dict =
|
| - [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32Int32Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
| int32_t value;
|
| - XCTAssertTrue([dict getInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 200);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 201);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 202);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 203);
|
|
|
| - [dict setInt32:203 forKey:11];
|
| + [dict setValue:203 forKey:11];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 203);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 201);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 202);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 203);
|
|
|
| - [dict setInt32:201 forKey:14];
|
| + [dict setValue:201 forKey:14];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 203);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 201);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 202);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 201);
|
|
|
| const int32_t kKeys2[] = { 12, 13 };
|
| const int32_t kValues2[] = { 202, 200 };
|
| GPBInt32Int32Dictionary *dict2 =
|
| - [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues2
|
| + [[GPBInt32Int32Dictionary alloc] initWithValues:kValues2
|
| forKeys:kKeys2
|
| count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| [dict addEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 203);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 202);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 200);
|
| - XCTAssertTrue([dict getInt32:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt32:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 201);
|
|
|
| [dict2 release];
|
| @@ -808,8 +808,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| GPBInt32UInt64Dictionary *dict = [[GPBInt32UInt64Dictionary alloc] init];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getUInt64:NULL forKey:11]);
|
| - [dict enumerateKeysAndUInt64sUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue, stop)
|
| XCTFail(@"Shouldn't get here!");
|
| }];
|
| @@ -817,15 +817,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| }
|
|
|
| - (void)testOne {
|
| - GPBInt32UInt64Dictionary *dict = [GPBInt32UInt64Dictionary dictionaryWithUInt64:300U forKey:11];
|
| + GPBInt32UInt64Dictionary *dict = [GPBInt32UInt64Dictionary dictionaryWithValue:300U forKey:11];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 1U);
|
| uint64_t value;
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 300U);
|
| - XCTAssertFalse([dict getUInt64:NULL forKey:12]);
|
| - [dict enumerateKeysAndUInt64sUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) {
|
| XCTAssertEqual(aKey, 11);
|
| XCTAssertEqual(aValue, 300U);
|
| XCTAssertNotEqual(stop, NULL);
|
| @@ -836,27 +836,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13 };
|
| const uint64_t kValues[] = { 300U, 301U, 302U };
|
| GPBInt32UInt64Dictionary *dict =
|
| - [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 3U);
|
| uint64_t value;
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 300U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 301U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 302U);
|
| - XCTAssertFalse([dict getUInt64:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| __block NSUInteger idx = 0;
|
| int32_t *seenKeys = malloc(3 * sizeof(int32_t));
|
| uint64_t *seenValues = malloc(3 * sizeof(uint64_t));
|
| - [dict enumerateKeysAndUInt64sUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) {
|
| XCTAssertLessThan(idx, 3U);
|
| seenKeys[idx] = aKey;
|
| seenValues[idx] = aValue;
|
| @@ -878,7 +878,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
|
|
| // Stopping the enumeration.
|
| idx = 0;
|
| - [dict enumerateKeysAndUInt64sUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue)
|
| if (idx == 1) *stop = YES;
|
| XCTAssertNotEqual(idx, 2U);
|
| @@ -894,29 +894,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const uint64_t kValues2[] = { 300U, 303U, 302U };
|
| const uint64_t kValues3[] = { 300U, 301U, 302U, 303U };
|
| GPBInt32UInt64Dictionary *dict1 =
|
| - [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues1
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1);
|
| GPBInt32UInt64Dictionary *dict1prime =
|
| - [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues1
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1prime);
|
| GPBInt32UInt64Dictionary *dict2 =
|
| - [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues2
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues2)];
|
| + [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues2
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| GPBInt32UInt64Dictionary *dict3 =
|
| - [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues1
|
| - forKeys:kKeys2
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys2
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict3);
|
| GPBInt32UInt64Dictionary *dict4 =
|
| - [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues3
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues3)];
|
| + [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues3
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues3)];
|
| XCTAssertNotNil(dict4);
|
|
|
| // 1/1Prime should be different objects, but equal.
|
| @@ -945,9 +945,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const uint64_t kValues[] = { 300U, 301U, 302U, 303U };
|
| GPBInt32UInt64Dictionary *dict =
|
| - [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
|
|
| GPBInt32UInt64Dictionary *dict2 = [dict copy];
|
| @@ -966,9 +966,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const uint64_t kValues[] = { 300U, 301U, 302U, 303U };
|
| GPBInt32UInt64Dictionary *dict =
|
| - [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
|
|
| GPBInt32UInt64Dictionary *dict2 =
|
| @@ -986,31 +986,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertNotNil(dict);
|
|
|
| XCTAssertEqual(dict.count, 0U);
|
| - [dict setUInt64:300U forKey:11];
|
| + [dict setValue:300U forKey:11];
|
| XCTAssertEqual(dict.count, 1U);
|
|
|
| const int32_t kKeys[] = { 12, 13, 14 };
|
| const uint64_t kValues[] = { 301U, 302U, 303U };
|
| GPBInt32UInt64Dictionary *dict2 =
|
| - [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict2);
|
| [dict addEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| uint64_t value;
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 300U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 301U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 302U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 303U);
|
| [dict2 release];
|
| }
|
| @@ -1019,57 +1019,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const uint64_t kValues[] = { 300U, 301U, 302U, 303U };
|
| GPBInt32UInt64Dictionary *dict =
|
| - [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| - [dict removeUInt64ForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| uint64_t value;
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 300U);
|
| - XCTAssertFalse([dict getUInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 302U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 303U);
|
|
|
| // Remove again does nothing.
|
| - [dict removeUInt64ForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 300U);
|
| - XCTAssertFalse([dict getUInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 302U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 303U);
|
|
|
| - [dict removeUInt64ForKey:14];
|
| + [dict removeValueForKey:14];
|
| XCTAssertEqual(dict.count, 2U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 300U);
|
| - XCTAssertFalse([dict getUInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 302U);
|
| - XCTAssertFalse([dict getUInt64:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| [dict removeAll];
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getUInt64:NULL forKey:11]);
|
| - XCTAssertFalse([dict getUInt64:NULL forKey:12]);
|
| - XCTAssertFalse([dict getUInt64:NULL forKey:13]);
|
| - XCTAssertFalse([dict getUInt64:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:13 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
| [dict release];
|
| }
|
|
|
| @@ -1077,75 +1077,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const uint64_t kValues[] = { 300U, 301U, 302U, 303U };
|
| GPBInt32UInt64Dictionary *dict =
|
| - [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
| uint64_t value;
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 300U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 301U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 302U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 303U);
|
|
|
| - [dict setUInt64:303U forKey:11];
|
| + [dict setValue:303U forKey:11];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 303U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 301U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 302U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 303U);
|
|
|
| - [dict setUInt64:301U forKey:14];
|
| + [dict setValue:301U forKey:14];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 303U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 301U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 302U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 301U);
|
|
|
| const int32_t kKeys2[] = { 12, 13 };
|
| const uint64_t kValues2[] = { 302U, 300U };
|
| GPBInt32UInt64Dictionary *dict2 =
|
| - [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues2
|
| - forKeys:kKeys2
|
| - count:GPBARRAYSIZE(kValues2)];
|
| + [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues2
|
| + forKeys:kKeys2
|
| + count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| [dict addEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 303U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 302U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 300U);
|
| - XCTAssertTrue([dict getUInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getUInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 301U);
|
|
|
| [dict2 release];
|
| @@ -1165,8 +1165,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| GPBInt32Int64Dictionary *dict = [[GPBInt32Int64Dictionary alloc] init];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getInt64:NULL forKey:11]);
|
| - [dict enumerateKeysAndInt64sUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue, stop)
|
| XCTFail(@"Shouldn't get here!");
|
| }];
|
| @@ -1174,15 +1174,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| }
|
|
|
| - (void)testOne {
|
| - GPBInt32Int64Dictionary *dict = [GPBInt32Int64Dictionary dictionaryWithInt64:400 forKey:11];
|
| + GPBInt32Int64Dictionary *dict = [GPBInt32Int64Dictionary dictionaryWithValue:400 forKey:11];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 1U);
|
| int64_t value;
|
| - XCTAssertTrue([dict getInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 400);
|
| - XCTAssertFalse([dict getInt64:NULL forKey:12]);
|
| - [dict enumerateKeysAndInt64sUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) {
|
| XCTAssertEqual(aKey, 11);
|
| XCTAssertEqual(aValue, 400);
|
| XCTAssertNotEqual(stop, NULL);
|
| @@ -1193,27 +1193,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13 };
|
| const int64_t kValues[] = { 400, 401, 402 };
|
| GPBInt32Int64Dictionary *dict =
|
| - [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues
|
| + [[GPBInt32Int64Dictionary alloc] initWithValues:kValues
|
| forKeys:kKeys
|
| count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 3U);
|
| int64_t value;
|
| - XCTAssertTrue([dict getInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 400);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 401);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 402);
|
| - XCTAssertFalse([dict getInt64:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| __block NSUInteger idx = 0;
|
| int32_t *seenKeys = malloc(3 * sizeof(int32_t));
|
| int64_t *seenValues = malloc(3 * sizeof(int64_t));
|
| - [dict enumerateKeysAndInt64sUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) {
|
| XCTAssertLessThan(idx, 3U);
|
| seenKeys[idx] = aKey;
|
| seenValues[idx] = aValue;
|
| @@ -1235,7 +1235,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
|
|
| // Stopping the enumeration.
|
| idx = 0;
|
| - [dict enumerateKeysAndInt64sUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue)
|
| if (idx == 1) *stop = YES;
|
| XCTAssertNotEqual(idx, 2U);
|
| @@ -1251,27 +1251,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int64_t kValues2[] = { 400, 403, 402 };
|
| const int64_t kValues3[] = { 400, 401, 402, 403 };
|
| GPBInt32Int64Dictionary *dict1 =
|
| - [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues1
|
| + [[GPBInt32Int64Dictionary alloc] initWithValues:kValues1
|
| forKeys:kKeys1
|
| count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1);
|
| GPBInt32Int64Dictionary *dict1prime =
|
| - [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues1
|
| + [[GPBInt32Int64Dictionary alloc] initWithValues:kValues1
|
| forKeys:kKeys1
|
| count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1prime);
|
| GPBInt32Int64Dictionary *dict2 =
|
| - [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues2
|
| + [[GPBInt32Int64Dictionary alloc] initWithValues:kValues2
|
| forKeys:kKeys1
|
| count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| GPBInt32Int64Dictionary *dict3 =
|
| - [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues1
|
| + [[GPBInt32Int64Dictionary alloc] initWithValues:kValues1
|
| forKeys:kKeys2
|
| count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict3);
|
| GPBInt32Int64Dictionary *dict4 =
|
| - [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues3
|
| + [[GPBInt32Int64Dictionary alloc] initWithValues:kValues3
|
| forKeys:kKeys1
|
| count:GPBARRAYSIZE(kValues3)];
|
| XCTAssertNotNil(dict4);
|
| @@ -1302,7 +1302,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const int64_t kValues[] = { 400, 401, 402, 403 };
|
| GPBInt32Int64Dictionary *dict =
|
| - [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues
|
| + [[GPBInt32Int64Dictionary alloc] initWithValues:kValues
|
| forKeys:kKeys
|
| count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| @@ -1323,7 +1323,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const int64_t kValues[] = { 400, 401, 402, 403 };
|
| GPBInt32Int64Dictionary *dict =
|
| - [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues
|
| + [[GPBInt32Int64Dictionary alloc] initWithValues:kValues
|
| forKeys:kKeys
|
| count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| @@ -1343,13 +1343,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertNotNil(dict);
|
|
|
| XCTAssertEqual(dict.count, 0U);
|
| - [dict setInt64:400 forKey:11];
|
| + [dict setValue:400 forKey:11];
|
| XCTAssertEqual(dict.count, 1U);
|
|
|
| const int32_t kKeys[] = { 12, 13, 14 };
|
| const int64_t kValues[] = { 401, 402, 403 };
|
| GPBInt32Int64Dictionary *dict2 =
|
| - [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues
|
| + [[GPBInt32Int64Dictionary alloc] initWithValues:kValues
|
| forKeys:kKeys
|
| count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict2);
|
| @@ -1357,17 +1357,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| int64_t value;
|
| - XCTAssertTrue([dict getInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 400);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 401);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 402);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 403);
|
| [dict2 release];
|
| }
|
| @@ -1376,57 +1376,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const int64_t kValues[] = { 400, 401, 402, 403 };
|
| GPBInt32Int64Dictionary *dict =
|
| - [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32Int64Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| - [dict removeInt64ForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| int64_t value;
|
| - XCTAssertTrue([dict getInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 400);
|
| - XCTAssertFalse([dict getInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 402);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 403);
|
|
|
| // Remove again does nothing.
|
| - [dict removeInt64ForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 400);
|
| - XCTAssertFalse([dict getInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 402);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 403);
|
|
|
| - [dict removeInt64ForKey:14];
|
| + [dict removeValueForKey:14];
|
| XCTAssertEqual(dict.count, 2U);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 400);
|
| - XCTAssertFalse([dict getInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 402);
|
| - XCTAssertFalse([dict getInt64:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| [dict removeAll];
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getInt64:NULL forKey:11]);
|
| - XCTAssertFalse([dict getInt64:NULL forKey:12]);
|
| - XCTAssertFalse([dict getInt64:NULL forKey:13]);
|
| - XCTAssertFalse([dict getInt64:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:13 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
| [dict release];
|
| }
|
|
|
| @@ -1434,75 +1434,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const int64_t kValues[] = { 400, 401, 402, 403 };
|
| GPBInt32Int64Dictionary *dict =
|
| - [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32Int64Dictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
| int64_t value;
|
| - XCTAssertTrue([dict getInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 400);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 401);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 402);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 403);
|
|
|
| - [dict setInt64:403 forKey:11];
|
| + [dict setValue:403 forKey:11];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 403);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 401);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 402);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 403);
|
|
|
| - [dict setInt64:401 forKey:14];
|
| + [dict setValue:401 forKey:14];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 403);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 401);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 402);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 401);
|
|
|
| const int32_t kKeys2[] = { 12, 13 };
|
| const int64_t kValues2[] = { 402, 400 };
|
| GPBInt32Int64Dictionary *dict2 =
|
| - [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues2
|
| + [[GPBInt32Int64Dictionary alloc] initWithValues:kValues2
|
| forKeys:kKeys2
|
| count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| [dict addEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:11]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 403);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:12]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 402);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:13]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 400);
|
| - XCTAssertTrue([dict getInt64:NULL forKey:14]);
|
| - XCTAssertTrue([dict getInt64:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 401);
|
|
|
| [dict2 release];
|
| @@ -1522,8 +1522,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| GPBInt32BoolDictionary *dict = [[GPBInt32BoolDictionary alloc] init];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getBool:NULL forKey:11]);
|
| - [dict enumerateKeysAndBoolsUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue, stop)
|
| XCTFail(@"Shouldn't get here!");
|
| }];
|
| @@ -1531,15 +1531,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| }
|
|
|
| - (void)testOne {
|
| - GPBInt32BoolDictionary *dict = [GPBInt32BoolDictionary dictionaryWithBool:YES forKey:11];
|
| + GPBInt32BoolDictionary *dict = [GPBInt32BoolDictionary dictionaryWithValue:YES forKey:11];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 1U);
|
| BOOL value;
|
| - XCTAssertTrue([dict getBool:NULL forKey:11]);
|
| - XCTAssertTrue([dict getBool:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, YES);
|
| - XCTAssertFalse([dict getBool:NULL forKey:12]);
|
| - [dict enumerateKeysAndBoolsUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) {
|
| XCTAssertEqual(aKey, 11);
|
| XCTAssertEqual(aValue, YES);
|
| XCTAssertNotEqual(stop, NULL);
|
| @@ -1550,27 +1550,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13 };
|
| const BOOL kValues[] = { YES, YES, NO };
|
| GPBInt32BoolDictionary *dict =
|
| - [[GPBInt32BoolDictionary alloc] initWithBools:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32BoolDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 3U);
|
| BOOL value;
|
| - XCTAssertTrue([dict getBool:NULL forKey:11]);
|
| - XCTAssertTrue([dict getBool:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, YES);
|
| - XCTAssertTrue([dict getBool:NULL forKey:12]);
|
| - XCTAssertTrue([dict getBool:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, YES);
|
| - XCTAssertTrue([dict getBool:NULL forKey:13]);
|
| - XCTAssertTrue([dict getBool:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, NO);
|
| - XCTAssertFalse([dict getBool:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| __block NSUInteger idx = 0;
|
| int32_t *seenKeys = malloc(3 * sizeof(int32_t));
|
| BOOL *seenValues = malloc(3 * sizeof(BOOL));
|
| - [dict enumerateKeysAndBoolsUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) {
|
| XCTAssertLessThan(idx, 3U);
|
| seenKeys[idx] = aKey;
|
| seenValues[idx] = aValue;
|
| @@ -1592,7 +1592,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
|
|
| // Stopping the enumeration.
|
| idx = 0;
|
| - [dict enumerateKeysAndBoolsUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue)
|
| if (idx == 1) *stop = YES;
|
| XCTAssertNotEqual(idx, 2U);
|
| @@ -1608,29 +1608,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const BOOL kValues2[] = { YES, NO, NO };
|
| const BOOL kValues3[] = { YES, YES, NO, NO };
|
| GPBInt32BoolDictionary *dict1 =
|
| - [[GPBInt32BoolDictionary alloc] initWithBools:kValues1
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32BoolDictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1);
|
| GPBInt32BoolDictionary *dict1prime =
|
| - [[GPBInt32BoolDictionary alloc] initWithBools:kValues1
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32BoolDictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1prime);
|
| GPBInt32BoolDictionary *dict2 =
|
| - [[GPBInt32BoolDictionary alloc] initWithBools:kValues2
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues2)];
|
| + [[GPBInt32BoolDictionary alloc] initWithValues:kValues2
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| GPBInt32BoolDictionary *dict3 =
|
| - [[GPBInt32BoolDictionary alloc] initWithBools:kValues1
|
| - forKeys:kKeys2
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32BoolDictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys2
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict3);
|
| GPBInt32BoolDictionary *dict4 =
|
| - [[GPBInt32BoolDictionary alloc] initWithBools:kValues3
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues3)];
|
| + [[GPBInt32BoolDictionary alloc] initWithValues:kValues3
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues3)];
|
| XCTAssertNotNil(dict4);
|
|
|
| // 1/1Prime should be different objects, but equal.
|
| @@ -1659,9 +1659,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const BOOL kValues[] = { YES, YES, NO, NO };
|
| GPBInt32BoolDictionary *dict =
|
| - [[GPBInt32BoolDictionary alloc] initWithBools:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32BoolDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
|
|
| GPBInt32BoolDictionary *dict2 = [dict copy];
|
| @@ -1680,9 +1680,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const BOOL kValues[] = { YES, YES, NO, NO };
|
| GPBInt32BoolDictionary *dict =
|
| - [[GPBInt32BoolDictionary alloc] initWithBools:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32BoolDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
|
|
| GPBInt32BoolDictionary *dict2 =
|
| @@ -1700,31 +1700,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertNotNil(dict);
|
|
|
| XCTAssertEqual(dict.count, 0U);
|
| - [dict setBool:YES forKey:11];
|
| + [dict setValue:YES forKey:11];
|
| XCTAssertEqual(dict.count, 1U);
|
|
|
| const int32_t kKeys[] = { 12, 13, 14 };
|
| const BOOL kValues[] = { YES, NO, NO };
|
| GPBInt32BoolDictionary *dict2 =
|
| - [[GPBInt32BoolDictionary alloc] initWithBools:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32BoolDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict2);
|
| [dict addEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| BOOL value;
|
| - XCTAssertTrue([dict getBool:NULL forKey:11]);
|
| - XCTAssertTrue([dict getBool:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, YES);
|
| - XCTAssertTrue([dict getBool:NULL forKey:12]);
|
| - XCTAssertTrue([dict getBool:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, YES);
|
| - XCTAssertTrue([dict getBool:NULL forKey:13]);
|
| - XCTAssertTrue([dict getBool:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, NO);
|
| - XCTAssertTrue([dict getBool:NULL forKey:14]);
|
| - XCTAssertTrue([dict getBool:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, NO);
|
| [dict2 release];
|
| }
|
| @@ -1733,57 +1733,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const BOOL kValues[] = { YES, YES, NO, NO };
|
| GPBInt32BoolDictionary *dict =
|
| - [[GPBInt32BoolDictionary alloc] initWithBools:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32BoolDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| - [dict removeBoolForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| BOOL value;
|
| - XCTAssertTrue([dict getBool:NULL forKey:11]);
|
| - XCTAssertTrue([dict getBool:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, YES);
|
| - XCTAssertFalse([dict getBool:NULL forKey:12]);
|
| - XCTAssertTrue([dict getBool:NULL forKey:13]);
|
| - XCTAssertTrue([dict getBool:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, NO);
|
| - XCTAssertTrue([dict getBool:NULL forKey:14]);
|
| - XCTAssertTrue([dict getBool:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, NO);
|
|
|
| // Remove again does nothing.
|
| - [dict removeBoolForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| - XCTAssertTrue([dict getBool:NULL forKey:11]);
|
| - XCTAssertTrue([dict getBool:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, YES);
|
| - XCTAssertFalse([dict getBool:NULL forKey:12]);
|
| - XCTAssertTrue([dict getBool:NULL forKey:13]);
|
| - XCTAssertTrue([dict getBool:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, NO);
|
| - XCTAssertTrue([dict getBool:NULL forKey:14]);
|
| - XCTAssertTrue([dict getBool:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, NO);
|
|
|
| - [dict removeBoolForKey:14];
|
| + [dict removeValueForKey:14];
|
| XCTAssertEqual(dict.count, 2U);
|
| - XCTAssertTrue([dict getBool:NULL forKey:11]);
|
| - XCTAssertTrue([dict getBool:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, YES);
|
| - XCTAssertFalse([dict getBool:NULL forKey:12]);
|
| - XCTAssertTrue([dict getBool:NULL forKey:13]);
|
| - XCTAssertTrue([dict getBool:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, NO);
|
| - XCTAssertFalse([dict getBool:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| [dict removeAll];
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getBool:NULL forKey:11]);
|
| - XCTAssertFalse([dict getBool:NULL forKey:12]);
|
| - XCTAssertFalse([dict getBool:NULL forKey:13]);
|
| - XCTAssertFalse([dict getBool:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:13 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
| [dict release];
|
| }
|
|
|
| @@ -1791,75 +1791,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const BOOL kValues[] = { YES, YES, NO, NO };
|
| GPBInt32BoolDictionary *dict =
|
| - [[GPBInt32BoolDictionary alloc] initWithBools:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32BoolDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
| BOOL value;
|
| - XCTAssertTrue([dict getBool:NULL forKey:11]);
|
| - XCTAssertTrue([dict getBool:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, YES);
|
| - XCTAssertTrue([dict getBool:NULL forKey:12]);
|
| - XCTAssertTrue([dict getBool:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, YES);
|
| - XCTAssertTrue([dict getBool:NULL forKey:13]);
|
| - XCTAssertTrue([dict getBool:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, NO);
|
| - XCTAssertTrue([dict getBool:NULL forKey:14]);
|
| - XCTAssertTrue([dict getBool:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, NO);
|
|
|
| - [dict setBool:NO forKey:11];
|
| + [dict setValue:NO forKey:11];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getBool:NULL forKey:11]);
|
| - XCTAssertTrue([dict getBool:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, NO);
|
| - XCTAssertTrue([dict getBool:NULL forKey:12]);
|
| - XCTAssertTrue([dict getBool:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, YES);
|
| - XCTAssertTrue([dict getBool:NULL forKey:13]);
|
| - XCTAssertTrue([dict getBool:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, NO);
|
| - XCTAssertTrue([dict getBool:NULL forKey:14]);
|
| - XCTAssertTrue([dict getBool:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, NO);
|
|
|
| - [dict setBool:YES forKey:14];
|
| + [dict setValue:YES forKey:14];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getBool:NULL forKey:11]);
|
| - XCTAssertTrue([dict getBool:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, NO);
|
| - XCTAssertTrue([dict getBool:NULL forKey:12]);
|
| - XCTAssertTrue([dict getBool:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, YES);
|
| - XCTAssertTrue([dict getBool:NULL forKey:13]);
|
| - XCTAssertTrue([dict getBool:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, NO);
|
| - XCTAssertTrue([dict getBool:NULL forKey:14]);
|
| - XCTAssertTrue([dict getBool:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, YES);
|
|
|
| const int32_t kKeys2[] = { 12, 13 };
|
| const BOOL kValues2[] = { NO, YES };
|
| GPBInt32BoolDictionary *dict2 =
|
| - [[GPBInt32BoolDictionary alloc] initWithBools:kValues2
|
| - forKeys:kKeys2
|
| - count:GPBARRAYSIZE(kValues2)];
|
| + [[GPBInt32BoolDictionary alloc] initWithValues:kValues2
|
| + forKeys:kKeys2
|
| + count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| [dict addEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getBool:NULL forKey:11]);
|
| - XCTAssertTrue([dict getBool:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, NO);
|
| - XCTAssertTrue([dict getBool:NULL forKey:12]);
|
| - XCTAssertTrue([dict getBool:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, NO);
|
| - XCTAssertTrue([dict getBool:NULL forKey:13]);
|
| - XCTAssertTrue([dict getBool:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, YES);
|
| - XCTAssertTrue([dict getBool:NULL forKey:14]);
|
| - XCTAssertTrue([dict getBool:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, YES);
|
|
|
| [dict2 release];
|
| @@ -1879,8 +1879,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| GPBInt32FloatDictionary *dict = [[GPBInt32FloatDictionary alloc] init];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getFloat:NULL forKey:11]);
|
| - [dict enumerateKeysAndFloatsUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue, stop)
|
| XCTFail(@"Shouldn't get here!");
|
| }];
|
| @@ -1888,15 +1888,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| }
|
|
|
| - (void)testOne {
|
| - GPBInt32FloatDictionary *dict = [GPBInt32FloatDictionary dictionaryWithFloat:500.f forKey:11];
|
| + GPBInt32FloatDictionary *dict = [GPBInt32FloatDictionary dictionaryWithValue:500.f forKey:11];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 1U);
|
| float value;
|
| - XCTAssertTrue([dict getFloat:NULL forKey:11]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 500.f);
|
| - XCTAssertFalse([dict getFloat:NULL forKey:12]);
|
| - [dict enumerateKeysAndFloatsUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) {
|
| XCTAssertEqual(aKey, 11);
|
| XCTAssertEqual(aValue, 500.f);
|
| XCTAssertNotEqual(stop, NULL);
|
| @@ -1907,27 +1907,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13 };
|
| const float kValues[] = { 500.f, 501.f, 502.f };
|
| GPBInt32FloatDictionary *dict =
|
| - [[GPBInt32FloatDictionary alloc] initWithFloats:kValues
|
| + [[GPBInt32FloatDictionary alloc] initWithValues:kValues
|
| forKeys:kKeys
|
| count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 3U);
|
| float value;
|
| - XCTAssertTrue([dict getFloat:NULL forKey:11]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 500.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:12]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 501.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:13]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 502.f);
|
| - XCTAssertFalse([dict getFloat:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| __block NSUInteger idx = 0;
|
| int32_t *seenKeys = malloc(3 * sizeof(int32_t));
|
| float *seenValues = malloc(3 * sizeof(float));
|
| - [dict enumerateKeysAndFloatsUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) {
|
| XCTAssertLessThan(idx, 3U);
|
| seenKeys[idx] = aKey;
|
| seenValues[idx] = aValue;
|
| @@ -1949,7 +1949,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
|
|
| // Stopping the enumeration.
|
| idx = 0;
|
| - [dict enumerateKeysAndFloatsUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue)
|
| if (idx == 1) *stop = YES;
|
| XCTAssertNotEqual(idx, 2U);
|
| @@ -1965,27 +1965,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const float kValues2[] = { 500.f, 503.f, 502.f };
|
| const float kValues3[] = { 500.f, 501.f, 502.f, 503.f };
|
| GPBInt32FloatDictionary *dict1 =
|
| - [[GPBInt32FloatDictionary alloc] initWithFloats:kValues1
|
| + [[GPBInt32FloatDictionary alloc] initWithValues:kValues1
|
| forKeys:kKeys1
|
| count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1);
|
| GPBInt32FloatDictionary *dict1prime =
|
| - [[GPBInt32FloatDictionary alloc] initWithFloats:kValues1
|
| + [[GPBInt32FloatDictionary alloc] initWithValues:kValues1
|
| forKeys:kKeys1
|
| count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1prime);
|
| GPBInt32FloatDictionary *dict2 =
|
| - [[GPBInt32FloatDictionary alloc] initWithFloats:kValues2
|
| + [[GPBInt32FloatDictionary alloc] initWithValues:kValues2
|
| forKeys:kKeys1
|
| count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| GPBInt32FloatDictionary *dict3 =
|
| - [[GPBInt32FloatDictionary alloc] initWithFloats:kValues1
|
| + [[GPBInt32FloatDictionary alloc] initWithValues:kValues1
|
| forKeys:kKeys2
|
| count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict3);
|
| GPBInt32FloatDictionary *dict4 =
|
| - [[GPBInt32FloatDictionary alloc] initWithFloats:kValues3
|
| + [[GPBInt32FloatDictionary alloc] initWithValues:kValues3
|
| forKeys:kKeys1
|
| count:GPBARRAYSIZE(kValues3)];
|
| XCTAssertNotNil(dict4);
|
| @@ -2016,7 +2016,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const float kValues[] = { 500.f, 501.f, 502.f, 503.f };
|
| GPBInt32FloatDictionary *dict =
|
| - [[GPBInt32FloatDictionary alloc] initWithFloats:kValues
|
| + [[GPBInt32FloatDictionary alloc] initWithValues:kValues
|
| forKeys:kKeys
|
| count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| @@ -2037,7 +2037,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const float kValues[] = { 500.f, 501.f, 502.f, 503.f };
|
| GPBInt32FloatDictionary *dict =
|
| - [[GPBInt32FloatDictionary alloc] initWithFloats:kValues
|
| + [[GPBInt32FloatDictionary alloc] initWithValues:kValues
|
| forKeys:kKeys
|
| count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| @@ -2057,13 +2057,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertNotNil(dict);
|
|
|
| XCTAssertEqual(dict.count, 0U);
|
| - [dict setFloat:500.f forKey:11];
|
| + [dict setValue:500.f forKey:11];
|
| XCTAssertEqual(dict.count, 1U);
|
|
|
| const int32_t kKeys[] = { 12, 13, 14 };
|
| const float kValues[] = { 501.f, 502.f, 503.f };
|
| GPBInt32FloatDictionary *dict2 =
|
| - [[GPBInt32FloatDictionary alloc] initWithFloats:kValues
|
| + [[GPBInt32FloatDictionary alloc] initWithValues:kValues
|
| forKeys:kKeys
|
| count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict2);
|
| @@ -2071,17 +2071,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| float value;
|
| - XCTAssertTrue([dict getFloat:NULL forKey:11]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 500.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:12]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 501.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:13]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 502.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:14]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 503.f);
|
| [dict2 release];
|
| }
|
| @@ -2090,57 +2090,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const float kValues[] = { 500.f, 501.f, 502.f, 503.f };
|
| GPBInt32FloatDictionary *dict =
|
| - [[GPBInt32FloatDictionary alloc] initWithFloats:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32FloatDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| - [dict removeFloatForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| float value;
|
| - XCTAssertTrue([dict getFloat:NULL forKey:11]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 500.f);
|
| - XCTAssertFalse([dict getFloat:NULL forKey:12]);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:13]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 502.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:14]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 503.f);
|
|
|
| // Remove again does nothing.
|
| - [dict removeFloatForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:11]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 500.f);
|
| - XCTAssertFalse([dict getFloat:NULL forKey:12]);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:13]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 502.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:14]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 503.f);
|
|
|
| - [dict removeFloatForKey:14];
|
| + [dict removeValueForKey:14];
|
| XCTAssertEqual(dict.count, 2U);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:11]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 500.f);
|
| - XCTAssertFalse([dict getFloat:NULL forKey:12]);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:13]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 502.f);
|
| - XCTAssertFalse([dict getFloat:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| [dict removeAll];
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getFloat:NULL forKey:11]);
|
| - XCTAssertFalse([dict getFloat:NULL forKey:12]);
|
| - XCTAssertFalse([dict getFloat:NULL forKey:13]);
|
| - XCTAssertFalse([dict getFloat:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:13 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
| [dict release];
|
| }
|
|
|
| @@ -2148,75 +2148,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const float kValues[] = { 500.f, 501.f, 502.f, 503.f };
|
| GPBInt32FloatDictionary *dict =
|
| - [[GPBInt32FloatDictionary alloc] initWithFloats:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32FloatDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
| float value;
|
| - XCTAssertTrue([dict getFloat:NULL forKey:11]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 500.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:12]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 501.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:13]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 502.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:14]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 503.f);
|
|
|
| - [dict setFloat:503.f forKey:11];
|
| + [dict setValue:503.f forKey:11];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:11]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 503.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:12]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 501.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:13]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 502.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:14]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 503.f);
|
|
|
| - [dict setFloat:501.f forKey:14];
|
| + [dict setValue:501.f forKey:14];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:11]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 503.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:12]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 501.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:13]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 502.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:14]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 501.f);
|
|
|
| const int32_t kKeys2[] = { 12, 13 };
|
| const float kValues2[] = { 502.f, 500.f };
|
| GPBInt32FloatDictionary *dict2 =
|
| - [[GPBInt32FloatDictionary alloc] initWithFloats:kValues2
|
| + [[GPBInt32FloatDictionary alloc] initWithValues:kValues2
|
| forKeys:kKeys2
|
| count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| [dict addEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:11]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 503.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:12]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 502.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:13]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 500.f);
|
| - XCTAssertTrue([dict getFloat:NULL forKey:14]);
|
| - XCTAssertTrue([dict getFloat:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 501.f);
|
|
|
| [dict2 release];
|
| @@ -2236,8 +2236,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| GPBInt32DoubleDictionary *dict = [[GPBInt32DoubleDictionary alloc] init];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getDouble:NULL forKey:11]);
|
| - [dict enumerateKeysAndDoublesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue, stop)
|
| XCTFail(@"Shouldn't get here!");
|
| }];
|
| @@ -2245,15 +2245,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| }
|
|
|
| - (void)testOne {
|
| - GPBInt32DoubleDictionary *dict = [GPBInt32DoubleDictionary dictionaryWithDouble:600. forKey:11];
|
| + GPBInt32DoubleDictionary *dict = [GPBInt32DoubleDictionary dictionaryWithValue:600. forKey:11];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 1U);
|
| double value;
|
| - XCTAssertTrue([dict getDouble:NULL forKey:11]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 600.);
|
| - XCTAssertFalse([dict getDouble:NULL forKey:12]);
|
| - [dict enumerateKeysAndDoublesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) {
|
| XCTAssertEqual(aKey, 11);
|
| XCTAssertEqual(aValue, 600.);
|
| XCTAssertNotEqual(stop, NULL);
|
| @@ -2264,27 +2264,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13 };
|
| const double kValues[] = { 600., 601., 602. };
|
| GPBInt32DoubleDictionary *dict =
|
| - [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32DoubleDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 3U);
|
| double value;
|
| - XCTAssertTrue([dict getDouble:NULL forKey:11]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 600.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:12]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 601.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:13]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 602.);
|
| - XCTAssertFalse([dict getDouble:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| __block NSUInteger idx = 0;
|
| int32_t *seenKeys = malloc(3 * sizeof(int32_t));
|
| double *seenValues = malloc(3 * sizeof(double));
|
| - [dict enumerateKeysAndDoublesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) {
|
| XCTAssertLessThan(idx, 3U);
|
| seenKeys[idx] = aKey;
|
| seenValues[idx] = aValue;
|
| @@ -2306,7 +2306,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
|
|
| // Stopping the enumeration.
|
| idx = 0;
|
| - [dict enumerateKeysAndDoublesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue)
|
| if (idx == 1) *stop = YES;
|
| XCTAssertNotEqual(idx, 2U);
|
| @@ -2322,29 +2322,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const double kValues2[] = { 600., 603., 602. };
|
| const double kValues3[] = { 600., 601., 602., 603. };
|
| GPBInt32DoubleDictionary *dict1 =
|
| - [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues1
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32DoubleDictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1);
|
| GPBInt32DoubleDictionary *dict1prime =
|
| - [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues1
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32DoubleDictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1prime);
|
| GPBInt32DoubleDictionary *dict2 =
|
| - [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues2
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues2)];
|
| + [[GPBInt32DoubleDictionary alloc] initWithValues:kValues2
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| GPBInt32DoubleDictionary *dict3 =
|
| - [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues1
|
| - forKeys:kKeys2
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32DoubleDictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys2
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict3);
|
| GPBInt32DoubleDictionary *dict4 =
|
| - [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues3
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues3)];
|
| + [[GPBInt32DoubleDictionary alloc] initWithValues:kValues3
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues3)];
|
| XCTAssertNotNil(dict4);
|
|
|
| // 1/1Prime should be different objects, but equal.
|
| @@ -2373,9 +2373,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const double kValues[] = { 600., 601., 602., 603. };
|
| GPBInt32DoubleDictionary *dict =
|
| - [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32DoubleDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
|
|
| GPBInt32DoubleDictionary *dict2 = [dict copy];
|
| @@ -2394,9 +2394,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const double kValues[] = { 600., 601., 602., 603. };
|
| GPBInt32DoubleDictionary *dict =
|
| - [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32DoubleDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
|
|
| GPBInt32DoubleDictionary *dict2 =
|
| @@ -2414,31 +2414,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertNotNil(dict);
|
|
|
| XCTAssertEqual(dict.count, 0U);
|
| - [dict setDouble:600. forKey:11];
|
| + [dict setValue:600. forKey:11];
|
| XCTAssertEqual(dict.count, 1U);
|
|
|
| const int32_t kKeys[] = { 12, 13, 14 };
|
| const double kValues[] = { 601., 602., 603. };
|
| GPBInt32DoubleDictionary *dict2 =
|
| - [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32DoubleDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict2);
|
| [dict addEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| double value;
|
| - XCTAssertTrue([dict getDouble:NULL forKey:11]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 600.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:12]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 601.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:13]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 602.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:14]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 603.);
|
| [dict2 release];
|
| }
|
| @@ -2447,57 +2447,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const double kValues[] = { 600., 601., 602., 603. };
|
| GPBInt32DoubleDictionary *dict =
|
| - [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32DoubleDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| - [dict removeDoubleForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| double value;
|
| - XCTAssertTrue([dict getDouble:NULL forKey:11]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 600.);
|
| - XCTAssertFalse([dict getDouble:NULL forKey:12]);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:13]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 602.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:14]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 603.);
|
|
|
| // Remove again does nothing.
|
| - [dict removeDoubleForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:11]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 600.);
|
| - XCTAssertFalse([dict getDouble:NULL forKey:12]);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:13]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 602.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:14]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 603.);
|
|
|
| - [dict removeDoubleForKey:14];
|
| + [dict removeValueForKey:14];
|
| XCTAssertEqual(dict.count, 2U);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:11]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 600.);
|
| - XCTAssertFalse([dict getDouble:NULL forKey:12]);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:13]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 602.);
|
| - XCTAssertFalse([dict getDouble:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| [dict removeAll];
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getDouble:NULL forKey:11]);
|
| - XCTAssertFalse([dict getDouble:NULL forKey:12]);
|
| - XCTAssertFalse([dict getDouble:NULL forKey:13]);
|
| - XCTAssertFalse([dict getDouble:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:13 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
| [dict release];
|
| }
|
|
|
| @@ -2505,75 +2505,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const double kValues[] = { 600., 601., 602., 603. };
|
| GPBInt32DoubleDictionary *dict =
|
| - [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32DoubleDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
| double value;
|
| - XCTAssertTrue([dict getDouble:NULL forKey:11]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 600.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:12]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 601.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:13]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 602.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:14]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 603.);
|
|
|
| - [dict setDouble:603. forKey:11];
|
| + [dict setValue:603. forKey:11];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:11]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 603.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:12]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 601.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:13]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 602.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:14]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 603.);
|
|
|
| - [dict setDouble:601. forKey:14];
|
| + [dict setValue:601. forKey:14];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:11]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 603.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:12]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 601.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:13]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 602.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:14]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 601.);
|
|
|
| const int32_t kKeys2[] = { 12, 13 };
|
| const double kValues2[] = { 602., 600. };
|
| GPBInt32DoubleDictionary *dict2 =
|
| - [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues2
|
| - forKeys:kKeys2
|
| - count:GPBARRAYSIZE(kValues2)];
|
| + [[GPBInt32DoubleDictionary alloc] initWithValues:kValues2
|
| + forKeys:kKeys2
|
| + count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| [dict addEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:11]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 603.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:12]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 602.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:13]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 600.);
|
| - XCTAssertTrue([dict getDouble:NULL forKey:14]);
|
| - XCTAssertTrue([dict getDouble:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 601.);
|
|
|
| [dict2 release];
|
| @@ -2593,8 +2593,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| GPBInt32EnumDictionary *dict = [[GPBInt32EnumDictionary alloc] init];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:11]);
|
| - [dict enumerateKeysAndEnumsUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue, stop)
|
| XCTFail(@"Shouldn't get here!");
|
| }];
|
| @@ -2602,15 +2602,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| }
|
|
|
| - (void)testOne {
|
| - GPBInt32EnumDictionary *dict = [GPBInt32EnumDictionary dictionaryWithEnum:700 forKey:11];
|
| + GPBInt32EnumDictionary *dict = [GPBInt32EnumDictionary dictionaryWithValue:700 forKey:11];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 1U);
|
| int32_t value;
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:12]);
|
| - [dict enumerateKeysAndEnumsUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| XCTAssertEqual(aKey, 11);
|
| XCTAssertEqual(aValue, 700);
|
| XCTAssertNotEqual(stop, NULL);
|
| @@ -2621,27 +2621,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13 };
|
| const int32_t kValues[] = { 700, 701, 702 };
|
| GPBInt32EnumDictionary *dict =
|
| - [[GPBInt32EnumDictionary alloc] initWithEnums:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32EnumDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 3U);
|
| int32_t value;
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 701);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| __block NSUInteger idx = 0;
|
| int32_t *seenKeys = malloc(3 * sizeof(int32_t));
|
| int32_t *seenValues = malloc(3 * sizeof(int32_t));
|
| - [dict enumerateKeysAndEnumsUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| XCTAssertLessThan(idx, 3U);
|
| seenKeys[idx] = aKey;
|
| seenValues[idx] = aValue;
|
| @@ -2663,7 +2663,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
|
|
| // Stopping the enumeration.
|
| idx = 0;
|
| - [dict enumerateKeysAndEnumsUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| #pragma unused(aKey, aValue)
|
| if (idx == 1) *stop = YES;
|
| XCTAssertNotEqual(idx, 2U);
|
| @@ -2679,29 +2679,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kValues2[] = { 700, 703, 702 };
|
| const int32_t kValues3[] = { 700, 701, 702, 703 };
|
| GPBInt32EnumDictionary *dict1 =
|
| - [[GPBInt32EnumDictionary alloc] initWithEnums:kValues1
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32EnumDictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1);
|
| GPBInt32EnumDictionary *dict1prime =
|
| - [[GPBInt32EnumDictionary alloc] initWithEnums:kValues1
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32EnumDictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict1prime);
|
| GPBInt32EnumDictionary *dict2 =
|
| - [[GPBInt32EnumDictionary alloc] initWithEnums:kValues2
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues2)];
|
| + [[GPBInt32EnumDictionary alloc] initWithValues:kValues2
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| GPBInt32EnumDictionary *dict3 =
|
| - [[GPBInt32EnumDictionary alloc] initWithEnums:kValues1
|
| - forKeys:kKeys2
|
| - count:GPBARRAYSIZE(kValues1)];
|
| + [[GPBInt32EnumDictionary alloc] initWithValues:kValues1
|
| + forKeys:kKeys2
|
| + count:GPBARRAYSIZE(kValues1)];
|
| XCTAssertNotNil(dict3);
|
| GPBInt32EnumDictionary *dict4 =
|
| - [[GPBInt32EnumDictionary alloc] initWithEnums:kValues3
|
| - forKeys:kKeys1
|
| - count:GPBARRAYSIZE(kValues3)];
|
| + [[GPBInt32EnumDictionary alloc] initWithValues:kValues3
|
| + forKeys:kKeys1
|
| + count:GPBARRAYSIZE(kValues3)];
|
| XCTAssertNotNil(dict4);
|
|
|
| // 1/1Prime should be different objects, but equal.
|
| @@ -2730,9 +2730,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const int32_t kValues[] = { 700, 701, 702, 703 };
|
| GPBInt32EnumDictionary *dict =
|
| - [[GPBInt32EnumDictionary alloc] initWithEnums:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32EnumDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
|
|
| GPBInt32EnumDictionary *dict2 = [dict copy];
|
| @@ -2751,9 +2751,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const int32_t kValues[] = { 700, 701, 702, 703 };
|
| GPBInt32EnumDictionary *dict =
|
| - [[GPBInt32EnumDictionary alloc] initWithEnums:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32EnumDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
|
|
| GPBInt32EnumDictionary *dict2 =
|
| @@ -2771,31 +2771,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertNotNil(dict);
|
|
|
| XCTAssertEqual(dict.count, 0U);
|
| - [dict setEnum:700 forKey:11];
|
| + [dict setValue:700 forKey:11];
|
| XCTAssertEqual(dict.count, 1U);
|
|
|
| const int32_t kKeys[] = { 12, 13, 14 };
|
| const int32_t kValues[] = { 701, 702, 703 };
|
| GPBInt32EnumDictionary *dict2 =
|
| - [[GPBInt32EnumDictionary alloc] initWithEnums:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32EnumDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict2);
|
| [dict addRawEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| int32_t value;
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 701);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:14]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 703);
|
| [dict2 release];
|
| }
|
| @@ -2804,57 +2804,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const int32_t kValues[] = { 700, 701, 702, 703 };
|
| GPBInt32EnumDictionary *dict =
|
| - [[GPBInt32EnumDictionary alloc] initWithEnums:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32EnumDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| - [dict removeEnumForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| int32_t value;
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:14]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 703);
|
|
|
| // Remove again does nothing.
|
| - [dict removeEnumForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:14]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 703);
|
|
|
| - [dict removeEnumForKey:14];
|
| + [dict removeValueForKey:14];
|
| XCTAssertEqual(dict.count, 2U);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| [dict removeAll];
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:11]);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:12]);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:13]);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:13 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
| [dict release];
|
| }
|
|
|
| @@ -2862,75 +2862,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 12, 13, 14 };
|
| const int32_t kValues[] = { 700, 701, 702, 703 };
|
| GPBInt32EnumDictionary *dict =
|
| - [[GPBInt32EnumDictionary alloc] initWithEnums:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32EnumDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
| int32_t value;
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 701);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:14]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 703);
|
|
|
| - [dict setEnum:703 forKey:11];
|
| + [dict setValue:703 forKey:11];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 703);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 701);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:14]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 703);
|
|
|
| - [dict setEnum:701 forKey:14];
|
| + [dict setValue:701 forKey:14];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 703);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 701);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:14]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 701);
|
|
|
| const int32_t kKeys2[] = { 12, 13 };
|
| const int32_t kValues2[] = { 702, 700 };
|
| GPBInt32EnumDictionary *dict2 =
|
| - [[GPBInt32EnumDictionary alloc] initWithEnums:kValues2
|
| - forKeys:kKeys2
|
| - count:GPBARRAYSIZE(kValues2)];
|
| + [[GPBInt32EnumDictionary alloc] initWithValues:kValues2
|
| + forKeys:kKeys2
|
| + count:GPBARRAYSIZE(kValues2)];
|
| XCTAssertNotNil(dict2);
|
| [dict addRawEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 703);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:14]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 701);
|
|
|
| [dict2 release];
|
| @@ -2958,24 +2958,24 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertEqual(dict.count, 3U);
|
| XCTAssertTrue(dict.validationFunc == TestingEnum_IsValidValue); // Pointer comparison
|
| int32_t value;
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:11]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 rawValue:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:12]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 rawValue:&value]);
|
| XCTAssertEqual(value, 801);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:13]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 rawValue:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertFalse([dict getRawValue:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 rawValue:NULL]);
|
|
|
| __block NSUInteger idx = 0;
|
| int32_t *seenKeys = malloc(3 * sizeof(int32_t));
|
| int32_t *seenValues = malloc(3 * sizeof(int32_t));
|
| - [dict enumerateKeysAndEnumsUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| + [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
|
| XCTAssertLessThan(idx, 3U);
|
| seenKeys[idx] = aKey;
|
| seenValues[idx] = aValue;
|
| @@ -3136,7 +3136,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertNotNil(dict);
|
|
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertThrowsSpecificNamed([dict setEnum:801 forKey:12], // Unknown
|
| + XCTAssertThrowsSpecificNamed([dict setValue:801 forKey:12], // Unknown
|
| NSException, NSInvalidArgumentException);
|
| XCTAssertEqual(dict.count, 0U);
|
| [dict setRawValue:801 forKey:12]; // Unknown
|
| @@ -3145,31 +3145,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const int32_t kKeys[] = { 11, 13, 14 };
|
| const int32_t kValues[] = { 700, 702, 803 }; // Unknown
|
| GPBInt32EnumDictionary *dict2 =
|
| - [[GPBInt32EnumDictionary alloc] initWithEnums:kValues
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kValues)];
|
| + [[GPBInt32EnumDictionary alloc] initWithValues:kValues
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kValues)];
|
| XCTAssertNotNil(dict2);
|
| [dict addRawEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| int32_t value;
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:12]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 rawValue:&value]);
|
| XCTAssertEqual(value, 801);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:14]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:14]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 rawValue:&value]);
|
| XCTAssertEqual(value, 803);
|
| [dict2 release];
|
| }
|
| @@ -3185,51 +3185,51 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| - [dict removeEnumForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| int32_t value;
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:14]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 rawValue:&value]);
|
| XCTAssertEqual(value, 803);
|
|
|
| // Remove again does nothing.
|
| - [dict removeEnumForKey:12];
|
| + [dict removeValueForKey:12];
|
| XCTAssertEqual(dict.count, 3U);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:14]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 rawValue:&value]);
|
| XCTAssertEqual(value, 803);
|
|
|
| - [dict removeEnumForKey:14];
|
| + [dict removeValueForKey:14];
|
| XCTAssertEqual(dict.count, 2U);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
|
|
| [dict removeAll];
|
| XCTAssertEqual(dict.count, 0U);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:11]);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:12]);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:13]);
|
| - XCTAssertFalse([dict getEnum:NULL forKey:14]);
|
| + XCTAssertFalse([dict valueForKey:11 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:12 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:13 value:NULL]);
|
| + XCTAssertFalse([dict valueForKey:14 value:NULL]);
|
| [dict release];
|
| }
|
|
|
| @@ -3244,63 +3244,63 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
| int32_t value;
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:12]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 rawValue:&value]);
|
| XCTAssertEqual(value, 801);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:14]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 rawValue:&value]);
|
| XCTAssertEqual(value, 803);
|
|
|
| - XCTAssertThrowsSpecificNamed([dict setEnum:803 forKey:11], // Unknown
|
| + XCTAssertThrowsSpecificNamed([dict setValue:803 forKey:11], // Unknown
|
| NSException, NSInvalidArgumentException);
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:11]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 value:&value]);
|
| XCTAssertEqual(value, 700);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:12]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 rawValue:&value]);
|
| XCTAssertEqual(value, 801);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:14]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 rawValue:&value]);
|
| XCTAssertEqual(value, 803);
|
|
|
| [dict setRawValue:803 forKey:11]; // Unknown
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:11]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 rawValue:&value]);
|
| XCTAssertEqual(value, 803);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:12]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 rawValue:&value]);
|
| XCTAssertEqual(value, 801);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:14]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 rawValue:&value]);
|
| XCTAssertEqual(value, 803);
|
|
|
| [dict setRawValue:700 forKey:14];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:11]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 rawValue:&value]);
|
| XCTAssertEqual(value, 803);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:12]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 rawValue:&value]);
|
| XCTAssertEqual(value, 801);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:13]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:14]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 700);
|
|
|
| const int32_t kKeys2[] = { 12, 13 };
|
| @@ -3313,17 +3313,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| XCTAssertNotNil(dict2);
|
| [dict addRawEntriesFromDictionary:dict2];
|
| XCTAssertEqual(dict.count, 4U);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:11]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:11]);
|
| + XCTAssertTrue([dict valueForKey:11 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:11 rawValue:&value]);
|
| XCTAssertEqual(value, 803);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:12]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:12]);
|
| + XCTAssertTrue([dict valueForKey:12 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:12 value:&value]);
|
| XCTAssertEqual(value, 702);
|
| - XCTAssertTrue([dict getRawValue:NULL forKey:13]);
|
| - XCTAssertTrue([dict getRawValue:&value forKey:13]);
|
| + XCTAssertTrue([dict valueForKey:13 rawValue:NULL]);
|
| + XCTAssertTrue([dict valueForKey:13 rawValue:&value]);
|
| XCTAssertEqual(value, 801);
|
| - XCTAssertTrue([dict getEnum:NULL forKey:14]);
|
| - XCTAssertTrue([dict getEnum:&value forKey:14]);
|
| + XCTAssertTrue([dict valueForKey:14 value:NULL]);
|
| + XCTAssertTrue([dict valueForKey:14 value:&value]);
|
| XCTAssertEqual(value, 700);
|
|
|
| [dict2 release];
|
| @@ -3559,8 +3559,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" };
|
| GPBInt32ObjectDictionary<NSString*> *dict =
|
| [[GPBInt32ObjectDictionary alloc] initWithObjects:kObjects
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kObjects)];
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kObjects)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
|
|
| @@ -3600,8 +3600,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
|
| const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" };
|
| GPBInt32ObjectDictionary<NSString*> *dict =
|
| [[GPBInt32ObjectDictionary alloc] initWithObjects:kObjects
|
| - forKeys:kKeys
|
| - count:GPBARRAYSIZE(kObjects)];
|
| + forKeys:kKeys
|
| + count:GPBARRAYSIZE(kObjects)];
|
| XCTAssertNotNil(dict);
|
| XCTAssertEqual(dict.count, 4U);
|
| XCTAssertEqualObjects([dict objectForKey:11], @"abc");
|
|
|
Chromium Code Reviews
Issue 2590803003:
Revert "third_party/protobuf: Update to HEAD (83d681ee2c)" (Closed)
