diff --git a/Source/AppleFetcher/Implement/AppleAdsAttributionTokenFetcher.swift b/Source/AppleFetcher/Implement/AppleAdsAttributionTokenFetcher.swift
index ae943d3..3084051 100644
--- a/Source/AppleFetcher/Implement/AppleAdsAttributionTokenFetcher.swift
+++ b/Source/AppleFetcher/Implement/AppleAdsAttributionTokenFetcher.swift
@@ -58,7 +58,8 @@ private final class ClassAAAttribution {
         
         let result = classAAAttribution.call(
             methodAttributionTokenWithError,
-            with: OpaquePointer(error)
+            with: OpaquePointer(error),
+            return: .reference
         )
         if let error = error.pointee {
             throw error
diff --git a/Source/AppleObjectiveCReflection/NSObjectClassMethod.swift b/Source/AppleObjectiveCReflection/NSObjectClassMethod.swift
index b8f06db..5be1cca 100644
--- a/Source/AppleObjectiveCReflection/NSObjectClassMethod.swift
+++ b/Source/AppleObjectiveCReflection/NSObjectClassMethod.swift
@@ -32,108 +32,182 @@ public final class NSObjectClassMethod {
 
 extension NSObjectClass {
     /// Call class method with reflection
-    /// - Warning: 0 value of non-class type will be returned as nil
     @discardableResult
-    public func call(
-        _ classMethod: NSObjectClassMethod
-    ) -> Any? {
+    public func call<Return>(
+        _ classMethod: NSObjectClassMethod,
+        return: NSObjectReturn<Return>
+    ) -> Return? {
         guard anyClass == classMethod.anyClass else { return nil }
         
-        typealias Function = @convention(c)(AnyClass, Selector)->Any?
         let implementation = method_getImplementation(classMethod.method)
-        let function = unsafeBitCast(implementation, to: Function.self)
         
-        return function(anyClass, classMethod.selector)
+        switch `return` {
+        case .reference:
+            typealias Function = @convention(c)(AnyClass, Selector)->Any?
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(anyClass, classMethod.selector)
+            return result as? Return
+        case .value(let type):
+            typealias Function = @convention(c)(AnyClass, Selector)->Unmanaged<AnyObject>
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(anyClass, classMethod.selector)
+            return cast(result, to: type)
+        }
     }
     
     /// Call class method with reflection
-    /// - Warning: 0 value of non-class type will be returned as nil
     @discardableResult
-    public func call(
+    public func call<Return>(
         _ classMethod: NSObjectClassMethod,
-        with argument0: Any?
-    ) -> Any? {
+        with argument0: Any?,
+        return: NSObjectReturn<Return>
+    ) -> Return? {
         guard anyClass == classMethod.anyClass else { return nil }
         
-        typealias Function = @convention(c)(AnyClass, Selector, Any?)->Any?
         let implementation = method_getImplementation(classMethod.method)
-        let function = unsafeBitCast(implementation, to: Function.self)
         
-        return function(anyClass, classMethod.selector, argument0)
+        switch `return` {
+        case .reference:
+            typealias Function = @convention(c)(AnyClass, Selector, Any?)->Any?
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(anyClass, classMethod.selector, argument0)
+            return result as? Return
+        case .value(let type):
+            typealias Function = @convention(c)(AnyClass, Selector, Any?)->Unmanaged<AnyObject>
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(anyClass, classMethod.selector, argument0)
+            return cast(result, to: type)
+        }
     }
     
     /// Call class method with reflection
-    /// - Warning: 0 value of non-class type will be returned as nil
     @discardableResult
-    public func call(
+    public func call<Return>(
         _ classMethod: NSObjectClassMethod,
         with argument0: Any?,
-        with argument1: Any?
-    ) -> Any? {
+        with argument1: Any?,
+        return: NSObjectReturn<Return>
+    ) -> Return? {
         guard anyClass == classMethod.anyClass else { return nil }
         
-        typealias Function = @convention(c)(AnyClass, Selector, Any?, Any?)->Any?
         let implementation = method_getImplementation(classMethod.method)
-        let function = unsafeBitCast(implementation, to: Function.self)
         
-        return function(anyClass, classMethod.selector, argument0, argument1)
+        switch `return` {
+        case .reference:
+            typealias Function = @convention(c)(AnyClass, Selector, Any?, Any?)->Any?
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(anyClass, classMethod.selector, argument0, argument1)
+            return result as? Return
+        case .value(let type):
+            typealias Function = @convention(c)(AnyClass, Selector, Any?, Any?)->Unmanaged<AnyObject>
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(anyClass, classMethod.selector, argument0, argument1)
+            return cast(result, to: type)
+        }
     }
     
     /// Call class method with reflection
-    /// - Warning: 0 value of non-class type will be returned as nil
     @discardableResult
-    public func call(
+    public func call<Return>(
         _ classMethod: NSObjectClassMethod,
         with argument0: Any?,
         with argument1: Any?,
-        with argument2: Any?
-    ) -> Any? {
+        with argument2: Any?,
+        return: NSObjectReturn<Return>
+    ) -> Return? {
         guard anyClass == classMethod.anyClass else { return nil }
         
-        typealias Function = @convention(c)(AnyClass, Selector, Any?, Any?, Any?)->Any?
         let implementation = method_getImplementation(classMethod.method)
-        let function = unsafeBitCast(implementation, to: Function.self)
         
-        return function(anyClass, classMethod.selector, argument0, argument1, argument2)
+        switch `return` {
+        case .reference:
+            typealias Function = @convention(c)(AnyClass, Selector, Any?, Any?, Any?)->Any?
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(anyClass, classMethod.selector, argument0, argument1, argument2)
+            return result as? Return
+        case .value(let type):
+            typealias Function = @convention(c)(AnyClass, Selector, Any?, Any?, Any?)->Unmanaged<AnyObject>
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(anyClass, classMethod.selector, argument0, argument1, argument2)
+            return cast(result, to: type)
+        }
     }
     
     /// Call class method with reflection
-    /// - Warning: 0 value of non-class type will be returned as nil
     @discardableResult
-    public func call(
+    public func call<Return>(
         _ classMethod: NSObjectClassMethod,
         with argument0: Any?,
         with argument1: Any?,
         with argument2: Any?,
-        with argument3: Any?
-    ) -> Any? {
+        with argument3: Any?,
+        return: NSObjectReturn<Return>
+    ) -> Return? {
         guard anyClass == classMethod.anyClass else { return nil }
         
-        typealias Function = @convention(c)(AnyClass, Selector, Any?, Any?, Any?, Any?)->Any?
         let implementation = method_getImplementation(classMethod.method)
-        let function = unsafeBitCast(implementation, to: Function.self)
         
-        return function(anyClass, classMethod.selector, argument0, argument1, argument2, argument3)
+        switch `return` {
+        case .reference:
+            typealias Function = @convention(c)(AnyClass, Selector, Any?, Any?, Any?, Any?)->Any?
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(anyClass, classMethod.selector, argument0, argument1, argument2, argument3)
+            return result as? Return
+        case .value(let type):
+            typealias Function = @convention(c)(AnyClass, Selector, Any?, Any?, Any?, Any?)->Unmanaged<AnyObject>
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(anyClass, classMethod.selector, argument0, argument1, argument2, argument3)
+            return cast(result, to: type)
+        }
     }
     
     /// Call class method with reflection
-    /// - Warning: 0 value of non-class type will be returned as nil
     @discardableResult
-    public func call(
+    public func call<Return>(
         _ classMethod: NSObjectClassMethod,
         with argument0: Any?,
         with argument1: Any?,
         with argument2: Any?,
         with argument3: Any?,
-        with argument4: Any?
-    ) -> Any? {
+        with argument4: Any?,
+        return: NSObjectReturn<Return>
+    ) -> Return? {
         guard anyClass == classMethod.anyClass else { return nil }
         
-        typealias Function = @convention(c)(AnyClass, Selector, Any?, Any?, Any?, Any?, Any?)->Any?
         let implementation = method_getImplementation(classMethod.method)
-        let function = unsafeBitCast(implementation, to: Function.self)
         
-        return function(anyClass, classMethod.selector, argument0, argument1, argument2, argument3, argument4)
+        switch `return` {
+        case .reference:
+            typealias Function = @convention(c)(AnyClass, Selector, Any?, Any?, Any?, Any?, Any?)->Any?
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(anyClass, classMethod.selector, argument0, argument1, argument2, argument3, argument4)
+            return result as? Return
+        case .value(let type):
+            typealias Function = @convention(c)(AnyClass, Selector, Any?, Any?, Any?, Any?, Any?)->Unmanaged<AnyObject>
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(anyClass, classMethod.selector, argument0, argument1, argument2, argument3, argument4)
+            return cast(result, to: type)
+        }
+    }
+}
+
+extension NSObjectClass {
+    private func cast<Actual>(
+        _ value: Unmanaged<AnyObject>,
+        to type: Actual.Type
+    ) -> Actual {
+        let raw = unsafeBitCast(value, to: Int.self)
+        
+        switch MemoryLayout<Actual>.size {
+        case 1:
+            return unsafeBitCast(Int8(raw), to: type)
+        case 2:
+            return unsafeBitCast(Int16(raw), to: type)
+        case 4:
+            return unsafeBitCast(Int32(raw), to: type)
+        default:
+            return unsafeBitCast(Int64(raw), to: type)
+        }
     }
 }
 
diff --git a/Source/AppleObjectiveCReflection/NSObjectInstanceMethod.swift b/Source/AppleObjectiveCReflection/NSObjectInstanceMethod.swift
index 7c0a86a..ddb452b 100644
--- a/Source/AppleObjectiveCReflection/NSObjectInstanceMethod.swift
+++ b/Source/AppleObjectiveCReflection/NSObjectInstanceMethod.swift
@@ -32,108 +32,182 @@ public final class NSObjectInstanceMethod {
 
 extension NSObjectInstance {
     /// Call class method with reflection
-    /// - Warning: 0 value of non-class type will be returned as nil
     @discardableResult
-    public func call(
-        _ instanceMethod: NSObjectInstanceMethod
-    ) -> Any? {
+    public func call<Return>(
+        _ instanceMethod: NSObjectInstanceMethod,
+        return: NSObjectReturn<Return>
+    ) -> Return? {
         guard object == instanceMethod.object else { return nil }
         
-        typealias Function = @convention(c)(NSObject, Selector)->Any?
         let implementation = method_getImplementation(instanceMethod.method)
-        let function = unsafeBitCast(implementation, to: Function.self)
         
-        return function(object, instanceMethod.selector)
+        switch `return` {
+        case .reference:
+            typealias Function = @convention(c)(NSObject, Selector)->Any?
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(object, instanceMethod.selector)
+            return result as? Return
+        case .value(let type):
+            typealias Function = @convention(c)(NSObject, Selector)->Unmanaged<AnyObject>
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(object, instanceMethod.selector)
+            return cast(result, to: type)
+        }
     }
     
     /// Call class method with reflection
-    /// - Warning: 0 value of non-class type will be returned as nil
     @discardableResult
-    public func call(
+    public func call<Return>(
         _ instanceMethod: NSObjectInstanceMethod,
-        with argument0: Any?
-    ) -> Any? {
+        with argument0: Any?,
+        return: NSObjectReturn<Return>
+    ) -> Return? {
         guard object == instanceMethod.object else { return nil }
         
-        typealias Function = @convention(c)(NSObject, Selector, Any?)->Any?
         let implementation = method_getImplementation(instanceMethod.method)
-        let function = unsafeBitCast(implementation, to: Function.self)
         
-        return function(object, instanceMethod.selector, argument0)
+        switch `return` {
+        case .reference:
+            typealias Function = @convention(c)(NSObject, Selector, Any?)->Any?
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(object, instanceMethod.selector, argument0)
+            return result as? Return
+        case .value(let type):
+            typealias Function = @convention(c)(NSObject, Selector, Any?)->Unmanaged<AnyObject>
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(object, instanceMethod.selector, argument0)
+            return cast(result, to: type)
+        }
     }
     
     /// Call class method with reflection
-    /// - Warning: 0 value of non-class type will be returned as nil
     @discardableResult
-    public func call(
+    public func call<Return>(
         _ instanceMethod: NSObjectInstanceMethod,
         with argument0: Any?,
-        with argument1: Any?
-    ) -> Any? {
+        with argument1: Any?,
+        return: NSObjectReturn<Return>
+    ) -> Return? {
         guard object == instanceMethod.object else { return nil }
         
-        typealias Function = @convention(c)(NSObject, Selector, Any?, Any?)->Any?
         let implementation = method_getImplementation(instanceMethod.method)
-        let function = unsafeBitCast(implementation, to: Function.self)
         
-        return function(object, instanceMethod.selector, argument0, argument1)
+        switch `return` {
+        case .reference:
+            typealias Function = @convention(c)(NSObject, Selector, Any?, Any?)->Any?
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(object, instanceMethod.selector, argument0, argument1)
+            return result as? Return
+        case .value(let type):
+            typealias Function = @convention(c)(NSObject, Selector, Any?, Any?)->Unmanaged<AnyObject>
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(object, instanceMethod.selector, argument0, argument1)
+            return cast(result, to: type)
+        }
     }
     
     /// Call class method with reflection
-    /// - Warning: 0 value of non-class type will be returned as nil
     @discardableResult
-    public func call(
+    public func call<Return>(
         _ instanceMethod: NSObjectInstanceMethod,
         with argument0: Any?,
         with argument1: Any?,
-        with argument2: Any?
-    ) -> Any? {
+        with argument2: Any?,
+        return: NSObjectReturn<Return>
+    ) -> Return? {
         guard object == instanceMethod.object else { return nil }
         
-        typealias Function = @convention(c)(NSObject, Selector, Any?, Any?, Any?)->Any?
         let implementation = method_getImplementation(instanceMethod.method)
-        let function = unsafeBitCast(implementation, to: Function.self)
         
-        return function(object, instanceMethod.selector, argument0, argument1, argument2)
+        switch `return` {
+        case .reference:
+            typealias Function = @convention(c)(NSObject, Selector, Any?, Any?, Any?)->Any?
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(object, instanceMethod.selector, argument0, argument1, argument2)
+            return result as? Return
+        case .value(let type):
+            typealias Function = @convention(c)(NSObject, Selector, Any?, Any?, Any?)->Unmanaged<AnyObject>
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(object, instanceMethod.selector, argument0, argument1, argument2)
+            return cast(result, to: type)
+        }
     }
     
     /// Call class method with reflection
-    /// - Warning: 0 value of non-class type will be returned as nil
     @discardableResult
-    public func call(
+    public func call<Return>(
         _ instanceMethod: NSObjectInstanceMethod,
         with argument0: Any?,
         with argument1: Any?,
         with argument2: Any?,
-        with argument3: Any?
-    ) -> Any? {
+        with argument3: Any?,
+        return: NSObjectReturn<Return>
+    ) -> Return? {
         guard object == instanceMethod.object else { return nil }
         
-        typealias Function = @convention(c)(NSObject, Selector, Any?, Any?, Any?, Any?)->Any?
         let implementation = method_getImplementation(instanceMethod.method)
-        let function = unsafeBitCast(implementation, to: Function.self)
         
-        return function(object, instanceMethod.selector, argument0, argument1, argument2, argument3)
+        switch `return` {
+        case .reference:
+            typealias Function = @convention(c)(NSObject, Selector, Any?, Any?, Any?, Any?)->Any?
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(object, instanceMethod.selector, argument0, argument1, argument2, argument3)
+            return result as? Return
+        case .value(let type):
+            typealias Function = @convention(c)(NSObject, Selector, Any?, Any?, Any?, Any?)->Unmanaged<AnyObject>
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(object, instanceMethod.selector, argument0, argument1, argument2, argument3)
+            return cast(result, to: type)
+        }
     }
     
     /// Call class method with reflection
-    /// - Warning: 0 value of non-class type will be returned as nil
     @discardableResult
-    public func call(
+    public func call<Return>(
         _ instanceMethod: NSObjectInstanceMethod,
         with argument0: Any?,
         with argument1: Any?,
         with argument2: Any?,
         with argument3: Any?,
-        with argument4: Any?
-    ) -> Any? {
+        with argument4: Any?,
+        return: NSObjectReturn<Return>
+    ) -> Return? {
         guard object == instanceMethod.object else { return nil }
         
-        typealias Function = @convention(c)(NSObject, Selector, Any?, Any?, Any?, Any?, Any?)->Any?
         let implementation = method_getImplementation(instanceMethod.method)
-        let function = unsafeBitCast(implementation, to: Function.self)
         
-        return function(object, instanceMethod.selector, argument0, argument1, argument2, argument3, argument4)
+        switch `return` {
+        case .reference:
+            typealias Function = @convention(c)(NSObject, Selector, Any?, Any?, Any?, Any?, Any?)->Any?
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(object, instanceMethod.selector, argument0, argument1, argument2, argument3, argument4)
+            return result as? Return
+        case .value(let type):
+            typealias Function = @convention(c)(NSObject, Selector, Any?, Any?, Any?, Any?, Any?)->Unmanaged<AnyObject>
+            let function = unsafeBitCast(implementation, to: Function.self)
+            let result = function(object, instanceMethod.selector, argument0, argument1, argument2, argument3, argument4)
+            return cast(result, to: type)
+        }
+    }
+}
+
+extension NSObjectInstance {
+    private func cast<Actual>(
+        _ value: Unmanaged<AnyObject>,
+        to type: Actual.Type
+    ) -> Actual {
+        let raw = unsafeBitCast(value, to: Int.self)
+        
+        switch MemoryLayout<Actual>.size {
+        case 1:
+            return unsafeBitCast(Int8(raw), to: type)
+        case 2:
+            return unsafeBitCast(Int16(raw), to: type)
+        case 4:
+            return unsafeBitCast(Int32(raw), to: type)
+        default:
+            return unsafeBitCast(Int64(raw), to: type)
+        }
     }
 }
 
diff --git a/Source/AppleObjectiveCReflection/NSObjectReturn.swift b/Source/AppleObjectiveCReflection/NSObjectReturn.swift
new file mode 100644
index 0000000..178197f
--- /dev/null
+++ b/Source/AppleObjectiveCReflection/NSObjectReturn.swift
@@ -0,0 +1,17 @@
+//
+//  NSObjectReturn.swift
+//  SabyAppleObjectiveCReflection
+//
+//  Created by WOF on 2024/01/31.
+//
+
+import Foundation
+
+public enum NSObjectReturn<Actual> {
+    case reference(Actual.Type)
+    case value(Actual.Type)
+}
+
+extension NSObjectReturn where Actual == Any {
+    public static let reference = NSObjectReturn.reference(Any.self)
+}
diff --git a/Source/AppleTracker/Implement/IdentifierForAdvertiserTracker.swift b/Source/AppleTracker/Implement/IdentifierForAdvertiserTracker.swift
index 8f3725e..c6e8884 100644
--- a/Source/AppleTracker/Implement/IdentifierForAdvertiserTracker.swift
+++ b/Source/AppleTracker/Implement/IdentifierForAdvertiserTracker.swift
@@ -53,7 +53,7 @@ private final class TrackerReflection {
                 classTracker.method(name: "sharedManager")
             ),
             let instanceTracker = (
-                classTracker.instance(object: classTracker.call(methodShared))
+                classTracker.instance(object: classTracker.call(methodShared, return: .reference))
             ),
             let methodTrackIdentifier = (
                 instanceTracker.method(name: "advertisingIdentifier")
@@ -73,12 +73,9 @@ private final class TrackerReflection {
     }
     
     func track() throws -> IdentifierForAdvertiser {
-        let limitAdTracking = instanceTracker.call(methodTrackLimitAdTracking) as? Bool ?? false
-        
         guard
-            let identifier = (
-                instanceTracker.call(methodTrackIdentifier) as? UUID
-            )
+            let limitAdTracking = instanceTracker.call(methodTrackLimitAdTracking, return: .value(Bool.self)),
+            let identifier = instanceTracker.call(methodTrackIdentifier, return: .reference(UUID.self))
         else {
             throw IdentifierForAdvertiserTrackerError.unmatchedType
         }
diff --git a/Source/AppleTracker/Implement/TrackingAuthorizationTracker.swift b/Source/AppleTracker/Implement/TrackingAuthorizationTracker.swift
index 3703cc1..cd90c18 100644
--- a/Source/AppleTracker/Implement/TrackingAuthorizationTracker.swift
+++ b/Source/AppleTracker/Implement/TrackingAuthorizationTracker.swift
@@ -60,9 +60,8 @@ private final class TrackerReflection {
     }
     
     func track() throws -> TrackingAuthorization {
-        let code = classTracker.call(methodTrackCode) as? UInt ?? 0
-        
         guard
+            let code = classTracker.call(methodTrackCode, return: .value(UInt.self)),
             let trackingAuthorization = TrackingAuthorization(rawValue: code)
         else {
             throw TrackingAuthorizationTrackerError.unmatchedType
diff --git a/Test/AppleObjectiveCReflection/NSObjectClassMethodTest.swift b/Test/AppleObjectiveCReflection/NSObjectClassMethodTest.swift
index f1212b7..7edfba7 100644
--- a/Test/AppleObjectiveCReflection/NSObjectClassMethodTest.swift
+++ b/Test/AppleObjectiveCReflection/NSObjectClassMethodTest.swift
@@ -10,23 +10,36 @@ import XCTest
 
 final class NSObjectClassMethodTest: XCTestCase {
     func test__init_class_method() {
-        let NSDictionary = NSObjectClass(name: "NSDictionary")!
+        let classNSDictionary = NSObjectClass(name: "NSDictionary")!
         
-        XCTAssertNotNil(NSDictionary.method(name: "dictionaryWithObjects:forKeys:"))
-        XCTAssertNil(NSDictionary.method(name: "1234567890"))
-        XCTAssertNil(NSDictionary.method(name: ""))
+        XCTAssertNotNil(classNSDictionary.method(name: "dictionaryWithObjects:forKeys:"))
+        XCTAssertNil(classNSDictionary.method(name: "1234567890"))
+        XCTAssertNil(classNSDictionary.method(name: ""))
     }
     
-    func test__call() {
-        let NSDictionary = NSObjectClass(name: "NSDictionary")!
-        let dictionaryWithValuesForKeys = NSDictionary.method(name: "dictionaryWithObjects:forKeys:")!
+    func test__call_return_reference() {
+        let classNSDictionary = NSObjectClass(name: "NSDictionary")!
+        let methodDictionaryWithValuesForKeys = classNSDictionary.method(name: "dictionaryWithObjects:forKeys:")!
         
-        let dictionary = NSDictionary.call(
-            dictionaryWithValuesForKeys,
+        let dictionary = classNSDictionary.call(
+            methodDictionaryWithValuesForKeys,
             with: ["1", "2", "3"],
-            with: ["a", "b", "c"]
-        ) as! NSDictionary
+            with: ["a", "b", "c"],
+            return: .reference(NSDictionary.self)
+        )!
         
         XCTAssertEqual(dictionary, ["a":"1","b":"2","c":"3"])
     }
+    
+    func test__call_return_value() {
+        let classNSDictionary = NSObjectClass(name: "NSDictionary")!
+        let methodIsProxy = classNSDictionary.method(name: "isProxy")!
+        
+        let isProxy = classNSDictionary.call(
+            methodIsProxy,
+            return: .value(Bool.self)
+        )!
+        
+        XCTAssertEqual(isProxy, false)
+    }
 }
diff --git a/Test/AppleObjectiveCReflection/NSObjectInstanceMethodTest.swift b/Test/AppleObjectiveCReflection/NSObjectInstanceMethodTest.swift
index d25c0cc..dbeaffe 100644
--- a/Test/AppleObjectiveCReflection/NSObjectInstanceMethodTest.swift
+++ b/Test/AppleObjectiveCReflection/NSObjectInstanceMethodTest.swift
@@ -10,10 +10,10 @@ import XCTest
 
 final class NSObjectInstanceMethodTest: XCTestCase {
     func test__init_class_method() {
-        let NSDictionary = NSObjectClass(name: "NSDictionary")!
-        let dictionaryWithValuesForKeys = NSDictionary.method(name: "dictionaryWithObjects:forKeys:")!
-        let instance = NSDictionary.instance(
-            object: NSDictionary.call(dictionaryWithValuesForKeys, with: ["1"], with: ["a"])
+        let classNSDictionary = NSObjectClass(name: "NSDictionary")!
+        let methodDictionaryWithValuesForKeys = classNSDictionary.method(name: "dictionaryWithObjects:forKeys:")!
+        let instance = classNSDictionary.instance(
+            object: classNSDictionary.call(methodDictionaryWithValuesForKeys, with: ["1"], with: ["a"], return: .reference)
         )!
         
         XCTAssertNotNil(instance.method(name: "objectForKey:"))
@@ -21,14 +21,25 @@ final class NSObjectInstanceMethodTest: XCTestCase {
         XCTAssertNil(instance.method(name: ""))
     }
     
-    func test__call() {
-        let NSDictionary = NSObjectClass(name: "NSDictionary")!
-        let dictionaryWithValuesForKeys = NSDictionary.method(name: "dictionaryWithObjects:forKeys:")!
-        let instance = NSDictionary.instance(
-            object: NSDictionary.call(dictionaryWithValuesForKeys, with: ["1"], with: ["a"])
+    func test__call_return_reference() {
+        let classNSDictionary = NSObjectClass(name: "NSDictionary")!
+        let methodDictionaryWithValuesForKeys = classNSDictionary.method(name: "dictionaryWithObjects:forKeys:")!
+        let instance = classNSDictionary.instance(
+            object: classNSDictionary.call(methodDictionaryWithValuesForKeys, with: ["1"], with: ["a"], return: .reference)
         )!
-        let objectForKey = instance.method(name: "objectForKey:")!
+        let methodObjectForKey = instance.method(name: "objectForKey:")!
         
-        XCTAssertEqual(instance.call(objectForKey, with: "a") as! String, "1")
+        XCTAssertEqual(instance.call(methodObjectForKey, with: "a", return: .reference(String.self))!, "1")
+    }
+    
+    func test__call_return_value() {
+        let classNSDictionary = NSObjectClass(name: "NSDictionary")!
+        let methodDictionaryWithValuesForKeys = classNSDictionary.method(name: "dictionaryWithObjects:forKeys:")!
+        let instance = classNSDictionary.instance(
+            object: classNSDictionary.call(methodDictionaryWithValuesForKeys, with: ["1"], with: ["a"], return: .reference)
+        )!
+        let methodCount = instance.method(name: "count")!
+        
+        XCTAssertEqual(instance.call(methodCount, return: .value(Int.self))!, 1)
     }
 }
diff --git a/Test/AppleObjectiveCReflection/NSObjectInstanceTest.swift b/Test/AppleObjectiveCReflection/NSObjectInstanceTest.swift
index 637f8b8..7d6270c 100644
--- a/Test/AppleObjectiveCReflection/NSObjectInstanceTest.swift
+++ b/Test/AppleObjectiveCReflection/NSObjectInstanceTest.swift
@@ -13,7 +13,7 @@ final class NSObjectInstanceTest: XCTestCase {
         let NSDictionary = NSObjectClass(name: "NSDictionary")!
         let dictionaryWithValuesForKeys = NSDictionary.method(name: "dictionaryWithObjects:forKeys:")!
         let instance = NSDictionary.instance(
-            object: NSDictionary.call(dictionaryWithValuesForKeys, with: ["1"], with: ["a"])
+            object: NSDictionary.call(dictionaryWithValuesForKeys, with: ["1"], with: ["a"], return: .reference)
         )!
         
         XCTAssertTrue(instance.object.isKind(of: NSDictionary.anyClass))