blob: d598a48b6076721d10274eb222cdaddbebb4680a [file] [log] [blame]
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
#import "GPBTestUtilities.h"
#import <objc/runtime.h>
#import "GPBArray_PackagePrivate.h"
#import "GPBDescriptor.h"
#import "GPBDictionary_PackagePrivate.h"
#import "GPBMessage_PackagePrivate.h"
#import "GPBUnknownFieldSet_PackagePrivate.h"
#import "GPBUnknownField_PackagePrivate.h"
#import "objectivec/Tests/Unittest.pbobjc.h"
#import "objectivec/Tests/UnittestImport.pbobjc.h"
#import "objectivec/Tests/UnittestObjc.pbobjc.h"
#import "objectivec/Tests/UnittestObjcOptions.pbobjc.h"
// Helper class to test KVO.
@interface GPBKVOTestObserver : NSObject {
id observee_;
NSString *keyPath_;
}
@property(nonatomic) BOOL didObserve;
- (id)initWithObservee:(id)observee keyPath:(NSString *)keyPath;
@end
@implementation GPBKVOTestObserver
@synthesize didObserve;
- (id)initWithObservee:(id)observee keyPath:(NSString *)keyPath {
if (self = [super init]) {
observee_ = [observee retain];
keyPath_ = [keyPath copy];
[observee_ addObserver:self forKeyPath:keyPath_ options:0 context:NULL];
}
return self;
}
- (void)dealloc {
[observee_ removeObserver:self forKeyPath:keyPath_];
[observee_ release];
[keyPath_ release];
[super dealloc];
}
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(__unused id)object
change:(__unused NSDictionary *)change
context:(__unused void *)context {
if ([keyPath isEqualToString:keyPath_]) {
self.didObserve = YES;
}
}
@end
@interface MessageTests : GPBTestCase
@end
@implementation MessageTests
// TODO: 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);
NSError *error = nil;
XCTAssertTrue([result mergeFromData:data
extensionRegistry:[UnittestRoot extensionRegistry]
error:&error]);
XCTAssertNil(error);
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
}
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
- (void)testCoding {
GPBMessage *original = [self mergeResult];
NSData *data = [NSKeyedArchiver archivedDataWithRootObject:original];
id unarchivedObject = [NSKeyedUnarchiver unarchiveObjectWithData:data];
XCTAssertEqualObjects(unarchivedObject, original);
// Intentionally doing a pointer comparison.
XCTAssertNotEqual(unarchivedObject, original);
}
- (void)testSecureCoding {
GPBMessage *original = [self mergeResult];
NSString *key = @"testing123";
NSMutableData *data = [NSMutableData data];
NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc] initForWritingWithMutableData:data];
[archiver setRequiresSecureCoding:YES];
[archiver encodeObject:original forKey:key];
[archiver finishEncoding];
NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:data];
[unarchiver setRequiresSecureCoding:YES];
id unarchivedObject = [unarchiver decodeObjectOfClass:[GPBMessage class] forKey:key];
[unarchiver finishDecoding];
XCTAssertEqualObjects(unarchivedObject, original);
// Intentionally doing a pointer comparison.
XCTAssertNotEqual(unarchivedObject, original);
}
#pragma clang diagnostic pop
- (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)testKVOBasic {
TestAllTypes *message = [TestAllTypes message];
GPBKVOTestObserver *observer =
[[[GPBKVOTestObserver alloc] initWithObservee:message keyPath:@"optionalString"] autorelease];
XCTAssertFalse(observer.didObserve);
message.defaultString = @"Hello";
XCTAssertFalse(observer.didObserve);
message.optionalString = @"Hello";
XCTAssertTrue(observer.didObserve);
}
- (void)testKVOAutocreate {
TestAllTypes *message = [TestAllTypes message];
GPBKVOTestObserver *autocreateObserver =
[[[GPBKVOTestObserver alloc] initWithObservee:message
keyPath:@"optionalImportMessage"] autorelease];
GPBKVOTestObserver *innerFieldObserver =
[[[GPBKVOTestObserver alloc] initWithObservee:message
keyPath:@"optionalImportMessage.d"] autorelease];
XCTAssertFalse(autocreateObserver.didObserve);
XCTAssertFalse(innerFieldObserver.didObserve);
int a = message.optionalImportMessage.d;
XCTAssertEqual(a, 0);
// Autocreation of fields is not observed by KVO when getting values.
XCTAssertFalse(autocreateObserver.didObserve);
XCTAssertFalse(innerFieldObserver.didObserve);
message.optionalImportMessage.d = 2;
// Autocreation of fields is not observed by KVO.
// This is undefined behavior. The library makes no guarantees with regards
// to KVO firing if an autocreation occurs as part of a setter.
// This test exists just to be aware if the behavior changes.
XCTAssertFalse(autocreateObserver.didObserve);
// Values set inside of an autocreated field are observed.
XCTAssertTrue(innerFieldObserver.didObserve);
// Explicit setting of a message field is observed.
message.optionalImportMessage = [ImportMessage message];
XCTAssertTrue(autocreateObserver.didObserve);
}
- (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 comparison
message.a.iArray = [GPBInt32Array arrayWithValue:1];
XCTAssertTrue([message hasA]);
XCTAssertNotEqual(message.a.iArray, iArray); // Pointer comparison
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 comparison
message.a.strArray = [NSMutableArray arrayWithObject:@"foo"];
XCTAssertTrue([message hasA]);
XCTAssertNotEqual(message.a.strArray, strArray); // Pointer comparison
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 alloc] init] autorelease];
[message3.iToI setInt32: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 comparison
message.a.iToI = [[[GPBInt32Int32Dictionary alloc] init] autorelease];
[message.a.iToI setInt32:6 forKey:7];
XCTAssertTrue([message hasA]);
XCTAssertNotEqual(message.a.iToI, iToI); // Pointer comparison
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 comparison
message.a.strToStr = [NSMutableDictionary dictionaryWithObject:@"abc" forKey:@"def"];
XCTAssertTrue([message hasA]);
XCTAssertNotEqual(message.a.strToStr, strToStr); // Pointer comparison
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)testClosedEnumsInExtensions {
// Only unknown values.
NSData *data =
DataFromCStr("\xA8\x01\x0A" // optional_nested_enum_extension set to 10
"\x98\x03\x0B" // repeated_nested_enum_extension set to 11
"\xA2\x03\x01\x0C" // repeated_foreign_enum_extension set to 12 (packed)
);
NSError *error = nil;
TestAllExtensions *msg = [TestAllExtensions parseFromData:data
extensionRegistry:[self extensionRegistry]
error:&error];
XCTAssertNil(error);
XCTAssertFalse([msg hasExtension:[UnittestRoot optionalNestedEnumExtension]]);
XCTAssertFalse([msg hasExtension:[UnittestRoot repeatedNestedEnumExtension]]);
XCTAssertFalse([msg hasExtension:[UnittestRoot repeatedForeignEnumExtension]]);
GPBUnknownFieldSet *unknownFields = msg.unknownFields;
GPBUnknownField *field =
[unknownFields getField:[UnittestRoot optionalNestedEnumExtension].fieldNumber];
XCTAssertNotNil(field);
XCTAssertEqual(field.varintList.count, 1);
XCTAssertEqual([field.varintList valueAtIndex:0], 10);
field = [unknownFields getField:[UnittestRoot repeatedNestedEnumExtension].fieldNumber];
XCTAssertNotNil(field);
XCTAssertEqual(field.varintList.count, 1);
XCTAssertEqual([field.varintList valueAtIndex:0], 11);
field = [unknownFields getField:[UnittestRoot repeatedForeignEnumExtension].fieldNumber];
XCTAssertNotNil(field);
XCTAssertEqual(field.varintList.count, 1);
XCTAssertEqual([field.varintList valueAtIndex:0], 12);
// Unknown and known, the known come though an unknown go to unknown fields.
data = DataFromCStr(
"\xA8\x01\x01" // optional_nested_enum_extension set to 1
"\xA8\x01\x0A" // optional_nested_enum_extension set to 10
"\xA8\x01\x02" // optional_nested_enum_extension set to 2
"\x98\x03\x02" // repeated_nested_enum_extension set to 2
"\x98\x03\x0B" // repeated_nested_enum_extension set to 11
"\x98\x03\x03" // repeated_nested_enum_extension set to 3
"\xA2\x03\x03\x04\x0C\x06" // repeated_foreign_enum_extension set to 4, 12, 6 (packed)
);
error = nil;
msg = [TestAllExtensions parseFromData:data
extensionRegistry:[self extensionRegistry]
error:&error];
XCTAssertNil(error);
XCTAssertTrue([msg hasExtension:[UnittestRoot optionalNestedEnumExtension]]);
XCTAssertEqualObjects([msg getExtension:[UnittestRoot optionalNestedEnumExtension]], @2);
XCTAssertTrue([msg hasExtension:[UnittestRoot repeatedNestedEnumExtension]]);
id expected = @[ @2, @3 ];
XCTAssertEqualObjects([msg getExtension:[UnittestRoot repeatedNestedEnumExtension]], expected);
XCTAssertTrue([msg hasExtension:[UnittestRoot repeatedForeignEnumExtension]]);
expected = @[ @4, @6 ];
XCTAssertEqualObjects([msg getExtension:[UnittestRoot repeatedForeignEnumExtension]], expected);
unknownFields = msg.unknownFields;
field = [unknownFields getField:[UnittestRoot optionalNestedEnumExtension].fieldNumber];
XCTAssertNotNil(field);
XCTAssertEqual(field.varintList.count, 1);
XCTAssertEqual([field.varintList valueAtIndex:0], 10);
field = [unknownFields getField:[UnittestRoot repeatedNestedEnumExtension].fieldNumber];
XCTAssertNotNil(field);
XCTAssertEqual(field.varintList.count, 1);
XCTAssertEqual([field.varintList valueAtIndex:0], 11);
field = [unknownFields getField:[UnittestRoot repeatedForeignEnumExtension].fieldNumber];
XCTAssertNotNil(field);
XCTAssertEqual(field.varintList.count, 1);
XCTAssertEqual([field.varintList valueAtIndex:0], 12);
}
- (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 {
// names.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 {
// names.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 descriptors 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)testReservedWordNaming {
// names.cc has some special handing to make sure that some "reserved" objc
// names get renamed in a way so they don't conflict.
//
// This "test" confirms that the expected names are generated,
// otherwise the test itself will fail to compile.
self_Class *msg = [self_Class message];
// Some ObjC/C/C++ keywords.
msg.className_p = msg.hasClassName_p;
msg.cmd = msg.hasCmd;
msg.nullable_p = msg.hasNullable_p;
msg.typeof_p = msg.hasTypeof_p;
msg.instancetype_p = msg.hasInstancetype_p;
msg.nil_p = msg.hasNil_p;
msg.instancetype_p = msg.hasInstancetype_p;
msg.public_p = msg.hasPublic_p;
// Some that would override NSObject methods
msg.camltype = msg.hasCamltype;
msg.isNsdictionary = msg.hasIsNsdictionary;
msg.dealloc_p = msg.hasDealloc_p;
msg.zone_p = msg.hasZone_p;
msg.accessibilityLabel_p = msg.hasAccessibilityLabel_p;
// Some that we shouldn't need to handle.
msg.atomic = msg.hasAtomic;
msg.nonatomic = msg.hasNonatomic;
msg.strong = msg.hasStrong;
msg.nullResettable = msg.hasNullResettable;
// Some that would override GPBMessage methods
msg.clear_p = msg.hasClear_p;
msg.data_p = msg.hasData_p;
// Some MacTypes
msg.fixed = msg.hasFixed;
msg.style = msg.hasStyle;
// Some C Identifiers
msg.generic = msg.hasGeneric;
msg.block = msg.hasBlock;
}
- (void)testOneBasedEnumHolder {
// Test case for https://github.com/protocolbuffers/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]);
}
- (void)testCopyingMapFields {
TestMessageOfMaps *msg = [TestMessageOfMaps message];
msg.strToStr[@"foo"] = @"bar";
[msg.strToInt setInt32:1 forKey:@"mumble"];
[msg.intToStr setObject:@"wee" forKey:42];
[msg.intToInt setInt32:123 forKey:321];
[msg.strToBool setBool:YES forKey:@"one"];
[msg.boolToStr setObject:@"something" forKey:YES];
[msg.boolToBool setBool:YES forKey:NO];
[msg.intToBool setBool:YES forKey:13];
[msg.boolToInt setInt32:111 forKey:NO];
TestAllTypes *subMsg1 = [TestAllTypes message];
subMsg1.optionalInt32 = 1;
TestAllTypes *subMsg2 = [TestAllTypes message];
subMsg1.optionalInt32 = 2;
TestAllTypes *subMsg3 = [TestAllTypes message];
subMsg1.optionalInt32 = 3;
msg.strToMsg[@"baz"] = subMsg1;
[msg.intToMsg setObject:subMsg2 forKey:222];
[msg.boolToMsg setObject:subMsg3 forKey:YES];
TestMessageOfMaps *msg2 = [[msg copy] autorelease];
XCTAssertNotNil(msg2);
XCTAssertEqualObjects(msg2, msg);
XCTAssertTrue(msg2 != msg); // ptr compare
XCTAssertTrue(msg.strToStr != msg2.strToStr); // ptr compare
XCTAssertTrue(msg.intToStr != msg2.intToStr); // ptr compare
XCTAssertTrue(msg.intToInt != msg2.intToInt); // ptr compare
XCTAssertTrue(msg.strToBool != msg2.strToBool); // ptr compare
XCTAssertTrue(msg.boolToStr != msg2.boolToStr); // ptr compare
XCTAssertTrue(msg.boolToBool != msg2.boolToBool); // ptr compare
XCTAssertTrue(msg.intToBool != msg2.intToBool); // ptr compare
XCTAssertTrue(msg.boolToInt != msg2.boolToInt); // ptr compare
XCTAssertTrue(msg.strToMsg != msg2.strToMsg); // ptr compare
XCTAssertTrue(msg.intToMsg != msg2.intToMsg); // ptr compare
XCTAssertTrue(msg.boolToMsg != msg2.boolToMsg); // ptr compare
XCTAssertTrue(msg.strToMsg[@"baz"] != msg2.strToMsg[@"baz"]); // ptr compare
XCTAssertEqualObjects(msg.strToMsg[@"baz"], msg2.strToMsg[@"baz"]);
XCTAssertTrue([msg.intToMsg objectForKey:222] !=
[msg2.intToMsg objectForKey:222]); // ptr compare
XCTAssertEqualObjects([msg.intToMsg objectForKey:222], [msg2.intToMsg objectForKey:222]);
XCTAssertTrue([msg.boolToMsg objectForKey:YES] !=
[msg2.boolToMsg objectForKey:YES]); // ptr compare
XCTAssertEqualObjects([msg.boolToMsg objectForKey:YES], [msg2.boolToMsg objectForKey:YES]);
}
- (void)testPrefixedNames {
// The fact that this compiles is sufficient as a test.
// The assertions are just there to avoid "not-used" warnings.
// Verify that enum types and values get the prefix.
GPBTESTTestObjcProtoPrefixEnum value = GPBTESTTestObjcProtoPrefixEnum_Value;
XCTAssertNotEqual(value, 0);
// Verify that roots get the prefix.
GPBTESTUnittestObjcOptionsRoot *root = nil;
XCTAssertNil(root);
// Verify that messages that don't already have the prefix get a prefix.
GPBTESTTestObjcProtoPrefixMessage *prefixedMessage = nil;
XCTAssertNil(prefixedMessage);
// Verify that messages that already have a prefix aren't prefixed twice.
GPBTESTTestHasAPrefixMessage *alreadyPrefixedMessage = nil;
XCTAssertNil(alreadyPrefixedMessage);
// Verify that enums that already have a prefix aren't prefixed twice.
GPBTESTTestHasAPrefixEnum prefixedValue = GPBTESTTestHasAPrefixEnum_ValueB;
XCTAssertNotEqual(prefixedValue, 0);
// Verify that classes named the same as prefixes are prefixed.
GPBTESTGPBTEST *prefixMessage = nil;
XCTAssertNil(prefixMessage);
// Verify that classes that have the prefix followed by a lowercase
// letter DO get the prefix.
GPBTESTGPBTESTshouldGetAPrefixMessage *shouldGetAPrefixMessage = nil;
XCTAssertNil(shouldGetAPrefixMessage);
}
- (void)testWriteToFullOutputStreamShouldThrow {
uint8_t buffer[1] = {0};
// Output stream which can write precisely 1 byte of data before it's full.
NSOutputStream *output = [[[NSOutputStream alloc] initToBuffer:buffer
capacity:sizeof(buffer)] autorelease];
TestAllTypes *message = [TestAllTypes message];
[message setOptionalInt32:1];
XCTAssertThrowsSpecificNamed([message writeToOutputStream:output], NSException,
GPBCodedOutputStreamException_WriteFailed);
}
@end