From d846b0b059b4d867536b98aa29475a387aa09114 Mon Sep 17 00:00:00 2001 From: Thomas Van Lenten Date: Mon, 8 Jun 2015 16:24:57 -0400 Subject: Beta quality drop of Objective C Support. - Add more to the ObjC dir readme. - Merge the ExtensionField and ExtensionDescriptor to reduce overhead. - Fix an initialization race. - Clean up the Xcode schemes. - Remove the class/enum filter. - Remove some forced inline that were bloating things without proof of performance wins. - Rename some internal types to avoid conflicts with the well know types protos. - Drop the use of ApplyFunctions to the compiler/optimizer can do what it wants. - Better document some possible future improvements. - Add missing support for parsing repeated primitive fields in packed or unpacked forms. - Improve -hash. - Add *Count for repeated and map<> fields to avoid auto create when checking for them being set. --- objectivec/Tests/GPBTestUtilities.m | 386 ++++++++++++++++++++++++++++-------- 1 file changed, 300 insertions(+), 86 deletions(-) (limited to 'objectivec/Tests/GPBTestUtilities.m') diff --git a/objectivec/Tests/GPBTestUtilities.m b/objectivec/Tests/GPBTestUtilities.m index 6058dfc1..3d85c744 100644 --- a/objectivec/Tests/GPBTestUtilities.m +++ b/objectivec/Tests/GPBTestUtilities.m @@ -599,6 +599,33 @@ const uint32_t kGPBDefaultRepeatCount = 2; XCTAssertEqual(count, message.repeatedStringPieceArray.count); XCTAssertEqual(count, message.repeatedCordArray.count); + XCTAssertEqual(count, message.repeatedInt32Array_Count); + XCTAssertEqual(count, message.repeatedInt64Array_Count); + XCTAssertEqual(count, message.repeatedUint32Array_Count); + XCTAssertEqual(count, message.repeatedUint64Array_Count); + XCTAssertEqual(count, message.repeatedSint32Array_Count); + XCTAssertEqual(count, message.repeatedSint64Array_Count); + XCTAssertEqual(count, message.repeatedFixed32Array_Count); + XCTAssertEqual(count, message.repeatedFixed64Array_Count); + XCTAssertEqual(count, message.repeatedSfixed32Array_Count); + XCTAssertEqual(count, message.repeatedSfixed64Array_Count); + XCTAssertEqual(count, message.repeatedFloatArray_Count); + XCTAssertEqual(count, message.repeatedDoubleArray_Count); + XCTAssertEqual(count, message.repeatedBoolArray_Count); + XCTAssertEqual(count, message.repeatedStringArray_Count); + XCTAssertEqual(count, message.repeatedBytesArray_Count); + + XCTAssertEqual(count, message.repeatedGroupArray_Count); + XCTAssertEqual(count, message.repeatedNestedMessageArray_Count); + XCTAssertEqual(count, message.repeatedForeignMessageArray_Count); + XCTAssertEqual(count, message.repeatedImportMessageArray_Count); + XCTAssertEqual(count, message.repeatedNestedEnumArray_Count); + XCTAssertEqual(count, message.repeatedForeignEnumArray_Count); + XCTAssertEqual(count, message.repeatedImportEnumArray_Count); + + XCTAssertEqual(count, message.repeatedStringPieceArray_Count); + XCTAssertEqual(count, message.repeatedCordArray_Count); + for (uint32_t i = 0; i < count; ++i) { XCTAssertEqual((int)(201 + i * 100), [message.repeatedInt32Array valueAtIndex:i]); @@ -1097,6 +1124,72 @@ const uint32_t kGPBDefaultRepeatCount = 2; } } +- (void)setAllTestPackedFields:(TestPackedTypes *)message { + // Must match -setAllTestUnpackedFields: + [message.packedInt32Array addValue:101]; + [message.packedInt64Array addValue:102]; + [message.packedUint32Array addValue:103]; + [message.packedUint64Array addValue:104]; + [message.packedSint32Array addValue:105]; + [message.packedSint64Array addValue:106]; + [message.packedFixed32Array addValue:107]; + [message.packedFixed64Array addValue:108]; + [message.packedSfixed32Array addValue:109]; + [message.packedSfixed64Array addValue:110]; + [message.packedFloatArray addValue:111.f]; + [message.packedDoubleArray addValue:112.]; + [message.packedBoolArray addValue:YES]; + [message.packedEnumArray addValue:ForeignEnum_ForeignBar]; + + [message.packedInt32Array addValue:201]; + [message.packedInt64Array addValue:302]; + [message.packedUint32Array addValue:203]; + [message.packedUint64Array addValue:204]; + [message.packedSint32Array addValue:205]; + [message.packedSint64Array addValue:206]; + [message.packedFixed32Array addValue:207]; + [message.packedFixed64Array addValue:208]; + [message.packedSfixed32Array addValue:209]; + [message.packedSfixed64Array addValue:210]; + [message.packedFloatArray addValue:211.f]; + [message.packedDoubleArray addValue:212.]; + [message.packedBoolArray addValue:NO]; + [message.packedEnumArray addValue:ForeignEnum_ForeignBaz]; +} + +- (void)setAllTestUnpackedFields:(TestUnpackedTypes *)message { + // Must match -setAllTestPackedFields: + [message.unpackedInt32Array addValue:101]; + [message.unpackedInt64Array addValue:102]; + [message.unpackedUint32Array addValue:103]; + [message.unpackedUint64Array addValue:104]; + [message.unpackedSint32Array addValue:105]; + [message.unpackedSint64Array addValue:106]; + [message.unpackedFixed32Array addValue:107]; + [message.unpackedFixed64Array addValue:108]; + [message.unpackedSfixed32Array addValue:109]; + [message.unpackedSfixed64Array addValue:110]; + [message.unpackedFloatArray addValue:111.f]; + [message.unpackedDoubleArray addValue:112.]; + [message.unpackedBoolArray addValue:YES]; + [message.unpackedEnumArray addValue:ForeignEnum_ForeignBar]; + + [message.unpackedInt32Array addValue:201]; + [message.unpackedInt64Array addValue:302]; + [message.unpackedUint32Array addValue:203]; + [message.unpackedUint64Array addValue:204]; + [message.unpackedSint32Array addValue:205]; + [message.unpackedSint64Array addValue:206]; + [message.unpackedFixed32Array addValue:207]; + [message.unpackedFixed64Array addValue:208]; + [message.unpackedSfixed32Array addValue:209]; + [message.unpackedSfixed64Array addValue:210]; + [message.unpackedFloatArray addValue:211.f]; + [message.unpackedDoubleArray addValue:212.]; + [message.unpackedBoolArray addValue:NO]; + [message.unpackedEnumArray addValue:ForeignEnum_ForeignBaz]; +} + - (GPBExtensionRegistry *)extensionRegistry { return [UnittestRoot extensionRegistry]; } @@ -1189,6 +1282,7 @@ const uint32_t kGPBDefaultRepeatCount = 2; XCTAssertEqualObjects(message.optionalCord, @""); // Repeated fields are empty. + XCTAssertEqual(0U, message.repeatedInt32Array.count); XCTAssertEqual(0U, message.repeatedInt64Array.count); XCTAssertEqual(0U, message.repeatedUint32Array.count); @@ -1216,6 +1310,33 @@ const uint32_t kGPBDefaultRepeatCount = 2; XCTAssertEqual(0U, message.repeatedStringPieceArray.count); XCTAssertEqual(0U, message.repeatedCordArray.count); + XCTAssertEqual(0U, message.repeatedInt32Array_Count); + XCTAssertEqual(0U, message.repeatedInt64Array_Count); + XCTAssertEqual(0U, message.repeatedUint32Array_Count); + XCTAssertEqual(0U, message.repeatedUint64Array_Count); + XCTAssertEqual(0U, message.repeatedSint32Array_Count); + XCTAssertEqual(0U, message.repeatedSint64Array_Count); + XCTAssertEqual(0U, message.repeatedFixed32Array_Count); + XCTAssertEqual(0U, message.repeatedFixed64Array_Count); + XCTAssertEqual(0U, message.repeatedSfixed32Array_Count); + XCTAssertEqual(0U, message.repeatedSfixed64Array_Count); + XCTAssertEqual(0U, message.repeatedFloatArray_Count); + XCTAssertEqual(0U, message.repeatedDoubleArray_Count); + XCTAssertEqual(0U, message.repeatedBoolArray_Count); + XCTAssertEqual(0U, message.repeatedStringArray_Count); + XCTAssertEqual(0U, message.repeatedBytesArray_Count); + + XCTAssertEqual(0U, message.repeatedGroupArray_Count); + XCTAssertEqual(0U, message.repeatedNestedMessageArray_Count); + XCTAssertEqual(0U, message.repeatedForeignMessageArray_Count); + XCTAssertEqual(0U, message.repeatedImportMessageArray_Count); + XCTAssertEqual(0U, message.repeatedNestedEnumArray_Count); + XCTAssertEqual(0U, message.repeatedForeignEnumArray_Count); + XCTAssertEqual(0U, message.repeatedImportEnumArray_Count); + + XCTAssertEqual(0U, message.repeatedStringPieceArray_Count); + XCTAssertEqual(0U, message.repeatedCordArray_Count); + // hasBlah() should also be NO for all default fields. XCTAssertFalse(message.hasDefaultInt32); XCTAssertFalse(message.hasDefaultInt64); @@ -1474,6 +1595,7 @@ const uint32_t kGPBDefaultRepeatCount = 2; // ModifyRepeatedFields only sets the second repeated element of each // field. In addition to verifying this, we also verify that the first // element and size were *not* modified. + XCTAssertEqual(count, message.repeatedInt32Array.count); XCTAssertEqual(count, message.repeatedInt64Array.count); XCTAssertEqual(count, message.repeatedUint32Array.count); @@ -1501,6 +1623,33 @@ const uint32_t kGPBDefaultRepeatCount = 2; XCTAssertEqual(count, message.repeatedStringPieceArray.count); XCTAssertEqual(count, message.repeatedCordArray.count); + XCTAssertEqual(count, message.repeatedInt32Array_Count); + XCTAssertEqual(count, message.repeatedInt64Array_Count); + XCTAssertEqual(count, message.repeatedUint32Array_Count); + XCTAssertEqual(count, message.repeatedUint64Array_Count); + XCTAssertEqual(count, message.repeatedSint32Array_Count); + XCTAssertEqual(count, message.repeatedSint64Array_Count); + XCTAssertEqual(count, message.repeatedFixed32Array_Count); + XCTAssertEqual(count, message.repeatedFixed64Array_Count); + XCTAssertEqual(count, message.repeatedSfixed32Array_Count); + XCTAssertEqual(count, message.repeatedSfixed64Array_Count); + XCTAssertEqual(count, message.repeatedFloatArray_Count); + XCTAssertEqual(count, message.repeatedDoubleArray_Count); + XCTAssertEqual(count, message.repeatedBoolArray_Count); + XCTAssertEqual(count, message.repeatedStringArray_Count); + XCTAssertEqual(count, message.repeatedBytesArray_Count); + + XCTAssertEqual(count, message.repeatedGroupArray_Count); + XCTAssertEqual(count, message.repeatedNestedMessageArray_Count); + XCTAssertEqual(count, message.repeatedForeignMessageArray_Count); + XCTAssertEqual(count, message.repeatedImportMessageArray_Count); + XCTAssertEqual(count, message.repeatedNestedEnumArray_Count); + XCTAssertEqual(count, message.repeatedForeignEnumArray_Count); + XCTAssertEqual(count, message.repeatedImportEnumArray_Count); + + XCTAssertEqual(count, message.repeatedStringPieceArray_Count); + XCTAssertEqual(count, message.repeatedCordArray_Count); + XCTAssertEqual(201, [message.repeatedInt32Array valueAtIndex:0]); XCTAssertEqual(202LL, [message.repeatedInt64Array valueAtIndex:0]); XCTAssertEqual(203U, [message.repeatedUint32Array valueAtIndex:0]); @@ -1563,105 +1712,101 @@ const uint32_t kGPBDefaultRepeatCount = 2; - (void)setPackedFields:(TestPackedTypes *)message repeatedCount:(uint32_t)count { - { - GPBInt32Array *scratch = [GPBInt32Array array]; - for (uint32_t i = 0; i < count; ++i) { - [scratch addValue:601 + i * 100]; - } - [message setPackedInt32Array:scratch]; + // Must match -setUnpackedFields:repeatedCount: + // Must match -setPackedExtensions:repeatedCount: + // Must match -setUnpackedExtensions:repeatedCount: + for (uint32_t i = 0; i < count; ++i) { + [message.packedInt32Array addValue:601 + i * 100]; } - { - GPBInt64Array *scratch = [GPBInt64Array array]; - for (uint32_t i = 0; i < count; ++i) { - [scratch addValue:602 + i * 100]; - } - [message setPackedInt64Array:scratch]; + for (uint32_t i = 0; i < count; ++i) { + [message.packedInt64Array addValue:602 + i * 100]; } - { - GPBUInt32Array *scratch = [GPBUInt32Array array]; - for (uint32_t i = 0; i < count; ++i) { - [scratch addValue:603 + i * 100]; - } - [message setPackedUint32Array:scratch]; + for (uint32_t i = 0; i < count; ++i) { + [message.packedUint32Array addValue:603 + i * 100]; } - { - GPBUInt64Array *scratch = [GPBUInt64Array array]; - for (uint32_t i = 0; i < count; ++i) { - [scratch addValue:604 + i * 100]; - } - [message setPackedUint64Array:scratch]; + for (uint32_t i = 0; i < count; ++i) { + [message.packedUint64Array addValue:604 + i * 100]; } - { - GPBInt32Array *scratch = [GPBInt32Array array]; - for (uint32_t i = 0; i < count; ++i) { - [scratch addValue:605 + i * 100]; - } - [message setPackedSint32Array:scratch]; + for (uint32_t i = 0; i < count; ++i) { + [message.packedSint32Array addValue:605 + i * 100]; } - { - GPBInt64Array *scratch = [GPBInt64Array array]; - for (uint32_t i = 0; i < count; ++i) { - [scratch addValue:606 + i * 100]; - } - [message setPackedSint64Array:scratch]; + for (uint32_t i = 0; i < count; ++i) { + [message.packedSint64Array addValue:606 + i * 100]; } - { - GPBUInt32Array *scratch = [GPBUInt32Array array]; - for (uint32_t i = 0; i < count; ++i) { - [scratch addValue:607 + i * 100]; - } - [message setPackedFixed32Array:scratch]; + for (uint32_t i = 0; i < count; ++i) { + [message.packedFixed32Array addValue:607 + i * 100]; } - { - GPBUInt64Array *scratch = [GPBUInt64Array array]; - for (uint32_t i = 0; i < count; ++i) { - [scratch addValue:608 + i * 100]; - } - [message setPackedFixed64Array:scratch]; + for (uint32_t i = 0; i < count; ++i) { + [message.packedFixed64Array addValue:608 + i * 100]; } - { - GPBInt32Array *scratch = [GPBInt32Array array]; - for (uint32_t i = 0; i < count; ++i) { - [scratch addValue:609 + i * 100]; - } - [message setPackedSfixed32Array:scratch]; + for (uint32_t i = 0; i < count; ++i) { + [message.packedSfixed32Array addValue:609 + i * 100]; } - { - GPBInt64Array *scratch = [GPBInt64Array array]; - for (uint32_t i = 0; i < count; ++i) { - [scratch addValue:610 + i * 100]; - } - [message setPackedSfixed64Array:scratch]; + for (uint32_t i = 0; i < count; ++i) { + [message.packedSfixed64Array addValue:610 + i * 100]; } - { - GPBFloatArray *scratch = [GPBFloatArray array]; - for (uint32_t i = 0; i < count; ++i) { - [scratch addValue:611 + i * 100]; - } - [message setPackedFloatArray:scratch]; + for (uint32_t i = 0; i < count; ++i) { + [message.packedFloatArray addValue:611 + i * 100]; } - { - GPBDoubleArray *scratch = [GPBDoubleArray array]; - for (uint32_t i = 0; i < count; ++i) { - [scratch addValue:612 + i * 100]; - } - [message setPackedDoubleArray:scratch]; + for (uint32_t i = 0; i < count; ++i) { + [message.packedDoubleArray addValue:612 + i * 100]; } - { - GPBBoolArray *scratch = [GPBBoolArray array]; - for (uint32_t i = 0; i < count; ++i) { - [scratch addValue:(i % 2) ? YES : NO]; - } - [message setPackedBoolArray:scratch]; + for (uint32_t i = 0; i < count; ++i) { + [message.packedBoolArray addValue:(i % 2) ? YES : NO]; } - { - GPBEnumArray *scratch = - [GPBEnumArray arrayWithValidationFunction:ForeignEnum_IsValidValue]; - for (uint32_t i = 0; i < count; ++i) { - [scratch - addValue:(i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz]; - } - [message setPackedEnumArray:scratch]; + for (uint32_t i = 0; i < count; ++i) { + [message.packedEnumArray + addValue:(i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz]; + } +} + +- (void)setUnpackedFields:(TestUnpackedTypes *)message + repeatedCount:(uint32_t)count { + // Must match -setPackedFields:repeatedCount: + // Must match -setPackedExtensions:repeatedCount: + // Must match -setUnpackedExtensions:repeatedCount: + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedInt32Array addValue:601 + i * 100]; + } + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedInt64Array addValue:602 + i * 100]; + } + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedUint32Array addValue:603 + i * 100]; + } + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedUint64Array addValue:604 + i * 100]; + } + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedSint32Array addValue:605 + i * 100]; + } + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedSint64Array addValue:606 + i * 100]; + } + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedFixed32Array addValue:607 + i * 100]; + } + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedFixed64Array addValue:608 + i * 100]; + } + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedSfixed32Array addValue:609 + i * 100]; + } + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedSfixed64Array addValue:610 + i * 100]; + } + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedFloatArray addValue:611 + i * 100]; + } + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedDoubleArray addValue:612 + i * 100]; + } + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedBoolArray addValue:(i % 2) ? YES : NO]; + } + for (uint32_t i = 0; i < count; ++i) { + [message.unpackedEnumArray + addValue:(i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz]; } } @@ -1708,6 +1853,9 @@ const uint32_t kGPBDefaultRepeatCount = 2; - (void)setPackedExtensions:(TestPackedExtensions *)message repeatedCount:(uint32_t)count { + // Must match -setPackedFields:repeatedCount: + // Must match -setUnpackedFields:repeatedCount: + // Must match -setUnpackedExtensions:repeatedCount: for (uint32_t i = 0; i < count; i++) { [message addExtension:[UnittestRoot packedInt32Extension] value:@(601 + i * 100)]; @@ -1741,6 +1889,44 @@ const uint32_t kGPBDefaultRepeatCount = 2; } } +- (void)setUnpackedExtensions:(TestUnpackedExtensions *)message + repeatedCount:(uint32_t)count { + // Must match -setPackedFields:repeatedCount: + // Must match -setUnpackedFields:repeatedCount: + // Must match -setPackedExtensions:repeatedCount: + for (uint32_t i = 0; i < count; i++) { + [message addExtension:[UnittestRoot unpackedInt32Extension] + value:@(601 + i * 100)]; + [message addExtension:[UnittestRoot unpackedInt64Extension] + value:@(602 + i * 100)]; + [message addExtension:[UnittestRoot unpackedUint32Extension] + value:@(603 + i * 100)]; + [message addExtension:[UnittestRoot unpackedUint64Extension] + value:@(604 + i * 100)]; + [message addExtension:[UnittestRoot unpackedSint32Extension] + value:@(605 + i * 100)]; + [message addExtension:[UnittestRoot unpackedSint64Extension] + value:@(606 + i * 100)]; + [message addExtension:[UnittestRoot unpackedFixed32Extension] + value:@(607 + i * 100)]; + [message addExtension:[UnittestRoot unpackedFixed64Extension] + value:@(608 + i * 100)]; + [message addExtension:[UnittestRoot unpackedSfixed32Extension] + value:@(609 + i * 100)]; + [message addExtension:[UnittestRoot unpackedSfixed64Extension] + value:@(610 + i * 100)]; + [message addExtension:[UnittestRoot unpackedFloatExtension] + value:@(611 + i * 100)]; + [message addExtension:[UnittestRoot unpackedDoubleExtension] + value:@(612 + i * 100)]; + [message addExtension:[UnittestRoot unpackedBoolExtension] + value:@((i % 2) ? YES : NO)]; + [message addExtension:[UnittestRoot unpackedEnumExtension] + value:@((i % 2) ? ForeignEnum_ForeignBar + : ForeignEnum_ForeignBaz)]; + } +} + - (void)assertPackedExtensionsSet:(TestPackedExtensions *)message repeatedCount:(uint32_t)count{ XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedInt32Extension]] count]); @@ -1884,6 +2070,34 @@ const uint32_t kGPBDefaultRepeatCount = 2; XCTAssertEqualObjects(message.repeatedStringPieceArray, [message valueForKey:@"repeatedStringPieceArray"]); XCTAssertEqualObjects(message.repeatedCordArray, [message valueForKey:@"repeatedCordArray"]); + XCTAssertEqualObjects(@(message.repeatedInt32Array_Count), [message valueForKey:@"repeatedInt32Array_Count"]); + XCTAssertEqualObjects(@(message.repeatedInt64Array_Count), [message valueForKey:@"repeatedInt64Array_Count"]); + XCTAssertEqualObjects(@(message.repeatedUint32Array_Count), [message valueForKey:@"repeatedUint32Array_Count"]); + XCTAssertEqualObjects(@(message.repeatedUint64Array_Count), [message valueForKey:@"repeatedUint64Array_Count"]); + XCTAssertEqualObjects(@(message.repeatedSint32Array_Count), [message valueForKey:@"repeatedSint32Array_Count"]); + XCTAssertEqualObjects(@(message.repeatedSint64Array_Count), [message valueForKey:@"repeatedSint64Array_Count"]); + XCTAssertEqualObjects(@(message.repeatedFixed32Array_Count), [message valueForKey:@"repeatedFixed32Array_Count"]); + XCTAssertEqualObjects(@(message.repeatedFixed64Array_Count), [message valueForKey:@"repeatedFixed64Array_Count"]); + XCTAssertEqualObjects(@(message.repeatedSfixed32Array_Count), [message valueForKey:@"repeatedSfixed32Array_Count"]); + XCTAssertEqualObjects(@(message.repeatedSfixed64Array_Count), [message valueForKey:@"repeatedSfixed64Array_Count"]); + XCTAssertEqualObjects(@(message.repeatedFloatArray_Count), [message valueForKey:@"repeatedFloatArray_Count"]); + XCTAssertEqualObjects(@(message.repeatedDoubleArray_Count), [message valueForKey:@"repeatedDoubleArray_Count"]); + XCTAssertEqualObjects(@(message.repeatedBoolArray_Count), [message valueForKey:@"repeatedBoolArray_Count"]); + XCTAssertEqualObjects(@(message.repeatedStringArray_Count), [message valueForKey:@"repeatedStringArray_Count"]); + XCTAssertEqualObjects(@(message.repeatedBytesArray_Count), [message valueForKey:@"repeatedBytesArray_Count"]); + + XCTAssertEqualObjects(@(message.repeatedGroupArray_Count), [message valueForKey:@"repeatedGroupArray_Count"]); + XCTAssertEqualObjects(@(message.repeatedNestedMessageArray_Count), [message valueForKey:@"repeatedNestedMessageArray_Count"]); + XCTAssertEqualObjects(@(message.repeatedForeignMessageArray_Count), [message valueForKey:@"repeatedForeignMessageArray_Count"]); + XCTAssertEqualObjects(@(message.repeatedImportMessageArray_Count), [message valueForKey:@"repeatedImportMessageArray_Count"]); + + XCTAssertEqualObjects(@(message.repeatedNestedEnumArray_Count), [message valueForKey:@"repeatedNestedEnumArray_Count"]); + XCTAssertEqualObjects(@(message.repeatedForeignEnumArray_Count), [message valueForKey:@"repeatedForeignEnumArray_Count"]); + XCTAssertEqualObjects(@(message.repeatedImportEnumArray_Count), [message valueForKey:@"repeatedImportEnumArray_Count"]); + + XCTAssertEqualObjects(@(message.repeatedStringPieceArray_Count), [message valueForKey:@"repeatedStringPieceArray_Count"]); + XCTAssertEqualObjects(@(message.repeatedCordArray_Count), [message valueForKey:@"repeatedCordArray_Count"]); + // ----------------------------------------------------------------- XCTAssertEqualObjects([message valueForKey:@"hasDefaultInt32"], @YES); -- cgit v1.2.3