 }
 
 
-protocol PureSwiftDelegate: class {}
+protocol PureSwiftDelegate: class {
+    func delegateTestIt(with: Int)
+}
 
 class PureSwiftView: ReactiveCompatible {
     weak var delegate: PureSwiftDelegate?
+
+    func testIt(with: Int) {
+        self.delegate?.delegateTestIt(with: with)
+    }
 }
 
 extension Reactive where Base: PureSwiftView {
     var proxy: DelegateProxy<PureSwiftView, PureSwiftDelegate> {
         return PureSwiftDelegateProxy.proxy(for: base)
+    }
+}
+
+extension Reactive where Base: PureSwiftView {
+    var testIt: ControlEvent<Int> {
+        return ControlEvent(events: PureSwiftDelegateProxy.proxy(for: base).testItObserver)
     }
 }
 

        let mock = MockPureSwiftDelegate()
        
        view.delegate = mock
        
        let proxy = view.rx.proxy
        XCTAssertTrue(view.delegate === proxy)
        XCTAssertTrue(view.rx.proxy.forwardToDelegate() === mock)
    }
}


    static func setCurrentDelegate(_ delegate: PureSwiftDelegate?, to object: ParentObject) {
        return object.delegate = delegate
    }

    func delegateTestIt(with: Int) {
        testItObserver.on(.next(with))
        self.forwardToDelegate()?.delegateTestIt(with: with)
    }

    deinit {
        self.testItObserver.on(.completed)
    }
}

final class MockPureSwiftDelegate: PureSwiftDelegate {
    var latestValue: Int?

    func delegateTestIt(with: Int) {
        latestValue = with
    }
}

// }

