Service/Tests/FunctionalTests/EDOServiceUIMemoryTest.m - external/github.com/google/eDistantObject - Git at Google

 //
 // Copyright 2018 Google LLC.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //

 #import "Service/Tests/FunctionalTests/EDOServiceUIBaseTest.h"

 #import "Service/Sources/EDOClientService.h"
 #import "Service/Sources/EDOHostService.h"
 #import "Service/Sources/EDORemoteException.h"
 #import "Service/Sources/EDOServiceException.h"
 #import "Service/Sources/NSObject+EDOValueObject.h"
 #import "Service/Sources/NSObject+EDOWeakObject.h"
 #import "Service/Tests/FunctionalTests/EDOTestDummyInTest.h"
 #import "Service/Tests/TestsBundle/EDOTestClassDummy.h"
 #import "Service/Tests/TestsBundle/EDOTestDummy.h"

 // Memory tests to assure the local and remote objects don't leak.
 @interface EDOUIMemoryTest : EDOServiceUIBaseTest
 // The launched application for the running test.
 @property(nonatomic) XCUIApplication *application;
 @end

 @implementation EDOUIMemoryTest

 - (void)setUp {
   [super setUp];

   self.application = [self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:6];
 }

 - (void)testStubClassAllocReturnsEDOObject {
   // Stub class forwarding alloc will alloc an instance of EDOObject.
   XCTAssertEqualObjects([[EDOTestClassDummy alloc] class], NSClassFromString(@"EDOObject"));
   XCTAssertEqualObjects([[EDOTestClassDummy allocWithZone:nil] class],
                         NSClassFromString(@"EDOObject"));
 }

 - (void)testStubClassAllocEqualsInit {
   EDOTestClassDummy *testDummy;
   @autoreleasepool {
     // The autoreleasepool to assure the inserted releases within the scope and all the temporary
     // objects if any will be reclaimed.
     // +alloc should return the same instance as from -init.
     testDummy = [EDOTestClassDummy alloc];
     XCTAssertEqual(testDummy, [testDummy initWithValue:10]);
   }
   // Ensure the appropriate value is retrieved from the object.
   XCTAssertEqual(testDummy.value, 10);
 }

 - (void)testAllocFamilyRetainsReturn {
   EDOTestClassDummy *testDummy1, *testDummy2, *testDummy3;
   @autoreleasepool {
     // allocDummy will trigger ARC to insert an extra release.
     // The autoreleasepool to assure the inserted releases within the scope and all the temporary
     // objects if any will be reclaimed.
     testDummy1 = [[EDOTestClassDummy allocDummy] initWithValue:10];
     testDummy2 = [[EDOTestClassDummy _allocDummy] initWithValue:20];
     testDummy3 = [[EDOTestClassDummy allocateDummy] initWithValue:30];
   }
   // Ensure the appropriate value is retrieved from the object.
   XCTAssertEqual(testDummy1.value, 10);
   XCTAssertEqual(testDummy2.value, 20);
   XCTAssertEqual(testDummy3.value, 30);
 }

 - (void)testAllocRemoteValueType {
   XCTAssertThrowsSpecificNamed([[EDO_REMOTE_CLASS(NSData, EDOTEST_APP_SERVICE_PORT) alloc] init],
                                EDORemoteException, EDOServiceAllocValueTypeException);
   XCTAssertThrowsSpecificNamed(
       [[EDO_REMOTE_CLASS(EDOTestDummy, EDOTEST_APP_SERVICE_PORT) returnByValue] alloc],
       EDORemoteException, EDOServiceAllocValueTypeException);
   XCTAssertNoThrow([EDO_REMOTE_CLASS(NSData, EDOTEST_APP_SERVICE_PORT) data]);
 }

 // Test that the remote objects are resolved to be local objects if they are coming back to their
 // origin.
 - (void)testEDOResolveToLocalAddress {
   // Use NSClassFromString to fetch EDOObject to make it private here.
   Class edoClass = NSClassFromString(@"EDOObject");

   XCTAssertNil(NSClassFromString(@"EDOTestDummy"));
   EDOTestDummyInTest *rootObject = [[EDOTestDummyInTest alloc] initWithValue:5];
   EDOHostService *service = [EDOHostService serviceWithPort:2234
                                                  rootObject:rootObject
                                                       queue:dispatch_get_main_queue()];

   EDOTestDummyInTest *dummyInTest = [[EDOTestDummyInTest alloc] initWithValue:5];
   EDOTestDummyInTest *dummyAssigned = [[EDOTestDummyInTest alloc] initWithValue:6];

   EDOTestDummy *remoteDummy = [EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT];
   XCTAssertEqualObjects([remoteDummy class], edoClass);

   EDOTestDummy *returnDummy = [remoteDummy returnIdWithInt:5];
   XCTAssertEqualObjects([returnDummy class], edoClass);
   // returnDummy.value = 5 + initValue(6);
   XCTAssertEqual(returnDummy.value, 11);

   Class testDummyClass = EDO_REMOTE_CLASS(EDOTestDummy, EDOTEST_APP_SERVICE_PORT);
   XCTAssertEqualObjects([testDummyClass class], edoClass);
   XCTAssertEqualObjects([remoteDummy class], edoClass);

   [remoteDummy setDummInTest:dummyInTest withDummy:dummyAssigned];

   XCTAssertEqual(dummyInTest.dummyInTest, dummyAssigned);
   XCTAssertEqual([remoteDummy getRootObject:2234], rootObject);

   EDOTestDummyInTest *returnedDummy = [remoteDummy createEDOWithPort:2234];
   XCTAssertEqualObjects([returnedDummy class], [EDOTestDummyInTest class]);
   // returnedDummy.value = -> createEDOWithPort:
   //     makeAnotherDummy:
   //        -> 7 + rooObject.value(5)
   //     -> 12 + 5
   XCTAssertEqual(returnedDummy.value.intValue, 17);

   [service invalidate];
 }

 // Test that the underlying object gets released if there is no remote reference.
 - (void)testUnderlyingObjectReleasedIfNotHeldRemotely {
   [self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:6];
   EDOTestDummy *remoteDummy = self.remoteRootObject;
   @autoreleasepool {
     // Allocate a weak variable inside the autoreleasepool.
     EDOTestDummy *dummyInTest = [remoteDummy weaklyHeldDummyForMemoryTest];
     // Assert that the remoteDummy holds a reference to the weak variable.
     XCTAssertNotNil(remoteDummy.weakDummyInTest);
     XCTAssertNotNil(dummyInTest);
   }
   // The strong variable that held a strong reference is gone. Since the remoteDummy holds a weak
   // reference to itself, then it should be nil.
   XCTAssertNil(remoteDummy.weakDummyInTest);
 }

 // Test that the same underlying objects should live if there is at least one remote reference.
 - (void)testUnderlyingObjectStayAliveIfHeldRemotely {
   EDOTestDummy *remoteDummy = self.remoteRootObject;
   NS_VALID_UNTIL_END_OF_SCOPE EDOTestDummy *strongReference;
   @autoreleasepool {
     // Hold the remote object strongly.
     strongReference = [remoteDummy weaklyHeldDummyForMemoryTest];
     XCTAssertNotNil(strongReference);
   }
   // Remote strong reference should keep the underlying object still alive.
   XCTAssertNotNil(remoteDummy.weakDummyInTest);
 }

 // Test that the multiple holdings of the same underlying objects can get released remotely.
 - (void)testUnderlyingObjectReleasedIfHeldWeakly {
   EDOTestDummy *remoteDummy = self.remoteRootObject;
   __weak EDOTestDummy *weakReference;
   @autoreleasepool {
     // Get a weak variable.
     NS_VALID_UNTIL_END_OF_SCOPE EDOTestDummy *dummy = [remoteDummy weaklyHeldDummyForMemoryTest];
     weakReference = dummy;
     XCTAssertNotNil(weakReference);
   }
   // Both variables are weak. When one of them is released both of them get released.
   XCTAssertNil(weakReference);
   XCTAssertNil(remoteDummy.weakDummyInTest);
 }

 // Test that the root object is strongly held even if the remote references are gone.
 - (void)testUnderlyingObjectStayAliveRegardlessOfRemoteReference {
   __weak EDOTestDummy *remoteWeakDummy;
   @autoreleasepool {
     // Initialize a weak reference to the rootObject.
     NS_VALID_UNTIL_END_OF_SCOPE EDOTestDummy *dummy = self.remoteRootObject;
     remoteWeakDummy = dummy;
     XCTAssertNotNil(remoteWeakDummy);
   }
   // The remote weak reference is gone but the underlying object should stay alive.
   XCTAssertNil(remoteWeakDummy);
   XCTAssertNotNil([EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT]);
 }

 // Test that the app wouldn't crash if the remote session is terminated.
 - (void)testSafeRecoverIfServiceTerminated {
   EDOTestDummy *remoteDummy = self.remoteRootObject;
   __weak EDOTestDummy *weakReference;
   @autoreleasepool {
     NS_VALID_UNTIL_END_OF_SCOPE EDOTestDummy *dummy = [remoteDummy weaklyHeldDummyForMemoryTest];
     weakReference = dummy;
     [self.application terminate];
   }
   // The test shouldn't crash if the app is gone.
   XCTAssertNil(weakReference);
 }

 /** Tests the remoteWeak function retains the weakly referenced object during its use. */
 - (void)testWeakObjectReferenceRetain {
   [self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:13];
   EDOHostService *service =
       [EDOHostService serviceWithPort:2234
                            rootObject:[[EDOTestDummyInTest alloc] initWithValue:9]
                                 queue:dispatch_get_main_queue()];
   EDOTestDummy *remoteDummy = [EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT];
   id local = [[NSObject alloc] init];

   // Originally, without remoteWeak, weakDelegate would return nil.
   remoteDummy.weakDelegate = local;
   XCTAssertNil(remoteDummy.weakDelegate);

   // RemoteWeak will retain the local.
   remoteDummy.weakDelegate = [local remoteWeak];
   XCTAssertNotNil(remoteDummy.weakDelegate);
   [service invalidate];
 }

 /** Tests the remoteWeak function retains the weakly referenced object during its use and releases
  * once the underlying object is released. */
 - (void)testWeakObjectReferenceRetainAndRelease {
   [self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:13];
   EDOHostService *service =
       [EDOHostService serviceWithPort:2234
                            rootObject:[[EDOTestDummyInTest alloc] initWithValue:9]
                                 queue:dispatch_get_main_queue()];
   EDOTestDummy *remoteDummy;
   @autoreleasepool {
     id local = [[NSObject alloc] init];
     remoteDummy = [EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT];
     // Original usage:
     // remoteDummy.weakDelegate = local;
     remoteDummy.weakDelegate = [local remoteWeak];
     XCTAssertNotNil(remoteDummy.weakDelegate);
   }
   XCTAssertNil(remoteDummy.weakDelegate);
   [service invalidate];
 }

 /** Tests the remoteWeak returns the same value when using on a local object.  */
 - (void)testRemoteWeakToLocalObject {
   EDOTestDummyInTest *dummy = [[EDOTestDummyInTest alloc] init];
   XCTAssertEqual([[dummy remoteWeak] value], [dummy value]);
 }

 /** Tests assigning remoteWeak to EDOObject throws the right exception. */
 - (void)testRemoteWeakToEDOObjectWithLocalReference {
   [self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:13];
   EDOHostService *service =
       [EDOHostService serviceWithPort:2234
                            rootObject:[[EDOTestDummyInTest alloc] initWithValue:9]
                                 queue:dispatch_get_main_queue()];
   EDOTestDummy *remoteDummy = [EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT];
   XCTAssertThrowsSpecificNamed([remoteDummy remoteWeak], NSException,
                                EDOWeakObjectRemoteWeakMisuseException);
   [service invalidate];
 }

 /** Tests assigning the same underlying object to multiple localReferences doesn't crash the
  * process. */
 - (void)testRemoteWeakToMultipleEDOObjectWithLocalReferences {
   [self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:13];
   EDOHostService *service =
       [EDOHostService serviceWithPort:2234
                            rootObject:[[EDOTestDummyInTest alloc] initWithValue:9]
                                 queue:dispatch_get_main_queue()];
   EDOTestDummy *remoteDummy;
   EDOTestDummy *remoteDummy2;
   @autoreleasepool {
     id local = [[NSObject alloc] init];
     remoteDummy = [EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT];
     remoteDummy2 = [remoteDummy returnDeepCopy];
     remoteDummy.weakDelegate = [local remoteWeak];
     XCTAssertNotNil(remoteDummy.weakDelegate);
     remoteDummy2.weakDelegate = [local remoteWeak];
     XCTAssertNotNil(remoteDummy.weakDelegate);
     XCTAssertNotNil(remoteDummy2.weakDelegate);
   }
   XCTAssertNil(remoteDummy.weakDelegate);
   XCTAssertNil(remoteDummy2.weakDelegate);
   [service invalidate];
 }

 /** Tests assigning the same underlying object to multiple localReferences doesn't crash the
  * process. */
 - (void)testRemoteWeakToEDOObjectWithMultipleLocalReferences {
   [self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:13];
   EDOHostService *service =
       [EDOHostService serviceWithPort:2234
                            rootObject:[[EDOTestDummyInTest alloc] initWithValue:9]
                                 queue:dispatch_get_main_queue()];
   EDOTestDummy *remoteDummy;
   @autoreleasepool {
     id local1 = [[NSObject alloc] init];
     id local2 = [[NSObject alloc] init];
     remoteDummy = [EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT];
     remoteDummy.weakDelegate = [local1 remoteWeak];
     remoteDummy.weakDelegate = [local2 remoteWeak];
     XCTAssertNotNil(remoteDummy.weakDelegate);
   }
   XCTAssertNil(remoteDummy.weakDelegate);
   [service invalidate];
 }

 @end
	//
	// Copyright 2018 Google LLC.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	//

	#import "Service/Tests/FunctionalTests/EDOServiceUIBaseTest.h"

	#import "Service/Sources/EDOClientService.h"
	#import "Service/Sources/EDOHostService.h"
	#import "Service/Sources/EDORemoteException.h"
	#import "Service/Sources/EDOServiceException.h"
	#import "Service/Sources/NSObject+EDOValueObject.h"
	#import "Service/Sources/NSObject+EDOWeakObject.h"
	#import "Service/Tests/FunctionalTests/EDOTestDummyInTest.h"
	#import "Service/Tests/TestsBundle/EDOTestClassDummy.h"
	#import "Service/Tests/TestsBundle/EDOTestDummy.h"

	// Memory tests to assure the local and remote objects don't leak.
	@interface EDOUIMemoryTest : EDOServiceUIBaseTest
	// The launched application for the running test.
	@property(nonatomic) XCUIApplication *application;
	@end

	@implementation EDOUIMemoryTest

	- (void)setUp {
	[super setUp];

	self.application = [self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:6];
	}

	- (void)testStubClassAllocReturnsEDOObject {
	// Stub class forwarding alloc will alloc an instance of EDOObject.
	XCTAssertEqualObjects([[EDOTestClassDummy alloc] class], NSClassFromString(@"EDOObject"));
	XCTAssertEqualObjects([[EDOTestClassDummy allocWithZone:nil] class],
	NSClassFromString(@"EDOObject"));
	}

	- (void)testStubClassAllocEqualsInit {
	EDOTestClassDummy *testDummy;
	@autoreleasepool {
	// The autoreleasepool to assure the inserted releases within the scope and all the temporary
	// objects if any will be reclaimed.
	// +alloc should return the same instance as from -init.
	testDummy = [EDOTestClassDummy alloc];
	XCTAssertEqual(testDummy, [testDummy initWithValue:10]);
	}
	// Ensure the appropriate value is retrieved from the object.
	XCTAssertEqual(testDummy.value, 10);
	}

	- (void)testAllocFamilyRetainsReturn {
	EDOTestClassDummy testDummy1, testDummy2, *testDummy3;
	@autoreleasepool {
	// allocDummy will trigger ARC to insert an extra release.
	// The autoreleasepool to assure the inserted releases within the scope and all the temporary
	// objects if any will be reclaimed.
	testDummy1 = [[EDOTestClassDummy allocDummy] initWithValue:10];
	testDummy2 = [[EDOTestClassDummy _allocDummy] initWithValue:20];
	testDummy3 = [[EDOTestClassDummy allocateDummy] initWithValue:30];
	}
	// Ensure the appropriate value is retrieved from the object.
	XCTAssertEqual(testDummy1.value, 10);
	XCTAssertEqual(testDummy2.value, 20);
	XCTAssertEqual(testDummy3.value, 30);
	}

	- (void)testAllocRemoteValueType {
	XCTAssertThrowsSpecificNamed([[EDO_REMOTE_CLASS(NSData, EDOTEST_APP_SERVICE_PORT) alloc] init],
	EDORemoteException, EDOServiceAllocValueTypeException);
	XCTAssertThrowsSpecificNamed(
	[[EDO_REMOTE_CLASS(EDOTestDummy, EDOTEST_APP_SERVICE_PORT) returnByValue] alloc],
	EDORemoteException, EDOServiceAllocValueTypeException);
	XCTAssertNoThrow([EDO_REMOTE_CLASS(NSData, EDOTEST_APP_SERVICE_PORT) data]);
	}

	// Test that the remote objects are resolved to be local objects if they are coming back to their
	// origin.
	- (void)testEDOResolveToLocalAddress {
	// Use NSClassFromString to fetch EDOObject to make it private here.
	Class edoClass = NSClassFromString(@"EDOObject");

	XCTAssertNil(NSClassFromString(@"EDOTestDummy"));
	EDOTestDummyInTest *rootObject = [[EDOTestDummyInTest alloc] initWithValue:5];
	EDOHostService *service = [EDOHostService serviceWithPort:2234
	rootObject:rootObject
	queue:dispatch_get_main_queue()];

	EDOTestDummyInTest *dummyInTest = [[EDOTestDummyInTest alloc] initWithValue:5];
	EDOTestDummyInTest *dummyAssigned = [[EDOTestDummyInTest alloc] initWithValue:6];

	EDOTestDummy *remoteDummy = [EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT];
	XCTAssertEqualObjects([remoteDummy class], edoClass);

	EDOTestDummy *returnDummy = [remoteDummy returnIdWithInt:5];
	XCTAssertEqualObjects([returnDummy class], edoClass);
	// returnDummy.value = 5 + initValue(6);
	XCTAssertEqual(returnDummy.value, 11);

	Class testDummyClass = EDO_REMOTE_CLASS(EDOTestDummy, EDOTEST_APP_SERVICE_PORT);
	XCTAssertEqualObjects([testDummyClass class], edoClass);
	XCTAssertEqualObjects([remoteDummy class], edoClass);

	[remoteDummy setDummInTest:dummyInTest withDummy:dummyAssigned];

	XCTAssertEqual(dummyInTest.dummyInTest, dummyAssigned);
	XCTAssertEqual([remoteDummy getRootObject:2234], rootObject);

	EDOTestDummyInTest *returnedDummy = [remoteDummy createEDOWithPort:2234];
	XCTAssertEqualObjects([returnedDummy class], [EDOTestDummyInTest class]);
	// returnedDummy.value = -> createEDOWithPort:
	// makeAnotherDummy:
	// -> 7 + rooObject.value(5)
	// -> 12 + 5
	XCTAssertEqual(returnedDummy.value.intValue, 17);

	[service invalidate];
	}

	// Test that the underlying object gets released if there is no remote reference.
	- (void)testUnderlyingObjectReleasedIfNotHeldRemotely {
	[self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:6];
	EDOTestDummy *remoteDummy = self.remoteRootObject;
	@autoreleasepool {
	// Allocate a weak variable inside the autoreleasepool.
	EDOTestDummy *dummyInTest = [remoteDummy weaklyHeldDummyForMemoryTest];
	// Assert that the remoteDummy holds a reference to the weak variable.
	XCTAssertNotNil(remoteDummy.weakDummyInTest);
	XCTAssertNotNil(dummyInTest);
	}
	// The strong variable that held a strong reference is gone. Since the remoteDummy holds a weak
	// reference to itself, then it should be nil.
	XCTAssertNil(remoteDummy.weakDummyInTest);
	}

	// Test that the same underlying objects should live if there is at least one remote reference.
	- (void)testUnderlyingObjectStayAliveIfHeldRemotely {
	EDOTestDummy *remoteDummy = self.remoteRootObject;
	NS_VALID_UNTIL_END_OF_SCOPE EDOTestDummy *strongReference;
	@autoreleasepool {
	// Hold the remote object strongly.
	strongReference = [remoteDummy weaklyHeldDummyForMemoryTest];
	XCTAssertNotNil(strongReference);
	}
	// Remote strong reference should keep the underlying object still alive.
	XCTAssertNotNil(remoteDummy.weakDummyInTest);
	}

	// Test that the multiple holdings of the same underlying objects can get released remotely.
	- (void)testUnderlyingObjectReleasedIfHeldWeakly {
	EDOTestDummy *remoteDummy = self.remoteRootObject;
	__weak EDOTestDummy *weakReference;
	@autoreleasepool {
	// Get a weak variable.
	NS_VALID_UNTIL_END_OF_SCOPE EDOTestDummy *dummy = [remoteDummy weaklyHeldDummyForMemoryTest];
	weakReference = dummy;
	XCTAssertNotNil(weakReference);
	}
	// Both variables are weak. When one of them is released both of them get released.
	XCTAssertNil(weakReference);
	XCTAssertNil(remoteDummy.weakDummyInTest);
	}

	// Test that the root object is strongly held even if the remote references are gone.
	- (void)testUnderlyingObjectStayAliveRegardlessOfRemoteReference {
	__weak EDOTestDummy *remoteWeakDummy;
	@autoreleasepool {
	// Initialize a weak reference to the rootObject.
	NS_VALID_UNTIL_END_OF_SCOPE EDOTestDummy *dummy = self.remoteRootObject;
	remoteWeakDummy = dummy;
	XCTAssertNotNil(remoteWeakDummy);
	}
	// The remote weak reference is gone but the underlying object should stay alive.
	XCTAssertNil(remoteWeakDummy);
	XCTAssertNotNil([EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT]);
	}

	// Test that the app wouldn't crash if the remote session is terminated.
	- (void)testSafeRecoverIfServiceTerminated {
	EDOTestDummy *remoteDummy = self.remoteRootObject;
	__weak EDOTestDummy *weakReference;
	@autoreleasepool {
	NS_VALID_UNTIL_END_OF_SCOPE EDOTestDummy *dummy = [remoteDummy weaklyHeldDummyForMemoryTest];
	weakReference = dummy;
	[self.application terminate];
	}
	// The test shouldn't crash if the app is gone.
	XCTAssertNil(weakReference);
	}

	/** Tests the remoteWeak function retains the weakly referenced object during its use. */
	- (void)testWeakObjectReferenceRetain {
	[self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:13];
	EDOHostService *service =
	[EDOHostService serviceWithPort:2234
	rootObject:[[EDOTestDummyInTest alloc] initWithValue:9]
	queue:dispatch_get_main_queue()];
	EDOTestDummy *remoteDummy = [EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT];
	id local = [[NSObject alloc] init];

	// Originally, without remoteWeak, weakDelegate would return nil.
	remoteDummy.weakDelegate = local;
	XCTAssertNil(remoteDummy.weakDelegate);

	// RemoteWeak will retain the local.
	remoteDummy.weakDelegate = [local remoteWeak];
	XCTAssertNotNil(remoteDummy.weakDelegate);
	[service invalidate];
	}

	/** Tests the remoteWeak function retains the weakly referenced object during its use and releases
	* once the underlying object is released. */
	- (void)testWeakObjectReferenceRetainAndRelease {
	[self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:13];
	EDOHostService *service =
	[EDOHostService serviceWithPort:2234
	rootObject:[[EDOTestDummyInTest alloc] initWithValue:9]
	queue:dispatch_get_main_queue()];
	EDOTestDummy *remoteDummy;
	@autoreleasepool {
	id local = [[NSObject alloc] init];
	remoteDummy = [EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT];
	// Original usage:
	// remoteDummy.weakDelegate = local;
	remoteDummy.weakDelegate = [local remoteWeak];
	XCTAssertNotNil(remoteDummy.weakDelegate);
	}
	XCTAssertNil(remoteDummy.weakDelegate);
	[service invalidate];
	}

	/** Tests the remoteWeak returns the same value when using on a local object. */
	- (void)testRemoteWeakToLocalObject {
	EDOTestDummyInTest *dummy = [[EDOTestDummyInTest alloc] init];
	XCTAssertEqual([[dummy remoteWeak] value], [dummy value]);
	}

	/** Tests assigning remoteWeak to EDOObject throws the right exception. */
	- (void)testRemoteWeakToEDOObjectWithLocalReference {
	[self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:13];
	EDOHostService *service =
	[EDOHostService serviceWithPort:2234
	rootObject:[[EDOTestDummyInTest alloc] initWithValue:9]
	queue:dispatch_get_main_queue()];
	EDOTestDummy *remoteDummy = [EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT];
	XCTAssertThrowsSpecificNamed([remoteDummy remoteWeak], NSException,
	EDOWeakObjectRemoteWeakMisuseException);
	[service invalidate];
	}

	/** Tests assigning the same underlying object to multiple localReferences doesn't crash the
	* process. */
	- (void)testRemoteWeakToMultipleEDOObjectWithLocalReferences {
	[self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:13];
	EDOHostService *service =
	[EDOHostService serviceWithPort:2234
	rootObject:[[EDOTestDummyInTest alloc] initWithValue:9]
	queue:dispatch_get_main_queue()];
	EDOTestDummy *remoteDummy;
	EDOTestDummy *remoteDummy2;
	@autoreleasepool {
	id local = [[NSObject alloc] init];
	remoteDummy = [EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT];
	remoteDummy2 = [remoteDummy returnDeepCopy];
	remoteDummy.weakDelegate = [local remoteWeak];
	XCTAssertNotNil(remoteDummy.weakDelegate);
	remoteDummy2.weakDelegate = [local remoteWeak];
	XCTAssertNotNil(remoteDummy.weakDelegate);
	XCTAssertNotNil(remoteDummy2.weakDelegate);
	}
	XCTAssertNil(remoteDummy.weakDelegate);
	XCTAssertNil(remoteDummy2.weakDelegate);
	[service invalidate];
	}

	/** Tests assigning the same underlying object to multiple localReferences doesn't crash the
	* process. */
	- (void)testRemoteWeakToEDOObjectWithMultipleLocalReferences {
	[self launchApplicationWithPort:EDOTEST_APP_SERVICE_PORT initValue:13];
	EDOHostService *service =
	[EDOHostService serviceWithPort:2234
	rootObject:[[EDOTestDummyInTest alloc] initWithValue:9]
	queue:dispatch_get_main_queue()];
	EDOTestDummy *remoteDummy;
	@autoreleasepool {
	id local1 = [[NSObject alloc] init];
	id local2 = [[NSObject alloc] init];
	remoteDummy = [EDOClientService rootObjectWithPort:EDOTEST_APP_SERVICE_PORT];
	remoteDummy.weakDelegate = [local1 remoteWeak];
	remoteDummy.weakDelegate = [local2 remoteWeak];
	XCTAssertNotNil(remoteDummy.weakDelegate);
	}
	XCTAssertNil(remoteDummy.weakDelegate);
	[service invalidate];
	}

	@end