RxTest & RxBlocking: Force explicit self calls

RxBlocking/BlockingObservable+Operators.swift

@@ -28,8 +28,8 @@ extension BlockingObservable {
     ///
     /// - returns: All elements of sequence.
     public func toArray() throws -> [E] {
-        let results = materializeResult()
-        return try elementsOrThrow(results)
+        let results = self.materializeResult()
+        return try self.elementsOrThrow(results)
     }
 }
 
@@ -40,8 +40,8 @@ extension BlockingObservable {
     ///
     /// - returns: First element of sequence. If sequence is empty `nil` is returned.
     public func first() throws -> E? {
-        let results = materializeResult(max: 1)
-        return try elementsOrThrow(results).first
+        let results = self.materializeResult(max: 1)
+        return try self.elementsOrThrow(results).first
     }
 }
 
@@ -52,8 +52,8 @@ extension BlockingObservable {
     ///
     /// - returns: Last element in the sequence. If sequence is empty `nil` is returned.
     public func last() throws -> E? {
-        let results = materializeResult()
-        return try elementsOrThrow(results).last
+        let results = self.materializeResult()
+        return try self.elementsOrThrow(results).last
     }
 }
 
@@ -64,7 +64,7 @@ extension BlockingObservable {
     ///
     /// - returns: Returns the only element of an sequence, and reports an error if there is not exactly one element in the observable sequence.
     public func single() throws -> E {
-        return try single { _ in true }
+        return try self.single { _ in true }
     }
 
     /// Blocks current thread until sequence terminates.
@@ -74,8 +74,8 @@ extension BlockingObservable {
     /// - parameter predicate: A function to test each source element for a condition.
     /// - returns: Returns the only element of an sequence that satisfies the condition in the predicate, and reports an error if there is not exactly one element in the sequence.
     public func single(_ predicate: @escaping (E) throws -> Bool) throws -> E {
-        let results = materializeResult(max: 2, predicate: predicate)
-        let elements = try elementsOrThrow(results)
+        let results = self.materializeResult(max: 2, predicate: predicate)
+        let elements = try self.elementsOrThrow(results)
 
         if elements.count > 1 {
             throw RxError.moreThanOneElement
@@ -96,7 +96,7 @@ extension BlockingObservable {
     ///
     /// - returns: On completion, returns the list of elements in the sequence. On error, returns the list of elements up to that point, along with the error itself.
     public func materialize() -> MaterializedSequenceResult<E> {
-        return materializeResult()
+        return self.materializeResult()
     }
 }
 
@@ -105,7 +105,7 @@ extension BlockingObservable {
         var elements: [E] = Array<E>()
         var error: Swift.Error?
         
-        let lock = RunLoopLock(timeout: timeout)
+        let lock = RunLoopLock(timeout: self.timeout)
         
         let d = SingleAssignmentDisposable()
         

RxBlocking/RunLoopLock.swift

@@ -27,12 +27,12 @@ final class RunLoopLock {
     var _timeout: RxTimeInterval?
 
     init(timeout: RxTimeInterval?) {
-        _timeout = timeout
-        _currentRunLoop = CFRunLoopGetCurrent()
+        self._timeout = timeout
+        self._currentRunLoop = CFRunLoopGetCurrent()
     }
 
     func dispatch(_ action: @escaping () -> Void) {
-        CFRunLoopPerformBlock(_currentRunLoop, runLoopModeRaw) {
+        CFRunLoopPerformBlock(self._currentRunLoop, runLoopModeRaw) {
             if CurrentThreadScheduler.isScheduleRequired {
                 _ = CurrentThreadScheduler.instance.schedule(()) { _ in
                     action()
@@ -43,24 +43,24 @@ final class RunLoopLock {
                 action()
             }
         }
-        CFRunLoopWakeUp(_currentRunLoop)
+        CFRunLoopWakeUp(self._currentRunLoop)
     }
 
     func stop() {
-        if _calledStop.decrement() > 1 {
+        if self._calledStop.decrement() > 1 {
             return
         }
-        CFRunLoopPerformBlock(_currentRunLoop, runLoopModeRaw) {
+        CFRunLoopPerformBlock(self._currentRunLoop, runLoopModeRaw) {
             CFRunLoopStop(self._currentRunLoop)
         }
-        CFRunLoopWakeUp(_currentRunLoop)
+        CFRunLoopWakeUp(self._currentRunLoop)
     }
 
     func run() throws {
-        if _calledRun.increment() != 0 {
+        if self._calledRun.increment() != 0 {
             fatalError("Run can be only called once")
         }
-        if let timeout = _timeout {
+        if let timeout = self._timeout {
             #if os(Linux)
                 switch Int(CFRunLoopRunInMode(runLoopModeRaw, timeout, false)) {
                 case kCFRunLoopRunFinished:

RxTest/Any+Equatable.swift

@@ -17,8 +17,8 @@ struct AnyEquatable<Target>
     let _comparer: Comparer
 
     init(target: Target, comparer: @escaping Comparer) {
-        _target = target
-        _comparer = comparer
+        self._target = target
+        self._comparer = comparer
     }
 }
 
@@ -30,10 +30,10 @@ extension AnyEquatable
     : CustomDebugStringConvertible
     , CustomStringConvertible  {
     var description: String {
-        return "\(_target)"
+        return "\(self._target)"
     }
 
     var debugDescription: String {
-        return "\(_target)"
+        return "\(self._target)"
     }
 }

RxTest/ColdObservable.swift

@@ -21,15 +21,15 @@ final class ColdObservable<Element>
     }
 
     /// Subscribes `observer` to receive events for this sequence.
-    override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
-        subscriptions.append(Subscription(testScheduler.clock))
+    override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
+        self.subscriptions.append(Subscription(self.testScheduler.clock))
         
         let i = self.subscriptions.count - 1
 
         var disposed = false
 
-        for recordedEvent in recordedEvents {
-            _ = testScheduler.scheduleRelativeVirtual((), dueTime: recordedEvent.time, action: { _ in
+        for recordedEvent in self.recordedEvents {
+            _ = self.testScheduler.scheduleRelativeVirtual((), dueTime: recordedEvent.time, action: { _ in
                 if !disposed {
                     observer.on(recordedEvent.value)
                 }

RxTest/Deprecated.swift

@@ -11,12 +11,12 @@ import RxSwift
 extension TestScheduler {
     @available(*, deprecated, renamed: "start(disposed:create:)")
     public func start<Element>(_ disposed: TestTime, create: @escaping () -> Observable<Element>) -> TestableObserver<Element> {
-        return start(Defaults.created, subscribed: Defaults.subscribed, disposed: disposed, create: create)
+        return self.start(Defaults.created, subscribed: Defaults.subscribed, disposed: disposed, create: create)
     }
 
     @available(*, deprecated, renamed: "start(created:subscribed:disposed:create:)")
     public func start<Element>(_ created: TestTime, subscribed: TestTime, disposed: TestTime, create: @escaping () -> Observable<Element>) -> TestableObserver<Element> {
-        return start(created: created, subscribed: subscribed, disposed: disposed, create: create)
+        return self.start(created: created, subscribed: subscribed, disposed: disposed, create: create)
     }
 }
 

RxTest/HotObservable.swift

@@ -23,7 +23,7 @@ final class HotObservable<Element>
     private var _observers: Observers
 
     override init(testScheduler: TestScheduler, recordedEvents: [Recorded<Event<Element>>]) {
-        _observers = Observers()
+        self._observers = Observers()
         
         super.init(testScheduler: testScheduler, recordedEvents: recordedEvents)
 
@@ -37,9 +37,9 @@ final class HotObservable<Element>
     }
 
     /// Subscribes `observer` to receive events for this sequence.
-    override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
-        let key = _observers.insert(observer.on)
-        subscriptions.append(Subscription(self.testScheduler.clock))
+    override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
+        let key = self._observers.insert(observer.on)
+        self.subscriptions.append(Subscription(self.testScheduler.clock))
         
         let i = self.subscriptions.count - 1
         

RxTest/Recorded.swift

@@ -28,7 +28,7 @@ public struct Recorded<Value>
 extension Recorded {
     /// A textual representation of `self`, suitable for debugging.
     public var debugDescription: String {
-        return "\(value) @ \(time)"
+        return "\(self.value) @ \(self.time)"
     }
 }
 

RxTest/Schedulers/TestScheduler.swift

@@ -31,7 +31,7 @@ public class TestScheduler : VirtualTimeScheduler<TestSchedulerVirtualTimeConver
         it will be scheduled to `now + 1` in virtual time.
     */
     public init(initialClock: TestTime, resolution: Double = 1.0, simulateProcessingDelay: Bool = true) {
-        _simulateProcessingDelay = simulateProcessingDelay
+        self._simulateProcessingDelay = simulateProcessingDelay
         super.init(initialClock: initialClock, converter: TestSchedulerVirtualTimeConverter(resolution: resolution))
     }
 
@@ -81,7 +81,7 @@ public class TestScheduler : VirtualTimeScheduler<TestSchedulerVirtualTimeConver
     Adjusts time of scheduling before adding item to schedule queue. If scheduled time is `<= clock`, then it is scheduled at `clock + 1`
     */
     override public func adjustScheduledTime(_ time: VirtualTime) -> VirtualTime {
-        return time <= clock ? clock + (_simulateProcessingDelay ? 1 : 0) : time
+        return time <= self.clock ? self.clock + (self._simulateProcessingDelay ? 1 : 0) : time
     }
 
     /**
@@ -96,7 +96,7 @@ public class TestScheduler : VirtualTimeScheduler<TestSchedulerVirtualTimeConver
     public func start<Element>(created: TestTime, subscribed: TestTime, disposed: TestTime, create: @escaping () -> Observable<Element>) -> TestableObserver<Element> {
         var source: Observable<Element>?
         var subscription: Disposable?
-        let observer = createObserver(Element.self)
+        let observer = self.createObserver(Element.self)
         
         _ = self.scheduleAbsoluteVirtual((), time: created) { _ in
             source = create()
@@ -113,7 +113,7 @@ public class TestScheduler : VirtualTimeScheduler<TestSchedulerVirtualTimeConver
             return Disposables.create()
         }
 
-        start()
+        self.start()
         
         return observer
     }
@@ -130,7 +130,7 @@ public class TestScheduler : VirtualTimeScheduler<TestSchedulerVirtualTimeConver
      - returns: Observer with timestamped recordings of events that were received during the virtual time window when the subscription to the source sequence was active.
      */
     public func start<Element>(disposed: TestTime, create: @escaping () -> Observable<Element>) -> TestableObserver<Element> {
-        return start(created: Defaults.created, subscribed: Defaults.subscribed, disposed: disposed, create: create)
+        return self.start(created: Defaults.created, subscribed: Defaults.subscribed, disposed: disposed, create: create)
     }
 
     /**
@@ -145,7 +145,7 @@ public class TestScheduler : VirtualTimeScheduler<TestSchedulerVirtualTimeConver
      - returns: Observer with timestamped recordings of events that were received during the virtual time window when the subscription to the source sequence was active.
      */
     public func start<Element>(_ create: @escaping () -> Observable<Element>) -> TestableObserver<Element> {
-        return start(created: Defaults.created, subscribed: Defaults.subscribed, disposed: Defaults.disposed, create: create)
+        return self.start(created: Defaults.created, subscribed: Defaults.subscribed, disposed: Defaults.disposed, create: create)
     }
 }
 

RxTest/Schedulers/TestSchedulerVirtualTimeConverter.swift

@@ -20,7 +20,7 @@ public struct TestSchedulerVirtualTimeConverter : VirtualTimeConverterType {
     private let _resolution: Double
 
     init(resolution: Double) {
-        _resolution = resolution
+        self._resolution = resolution
     }
 
 
@@ -29,7 +29,7 @@ public struct TestSchedulerVirtualTimeConverter : VirtualTimeConverterType {
     /// - parameter virtualTime: Virtual time to convert to `Date`.
     /// - returns: `Date` corresponding to virtual time.
     public func convertFromVirtualTime(_ virtualTime: VirtualTimeUnit) -> RxTime {
-        return Date(timeIntervalSince1970: RxTimeInterval(virtualTime) * _resolution)
+        return Date(timeIntervalSince1970: RxTimeInterval(virtualTime) * self._resolution)
     }
 
     /// Converts real time to virtual time.
@@ -37,7 +37,7 @@ public struct TestSchedulerVirtualTimeConverter : VirtualTimeConverterType {
     /// - parameter time: `Date` to convert to virtual time.
     /// - returns: Virtual time corresponding to `Date`.
     public func convertToVirtualTime(_ time: RxTime) -> VirtualTimeUnit {
-        return VirtualTimeIntervalUnit(time.timeIntervalSince1970 / _resolution + 0.5)
+        return VirtualTimeIntervalUnit(time.timeIntervalSince1970 / self._resolution + 0.5)
     }
 
     /// Converts from virtual time interval to `NSTimeInterval`.
@@ -45,7 +45,7 @@ public struct TestSchedulerVirtualTimeConverter : VirtualTimeConverterType {
     /// - parameter virtualTimeInterval: Virtual time interval to convert to `NSTimeInterval`.
     /// - returns: `NSTimeInterval` corresponding to virtual time interval.
     public func convertFromVirtualTimeInterval(_ virtualTimeInterval: VirtualTimeIntervalUnit) -> RxTimeInterval {
-        return RxTimeInterval(virtualTimeInterval) * _resolution
+        return RxTimeInterval(virtualTimeInterval) * self._resolution
     }
 
     /// Converts from virtual time interval to `NSTimeInterval`.
@@ -53,7 +53,7 @@ public struct TestSchedulerVirtualTimeConverter : VirtualTimeConverterType {
     /// - parameter timeInterval: `NSTimeInterval` to convert to virtual time interval.
     /// - returns: Virtual time interval corresponding to time interval.
     public func convertToVirtualTimeInterval(_ timeInterval: RxTimeInterval) -> VirtualTimeIntervalUnit {
-        return VirtualTimeIntervalUnit(timeInterval / _resolution + 0.5)
+        return VirtualTimeIntervalUnit(timeInterval / self._resolution + 0.5)
     }
 
     /// Adds virtual time and virtual time interval.

RxTest/Subscription.swift

@@ -38,8 +38,8 @@ extension Subscription
     : Hashable
     , Equatable {
     /// The hash value.
-    public var hashValue : Int {
-        return subscribe.hashValue ^ unsubscribe.hashValue
+    public var hashValue: Int {
+        return self.subscribe.hashValue ^ self.unsubscribe.hashValue
     }
 }
 
@@ -48,7 +48,7 @@ extension Subscription
     /// A textual representation of `self`, suitable for debugging.
     public var debugDescription : String {
         let infiniteText = "Infinity"
-        return "(\(subscribe) : \(unsubscribe != Int.max ? String(unsubscribe) : infiniteText))"
+        return "(\(self.subscribe): \(self.unsubscribe != Int.max ? String(self.unsubscribe) : infiniteText))"
     }
 }
 

RxTest/TestableObserver.swift

@@ -19,13 +19,13 @@ public final class TestableObserver<ElementType>
     public fileprivate(set) var events = [Recorded<Event<Element>>]()
     
     init(scheduler: TestScheduler) {
-        _scheduler = scheduler
+        self._scheduler = scheduler
     }
 
     /// Notify observer about sequence event.
     ///
     /// - parameter event: Event that occurred.
     public func on(_ event: Event<Element>) {
-        events.append(Recorded(time: _scheduler.clock, value: event))
+        self.events.append(Recorded(time: self._scheduler.clock, value: event))
     }
 }