Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(411)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: third_party/protobuf/objectivec/Tests/GPBMessageTests.m

Issue 1322483002: Revert https://codereview.chromium.org/1291903002 (protobuf roll). (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « third_party/protobuf/objectivec/Tests/GPBDictionaryTests+UInt64.m ('k') | third_party/protobuf/objectivec/Tests/GPBMessageTests+Merge.m » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/protobuf/objectivec/Tests/GPBMessageTests.m
diff --git a/third_party/protobuf/objectivec/Tests/GPBMessageTests.m b/third_party/protobuf/objectivec/Tests/GPBMessageTests.m
deleted file mode 100644
index cd0de8fcb735069c635d7bd14359f174cd02a4cc..0000000000000000000000000000000000000000
--- a/third_party/protobuf/objectivec/Tests/GPBMessageTests.m
+++ /dev/null
@@ -1,1932 +0,0 @@
-// 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 = [NSMutableArray array];
- [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 = [NSMutableArray array];
- [message.repeatedStringArray addObject:@"qux"];
- return message;
-}
-
-- (TestAllTypes *)mergeDestinationWithoutForeignMessageIvar {
- TestAllTypes *message = [TestAllTypes message];
- [message setOptionalInt64:2];
- [message setOptionalString:@"baz"];
- message.repeatedStringArray = [NSMutableArray array];
- [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 = [NSMutableArray array];
- [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 = [NSMutableArray array];
- [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];
- [result mergeFromData:[[self mergeExtensionsSource] 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 = [NSMutableArray array];
- [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 = [NSMutableArray array];
- [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 = [NSMutableArray array];
- [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)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 setValue: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 setValue: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 dictionaryWithValue: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)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 dictionaryWithValue: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)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.
- EnumTestMsg *msgPrime = [EnumTestMsg parseFromData:[msg 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.
- msgPrime = [EnumTestMsg parseFromData:[msg 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.
- msgPrime = [EnumTestMsg parseFromData:[msg 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);
-}
-
-@end
« no previous file with comments | « third_party/protobuf/objectivec/Tests/GPBDictionaryTests+UInt64.m ('k') | third_party/protobuf/objectivec/Tests/GPBMessageTests+Merge.m » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698