diff options
author | Paul Yang <paulyang1211@gmail.com> | 2015-05-06 17:32:07 -0700 |
---|---|---|
committer | Paul Yang <paulyang1211@gmail.com> | 2015-05-06 17:32:07 -0700 |
commit | b89de5f6e0d81eccc34664f19362b83a82a152ca (patch) | |
tree | f27448a279bea152488306d66e999c4d2a70fa42 /objectivec/Tests/GPBTestUtilities.m | |
parent | f47db47cd97c00a3a49584eda13e03c3352e5215 (diff) | |
parent | 30650d81d9baa446dbc8deb784ba53794cafda5b (diff) | |
download | protobuf-b89de5f6e0d81eccc34664f19362b83a82a152ca.tar.gz protobuf-b89de5f6e0d81eccc34664f19362b83a82a152ca.tar.bz2 protobuf-b89de5f6e0d81eccc34664f19362b83a82a152ca.zip |
Merge pull request #331 from thomasvl/objc_alpha1_drop
Objective C compiler plugin and runtime
Diffstat (limited to 'objectivec/Tests/GPBTestUtilities.m')
-rw-r--r-- | objectivec/Tests/GPBTestUtilities.m | 2350 |
1 files changed, 2350 insertions, 0 deletions
diff --git a/objectivec/Tests/GPBTestUtilities.m b/objectivec/Tests/GPBTestUtilities.m new file mode 100644 index 00000000..d664a88a --- /dev/null +++ b/objectivec/Tests/GPBTestUtilities.m @@ -0,0 +1,2350 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#import "GPBTestUtilities.h" + +#import "google/protobuf/MapUnittest.pbobjc.h" +#import "google/protobuf/Unittest.pbobjc.h" + +const uint32_t kGPBDefaultRepeatCount = 2; + +// Small category to easily turn a CString into an NSData. +@interface NSData (GPBTestCase) ++ (NSData *)gpbtu_dataWithCString:(char *)buffer; ++ (instancetype)gpbtu_dataWithEmbeddedNulls; +@end + +@implementation NSData (GPBTestCase) ++ (NSData *)gpbtu_dataWithCString:(char *)buffer { + return [NSData dataWithBytes:buffer length:strlen(buffer)]; +} + ++ (instancetype)gpbtu_dataWithUint32:(uint32_t)value { + return [[[self alloc] initWithUint32_gpbtu:value] autorelease]; +} + +- (instancetype)initWithUint32_gpbtu:(uint32_t)value { + value = CFSwapInt32HostToLittle(value); + return [self initWithBytes:&value length:sizeof(value)]; +} + ++ (instancetype)gpbtu_dataWithEmbeddedNulls { + char bytes[6] = "\1\0\2\3\0\5"; + return [self dataWithBytes:bytes length:sizeof(bytes)]; +} +@end + +@implementation GPBTestCase + +// Return data for name. Optionally (based on #if setting) write out dataToWrite +// to replace that data. Useful for setting golden masters. +- (NSData *)getDataFileNamed:(NSString *)name + dataToWrite:(NSData *)dataToWrite { + NSBundle *bundle = [NSBundle bundleForClass:[self class]]; + NSString *path = [bundle pathForResource:[name stringByDeletingPathExtension] + ofType:[name pathExtension]]; + XCTAssertNotNil(path, @"Unable to find %@", name); + NSData *data = [NSData dataWithContentsOfFile:path]; + XCTAssertNotNil(data, @"Unable to load from %@", path); +#if 0 + // Enable to write out golden master files. + if (!path) { + path = [[bundle resourcePath] stringByAppendingPathComponent:name]; + } + NSError *error = nil; + BOOL wrote = [dataToWrite writeToFile:path options:NSDataWritingAtomic error:&error]; + XCTAssertTrue(wrote, @"Unable to write %@ (%@)", path, error); + NSLog(@"Wrote data file to %@", path); +#else + // Kill off the unused variable warning. + dataToWrite = dataToWrite; +#endif + return data; +} + +// ------------------------------------------------------------------- + +- (void)modifyRepeatedExtensions:(TestAllExtensions *)message { + [message setExtension:[UnittestRoot repeatedInt32Extension] + index:1 + value:@501]; + [message setExtension:[UnittestRoot repeatedInt64Extension] + index:1 + value:@502]; + [message setExtension:[UnittestRoot repeatedUint32Extension] + index:1 + value:@503]; + [message setExtension:[UnittestRoot repeatedUint64Extension] + index:1 + value:@504]; + [message setExtension:[UnittestRoot repeatedSint32Extension] + index:1 + value:@505]; + [message setExtension:[UnittestRoot repeatedSint64Extension] + index:1 + value:@506]; + [message setExtension:[UnittestRoot repeatedFixed32Extension] + index:1 + value:@507]; + [message setExtension:[UnittestRoot repeatedFixed64Extension] + index:1 + value:@508]; + [message setExtension:[UnittestRoot repeatedSfixed32Extension] + index:1 + value:@509]; + [message setExtension:[UnittestRoot repeatedSfixed64Extension] + index:1 + value:@510]; + [message setExtension:[UnittestRoot repeatedFloatExtension] + index:1 + value:@511.0f]; + [message setExtension:[UnittestRoot repeatedDoubleExtension] + index:1 + value:@512.0]; + [message setExtension:[UnittestRoot repeatedBoolExtension] + index:1 + value:@YES]; + [message setExtension:[UnittestRoot repeatedStringExtension] + index:1 + value:@"515"]; + [message setExtension:[UnittestRoot repeatedBytesExtension] + index:1 + value:[NSData gpbtu_dataWithUint32:516]]; + + RepeatedGroup_extension *repeatedGroup = [RepeatedGroup_extension message]; + [repeatedGroup setA:517]; + [message setExtension:[UnittestRoot repeatedGroupExtension] + index:1 + value:repeatedGroup]; + TestAllTypes_NestedMessage *nestedMessage = + [TestAllTypes_NestedMessage message]; + [nestedMessage setBb:518]; + [message setExtension:[UnittestRoot repeatedNestedMessageExtension] + index:1 + value:nestedMessage]; + ForeignMessage *foreignMessage = [ForeignMessage message]; + [foreignMessage setC:519]; + [message setExtension:[UnittestRoot repeatedForeignMessageExtension] + index:1 + value:foreignMessage]; + ImportMessage *importMessage = [ImportMessage message]; + [importMessage setD:520]; + [message setExtension:[UnittestRoot repeatedImportMessageExtension] + index:1 + value:importMessage]; + + [message setExtension:[UnittestRoot repeatedNestedEnumExtension] + index:1 + value:@(TestAllTypes_NestedEnum_Foo)]; + [message setExtension:[UnittestRoot repeatedForeignEnumExtension] + index:1 + value:@(ForeignEnum_ForeignFoo)]; + [message setExtension:[UnittestRoot repeatedImportEnumExtension] + index:1 + value:@(ImportEnum_ImportFoo)]; + + [message setExtension:[UnittestRoot repeatedStringPieceExtension] + index:1 + value:@"524"]; + [message setExtension:[UnittestRoot repeatedCordExtension] + index:1 + value:@"525"]; +} + +- (void)assertAllExtensionsSet:(TestAllExtensions *)message + repeatedCount:(uint32_t)count { + XCTAssertTrue([message hasExtension:[UnittestRoot optionalInt32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalInt64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalUint32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalUint64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalSint32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalSint64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalFixed32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalFixed64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalSfixed32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalSfixed64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalFloatExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalDoubleExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalBoolExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalStringExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalBytesExtension]]); + + XCTAssertTrue([message hasExtension:[UnittestRoot optionalGroupExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalNestedMessageExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalForeignMessageExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalImportMessageExtension]]); + + XCTAssertTrue([[message getExtension:[UnittestRoot optionalGroupExtension]] hasA]); + XCTAssertTrue([[message getExtension:[UnittestRoot optionalNestedMessageExtension]] hasBb]); + XCTAssertTrue([[message getExtension:[UnittestRoot optionalForeignMessageExtension]] hasC]); + XCTAssertTrue([[message getExtension:[UnittestRoot optionalImportMessageExtension]] hasD]); + + XCTAssertTrue([message hasExtension:[UnittestRoot optionalNestedEnumExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalForeignEnumExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalImportEnumExtension]]); + + XCTAssertTrue([message hasExtension:[UnittestRoot optionalStringPieceExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot optionalCordExtension]]); + + XCTAssertTrue([message hasExtension:[UnittestRoot defaultInt32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultInt64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultUint32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultUint64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultSint32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultSint64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultFixed32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultFixed64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultSfixed32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultSfixed64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultFloatExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultDoubleExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultBoolExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultStringExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultBytesExtension]]); + + XCTAssertTrue([message hasExtension:[UnittestRoot defaultNestedEnumExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultForeignEnumExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultImportEnumExtension]]); + + XCTAssertTrue([message hasExtension:[UnittestRoot defaultStringPieceExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultCordExtension]]); + + XCTAssertEqual(101, [[message getExtension:[UnittestRoot optionalInt32Extension]] intValue]); + XCTAssertEqual(102LL, [[message getExtension:[UnittestRoot optionalInt64Extension]] longLongValue]); + XCTAssertEqual(103U, [[message getExtension:[UnittestRoot optionalUint32Extension]] unsignedIntValue]); + XCTAssertEqual(104ULL, [[message getExtension:[UnittestRoot optionalUint64Extension]] unsignedLongLongValue]); + XCTAssertEqual(105, [[message getExtension:[UnittestRoot optionalSint32Extension]] intValue]); + XCTAssertEqual(106LL, [[message getExtension:[UnittestRoot optionalSint64Extension]] longLongValue]); + XCTAssertEqual(107U, [[message getExtension:[UnittestRoot optionalFixed32Extension]] unsignedIntValue]); + XCTAssertEqual(108ULL, [[message getExtension:[UnittestRoot optionalFixed64Extension]] unsignedLongLongValue]); + XCTAssertEqual(109, [[message getExtension:[UnittestRoot optionalSfixed32Extension]] intValue]); + XCTAssertEqual(110LL, [[message getExtension:[UnittestRoot optionalSfixed64Extension]] longLongValue]); + XCTAssertEqualWithAccuracy(111.0f, [[message getExtension:[UnittestRoot optionalFloatExtension]] floatValue], 0.01); + XCTAssertEqualWithAccuracy(112.0, [[message getExtension:[UnittestRoot optionalDoubleExtension]] doubleValue], 0.01); + XCTAssertTrue([[message getExtension:[UnittestRoot optionalBoolExtension]] boolValue]); + XCTAssertEqualObjects(@"115", [message getExtension:[UnittestRoot optionalStringExtension]]); + XCTAssertEqualObjects([NSData gpbtu_dataWithEmbeddedNulls], [message getExtension:[UnittestRoot optionalBytesExtension]]); + + XCTAssertEqual(117, [(TestAllTypes_OptionalGroup*)[message getExtension:[UnittestRoot optionalGroupExtension]] a]); + XCTAssertEqual(118, [(TestAllTypes_NestedMessage*)[message getExtension:[UnittestRoot optionalNestedMessageExtension]] bb]); + XCTAssertEqual(119, [[message getExtension:[UnittestRoot optionalForeignMessageExtension]] c]); + XCTAssertEqual(120, [[message getExtension:[UnittestRoot optionalImportMessageExtension]] d]); + + XCTAssertEqual(TestAllTypes_NestedEnum_Baz, [[message getExtension:[UnittestRoot optionalNestedEnumExtension]] intValue]); + XCTAssertEqual(ForeignEnum_ForeignBaz, [[message getExtension:[UnittestRoot optionalForeignEnumExtension]] intValue]); + XCTAssertEqual(ImportEnum_ImportBaz, [[message getExtension:[UnittestRoot optionalImportEnumExtension]] intValue]); + + XCTAssertEqualObjects(@"124", [message getExtension:[UnittestRoot optionalStringPieceExtension]]); + XCTAssertEqualObjects(@"125", [message getExtension:[UnittestRoot optionalCordExtension]]); + + // ----------------------------------------------------------------- + + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedInt32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedInt64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedUint32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedUint64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSint32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSint64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedFixed32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedFixed64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSfixed32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSfixed64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedFloatExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedDoubleExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedBoolExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedStringExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedBytesExtension]] count]); + + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedGroupExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedNestedMessageExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedForeignMessageExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedImportMessageExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedNestedEnumExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedForeignEnumExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedImportEnumExtension]] count]); + + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedStringPieceExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedCordExtension]] count]); + + for (uint32_t i = 0; i < count; ++i) { + id extension = [message getExtension:[UnittestRoot repeatedInt32Extension]]; + XCTAssertEqual((int)(201 + i * 100), [extension[i] intValue]); + extension = [message getExtension:[UnittestRoot repeatedInt64Extension]]; + XCTAssertEqual(202 + i * 100, [extension[i] longLongValue]); + extension = [message getExtension:[UnittestRoot repeatedUint32Extension]]; + XCTAssertEqual(203 + i * 100, [extension[i] unsignedIntValue]); + extension = [message getExtension:[UnittestRoot repeatedUint64Extension]]; + XCTAssertEqual(204 + i * 100, [extension[i] unsignedLongLongValue]); + extension = [message getExtension:[UnittestRoot repeatedSint32Extension]]; + XCTAssertEqual((int)(205 + i * 100), [extension[i] intValue]); + extension = [message getExtension:[UnittestRoot repeatedSint64Extension]]; + XCTAssertEqual(206 + i * 100, [extension[i] longLongValue]); + extension = [message getExtension:[UnittestRoot repeatedFixed32Extension]]; + XCTAssertEqual(207 + i * 100, [extension[i] unsignedIntValue]); + extension = [message getExtension:[UnittestRoot repeatedFixed64Extension]]; + XCTAssertEqual(208 + i * 100, [extension[i] unsignedLongLongValue]); + extension = [message getExtension:[UnittestRoot repeatedSfixed32Extension]]; + XCTAssertEqual((int)(209 + i * 100), [extension[i] intValue]); + extension = [message getExtension:[UnittestRoot repeatedSfixed64Extension]]; + XCTAssertEqual(210 + i * 100, [extension[i] longLongValue]); + extension = [message getExtension:[UnittestRoot repeatedFloatExtension]]; + XCTAssertEqualWithAccuracy(211 + i * 100, [extension[i] floatValue], 0.01); + extension = [message getExtension:[UnittestRoot repeatedDoubleExtension]]; + XCTAssertEqualWithAccuracy(212 + i * 100, [extension[i] doubleValue], 0.01); + extension = [message getExtension:[UnittestRoot repeatedBoolExtension]]; + XCTAssertEqual((i % 2) ? YES : NO, [extension[i] boolValue]); + + NSString *string = [[NSString alloc] initWithFormat:@"%d", 215 + i * 100]; + extension = [message getExtension:[UnittestRoot repeatedStringExtension]]; + XCTAssertEqualObjects(string, extension[i]); + [string release]; + + NSData *data = [[NSData alloc] initWithUint32_gpbtu:216 + i * 100]; + extension = [message getExtension:[UnittestRoot repeatedBytesExtension]]; + XCTAssertEqualObjects(data, extension[i]); + [data release]; + + extension = [message getExtension:[UnittestRoot repeatedGroupExtension]]; + XCTAssertEqual((int)(217 + i * 100), [(TestAllTypes_OptionalGroup*)extension[i] a]); + extension = [message getExtension:[UnittestRoot repeatedNestedMessageExtension]]; + XCTAssertEqual((int)(218 + i * 100), [(TestAllTypes_NestedMessage*)extension[i] bb]); + extension = [message getExtension:[UnittestRoot repeatedForeignMessageExtension]]; + XCTAssertEqual((int)(219 + i * 100), [extension[i] c]); + extension = [message getExtension:[UnittestRoot repeatedImportMessageExtension]]; + XCTAssertEqual((int)(220 + i * 100), [extension[i] d]); + + extension = [message getExtension:[UnittestRoot repeatedNestedEnumExtension]]; + XCTAssertEqual((i % 2) ? TestAllTypes_NestedEnum_Bar : TestAllTypes_NestedEnum_Baz, [extension[i] intValue]); + extension = [message getExtension:[UnittestRoot repeatedForeignEnumExtension]]; + XCTAssertEqual((i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz, [extension[i] intValue]); + extension = [message getExtension:[UnittestRoot repeatedImportEnumExtension]]; + XCTAssertEqual((i % 2) ? ImportEnum_ImportBar : ImportEnum_ImportBaz, [extension[i] intValue]); + + string = [[NSString alloc] initWithFormat:@"%d", 224 + i * 100]; + extension = [message getExtension:[UnittestRoot repeatedStringPieceExtension]]; + XCTAssertEqualObjects(string, extension[i]); + [string release]; + + string = [[NSString alloc] initWithFormat:@"%d", 225 + i * 100]; + extension = [message getExtension:[UnittestRoot repeatedCordExtension]]; + XCTAssertEqualObjects(string, extension[i]); + [string release]; + } + + // ----------------------------------------------------------------- + + XCTAssertTrue([message hasExtension:[UnittestRoot defaultInt32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultInt64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultUint32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultUint64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultSint32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultSint64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultFixed32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultFixed64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultSfixed32Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultSfixed64Extension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultFloatExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultDoubleExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultBoolExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultStringExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultBytesExtension]]); + + XCTAssertTrue([message hasExtension:[UnittestRoot defaultNestedEnumExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultForeignEnumExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultImportEnumExtension]]); + + XCTAssertTrue([message hasExtension:[UnittestRoot defaultStringPieceExtension]]); + XCTAssertTrue([message hasExtension:[UnittestRoot defaultCordExtension]]); + + XCTAssertEqual(401, [[message getExtension:[UnittestRoot defaultInt32Extension]] intValue]); + XCTAssertEqual(402LL, [[message getExtension:[UnittestRoot defaultInt64Extension]] longLongValue]); + XCTAssertEqual(403U, [[message getExtension:[UnittestRoot defaultUint32Extension]] unsignedIntValue]); + XCTAssertEqual(404ULL, [[message getExtension:[UnittestRoot defaultUint64Extension]] unsignedLongLongValue]); + XCTAssertEqual(405, [[message getExtension:[UnittestRoot defaultSint32Extension]] intValue]); + XCTAssertEqual(406LL, [[message getExtension:[UnittestRoot defaultSint64Extension]] longLongValue]); + XCTAssertEqual(407U, [[message getExtension:[UnittestRoot defaultFixed32Extension]] unsignedIntValue]); + XCTAssertEqual(408ULL, [[message getExtension:[UnittestRoot defaultFixed64Extension]] unsignedLongLongValue]); + XCTAssertEqual(409, [[message getExtension:[UnittestRoot defaultSfixed32Extension]] intValue]); + XCTAssertEqual(410LL,[[message getExtension:[UnittestRoot defaultSfixed64Extension]] longLongValue]); + XCTAssertEqualWithAccuracy(411.0f, [[message getExtension:[UnittestRoot defaultFloatExtension]] floatValue], 0.01); + XCTAssertEqualWithAccuracy(412.0, [[message getExtension:[UnittestRoot defaultDoubleExtension]] doubleValue], 0.01); + XCTAssertFalse([[message getExtension:[UnittestRoot defaultBoolExtension]] boolValue]); + XCTAssertEqualObjects(@"415", [message getExtension:[UnittestRoot defaultStringExtension]]); + XCTAssertEqualObjects([NSData gpbtu_dataWithUint32:416], [message getExtension:[UnittestRoot defaultBytesExtension]]); + + XCTAssertEqual(TestAllTypes_NestedEnum_Foo, [[message getExtension:[UnittestRoot defaultNestedEnumExtension]] intValue]); + XCTAssertEqual(ForeignEnum_ForeignFoo, [[message getExtension:[UnittestRoot defaultForeignEnumExtension]] intValue]); + XCTAssertEqual(ImportEnum_ImportFoo, [[message getExtension:[UnittestRoot defaultImportEnumExtension]] intValue]); + + XCTAssertEqualObjects(@"424", [message getExtension:[UnittestRoot defaultStringPieceExtension]]); + XCTAssertEqualObjects(@"425", [message getExtension:[UnittestRoot defaultCordExtension]]); +} + +- (void)assertRepeatedExtensionsModified:(TestAllExtensions *)message + repeatedCount:(uint32_t)count { + // 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 getExtension:[UnittestRoot repeatedInt32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedInt64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedUint32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedUint64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSint32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSint64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedFixed32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedFixed64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSfixed32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedSfixed64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedFloatExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedDoubleExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedBoolExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedStringExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedBytesExtension]] count]); + + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedGroupExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedNestedMessageExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedForeignMessageExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedImportMessageExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedNestedEnumExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedForeignEnumExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedImportEnumExtension]] count]); + + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedStringPieceExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot repeatedCordExtension]] count]); + + XCTAssertEqual(201,[[message getExtension:[UnittestRoot repeatedInt32Extension]][0] intValue]); + XCTAssertEqual(202LL, [[message getExtension:[UnittestRoot repeatedInt64Extension]][0] longLongValue]); + XCTAssertEqual(203U, [[message getExtension:[UnittestRoot repeatedUint32Extension]][0] unsignedIntValue]); + XCTAssertEqual(204ULL, [[message getExtension:[UnittestRoot repeatedUint64Extension]][0] unsignedLongLongValue]); + XCTAssertEqual(205, [[message getExtension:[UnittestRoot repeatedSint32Extension]][0] intValue]); + XCTAssertEqual(206LL, [[message getExtension:[UnittestRoot repeatedSint64Extension]][0] longLongValue]); + XCTAssertEqual(207U, [[message getExtension:[UnittestRoot repeatedFixed32Extension]][0] unsignedIntValue]); + XCTAssertEqual(208ULL, [[message getExtension:[UnittestRoot repeatedFixed64Extension]][0] unsignedLongLongValue]); + XCTAssertEqual(209, [[message getExtension:[UnittestRoot repeatedSfixed32Extension]][0] intValue]); + XCTAssertEqual(210LL, [[message getExtension:[UnittestRoot repeatedSfixed64Extension]][0] longLongValue]); + XCTAssertEqualWithAccuracy(211.0f, [[message getExtension:[UnittestRoot repeatedFloatExtension]][0] floatValue], 0.01); + XCTAssertEqualWithAccuracy(212.0, [[message getExtension:[UnittestRoot repeatedDoubleExtension]][0] doubleValue], 0.01); + XCTAssertFalse([[message getExtension:[UnittestRoot repeatedBoolExtension]][0] boolValue]); + XCTAssertEqualObjects(@"215", [message getExtension:[UnittestRoot repeatedStringExtension]][0]); + XCTAssertEqualObjects([NSData gpbtu_dataWithUint32:216], [message getExtension:[UnittestRoot repeatedBytesExtension]][0]); + + XCTAssertEqual(217, [(TestAllTypes_OptionalGroup*)[message getExtension:[UnittestRoot repeatedGroupExtension]][0] a]); + XCTAssertEqual(218, [(TestAllTypes_NestedMessage*)[message getExtension:[UnittestRoot repeatedNestedMessageExtension]][0] bb]); + XCTAssertEqual(219, [[message getExtension:[UnittestRoot repeatedForeignMessageExtension]][0] c]); + XCTAssertEqual(220, [[message getExtension:[UnittestRoot repeatedImportMessageExtension]][0] d]); + + XCTAssertEqual(TestAllTypes_NestedEnum_Baz, + [[message getExtension:[UnittestRoot repeatedNestedEnumExtension]][0] intValue]); + XCTAssertEqual(ForeignEnum_ForeignBaz, + [[message getExtension:[UnittestRoot repeatedForeignEnumExtension]][0] intValue]); + XCTAssertEqual(ImportEnum_ImportBaz, + [[message getExtension:[UnittestRoot repeatedImportEnumExtension]][0] intValue]); + + XCTAssertEqualObjects(@"224", [message getExtension:[UnittestRoot repeatedStringPieceExtension]][0]); + XCTAssertEqualObjects(@"225", [message getExtension:[UnittestRoot repeatedCordExtension]][0]); + + // Actually verify the second (modified) elements now. + XCTAssertEqual(501, [[message getExtension:[UnittestRoot repeatedInt32Extension]][1] intValue]); + XCTAssertEqual(502LL, [[message getExtension:[UnittestRoot repeatedInt64Extension]][1] longLongValue]); + XCTAssertEqual(503U, [[message getExtension:[UnittestRoot repeatedUint32Extension]][1] unsignedIntValue]); + XCTAssertEqual(504ULL, [[message getExtension:[UnittestRoot repeatedUint64Extension]][1] unsignedLongLongValue]); + XCTAssertEqual(505, [[message getExtension:[UnittestRoot repeatedSint32Extension]][1] intValue]); + XCTAssertEqual(506LL, [[message getExtension:[UnittestRoot repeatedSint64Extension]][1] longLongValue]); + XCTAssertEqual(507U, [[message getExtension:[UnittestRoot repeatedFixed32Extension]][1] unsignedIntValue]); + XCTAssertEqual(508ULL, [[message getExtension:[UnittestRoot repeatedFixed64Extension]][1] unsignedLongLongValue]); + XCTAssertEqual(509, [[message getExtension:[UnittestRoot repeatedSfixed32Extension]][1] intValue]); + XCTAssertEqual(510LL, [[message getExtension:[UnittestRoot repeatedSfixed64Extension]][1] longLongValue]); + XCTAssertEqualWithAccuracy(511.0f, [[message getExtension:[UnittestRoot repeatedFloatExtension]][1] floatValue], 0.01); + XCTAssertEqualWithAccuracy(512.0, [[message getExtension:[UnittestRoot repeatedDoubleExtension]][1] doubleValue], 0.01); + XCTAssertTrue([[message getExtension:[UnittestRoot repeatedBoolExtension]][1] boolValue]); + XCTAssertEqualObjects(@"515", [message getExtension:[UnittestRoot repeatedStringExtension]][1]); + XCTAssertEqualObjects([NSData gpbtu_dataWithUint32:516], [message getExtension:[UnittestRoot repeatedBytesExtension]][1]); + + XCTAssertEqual(517, [(TestAllTypes_OptionalGroup*)[message getExtension:[UnittestRoot repeatedGroupExtension]][1] a]); + XCTAssertEqual(518, [(TestAllTypes_NestedMessage*)[message getExtension:[UnittestRoot repeatedNestedMessageExtension]][1] bb]); + XCTAssertEqual(519, [[message getExtension:[UnittestRoot repeatedForeignMessageExtension]][1] c]); + XCTAssertEqual(520, [[message getExtension:[UnittestRoot repeatedImportMessageExtension]][1] d]); + + XCTAssertEqual(TestAllTypes_NestedEnum_Foo, + [[message getExtension:[UnittestRoot repeatedNestedEnumExtension]][1] intValue]); + XCTAssertEqual(ForeignEnum_ForeignFoo, + [[message getExtension:[UnittestRoot repeatedForeignEnumExtension]][1] intValue]); + XCTAssertEqual(ImportEnum_ImportFoo, + [[message getExtension:[UnittestRoot repeatedImportEnumExtension]][1] intValue]); + + XCTAssertEqualObjects(@"524", [message getExtension:[UnittestRoot repeatedStringPieceExtension]][1]); + XCTAssertEqualObjects(@"525", [message getExtension:[UnittestRoot repeatedCordExtension]][1]); +} + +// ------------------------------------------------------------------- + +- (void)assertAllFieldsSet:(TestAllTypes *)message + repeatedCount:(uint32_t)count { + XCTAssertTrue(message.hasOptionalInt32); + XCTAssertTrue(message.hasOptionalInt64); + XCTAssertTrue(message.hasOptionalUint32); + XCTAssertTrue(message.hasOptionalUint64); + XCTAssertTrue(message.hasOptionalSint32); + XCTAssertTrue(message.hasOptionalSint64); + XCTAssertTrue(message.hasOptionalFixed32); + XCTAssertTrue(message.hasOptionalFixed64); + XCTAssertTrue(message.hasOptionalSfixed32); + XCTAssertTrue(message.hasOptionalSfixed64); + XCTAssertTrue(message.hasOptionalFloat); + XCTAssertTrue(message.hasOptionalDouble); + XCTAssertTrue(message.hasOptionalBool); + XCTAssertTrue(message.hasOptionalString); + XCTAssertTrue(message.hasOptionalBytes); + + XCTAssertTrue(message.hasOptionalGroup); + XCTAssertTrue(message.hasOptionalNestedMessage); + XCTAssertTrue(message.hasOptionalForeignMessage); + XCTAssertTrue(message.hasOptionalImportMessage); + + XCTAssertTrue(message.optionalGroup.hasA); + XCTAssertTrue(message.optionalNestedMessage.hasBb); + XCTAssertTrue(message.optionalForeignMessage.hasC); + XCTAssertTrue(message.optionalImportMessage.hasD); + + XCTAssertTrue(message.hasOptionalNestedEnum); + XCTAssertTrue(message.hasOptionalForeignEnum); + XCTAssertTrue(message.hasOptionalImportEnum); + + XCTAssertTrue(message.hasOptionalStringPiece); + XCTAssertTrue(message.hasOptionalCord); + + XCTAssertEqual(101, message.optionalInt32); + XCTAssertEqual(102LL, message.optionalInt64); + XCTAssertEqual(103U, message.optionalUint32); + XCTAssertEqual(104ULL, message.optionalUint64); + XCTAssertEqual(105, message.optionalSint32); + XCTAssertEqual(106LL, message.optionalSint64); + XCTAssertEqual(107U, message.optionalFixed32); + XCTAssertEqual(108ULL, message.optionalFixed64); + XCTAssertEqual(109, message.optionalSfixed32); + XCTAssertEqual(110LL, message.optionalSfixed64); + XCTAssertEqualWithAccuracy(111.0f, message.optionalFloat, 0.1); + XCTAssertEqualWithAccuracy(112.0, message.optionalDouble, 0.1); + XCTAssertTrue(message.optionalBool); + XCTAssertEqualObjects(@"115", message.optionalString); + XCTAssertEqualObjects([NSData gpbtu_dataWithEmbeddedNulls], + message.optionalBytes); + + XCTAssertEqual(117, message.optionalGroup.a); + XCTAssertEqual(118, message.optionalNestedMessage.bb); + XCTAssertEqual(119, message.optionalForeignMessage.c); + XCTAssertEqual(120, message.optionalImportMessage.d); + + XCTAssertEqual(TestAllTypes_NestedEnum_Baz, message.optionalNestedEnum); + XCTAssertEqual(ForeignEnum_ForeignBaz, message.optionalForeignEnum); + XCTAssertEqual(ImportEnum_ImportBaz, message.optionalImportEnum); + + XCTAssertEqualObjects(@"124", message.optionalStringPiece); + XCTAssertEqualObjects(@"125", message.optionalCord); + + // ----------------------------------------------------------------- + + 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]); + XCTAssertEqual(202 + i * 100, [message.repeatedInt64Array valueAtIndex:i]); + XCTAssertEqual(203 + i * 100, [message.repeatedUint32Array valueAtIndex:i]); + XCTAssertEqual(204 + i * 100, [message.repeatedUint64Array valueAtIndex:i]); + XCTAssertEqual((int)(205 + i * 100), + [message.repeatedSint32Array valueAtIndex:i]); + XCTAssertEqual(206 + i * 100, [message.repeatedSint64Array valueAtIndex:i]); + XCTAssertEqual(207 + i * 100, + [message.repeatedFixed32Array valueAtIndex:i]); + XCTAssertEqual(208 + i * 100, + [message.repeatedFixed64Array valueAtIndex:i]); + XCTAssertEqual((int)(209 + i * 100), + [message.repeatedSfixed32Array valueAtIndex:i]); + XCTAssertEqual(210 + i * 100, + [message.repeatedSfixed64Array valueAtIndex:i]); + XCTAssertEqualWithAccuracy( + 211 + i * 100, [message.repeatedFloatArray valueAtIndex:i], 0.1); + XCTAssertEqualWithAccuracy( + 212 + i * 100, [message.repeatedDoubleArray valueAtIndex:i], 0.1); + XCTAssertEqual((i % 2) ? YES : NO, + [message.repeatedBoolArray valueAtIndex:i]); + + NSString *string = [[NSString alloc] initWithFormat:@"%d", 215 + i * 100]; + XCTAssertEqualObjects(string, message.repeatedStringArray[i]); + [string release]; + + NSData *data = [[NSData alloc] initWithUint32_gpbtu:216 + i * 100]; + XCTAssertEqualObjects(data, message.repeatedBytesArray[i]); + [data release]; + + XCTAssertEqual((int)(217 + i * 100), ((TestAllTypes_RepeatedGroup*)message.repeatedGroupArray[i]).a); + XCTAssertEqual((int)(218 + i * 100), ((TestAllTypes_NestedMessage*)message.repeatedNestedMessageArray[i]).bb); + XCTAssertEqual((int)(219 + i * 100), ((ForeignMessage*)message.repeatedForeignMessageArray[i]).c); + XCTAssertEqual((int)(220 + i * 100), ((ImportMessage*)message.repeatedImportMessageArray[i]).d); + + XCTAssertEqual((i % 2) ? TestAllTypes_NestedEnum_Bar : TestAllTypes_NestedEnum_Baz, [message.repeatedNestedEnumArray valueAtIndex:i]); + XCTAssertEqual((i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz, [message.repeatedForeignEnumArray valueAtIndex:i]); + XCTAssertEqual((i % 2) ? ImportEnum_ImportBar : ImportEnum_ImportBaz, [message.repeatedImportEnumArray valueAtIndex:i]); + + string = [[NSString alloc] initWithFormat:@"%d", 224 + i * 100]; + XCTAssertEqualObjects(string, message.repeatedStringPieceArray[i]); + [string release]; + + string = [[NSString alloc] initWithFormat:@"%d", 225 + i * 100]; + XCTAssertEqualObjects(string, message.repeatedCordArray[i]); + [string release]; + } + + // ----------------------------------------------------------------- + + XCTAssertTrue(message.hasDefaultInt32); + XCTAssertTrue(message.hasDefaultInt64); + XCTAssertTrue(message.hasDefaultUint32); + XCTAssertTrue(message.hasDefaultUint64); + XCTAssertTrue(message.hasDefaultSint32); + XCTAssertTrue(message.hasDefaultSint64); + XCTAssertTrue(message.hasDefaultFixed32); + XCTAssertTrue(message.hasDefaultFixed64); + XCTAssertTrue(message.hasDefaultSfixed32); + XCTAssertTrue(message.hasDefaultSfixed64); + XCTAssertTrue(message.hasDefaultFloat); + XCTAssertTrue(message.hasDefaultDouble); + XCTAssertTrue(message.hasDefaultBool); + XCTAssertTrue(message.hasDefaultString); + XCTAssertTrue(message.hasDefaultBytes); + + XCTAssertTrue(message.hasDefaultNestedEnum); + XCTAssertTrue(message.hasDefaultForeignEnum); + XCTAssertTrue(message.hasDefaultImportEnum); + + XCTAssertTrue(message.hasDefaultStringPiece); + XCTAssertTrue(message.hasDefaultCord); + + XCTAssertEqual(401, message.defaultInt32); + XCTAssertEqual(402LL, message.defaultInt64); + XCTAssertEqual(403U, message.defaultUint32); + XCTAssertEqual(404ULL, message.defaultUint64); + XCTAssertEqual(405, message.defaultSint32); + XCTAssertEqual(406LL, message.defaultSint64); + XCTAssertEqual(407U, message.defaultFixed32); + XCTAssertEqual(408ULL, message.defaultFixed64); + XCTAssertEqual(409, message.defaultSfixed32); + XCTAssertEqual(410LL, message.defaultSfixed64); + XCTAssertEqualWithAccuracy(411.0f, message.defaultFloat, 0.1); + XCTAssertEqualWithAccuracy(412.0, message.defaultDouble, 0.1); + XCTAssertFalse(message.defaultBool); + XCTAssertEqualObjects(@"415", message.defaultString); + XCTAssertEqualObjects([NSData gpbtu_dataWithUint32:416], + message.defaultBytes); + + XCTAssertEqual(TestAllTypes_NestedEnum_Foo, message.defaultNestedEnum); + XCTAssertEqual(ForeignEnum_ForeignFoo, message.defaultForeignEnum); + XCTAssertEqual(ImportEnum_ImportFoo, message.defaultImportEnum); + + XCTAssertEqualObjects(@"424", message.defaultStringPiece); + XCTAssertEqualObjects(@"425", message.defaultCord); +} + +- (void)setAllFields:(TestAllTypes *)message repeatedCount:(uint32_t)count { + [message setOptionalInt32:101]; + [message setOptionalInt64:102]; + [message setOptionalUint32:103]; + [message setOptionalUint64:104]; + [message setOptionalSint32:105]; + [message setOptionalSint64:106]; + [message setOptionalFixed32:107]; + [message setOptionalFixed64:108]; + [message setOptionalSfixed32:109]; + [message setOptionalSfixed64:110]; + [message setOptionalFloat:111]; + [message setOptionalDouble:112]; + [message setOptionalBool:YES]; + [message setOptionalString:@"115"]; + [message setOptionalBytes:[NSData gpbtu_dataWithEmbeddedNulls]]; + + TestAllTypes_OptionalGroup *allTypes = [TestAllTypes_OptionalGroup message]; + [allTypes setA:117]; + [message setOptionalGroup:allTypes]; + TestAllTypes_NestedMessage *nestedMessage = + [TestAllTypes_NestedMessage message]; + [nestedMessage setBb:118]; + [message setOptionalNestedMessage:nestedMessage]; + ForeignMessage *foreignMessage = [ForeignMessage message]; + [foreignMessage setC:119]; + [message setOptionalForeignMessage:foreignMessage]; + ImportMessage *importMessage = [ImportMessage message]; + [importMessage setD:120]; + [message setOptionalImportMessage:importMessage]; + + [message setOptionalNestedEnum:TestAllTypes_NestedEnum_Baz]; + [message setOptionalForeignEnum:ForeignEnum_ForeignBaz]; + [message setOptionalImportEnum:ImportEnum_ImportBaz]; + + [message setOptionalStringPiece:@"124"]; + [message setOptionalCord:@"125"]; + + // ----------------------------------------------------------------- + + for (uint32_t i = 0; i < count; i++) { + [message.repeatedInt32Array addValue:201 + i * 100]; + [message.repeatedInt64Array addValue:202 + i * 100]; + [message.repeatedUint32Array addValue:203 + i * 100]; + [message.repeatedUint64Array addValue:204 + i * 100]; + [message.repeatedSint32Array addValue:205 + i * 100]; + [message.repeatedSint64Array addValue:206 + i * 100]; + [message.repeatedFixed32Array addValue:207 + i * 100]; + [message.repeatedFixed64Array addValue:208 + i * 100]; + [message.repeatedSfixed32Array addValue:209 + i * 100]; + [message.repeatedSfixed64Array addValue:210 + i * 100]; + [message.repeatedFloatArray addValue:211 + i * 100]; + [message.repeatedDoubleArray addValue:212 + i * 100]; + [message.repeatedBoolArray addValue:(i % 2)]; + NSString *string = [[NSString alloc] initWithFormat:@"%d", 215 + i * 100]; + [message.repeatedStringArray addObject:string]; + [string release]; + + NSData *data = [[NSData alloc] initWithUint32_gpbtu:216 + i * 100]; + [message.repeatedBytesArray addObject:data]; + [data release]; + + TestAllTypes_RepeatedGroup *testAll = + [[TestAllTypes_RepeatedGroup alloc] init]; + [testAll setA:217 + i * 100]; + [message.repeatedGroupArray addObject:testAll]; + [testAll release]; + + nestedMessage = [[TestAllTypes_NestedMessage alloc] init]; + [nestedMessage setBb:218 + i * 100]; + [message.repeatedNestedMessageArray addObject:nestedMessage]; + [nestedMessage release]; + + foreignMessage = [[ForeignMessage alloc] init]; + [foreignMessage setC:219 + i * 100]; + [message.repeatedForeignMessageArray addObject:foreignMessage]; + [foreignMessage release]; + + importMessage = [[ImportMessage alloc] init]; + [importMessage setD:220 + i * 100]; + [message.repeatedImportMessageArray addObject:importMessage]; + [importMessage release]; + + [message.repeatedNestedEnumArray addValue:(i % 2) ? TestAllTypes_NestedEnum_Bar : TestAllTypes_NestedEnum_Baz]; + + [message.repeatedForeignEnumArray addValue:(i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz]; + [message.repeatedImportEnumArray addValue:(i % 2) ? ImportEnum_ImportBar : ImportEnum_ImportBaz]; + + string = [[NSString alloc] initWithFormat:@"%d", 224 + i * 100]; + [message.repeatedStringPieceArray addObject:string]; + [string release]; + + string = [[NSString alloc] initWithFormat:@"%d", 225 + i * 100]; + [message.repeatedCordArray addObject:string]; + [string release]; + } + // ----------------------------------------------------------------- + + message.defaultInt32 = 401; + message.defaultInt64 = 402; + message.defaultUint32 = 403; + message.defaultUint64 = 404; + message.defaultSint32 = 405; + message.defaultSint64 = 406; + message.defaultFixed32 = 407; + message.defaultFixed64 = 408; + message.defaultSfixed32 = 409; + message.defaultSfixed64 = 410; + message.defaultFloat = 411; + message.defaultDouble = 412; + message.defaultBool = NO; + message.defaultString = @"415"; + message.defaultBytes = [NSData gpbtu_dataWithUint32:416]; + + message.defaultNestedEnum = TestAllTypes_NestedEnum_Foo; + message.defaultForeignEnum = ForeignEnum_ForeignFoo; + message.defaultImportEnum = ImportEnum_ImportFoo; + + message.defaultStringPiece = @"424"; + message.defaultCord = @"425"; +} + +- (void)clearAllFields:(TestAllTypes *)message { + message.hasOptionalInt32 = NO; + message.hasOptionalInt64 = NO; + message.hasOptionalUint32 = NO; + message.hasOptionalUint64 = NO; + message.hasOptionalSint32 = NO; + message.hasOptionalSint64 = NO; + message.hasOptionalFixed32 = NO; + message.hasOptionalFixed64 = NO; + message.hasOptionalSfixed32 = NO; + message.hasOptionalSfixed64 = NO; + message.hasOptionalFloat = NO; + message.hasOptionalDouble = NO; + message.hasOptionalBool = NO; + message.hasOptionalString = NO; + message.hasOptionalBytes = NO; + + message.hasOptionalGroup = NO; + message.hasOptionalNestedMessage = NO; + message.hasOptionalForeignMessage = NO; + message.hasOptionalImportMessage = NO; + + message.hasOptionalNestedEnum = NO; + message.hasOptionalForeignEnum = NO; + message.hasOptionalImportEnum = NO; + + message.hasOptionalStringPiece = NO; + message.hasOptionalCord = NO; + + // ----------------------------------------------------------------- + + [message.repeatedInt32Array removeAll]; + [message.repeatedInt64Array removeAll]; + [message.repeatedUint32Array removeAll]; + [message.repeatedUint64Array removeAll]; + [message.repeatedSint32Array removeAll]; + [message.repeatedSint64Array removeAll]; + [message.repeatedFixed32Array removeAll]; + [message.repeatedFixed64Array removeAll]; + [message.repeatedSfixed32Array removeAll]; + [message.repeatedSfixed64Array removeAll]; + [message.repeatedFloatArray removeAll]; + [message.repeatedDoubleArray removeAll]; + [message.repeatedBoolArray removeAll]; + [message.repeatedStringArray removeAllObjects]; + [message.repeatedBytesArray removeAllObjects]; + + [message.repeatedGroupArray removeAllObjects]; + [message.repeatedNestedMessageArray removeAllObjects]; + [message.repeatedForeignMessageArray removeAllObjects]; + [message.repeatedImportMessageArray removeAllObjects]; + + [message.repeatedNestedEnumArray removeAll]; + [message.repeatedForeignEnumArray removeAll]; + [message.repeatedImportEnumArray removeAll]; + + [message.repeatedStringPieceArray removeAllObjects]; + [message.repeatedCordArray removeAllObjects]; + + // ----------------------------------------------------------------- + + message.hasDefaultInt32 = NO; + message.hasDefaultInt64 = NO; + message.hasDefaultUint32 = NO; + message.hasDefaultUint64 = NO; + message.hasDefaultSint32 = NO; + message.hasDefaultSint64 = NO; + message.hasDefaultFixed32 = NO; + message.hasDefaultFixed64 = NO; + message.hasDefaultSfixed32 = NO; + message.hasDefaultSfixed64 = NO; + message.hasDefaultFloat = NO; + message.hasDefaultDouble = NO; + message.hasDefaultBool = NO; + message.hasDefaultString = NO; + message.hasDefaultBytes = NO; + + message.hasDefaultNestedEnum = NO; + message.hasDefaultForeignEnum = NO; + message.hasDefaultImportEnum = NO; + + message.hasDefaultStringPiece = NO; + message.hasDefaultCord = NO; +} + +- (void)setAllExtensions:(TestAllExtensions *)message + repeatedCount:(uint32_t)count { + [message setExtension:[UnittestRoot optionalInt32Extension] value:@101]; + [message setExtension:[UnittestRoot optionalInt64Extension] value:@102L]; + [message setExtension:[UnittestRoot optionalUint32Extension] value:@103]; + [message setExtension:[UnittestRoot optionalUint64Extension] value:@104L]; + [message setExtension:[UnittestRoot optionalSint32Extension] value:@105]; + [message setExtension:[UnittestRoot optionalSint64Extension] value:@106L]; + [message setExtension:[UnittestRoot optionalFixed32Extension] value:@107]; + [message setExtension:[UnittestRoot optionalFixed64Extension] value:@108L]; + [message setExtension:[UnittestRoot optionalSfixed32Extension] value:@109]; + [message setExtension:[UnittestRoot optionalSfixed64Extension] value:@110L]; + [message setExtension:[UnittestRoot optionalFloatExtension] value:@111.0f]; + [message setExtension:[UnittestRoot optionalDoubleExtension] value:@112.0]; + [message setExtension:[UnittestRoot optionalBoolExtension] value:@YES]; + [message setExtension:[UnittestRoot optionalStringExtension] value:@"115"]; + [message setExtension:[UnittestRoot optionalBytesExtension] + value:[NSData gpbtu_dataWithEmbeddedNulls]]; + + OptionalGroup_extension *optionalGroup = [OptionalGroup_extension message]; + [optionalGroup setA:117]; + [message setExtension:[UnittestRoot optionalGroupExtension] + value:optionalGroup]; + TestAllTypes_NestedMessage *nestedMessage = + [TestAllTypes_NestedMessage message]; + [nestedMessage setBb:118]; + [message setExtension:[UnittestRoot optionalNestedMessageExtension] + value:nestedMessage]; + ForeignMessage *foreignMessage = [ForeignMessage message]; + [foreignMessage setC:119]; + [message setExtension:[UnittestRoot optionalForeignMessageExtension] + value:foreignMessage]; + ImportMessage *importMessage = [ImportMessage message]; + [importMessage setD:120]; + [message setExtension:[UnittestRoot optionalImportMessageExtension] + value:importMessage]; + + [message setExtension:[UnittestRoot optionalNestedEnumExtension] + value:@(TestAllTypes_NestedEnum_Baz)]; + [message setExtension:[UnittestRoot optionalForeignEnumExtension] + value:@(ForeignEnum_ForeignBaz)]; + [message setExtension:[UnittestRoot optionalImportEnumExtension] + value:@(ImportEnum_ImportBaz)]; + + [message setExtension:[UnittestRoot optionalStringPieceExtension] + value:@"124"]; + [message setExtension:[UnittestRoot optionalCordExtension] value:@"125"]; + + for (uint32_t i = 0; i < count; ++i) { + [message addExtension:[UnittestRoot repeatedInt32Extension] + value:@(201 + i * 100)]; + [message addExtension:[UnittestRoot repeatedInt64Extension] + value:@(202 + i * 100)]; + [message addExtension:[UnittestRoot repeatedUint32Extension] + value:@(203 + i * 100)]; + [message addExtension:[UnittestRoot repeatedUint64Extension] + value:@(204 + i * 100)]; + [message addExtension:[UnittestRoot repeatedSint32Extension] + value:@(205 + i * 100)]; + [message addExtension:[UnittestRoot repeatedSint64Extension] + value:@(206 + i * 100)]; + [message addExtension:[UnittestRoot repeatedFixed32Extension] + value:@(207 + i * 100)]; + [message addExtension:[UnittestRoot repeatedFixed64Extension] + value:@(208 + i * 100)]; + [message addExtension:[UnittestRoot repeatedSfixed32Extension] + value:@(209 + i * 100)]; + [message addExtension:[UnittestRoot repeatedSfixed64Extension] + value:@(210 + i * 100)]; + [message addExtension:[UnittestRoot repeatedFloatExtension] + value:@(211 + i * 100)]; + [message addExtension:[UnittestRoot repeatedDoubleExtension] + value:@(212 + i * 100)]; + [message addExtension:[UnittestRoot repeatedBoolExtension] + value:@((i % 2) ? YES : NO)]; + NSString *string = [[NSString alloc] initWithFormat:@"%d", 215 + i * 100]; + [message addExtension:[UnittestRoot repeatedStringExtension] value:string]; + [string release]; + NSData *data = [[NSData alloc] initWithUint32_gpbtu:216 + i * 100]; + [message addExtension:[UnittestRoot repeatedBytesExtension] value:data]; + [data release]; + + RepeatedGroup_extension *repeatedGroup = + [[RepeatedGroup_extension alloc] init]; + [repeatedGroup setA:217 + i * 100]; + [message addExtension:[UnittestRoot repeatedGroupExtension] + value:repeatedGroup]; + [repeatedGroup release]; + nestedMessage = [[TestAllTypes_NestedMessage alloc] init]; + [nestedMessage setBb:218 + i * 100]; + [message addExtension:[UnittestRoot repeatedNestedMessageExtension] + value:nestedMessage]; + [nestedMessage release]; + foreignMessage = [[ForeignMessage alloc] init]; + [foreignMessage setC:219 + i * 100]; + [message addExtension:[UnittestRoot repeatedForeignMessageExtension] + value:foreignMessage]; + [foreignMessage release]; + importMessage = [[ImportMessage alloc] init]; + [importMessage setD:220 + i * 100]; + [message addExtension:[UnittestRoot repeatedImportMessageExtension] + value:importMessage]; + [importMessage release]; + [message addExtension:[UnittestRoot repeatedNestedEnumExtension] + value:@((i % 2) ? TestAllTypes_NestedEnum_Bar + : TestAllTypes_NestedEnum_Baz)]; + [message addExtension:[UnittestRoot repeatedForeignEnumExtension] + value:@((i % 2) ? ForeignEnum_ForeignBar + : ForeignEnum_ForeignBaz)]; + [message + addExtension:[UnittestRoot repeatedImportEnumExtension] + value:@((i % 2) ? ImportEnum_ImportBar : ImportEnum_ImportBaz)]; + + string = [[NSString alloc] initWithFormat:@"%d", 224 + i * 100]; + [message addExtension:[UnittestRoot repeatedStringPieceExtension] + value:string]; + [string release]; + + string = [[NSString alloc] initWithFormat:@"%d", 225 + i * 100]; + [message addExtension:[UnittestRoot repeatedCordExtension] value:string]; + [string release]; + } + + // ----------------------------------------------------------------- + + [message setExtension:[UnittestRoot defaultInt32Extension] value:@401]; + [message setExtension:[UnittestRoot defaultInt64Extension] value:@402L]; + [message setExtension:[UnittestRoot defaultUint32Extension] value:@403]; + [message setExtension:[UnittestRoot defaultUint64Extension] value:@404L]; + [message setExtension:[UnittestRoot defaultSint32Extension] value:@405]; + [message setExtension:[UnittestRoot defaultSint64Extension] value:@406L]; + [message setExtension:[UnittestRoot defaultFixed32Extension] value:@407]; + [message setExtension:[UnittestRoot defaultFixed64Extension] value:@408L]; + [message setExtension:[UnittestRoot defaultSfixed32Extension] value:@409]; + [message setExtension:[UnittestRoot defaultSfixed64Extension] value:@410L]; + [message setExtension:[UnittestRoot defaultFloatExtension] value:@411.0f]; + [message setExtension:[UnittestRoot defaultDoubleExtension] value:@412.0]; + [message setExtension:[UnittestRoot defaultBoolExtension] value:@NO]; + [message setExtension:[UnittestRoot defaultStringExtension] value:@"415"]; + [message setExtension:[UnittestRoot defaultBytesExtension] + value:[NSData gpbtu_dataWithUint32:416]]; + + [message setExtension:[UnittestRoot defaultNestedEnumExtension] + value:@(TestAllTypes_NestedEnum_Foo)]; + [message setExtension:[UnittestRoot defaultForeignEnumExtension] + value:@(ForeignEnum_ForeignFoo)]; + [message setExtension:[UnittestRoot defaultImportEnumExtension] + value:@(ImportEnum_ImportFoo)]; + + [message setExtension:[UnittestRoot defaultStringPieceExtension] + value:@"424"]; + [message setExtension:[UnittestRoot defaultCordExtension] value:@"425"]; +} + +- (void)setAllMapFields:(TestMap *)message numEntries:(uint32_t)count { + message.mapInt32Int32 = [GPBInt32Int32Dictionary dictionary]; + message.mapInt64Int64 = [GPBInt64Int64Dictionary dictionary]; + message.mapUint32Uint32 = [GPBUInt32UInt32Dictionary dictionary]; + message.mapUint64Uint64 = [GPBUInt64UInt64Dictionary dictionary]; + message.mapSint32Sint32 = [GPBInt32Int32Dictionary dictionary]; + message.mapSint64Sint64 = [GPBInt64Int64Dictionary dictionary]; + message.mapFixed32Fixed32 = [GPBUInt32UInt32Dictionary dictionary]; + message.mapFixed64Fixed64 = [GPBUInt64UInt64Dictionary dictionary]; + message.mapSfixed32Sfixed32 = [GPBInt32Int32Dictionary dictionary]; + message.mapSfixed64Sfixed64 = [GPBInt64Int64Dictionary dictionary]; + message.mapInt32Float = [GPBInt32FloatDictionary dictionary]; + message.mapInt32Double = [GPBInt32DoubleDictionary dictionary]; + message.mapBoolBool = [GPBBoolBoolDictionary dictionary]; + message.mapStringString = [NSMutableDictionary dictionary]; + message.mapInt32Bytes = [GPBInt32ObjectDictionary dictionary]; + message.mapInt32Enum = [GPBInt32EnumDictionary + dictionaryWithValidationFunction:MapEnum_IsValidValue]; + message.mapInt32ForeignMessage = [GPBInt32ObjectDictionary dictionary]; + + for (uint32_t i = 0; i < count; i++) { + [message.mapInt32Int32 setValue:(i + 1) forKey:100 + i * 100]; + [message.mapInt64Int64 setValue:(i + 1) forKey:101 + i * 100]; + [message.mapUint32Uint32 setValue:(i + 1) forKey:102 + i * 100]; + [message.mapUint64Uint64 setValue:(i + 1) forKey:103 + i * 100]; + [message.mapSint32Sint32 setValue:(i + 1) forKey:104 + i * 100]; + [message.mapSint64Sint64 setValue:(i + 1) forKey:105 + i * 100]; + [message.mapFixed32Fixed32 setValue:(i + 1) forKey:106 + i * 100]; + [message.mapFixed64Fixed64 setValue:(i + 1) forKey:107 + i * 100]; + [message.mapSfixed32Sfixed32 setValue:(i + 1) forKey:108 + i * 100]; + [message.mapSfixed64Sfixed64 setValue:(i + 1) forKey:109 + i * 100]; + [message.mapInt32Float setValue:(i + 1) forKey:110 + i * 100]; + [message.mapInt32Double setValue:(i + 1) forKey:111 + i * 100]; + [message.mapBoolBool setValue:((i % 2) == 1) forKey:((i % 2) == 0)]; + + NSString *keyStr = [[NSString alloc] initWithFormat:@"%d", 112 + i * 100]; + NSString *dataStr = [[NSString alloc] initWithFormat:@"%d", i + 1]; + [message.mapStringString setObject:dataStr forKey:keyStr]; + [keyStr release]; + [dataStr release]; + + NSData *data = [[NSData alloc] initWithUint32_gpbtu:i + 1]; + [message.mapInt32Bytes setValue:data forKey:113 + i * 100]; + [data release]; + + [message.mapInt32Enum + setValue:(i % 2) ? MapEnum_MapEnumBar : MapEnum_MapEnumBaz + forKey:114 + i * 100]; + + ForeignMessage *subMsg = [[ForeignMessage alloc] init]; + subMsg.c = i + 1; + [message.mapInt32ForeignMessage setValue:subMsg forKey:115 + i * 100]; + [subMsg release]; + } +} + +- (GPBExtensionRegistry *)extensionRegistry { + return [UnittestRoot extensionRegistry]; +} + +- (TestAllTypes *)allSetRepeatedCount:(uint32_t)count { + TestAllTypes *message = [TestAllTypes message]; + [self setAllFields:message repeatedCount:count]; + return message; +} + +- (TestAllExtensions *)allExtensionsSetRepeatedCount:(uint32_t)count { + TestAllExtensions *message = [TestAllExtensions message]; + [self setAllExtensions:message repeatedCount:count]; + return message; +} + +- (TestPackedTypes *)packedSetRepeatedCount:(uint32_t)count { + TestPackedTypes *message = [TestPackedTypes message]; + [self setPackedFields:message repeatedCount:count]; + return message; +} + +- (TestPackedExtensions *)packedExtensionsSetRepeatedCount:(uint32_t)count { + TestPackedExtensions *message = [TestPackedExtensions message]; + [self setPackedExtensions:message repeatedCount:count]; + return message; +} + +// ------------------------------------------------------------------- + +- (void)assertClear:(TestAllTypes *)message { + // hasBlah() should initially be NO for all optional fields. + XCTAssertFalse(message.hasOptionalInt32); + XCTAssertFalse(message.hasOptionalInt64); + XCTAssertFalse(message.hasOptionalUint32); + XCTAssertFalse(message.hasOptionalUint64); + XCTAssertFalse(message.hasOptionalSint32); + XCTAssertFalse(message.hasOptionalSint64); + XCTAssertFalse(message.hasOptionalFixed32); + XCTAssertFalse(message.hasOptionalFixed64); + XCTAssertFalse(message.hasOptionalSfixed32); + XCTAssertFalse(message.hasOptionalSfixed64); + XCTAssertFalse(message.hasOptionalFloat); + XCTAssertFalse(message.hasOptionalDouble); + XCTAssertFalse(message.hasOptionalBool); + XCTAssertFalse(message.hasOptionalString); + XCTAssertFalse(message.hasOptionalBytes); + + XCTAssertFalse(message.hasOptionalGroup); + XCTAssertFalse(message.hasOptionalNestedMessage); + XCTAssertFalse(message.hasOptionalForeignMessage); + XCTAssertFalse(message.hasOptionalImportMessage); + + XCTAssertFalse(message.hasOptionalNestedEnum); + XCTAssertFalse(message.hasOptionalForeignEnum); + XCTAssertFalse(message.hasOptionalImportEnum); + + XCTAssertFalse(message.hasOptionalStringPiece); + XCTAssertFalse(message.hasOptionalCord); + + // Optional fields without defaults are set to zero or something like it. + XCTAssertEqual(0, message.optionalInt32); + XCTAssertEqual(0LL, message.optionalInt64); + XCTAssertEqual(0U, message.optionalUint32); + XCTAssertEqual(0ULL, message.optionalUint64); + XCTAssertEqual(0, message.optionalSint32); + XCTAssertEqual(0LL, message.optionalSint64); + XCTAssertEqual(0U, message.optionalFixed32); + XCTAssertEqual(0ULL, message.optionalFixed64); + XCTAssertEqual(0, message.optionalSfixed32); + XCTAssertEqual(0LL, message.optionalSfixed64); + XCTAssertEqual(0.0f, message.optionalFloat); + XCTAssertEqual(0.0, message.optionalDouble); + XCTAssertFalse(message.optionalBool); + XCTAssertEqualObjects(message.optionalString, @""); + XCTAssertEqualObjects(message.optionalBytes, GPBEmptyNSData()); + + // Embedded messages should also be clear. + XCTAssertFalse(message.hasOptionalGroup); + XCTAssertFalse(message.hasOptionalNestedMessage); + XCTAssertFalse(message.hasOptionalForeignMessage); + XCTAssertFalse(message.hasOptionalImportMessage); + + // Enums without defaults are set to the first value in the enum. + XCTAssertEqual(TestAllTypes_NestedEnum_Foo, message.optionalNestedEnum); + XCTAssertEqual(ForeignEnum_ForeignFoo, message.optionalForeignEnum); + XCTAssertEqual(ImportEnum_ImportFoo, message.optionalImportEnum); + + XCTAssertEqualObjects(message.optionalStringPiece, @""); + XCTAssertEqualObjects(message.optionalCord, @""); + + // Repeated fields are empty. + 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); + XCTAssertFalse(message.hasDefaultUint32); + XCTAssertFalse(message.hasDefaultUint64); + XCTAssertFalse(message.hasDefaultSint32); + XCTAssertFalse(message.hasDefaultSint64); + XCTAssertFalse(message.hasDefaultFixed32); + XCTAssertFalse(message.hasDefaultFixed64); + XCTAssertFalse(message.hasDefaultSfixed32); + XCTAssertFalse(message.hasDefaultSfixed64); + XCTAssertFalse(message.hasDefaultFloat); + XCTAssertFalse(message.hasDefaultDouble); + XCTAssertFalse(message.hasDefaultBool); + XCTAssertFalse(message.hasDefaultString); + XCTAssertFalse(message.hasDefaultBytes); + + XCTAssertFalse(message.hasDefaultNestedEnum); + XCTAssertFalse(message.hasDefaultForeignEnum); + XCTAssertFalse(message.hasDefaultImportEnum); + + XCTAssertFalse(message.hasDefaultStringPiece); + XCTAssertFalse(message.hasDefaultCord); + + // Fields with defaults have their default values (duh). + XCTAssertEqual(41, message.defaultInt32); + XCTAssertEqual(42LL, message.defaultInt64); + XCTAssertEqual(43U, message.defaultUint32); + XCTAssertEqual(44ULL, message.defaultUint64); + XCTAssertEqual(-45, message.defaultSint32); + XCTAssertEqual(46LL, message.defaultSint64); + XCTAssertEqual(47U, message.defaultFixed32); + XCTAssertEqual(48ULL, message.defaultFixed64); + XCTAssertEqual(49, message.defaultSfixed32); + XCTAssertEqual(-50LL, message.defaultSfixed64); + XCTAssertEqualWithAccuracy(51.5f, message.defaultFloat, 0.1); + XCTAssertEqualWithAccuracy(52e3, message.defaultDouble, 0.1); + XCTAssertTrue(message.defaultBool); + XCTAssertEqualObjects(@"hello", message.defaultString); + XCTAssertEqualObjects([NSData gpbtu_dataWithCString:"world"], + message.defaultBytes); + + XCTAssertEqual(TestAllTypes_NestedEnum_Bar, message.defaultNestedEnum); + XCTAssertEqual(ForeignEnum_ForeignBar, message.defaultForeignEnum); + XCTAssertEqual(ImportEnum_ImportBar, message.defaultImportEnum); + + XCTAssertEqualObjects(@"abc", message.defaultStringPiece); + XCTAssertEqualObjects(@"123", message.defaultCord); +} + +- (void)assertExtensionsClear:(TestAllExtensions *)message { + // hasBlah() should initially be NO for all optional fields. + XCTAssertFalse([message hasExtension:[UnittestRoot optionalInt32Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalInt64Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalUint32Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalUint64Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalSint32Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalSint64Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalFixed32Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalFixed64Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalSfixed32Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalSfixed64Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalFloatExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalDoubleExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalBoolExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalStringExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalBytesExtension]]); + + XCTAssertFalse([message hasExtension:[UnittestRoot optionalGroupExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalNestedMessageExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalForeignMessageExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalImportMessageExtension]]); + + XCTAssertFalse([message hasExtension:[UnittestRoot optionalNestedEnumExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalForeignEnumExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalImportEnumExtension]]); + + XCTAssertFalse([message hasExtension:[UnittestRoot optionalStringPieceExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot optionalCordExtension]]); + + // Optional fields without defaults are set to zero or something like it. + XCTAssertEqual(0, [[message getExtension:[UnittestRoot optionalInt32Extension]] intValue]); + XCTAssertEqual(0LL,[[message getExtension:[UnittestRoot optionalInt64Extension]] longLongValue]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot optionalUint32Extension]] unsignedIntValue]); + XCTAssertEqual(0ULL, [[message getExtension:[UnittestRoot optionalUint64Extension]] unsignedLongLongValue]); + XCTAssertEqual(0, [[message getExtension:[UnittestRoot optionalSint32Extension]] intValue]); + XCTAssertEqual(0LL, [[message getExtension:[UnittestRoot optionalSint64Extension]] longLongValue]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot optionalFixed32Extension]] unsignedIntValue]); + XCTAssertEqual(0ULL, [[message getExtension:[UnittestRoot optionalFixed64Extension]] unsignedLongLongValue]); + XCTAssertEqual(0, [[message getExtension:[UnittestRoot optionalSfixed32Extension]] intValue]); + XCTAssertEqual(0LL, [[message getExtension:[UnittestRoot optionalSfixed64Extension]] longLongValue]); + XCTAssertEqualWithAccuracy(0.0f, [[message getExtension:[UnittestRoot optionalFloatExtension]] floatValue], 0.01); + XCTAssertEqualWithAccuracy(0.0, [[message getExtension:[UnittestRoot optionalDoubleExtension]] doubleValue], 0.01); + XCTAssertFalse([[message getExtension:[UnittestRoot optionalBoolExtension]] boolValue]); + XCTAssertEqualObjects(@"", [message getExtension:[UnittestRoot optionalStringExtension]]); + XCTAssertEqualObjects(GPBEmptyNSData(), [message getExtension:[UnittestRoot optionalBytesExtension]]); + + // Embedded messages should also be clear. + + XCTAssertFalse([[message getExtension:[UnittestRoot optionalGroupExtension]] hasA]); + XCTAssertFalse([[message getExtension:[UnittestRoot optionalNestedMessageExtension]] hasBb]); + XCTAssertFalse([[message getExtension:[UnittestRoot optionalForeignMessageExtension]] hasC]); + XCTAssertFalse([[message getExtension:[UnittestRoot optionalImportMessageExtension]] hasD]); + + XCTAssertEqual(0, [(TestAllTypes_OptionalGroup*)[message getExtension:[UnittestRoot optionalGroupExtension]] a]); + XCTAssertEqual(0, [(TestAllTypes_NestedMessage*)[message getExtension:[UnittestRoot optionalNestedMessageExtension]] bb]); + XCTAssertEqual(0, [[message getExtension:[UnittestRoot optionalForeignMessageExtension]] c]); + XCTAssertEqual(0, [[message getExtension:[UnittestRoot optionalImportMessageExtension]] d]); + + // Enums without defaults are set to the first value in the enum. + XCTAssertEqual(TestAllTypes_NestedEnum_Foo, + [[message getExtension:[UnittestRoot optionalNestedEnumExtension]] intValue]); + XCTAssertEqual(ForeignEnum_ForeignFoo, + [[message getExtension:[UnittestRoot optionalForeignEnumExtension]] intValue]); + XCTAssertEqual(ImportEnum_ImportFoo, + [[message getExtension:[UnittestRoot optionalImportEnumExtension]] intValue]); + + XCTAssertEqualObjects(@"", [message getExtension:[UnittestRoot optionalStringPieceExtension]]); + XCTAssertEqualObjects(@"", [message getExtension:[UnittestRoot optionalCordExtension]]); + + // Repeated fields are empty. + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedInt32Extension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedInt64Extension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedUint32Extension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedUint64Extension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedSint32Extension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedSint64Extension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedFixed32Extension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedFixed64Extension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedSfixed32Extension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedSfixed64Extension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedFloatExtension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedDoubleExtension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedBoolExtension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedStringExtension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedBytesExtension]] count]); + + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedGroupExtension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedNestedMessageExtension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedForeignMessageExtension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedImportMessageExtension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedNestedEnumExtension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedForeignEnumExtension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedImportEnumExtension]] count]); + + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedStringPieceExtension]] count]); + XCTAssertEqual(0U, [[message getExtension:[UnittestRoot repeatedCordExtension]] count]); + + // hasBlah() should also be NO for all default fields. + XCTAssertFalse([message hasExtension:[UnittestRoot defaultInt32Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultInt64Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultUint32Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultUint64Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultSint32Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultSint64Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultFixed32Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultFixed64Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultSfixed32Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultSfixed64Extension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultFloatExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultDoubleExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultBoolExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultStringExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultBytesExtension]]); + + XCTAssertFalse([message hasExtension:[UnittestRoot defaultNestedEnumExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultForeignEnumExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultImportEnumExtension]]); + + XCTAssertFalse([message hasExtension:[UnittestRoot defaultStringPieceExtension]]); + XCTAssertFalse([message hasExtension:[UnittestRoot defaultCordExtension]]); + + // Fields with defaults have their default values (duh). + XCTAssertEqual( 41, [[message getExtension:[UnittestRoot defaultInt32Extension]] intValue]); + XCTAssertEqual( 42LL, [[message getExtension:[UnittestRoot defaultInt64Extension]] longLongValue]); + XCTAssertEqual( 43U, [[message getExtension:[UnittestRoot defaultUint32Extension]] unsignedIntValue]); + XCTAssertEqual( 44ULL, [[message getExtension:[UnittestRoot defaultUint64Extension]] unsignedLongLongValue]); + XCTAssertEqual(-45, [[message getExtension:[UnittestRoot defaultSint32Extension]] intValue]); + XCTAssertEqual( 46LL, [[message getExtension:[UnittestRoot defaultSint64Extension]] longLongValue]); + XCTAssertEqual( 47, [[message getExtension:[UnittestRoot defaultFixed32Extension]] intValue]); + XCTAssertEqual( 48ULL, [[message getExtension:[UnittestRoot defaultFixed64Extension]] unsignedLongLongValue]); + XCTAssertEqual( 49, [[message getExtension:[UnittestRoot defaultSfixed32Extension]] intValue]); + XCTAssertEqual(-50LL, [[message getExtension:[UnittestRoot defaultSfixed64Extension]] longLongValue]); + XCTAssertEqualWithAccuracy( 51.5f, [[message getExtension:[UnittestRoot defaultFloatExtension]] floatValue], 0.01); + XCTAssertEqualWithAccuracy( 52e3, [[message getExtension:[UnittestRoot defaultDoubleExtension]] doubleValue], 0.01); + XCTAssertTrue([[message getExtension:[UnittestRoot defaultBoolExtension]] boolValue]); + XCTAssertEqualObjects(@"hello", [message getExtension:[UnittestRoot defaultStringExtension]]); + XCTAssertEqualObjects([NSData gpbtu_dataWithCString:"world"], [message getExtension:[UnittestRoot defaultBytesExtension]]); + + XCTAssertEqual(TestAllTypes_NestedEnum_Bar, + [[message getExtension:[UnittestRoot defaultNestedEnumExtension]] intValue]); + XCTAssertEqual(ForeignEnum_ForeignBar, + [[message getExtension:[UnittestRoot defaultForeignEnumExtension]] intValue]); + XCTAssertEqual(ImportEnum_ImportBar, + [[message getExtension:[UnittestRoot defaultImportEnumExtension]] intValue]); + + XCTAssertEqualObjects(@"abc", [message getExtension:[UnittestRoot defaultStringPieceExtension]]); + XCTAssertEqualObjects(@"123", [message getExtension:[UnittestRoot defaultCordExtension]]); +} + +- (void)modifyRepeatedFields:(TestAllTypes *)message { + [message.repeatedInt32Array replaceValueAtIndex:1 withValue:501]; + [message.repeatedInt64Array replaceValueAtIndex:1 withValue:502]; + [message.repeatedUint32Array replaceValueAtIndex:1 withValue:503]; + [message.repeatedUint64Array replaceValueAtIndex:1 withValue:504]; + [message.repeatedSint32Array replaceValueAtIndex:1 withValue:505]; + [message.repeatedSint64Array replaceValueAtIndex:1 withValue:506]; + [message.repeatedFixed32Array replaceValueAtIndex:1 withValue:507]; + [message.repeatedFixed64Array replaceValueAtIndex:1 withValue:508]; + [message.repeatedSfixed32Array replaceValueAtIndex:1 withValue:509]; + [message.repeatedSfixed64Array replaceValueAtIndex:1 withValue:510]; + [message.repeatedFloatArray replaceValueAtIndex:1 withValue:511]; + [message.repeatedDoubleArray replaceValueAtIndex:1 withValue:512]; + [message.repeatedBoolArray replaceValueAtIndex:1 withValue:YES]; + [message.repeatedStringArray replaceObjectAtIndex:1 withObject:@"515"]; + + NSData *data = [[NSData alloc] initWithUint32_gpbtu:516]; + [message.repeatedBytesArray replaceObjectAtIndex:1 withObject:data]; + [data release]; + + TestAllTypes_RepeatedGroup *testAll = + [[TestAllTypes_RepeatedGroup alloc] init]; + [testAll setA:517]; + [message.repeatedGroupArray replaceObjectAtIndex:1 withObject:testAll]; + [testAll release]; + + TestAllTypes_NestedMessage *nestedMessage = + [[TestAllTypes_NestedMessage alloc] init]; + [nestedMessage setBb:518]; + [message.repeatedNestedMessageArray replaceObjectAtIndex:1 + withObject:nestedMessage]; + [nestedMessage release]; + + ForeignMessage *foreignMessage = [[ForeignMessage alloc] init]; + [foreignMessage setC:519]; + [message.repeatedForeignMessageArray replaceObjectAtIndex:1 + withObject:foreignMessage]; + [foreignMessage release]; + + ImportMessage *importMessage = [[ImportMessage alloc] init]; + [importMessage setD:520]; + [message.repeatedImportMessageArray replaceObjectAtIndex:1 + withObject:importMessage]; + [importMessage release]; + + [message.repeatedNestedEnumArray replaceValueAtIndex:1 withValue:TestAllTypes_NestedEnum_Foo]; + [message.repeatedForeignEnumArray replaceValueAtIndex:1 withValue:ForeignEnum_ForeignFoo]; + [message.repeatedImportEnumArray replaceValueAtIndex:1 withValue:ImportEnum_ImportFoo]; + + [message.repeatedStringPieceArray replaceObjectAtIndex:1 withObject:@"524"]; + [message.repeatedCordArray replaceObjectAtIndex:1 withObject:@"525"]; +} + +- (void)assertRepeatedFieldsModified:(TestAllTypes *)message + repeatedCount:(uint32_t)count { + // 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); + 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]); + XCTAssertEqual(204ULL, [message.repeatedUint64Array valueAtIndex:0]); + XCTAssertEqual(205, [message.repeatedSint32Array valueAtIndex:0]); + XCTAssertEqual(206LL, [message.repeatedSint64Array valueAtIndex:0]); + XCTAssertEqual(207U, [message.repeatedFixed32Array valueAtIndex:0]); + XCTAssertEqual(208ULL, [message.repeatedFixed64Array valueAtIndex:0]); + XCTAssertEqual(209, [message.repeatedSfixed32Array valueAtIndex:0]); + XCTAssertEqual(210LL, [message.repeatedSfixed64Array valueAtIndex:0]); + XCTAssertEqualWithAccuracy(211.0f, [message.repeatedFloatArray valueAtIndex:0], 0.01); + XCTAssertEqualWithAccuracy(212.0, [message.repeatedDoubleArray valueAtIndex:0], 0.01); + XCTAssertFalse([message.repeatedBoolArray valueAtIndex:0]); + XCTAssertEqualObjects(@"215", message.repeatedStringArray[0]); + XCTAssertEqualObjects([NSData gpbtu_dataWithUint32:216], + message.repeatedBytesArray[0]); + + XCTAssertEqual(217, ((TestAllTypes_RepeatedGroup*)message.repeatedGroupArray[0]).a); + XCTAssertEqual(218, ((TestAllTypes_NestedMessage*)message.repeatedNestedMessageArray[0]).bb); + XCTAssertEqual(219, ((ForeignMessage*)message.repeatedForeignMessageArray[0]).c); + XCTAssertEqual(220, ((ImportMessage*)message.repeatedImportMessageArray[0]).d); + + XCTAssertEqual(TestAllTypes_NestedEnum_Baz, [message.repeatedNestedEnumArray valueAtIndex:0]); + XCTAssertEqual(ForeignEnum_ForeignBaz, [message.repeatedForeignEnumArray valueAtIndex:0]); + XCTAssertEqual(ImportEnum_ImportBaz, [message.repeatedImportEnumArray valueAtIndex:0]); + + XCTAssertEqualObjects(@"224", message.repeatedStringPieceArray[0]); + XCTAssertEqualObjects(@"225", message.repeatedCordArray[0]); + + // Actually verify the second (modified) elements now. + XCTAssertEqual(501, [message.repeatedInt32Array valueAtIndex:1]); + XCTAssertEqual(502LL, [message.repeatedInt64Array valueAtIndex:1]); + XCTAssertEqual(503U, [message.repeatedUint32Array valueAtIndex:1]); + XCTAssertEqual(504ULL, [message.repeatedUint64Array valueAtIndex:1]); + XCTAssertEqual(505, [message.repeatedSint32Array valueAtIndex:1]); + XCTAssertEqual(506LL, [message.repeatedSint64Array valueAtIndex:1]); + XCTAssertEqual(507U, [message.repeatedFixed32Array valueAtIndex:1]); + XCTAssertEqual(508ULL, [message.repeatedFixed64Array valueAtIndex:1]); + XCTAssertEqual(509, [message.repeatedSfixed32Array valueAtIndex:1]); + XCTAssertEqual(510LL, [message.repeatedSfixed64Array valueAtIndex:1]); + XCTAssertEqualWithAccuracy(511.0f, [message.repeatedFloatArray valueAtIndex:1], 0.01); + XCTAssertEqualWithAccuracy(512.0, [message.repeatedDoubleArray valueAtIndex:1], 0.01); + XCTAssertTrue([message.repeatedBoolArray valueAtIndex:1]); + XCTAssertEqualObjects(@"515", message.repeatedStringArray[1]); + XCTAssertEqualObjects([NSData gpbtu_dataWithUint32:516], + message.repeatedBytesArray[1]); + + XCTAssertEqual(517, ((TestAllTypes_RepeatedGroup*)message.repeatedGroupArray[1]).a); + XCTAssertEqual(518, ((TestAllTypes_NestedMessage*)message.repeatedNestedMessageArray[1]).bb); + XCTAssertEqual(519, ((ForeignMessage*)message.repeatedForeignMessageArray[1]).c); + XCTAssertEqual(520, ((ImportMessage*)message.repeatedImportMessageArray[1]).d); + + XCTAssertEqual(TestAllTypes_NestedEnum_Foo, [message.repeatedNestedEnumArray valueAtIndex:1]); + XCTAssertEqual(ForeignEnum_ForeignFoo, [message.repeatedForeignEnumArray valueAtIndex:1]); + XCTAssertEqual(ImportEnum_ImportFoo, [message.repeatedImportEnumArray valueAtIndex:1]); + + XCTAssertEqualObjects(@"524", message.repeatedStringPieceArray[1]); + XCTAssertEqualObjects(@"525", message.repeatedCordArray[1]); +} + +- (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]; + } + { + GPBInt64Array *scratch = [GPBInt64Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:602 + i * 100]; + } + [message setPackedInt64Array:scratch]; + } + { + GPBUInt32Array *scratch = [GPBUInt32Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:603 + i * 100]; + } + [message setPackedUint32Array:scratch]; + } + { + GPBUInt64Array *scratch = [GPBUInt64Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:604 + i * 100]; + } + [message setPackedUint64Array:scratch]; + } + { + GPBInt32Array *scratch = [GPBInt32Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:605 + i * 100]; + } + [message setPackedSint32Array:scratch]; + } + { + GPBInt64Array *scratch = [GPBInt64Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:606 + i * 100]; + } + [message setPackedSint64Array:scratch]; + } + { + GPBUInt32Array *scratch = [GPBUInt32Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:607 + i * 100]; + } + [message setPackedFixed32Array:scratch]; + } + { + GPBUInt64Array *scratch = [GPBUInt64Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:608 + i * 100]; + } + [message setPackedFixed64Array:scratch]; + } + { + GPBInt32Array *scratch = [GPBInt32Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:609 + i * 100]; + } + [message setPackedSfixed32Array:scratch]; + } + { + GPBInt64Array *scratch = [GPBInt64Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:610 + i * 100]; + } + [message setPackedSfixed64Array:scratch]; + } + { + GPBFloatArray *scratch = [GPBFloatArray array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:611 + i * 100]; + } + [message setPackedFloatArray:scratch]; + } + { + GPBDoubleArray *scratch = [GPBDoubleArray array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:612 + i * 100]; + } + [message setPackedDoubleArray:scratch]; + } + { + GPBBoolArray *scratch = [GPBBoolArray array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:(i % 2) ? YES : NO]; + } + [message setPackedBoolArray:scratch]; + } + { + 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]; + } +} + +- (void)assertPackedFieldsSet:(TestPackedTypes *)message + repeatedCount:(uint32_t)count { + XCTAssertEqual(count, message.packedInt32Array.count); + XCTAssertEqual(count, message.packedInt64Array.count); + XCTAssertEqual(count, message.packedUint32Array.count); + XCTAssertEqual(count, message.packedUint64Array.count); + XCTAssertEqual(count, message.packedSint32Array.count); + XCTAssertEqual(count, message.packedSint64Array.count); + XCTAssertEqual(count, message.packedFixed32Array.count); + XCTAssertEqual(count, message.packedFixed64Array.count); + XCTAssertEqual(count, message.packedSfixed32Array.count); + XCTAssertEqual(count, message.packedSfixed64Array.count); + XCTAssertEqual(count, message.packedFloatArray.count); + XCTAssertEqual(count, message.packedDoubleArray.count); + XCTAssertEqual(count, message.packedBoolArray.count); + XCTAssertEqual(count, message.packedEnumArray.count); + for (uint32_t i = 0; i < count; ++i) { + XCTAssertEqual((int)(601 + i * 100), + [message.packedInt32Array valueAtIndex:i]); + XCTAssertEqual(602 + i * 100, [message.packedInt64Array valueAtIndex:i]); + XCTAssertEqual(603 + i * 100, [message.packedUint32Array valueAtIndex:i]); + XCTAssertEqual(604 + i * 100, [message.packedUint64Array valueAtIndex:i]); + XCTAssertEqual((int)(605 + i * 100), + [message.packedSint32Array valueAtIndex:i]); + XCTAssertEqual(606 + i * 100, [message.packedSint64Array valueAtIndex:i]); + XCTAssertEqual(607 + i * 100, [message.packedFixed32Array valueAtIndex:i]); + XCTAssertEqual(608 + i * 100, [message.packedFixed64Array valueAtIndex:i]); + XCTAssertEqual((int)(609 + i * 100), + [message.packedSfixed32Array valueAtIndex:i]); + XCTAssertEqual(610 + i * 100, [message.packedSfixed64Array valueAtIndex:i]); + XCTAssertEqualWithAccuracy(611 + i * 100, + [message.packedFloatArray valueAtIndex:i], 0.01); + XCTAssertEqualWithAccuracy( + 612 + i * 100, [message.packedDoubleArray valueAtIndex:i], 0.01); + XCTAssertEqual((i % 2) ? YES : NO, + [message.packedBoolArray valueAtIndex:i]); + XCTAssertEqual((i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz, + [message.packedEnumArray valueAtIndex:i]); + } +} + +- (void)setPackedExtensions:(TestPackedExtensions *)message + repeatedCount:(uint32_t)count { + for (uint32_t i = 0; i < count; i++) { + [message addExtension:[UnittestRoot packedInt32Extension] + value:@(601 + i * 100)]; + [message addExtension:[UnittestRoot packedInt64Extension] + value:@(602 + i * 100)]; + [message addExtension:[UnittestRoot packedUint32Extension] + value:@(603 + i * 100)]; + [message addExtension:[UnittestRoot packedUint64Extension] + value:@(604 + i * 100)]; + [message addExtension:[UnittestRoot packedSint32Extension] + value:@(605 + i * 100)]; + [message addExtension:[UnittestRoot packedSint64Extension] + value:@(606 + i * 100)]; + [message addExtension:[UnittestRoot packedFixed32Extension] + value:@(607 + i * 100)]; + [message addExtension:[UnittestRoot packedFixed64Extension] + value:@(608 + i * 100)]; + [message addExtension:[UnittestRoot packedSfixed32Extension] + value:@(609 + i * 100)]; + [message addExtension:[UnittestRoot packedSfixed64Extension] + value:@(610 + i * 100)]; + [message addExtension:[UnittestRoot packedFloatExtension] + value:@(611 + i * 100)]; + [message addExtension:[UnittestRoot packedDoubleExtension] + value:@(612 + i * 100)]; + [message addExtension:[UnittestRoot packedBoolExtension] + value:@((i % 2) ? YES : NO)]; + [message addExtension:[UnittestRoot packedEnumExtension] + value:@((i % 2) ? ForeignEnum_ForeignBar + : ForeignEnum_ForeignBaz)]; + } +} + +- (void)assertPackedExtensionsSet:(TestPackedExtensions *)message + repeatedCount:(uint32_t)count{ + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedInt32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedInt64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedUint32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedUint64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedSint32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedSint64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedFixed32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedFixed64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedSfixed32Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedSfixed64Extension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedFloatExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedDoubleExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedBoolExtension]] count]); + XCTAssertEqual(count, [[message getExtension:[UnittestRoot packedEnumExtension]] count]); + + for (uint32_t i = 0; i < count; ++i) { + id extension = [message getExtension:[UnittestRoot packedInt32Extension]]; + XCTAssertEqual((int)(601 + i * 100), [extension[i] intValue]); + extension = [message getExtension:[UnittestRoot packedInt64Extension]]; + XCTAssertEqual(602 + i * 100, [extension[i] longLongValue]); + extension = [message getExtension:[UnittestRoot packedUint32Extension]]; + XCTAssertEqual(603 + i * 100, [extension[i] unsignedIntValue]); + extension = [message getExtension:[UnittestRoot packedUint64Extension]]; + XCTAssertEqual(604 + i * 100, [extension[i] unsignedLongLongValue]); + extension = [message getExtension:[UnittestRoot packedSint32Extension]]; + XCTAssertEqual((int)(605 + i * 100), [extension[i] intValue]); + extension = [message getExtension:[UnittestRoot packedSint64Extension]]; + XCTAssertEqual(606 + i * 100, [extension[i] longLongValue]); + extension = [message getExtension:[UnittestRoot packedFixed32Extension]]; + XCTAssertEqual(607 + i * 100, [extension[i] unsignedIntValue]); + extension = [message getExtension:[UnittestRoot packedFixed64Extension]]; + XCTAssertEqual(608 + i * 100, [extension[i] unsignedLongLongValue]); + extension = [message getExtension:[UnittestRoot packedSfixed32Extension]]; + XCTAssertEqual((int)(609 + i * 100), [extension[i] intValue]); + extension = [message getExtension:[UnittestRoot packedSfixed64Extension]]; + XCTAssertEqual(610 + i * 100, [extension[i] longLongValue]); + extension = [message getExtension:[UnittestRoot packedFloatExtension]]; + XCTAssertEqualWithAccuracy(611 + i * 100, [extension[i] floatValue], 0.01); + extension = [message getExtension:[UnittestRoot packedDoubleExtension]]; + XCTAssertEqualWithAccuracy(612 + i * 100, [extension[i] doubleValue], 0.01); + extension = [message getExtension:[UnittestRoot packedBoolExtension]]; + XCTAssertEqual((i % 2) ? YES : NO, [extension[i] boolValue]); + extension = [message getExtension:[UnittestRoot packedEnumExtension]]; + XCTAssertEqual((i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz, + [extension[i] intValue]); + } +} + +- (void)assertAllFieldsKVCMatch:(TestAllTypes *)message { + XCTAssertEqualObjects([message valueForKey:@"hasOptionalInt32"], @YES); + XCTAssertEqualObjects(@(message.optionalInt32), [message valueForKey:@"optionalInt32"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalInt64"], @YES); + XCTAssertEqualObjects(@(message.optionalInt64), [message valueForKey:@"optionalInt64"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalUint32"], @YES); + XCTAssertEqualObjects(@(message.optionalUint32), [message valueForKey:@"optionalUint32"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalUint64"], @YES); + XCTAssertEqualObjects(@(message.optionalUint64), [message valueForKey:@"optionalUint64"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalSint32"], @YES); + XCTAssertEqualObjects(@(message.optionalSint32), [message valueForKey:@"optionalSint32"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalSint64"], @YES); + XCTAssertEqualObjects(@(message.optionalSint64), [message valueForKey:@"optionalSint64"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalFixed32"], @YES); + XCTAssertEqualObjects(@(message.optionalFixed32), [message valueForKey:@"optionalFixed32"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalFixed64"], @YES); + XCTAssertEqualObjects(@(message.optionalFixed64), [message valueForKey:@"optionalFixed64"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalSfixed32"], @YES); + XCTAssertEqualObjects(@(message.optionalSfixed32), [message valueForKey:@"optionalSfixed32"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalSfixed64"], @YES); + XCTAssertEqualObjects(@(message.optionalSfixed64), [message valueForKey:@"optionalSfixed64"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalFloat"], @YES); + XCTAssertEqualObjects(@(message.optionalFloat), [message valueForKey:@"optionalFloat"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalDouble"], @YES); + XCTAssertEqualObjects(@(message.optionalDouble), [message valueForKey:@"optionalDouble"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalBool"], @YES); + XCTAssertEqualObjects(@(message.optionalBool), [message valueForKey:@"optionalBool"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalString"], @YES); + XCTAssertEqualObjects(message.optionalString, [message valueForKey:@"optionalString"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalBytes"], @YES); + XCTAssertEqualObjects(message.optionalBytes, [message valueForKey:@"optionalBytes"]); + + XCTAssertEqualObjects([message valueForKey:@"hasOptionalGroup"], @YES); + XCTAssertNotNil(message.optionalGroup); + XCTAssertEqualObjects([message valueForKeyPath:@"optionalGroup.hasA"], @YES); + XCTAssertEqualObjects(@(message.optionalGroup.a), [message valueForKeyPath:@"optionalGroup.a"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalNestedMessage"], @YES); + XCTAssertNotNil(message.optionalNestedMessage); + XCTAssertEqualObjects([message valueForKeyPath:@"optionalNestedMessage.hasBb"], @YES); + XCTAssertEqualObjects(@(message.optionalNestedMessage.bb), [message valueForKeyPath:@"optionalNestedMessage.bb"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalForeignMessage"], @YES); + XCTAssertNotNil(message.optionalForeignMessage); + XCTAssertEqualObjects([message valueForKeyPath:@"optionalForeignMessage.hasC"], @YES); + XCTAssertEqualObjects(@(message.optionalForeignMessage.c), [message valueForKeyPath:@"optionalForeignMessage.c"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalImportMessage"], @YES); + XCTAssertNotNil(message.optionalForeignMessage); + XCTAssertEqualObjects([message valueForKeyPath:@"optionalImportMessage.hasD"], @YES); + XCTAssertEqualObjects(@(message.optionalImportMessage.d), [message valueForKeyPath:@"optionalImportMessage.d"]); + + XCTAssertEqualObjects([message valueForKey:@"hasOptionalNestedEnum"], @YES); + XCTAssertEqualObjects(@(message.optionalNestedEnum), [message valueForKey:@"optionalNestedEnum"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalForeignEnum"], @YES); + XCTAssertEqualObjects(@(message.optionalForeignEnum), [message valueForKey:@"optionalForeignEnum"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalImportEnum"], @YES); + XCTAssertEqualObjects(@(message.optionalImportEnum), [message valueForKey:@"optionalImportEnum"]); + + XCTAssertEqualObjects([message valueForKey:@"hasOptionalStringPiece"], @YES); + XCTAssertEqualObjects(message.optionalStringPiece, [message valueForKey:@"optionalStringPiece"]); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalCord"], @YES); + XCTAssertEqualObjects(message.optionalCord, [message valueForKey:@"optionalCord"]); + + // ----------------------------------------------------------------- + + // GPBArray interface for repeated + + XCTAssertEqualObjects(message.repeatedInt32Array, [message valueForKey:@"repeatedInt32Array"]); + XCTAssertEqualObjects(message.repeatedInt64Array, [message valueForKey:@"repeatedInt64Array"]); + XCTAssertEqualObjects(message.repeatedUint32Array, [message valueForKey:@"repeatedUint32Array"]); + XCTAssertEqualObjects(message.repeatedUint64Array, [message valueForKey:@"repeatedUint64Array"]); + XCTAssertEqualObjects(message.repeatedSint32Array, [message valueForKey:@"repeatedSint32Array"]); + XCTAssertEqualObjects(message.repeatedSint64Array, [message valueForKey:@"repeatedSint64Array"]); + XCTAssertEqualObjects(message.repeatedFixed32Array, [message valueForKey:@"repeatedFixed32Array"]); + XCTAssertEqualObjects(message.repeatedFixed64Array, [message valueForKey:@"repeatedFixed64Array"]); + XCTAssertEqualObjects(message.repeatedSfixed32Array, [message valueForKey:@"repeatedSfixed32Array"]); + XCTAssertEqualObjects(message.repeatedSfixed64Array, [message valueForKey:@"repeatedSfixed64Array"]); + XCTAssertEqualObjects(message.repeatedFloatArray, [message valueForKey:@"repeatedFloatArray"]); + XCTAssertEqualObjects(message.repeatedDoubleArray, [message valueForKey:@"repeatedDoubleArray"]); + XCTAssertEqualObjects(message.repeatedBoolArray, [message valueForKey:@"repeatedBoolArray"]); + XCTAssertEqualObjects(message.repeatedStringArray, [message valueForKey:@"repeatedStringArray"]); + XCTAssertEqualObjects(message.repeatedBytesArray, [message valueForKey:@"repeatedBytesArray"]); + + XCTAssertEqualObjects(message.repeatedGroupArray, [message valueForKey:@"repeatedGroupArray"]); + XCTAssertEqualObjects(message.repeatedNestedMessageArray, [message valueForKey:@"repeatedNestedMessageArray"]); + XCTAssertEqualObjects(message.repeatedForeignMessageArray, [message valueForKey:@"repeatedForeignMessageArray"]); + XCTAssertEqualObjects(message.repeatedImportMessageArray, [message valueForKey:@"repeatedImportMessageArray"]); + + XCTAssertEqualObjects(message.repeatedNestedEnumArray, [message valueForKey:@"repeatedNestedEnumArray"]); + XCTAssertEqualObjects(message.repeatedForeignEnumArray, [message valueForKey:@"repeatedForeignEnumArray"]); + XCTAssertEqualObjects(message.repeatedImportEnumArray, [message valueForKey:@"repeatedImportEnumArray"]); + + XCTAssertEqualObjects(message.repeatedStringPieceArray, [message valueForKey:@"repeatedStringPieceArray"]); + XCTAssertEqualObjects(message.repeatedCordArray, [message valueForKey:@"repeatedCordArray"]); + + // ----------------------------------------------------------------- + + XCTAssertEqualObjects([message valueForKey:@"hasDefaultInt32"], @YES); + XCTAssertEqualObjects(@(message.defaultInt32), [message valueForKey:@"defaultInt32"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultInt64"], @YES); + XCTAssertEqualObjects(@(message.defaultInt64), [message valueForKey:@"defaultInt64"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultUint32"], @YES); + XCTAssertEqualObjects(@(message.defaultUint32), [message valueForKey:@"defaultUint32"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultUint64"], @YES); + XCTAssertEqualObjects(@(message.defaultUint64), [message valueForKey:@"defaultUint64"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultSint32"], @YES); + XCTAssertEqualObjects(@(message.defaultSint32), [message valueForKey:@"defaultSint32"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultSint64"], @YES); + XCTAssertEqualObjects(@(message.defaultSint64), [message valueForKey:@"defaultSint64"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultFixed32"], @YES); + XCTAssertEqualObjects(@(message.defaultFixed32), [message valueForKey:@"defaultFixed32"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultFixed64"], @YES); + XCTAssertEqualObjects(@(message.defaultFixed64), [message valueForKey:@"defaultFixed64"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultSfixed32"], @YES); + XCTAssertEqualObjects(@(message.defaultSfixed32), [message valueForKey:@"defaultSfixed32"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultSfixed64"], @YES); + XCTAssertEqualObjects(@(message.defaultSfixed64), [message valueForKey:@"defaultSfixed64"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultFloat"], @YES); + XCTAssertEqualObjects(@(message.defaultFloat), [message valueForKey:@"defaultFloat"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultDouble"], @YES); + XCTAssertEqualObjects(@(message.defaultDouble), [message valueForKey:@"defaultDouble"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultBool"], @YES); + XCTAssertEqualObjects(@(message.defaultBool), [message valueForKey:@"defaultBool"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultString"], @YES); + XCTAssertEqualObjects(message.defaultString, [message valueForKey:@"defaultString"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultBytes"], @YES); + XCTAssertEqualObjects(message.defaultBytes, [message valueForKey:@"defaultBytes"]); + + XCTAssertEqualObjects([message valueForKey:@"hasDefaultNestedEnum"], @YES); + XCTAssertEqualObjects(@(message.defaultNestedEnum), [message valueForKey:@"defaultNestedEnum"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultForeignEnum"], @YES); + XCTAssertEqualObjects(@(message.defaultForeignEnum), [message valueForKey:@"defaultForeignEnum"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultImportEnum"], @YES); + XCTAssertEqualObjects(@(message.defaultImportEnum), [message valueForKey:@"defaultImportEnum"]); + + XCTAssertEqualObjects([message valueForKey:@"hasDefaultStringPiece"], @YES); + XCTAssertEqualObjects(message.defaultStringPiece, [message valueForKey:@"defaultStringPiece"]); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultCord"], @YES); + XCTAssertEqualObjects(message.defaultCord, [message valueForKey:@"defaultCord"]); +} + +- (void)setAllFieldsViaKVC:(TestAllTypes *)message + repeatedCount:(uint32_t)count { + [message setValue:@101 forKey:@"optionalInt32"]; + [message setValue:@102 forKey:@"optionalInt64"]; + [message setValue:@103 forKey:@"optionalUint32"]; + [message setValue:@104 forKey:@"optionalUint64"]; + [message setValue:@105 forKey:@"optionalSint32"]; + [message setValue:@106 forKey:@"optionalSint64"]; + [message setValue:@107 forKey:@"optionalFixed32"]; + [message setValue:@108 forKey:@"optionalFixed64"]; + [message setValue:@109 forKey:@"optionalSfixed32"]; + [message setValue:@110 forKey:@"optionalSfixed64"]; + [message setValue:@111 forKey:@"optionalFloat"]; + [message setValue:@112 forKey:@"optionalDouble"]; + [message setValue:@YES forKey:@"optionalBool"]; + [message setValue:@"115" forKey:@"optionalString"]; + [message setValue:[NSData gpbtu_dataWithEmbeddedNulls] + forKey:@"optionalBytes"]; + + TestAllTypes_OptionalGroup *allTypes = [TestAllTypes_OptionalGroup message]; + [allTypes setValue:@117 forKey:@"a"]; + [message setValue:allTypes forKey:@"optionalGroup"]; + TestAllTypes_NestedMessage *nestedMessage = + [TestAllTypes_NestedMessage message]; + [nestedMessage setValue:@118 forKey:@"bb"]; + [message setValue:nestedMessage forKey:@"optionalNestedMessage"]; + ForeignMessage *foreignMessage = [ForeignMessage message]; + [foreignMessage setValue:@119 forKey:@"c"]; + [message setValue:foreignMessage forKey:@"optionalForeignMessage"]; + ImportMessage *importMessage = [ImportMessage message]; + [importMessage setValue:@120 forKey:@"d"]; + [message setValue:importMessage forKey:@"optionalImportMessage"]; + + [message setValue:@(TestAllTypes_NestedEnum_Baz) + forKey:@"optionalNestedEnum"]; + [message setValue:@(ForeignEnum_ForeignBaz) forKey:@"optionalForeignEnum"]; + [message setValue:@(ImportEnum_ImportBaz) forKey:@"optionalImportEnum"]; + + [message setValue:@"124" forKey:@"optionalStringPiece"]; + [message setValue:@"125" forKey:@"optionalCord"]; + + // ----------------------------------------------------------------- + + { + GPBInt32Array *scratch = [GPBInt32Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:201 + i * 100]; + } + [message setValue:scratch forKey:@"repeatedInt32Array"]; + } + { + GPBInt64Array *scratch = [GPBInt64Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:202 + i * 100]; + } + [message setValue:scratch forKey:@"repeatedInt64Array"]; + } + { + GPBUInt32Array *scratch = [GPBUInt32Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:203 + i * 100]; + } + [message setValue:scratch forKey:@"repeatedUint32Array"]; + } + { + GPBUInt64Array *scratch = [GPBUInt64Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:204 + i * 100]; + } + [message setValue:scratch forKey:@"repeatedUint64Array"]; + } + { + GPBInt32Array *scratch = [GPBInt32Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:205 + i * 100]; + } + [message setValue:scratch forKey:@"repeatedSint32Array"]; + } + { + GPBInt64Array *scratch = [GPBInt64Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:206 + i * 100]; + } + [message setValue:scratch forKey:@"repeatedSint64Array"]; + } + { + GPBUInt32Array *scratch = [GPBUInt32Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:207 + i * 100]; + } + [message setValue:scratch forKey:@"repeatedFixed32Array"]; + } + { + GPBUInt64Array *scratch = [GPBUInt64Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:208 + i * 100]; + } + [message setValue:scratch forKey:@"repeatedFixed64Array"]; + } + { + GPBInt32Array *scratch = [GPBInt32Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:209 + i * 100]; + } + [message setValue:scratch forKey:@"repeatedSfixed32Array"]; + } + { + GPBInt64Array *scratch = [GPBInt64Array array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:210 + i * 100]; + } + [message setValue:scratch forKey:@"repeatedSfixed64Array"]; + } + { + GPBFloatArray *scratch = [GPBFloatArray array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:211 + i * 100]; + } + [message setValue:scratch forKey:@"repeatedFloatArray"]; + } + { + GPBDoubleArray *scratch = [GPBDoubleArray array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:212 + i * 100]; + } + [message setValue:scratch forKey:@"repeatedDoubleArray"]; + } + { + GPBBoolArray *scratch = [GPBBoolArray array]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:(i % 2) ? YES : NO]; + } + [message setValue:scratch forKey:@"repeatedBoolArray"]; + } + + NSMutableArray *array = [[NSMutableArray alloc] initWithCapacity:count]; + for (uint32_t i = 0; i < count; ++i) { + NSString *string = [[NSString alloc] initWithFormat:@"%d", 215 + i * 100]; + [array addObject:string]; + [string release]; + } + [message setValue:array forKey:@"repeatedStringArray"]; + [array release]; + + array = [[NSMutableArray alloc] initWithCapacity:count]; + for (uint32_t i = 0; i < count; ++i) { + NSData *data = [[NSData alloc] initWithUint32_gpbtu:216 + i * 100]; + [array addObject:data]; + [data release]; + } + [message setValue:array forKey:@"repeatedBytesArray"]; + [array release]; + + array = [[NSMutableArray alloc] initWithCapacity:count]; + for (uint32_t i = 0; i < count; ++i) { + TestAllTypes_RepeatedGroup *testAll = + [[TestAllTypes_RepeatedGroup alloc] init]; + [testAll setA:217 + i * 100]; + [array addObject:testAll]; + [testAll release]; + } + [message setValue:array forKey:@"repeatedGroupArray"]; + [array release]; + + array = [[NSMutableArray alloc] initWithCapacity:count]; + for (uint32_t i = 0; i < count; ++i) { + nestedMessage = [[TestAllTypes_NestedMessage alloc] init]; + [nestedMessage setBb:218 + i * 100]; + [array addObject:nestedMessage]; + [nestedMessage release]; + } + [message setValue:array forKey:@"repeatedNestedMessageArray"]; + [array release]; + + array = [[NSMutableArray alloc] initWithCapacity:count]; + for (uint32_t i = 0; i < count; ++i) { + foreignMessage = [[ForeignMessage alloc] init]; + [foreignMessage setC:219 + i * 100]; + [array addObject:foreignMessage]; + [foreignMessage release]; + } + [message setValue:array forKey:@"repeatedForeignMessageArray"]; + [array release]; + + array = [[NSMutableArray alloc] initWithCapacity:count]; + for (uint32_t i = 0; i < count; ++i) { + importMessage = [[ImportMessage alloc] init]; + [importMessage setD:220 + i * 100]; + [array addObject:importMessage]; + [importMessage release]; + } + [message setValue:array forKey:@"repeatedImportMessageArray"]; + [array release]; + + { + GPBEnumArray *scratch = [GPBEnumArray + arrayWithValidationFunction:TestAllTypes_NestedEnum_IsValidValue]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:(i % 2) ? TestAllTypes_NestedEnum_Bar + : TestAllTypes_NestedEnum_Baz]; + } + [message setValue:scratch forKey:@"repeatedNestedEnumArray"]; + } + { + GPBEnumArray *scratch = + [GPBEnumArray arrayWithValidationFunction:ForeignEnum_IsValidValue]; + for (uint32_t i = 0; i < count; ++i) { + [scratch + addValue:(i % 2) ? ForeignEnum_ForeignBar : ForeignEnum_ForeignBaz]; + } + [message setValue:scratch forKey:@"repeatedForeignEnumArray"]; + } + { + GPBEnumArray *scratch = + [GPBEnumArray arrayWithValidationFunction:ImportEnum_IsValidValue]; + for (uint32_t i = 0; i < count; ++i) { + [scratch addValue:(i % 2) ? ImportEnum_ImportBar : ImportEnum_ImportBaz]; + } + [message setValue:scratch forKey:@"repeatedImportEnumArray"]; + } + + array = [[NSMutableArray alloc] initWithCapacity:count]; + for (uint32_t i = 0; i < count; ++i) { + NSString *string = [[NSString alloc] initWithFormat:@"%d", 224 + i * 100]; + [array addObject:string]; + [string release]; + } + [message setValue:array forKey:@"repeatedStringPieceArray"]; + [array release]; + + array = [[NSMutableArray alloc] initWithCapacity:count]; + for (uint32_t i = 0; i < count; ++i) { + NSString *string = [[NSString alloc] initWithFormat:@"%d", 225 + i * 100]; + [array addObject:string]; + [string release]; + } + [message setValue:array forKey:@"repeatedCordArray"]; + [array release]; + + // ----------------------------------------------------------------- + + [message setValue:@401 forKey:@"defaultInt32"]; + [message setValue:@402 forKey:@"defaultInt64"]; + [message setValue:@403 forKey:@"defaultUint32"]; + [message setValue:@404 forKey:@"defaultUint64"]; + [message setValue:@405 forKey:@"defaultSint32"]; + [message setValue:@406 forKey:@"defaultSint64"]; + [message setValue:@407 forKey:@"defaultFixed32"]; + [message setValue:@408 forKey:@"defaultFixed64"]; + [message setValue:@409 forKey:@"defaultSfixed32"]; + [message setValue:@410 forKey:@"defaultSfixed64"]; + [message setValue:@411 forKey:@"defaultFloat"]; + [message setValue:@412 forKey:@"defaultDouble"]; + [message setValue:@NO forKey:@"defaultBool"]; + [message setValue:@"415" forKey:@"defaultString"]; + [message setValue:[NSData gpbtu_dataWithUint32:416] forKey:@"defaultBytes"]; + + [message setValue:@(TestAllTypes_NestedEnum_Foo) forKey:@"defaultNestedEnum"]; + [message setValue:@(ForeignEnum_ForeignFoo) forKey:@"defaultForeignEnum"]; + [message setValue:@(ImportEnum_ImportFoo) forKey:@"defaultImportEnum"]; + + [message setValue:@"424" forKey:@"defaultStringPiece"]; + [message setValue:@"425" forKey:@"defaultCord"]; +} + +- (void)assertClearKVC:(TestAllTypes *)message { + XCTAssertEqualObjects([message valueForKey:@"hasOptionalInt32"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalInt64"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalUint32"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalUint64"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalSint32"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalSint64"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalFixed32"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalFixed64"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalSfixed32"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalSfixed64"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalFloat"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalDouble"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalBool"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalString"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalBytes"], @NO); + + XCTAssertEqualObjects([message valueForKey:@"hasOptionalGroup"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalNestedMessage"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalForeignMessage"], + @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalImportMessage"], @NO); + + XCTAssertEqualObjects([message valueForKey:@"hasOptionalNestedEnum"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalForeignEnum"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalImportEnum"], @NO); + + XCTAssertEqualObjects([message valueForKey:@"hasOptionalStringPiece"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasOptionalCord"], @NO); + + // Optional fields without defaults are set to zero or something like it. + XCTAssertEqualObjects([message valueForKey:@"optionalInt32"], @0); + XCTAssertEqualObjects([message valueForKey:@"optionalInt64"], @0); + XCTAssertEqualObjects([message valueForKey:@"optionalUint32"], @0); + XCTAssertEqualObjects([message valueForKey:@"optionalUint64"], @0); + XCTAssertEqualObjects([message valueForKey:@"optionalSint32"], @0); + XCTAssertEqualObjects([message valueForKey:@"optionalSint64"], @0); + XCTAssertEqualObjects([message valueForKey:@"optionalFixed32"], @0); + XCTAssertEqualObjects([message valueForKey:@"optionalFixed64"], @0); + XCTAssertEqualObjects([message valueForKey:@"optionalSfixed32"], @0); + XCTAssertEqualObjects([message valueForKey:@"optionalSfixed64"], @0); + XCTAssertEqualObjects([message valueForKey:@"optionalFloat"], @0); + XCTAssertEqualObjects([message valueForKey:@"optionalDouble"], @0); + XCTAssertEqualObjects([message valueForKey:@"optionalBool"], @NO); + XCTAssertEqualObjects([message valueForKey:@"optionalString"], @""); + XCTAssertEqualObjects([message valueForKey:@"optionalBytes"], + GPBEmptyNSData()); + + // Embedded messages should also be exist, but be clear. + XCTAssertNotNil([message valueForKeyPath:@"optionalGroup"]); + XCTAssertNotNil([message valueForKeyPath:@"optionalNestedMessage"]); + XCTAssertNotNil([message valueForKeyPath:@"optionalForeignMessage"]); + XCTAssertNotNil([message valueForKeyPath:@"optionalImportMessage"]); + XCTAssertEqualObjects([message valueForKeyPath:@"optionalGroup.hasA"], @NO); + XCTAssertEqualObjects( + [message valueForKeyPath:@"optionalNestedMessage.hasBb"], @NO); + XCTAssertEqualObjects( + [message valueForKeyPath:@"optionalForeignMessage.hasC"], @NO); + XCTAssertEqualObjects([message valueForKeyPath:@"optionalImportMessage.hasD"], + @NO); + + XCTAssertEqualObjects([message valueForKeyPath:@"optionalGroup.a"], @0); + XCTAssertEqualObjects([message valueForKeyPath:@"optionalNestedMessage.bb"], + @0); + XCTAssertEqualObjects([message valueForKeyPath:@"optionalForeignMessage.c"], + @0); + XCTAssertEqualObjects([message valueForKeyPath:@"optionalImportMessage.d"], + @0); + + // Enums without defaults are set to the first value in the enum. + XCTAssertEqualObjects([message valueForKey:@"optionalNestedEnum"], + @(TestAllTypes_NestedEnum_Foo)); + XCTAssertEqualObjects([message valueForKey:@"optionalForeignEnum"], + @(ForeignEnum_ForeignFoo)); + XCTAssertEqualObjects([message valueForKey:@"optionalImportEnum"], + @(ImportEnum_ImportFoo)); + + XCTAssertEqualObjects([message valueForKey:@"optionalStringPiece"], @""); + XCTAssertEqualObjects([message valueForKey:@"optionalCord"], @""); + + // NSArray interface for repeated doesn't have has*, nil means no value. + + XCTAssertEqualObjects([message valueForKey:@"hasDefaultInt32"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultInt64"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultUint32"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultUint64"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultSint32"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultSint64"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultFixed32"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultFixed64"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultSfixed32"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultSfixed64"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultFloat"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultDouble"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultBool"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultString"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultBytes"], @NO); + + XCTAssertEqualObjects([message valueForKey:@"hasDefaultNestedEnum"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultForeignEnum"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultImportEnum"], @NO); + + XCTAssertEqualObjects([message valueForKey:@"hasDefaultStringPiece"], @NO); + XCTAssertEqualObjects([message valueForKey:@"hasDefaultCord"], @NO); + + // Fields with defaults have their default values (duh). + XCTAssertEqualObjects([message valueForKey:@"defaultInt32"], @41); + XCTAssertEqualObjects([message valueForKey:@"defaultInt64"], @42); + XCTAssertEqualObjects([message valueForKey:@"defaultUint32"], @43); + XCTAssertEqualObjects([message valueForKey:@"defaultUint64"], @44); + XCTAssertEqualObjects([message valueForKey:@"defaultSint32"], @-45); + XCTAssertEqualObjects([message valueForKey:@"defaultSint64"], @46); + XCTAssertEqualObjects([message valueForKey:@"defaultFixed32"], @47); + XCTAssertEqualObjects([message valueForKey:@"defaultFixed64"], @48); + XCTAssertEqualObjects([message valueForKey:@"defaultSfixed32"], @49); + XCTAssertEqualObjects([message valueForKey:@"defaultSfixed64"], @-50); + XCTAssertEqualObjects([message valueForKey:@"defaultFloat"], @51.5); + XCTAssertEqualObjects([message valueForKey:@"defaultDouble"], @52e3); + XCTAssertEqualObjects([message valueForKey:@"defaultBool"], @YES); + XCTAssertEqualObjects([message valueForKey:@"defaultString"], @"hello"); + XCTAssertEqualObjects([message valueForKey:@"defaultBytes"], + [NSData gpbtu_dataWithCString:"world"]); + + XCTAssertEqualObjects([message valueForKey:@"defaultNestedEnum"], + @(TestAllTypes_NestedEnum_Bar)); + XCTAssertEqualObjects([message valueForKey:@"defaultForeignEnum"], + @(ForeignEnum_ForeignBar)); + XCTAssertEqualObjects([message valueForKey:@"defaultImportEnum"], + @(ImportEnum_ImportBar)); + + XCTAssertEqualObjects([message valueForKey:@"defaultStringPiece"], @"abc"); + XCTAssertEqualObjects([message valueForKey:@"defaultCord"], @"123"); +} + +@end |