Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

[ObjC] Move from `#pragma unused()` to `_unused`

Browse Source
pull/10652/head
Thomas Van Lenten 2 years ago
parent f1a939fb69
commit 2fb33b8c54
18 changed files with 370 additions and 705 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 170
      objectivec/GPBCodedOutputStream.m
  2. 6
      objectivec/GPBDescriptor.m
  3. 343
      objectivec/GPBDictionary.m
  4. 16
      objectivec/GPBMessage.m
  5. 12
      objectivec/GPBRootObject.m
  6. 52
      objectivec/GPBUnknownField.m
  7. 18
      objectivec/GPBUnknownFieldSet.m
  8. 50
      objectivec/GPBUtilities.m
  9. 54
      objectivec/Tests/GPBArrayTests.m
  10. 48
      objectivec/Tests/GPBDictionaryTests+Bool.m
  11. 57
      objectivec/Tests/GPBDictionaryTests+Int32.m
  12. 57
      objectivec/Tests/GPBDictionaryTests+Int64.m
  13. 51
      objectivec/Tests/GPBDictionaryTests+String.m
  14. 57
      objectivec/Tests/GPBDictionaryTests+UInt32.m
  15. 57
      objectivec/Tests/GPBDictionaryTests+UInt64.m
  16. 15
      objectivec/Tests/GPBDictionaryTests.pddm
  17. 3
      objectivec/Tests/GPBMessageTests+Runtime.m
  18. 9
      objectivec/Tests/GPBMessageTests.m

170
objectivec/GPBCodedOutputStream.m
Unescape View File

