Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity
Protocol Buffers - Google's data interchange format (grpc依赖) https://developers.google.com/protocol-buffers/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4666 Commits
201 Branches
346 Tags
254 MiB
 
 
 
 
 
 
Tag: Branch: Tree: 4b36d4006b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '4b36d4006b'
${ noResults }
protobuf/objectivec/Tests/GPBMessageTests.m

2053 lines
81 KiB
Raw Blame History

// 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 <objc/runtime.h>
#import "GPBArray_PackagePrivate.h"
#import "GPBDescriptor.h"
#import "GPBDictionary_PackagePrivate.h"
#import "GPBMessage_PackagePrivate.h"
#import "GPBUnknownField_PackagePrivate.h"
#import "GPBUnknownFieldSet_PackagePrivate.h"
#import "google/protobuf/Unittest.pbobjc.h"
#import "google/protobuf/UnittestObjc.pbobjc.h"
@interface MessageTests : GPBTestCase
@end
@implementation MessageTests
// TODO(thomasvl): this should get split into a few files of logic junks, it is
// a jumble of things at the moment (and the testutils have a bunch of the real
// assertions).
- (TestAllTypes *)mergeSource {
TestAllTypes *message = [TestAllTypes message];
[message setOptionalInt32:1];
[message setOptionalString:@"foo"];
[message setOptionalForeignMessage:[ForeignMessage message]];
[message.repeatedStringArray addObject:@"bar"];
return message;
}
- (TestAllTypes *)mergeDestination {
TestAllTypes *message = [TestAllTypes message];
[message setOptionalInt64:2];
[message setOptionalString:@"baz"];
ForeignMessage *foreignMessage = [ForeignMessage message];
[foreignMessage setC:3];
[message setOptionalForeignMessage:foreignMessage];
[message.repeatedStringArray addObject:@"qux"];
return message;
}
- (TestAllTypes *)mergeDestinationWithoutForeignMessageIvar {
TestAllTypes *message = [TestAllTypes message];
[message setOptionalInt64:2];
[message setOptionalString:@"baz"];
[message.repeatedStringArray addObject:@"qux"];
return message;
}
- (TestAllTypes *)mergeResult {
TestAllTypes *message = [TestAllTypes message];
[message setOptionalInt32:1];
[message setOptionalInt64:2];
[message setOptionalString:@"foo"];
ForeignMessage *foreignMessage = [ForeignMessage message];
[foreignMessage setC:3];
[message setOptionalForeignMessage:foreignMessage];
[message.repeatedStringArray addObject:@"qux"];
[message.repeatedStringArray addObject:@"bar"];
return message;
}
- (TestAllTypes *)mergeResultForDestinationWithoutForeignMessageIvar {
TestAllTypes *message = [TestAllTypes message];
[message setOptionalInt32:1];
[message setOptionalInt64:2];
[message setOptionalString:@"foo"];
ForeignMessage *foreignMessage = [ForeignMessage message];
[message setOptionalForeignMessage:foreignMessage];
[message.repeatedStringArray addObject:@"qux"];
[message.repeatedStringArray addObject:@"bar"];
return message;
}
- (TestAllExtensions *)mergeExtensionsDestination {
TestAllExtensions *message = [TestAllExtensions message];
[message setExtension:[UnittestRoot optionalInt32Extension] value:@5];
[message setExtension:[UnittestRoot optionalStringExtension] value:@"foo"];
ForeignMessage *foreignMessage = [ForeignMessage message];
foreignMessage.c = 4;
[message setExtension:[UnittestRoot optionalForeignMessageExtension]
value:foreignMessage];
TestAllTypes_NestedMessage *nestedMessage =
[TestAllTypes_NestedMessage message];
[message setExtension:[UnittestRoot optionalNestedMessageExtension]
value:nestedMessage];
return message;
}
- (TestAllExtensions *)mergeExtensionsSource {
TestAllExtensions *message = [TestAllExtensions message];
[message setExtension:[UnittestRoot optionalInt64Extension] value:@6];
[message setExtension:[UnittestRoot optionalStringExtension] value:@"bar"];
ForeignMessage *foreignMessage = [ForeignMessage message];
[message setExtension:[UnittestRoot optionalForeignMessageExtension]
value:foreignMessage];
TestAllTypes_NestedMessage *nestedMessage =
[TestAllTypes_NestedMessage message];
nestedMessage.bb = 7;
[message setExtension:[UnittestRoot optionalNestedMessageExtension]
value:nestedMessage];
return message;
}
- (TestAllExtensions *)mergeExtensionsResult {
TestAllExtensions *message = [TestAllExtensions message];
[message setExtension:[UnittestRoot optionalInt32Extension] value:@5];
[message setExtension:[UnittestRoot optionalInt64Extension] value:@6];
[message setExtension:[UnittestRoot optionalStringExtension] value:@"bar"];
ForeignMessage *foreignMessage = [ForeignMessage message];
foreignMessage.c = 4;
[message setExtension:[UnittestRoot optionalForeignMessageExtension]
value:foreignMessage];
TestAllTypes_NestedMessage *nestedMessage =
[TestAllTypes_NestedMessage message];
nestedMessage.bb = 7;
[message setExtension:[UnittestRoot optionalNestedMessageExtension]
value:nestedMessage];
return message;
}
- (void)testMergeFrom {
TestAllTypes *result = [[self.mergeDestination copy] autorelease];
[result mergeFrom:self.mergeSource];
NSData *resultData = [result data];
NSData *mergeResultData = [self.mergeResult data];
XCTAssertEqualObjects(resultData, mergeResultData);
XCTAssertEqualObjects(result, self.mergeResult);
// Test when destination does not have an Ivar (type is an object) but source
// has such Ivar.
// The result must has the Ivar which is same as the one in source.
result = [[self.mergeDestinationWithoutForeignMessageIvar copy] autorelease];
[result mergeFrom:self.mergeSource];
resultData = [result data];
mergeResultData =
[self.mergeResultForDestinationWithoutForeignMessageIvar data];
XCTAssertEqualObjects(resultData, mergeResultData);
XCTAssertEqualObjects(
result, self.mergeResultForDestinationWithoutForeignMessageIvar);
// Test when destination is empty.
// The result must is same as the source.
result = [TestAllTypes message];
[result mergeFrom:self.mergeSource];
resultData = [result data];
mergeResultData = [self.mergeSource data];
XCTAssertEqualObjects(resultData, mergeResultData);
XCTAssertEqualObjects(result, self.mergeSource);
}
- (void)testMergeFromWithExtensions {
TestAllExtensions *result = [self mergeExtensionsDestination];
[result mergeFrom:[self mergeExtensionsSource]];
NSData *resultData = [result data];
NSData *mergeResultData = [[self mergeExtensionsResult] data];
XCTAssertEqualObjects(resultData, mergeResultData);
XCTAssertEqualObjects(result, [self mergeExtensionsResult]);
// Test merging from data.
result = [self mergeExtensionsDestination];
NSData *data = [[self mergeExtensionsSource] data];
XCTAssertNotNil(data);
[result mergeFromData:data
extensionRegistry:[UnittestRoot extensionRegistry]];
resultData = [result data];
XCTAssertEqualObjects(resultData, mergeResultData);
XCTAssertEqualObjects(result, [self mergeExtensionsResult]);
}
- (void)testIsEquals {
TestAllTypes *result = [[self.mergeDestination copy] autorelease];
[result mergeFrom:self.mergeSource];
XCTAssertEqualObjects(result.data, self.mergeResult.data);
XCTAssertEqualObjects(result, self.mergeResult);
TestAllTypes *result2 = [[self.mergeDestination copy] autorelease];
XCTAssertNotEqualObjects(result2.data, self.mergeResult.data);
XCTAssertNotEqualObjects(result2, self.mergeResult);
}
// =================================================================
// Required-field-related tests.
- (TestRequired *)testRequiredInitialized {
TestRequired *message = [TestRequired message];
[message setA:1];
[message setB:2];
[message setC:3];
return message;
}
- (void)testRequired {
TestRequired *message = [TestRequired message];
XCTAssertFalse(message.initialized);
[message setA:1];
XCTAssertFalse(message.initialized);
[message setB:1];
XCTAssertFalse(message.initialized);
[message setC:1];
XCTAssertTrue(message.initialized);
}
- (void)testRequiredForeign {
TestRequiredForeign *message = [TestRequiredForeign message];
XCTAssertTrue(message.initialized);
[message setOptionalMessage:[TestRequired message]];
XCTAssertFalse(message.initialized);
[message setOptionalMessage:self.testRequiredInitialized];
XCTAssertTrue(message.initialized);
[message.repeatedMessageArray addObject:[TestRequired message]];
XCTAssertFalse(message.initialized);
[message.repeatedMessageArray removeAllObjects];
[message.repeatedMessageArray addObject:self.testRequiredInitialized];
XCTAssertTrue(message.initialized);
}
- (void)testRequiredExtension {
TestAllExtensions *message = [TestAllExtensions message];
XCTAssertTrue(message.initialized);
[message setExtension:[TestRequired single] value:[TestRequired message]];
XCTAssertFalse(message.initialized);
[message setExtension:[TestRequired single]
value:self.testRequiredInitialized];
XCTAssertTrue(message.initialized);
[message addExtension:[TestRequired multi] value:[TestRequired message]];
XCTAssertFalse(message.initialized);
[message setExtension:[TestRequired multi]
index:0
value:self.testRequiredInitialized];
XCTAssertTrue(message.initialized);
}
- (void)testDataFromUninitialized {
TestRequired *message = [TestRequired message];
NSData *data = [message data];
// In DEBUG, the data generation will fail, but in non DEBUG, it passes
// because the check isn't done (for speed).
#ifdef DEBUG
XCTAssertNil(data);
#else
XCTAssertNotNil(data);
XCTAssertFalse(message.initialized);
#endif // DEBUG
}
- (void)testInitialized {
// We're mostly testing that no exception is thrown.
TestRequired *message = [TestRequired message];
XCTAssertFalse(message.initialized);
}
- (void)testDataFromNestedUninitialized {
TestRequiredForeign *message = [TestRequiredForeign message];
[message setOptionalMessage:[TestRequired message]];
[message.repeatedMessageArray addObject:[TestRequired message]];
[message.repeatedMessageArray addObject:[TestRequired message]];
NSData *data = [message data];
// In DEBUG, the data generation will fail, but in non DEBUG, it passes
// because the check isn't done (for speed).
#ifdef DEBUG
XCTAssertNil(data);
#else
XCTAssertNotNil(data);
XCTAssertFalse(message.initialized);
#endif // DEBUG
}
- (void)testNestedInitialized {
// We're mostly testing that no exception is thrown.
TestRequiredForeign *message = [TestRequiredForeign message];
[message setOptionalMessage:[TestRequired message]];
[message.repeatedMessageArray addObject:[TestRequired message]];
[message.repeatedMessageArray addObject:[TestRequired message]];
XCTAssertFalse(message.initialized);
}
- (void)testParseUninitialized {
NSError *error = nil;
TestRequired *msg =
[TestRequired parseFromData:GPBEmptyNSData() error:&error];
// In DEBUG, the parse will fail, but in non DEBUG, it passes because
// the check isn't done (for speed).
#ifdef DEBUG
XCTAssertNil(msg);
XCTAssertNotNil(error);
XCTAssertEqualObjects(error.domain, GPBMessageErrorDomain);
XCTAssertEqual(error.code, GPBMessageErrorCodeMissingRequiredField);
#else
XCTAssertNotNil(msg);
XCTAssertNil(error);
XCTAssertFalse(msg.initialized);
#endif // DEBUG
}
- (void)testCoding {
NSData *data =
[NSKeyedArchiver archivedDataWithRootObject:[self mergeResult]];
id unarchivedObject = [NSKeyedUnarchiver unarchiveObjectWithData:data];
XCTAssertEqualObjects(unarchivedObject, [self mergeResult]);
// Intentionally doing a pointer comparison.
XCTAssertNotEqual(unarchivedObject, [self mergeResult]);
}
- (void)testObjectReset {
// Tests a failure where clearing out defaults values caused an over release.
TestAllTypes *message = [TestAllTypes message];
message.hasOptionalNestedMessage = NO;
[message setOptionalNestedMessage:[TestAllTypes_NestedMessage message]];
message.hasOptionalNestedMessage = NO;
[message setOptionalNestedMessage:[TestAllTypes_NestedMessage message]];
[message setOptionalNestedMessage:nil];
message.hasOptionalNestedMessage = NO;
}
- (void)testSettingHasToYes {
TestAllTypes *message = [TestAllTypes message];
XCTAssertThrows([message setHasOptionalNestedMessage:YES]);
}
- (void)testRoot {
XCTAssertNotNil([UnittestRoot extensionRegistry]);
}
- (void)testGPBMessageSize {
// See the note in GPBMessage_PackagePrivate.h about why we want to keep the
// base instance size pointer size aligned.
size_t messageSize = class_getInstanceSize([GPBMessage class]);
XCTAssertEqual((messageSize % sizeof(void *)), (size_t)0,
@"Base size isn't pointer size aligned");
// Since we add storage ourselves (see +allocWithZone: in GPBMessage), confirm
// that the size of some generated classes is still the same as the base for
// that logic to work as desired.
size_t testMessageSize = class_getInstanceSize([TestAllTypes class]);
XCTAssertEqual(testMessageSize, messageSize);
}
- (void)testInit {
TestAllTypes *message = [TestAllTypes message];
[self assertClear:message];
}
- (void)testAccessors {
TestAllTypes *message = [TestAllTypes message];
[self setAllFields:message repeatedCount:kGPBDefaultRepeatCount];
[self assertAllFieldsSet:message repeatedCount:kGPBDefaultRepeatCount];
}
- (void)testKVC_ValueForKey {
TestAllTypes *message = [TestAllTypes message];
[self setAllFields:message repeatedCount:kGPBDefaultRepeatCount];
[self assertAllFieldsKVCMatch:message];
}
- (void)testKVC_SetValue_ForKey {
TestAllTypes *message = [TestAllTypes message];
[self setAllFieldsViaKVC:message repeatedCount:kGPBDefaultRepeatCount];
[self assertAllFieldsKVCMatch:message];
[self assertAllFieldsSet:message repeatedCount:kGPBDefaultRepeatCount];
[self assertAllFieldsKVCMatch:message];
}
- (void)testDescription {
// No real test, just exercise code
TestAllTypes *message = [TestAllTypes message];
[self setAllFields:message repeatedCount:kGPBDefaultRepeatCount];
GPBUnknownFieldSet *unknownFields =
[[[GPBUnknownFieldSet alloc] init] autorelease];
GPBUnknownField *field =
[[[GPBUnknownField alloc] initWithNumber:2] autorelease];
[field addVarint:2];
[unknownFields addField:field];
field = [[[GPBUnknownField alloc] initWithNumber:3] autorelease];
[field addVarint:4];
[unknownFields addField:field];
[message setUnknownFields:unknownFields];
NSString *description = [message description];
XCTAssertGreaterThan([description length], 0U);
GPBMessage *message2 = [TestAllExtensions message];
[message2 setExtension:[UnittestRoot optionalInt32Extension] value:@1];
[message2 addExtension:[UnittestRoot repeatedInt32Extension] value:@2];
description = [message2 description];
XCTAssertGreaterThan([description length], 0U);
}
- (void)testSetter {
// Test to make sure that if we set a value that has a default value
// with the default, that the has is set, and the value gets put into the
// message correctly.
TestAllTypes *message = [TestAllTypes message];
GPBDescriptor *descriptor = [[message class] descriptor];
XCTAssertNotNil(descriptor);
GPBFieldDescriptor *fieldDescriptor =
[descriptor fieldWithName:@"defaultInt32"];
XCTAssertNotNil(fieldDescriptor);
GPBGenericValue defaultValue = [fieldDescriptor defaultValue];
[message setDefaultInt32:defaultValue.valueInt32];
XCTAssertTrue(message.hasDefaultInt32);
XCTAssertEqual(message.defaultInt32, defaultValue.valueInt32);
// Do the same thing with an object type.
message = [TestAllTypes message];
fieldDescriptor = [descriptor fieldWithName:@"defaultString"];
XCTAssertNotNil(fieldDescriptor);
defaultValue = [fieldDescriptor defaultValue];
[message setDefaultString:defaultValue.valueString];
XCTAssertTrue(message.hasDefaultString);
XCTAssertEqualObjects(message.defaultString, defaultValue.valueString);
// Test default string type.
message = [TestAllTypes message];
XCTAssertEqualObjects(message.defaultString, @"hello");
XCTAssertFalse(message.hasDefaultString);
fieldDescriptor = [descriptor fieldWithName:@"defaultString"];
XCTAssertNotNil(fieldDescriptor);
defaultValue = [fieldDescriptor defaultValue];
[message setDefaultString:defaultValue.valueString];
XCTAssertEqualObjects(message.defaultString, @"hello");
XCTAssertTrue(message.hasDefaultString);
[message setDefaultString:nil];
XCTAssertEqualObjects(message.defaultString, @"hello");
XCTAssertFalse(message.hasDefaultString);
message.hasDefaultString = NO;
XCTAssertFalse(message.hasDefaultString);
XCTAssertEqualObjects(message.defaultString, @"hello");
// Test default bytes type.
NSData *defaultBytes = [@"world" dataUsingEncoding:NSUTF8StringEncoding];
XCTAssertEqualObjects(message.defaultBytes, defaultBytes);
XCTAssertFalse(message.hasDefaultString);
fieldDescriptor = [descriptor fieldWithName:@"defaultBytes"];
XCTAssertNotNil(fieldDescriptor);
defaultValue = [fieldDescriptor defaultValue];
[message setDefaultBytes:defaultValue.valueData];
XCTAssertEqualObjects(message.defaultBytes, defaultBytes);
XCTAssertTrue(message.hasDefaultBytes);
[message setDefaultBytes:nil];
XCTAssertEqualObjects(message.defaultBytes, defaultBytes);
XCTAssertFalse(message.hasDefaultBytes);
message.hasDefaultBytes = NO;
XCTAssertFalse(message.hasDefaultBytes);
XCTAssertEqualObjects(message.defaultBytes, defaultBytes);
// Test optional string.
XCTAssertFalse(message.hasOptionalString);
XCTAssertEqualObjects(message.optionalString, @"");
XCTAssertFalse(message.hasOptionalString);
message.optionalString = nil;
XCTAssertFalse(message.hasOptionalString);
XCTAssertEqualObjects(message.optionalString, @"");
NSString *string = @"string";
message.optionalString = string;
XCTAssertEqualObjects(message.optionalString, string);
XCTAssertTrue(message.hasOptionalString);
message.optionalString = nil;
XCTAssertFalse(message.hasOptionalString);
XCTAssertEqualObjects(message.optionalString, @"");
// Test optional data.
XCTAssertFalse(message.hasOptionalBytes);
XCTAssertEqualObjects(message.optionalBytes, GPBEmptyNSData());
XCTAssertFalse(message.hasOptionalBytes);
message.optionalBytes = nil;
XCTAssertFalse(message.hasOptionalBytes);
XCTAssertEqualObjects(message.optionalBytes, GPBEmptyNSData());
NSData *data = [@"bytes" dataUsingEncoding:NSUTF8StringEncoding];
message.optionalBytes = data;
XCTAssertEqualObjects(message.optionalBytes, data);
XCTAssertTrue(message.hasOptionalBytes);
message.optionalBytes = nil;
XCTAssertFalse(message.hasOptionalBytes);
XCTAssertEqualObjects(message.optionalBytes, GPBEmptyNSData());
// Test lazy message setting
XCTAssertFalse(message.hasOptionalLazyMessage);
XCTAssertNotNil(message.optionalLazyMessage);
XCTAssertFalse(message.hasOptionalLazyMessage);
message.hasOptionalLazyMessage = NO;
XCTAssertFalse(message.hasOptionalLazyMessage);
XCTAssertNotNil(message.optionalLazyMessage);
XCTAssertFalse(message.hasOptionalLazyMessage);
message.optionalLazyMessage = nil;
XCTAssertFalse(message.hasOptionalLazyMessage);
// Test nested messages
XCTAssertFalse(message.hasOptionalLazyMessage);
message.optionalLazyMessage.bb = 1;
XCTAssertTrue(message.hasOptionalLazyMessage);
XCTAssertEqual(message.optionalLazyMessage.bb, 1);
XCTAssertNotNil(message.optionalLazyMessage);
message.optionalLazyMessage = nil;
XCTAssertFalse(message.hasOptionalLazyMessage);
XCTAssertEqual(message.optionalLazyMessage.bb, 0);
XCTAssertFalse(message.hasOptionalLazyMessage);
XCTAssertNotNil(message.optionalLazyMessage);
// -testDefaultSubMessages tests the "defaulting" handling of fields
// containing messages.
}
- (void)testRepeatedSetters {
TestAllTypes *message = [TestAllTypes message];
[self setAllFields:message repeatedCount:kGPBDefaultRepeatCount];
[self modifyRepeatedFields:message];
[self assertRepeatedFieldsModified:message
repeatedCount:kGPBDefaultRepeatCount];
}
- (void)testClear {
TestAllTypes *message = [TestAllTypes message];
[self setAllFields:message repeatedCount:kGPBDefaultRepeatCount];
[self clearAllFields:message];
[self assertClear:message];
TestAllTypes *message2 = [TestAllTypes message];
XCTAssertEqualObjects(message, message2);
}
- (void)testClearKVC {
TestAllTypes *message = [TestAllTypes message];
[self setAllFields:message repeatedCount:kGPBDefaultRepeatCount];
[self clearAllFields:message];
[self assertClear:message];
[self assertClearKVC:message];
}
- (void)testClearExtension {
// clearExtension() is not actually used in TestUtil, so try it manually.
GPBMessage *message1 = [TestAllExtensions message];
[message1 setExtension:[UnittestRoot optionalInt32Extension] value:@1];
XCTAssertTrue([message1 hasExtension:[UnittestRoot optionalInt32Extension]]);
[message1 clearExtension:[UnittestRoot optionalInt32Extension]];
XCTAssertFalse([message1 hasExtension:[UnittestRoot optionalInt32Extension]]);
GPBMessage *message2 = [TestAllExtensions message];
[message2 addExtension:[UnittestRoot repeatedInt32Extension] value:@1];
XCTAssertEqual(
[[message2 getExtension:[UnittestRoot repeatedInt32Extension]] count],
(NSUInteger)1);
[message2 clearExtension:[UnittestRoot repeatedInt32Extension]];
XCTAssertEqual(
[[message2 getExtension:[UnittestRoot repeatedInt32Extension]] count],
(NSUInteger)0);
// Clearing an unset extension field shouldn't make the target message
// visible.
GPBMessage *message3 = [TestAllExtensions message];
GPBMessage *extension_msg =
[message3 getExtension:[UnittestObjcRoot recursiveExtension]];
XCTAssertFalse([message3 hasExtension:[UnittestObjcRoot recursiveExtension]]);
[extension_msg clearExtension:[UnittestRoot optionalInt32Extension]];
XCTAssertFalse([message3 hasExtension:[UnittestObjcRoot recursiveExtension]]);
}
- (void)testDefaultingSubMessages {
TestAllTypes *message = [TestAllTypes message];
// Initially they should all not have values.
XCTAssertFalse(message.hasOptionalGroup);
XCTAssertFalse(message.hasOptionalNestedMessage);
XCTAssertFalse(message.hasOptionalForeignMessage);
XCTAssertFalse(message.hasOptionalImportMessage);
XCTAssertFalse(message.hasOptionalPublicImportMessage);
XCTAssertFalse(message.hasOptionalLazyMessage);
// They should auto create something when fetched.
TestAllTypes_OptionalGroup *optionalGroup = [message.optionalGroup retain];
TestAllTypes_NestedMessage *optionalNestedMessage =
[message.optionalNestedMessage retain];
ForeignMessage *optionalForeignMessage =
[message.optionalForeignMessage retain];
ImportMessage *optionalImportMessage = [message.optionalImportMessage retain];
PublicImportMessage *optionalPublicImportMessage =
[message.optionalPublicImportMessage retain];
TestAllTypes_NestedMessage *optionalLazyMessage =
[message.optionalLazyMessage retain];
XCTAssertNotNil(optionalGroup);
XCTAssertNotNil(optionalNestedMessage);
XCTAssertNotNil(optionalForeignMessage);
XCTAssertNotNil(optionalImportMessage);
XCTAssertNotNil(optionalPublicImportMessage);
XCTAssertNotNil(optionalLazyMessage);
// Although they were created, they should not respond to hasValue until that
// submessage is mutated.
XCTAssertFalse(message.hasOptionalGroup);
XCTAssertFalse(message.hasOptionalNestedMessage);
XCTAssertFalse(message.hasOptionalForeignMessage);
XCTAssertFalse(message.hasOptionalImportMessage);
XCTAssertFalse(message.hasOptionalPublicImportMessage);
XCTAssertFalse(message.hasOptionalLazyMessage);
// And they set that value back in to the message since the value created was
// mutable (so a second fetch should give the same object).
XCTAssertEqual(message.optionalGroup, optionalGroup);
XCTAssertEqual(message.optionalNestedMessage, optionalNestedMessage);
XCTAssertEqual(message.optionalForeignMessage, optionalForeignMessage);
XCTAssertEqual(message.optionalImportMessage, optionalImportMessage);
XCTAssertEqual(message.optionalPublicImportMessage,
optionalPublicImportMessage);
XCTAssertEqual(message.optionalLazyMessage, optionalLazyMessage);
// And the default objects for a second message should be distinct (again,
// since they are mutable, each needs their own copy).
TestAllTypes *message2 = [TestAllTypes message];
// Intentionally doing a pointer comparison.
XCTAssertNotEqual(message2.optionalGroup, optionalGroup);
XCTAssertNotEqual(message2.optionalNestedMessage, optionalNestedMessage);
XCTAssertNotEqual(message2.optionalForeignMessage, optionalForeignMessage);
XCTAssertNotEqual(message2.optionalImportMessage, optionalImportMessage);
XCTAssertNotEqual(message2.optionalPublicImportMessage,
optionalPublicImportMessage);
XCTAssertNotEqual(message2.optionalLazyMessage, optionalLazyMessage);
// Setting the values to nil will clear the has flag, and on next access you
// get back new submessages.
message.optionalGroup = nil;
message.optionalNestedMessage = nil;
message.optionalForeignMessage = nil;
message.optionalImportMessage = nil;
message.optionalPublicImportMessage = nil;
message.optionalLazyMessage = nil;
XCTAssertFalse(message.hasOptionalGroup);
XCTAssertFalse(message.hasOptionalNestedMessage);
XCTAssertFalse(message.hasOptionalForeignMessage);
XCTAssertFalse(message.hasOptionalImportMessage);
XCTAssertFalse(message.hasOptionalPublicImportMessage);
XCTAssertFalse(message.hasOptionalLazyMessage);
// Intentionally doing a pointer comparison.
XCTAssertNotEqual(message.optionalGroup, optionalGroup);
XCTAssertNotEqual(message.optionalNestedMessage, optionalNestedMessage);
XCTAssertNotEqual(message.optionalForeignMessage, optionalForeignMessage);
XCTAssertNotEqual(message.optionalImportMessage, optionalImportMessage);
XCTAssertNotEqual(message.optionalPublicImportMessage,
optionalPublicImportMessage);
XCTAssertNotEqual(message.optionalLazyMessage, optionalLazyMessage);
[optionalGroup release];
[optionalNestedMessage release];
[optionalForeignMessage release];
[optionalImportMessage release];
[optionalPublicImportMessage release];
[optionalLazyMessage release];
}
- (void)testMultiplePointersToAutocreatedMessage {
// Multiple objects pointing to the same autocreated message.
TestAllTypes *message = [TestAllTypes message];
TestAllTypes *message2 = [TestAllTypes message];
message2.optionalGroup = message.optionalGroup;
XCTAssertTrue([message2 hasOptionalGroup]);
XCTAssertFalse([message hasOptionalGroup]);
message2.optionalGroup.a = 42;
XCTAssertTrue([message hasOptionalGroup]);
XCTAssertTrue([message2 hasOptionalGroup]);
}
- (void)testCopyWithAutocreatedMessage {
// Mutable copy should not copy autocreated messages.
TestAllTypes *message = [TestAllTypes message];
message.optionalGroup.a = 42;
XCTAssertNotNil(message.optionalNestedMessage);
TestAllTypes *message2 = [[message copy] autorelease];
XCTAssertTrue([message2 hasOptionalGroup]);
XCTAssertFalse([message2 hasOptionalNestedMessage]);
// Intentionally doing a pointer comparison.
XCTAssertNotEqual(message.optionalNestedMessage,
message2.optionalNestedMessage);
}
- (void)testClearAutocreatedSubmessage {
// Call clear on an intermediate submessage should cause it to get recreated
// on the next call.
TestRecursiveMessage *message = [TestRecursiveMessage message];
TestRecursiveMessage *message_inner = [message.a.a.a retain];
XCTAssertNotNil(message_inner);
XCTAssertTrue(GPBWasMessageAutocreatedBy(message_inner, message.a.a));
[message.a.a clear];
XCTAssertFalse(GPBWasMessageAutocreatedBy(message_inner, message.a.a));
// Intentionally doing a pointer comparison.
XCTAssertNotEqual(message.a.a.a, message_inner);
[message_inner release];
}
- (void)testRetainAutocreatedSubmessage {
// Should be able to retain autocreated submessage while the creator is
// dealloced.
TestAllTypes *message = [TestAllTypes message];
ForeignMessage *subMessage;
@autoreleasepool {
TestAllTypes *message2 = [TestAllTypes message];
subMessage = message2.optionalForeignMessage; // Autocreated
message.optionalForeignMessage = subMessage;
XCTAssertTrue(GPBWasMessageAutocreatedBy(message.optionalForeignMessage,
message2));
}
// Should be the same object, and should still be live.
XCTAssertEqual(message.optionalForeignMessage, subMessage);
XCTAssertNotNil([subMessage description]);
}
- (void)testSetNilAutocreatedSubmessage {
TestRecursiveMessage *message = [TestRecursiveMessage message];
TestRecursiveMessage *message_inner = [message.a.a retain];
XCTAssertFalse([message hasA]);
XCTAssertFalse([message.a hasA]);
message.a.a = nil;
// |message.a| has to be made visible, but |message.a.a| was set to nil so
// shouldn't be.
XCTAssertTrue([message hasA]);
XCTAssertFalse([message.a hasA]);
// Setting submessage to nil should cause it to lose its creator.
XCTAssertFalse(GPBWasMessageAutocreatedBy(message_inner, message.a));
// After setting to nil, getting it again should create a new autocreated
// message.
// Intentionally doing a pointer comparison.
XCTAssertNotEqual(message.a.a, message_inner);
[message_inner release];
}
- (void)testSetDoesntHaveAutocreatedSubmessage {
// Clearing submessage (set has == NO) should NOT cause it to lose its
// creator.
TestAllTypes *message = [TestAllTypes message];
TestAllTypes_NestedMessage *nestedMessage = message.optionalNestedMessage;
XCTAssertFalse([message hasOptionalNestedMessage]);
[message setHasOptionalNestedMessage:NO];
XCTAssertFalse([message hasOptionalNestedMessage]);
XCTAssertEqual(message.optionalNestedMessage, nestedMessage);
}
- (void)testSetAutocreatedMessageBecomesVisible {
// Setting a value should cause the submessage to appear to its creator.
// Test this several levels deep.
TestRecursiveMessage *message = [TestRecursiveMessage message];
message.a.a.a.a.i = 42;
XCTAssertTrue([message hasA]);
XCTAssertTrue([message.a hasA]);
XCTAssertTrue([message.a.a hasA]);
XCTAssertTrue([message.a.a.a hasA]);
XCTAssertFalse([message.a.a.a.a hasA]);
XCTAssertEqual(message.a.a.a.a.i, 42);
}
- (void)testClearUnsetFieldOfAutocreatedMessage {
// Clearing an unset field should not cause the submessage to appear to its
// creator.
TestRecursiveMessage *message = [TestRecursiveMessage message];
message.a.a.a.a.hasI = NO;
XCTAssertFalse([message hasA]);
XCTAssertFalse([message.a hasA]);
XCTAssertFalse([message.a.a hasA]);
XCTAssertFalse([message.a.a.a hasA]);
}
- (void)testAutocreatedSubmessageAssignSkip {
TestRecursiveMessage *message = [TestRecursiveMessage message];
TestRecursiveMessage *messageLevel1 = [message.a retain];
TestRecursiveMessage *messageLevel2 = [message.a.a retain];
TestRecursiveMessage *messageLevel3 = [message.a.a.a retain];
TestRecursiveMessage *messageLevel4 = [message.a.a.a.a retain];
XCTAssertTrue(GPBWasMessageAutocreatedBy(messageLevel1, message));
XCTAssertTrue(GPBWasMessageAutocreatedBy(messageLevel2, messageLevel1));
XCTAssertTrue(GPBWasMessageAutocreatedBy(messageLevel3, messageLevel2));
XCTAssertTrue(GPBWasMessageAutocreatedBy(messageLevel4, messageLevel3));
// Test skipping over an autocreated submessage and ensure it gets unset.
message.a = message.a.a;
XCTAssertEqual(message.a, messageLevel2);
XCTAssertTrue([message hasA]);
XCTAssertEqual(message.a.a, messageLevel3);
XCTAssertFalse([message.a hasA]);
XCTAssertEqual(message.a.a.a, messageLevel4);
XCTAssertFalse(GPBWasMessageAutocreatedBy(messageLevel1,
message)); // Because it was orphaned.
XCTAssertTrue(GPBWasMessageAutocreatedBy(messageLevel2, messageLevel1));
XCTAssertTrue(GPBWasMessageAutocreatedBy(messageLevel3, messageLevel2));
[messageLevel1 release];
[messageLevel2 release];
[messageLevel3 release];
[messageLevel4 release];
}
- (void)testAutocreatedSubmessageAssignLoop {
TestRecursiveMessage *message = [TestRecursiveMessage message];
TestRecursiveMessage *messageLevel1 = [message.a retain];
TestRecursiveMessage *messageLevel2 = [message.a.a retain];
TestRecursiveMessage *messageLevel3 = [message.a.a.a retain];
TestRecursiveMessage *messageLevel4 = [message.a.a.a.a retain];
XCTAssertTrue(GPBWasMessageAutocreatedBy(messageLevel1, message));
XCTAssertTrue(GPBWasMessageAutocreatedBy(messageLevel2, messageLevel1));
XCTAssertTrue(GPBWasMessageAutocreatedBy(messageLevel3, messageLevel2));
XCTAssertTrue(GPBWasMessageAutocreatedBy(messageLevel4, messageLevel3));
// Test a property with a loop. You'd never do this but at least ensure the
// autocreated submessages behave sanely.
message.a.a = message.a;
XCTAssertTrue([message hasA]);
XCTAssertEqual(message.a, messageLevel1);
XCTAssertTrue([message.a hasA]);
XCTAssertEqual(message.a.a, messageLevel1);
XCTAssertTrue([message.a.a hasA]);
XCTAssertEqual(message.a.a.a, messageLevel1);
XCTAssertFalse(GPBWasMessageAutocreatedBy(messageLevel1,
message)); // Because it was assigned.
XCTAssertFalse(GPBWasMessageAutocreatedBy(messageLevel2,
messageLevel1)); // Because it was orphaned.
XCTAssertFalse([messageLevel2 hasA]);
// Break the retain loop.
message.a.a = nil;
XCTAssertTrue([message hasA]);
XCTAssertFalse([message.a hasA]);
[messageLevel1 release];
[messageLevel2 release];
[messageLevel3 release];
[messageLevel4 release];
}
- (void)testSetAutocreatedSubmessage {
// Setting autocreated submessage to another value should cause the old one to
// lose its creator.
TestAllTypes *message = [TestAllTypes message];
TestAllTypes_NestedMessage *nestedMessage =
[message.optionalNestedMessage retain];
message.optionalNestedMessage = [TestAllTypes_NestedMessage message];
XCTAssertTrue([message hasOptionalNestedMessage]);
XCTAssertTrue(message.optionalNestedMessage != nestedMessage);
XCTAssertFalse(GPBWasMessageAutocreatedBy(nestedMessage, message));
[nestedMessage release];
}
- (void)testAutocreatedUnknownFields {
// Doing anything with (except reading) unknown fields should cause the
// submessage to become visible.
TestAllTypes *message = [TestAllTypes message];
XCTAssertNotNil(message.optionalNestedMessage);
XCTAssertFalse([message hasOptionalNestedMessage]);
XCTAssertNil(message.optionalNestedMessage.unknownFields);
XCTAssertFalse([message hasOptionalNestedMessage]);
GPBUnknownFieldSet *unknownFields =
[[[GPBUnknownFieldSet alloc] init] autorelease];
message.optionalNestedMessage.unknownFields = unknownFields;
XCTAssertTrue([message hasOptionalNestedMessage]);
message.optionalNestedMessage = nil;
XCTAssertFalse([message hasOptionalNestedMessage]);
[message.optionalNestedMessage setUnknownFields:unknownFields];
XCTAssertTrue([message hasOptionalNestedMessage]);
}
- (void)testSetAutocreatedSubmessageToSelf {
// Setting submessage to itself should cause it to become visible.
TestAllTypes *message = [TestAllTypes message];
XCTAssertNotNil(message.optionalNestedMessage);
XCTAssertFalse([message hasOptionalNestedMessage]);
message.optionalNestedMessage = message.optionalNestedMessage;
XCTAssertTrue([message hasOptionalNestedMessage]);
}
- (void)testAutocreatedSubmessageMemoryLeaks {
// Test for memory leaks with autocreated submessages.
TestRecursiveMessage *message;
TestRecursiveMessage *messageLevel1;
TestRecursiveMessage *messageLevel2;
TestRecursiveMessage *messageLevel3;
TestRecursiveMessage *messageLevel4;
@autoreleasepool {
message = [[TestRecursiveMessage alloc] init];
messageLevel1 = [message.a retain];
messageLevel2 = [message.a.a retain];
messageLevel3 = [message.a.a.a retain];
messageLevel4 = [message.a.a.a.a retain];
message.a.i = 1;
}
XCTAssertEqual(message.retainCount, (NSUInteger)1);
[message release];
XCTAssertEqual(messageLevel1.retainCount, (NSUInteger)1);
[messageLevel1 release];
XCTAssertEqual(messageLevel2.retainCount, (NSUInteger)1);
[messageLevel2 release];
XCTAssertEqual(messageLevel3.retainCount, (NSUInteger)1);
[messageLevel3 release];
XCTAssertEqual(messageLevel4.retainCount, (NSUInteger)1);
[messageLevel4 release];
}
- (void)testDefaultingArrays {
// Basic tests for default creation of arrays in a message.
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
TestRecursiveMessageWithRepeatedField *message2 =
[TestRecursiveMessageWithRepeatedField message];
// Simply accessing the array should not make any fields visible.
XCTAssertNotNil(message.a.a.iArray);
XCTAssertFalse([message hasA]);
XCTAssertFalse([message.a hasA]);
XCTAssertNotNil(message2.a.a.strArray);
XCTAssertFalse([message2 hasA]);
XCTAssertFalse([message2.a hasA]);
// But adding an element to the array should.
[message.a.a.iArray addValue:42];
XCTAssertTrue([message hasA]);
XCTAssertTrue([message.a hasA]);
XCTAssertEqual([message.a.a.iArray count], (NSUInteger)1);
[message2.a.a.strArray addObject:@"foo"];
XCTAssertTrue([message2 hasA]);
XCTAssertTrue([message2.a hasA]);
XCTAssertEqual([message2.a.a.strArray count], (NSUInteger)1);
}
- (void)testAutocreatedArrayShared {
// Multiple objects pointing to the same array.
TestRecursiveMessageWithRepeatedField *message1a =
[TestRecursiveMessageWithRepeatedField message];
TestRecursiveMessageWithRepeatedField *message1b =
[TestRecursiveMessageWithRepeatedField message];
message1a.a.iArray = message1b.a.iArray;
XCTAssertTrue([message1a hasA]);
XCTAssertFalse([message1b hasA]);
[message1a.a.iArray addValue:1];
XCTAssertTrue([message1a hasA]);
XCTAssertTrue([message1b hasA]);
XCTAssertEqual(message1a.a.iArray, message1b.a.iArray);
TestRecursiveMessageWithRepeatedField *message2a =
[TestRecursiveMessageWithRepeatedField message];
TestRecursiveMessageWithRepeatedField *message2b =
[TestRecursiveMessageWithRepeatedField message];
message2a.a.strArray = message2b.a.strArray;
XCTAssertTrue([message2a hasA]);
XCTAssertFalse([message2b hasA]);
[message2a.a.strArray addObject:@"bar"];
XCTAssertTrue([message2a hasA]);
XCTAssertTrue([message2b hasA]);
XCTAssertEqual(message2a.a.strArray, message2b.a.strArray);
}
- (void)testAutocreatedArrayCopy {
// Copy should not copy autocreated arrays.
TestAllTypes *message = [TestAllTypes message];
XCTAssertNotNil(message.repeatedStringArray);
XCTAssertNotNil(message.repeatedInt32Array);
TestAllTypes *message2 = [[message copy] autorelease];
// Pointer conparisions.
XCTAssertNotEqual(message.repeatedStringArray, message2.repeatedStringArray);
XCTAssertNotEqual(message.repeatedInt32Array, message2.repeatedInt32Array);
// Mutable copy should copy empty arrays that were explicitly set (end up
// with different objects that are equal).
TestAllTypes *message3 = [TestAllTypes message];
message3.repeatedInt32Array = [GPBInt32Array arrayWithValue:42];
message3.repeatedStringArray = [NSMutableArray arrayWithObject:@"wee"];
XCTAssertNotNil(message.repeatedInt32Array);
XCTAssertNotNil(message.repeatedStringArray);
TestAllTypes *message4 = [[message3 copy] autorelease];
XCTAssertNotEqual(message3.repeatedInt32Array, message4.repeatedInt32Array);
XCTAssertEqualObjects(message3.repeatedInt32Array,
message4.repeatedInt32Array);
XCTAssertNotEqual(message3.repeatedStringArray, message4.repeatedStringArray);
XCTAssertEqualObjects(message3.repeatedStringArray,
message4.repeatedStringArray);
}
- (void)testAutocreatedArrayRetain {
// Should be able to retain autocreated array while the creator is dealloced.
TestAllTypes *message = [TestAllTypes message];
@autoreleasepool {
TestAllTypes *message2 = [TestAllTypes message];
message.repeatedInt32Array = message2.repeatedInt32Array;
message.repeatedStringArray = message2.repeatedStringArray;
// Pointer conparision
XCTAssertEqual(message.repeatedInt32Array->_autocreator, message2);
XCTAssertTrue([message.repeatedStringArray
isKindOfClass:[GPBAutocreatedArray class]]);
XCTAssertEqual(
((GPBAutocreatedArray *)message.repeatedStringArray)->_autocreator,
message2);
}
XCTAssertNil(message.repeatedInt32Array->_autocreator);
XCTAssertTrue(
[message.repeatedStringArray isKindOfClass:[GPBAutocreatedArray class]]);
XCTAssertNil(
((GPBAutocreatedArray *)message.repeatedStringArray)->_autocreator);
}
- (void)testSetNilAutocreatedArray {
// Setting array to nil should cause it to lose its delegate.
TestAllTypes *message = [TestAllTypes message];
GPBInt32Array *repeatedInt32Array = [message.repeatedInt32Array retain];
GPBAutocreatedArray *repeatedStringArray =
(GPBAutocreatedArray *)[message.repeatedStringArray retain];
XCTAssertTrue([repeatedStringArray isKindOfClass:[GPBAutocreatedArray class]]);
XCTAssertEqual(repeatedInt32Array->_autocreator, message);
XCTAssertEqual(repeatedStringArray->_autocreator, message);
message.repeatedInt32Array = nil;
message.repeatedStringArray = nil;
XCTAssertNil(repeatedInt32Array->_autocreator);
XCTAssertNil(repeatedStringArray->_autocreator);
[repeatedInt32Array release];
[repeatedStringArray release];
}
- (void)testSetOverAutocreatedArrayAndSetAgain {
// Ensure when dealing with replacing an array it is handled being either
// an autocreated one or a straight NSArray.
// The real test here is that nothing crashes while doing the work.
TestAllTypes *message = [TestAllTypes message];
[message.repeatedStringArray addObject:@"foo"];
XCTAssertEqual(message.repeatedStringArray_Count, (NSUInteger)1);
message.repeatedStringArray = [NSMutableArray arrayWithObjects:@"bar", @"bar2", nil];
XCTAssertEqual(message.repeatedStringArray_Count, (NSUInteger)2);
message.repeatedStringArray = [NSMutableArray arrayWithObject:@"baz"];
XCTAssertEqual(message.repeatedStringArray_Count, (NSUInteger)1);
}
- (void)testReplaceAutocreatedArray {
// Replacing array should orphan the old one and cause its creator to become
// visible.
{
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
XCTAssertNotNil(message.a);
XCTAssertNotNil(message.a.iArray);
XCTAssertFalse([message hasA]);
GPBInt32Array *iArray = [message.a.iArray retain];
XCTAssertEqual(iArray->_autocreator, message.a); // Pointer comparision
message.a.iArray = [GPBInt32Array arrayWithValue:1];
XCTAssertTrue([message hasA]);
XCTAssertNotEqual(message.a.iArray, iArray); // Pointer comparision
XCTAssertNil(iArray->_autocreator);
[iArray release];
}
{
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
XCTAssertNotNil(message.a);
XCTAssertNotNil(message.a.strArray);
XCTAssertFalse([message hasA]);
GPBAutocreatedArray *strArray =
(GPBAutocreatedArray *)[message.a.strArray retain];
XCTAssertTrue([strArray isKindOfClass:[GPBAutocreatedArray class]]);
XCTAssertEqual(strArray->_autocreator, message.a); // Pointer comparision
message.a.strArray = [NSMutableArray arrayWithObject:@"foo"];
XCTAssertTrue([message hasA]);
XCTAssertNotEqual(message.a.strArray, strArray); // Pointer comparision
XCTAssertNil(strArray->_autocreator);
[strArray release];
}
}
- (void)testSetAutocreatedArrayToSelf {
// Setting array to itself should cause it to become visible.
{
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
XCTAssertNotNil(message.a);
XCTAssertNotNil(message.a.iArray);
XCTAssertFalse([message hasA]);
message.a.iArray = message.a.iArray;
XCTAssertTrue([message hasA]);
XCTAssertNil(message.a.iArray->_autocreator);
}
{
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
XCTAssertNotNil(message.a);
XCTAssertNotNil(message.a.strArray);
XCTAssertFalse([message hasA]);
message.a.strArray = message.a.strArray;
XCTAssertTrue([message hasA]);
XCTAssertTrue([message.a.strArray isKindOfClass:[GPBAutocreatedArray class]]);
XCTAssertNil(((GPBAutocreatedArray *)message.a.strArray)->_autocreator);
}
}
- (void)testAutocreatedArrayRemoveAllValues {
// Calling removeAllValues on autocreated array should not cause it to be
// visible.
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
[message.a.iArray removeAll];
XCTAssertFalse([message hasA]);
[message.a.strArray removeAllObjects];
XCTAssertFalse([message hasA]);
}
- (void)testDefaultingMaps {
// Basic tests for default creation of maps in a message.
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
TestRecursiveMessageWithRepeatedField *message2 =
[TestRecursiveMessageWithRepeatedField message];
// Simply accessing the map should not make any fields visible.
XCTAssertNotNil(message.a.a.iToI);
XCTAssertFalse([message hasA]);
XCTAssertFalse([message.a hasA]);
XCTAssertNotNil(message2.a.a.strToStr);
XCTAssertFalse([message2 hasA]);
XCTAssertFalse([message2.a hasA]);
// But adding an element to the map should.
[message.a.a.iToI setInt32:100 forKey:200];
XCTAssertTrue([message hasA]);
XCTAssertTrue([message.a hasA]);
XCTAssertEqual([message.a.a.iToI count], (NSUInteger)1);
[message2.a.a.strToStr setObject:@"foo" forKey:@"bar"];
XCTAssertTrue([message2 hasA]);
XCTAssertTrue([message2.a hasA]);
XCTAssertEqual([message2.a.a.strToStr count], (NSUInteger)1);
}
- (void)testAutocreatedMapShared {
// Multiple objects pointing to the same map.
TestRecursiveMessageWithRepeatedField *message1a =
[TestRecursiveMessageWithRepeatedField message];
TestRecursiveMessageWithRepeatedField *message1b =
[TestRecursiveMessageWithRepeatedField message];
message1a.a.iToI = message1b.a.iToI;
XCTAssertTrue([message1a hasA]);
XCTAssertFalse([message1b hasA]);
[message1a.a.iToI setInt32:1 forKey:2];
XCTAssertTrue([message1a hasA]);
XCTAssertTrue([message1b hasA]);
XCTAssertEqual(message1a.a.iToI, message1b.a.iToI);
TestRecursiveMessageWithRepeatedField *message2a =
[TestRecursiveMessageWithRepeatedField message];
TestRecursiveMessageWithRepeatedField *message2b =
[TestRecursiveMessageWithRepeatedField message];
message2a.a.strToStr = message2b.a.strToStr;
XCTAssertTrue([message2a hasA]);
XCTAssertFalse([message2b hasA]);
[message2a.a.strToStr setObject:@"bar" forKey:@"foo"];
XCTAssertTrue([message2a hasA]);
XCTAssertTrue([message2b hasA]);
XCTAssertEqual(message2a.a.strToStr, message2b.a.strToStr);
}
- (void)testAutocreatedMapCopy {
// Copy should not copy autocreated maps.
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
XCTAssertNotNil(message.strToStr);
XCTAssertNotNil(message.iToI);
TestRecursiveMessageWithRepeatedField *message2 =
[[message copy] autorelease];
// Pointer conparisions.
XCTAssertNotEqual(message.strToStr, message2.strToStr);
XCTAssertNotEqual(message.iToI, message2.iToI);
// Mutable copy should copy empty arrays that were explicitly set (end up
// with different objects that are equal).
TestRecursiveMessageWithRepeatedField *message3 =
[TestRecursiveMessageWithRepeatedField message];
message3.iToI = [GPBInt32Int32Dictionary dictionaryWithInt32:10 forKey:20];
message3.strToStr =
[NSMutableDictionary dictionaryWithObject:@"abc" forKey:@"123"];
XCTAssertNotNil(message.iToI);
XCTAssertNotNil(message.iToI);
TestRecursiveMessageWithRepeatedField *message4 =
[[message3 copy] autorelease];
XCTAssertNotEqual(message3.iToI, message4.iToI);
XCTAssertEqualObjects(message3.iToI, message4.iToI);
XCTAssertNotEqual(message3.strToStr, message4.strToStr);
XCTAssertEqualObjects(message3.strToStr, message4.strToStr);
}
- (void)testAutocreatedMapRetain {
// Should be able to retain autocreated map while the creator is dealloced.
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
@autoreleasepool {
TestRecursiveMessageWithRepeatedField *message2 =
[TestRecursiveMessageWithRepeatedField message];
message.iToI = message2.iToI;
message.strToStr = message2.strToStr;
// Pointer conparision
XCTAssertEqual(message.iToI->_autocreator, message2);
XCTAssertTrue([message.strToStr
isKindOfClass:[GPBAutocreatedDictionary class]]);
XCTAssertEqual(
((GPBAutocreatedDictionary *)message.strToStr)->_autocreator,
message2);
}
XCTAssertNil(message.iToI->_autocreator);
XCTAssertTrue(
[message.strToStr isKindOfClass:[GPBAutocreatedDictionary class]]);
XCTAssertNil(
((GPBAutocreatedDictionary *)message.strToStr)->_autocreator);
}
- (void)testSetNilAutocreatedMap {
// Setting map to nil should cause it to lose its delegate.
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
GPBInt32Int32Dictionary *iToI = [message.iToI retain];
GPBAutocreatedDictionary *strToStr =
(GPBAutocreatedDictionary *)[message.strToStr retain];
XCTAssertTrue([strToStr isKindOfClass:[GPBAutocreatedDictionary class]]);
XCTAssertEqual(iToI->_autocreator, message);
XCTAssertEqual(strToStr->_autocreator, message);
message.iToI = nil;
message.strToStr = nil;
XCTAssertNil(iToI->_autocreator);
XCTAssertNil(strToStr->_autocreator);
[iToI release];
[strToStr release];
}
- (void)testSetOverAutocreatedMapAndSetAgain {
// Ensure when dealing with replacing a map it is handled being either
// an autocreated one or a straight NSDictionary.
// The real test here is that nothing crashes while doing the work.
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
message.strToStr[@"foo"] = @"bar";
XCTAssertEqual(message.strToStr_Count, (NSUInteger)1);
message.strToStr =
[NSMutableDictionary dictionaryWithObjectsAndKeys:@"bar", @"key1", @"baz", @"key2", nil];
XCTAssertEqual(message.strToStr_Count, (NSUInteger)2);
message.strToStr =
[NSMutableDictionary dictionaryWithObject:@"baz" forKey:@"mumble"];
XCTAssertEqual(message.strToStr_Count, (NSUInteger)1);
}
- (void)testReplaceAutocreatedMap {
// Replacing map should orphan the old one and cause its creator to become
// visible.
{
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
XCTAssertNotNil(message.a);
XCTAssertNotNil(message.a.iToI);
XCTAssertFalse([message hasA]);
GPBInt32Int32Dictionary *iToI = [message.a.iToI retain];
XCTAssertEqual(iToI->_autocreator, message.a); // Pointer comparision
message.a.iToI = [GPBInt32Int32Dictionary dictionaryWithInt32:6 forKey:7];
XCTAssertTrue([message hasA]);
XCTAssertNotEqual(message.a.iToI, iToI); // Pointer comparision
XCTAssertNil(iToI->_autocreator);
[iToI release];
}
{
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
XCTAssertNotNil(message.a);
XCTAssertNotNil(message.a.strToStr);
XCTAssertFalse([message hasA]);
GPBAutocreatedDictionary *strToStr =
(GPBAutocreatedDictionary *)[message.a.strToStr retain];
XCTAssertTrue([strToStr isKindOfClass:[GPBAutocreatedDictionary class]]);
XCTAssertEqual(strToStr->_autocreator, message.a); // Pointer comparision
message.a.strToStr =
[NSMutableDictionary dictionaryWithObject:@"abc" forKey:@"def"];
XCTAssertTrue([message hasA]);
XCTAssertNotEqual(message.a.strToStr, strToStr); // Pointer comparision
XCTAssertNil(strToStr->_autocreator);
[strToStr release];
}
}
- (void)testSetAutocreatedMapToSelf {
// Setting map to itself should cause it to become visible.
{
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
XCTAssertNotNil(message.a);
XCTAssertNotNil(message.a.iToI);
XCTAssertFalse([message hasA]);
message.a.iToI = message.a.iToI;
XCTAssertTrue([message hasA]);
XCTAssertNil(message.a.iToI->_autocreator);
}
{
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
XCTAssertNotNil(message.a);
XCTAssertNotNil(message.a.strToStr);
XCTAssertFalse([message hasA]);
message.a.strToStr = message.a.strToStr;
XCTAssertTrue([message hasA]);
XCTAssertTrue([message.a.strToStr isKindOfClass:[GPBAutocreatedDictionary class]]);
XCTAssertNil(((GPBAutocreatedDictionary *)message.a.strToStr)->_autocreator);
}
}
- (void)testAutocreatedMapRemoveAllValues {
// Calling removeAll on autocreated map should not cause it to be visible.
TestRecursiveMessageWithRepeatedField *message =
[TestRecursiveMessageWithRepeatedField message];
[message.a.iToI removeAll];
XCTAssertFalse([message hasA]);
[message.a.strToStr removeAllObjects];
XCTAssertFalse([message hasA]);
}
- (void)testExtensionAccessors {
TestAllExtensions *message = [TestAllExtensions message];
[self setAllExtensions:message repeatedCount:kGPBDefaultRepeatCount];
[self assertAllExtensionsSet:message repeatedCount:kGPBDefaultRepeatCount];
}
- (void)testExtensionRepeatedSetters {
TestAllExtensions *message = [TestAllExtensions message];
[self setAllExtensions:message repeatedCount:kGPBDefaultRepeatCount];
[self modifyRepeatedExtensions:message];
[self assertRepeatedExtensionsModified:message
repeatedCount:kGPBDefaultRepeatCount];
}
- (void)testExtensionDefaults {
[self assertExtensionsClear:[TestAllExtensions message]];
}
- (void)testExtensionIsEquals {
TestAllExtensions *message = [TestAllExtensions message];
[self setAllExtensions:message repeatedCount:kGPBDefaultRepeatCount];
[self modifyRepeatedExtensions:message];
TestAllExtensions *message2 = [TestAllExtensions message];
[self setAllExtensions:message2 repeatedCount:kGPBDefaultRepeatCount];
XCTAssertFalse([message isEqual:message2]);
message2 = [TestAllExtensions message];
[self setAllExtensions:message2 repeatedCount:kGPBDefaultRepeatCount];
[self modifyRepeatedExtensions:message2];
XCTAssertEqualObjects(message, message2);
}
- (void)testExtensionsMergeFrom {
TestAllExtensions *message = [TestAllExtensions message];
[self setAllExtensions:message repeatedCount:kGPBDefaultRepeatCount];
[self modifyRepeatedExtensions:message];
message = [TestAllExtensions message];
[self setAllExtensions:message repeatedCount:kGPBDefaultRepeatCount];
TestAllExtensions *message2 = [TestAllExtensions message];
[self modifyRepeatedExtensions:message2];
[message2 mergeFrom:message];
XCTAssertEqualObjects(message, message2);
}
- (void)testDefaultingExtensionMessages {
TestAllExtensions *message = [TestAllExtensions message];
// Initially they should all not have values.
XCTAssertFalse([message hasExtension:[UnittestRoot optionalGroupExtension]]);
XCTAssertFalse([message hasExtension:[UnittestRoot optionalGroupExtension]]);
XCTAssertFalse(
[message hasExtension:[UnittestRoot optionalNestedMessageExtension]]);
XCTAssertFalse(
[message hasExtension:[UnittestRoot optionalForeignMessageExtension]]);
XCTAssertFalse(
[message hasExtension:[UnittestRoot optionalImportMessageExtension]]);
XCTAssertFalse([message
hasExtension:[UnittestRoot optionalPublicImportMessageExtension]]);
XCTAssertFalse(
[message hasExtension:[UnittestRoot optionalLazyMessageExtension]]);
// They should auto create something when fetched.
TestAllTypes_OptionalGroup *optionalGroup =
[message getExtension:[UnittestRoot optionalGroupExtension]];
TestAllTypes_NestedMessage *optionalNestedMessage =
[message getExtension:[UnittestRoot optionalNestedMessageExtension]];
ForeignMessage *optionalForeignMessage =
[message getExtension:[UnittestRoot optionalForeignMessageExtension]];
ImportMessage *optionalImportMessage =
[message getExtension:[UnittestRoot optionalImportMessageExtension]];
PublicImportMessage *optionalPublicImportMessage = [message
getExtension:[UnittestRoot optionalPublicImportMessageExtension]];
TestAllTypes_NestedMessage *optionalLazyMessage =
[message getExtension:[UnittestRoot optionalLazyMessageExtension]];
XCTAssertNotNil(optionalGroup);
XCTAssertNotNil(optionalNestedMessage);
XCTAssertNotNil(optionalForeignMessage);
XCTAssertNotNil(optionalImportMessage);
XCTAssertNotNil(optionalPublicImportMessage);
XCTAssertNotNil(optionalLazyMessage);
// Although it auto-created empty messages, it should not show that it has
// them.
XCTAssertFalse([message hasExtension:[UnittestRoot optionalGroupExtension]]);
XCTAssertFalse([message hasExtension:[UnittestRoot optionalGroupExtension]]);
XCTAssertFalse([message hasExtension:[UnittestRoot optionalNestedMessageExtension]]);
XCTAssertFalse([message hasExtension:[UnittestRoot optionalForeignMessageExtension]]);
XCTAssertFalse([message hasExtension:[UnittestRoot optionalImportMessageExtension]]);
XCTAssertFalse([message hasExtension:[UnittestRoot optionalPublicImportMessageExtension]]);
XCTAssertFalse([message hasExtension:[UnittestRoot optionalLazyMessageExtension]]);
// And they set that value back in to the message since the value created was
// mutable (so a second fetch should give the same object).
XCTAssertEqual([message getExtension:[UnittestRoot optionalGroupExtension]],
optionalGroup);
XCTAssertEqual(
[message getExtension:[UnittestRoot optionalNestedMessageExtension]],
optionalNestedMessage);
XCTAssertEqual(
[message getExtension:[UnittestRoot optionalForeignMessageExtension]],
optionalForeignMessage);
XCTAssertEqual(
[message getExtension:[UnittestRoot optionalImportMessageExtension]],
optionalImportMessage);
XCTAssertEqual(
[message getExtension:[UnittestRoot optionalPublicImportMessageExtension]],
optionalPublicImportMessage);
XCTAssertEqual(
[message getExtension:[UnittestRoot optionalLazyMessageExtension]],
optionalLazyMessage);
// And the default objects for a second message should be distinct (again,
// since they are mutable, each needs their own copy).
TestAllExtensions *message2 = [TestAllExtensions message];
// Intentionally doing a pointer comparison.
XCTAssertNotEqual(
[message2 getExtension:[UnittestRoot optionalGroupExtension]],
optionalGroup);
XCTAssertNotEqual(
[message2 getExtension:[UnittestRoot optionalNestedMessageExtension]],
optionalNestedMessage);
XCTAssertNotEqual(
[message2 getExtension:[UnittestRoot optionalForeignMessageExtension]],
optionalForeignMessage);
XCTAssertNotEqual(
[message2 getExtension:[UnittestRoot optionalImportMessageExtension]],
optionalImportMessage);
XCTAssertNotEqual(
[message2 getExtension:[UnittestRoot optionalPublicImportMessageExtension]],
optionalPublicImportMessage);
XCTAssertNotEqual(
[message2 getExtension:[UnittestRoot optionalLazyMessageExtension]],
optionalLazyMessage);
// Clear values, and on next access you get back new submessages.
[message setExtension:[UnittestRoot optionalGroupExtension] value:nil];
[message setExtension:[UnittestRoot optionalGroupExtension] value:nil];
[message setExtension:[UnittestRoot optionalNestedMessageExtension]
value:nil];
[message setExtension:[UnittestRoot optionalForeignMessageExtension]
value:nil];
[message setExtension:[UnittestRoot optionalImportMessageExtension]
value:nil];
[message setExtension:[UnittestRoot optionalPublicImportMessageExtension]
value:nil];
[message setExtension:[UnittestRoot optionalLazyMessageExtension] value:nil];
XCTAssertFalse([message hasExtension:[UnittestRoot optionalGroupExtension]]);
XCTAssertFalse([message hasExtension:[UnittestRoot optionalGroupExtension]]);
XCTAssertFalse(
[message hasExtension:[UnittestRoot optionalNestedMessageExtension]]);
XCTAssertFalse(
[message hasExtension:[UnittestRoot optionalForeignMessageExtension]]);
XCTAssertFalse(
[message hasExtension:[UnittestRoot optionalImportMessageExtension]]);
XCTAssertFalse([message
hasExtension:[UnittestRoot optionalPublicImportMessageExtension]]);
XCTAssertFalse(
[message hasExtension:[UnittestRoot optionalLazyMessageExtension]]);
XCTAssertEqual([message getExtension:[UnittestRoot optionalGroupExtension]],
optionalGroup);
XCTAssertEqual(
[message getExtension:[UnittestRoot optionalNestedMessageExtension]],
optionalNestedMessage);
XCTAssertEqual(
[message getExtension:[UnittestRoot optionalForeignMessageExtension]],
optionalForeignMessage);
XCTAssertEqual(
[message getExtension:[UnittestRoot optionalImportMessageExtension]],
optionalImportMessage);
XCTAssertEqual(
[message
getExtension:[UnittestRoot optionalPublicImportMessageExtension]],
optionalPublicImportMessage);
XCTAssertEqual(
[message getExtension:[UnittestRoot optionalLazyMessageExtension]],
optionalLazyMessage);
}
- (void)testMultiplePointersToAutocreatedExtension {
// 2 objects point to the same auto-created extension. One should "has" it.
// The other should not.
TestAllExtensions *message = [TestAllExtensions message];
TestAllExtensions *message2 = [TestAllExtensions message];
GPBExtensionDescriptor *extension = [UnittestRoot optionalGroupExtension];
[message setExtension:extension value:[message2 getExtension:extension]];
XCTAssertEqual([message getExtension:extension],
[message2 getExtension:extension]);
XCTAssertFalse([message2 hasExtension:extension]);
XCTAssertTrue([message hasExtension:extension]);
TestAllTypes_OptionalGroup *extensionValue =
[message2 getExtension:extension];
extensionValue.a = 1;
XCTAssertTrue([message2 hasExtension:extension]);
XCTAssertTrue([message hasExtension:extension]);
}
- (void)testCopyWithAutocreatedExtension {
// Mutable copy shouldn't copy autocreated extensions.
TestAllExtensions *message = [TestAllExtensions message];
GPBExtensionDescriptor *optionalGroupExtension =
[UnittestRoot optionalGroupExtension];
GPBExtensionDescriptor *optionalNestedMessageExtesion =
[UnittestRoot optionalNestedMessageExtension];
TestAllTypes_OptionalGroup *optionalGroup =
[message getExtension:optionalGroupExtension];
optionalGroup.a = 42;
XCTAssertNotNil(optionalGroup);
XCTAssertNotNil([message getExtension:optionalNestedMessageExtesion]);
XCTAssertTrue([message hasExtension:optionalGroupExtension]);
XCTAssertFalse([message hasExtension:optionalNestedMessageExtesion]);
TestAllExtensions *message2 = [[message copy] autorelease];
// message2 should end up with its own copy of the optional group.
XCTAssertTrue([message2 hasExtension:optionalGroupExtension]);
XCTAssertEqualObjects([message getExtension:optionalGroupExtension],
[message2 getExtension:optionalGroupExtension]);
// Intentionally doing a pointer comparison.
XCTAssertNotEqual([message getExtension:optionalGroupExtension],
[message2 getExtension:optionalGroupExtension]);
XCTAssertFalse([message2 hasExtension:optionalNestedMessageExtesion]);
// Intentionally doing a pointer comparison (auto creation should be
// different)
XCTAssertNotEqual([message getExtension:optionalNestedMessageExtesion],
[message2 getExtension:optionalNestedMessageExtesion]);
}
- (void)testClearMessageAutocreatedExtension {
// Call clear should cause it to recreate its autocreated extensions.
TestAllExtensions *message = [TestAllExtensions message];
GPBExtensionDescriptor *optionalGroupExtension =
[UnittestRoot optionalGroupExtension];
TestAllTypes_OptionalGroup *optionalGroup =
[[message getExtension:optionalGroupExtension] retain];
[message clear];
TestAllTypes_OptionalGroup *optionalGroupNew =
[message getExtension:optionalGroupExtension];
// Intentionally doing a pointer comparison.
XCTAssertNotEqual(optionalGroup, optionalGroupNew);
[optionalGroup release];
}
- (void)testRetainAutocreatedExtension {
// Should be able to retain autocreated extension while the creator is
// dealloced.
TestAllExtensions *message = [TestAllExtensions message];
GPBExtensionDescriptor *optionalGroupExtension =
[UnittestRoot optionalGroupExtension];
@autoreleasepool {
TestAllExtensions *message2 = [TestAllExtensions message];
[message setExtension:optionalGroupExtension
value:[message2 getExtension:optionalGroupExtension]];
XCTAssertTrue(GPBWasMessageAutocreatedBy(
[message getExtension:optionalGroupExtension], message2));
}
XCTAssertFalse(GPBWasMessageAutocreatedBy(
[message getExtension:optionalGroupExtension], message));
}
- (void)testClearAutocreatedExtension {
// Clearing autocreated extension should NOT cause it to lose its creator.
TestAllExtensions *message = [TestAllExtensions message];
GPBExtensionDescriptor *optionalGroupExtension =
[UnittestRoot optionalGroupExtension];
TestAllTypes_OptionalGroup *optionalGroup =
[[message getExtension:optionalGroupExtension] retain];
[message clearExtension:optionalGroupExtension];
TestAllTypes_OptionalGroup *optionalGroupNew =
[message getExtension:optionalGroupExtension];
XCTAssertEqual(optionalGroup, optionalGroupNew);
XCTAssertFalse([message hasExtension:optionalGroupExtension]);
[optionalGroup release];
// Clearing autocreated extension should not cause its creator to become
// visible
GPBExtensionDescriptor *recursiveExtension =
[UnittestObjcRoot recursiveExtension];
TestAllExtensions *message_lvl2 = [message getExtension:recursiveExtension];
TestAllExtensions *message_lvl3 =
[message_lvl2 getExtension:recursiveExtension];
[message_lvl3 clearExtension:recursiveExtension];
XCTAssertFalse([message hasExtension:recursiveExtension]);
}
- (void)testSetAutocreatedExtensionBecomesVisible {
// Setting an extension should cause the extension to appear to its creator.
// Test this several levels deep.
TestAllExtensions *message = [TestAllExtensions message];
GPBExtensionDescriptor *recursiveExtension =
[UnittestObjcRoot recursiveExtension];
TestAllExtensions *message_lvl2 = [message getExtension:recursiveExtension];
TestAllExtensions *message_lvl3 =
[message_lvl2 getExtension:recursiveExtension];
TestAllExtensions *message_lvl4 =
[message_lvl3 getExtension:recursiveExtension];
XCTAssertFalse([message hasExtension:recursiveExtension]);
XCTAssertFalse([message_lvl2 hasExtension:recursiveExtension]);
XCTAssertFalse([message_lvl3 hasExtension:recursiveExtension]);
XCTAssertFalse([message_lvl4 hasExtension:recursiveExtension]);
[message_lvl4 setExtension:[UnittestRoot optionalInt32Extension] value:@(1)];
XCTAssertTrue([message hasExtension:recursiveExtension]);
XCTAssertTrue([message_lvl2 hasExtension:recursiveExtension]);
XCTAssertTrue([message_lvl3 hasExtension:recursiveExtension]);
XCTAssertFalse([message_lvl4 hasExtension:recursiveExtension]);
XCTAssertFalse(GPBWasMessageAutocreatedBy(message_lvl4, message_lvl3));
XCTAssertFalse(GPBWasMessageAutocreatedBy(message_lvl3, message_lvl2));
XCTAssertFalse(GPBWasMessageAutocreatedBy(message_lvl2, message));
}
- (void)testSetAutocreatedExtensionToSelf {
// Setting extension to itself should cause it to become visible.
TestAllExtensions *message = [TestAllExtensions message];
GPBExtensionDescriptor *optionalGroupExtension =
[UnittestRoot optionalGroupExtension];
XCTAssertNotNil([message getExtension:optionalGroupExtension]);
XCTAssertFalse([message hasExtension:optionalGroupExtension]);
[message setExtension:optionalGroupExtension
value:[message getExtension:optionalGroupExtension]];
XCTAssertTrue([message hasExtension:optionalGroupExtension]);
}
- (void)testAutocreatedExtensionMemoryLeaks {
GPBExtensionDescriptor *recursiveExtension =
[UnittestObjcRoot recursiveExtension];
// Test for memory leaks with autocreated extensions.
TestAllExtensions *message;
TestAllExtensions *message_lvl2;
TestAllExtensions *message_lvl3;
TestAllExtensions *message_lvl4;
@autoreleasepool {
message = [[TestAllExtensions alloc] init];
message_lvl2 = [[message getExtension:recursiveExtension] retain];
message_lvl3 = [[message_lvl2 getExtension:recursiveExtension] retain];
message_lvl4 = [[message_lvl3 getExtension:recursiveExtension] retain];
[message_lvl2 setExtension:[UnittestRoot optionalInt32Extension]
value:@(1)];
}
XCTAssertEqual(message.retainCount, (NSUInteger)1);
@autoreleasepool {
[message release];
}
XCTAssertEqual(message_lvl2.retainCount, (NSUInteger)1);
@autoreleasepool {
[message_lvl2 release];
}
XCTAssertEqual(message_lvl3.retainCount, (NSUInteger)1);
@autoreleasepool {
[message_lvl3 release];
}
XCTAssertEqual(message_lvl4.retainCount, (NSUInteger)1);
[message_lvl4 release];
}
- (void)testSetExtensionWithAutocreatedValue {
GPBExtensionDescriptor *recursiveExtension =
[UnittestObjcRoot recursiveExtension];
TestAllExtensions *message;
@autoreleasepool {
message = [[TestAllExtensions alloc] init];
[message getExtension:recursiveExtension];
}
// This statements checks that the extension value isn't accidentally
// dealloced when removing it from the autocreated map.
[message setExtension:recursiveExtension
value:[message getExtension:recursiveExtension]];
XCTAssertTrue([message hasExtension:recursiveExtension]);
[message release];
}
- (void)testRecursion {
TestRecursiveMessage *message = [TestRecursiveMessage message];
XCTAssertNotNil(message.a);
XCTAssertNotNil(message.a.a);
XCTAssertEqual(message.a.a.i, 0);
}
- (void)testGenerateAndParseUnknownMessage {
GPBUnknownFieldSet *unknowns =
[[[GPBUnknownFieldSet alloc] init] autorelease];
[unknowns mergeVarintField:123 value:456];
GPBMessage *message = [GPBMessage message];
[message setUnknownFields:unknowns];
NSData *data = [message data];
GPBMessage *message2 =
[GPBMessage parseFromData:data extensionRegistry:nil error:NULL];
XCTAssertEqualObjects(message, message2);
}
- (void)testDelimitedWriteAndParseMultipleMessages {
GPBUnknownFieldSet *unknowns1 =
[[[GPBUnknownFieldSet alloc] init] autorelease];
[unknowns1 mergeVarintField:123 value:456];
GPBMessage *message1 = [GPBMessage message];
[message1 setUnknownFields:unknowns1];
GPBUnknownFieldSet *unknowns2 =
[[[GPBUnknownFieldSet alloc] init] autorelease];
[unknowns2 mergeVarintField:789 value:987];
[unknowns2 mergeVarintField:654 value:321];
GPBMessage *message2 = [GPBMessage message];
[message2 setUnknownFields:unknowns2];
NSMutableData *delimitedData = [NSMutableData data];
[delimitedData appendData:[message1 delimitedData]];
[delimitedData appendData:[message2 delimitedData]];
GPBCodedInputStream *input =
[GPBCodedInputStream streamWithData:delimitedData];
GPBMessage *message3 = [GPBMessage parseDelimitedFromCodedInputStream:input
extensionRegistry:nil
error:NULL];
GPBMessage *message4 = [GPBMessage parseDelimitedFromCodedInputStream:input
extensionRegistry:nil
error:NULL];
XCTAssertEqualObjects(message1, message3);
XCTAssertEqualObjects(message2, message4);
}
- (void)testDuplicateEnums {
XCTAssertEqual(TestEnumWithDupValue_Foo1, TestEnumWithDupValue_Foo2);
}
- (void)testWeirdDefaults {
ObjcWeirdDefaults *message = [ObjcWeirdDefaults message];
GPBDescriptor *descriptor = [[message class] descriptor];
GPBFieldDescriptor *fieldDesc = [descriptor fieldWithName:@"foo"];
XCTAssertNotNil(fieldDesc);
XCTAssertTrue(fieldDesc.hasDefaultValue);
XCTAssertFalse(message.hasFoo);
XCTAssertEqualObjects(message.foo, @"");
fieldDesc = [descriptor fieldWithName:@"bar"];
XCTAssertNotNil(fieldDesc);
XCTAssertTrue(fieldDesc.hasDefaultValue);
XCTAssertFalse(message.hasBar);
XCTAssertEqualObjects(message.bar, GPBEmptyNSData());
}
- (void)testEnumDescriptorFromExtensionDescriptor {
GPBExtensionDescriptor *extDescriptor =
[UnittestRoot optionalForeignEnumExtension];
XCTAssertEqual(extDescriptor.dataType, GPBDataTypeEnum);
GPBEnumDescriptor *enumDescriptor = extDescriptor.enumDescriptor;
GPBEnumDescriptor *expectedDescriptor = ForeignEnum_EnumDescriptor();
XCTAssertEqualObjects(enumDescriptor, expectedDescriptor);
}
- (void)testPropertyNaming {
// objectivec_helpers.cc has some special handing to get proper all caps
// for a few cases to meet objc developer expectations.
//
// This "test" confirms that the expected names are generated, otherwise the
// test itself will fail to compile.
ObjCPropertyNaming *msg = [ObjCPropertyNaming message];
// On their own, at the end, in the middle.
msg.URL = @"good";
msg.thumbnailURL = @"good";
msg.URLFoo = @"good";
msg.someURLBlah = @"good";
msg.HTTP = @"good";
msg.HTTPS = @"good";
// No caps since it was "urls".
[msg.urlsArray addObject:@"good"];
}
- (void)testEnumNaming {
// objectivec_helpers.cc has some interesting cases to deal with in
// EnumValueName/EnumValueShortName. Confirm that things generated as
// expected.
// This block just has to compile to confirm we got the expected types/names.
// The *_IsValidValue() calls are just there to keep the projects warnings
// flags happy by providing use of the variables/values.
Foo aFoo = Foo_SerializedSize;
Foo_IsValidValue(aFoo);
aFoo = Foo_Size;
Foo_IsValidValue(aFoo);
Category_Enum aCat = Category_Enum_Red;
Category_Enum_IsValidValue(aCat);
Time aTime = Time_Base;
Time_IsValidValue(aTime);
aTime = Time_SomethingElse;
Time_IsValidValue(aTime);
// This block confirms the names in the decriptors is what we wanted.
GPBEnumDescriptor *descriptor;
NSString *valueName;
descriptor = Foo_EnumDescriptor();
XCTAssertNotNil(descriptor);
XCTAssertEqualObjects(@"Foo", descriptor.name);
valueName = [descriptor enumNameForValue:Foo_SerializedSize];
XCTAssertEqualObjects(@"Foo_SerializedSize", valueName);
valueName = [descriptor enumNameForValue:Foo_Size];
XCTAssertEqualObjects(@"Foo_Size", valueName);
descriptor = Category_Enum_EnumDescriptor();
XCTAssertNotNil(descriptor);
XCTAssertEqualObjects(@"Category_Enum", descriptor.name);
valueName = [descriptor enumNameForValue:Category_Enum_Red];
XCTAssertEqualObjects(@"Category_Enum_Red", valueName);
descriptor = Time_EnumDescriptor();
XCTAssertNotNil(descriptor);
XCTAssertEqualObjects(@"Time", descriptor.name);
valueName = [descriptor enumNameForValue:Time_Base];
XCTAssertEqualObjects(@"Time_Base", valueName);
valueName = [descriptor enumNameForValue:Time_SomethingElse];
XCTAssertEqualObjects(@"Time_SomethingElse", valueName);
}
- (void)testNegativeEnums {
EnumTestMsg *msg = [EnumTestMsg message];
// Defaults
XCTAssertEqual(msg.foo, EnumTestMsg_MyEnum_Zero);
XCTAssertEqual(msg.bar, EnumTestMsg_MyEnum_One);
XCTAssertEqual(msg.baz, EnumTestMsg_MyEnum_NegOne);
// Bounce to wire and back.
NSData *data = [msg data];
XCTAssertNotNil(data);
EnumTestMsg *msgPrime = [EnumTestMsg parseFromData:data error:NULL];
XCTAssertEqualObjects(msgPrime, msg);
XCTAssertEqual(msgPrime.foo, EnumTestMsg_MyEnum_Zero);
XCTAssertEqual(msgPrime.bar, EnumTestMsg_MyEnum_One);
XCTAssertEqual(msgPrime.baz, EnumTestMsg_MyEnum_NegOne);
// Other values
msg.bar = EnumTestMsg_MyEnum_Two;
msg.baz = EnumTestMsg_MyEnum_NegTwo;
XCTAssertEqual(msg.bar, EnumTestMsg_MyEnum_Two);
XCTAssertEqual(msg.baz, EnumTestMsg_MyEnum_NegTwo);
// Bounce to wire and back.
data = [msg data];
XCTAssertNotNil(data);
msgPrime = [EnumTestMsg parseFromData:data error:NULL];
XCTAssertEqualObjects(msgPrime, msg);
XCTAssertEqual(msgPrime.foo, EnumTestMsg_MyEnum_Zero);
XCTAssertEqual(msgPrime.bar, EnumTestMsg_MyEnum_Two);
XCTAssertEqual(msgPrime.baz, EnumTestMsg_MyEnum_NegTwo);
// Repeated field (shouldn't ever be an issue since developer has to use the
// right GPBArray methods themselves).
msg.mumbleArray = [GPBEnumArray
arrayWithValidationFunction:EnumTestMsg_MyEnum_IsValidValue];
[msg.mumbleArray addValue:EnumTestMsg_MyEnum_Zero];
[msg.mumbleArray addValue:EnumTestMsg_MyEnum_One];
[msg.mumbleArray addValue:EnumTestMsg_MyEnum_Two];
[msg.mumbleArray addValue:EnumTestMsg_MyEnum_NegOne];
[msg.mumbleArray addValue:EnumTestMsg_MyEnum_NegTwo];
XCTAssertEqual([msg.mumbleArray valueAtIndex:0], EnumTestMsg_MyEnum_Zero);
XCTAssertEqual([msg.mumbleArray valueAtIndex:1], EnumTestMsg_MyEnum_One);
XCTAssertEqual([msg.mumbleArray valueAtIndex:2], EnumTestMsg_MyEnum_Two);
XCTAssertEqual([msg.mumbleArray valueAtIndex:3], EnumTestMsg_MyEnum_NegOne);
XCTAssertEqual([msg.mumbleArray valueAtIndex:4], EnumTestMsg_MyEnum_NegTwo);
// Bounce to wire and back.
data = [msg data];
XCTAssertNotNil(data);
msgPrime = [EnumTestMsg parseFromData:data error:NULL];
XCTAssertEqualObjects(msgPrime, msg);
XCTAssertEqual([msgPrime.mumbleArray valueAtIndex:0],
EnumTestMsg_MyEnum_Zero);
XCTAssertEqual([msgPrime.mumbleArray valueAtIndex:1], EnumTestMsg_MyEnum_One);
XCTAssertEqual([msgPrime.mumbleArray valueAtIndex:2], EnumTestMsg_MyEnum_Two);
XCTAssertEqual([msgPrime.mumbleArray valueAtIndex:3],
EnumTestMsg_MyEnum_NegOne);
XCTAssertEqual([msgPrime.mumbleArray valueAtIndex:4],
EnumTestMsg_MyEnum_NegTwo);
}
- (void)testOneBasedEnumHolder {
// Test case for https://github.com/google/protobuf/issues/1453
// Message with no explicit defaults, but a non zero default for an enum.
MessageWithOneBasedEnum *enumMsg = [MessageWithOneBasedEnum message];
XCTAssertEqual(enumMsg.enumField, MessageWithOneBasedEnum_OneBasedEnum_One);
}
- (void)testBoolOffsetUsage {
// Bools use storage within has_bits; this test ensures that this is honored
// in all places where things should crash or fail based on reading out of
// field storage instead.
BoolOnlyMessage *msg1 = [BoolOnlyMessage message];
BoolOnlyMessage *msg2 = [BoolOnlyMessage message];
msg1.boolField1 = YES;
msg2.boolField1 = YES;
msg1.boolField3 = YES;
msg2.boolField3 = YES;
msg1.boolField5 = YES;
msg2.boolField5 = YES;
msg1.boolField7 = YES;
msg2.boolField7 = YES;
msg1.boolField9 = YES;
msg2.boolField9 = YES;
msg1.boolField11 = YES;
msg2.boolField11 = YES;
msg1.boolField13 = YES;
msg2.boolField13 = YES;
msg1.boolField15 = YES;
msg2.boolField15 = YES;
msg1.boolField17 = YES;
msg2.boolField17 = YES;
msg1.boolField19 = YES;
msg2.boolField19 = YES;
msg1.boolField21 = YES;
msg2.boolField21 = YES;
msg1.boolField23 = YES;
msg2.boolField23 = YES;
msg1.boolField25 = YES;
msg2.boolField25 = YES;
msg1.boolField27 = YES;
msg2.boolField27 = YES;
msg1.boolField29 = YES;
msg2.boolField29 = YES;
msg1.boolField31 = YES;
msg2.boolField31 = YES;
msg1.boolField32 = YES;
msg2.boolField32 = YES;
XCTAssertTrue(msg1 != msg2); // Different pointers.
XCTAssertEqual([msg1 hash], [msg2 hash]);
XCTAssertEqualObjects(msg1, msg2);
BoolOnlyMessage *msg1Prime = [[msg1 copy] autorelease];
XCTAssertTrue(msg1Prime != msg1); // Different pointers.
XCTAssertEqual([msg1 hash], [msg1Prime hash]);
XCTAssertEqualObjects(msg1, msg1Prime);
// Field set in one, but not the other means they don't match (even if
// set to default value).
msg1Prime.boolField2 = NO;
XCTAssertNotEqualObjects(msg1Prime, msg1);
// And when set to different values.
msg1.boolField2 = YES;
XCTAssertNotEqualObjects(msg1Prime, msg1);
// And then they match again.
msg1.boolField2 = NO;
XCTAssertEqualObjects(msg1Prime, msg1);
XCTAssertEqual([msg1 hash], [msg1Prime hash]);
}
@end