Migrated more class hook tests

Author: lukaskubanek

Tests/InterposeKitTests/ClassHookTests.swift

@@ -3,10 +3,15 @@ import XCTest
 
 fileprivate class ExampleClass: NSObject {
     @objc dynamic func doSomething() {}
-    @objc dynamic var intValue = 1
+    @objc dynamic var intValue: Int { 1 }
+    @objc dynamic var arrayValue: [String] { ["ExampleClass"] }
 }
 
-fileprivate class ExampleSubclass: ExampleClass {}
+fileprivate class ExampleSubclass: ExampleClass {
+    override var arrayValue: [String] {
+        super.arrayValue + ["ExampleSubclass"]
+    }
+}
 
 final class ClassHookTests: InterposeKitTestCase {
 
@@ -117,6 +122,42 @@ final class ClassHookTests: InterposeKitTestCase {
         XCTAssertEqual(hook.state, .pending)
     }
 
+    func testLifecycle_subclassOverride() throws {
+        let object = ExampleSubclass()
+        XCTAssertEqual(object.arrayValue, ["ExampleClass", "ExampleSubclass"])
+        
+        let superclassHook = try Interpose.applyHook(
+            on: ExampleClass.self,
+            for: #selector(getter: ExampleClass.arrayValue),
+            methodSignature: (@convention(c) (NSObject, Selector) -> [String]).self,
+            hookSignature: (@convention(block) (NSObject) -> [String]).self
+        ) { hook in
+            return { `self` in
+                return hook.original(self, hook.selector) + ["ExampleClass.hook"]
+            }
+        }
+        XCTAssertEqual(object.arrayValue, ["ExampleClass", "ExampleClass.hook", "ExampleSubclass"])
+        
+        let subclassHook = try Interpose.applyHook(
+            on: ExampleSubclass.self,
+            for: #selector(getter: ExampleClass.arrayValue),
+            methodSignature: (@convention(c) (NSObject, Selector) -> [String]).self,
+            hookSignature: (@convention(block) (NSObject) -> [String]).self
+        ) { hook in
+            return { `self` in
+                return hook.original(self, hook.selector) + ["ExampleSubclass.hook"]
+            }
+        }
+        
+        XCTAssertEqual(object.arrayValue, ["ExampleClass", "ExampleClass.hook", "ExampleSubclass", "ExampleSubclass.hook"])
+        
+        try superclassHook.revert()
+        XCTAssertEqual(object.arrayValue, ["ExampleClass", "ExampleSubclass", "ExampleSubclass.hook"])
+        
+        try subclassHook.revert()
+        XCTAssertEqual(object.arrayValue, ["ExampleClass", "ExampleSubclass"])
+    }
+    
     func testValidationFailure_methodNotFound() throws {
         XCTAssertThrowsError(
             try Interpose.prepareHook(
@@ -195,4 +236,50 @@ final class ClassHookTests: InterposeKitTestCase {
         )
     }
 
+    func testCleanup_implementationPreserved() throws {
+        var deallocated = false
+        
+        try autoreleasepool {
+            let tracker = LifetimeTracker { deallocated = true }
+            
+            try Interpose.applyHook(
+                on: ExampleClass.self,
+                for: #selector(ExampleClass.doSomething),
+                methodSignature: (@convention(c) (NSObject, Selector) -> Void).self,
+                hookSignature: (@convention(block) (NSObject) -> Void).self
+            ) { hook in
+                return { `self` in
+                    tracker.keep()
+                    return hook.original(self, hook.selector)
+                }
+            }
+        }
+        
+        XCTAssertFalse(deallocated)
+    }
+    
+    func testCleanup_implementationDeallocated() throws {
+        var deallocated = false
+        
+        try autoreleasepool {
+            let tracker = LifetimeTracker { deallocated = true }
+            
+            let hook = try Interpose.applyHook(
+                on: ExampleClass.self,
+                for: #selector(ExampleClass.doSomething),
+                methodSignature: (@convention(c) (NSObject, Selector) -> Void).self,
+                hookSignature: (@convention(block) (NSObject) -> Void).self
+            ) { hook in
+                return { `self` in
+                    tracker.keep()
+                    return hook.original(self, hook.selector)
+                }
+            }
+            
+            try hook.revert()
+        }
+        
+        XCTAssertTrue(deallocated)
+    }
+    
 }

Tests/InterposeKitTests/Helpers/LifetimeTracker.swift

@@ -0,0 +1,15 @@
+final class LifetimeTracker {
+    
+    init(onDeinit: @escaping () -> Void) {
+        self.onDeinit = onDeinit
+    }
+    
+    private let onDeinit: () -> Void
+    
+    func keep() {}
+    
+    deinit {
+        self.onDeinit()
+    }
+    
+}

Tests/InterposeKitTests/ToBePolished/InterposeKitTests.swift

@@ -247,4 +247,33 @@ final class ObjectInterposeTests: InterposeKitTestCase {
 //        try hook.revert()
 //        XCTAssertEqual(testObj.invert3DTransform(transform), transform.inverted)
 //    }
+    
+    func testRevertedCleanup_object() throws {
+        var deallocated = false
+        
+        try autoreleasepool {
+            let tracker = LifetimeTracker {
+                deallocated = true
+            }
+            
+            let object = TestClass()
+            let hook = try Interpose.applyHook(
+                on: object,
+                for: #selector(TestClass.doNothing),
+                methodSignature: (@convention(c) (NSObject, Selector) -> Void).self,
+                hookSignature: (@convention(block) (NSObject) -> Void).self
+            ) { hook in
+                return { `self` in
+                    tracker.keep()
+                    return hook.original(self, hook.selector)
+                }
+            }
+            
+            try hook.revert()
+        }
+        
+        // Verify that the block was deallocated
+        XCTAssertTrue(deallocated)
+    }
+    
 }

Tests/InterposeKitTests/ToBePolished/ObjectInterposeTests.swift

@@ -55,4 +55,27 @@ final class UtilitiesTests: XCTestCase {
         XCTAssertFalse(object_isKVOActive(object))
     }
 
+    func test_impRemoveBlock() {
+        var deallocated = false
+        
+        let imp: IMP = autoreleasepool {
+            let tracker = LifetimeTracker { deallocated = true }
+            
+            let block: @convention(block) (NSObject) -> Void = { _ in
+                tracker.keep()
+            }
+            
+            return imp_implementationWithBlock(block)
+        }
+        
+        // `imp` retains `block` which retains `tracker`.
+        XCTAssertFalse(deallocated)
+        
+        // Detach `block` from `imp`, while keeping `imp`.
+        imp_removeBlock(imp)
+        
+        // `block` and `tracker` should be deallocated now.
+        XCTAssertTrue(deallocated)
+    }
+    
 }