@ -416,19 +416,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
//% if (tag != 0) {
//% if (values.count == 0) return;
//% __block size_t dataSize = 0;
//% [values enumerate##ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
//%#pragma unused(idx, stop)
//% [values enumerate##ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, __unused NSUInteger idx,__unused BOOL *stop) {
//% dataSize += GPBCompute##NAME##SizeNoTag(value);
//% }];
//% GPBWriteRawVarint32(&state_, tag);
//% GPBWriteRawVarint32(&state_, (int32_t)dataSize);
//% [values enumerate##ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
//%#pragma unused(idx, stop)
//% [values enumerate##ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, __unused NSUInteger idx, __unused BOOL *stop) {
//% [self write##NAME##NoTag:value];
//% }];
//% } else {
//% [values enumerate##ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
//%#pragma unused(idx, stop)
//% [values enumerate##ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, __unused NSUInteger idx, __unused BOOL *stop) {
//% [self write##NAME:fieldNumber value:value];
//% }];
//% }
@ -450,19 +447,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateValuesWithBlock:^(double value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(double value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeDoubleSizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateValuesWithBlock:^(double value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(double value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeDoubleNoTag:value];
}];
} else {
[values enumerateValuesWithBlock:^(double value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(double value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeDouble:fieldNumber value:value];
}];
}
@ -477,19 +471,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateValuesWithBlock:^(float value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(float value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeFloatSizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateValuesWithBlock:^(float value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(float value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeFloatNoTag:value];
}];
} else {
[values enumerateValuesWithBlock:^(float value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(float value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeFloat:fieldNumber value:value];
}];
}
@ -504,19 +495,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(uint64_t value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeUInt64SizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(uint64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeUInt64NoTag:value];
}];
} else {
[values enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(uint64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeUInt64:fieldNumber value:value];
}];
}
@ -531,19 +519,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int64_t value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeInt64SizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeInt64NoTag:value];
}];
} else {
[values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeInt64:fieldNumber value:value];
}];
}
@ -558,19 +543,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int32_t value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeInt32SizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeInt32NoTag:value];
}];
} else {
[values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeInt32:fieldNumber value:value];
}];
}
@ -585,19 +567,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(uint32_t value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeUInt32SizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(uint32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeUInt32NoTag:value];
}];
} else {
[values enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(uint32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeUInt32:fieldNumber value:value];
}];
}
@ -612,19 +591,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(uint64_t value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeFixed64SizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(uint64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeFixed64NoTag:value];
}];
} else {
[values enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(uint64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeFixed64:fieldNumber value:value];
}];
}
@ -639,19 +615,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(uint32_t value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeFixed32SizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(uint32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeFixed32NoTag:value];
}];
} else {
[values enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(uint32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeFixed32:fieldNumber value:value];
}];
}
@ -666,19 +639,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int32_t value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeSInt32SizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeSInt32NoTag:value];
}];
} else {
[values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeSInt32:fieldNumber value:value];
}];
}
@ -693,19 +663,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int64_t value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeSInt64SizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeSInt64NoTag:value];
}];
} else {
[values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeSInt64:fieldNumber value:value];
}];
}
@ -720,19 +687,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int64_t value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeSFixed64SizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeSFixed64NoTag:value];
}];
} else {
[values enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeSFixed64:fieldNumber value:value];
}];
}
@ -747,19 +711,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int32_t value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeSFixed32SizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeSFixed32NoTag:value];
}];
} else {
[values enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(int32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeSFixed32:fieldNumber value:value];
}];
}
@ -774,19 +735,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateValuesWithBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(BOOL value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeBoolSizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateValuesWithBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(BOOL value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeBoolNoTag:value];
}];
} else {
[values enumerateValuesWithBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateValuesWithBlock:^(BOOL value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeBool:fieldNumber value:value];
}];
}
@ -801,19 +759,16 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
if (tag != 0) {
if (values.count == 0) return;
__block size_t dataSize = 0;
[values enumerateRawValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateRawValuesWithBlock:^(int32_t value, __unused NSUInteger idx,__unused BOOL *stop) {
dataSize += GPBComputeEnumSizeNoTag(value);
}];
GPBWriteRawVarint32(&state_, tag);
GPBWriteRawVarint32(&state_, (int32_t)dataSize);
[values enumerateRawValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateRawValuesWithBlock:^(int32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeEnumNoTag:value];
}];
} else {
[values enumerateRawValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[values enumerateRawValuesWithBlock:^(int32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[self writeEnum:fieldNumber value:value];
}];
}
@ -964,15 +919,9 @@ static void GPBWriteRawLittleEndian64(GPBOutputBufferState *state, int64_t value
@end
size_t GPBComputeDoubleSizeNoTag(Float64 value) {
#pragma unused(value)
return LITTLE_ENDIAN_64_SIZE;
}
size_t GPBComputeDoubleSizeNoTag(__unused Float64 value) { return LITTLE_ENDIAN_64_SIZE; }
size_t GPBComputeFloatSizeNoTag(Float32 value) {
#pragma unused(value)
return LITTLE_ENDIAN_32_SIZE;
}
size_t GPBComputeFloatSizeNoTag(__unused Float32 value) { return LITTLE_ENDIAN_32_SIZE; }
size_t GPBComputeUInt64SizeNoTag(uint64_t value) { return GPBComputeRawVarint64Size(value); }
@ -991,20 +940,11 @@ size_t GPBComputeSizeTSizeAsInt32NoTag(size_t value) {
return GPBComputeInt32SizeNoTag((int32_t)value);
}
size_t GPBComputeFixed64SizeNoTag(uint64_t value) {
#pragma unused(value)
return LITTLE_ENDIAN_64_SIZE;
}
size_t GPBComputeFixed64SizeNoTag(__unused uint64_t value) { return LITTLE_ENDIAN_64_SIZE; }
size_t GPBComputeFixed32SizeNoTag(uint32_t value) {
#pragma unused(value)
return LITTLE_ENDIAN_32_SIZE;
}
size_t GPBComputeFixed32SizeNoTag(__unused uint32_t value) { return LITTLE_ENDIAN_32_SIZE; }
size_t GPBComputeBoolSizeNoTag(BOOL value) {
#pragma unused(value)
return 1;
}
size_t GPBComputeBoolSizeNoTag(__unused BOOL value) { return 1; }
size_t GPBComputeStringSizeNoTag(NSString *value) {
NSUInteger length = [value lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
@ -1029,15 +969,9 @@ size_t GPBComputeUInt32SizeNoTag(int32_t value) { return GPBComputeRawVarint32Si
size_t GPBComputeEnumSizeNoTag(int32_t value) { return GPBComputeInt32SizeNoTag(value); }
size_t GPBComputeSFixed32SizeNoTag(int32_t value) {
#pragma unused(value)
return LITTLE_ENDIAN_32_SIZE;
}
size_t GPBComputeSFixed32SizeNoTag(__unused int32_t value) { return LITTLE_ENDIAN_32_SIZE; }
size_t GPBComputeSFixed64SizeNoTag(int64_t value) {
#pragma unused(value)
return LITTLE_ENDIAN_64_SIZE;
}
size_t GPBComputeSFixed64SizeNoTag(__unused int64_t value) { return LITTLE_ENDIAN_64_SIZE; }
size_t GPBComputeSInt32SizeNoTag(int32_t value) {
return GPBComputeRawVarint32Size(GPBEncodeZigZag32(value));

6
objectivec/GPBDescriptor.m
Unescape View File

@ -296,8 +296,7 @@ static NSArray *NewFieldsArrayForHasIndex(int hasIndex, NSArray *allMessageField
return result;
}
- (id)copyWithZone:(NSZone *)zone {
#pragma unused(zone)
- (id)copyWithZone:(__unused NSZone *)zone {
return [self retain];
}
@ -997,8 +996,7 @@ uint32_t GPBFieldAlternateTag(GPBFieldDescriptor *self) {
[super dealloc];
}
- (instancetype)copyWithZone:(NSZone *)zone {
#pragma unused(zone)
- (instancetype)copyWithZone:(__unused NSZone *)zone {
// Immutable.
return [self retain];
}

343
objectivec/GPBDictionary.m
View File

File diff suppressed because it is too large Load Diff

16
objectivec/GPBMessage.m
Unescape View File

@ -953,13 +953,12 @@ static GPBUnknownFieldSet *GetOrMakeUnknownFields(GPBMessage *self) {
NSMutableDictionary *newDict =
[[NSMutableDictionary alloc] initWithCapacity:existingDict.count];
newValue = newDict;
[existingDict
enumerateKeysAndObjectsUsingBlock:^(NSString *key, GPBMessage *msg, BOOL *stop) {
#pragma unused(stop)
GPBMessage *copiedMsg = [msg copyWithZone:zone];
[newDict setObject:copiedMsg forKey:key];
[copiedMsg release];
}];
[existingDict enumerateKeysAndObjectsUsingBlock:^(NSString *key, GPBMessage *msg,
__unused BOOL *stop) {
GPBMessage *copiedMsg = [msg copyWithZone:zone];
[newDict setObject:copiedMsg forKey:key];
[copiedMsg release];
}];
} else {
// Is one of the GPB*ObjectDictionary classes. Type doesn't
// matter, just need one to invoke the selector.
@ -2909,8 +2908,7 @@ static void MergeRepeatedNotPackedFieldFromCodedInputStream(
#define CASE_REPEATED_POD_EXTRA(NAME, TYPE, ARRAY_TYPE, ARRAY_ACCESSOR_NAME) \
case GPBDataType##NAME: { \
GPB##ARRAY_TYPE##Array *array = genericArray; \
[array enumerate##ARRAY_ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) { \
_Pragma("unused(idx, stop)"); \
[array enumerate##ARRAY_ACCESSOR_NAME##ValuesWithBlock:^(TYPE value, __unused NSUInteger idx, __unused BOOL *stop) { \
dataSize += GPBCompute##NAME##SizeNoTag(value); \
}]; \
break; \

12
objectivec/GPBRootObject.m
Unescape View File

@ -73,15 +73,12 @@ static uint32_t jenkins_one_at_a_time_hash(const char *key) {
// to worry about deallocation. All of the items are added to it at
// startup, and so the keys don't need to be retained/released.
// Keys are NULL terminated char *.
static const void *GPBRootExtensionKeyRetain(CFAllocatorRef allocator, const void *value) {
#pragma unused(allocator)
static const void *GPBRootExtensionKeyRetain(__unused CFAllocatorRef allocator, const void *value) {
return value;
}
static void GPBRootExtensionKeyRelease(CFAllocatorRef allocator, const void *value) {
#pragma unused(allocator)
#pragma unused(value)
}
static void GPBRootExtensionKeyRelease(__unused CFAllocatorRef allocator,
__unused const void *value) {}
static CFStringRef GPBRootExtensionCopyKeyDescription(const void *value) {
const char *key = (const char *)value;
@ -207,8 +204,7 @@ BOOL GPBResolveExtensionClassMethod(Class self, SEL sel) {
if (extension != nil) {
const char *encoding = GPBMessageEncodingForSelector(@selector(getClassValue), NO);
Class metaClass = objc_getMetaClass(class_getName(self));
IMP imp = imp_implementationWithBlock(^(id obj) {
#pragma unused(obj)
IMP imp = imp_implementationWithBlock(^(__unused id obj) {
return extension;
});
BOOL methodAdded = class_addMethod(metaClass, sel, imp, encoding);

52
objectivec/GPBUnknownField.m
Unescape View File

@ -153,20 +153,20 @@
- (size_t)serializedSize {
__block size_t result = 0;
int32_t number = number_;
[mutableVarintList_ enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
result += GPBComputeUInt64Size(number, value);
}];
[mutableVarintList_
enumerateValuesWithBlock:^(uint64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
result += GPBComputeUInt64Size(number, value);
}];
[mutableFixed32List_ enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
result += GPBComputeFixed32Size(number, value);
}];
[mutableFixed32List_
enumerateValuesWithBlock:^(uint32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
result += GPBComputeFixed32Size(number, value);
}];
[mutableFixed64List_ enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
result += GPBComputeFixed64Size(number, value);
}];
[mutableFixed64List_
enumerateValuesWithBlock:^(uint64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
result += GPBComputeFixed64Size(number, value);
}];
for (NSData *data in mutableLengthDelimitedList_) {
result += GPBComputeBytesSize(number, data);
@ -196,20 +196,20 @@
- (NSString *)description {
NSMutableString *description =
[NSMutableString stringWithFormat:@"<%@ %p>: Field: %d {\n", [self class], self, number_];
[mutableVarintList_ enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[description appendFormat:@"\t%llu\n", value];
}];
[mutableFixed32List_ enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[description appendFormat:@"\t%u\n", value];
}];
[mutableFixed64List_ enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(idx, stop)
[description appendFormat:@"\t%llu\n", value];
}];
[mutableVarintList_
enumerateValuesWithBlock:^(uint64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[description appendFormat:@"\t%llu\n", value];
}];
[mutableFixed32List_
enumerateValuesWithBlock:^(uint32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[description appendFormat:@"\t%u\n", value];
}];
[mutableFixed64List_
enumerateValuesWithBlock:^(uint64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
[description appendFormat:@"\t%llu\n", value];
}];
for (NSData *data in mutableLengthDelimitedList_) {
[description appendFormat:@"\t%@\n", data];

18
objectivec/GPBUnknownFieldSet.m
Unescape View File

@ -49,8 +49,7 @@ static void checkNumber(int32_t number) {
CFMutableDictionaryRef fields_;
}
static void CopyWorker(const void *key, const void *value, void *context) {
#pragma unused(key)
static void CopyWorker(__unused const void *key, const void *value, void *context) {
GPBUnknownField *field = value;
GPBUnknownFieldSet *result = context;
@ -184,8 +183,8 @@ static void CopyWorker(const void *key, const void *value, void *context) {
return description;
}
static void GPBUnknownFieldSetSerializedSize(const void *key, const void *value, void *context) {
#pragma unused(key)
static void GPBUnknownFieldSetSerializedSize(__unused const void *key, const void *value,
void *context) {
GPBUnknownField *field = value;
size_t *result = context;
*result += [field serializedSize];
@ -199,9 +198,8 @@ static void GPBUnknownFieldSetSerializedSize(const void *key, const void *value,
return result;
}
static void GPBUnknownFieldSetWriteAsMessageSetTo(const void *key, const void *value,
static void GPBUnknownFieldSetWriteAsMessageSetTo(__unused const void *key, const void *value,
void *context) {
#pragma unused(key)
GPBUnknownField *field = value;
GPBCodedOutputStream *output = context;
[field writeAsMessageSetExtensionToOutput:output];
@ -213,9 +211,8 @@ static void GPBUnknownFieldSetWriteAsMessageSetTo(const void *key, const void *v
}
}
static void GPBUnknownFieldSetSerializedSizeAsMessageSet(const void *key, const void *value,
void *context) {
#pragma unused(key)
static void GPBUnknownFieldSetSerializedSizeAsMessageSet(__unused const void *key,
const void *value, void *context) {
GPBUnknownField *field = value;
size_t *result = context;
*result += [field serializedSizeAsMessageSetExtension];
@ -266,9 +263,8 @@ static void GPBUnknownFieldSetSerializedSizeAsMessageSet(const void *key, const
return existing;
}
static void GPBUnknownFieldSetMergeUnknownFields(const void *key, const void *value,
static void GPBUnknownFieldSetMergeUnknownFields(__unused const void *key, const void *value,
void *context) {
#pragma unused(key)
GPBUnknownField *field = value;
GPBUnknownFieldSet *self = context;

50
objectivec/GPBUtilities.m
Unescape View File

@ -115,18 +115,16 @@ void GPBMessageDropUnknownFieldsRecursively(GPBMessage *initialMessage) {
switch (field.mapKeyDataType) {
case GPBDataTypeBool:
[(GPBBoolObjectDictionary *)rawFieldMap
enumerateKeysAndObjectsUsingBlock:^(BOOL key, id _Nonnull object,
BOOL *_Nonnull stop) {
#pragma unused(key, stop)
enumerateKeysAndObjectsUsingBlock:^(__unused BOOL key, id _Nonnull object,
__unused BOOL *_Nonnull stop) {
[todo addObject:object];
}];
break;
case GPBDataTypeFixed32:
case GPBDataTypeUInt32:
[(GPBUInt32ObjectDictionary *)rawFieldMap
enumerateKeysAndObjectsUsingBlock:^(uint32_t key, id _Nonnull object,
BOOL *_Nonnull stop) {
#pragma unused(key, stop)
enumerateKeysAndObjectsUsingBlock:^(__unused uint32_t key, id _Nonnull object,
__unused BOOL *_Nonnull stop) {
[todo addObject:object];
}];
break;
@ -134,18 +132,16 @@ void GPBMessageDropUnknownFieldsRecursively(GPBMessage *initialMessage) {
case GPBDataTypeSFixed32:
case GPBDataTypeSInt32:
[(GPBInt32ObjectDictionary *)rawFieldMap
enumerateKeysAndObjectsUsingBlock:^(int32_t key, id _Nonnull object,
BOOL *_Nonnull stop) {
#pragma unused(key, stop)
enumerateKeysAndObjectsUsingBlock:^(__unused int32_t key, id _Nonnull object,
__unused BOOL *_Nonnull stop) {
[todo addObject:object];
}];
break;
case GPBDataTypeFixed64:
case GPBDataTypeUInt64:
[(GPBUInt64ObjectDictionary *)rawFieldMap
enumerateKeysAndObjectsUsingBlock:^(uint64_t key, id _Nonnull object,
BOOL *_Nonnull stop) {
#pragma unused(key, stop)
enumerateKeysAndObjectsUsingBlock:^(__unused uint64_t key, id _Nonnull object,
__unused BOOL *_Nonnull stop) {
[todo addObject:object];
}];
break;
@ -153,17 +149,16 @@ void GPBMessageDropUnknownFieldsRecursively(GPBMessage *initialMessage) {
case GPBDataTypeSFixed64:
case GPBDataTypeSInt64:
[(GPBInt64ObjectDictionary *)rawFieldMap
enumerateKeysAndObjectsUsingBlock:^(int64_t key, id _Nonnull object,
BOOL *_Nonnull stop) {
#pragma unused(key, stop)
enumerateKeysAndObjectsUsingBlock:^(__unused int64_t key, id _Nonnull object,
__unused BOOL *_Nonnull stop) {
[todo addObject:object];
}];
break;
case GPBDataTypeString:
[(NSDictionary *)rawFieldMap
enumerateKeysAndObjectsUsingBlock:^(
NSString *_Nonnull key, GPBMessage *_Nonnull obj, BOOL *_Nonnull stop) {
#pragma unused(key, stop)
enumerateKeysAndObjectsUsingBlock:^(__unused NSString *_Nonnull key,
GPBMessage *_Nonnull obj,
__unused BOOL *_Nonnull stop) {
[todo addObject:obj];
}];
break;
@ -1604,8 +1599,7 @@ static void AppendTextFormatForMapMessageField(id map, GPBFieldDescriptor *field
if ((keyDataType == GPBDataTypeString) && GPBDataTypeIsObject(valueDataType)) {
// map is an NSDictionary.
NSDictionary *dict = map;
[dict enumerateKeysAndObjectsUsingBlock:^(NSString *key, id value, BOOL *stop) {
#pragma unused(stop)
[dict enumerateKeysAndObjectsUsingBlock:^(NSString *key, id value, __unused BOOL *stop) {
[toStr appendString:(isFirst ? msgStartFirst : msgStart)];
isFirst = NO;
@ -1997,11 +1991,11 @@ NSString *GPBTextFormatForUnknownFieldSet(GPBUnknownFieldSet *unknownSet, NSStri
for (GPBUnknownField *field in [unknownSet sortedFields]) {
int32_t fieldNumber = [field number];
#define PRINT_LOOP(PROPNAME, CTYPE, FORMAT) \
[field.PROPNAME enumerateValuesWithBlock:^(CTYPE value, NSUInteger idx, BOOL * stop) { \
_Pragma("unused(idx, stop)"); \
[result appendFormat:@"%@%d: " FORMAT "\n", lineIndent, fieldNumber, value]; \
}];
#define PRINT_LOOP(PROPNAME, CTYPE, FORMAT) \
[field.PROPNAME \
enumerateValuesWithBlock:^(CTYPE value, __unused NSUInteger idx, __unused BOOL * stop) { \
[result appendFormat:@"%@%d: " FORMAT "\n", lineIndent, fieldNumber, value]; \
}];
PRINT_LOOP(varintList, uint64_t, "%llu");
PRINT_LOOP(fixed32List, uint32_t, "0x%X");
@ -2180,14 +2174,12 @@ NSString *GPBDecodeTextFormatName(const uint8_t *decodeData, int32_t key, NSStri
// Shim from the older generated code into the runtime.
void GPBSetInt32IvarWithFieldInternal(GPBMessage *self, GPBFieldDescriptor *field, int32_t value,
GPBFileSyntax syntax) {
#pragma unused(syntax)
__unused GPBFileSyntax syntax) {
GPBSetMessageInt32Field(self, field, value);
}
void GPBMaybeClearOneof(GPBMessage *self, GPBOneofDescriptor *oneof, int32_t oneofHasIndex,
uint32_t fieldNumberNotToClear) {
#pragma unused(fieldNumberNotToClear)
__unused uint32_t fieldNumberNotToClear) {
#if defined(DEBUG) && DEBUG
NSCAssert([[self descriptor] oneofWithName:oneof.name] == oneof,
@"OneofDescriptor %@ doesn't appear to be for %@ messages.", oneof.name, [self class]);

54
objectivec/Tests/GPBArrayTests.m
Unescape View File

@ -101,13 +101,11 @@ static BOOL TestingEnum_IsValidValue2(int32_t value) {
//% XCTAssertNotNil(array);
//% XCTAssertEqual(array.count, 0U);
//% XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
//% [array enumerateValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
//% #pragma unused(value, idx, stop)
//% [array enumerateValuesWithBlock:^(__unused TYPE value, __unused NSUInteger idx, __unused BOOL *stop) {
//% XCTFail(@"Shouldn't get here!");
//% }];
//% [array enumerateValuesWithOptions:NSEnumerationReverse
//% usingBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
//% #pragma unused(value, idx, stop)
//% usingBlock:^(__unused TYPE value, __unused NSUInteger idx, __unused BOOL *stop) {
//% XCTFail(@"Shouldn't get here!");
//% }];
//% [array release];
@ -445,13 +443,11 @@ static BOOL TestingEnum_IsValidValue2(int32_t value) {
XCTAssertNotNil(array);
XCTAssertEqual(array.count, 0U);
XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
[array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
[array enumerateValuesWithBlock:^(__unused int32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array enumerateValuesWithOptions:NSEnumerationReverse
usingBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
usingBlock:^(__unused int32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array release];
@ -789,13 +785,11 @@ static BOOL TestingEnum_IsValidValue2(int32_t value) {
XCTAssertNotNil(array);
XCTAssertEqual(array.count, 0U);
XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
[array enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
[array enumerateValuesWithBlock:^(__unused uint32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array enumerateValuesWithOptions:NSEnumerationReverse
usingBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
usingBlock:^(__unused uint32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array release];
@ -1133,13 +1127,11 @@ static BOOL TestingEnum_IsValidValue2(int32_t value) {
XCTAssertNotNil(array);
XCTAssertEqual(array.count, 0U);
XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
[array enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
[array enumerateValuesWithBlock:^(__unused int64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array enumerateValuesWithOptions:NSEnumerationReverse
usingBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
usingBlock:^(__unused int64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array release];
@ -1477,13 +1469,11 @@ static BOOL TestingEnum_IsValidValue2(int32_t value) {
XCTAssertNotNil(array);
XCTAssertEqual(array.count, 0U);
XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
[array enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
[array enumerateValuesWithBlock:^(__unused uint64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array enumerateValuesWithOptions:NSEnumerationReverse
usingBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
usingBlock:^(__unused uint64_t value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array release];
@ -1821,13 +1811,11 @@ static BOOL TestingEnum_IsValidValue2(int32_t value) {
XCTAssertNotNil(array);
XCTAssertEqual(array.count, 0U);
XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
[array enumerateValuesWithBlock:^(float value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
[array enumerateValuesWithBlock:^(__unused float value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array enumerateValuesWithOptions:NSEnumerationReverse
usingBlock:^(float value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
usingBlock:^(__unused float value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array release];
@ -2165,13 +2153,11 @@ static BOOL TestingEnum_IsValidValue2(int32_t value) {
XCTAssertNotNil(array);
XCTAssertEqual(array.count, 0U);
XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
[array enumerateValuesWithBlock:^(double value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
[array enumerateValuesWithBlock:^(__unused double value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array enumerateValuesWithOptions:NSEnumerationReverse
usingBlock:^(double value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
usingBlock:^(__unused double value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array release];
@ -2509,13 +2495,11 @@ static BOOL TestingEnum_IsValidValue2(int32_t value) {
XCTAssertNotNil(array);
XCTAssertEqual(array.count, 0U);
XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
[array enumerateValuesWithBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
[array enumerateValuesWithBlock:^(__unused BOOL value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array enumerateValuesWithOptions:NSEnumerationReverse
usingBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
usingBlock:^(__unused BOOL value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array release];
@ -2853,13 +2837,11 @@ static BOOL TestingEnum_IsValidValue2(int32_t value) {
XCTAssertNotNil(array);
XCTAssertEqual(array.count, 0U);
XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
[array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
[array enumerateValuesWithBlock:^(__unused int32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array enumerateValuesWithOptions:NSEnumerationReverse
usingBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
#pragma unused(value, idx, stop)
usingBlock:^(__unused int32_t value, __unused NSUInteger idx, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[array release];

48
objectivec/Tests/GPBDictionaryTests+Bool.m
Unescape View File

@ -58,8 +58,7 @@
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getUInt32:NULL forKey:YES]);
[dict enumerateKeysAndUInt32sUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndUInt32sUsingBlock:^(__unused BOOL aKey, __unused uint32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -125,8 +124,7 @@
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndUInt32sUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndUInt32sUsingBlock:^(__unused BOOL aKey, __unused uint32_t aValue, BOOL *stop) {
if (idx == 0) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -363,8 +361,7 @@
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getInt32:NULL forKey:YES]);
[dict enumerateKeysAndInt32sUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndInt32sUsingBlock:^(__unused BOOL aKey, __unused int32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -430,8 +427,7 @@
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndInt32sUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndInt32sUsingBlock:^(__unused BOOL aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 0) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -668,8 +664,7 @@
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getUInt64:NULL forKey:YES]);
[dict enumerateKeysAndUInt64sUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndUInt64sUsingBlock:^(__unused BOOL aKey, __unused uint64_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -735,8 +730,7 @@
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndUInt64sUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndUInt64sUsingBlock:^(__unused BOOL aKey, __unused uint64_t aValue, BOOL *stop) {
if (idx == 0) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -973,8 +967,7 @@
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getInt64:NULL forKey:YES]);
[dict enumerateKeysAndInt64sUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndInt64sUsingBlock:^(__unused BOOL aKey, __unused int64_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1040,8 +1033,7 @@
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndInt64sUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndInt64sUsingBlock:^(__unused BOOL aKey, __unused int64_t aValue, BOOL *stop) {
if (idx == 0) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1278,8 +1270,7 @@
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getBool:NULL forKey:YES]);
[dict enumerateKeysAndBoolsUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndBoolsUsingBlock:^(__unused BOOL aKey, __unused BOOL aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1345,8 +1336,7 @@
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndBoolsUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndBoolsUsingBlock:^(__unused BOOL aKey, __unused BOOL aValue, BOOL *stop) {
if (idx == 0) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1583,8 +1573,7 @@
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getFloat:NULL forKey:YES]);
[dict enumerateKeysAndFloatsUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndFloatsUsingBlock:^(__unused BOOL aKey, __unused float aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1650,8 +1639,7 @@
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndFloatsUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndFloatsUsingBlock:^(__unused BOOL aKey, __unused float aValue, BOOL *stop) {
if (idx == 0) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1888,8 +1876,7 @@
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getDouble:NULL forKey:YES]);
[dict enumerateKeysAndDoublesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndDoublesUsingBlock:^(__unused BOOL aKey, __unused double aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1955,8 +1942,7 @@
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndDoublesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndDoublesUsingBlock:^(__unused BOOL aKey, __unused double aValue, BOOL *stop) {
if (idx == 0) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -2193,8 +2179,7 @@
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertNil([dict objectForKey:YES]);
[dict enumerateKeysAndObjectsUsingBlock:^(BOOL aKey, NSString* aObject, BOOL *stop) {
#pragma unused(aKey, aObject, stop)
[dict enumerateKeysAndObjectsUsingBlock:^(__unused BOOL aKey, __unused NSString* aObject, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -2252,8 +2237,7 @@
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndObjectsUsingBlock:^(BOOL aKey, NSString* aObject, BOOL *stop) {
#pragma unused(aKey, aObject)
[dict enumerateKeysAndObjectsUsingBlock:^(__unused BOOL aKey, __unused NSString* aObject, BOOL *stop) {
if (idx == 0) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;

57
objectivec/Tests/GPBDictionaryTests+Int32.m
Unescape View File

@ -89,8 +89,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getUInt32:NULL forKey:11]);
[dict enumerateKeysAndUInt32sUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndUInt32sUsingBlock:^(__unused int32_t aKey, __unused uint32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -160,8 +159,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndUInt32sUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndUInt32sUsingBlock:^(__unused int32_t aKey, __unused uint32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -450,8 +448,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getInt32:NULL forKey:11]);
[dict enumerateKeysAndInt32sUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndInt32sUsingBlock:^(__unused int32_t aKey, __unused int32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -521,8 +518,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndInt32sUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndInt32sUsingBlock:^(__unused int32_t aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -811,8 +807,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getUInt64:NULL forKey:11]);
[dict enumerateKeysAndUInt64sUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndUInt64sUsingBlock:^(__unused int32_t aKey, __unused uint64_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -882,8 +877,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndUInt64sUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndUInt64sUsingBlock:^(__unused int32_t aKey, __unused uint64_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1172,8 +1166,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getInt64:NULL forKey:11]);
[dict enumerateKeysAndInt64sUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndInt64sUsingBlock:^(__unused int32_t aKey, __unused int64_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1243,8 +1236,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndInt64sUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndInt64sUsingBlock:^(__unused int32_t aKey, __unused int64_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1533,8 +1525,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getBool:NULL forKey:11]);
[dict enumerateKeysAndBoolsUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndBoolsUsingBlock:^(__unused int32_t aKey, __unused BOOL aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1604,8 +1595,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndBoolsUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndBoolsUsingBlock:^(__unused int32_t aKey, __unused BOOL aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1894,8 +1884,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getFloat:NULL forKey:11]);
[dict enumerateKeysAndFloatsUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndFloatsUsingBlock:^(__unused int32_t aKey, __unused float aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1965,8 +1954,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndFloatsUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndFloatsUsingBlock:^(__unused int32_t aKey, __unused float aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -2255,8 +2243,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getDouble:NULL forKey:11]);
[dict enumerateKeysAndDoublesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndDoublesUsingBlock:^(__unused int32_t aKey, __unused double aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -2326,8 +2313,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndDoublesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndDoublesUsingBlock:^(__unused int32_t aKey, __unused double aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -2616,8 +2602,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getEnum:NULL forKey:11]);
[dict enumerateKeysAndEnumsUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndEnumsUsingBlock:^(__unused int32_t aKey, __unused int32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -2687,8 +2672,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndEnumsUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndEnumsUsingBlock:^(__unused int32_t aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -3045,8 +3029,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndRawValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndRawValuesUsingBlock:^(__unused int32_t aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -3395,8 +3378,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertNil([dict objectForKey:11]);
[dict enumerateKeysAndObjectsUsingBlock:^(int32_t aKey, NSString* aObject, BOOL *stop) {
#pragma unused(aKey, aObject, stop)
[dict enumerateKeysAndObjectsUsingBlock:^(__unused int32_t aKey, __unused NSString* aObject, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -3456,8 +3438,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndObjectsUsingBlock:^(int32_t aKey, NSString* aObject, BOOL *stop) {
#pragma unused(aKey, aObject)
[dict enumerateKeysAndObjectsUsingBlock:^(__unused int32_t aKey, __unused NSString* aObject, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;

57
objectivec/Tests/GPBDictionaryTests+Int64.m
Unescape View File

@ -89,8 +89,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getUInt32:NULL forKey:21LL]);
[dict enumerateKeysAndUInt32sUsingBlock:^(int64_t aKey, uint32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndUInt32sUsingBlock:^(__unused int64_t aKey, __unused uint32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -160,8 +159,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndUInt32sUsingBlock:^(int64_t aKey, uint32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndUInt32sUsingBlock:^(__unused int64_t aKey, __unused uint32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -450,8 +448,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getInt32:NULL forKey:21LL]);
[dict enumerateKeysAndInt32sUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndInt32sUsingBlock:^(__unused int64_t aKey, __unused int32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -521,8 +518,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndInt32sUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndInt32sUsingBlock:^(__unused int64_t aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -811,8 +807,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getUInt64:NULL forKey:21LL]);
[dict enumerateKeysAndUInt64sUsingBlock:^(int64_t aKey, uint64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndUInt64sUsingBlock:^(__unused int64_t aKey, __unused uint64_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -882,8 +877,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndUInt64sUsingBlock:^(int64_t aKey, uint64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndUInt64sUsingBlock:^(__unused int64_t aKey, __unused uint64_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1172,8 +1166,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getInt64:NULL forKey:21LL]);
[dict enumerateKeysAndInt64sUsingBlock:^(int64_t aKey, int64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndInt64sUsingBlock:^(__unused int64_t aKey, __unused int64_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1243,8 +1236,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndInt64sUsingBlock:^(int64_t aKey, int64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndInt64sUsingBlock:^(__unused int64_t aKey, __unused int64_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1533,8 +1525,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getBool:NULL forKey:21LL]);
[dict enumerateKeysAndBoolsUsingBlock:^(int64_t aKey, BOOL aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndBoolsUsingBlock:^(__unused int64_t aKey, __unused BOOL aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1604,8 +1595,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndBoolsUsingBlock:^(int64_t aKey, BOOL aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndBoolsUsingBlock:^(__unused int64_t aKey, __unused BOOL aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1894,8 +1884,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getFloat:NULL forKey:21LL]);
[dict enumerateKeysAndFloatsUsingBlock:^(int64_t aKey, float aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndFloatsUsingBlock:^(__unused int64_t aKey, __unused float aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1965,8 +1954,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndFloatsUsingBlock:^(int64_t aKey, float aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndFloatsUsingBlock:^(__unused int64_t aKey, __unused float aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -2255,8 +2243,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getDouble:NULL forKey:21LL]);
[dict enumerateKeysAndDoublesUsingBlock:^(int64_t aKey, double aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndDoublesUsingBlock:^(__unused int64_t aKey, __unused double aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -2326,8 +2313,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndDoublesUsingBlock:^(int64_t aKey, double aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndDoublesUsingBlock:^(__unused int64_t aKey, __unused double aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -2616,8 +2602,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getEnum:NULL forKey:21LL]);
[dict enumerateKeysAndEnumsUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndEnumsUsingBlock:^(__unused int64_t aKey, __unused int32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -2687,8 +2672,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndEnumsUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndEnumsUsingBlock:^(__unused int64_t aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -3045,8 +3029,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndRawValuesUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndRawValuesUsingBlock:^(__unused int64_t aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -3395,8 +3378,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertNil([dict objectForKey:21LL]);
[dict enumerateKeysAndObjectsUsingBlock:^(int64_t aKey, NSString* aObject, BOOL *stop) {
#pragma unused(aKey, aObject, stop)
[dict enumerateKeysAndObjectsUsingBlock:^(__unused int64_t aKey, __unused NSString* aObject, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -3456,8 +3438,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndObjectsUsingBlock:^(int64_t aKey, NSString* aObject, BOOL *stop) {
#pragma unused(aKey, aObject)
[dict enumerateKeysAndObjectsUsingBlock:^(__unused int64_t aKey, __unused NSString* aObject, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;

51
objectivec/Tests/GPBDictionaryTests+String.m
Unescape View File

@ -89,8 +89,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getUInt32:NULL forKey:@"foo"]);
[dict enumerateKeysAndUInt32sUsingBlock:^(NSString *aKey, uint32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndUInt32sUsingBlock:^(__unused NSString *aKey, __unused uint32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -160,8 +159,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndUInt32sUsingBlock:^(NSString *aKey, uint32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndUInt32sUsingBlock:^(__unused NSString *aKey, __unused uint32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -450,8 +448,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getInt32:NULL forKey:@"foo"]);
[dict enumerateKeysAndInt32sUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndInt32sUsingBlock:^(__unused NSString *aKey, __unused int32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -521,8 +518,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndInt32sUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndInt32sUsingBlock:^(__unused NSString *aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -811,8 +807,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getUInt64:NULL forKey:@"foo"]);
[dict enumerateKeysAndUInt64sUsingBlock:^(NSString *aKey, uint64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndUInt64sUsingBlock:^(__unused NSString *aKey, __unused uint64_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -882,8 +877,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndUInt64sUsingBlock:^(NSString *aKey, uint64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndUInt64sUsingBlock:^(__unused NSString *aKey, __unused uint64_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1172,8 +1166,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getInt64:NULL forKey:@"foo"]);
[dict enumerateKeysAndInt64sUsingBlock:^(NSString *aKey, int64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndInt64sUsingBlock:^(__unused NSString *aKey, __unused int64_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1243,8 +1236,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndInt64sUsingBlock:^(NSString *aKey, int64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndInt64sUsingBlock:^(__unused NSString *aKey, __unused int64_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1533,8 +1525,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getBool:NULL forKey:@"foo"]);
[dict enumerateKeysAndBoolsUsingBlock:^(NSString *aKey, BOOL aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndBoolsUsingBlock:^(__unused NSString *aKey, __unused BOOL aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1604,8 +1595,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndBoolsUsingBlock:^(NSString *aKey, BOOL aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndBoolsUsingBlock:^(__unused NSString *aKey, __unused BOOL aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1894,8 +1884,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getFloat:NULL forKey:@"foo"]);
[dict enumerateKeysAndFloatsUsingBlock:^(NSString *aKey, float aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndFloatsUsingBlock:^(__unused NSString *aKey, __unused float aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1965,8 +1954,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndFloatsUsingBlock:^(NSString *aKey, float aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndFloatsUsingBlock:^(__unused NSString *aKey, __unused float aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -2255,8 +2243,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getDouble:NULL forKey:@"foo"]);
[dict enumerateKeysAndDoublesUsingBlock:^(NSString *aKey, double aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndDoublesUsingBlock:^(__unused NSString *aKey, __unused double aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -2326,8 +2313,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndDoublesUsingBlock:^(NSString *aKey, double aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndDoublesUsingBlock:^(__unused NSString *aKey, __unused double aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -2616,8 +2602,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getEnum:NULL forKey:@"foo"]);
[dict enumerateKeysAndEnumsUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndEnumsUsingBlock:^(__unused NSString *aKey, __unused int32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -2687,8 +2672,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndEnumsUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndEnumsUsingBlock:^(__unused NSString *aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -3045,8 +3029,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndRawValuesUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndRawValuesUsingBlock:^(__unused NSString *aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;

57
objectivec/Tests/GPBDictionaryTests+UInt32.m
Unescape View File

@ -89,8 +89,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getUInt32:NULL forKey:1U]);
[dict enumerateKeysAndUInt32sUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndUInt32sUsingBlock:^(__unused uint32_t aKey, __unused uint32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -160,8 +159,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndUInt32sUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndUInt32sUsingBlock:^(__unused uint32_t aKey, __unused uint32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -450,8 +448,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getInt32:NULL forKey:1U]);
[dict enumerateKeysAndInt32sUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndInt32sUsingBlock:^(__unused uint32_t aKey, __unused int32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -521,8 +518,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndInt32sUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndInt32sUsingBlock:^(__unused uint32_t aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -811,8 +807,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getUInt64:NULL forKey:1U]);
[dict enumerateKeysAndUInt64sUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndUInt64sUsingBlock:^(__unused uint32_t aKey, __unused uint64_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -882,8 +877,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndUInt64sUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndUInt64sUsingBlock:^(__unused uint32_t aKey, __unused uint64_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1172,8 +1166,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getInt64:NULL forKey:1U]);
[dict enumerateKeysAndInt64sUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndInt64sUsingBlock:^(__unused uint32_t aKey, __unused int64_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1243,8 +1236,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndInt64sUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndInt64sUsingBlock:^(__unused uint32_t aKey, __unused int64_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1533,8 +1525,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getBool:NULL forKey:1U]);
[dict enumerateKeysAndBoolsUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndBoolsUsingBlock:^(__unused uint32_t aKey, __unused BOOL aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1604,8 +1595,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndBoolsUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndBoolsUsingBlock:^(__unused uint32_t aKey, __unused BOOL aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1894,8 +1884,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getFloat:NULL forKey:1U]);
[dict enumerateKeysAndFloatsUsingBlock:^(uint32_t aKey, float aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndFloatsUsingBlock:^(__unused uint32_t aKey, __unused float aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1965,8 +1954,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndFloatsUsingBlock:^(uint32_t aKey, float aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndFloatsUsingBlock:^(__unused uint32_t aKey, __unused float aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -2255,8 +2243,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getDouble:NULL forKey:1U]);
[dict enumerateKeysAndDoublesUsingBlock:^(uint32_t aKey, double aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndDoublesUsingBlock:^(__unused uint32_t aKey, __unused double aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -2326,8 +2313,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndDoublesUsingBlock:^(uint32_t aKey, double aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndDoublesUsingBlock:^(__unused uint32_t aKey, __unused double aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -2616,8 +2602,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getEnum:NULL forKey:1U]);
[dict enumerateKeysAndEnumsUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndEnumsUsingBlock:^(__unused uint32_t aKey, __unused int32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -2687,8 +2672,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndEnumsUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndEnumsUsingBlock:^(__unused uint32_t aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -3045,8 +3029,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndRawValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndRawValuesUsingBlock:^(__unused uint32_t aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -3395,8 +3378,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertNil([dict objectForKey:1U]);
[dict enumerateKeysAndObjectsUsingBlock:^(uint32_t aKey, NSString* aObject, BOOL *stop) {
#pragma unused(aKey, aObject, stop)
[dict enumerateKeysAndObjectsUsingBlock:^(__unused uint32_t aKey, __unused NSString* aObject, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -3456,8 +3438,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndObjectsUsingBlock:^(uint32_t aKey, NSString* aObject, BOOL *stop) {
#pragma unused(aKey, aObject)
[dict enumerateKeysAndObjectsUsingBlock:^(__unused uint32_t aKey, __unused NSString* aObject, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;

57
objectivec/Tests/GPBDictionaryTests+UInt64.m
Unescape View File

@ -89,8 +89,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getUInt32:NULL forKey:31ULL]);
[dict enumerateKeysAndUInt32sUsingBlock:^(uint64_t aKey, uint32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndUInt32sUsingBlock:^(__unused uint64_t aKey, __unused uint32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -160,8 +159,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndUInt32sUsingBlock:^(uint64_t aKey, uint32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndUInt32sUsingBlock:^(__unused uint64_t aKey, __unused uint32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -450,8 +448,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getInt32:NULL forKey:31ULL]);
[dict enumerateKeysAndInt32sUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndInt32sUsingBlock:^(__unused uint64_t aKey, __unused int32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -521,8 +518,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndInt32sUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndInt32sUsingBlock:^(__unused uint64_t aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -811,8 +807,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getUInt64:NULL forKey:31ULL]);
[dict enumerateKeysAndUInt64sUsingBlock:^(uint64_t aKey, uint64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndUInt64sUsingBlock:^(__unused uint64_t aKey, __unused uint64_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -882,8 +877,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndUInt64sUsingBlock:^(uint64_t aKey, uint64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndUInt64sUsingBlock:^(__unused uint64_t aKey, __unused uint64_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1172,8 +1166,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getInt64:NULL forKey:31ULL]);
[dict enumerateKeysAndInt64sUsingBlock:^(uint64_t aKey, int64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndInt64sUsingBlock:^(__unused uint64_t aKey, __unused int64_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1243,8 +1236,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndInt64sUsingBlock:^(uint64_t aKey, int64_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndInt64sUsingBlock:^(__unused uint64_t aKey, __unused int64_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1533,8 +1525,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getBool:NULL forKey:31ULL]);
[dict enumerateKeysAndBoolsUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndBoolsUsingBlock:^(__unused uint64_t aKey, __unused BOOL aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1604,8 +1595,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndBoolsUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndBoolsUsingBlock:^(__unused uint64_t aKey, __unused BOOL aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -1894,8 +1884,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getFloat:NULL forKey:31ULL]);
[dict enumerateKeysAndFloatsUsingBlock:^(uint64_t aKey, float aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndFloatsUsingBlock:^(__unused uint64_t aKey, __unused float aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -1965,8 +1954,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndFloatsUsingBlock:^(uint64_t aKey, float aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndFloatsUsingBlock:^(__unused uint64_t aKey, __unused float aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -2255,8 +2243,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getDouble:NULL forKey:31ULL]);
[dict enumerateKeysAndDoublesUsingBlock:^(uint64_t aKey, double aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndDoublesUsingBlock:^(__unused uint64_t aKey, __unused double aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -2326,8 +2313,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndDoublesUsingBlock:^(uint64_t aKey, double aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndDoublesUsingBlock:^(__unused uint64_t aKey, __unused double aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -2616,8 +2602,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertFalse([dict getEnum:NULL forKey:31ULL]);
[dict enumerateKeysAndEnumsUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue, stop)
[dict enumerateKeysAndEnumsUsingBlock:^(__unused uint64_t aKey, __unused int32_t aValue, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -2687,8 +2672,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndEnumsUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndEnumsUsingBlock:^(__unused uint64_t aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -3045,8 +3029,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndRawValuesUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) {
#pragma unused(aKey, aValue)
[dict enumerateKeysAndRawValuesUsingBlock:^(__unused uint64_t aKey, __unused int32_t aValue, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;
@ -3395,8 +3378,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
XCTAssertNotNil(dict);
XCTAssertEqual(dict.count, 0U);
XCTAssertNil([dict objectForKey:31ULL]);
[dict enumerateKeysAndObjectsUsingBlock:^(uint64_t aKey, NSString* aObject, BOOL *stop) {
#pragma unused(aKey, aObject, stop)
[dict enumerateKeysAndObjectsUsingBlock:^(__unused uint64_t aKey, __unused NSString* aObject, __unused BOOL *stop) {
XCTFail(@"Shouldn't get here!");
}];
[dict release];
@ -3456,8 +3438,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) {
// Stopping the enumeration.
idx = 0;
[dict enumerateKeysAndObjectsUsingBlock:^(uint64_t aKey, NSString* aObject, BOOL *stop) {
#pragma unused(aKey, aObject)
[dict enumerateKeysAndObjectsUsingBlock:^(__unused uint64_t aKey, __unused NSString* aObject, BOOL *stop) {
if (idx == 1) *stop = YES;
XCTAssertNotEqual(idx, 2U);
++idx;

15
objectivec/Tests/GPBDictionaryTests.pddm
Unescape View File

@ -70,8 +70,7 @@
//% XCTAssertNotNil(dict);
//% XCTAssertEqual(dict.count, 0U);
//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY1)
//% [dict enumerateKeysAnd##VALUE_NAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u, BOOL *stop) {
//% #pragma unused(aKey, a##VNAME$u, stop)
//% [dict enumerateKeysAnd##VALUE_NAME$u##sUsingBlock:^(__unused KEY_TYPE KisP##aKey, __unused VALUE_TYPE a##VNAME$u, __unused BOOL *stop) {
//% XCTFail(@"Shouldn't get here!");
//% }];
//% [dict release];
@ -131,8 +130,7 @@
//%
//% // Stopping the enumeration.
//% idx = 0;
//% [dict enumerateKeysAnd##VALUE_NAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u, BOOL *stop) {
//% #pragma unused(aKey, a##VNAME$u)
//% [dict enumerateKeysAnd##VALUE_NAME$u##sUsingBlock:^(__unused KEY_TYPE KisP##aKey, __unused VALUE_TYPE a##VNAME$u, BOOL *stop) {
//% if (idx == 1) *stop = YES;
//% XCTAssertNotEqual(idx, 2U);
//% ++idx;
@ -425,8 +423,7 @@
//%
//% // Stopping the enumeration.
//% idx = 0;
//% [dict enumerateKeysAndRawValuesUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE aValue, BOOL *stop) {
//% #pragma unused(aKey, aValue)
//% [dict enumerateKeysAndRawValuesUsingBlock:^(__unused KEY_TYPE KisP##aKey, __unused VALUE_TYPE aValue, BOOL *stop) {
//% if (idx == 1) *stop = YES;
//% XCTAssertNotEqual(idx, 2U);
//% ++idx;
@ -790,8 +787,7 @@
//% XCTAssertNotNil(dict);
//% XCTAssertEqual(dict.count, 0U);
//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY1)
//% [dict enumerateKeysAnd##VALUE_NAME##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u##, BOOL *stop) {
//% #pragma unused(aKey, a##VNAME$u##, stop)
//% [dict enumerateKeysAnd##VALUE_NAME##sUsingBlock:^(__unused KEY_TYPE KisP##aKey, __unused VALUE_TYPE a##VNAME$u##, __unused BOOL *stop) {
//% XCTFail(@"Shouldn't get here!");
//% }];
//% [dict release];
@ -849,8 +845,7 @@
//%
//% // Stopping the enumeration.
//% idx = 0;
//% [dict enumerateKeysAnd##VALUE_NAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u##, BOOL *stop) {
//% #pragma unused(aKey, a##VNAME$u)
//% [dict enumerateKeysAnd##VALUE_NAME$u##sUsingBlock:^(__unused KEY_TYPE KisP##aKey, __unused VALUE_TYPE a##VNAME$u##, BOOL *stop) {
//% if (idx == 0) *stop = YES;
//% XCTAssertNotEqual(idx, 2U);
//% ++idx;

3
objectivec/Tests/GPBMessageTests+Runtime.m
Unescape View File

@ -2600,8 +2600,7 @@
// Ensure the messages are unique per map.
[msg1.mapInt32ForeignMessage
enumerateKeysAndObjectsUsingBlock:^(int32_t key, id value, BOOL *stop) {
#pragma unused(stop)
enumerateKeysAndObjectsUsingBlock:^(int32_t key, id value, __unused BOOL *stop) {
ForeignMessage *subMsg2 = [msg2.mapInt32ForeignMessage objectForKey:key];
XCTAssertNotEqual(value, subMsg2); // Ptr compare, new object.
}];

9
objectivec/Tests/GPBMessageTests.m
Unescape View File

@ -74,12 +74,9 @@
}
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary *)change
context:(void *)context {
#pragma unused(object)
#pragma unused(change)
#pragma unused(context)
ofObject:(__unused id)object
change:(__unused NSDictionary *)change
context:(__unused void *)context {
if ([keyPath isEqualToString:keyPath_]) {
self.didObserve = YES;
}

Write Preview
Loading…
Cancel
Save