Adds PrimitiveSequence unit tests.

2024-10-05 22:47:15 +03:00 · 2017-03-12 02:18:06 +01:00 · 2017-03-12 02:18:06 +01:00 · f867fc1c74
commit f867fc1c74
parent a26b9ac3ed
5 changed files with 749 additions and 0 deletions
--- a/Rx.xcodeproj/project.pbxproj
+++ b/Rx.xcodeproj/project.pbxproj
@ -547,6 +547,9 @@
 		C84CC5681BDD08A500E06A64 /* SubscriptionDisposable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C84CC5661BDD08A500E06A64 /* SubscriptionDisposable.swift */; };
 		C84CC5691BDD08A500E06A64 /* SubscriptionDisposable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C84CC5661BDD08A500E06A64 /* SubscriptionDisposable.swift */; };
 		C84CC56A1BDD08A500E06A64 /* SubscriptionDisposable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C84CC5661BDD08A500E06A64 /* SubscriptionDisposable.swift */; };
+		C850F3D41E749F5C006C417C /* Single+Maybe+Completeable+Test.swift.swift in Sources */ = {isa = PBXBuildFile; fileRef = C850F3D31E749F5C006C417C /* Single+Maybe+Completeable+Test.swift.swift */; };
+		C850F3D51E749F5C006C417C /* Single+Maybe+Completeable+Test.swift.swift in Sources */ = {isa = PBXBuildFile; fileRef = C850F3D31E749F5C006C417C /* Single+Maybe+Completeable+Test.swift.swift */; };
+		C850F3D61E749F5C006C417C /* Single+Maybe+Completeable+Test.swift.swift in Sources */ = {isa = PBXBuildFile; fileRef = C850F3D31E749F5C006C417C /* Single+Maybe+Completeable+Test.swift.swift */; };
 		C85106881C2D550E0075150C /* String+Rx.swift in Sources */ = {isa = PBXBuildFile; fileRef = C85106871C2D550E0075150C /* String+Rx.swift */; };
 		C85106891C2D550E0075150C /* String+Rx.swift in Sources */ = {isa = PBXBuildFile; fileRef = C85106871C2D550E0075150C /* String+Rx.swift */; };
 		C851068A1C2D550E0075150C /* String+Rx.swift in Sources */ = {isa = PBXBuildFile; fileRef = C85106871C2D550E0075150C /* String+Rx.swift */; };
@ -1787,6 +1790,7 @@
 		C84CC55C1BDD010800E06A64 /* SynchronizedUnsubscribeType.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SynchronizedUnsubscribeType.swift; sourceTree = "<group>"; };
 		C84CC5611BDD037900E06A64 /* SynchronizedDisposeType.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SynchronizedDisposeType.swift; sourceTree = "<group>"; };
 		C84CC5661BDD08A500E06A64 /* SubscriptionDisposable.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SubscriptionDisposable.swift; sourceTree = "<group>"; };
+		C850F3D31E749F5C006C417C /* Single+Maybe+Completeable+Test.swift.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Single+Maybe+Completeable+Test.swift.swift"; sourceTree = "<group>"; };
 		C85106871C2D550E0075150C /* String+Rx.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "String+Rx.swift"; sourceTree = "<group>"; };
 		C85217E31E3374710015DD38 /* GroupBy.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = GroupBy.swift; sourceTree = "<group>"; };
 		C85217E81E3374970015DD38 /* GroupedObservable.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = GroupedObservable.swift; sourceTree = "<group>"; };
@ -2564,6 +2568,7 @@
 				C8BAA78C1E34F8D400EEC727 /* RecursiveLockTest.swift */,
 				C896A68A1E6B7DC60073A3A8 /* Observable+MultipleTest+CombineLatest+Fixed.swift */,
 				C81A097C1E6C27A100900B3B /* Observable+MultipleTest+Zip+Fixed.swift */,
+				C850F3D31E749F5C006C417C /* Single+Maybe+Completeable+Test.swift.swift */,
 			);
 			path = RxSwiftTests;
 			sourceTree = "<group>";
@ -4067,6 +4072,7 @@
 				C81A097D1E6C27A100900B3B /* Observable+MultipleTest+Zip+Fixed.swift in Sources */,
 				C83509321C38706E0027C24C /* DelegateProxyTest.swift in Sources */,
 				0BA9496C1E224B9C0036DD06 /* AsyncSubjectTests.swift in Sources */,
+				C850F3D41E749F5C006C417C /* Single+Maybe+Completeable+Test.swift.swift in Sources */,
 				C8F27DC01CE68DA600D5FB4F /* UITextView+RxTests.swift in Sources */,
 				C860EC951C42E25E00A664B3 /* SectionedViewDataSourceMock.swift in Sources */,
 				C83509431C38706E0027C24C /* MockDisposable.swift in Sources */,
@ -4173,6 +4179,7 @@
 				C81B6AAE1DB2C15C0047CF86 /* Platform.Linux.swift in Sources */,
 				C83509F21C38755D0027C24C /* AnonymousObservable+Test.swift in Sources */,
 				7FE849481C5D0D6B00845C0E /* UIRefreshControl+RxTests.swift in Sources */,
+				C850F3D51E749F5C006C417C /* Single+Maybe+Completeable+Test.swift.swift in Sources */,
 				C8C4F1791DE9DF0200003FA7 /* UIAlertAction+RxTests.swift in Sources */,
 				C83509D31C3875390027C24C /* RXObjCRuntime+Testing.m in Sources */,
 				C81A097E1E6C27A100900B3B /* Observable+MultipleTest+Zip+Fixed.swift in Sources */,
@ -4201,6 +4208,7 @@
 				C8D9D6171E63747200AFCA6C /* Observable+MultipleTest2.swift in Sources */,
 				0BA9496E1E224B9C0036DD06 /* AsyncSubjectTests.swift in Sources */,
 				C83509E71C3875580027C24C /* PrimitiveHotObservable.swift in Sources */,
+				C850F3D61E749F5C006C417C /* Single+Maybe+Completeable+Test.swift.swift in Sources */,
 				C83509CE1C3875230027C24C /* NSObject+RxTests.swift in Sources */,
 				C8350A011C38755E0027C24C /* AssumptionsTest.swift in Sources */,
 				C81B6AAC1DB2C15C0047CF86 /* Platform.Darwin.swift in Sources */,
--- a/RxSwift/Units/Single+Maybe+Completeable.swift
+++ b/RxSwift/Units/Single+Maybe+Completeable.swift
@ -507,4 +507,32 @@ extension PrimitiveSequenceType where ElementType: SignedInteger
    }
 }

+extension PrimitiveSequenceType where TraitType == MaybeTrait {
+    /**
+     Returns an empty observable sequence, using the specified scheduler to send out the single `Completed` message.
+
+     - seealso: [empty operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
+
+     - returns: An observable sequence with no elements.
+     */
+    public static func empty() -> PrimitiveSequence<MaybeTrait, ElementType> {
+        return PrimitiveSequence(raw: Observable.empty())
+    }
+}
+
+extension PrimitiveSequenceType where TraitType == CompleteableTrait, ElementType == Never {
+    /**
+     Returns an empty observable sequence, using the specified scheduler to send out the single `Completed` message.
+
+     - seealso: [empty operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
+
+     - returns: An observable sequence with no elements.
+     */
+    public static func empty() -> PrimitiveSequence<CompleteableTrait, Never> {
+        return PrimitiveSequence(raw: Observable.empty())
+    }
+}
+
+
+
 // Zip: To be done
--- a/Sources/AllTestz/Single+Maybe+Completeable+Test.swift.swift
+++ b/Sources/AllTestz/Single+Maybe+Completeable+Test.swift.swift
@ -0,0 +1 @@
+../../Tests/RxSwiftTests/Single+Maybe+Completeable+Test.swift.swift
--- a/Sources/AllTestz/main.swift
+++ b/Sources/AllTestz/main.swift
@ -54,6 +54,51 @@ final class AnomaliesTest_ : AnomaliesTest, RxTestCase {
    ] }
 }

+final class PrimitiveSequenceTest_ : PrimitiveSequenceTest, RxTestCase {
+    #if os(macOS)
+    required override init() {
+        super.init()
+    }
+    #endif
+
+    static var allTests: [(String, (PrimitiveSequenceTest_) -> () -> ())] { return [
+    ("testSingle_Subscription_success", PrimitiveSequenceTest.testSingle_Subscription_success),
+    ("testSingle_Subscription_error", PrimitiveSequenceTest.testSingle_Subscription_error),
+    ("testSingle_create_success", PrimitiveSequenceTest.testSingle_create_success),
+    ("testSingle_create_error", PrimitiveSequenceTest.testSingle_create_error),
+    ("testSingle_create_disposing", PrimitiveSequenceTest.testSingle_create_disposing),
+    ("testMaybe_Subscription_success", PrimitiveSequenceTest.testMaybe_Subscription_success),
+    ("testMaybe_Subscription_completed", PrimitiveSequenceTest.testMaybe_Subscription_completed),
+    ("testMaybe_Subscription_error", PrimitiveSequenceTest.testMaybe_Subscription_error),
+    ("testMaybe_create_success", PrimitiveSequenceTest.testMaybe_create_success),
+    ("testMaybe_create_completed", PrimitiveSequenceTest.testMaybe_create_completed),
+    ("testMaybe_create_error", PrimitiveSequenceTest.testMaybe_create_error),
+    ("testMaybe_create_disposing", PrimitiveSequenceTest.testMaybe_create_disposing),
+    ("testCompleteable_Subscription_completed", PrimitiveSequenceTest.testCompleteable_Subscription_completed),
+    ("testCompleteable_Subscription_error", PrimitiveSequenceTest.testCompleteable_Subscription_error),
+    ("testCompleteable_create_completed", PrimitiveSequenceTest.testCompleteable_create_completed),
+    ("testCompleteable_create_error", PrimitiveSequenceTest.testCompleteable_create_error),
+    ("testCompleteable_create_disposing", PrimitiveSequenceTest.testCompleteable_create_disposing),
+    ("testSingle_deferred_producesSingleElement", PrimitiveSequenceTest.testSingle_deferred_producesSingleElement),
+    ("testSingle_just_producesSingleElement", PrimitiveSequenceTest.testSingle_just_producesSingleElement),
+    ("testSingle_just2_producesSingleElement", PrimitiveSequenceTest.testSingle_just2_producesSingleElement),
+    ("testSingle_error_fails", PrimitiveSequenceTest.testSingle_error_fails),
+    ("testSingle_never_producesSingleElement", PrimitiveSequenceTest.testSingle_never_producesSingleElement),
+    ("testSingle_delaySubscription_producesSingleElement", PrimitiveSequenceTest.testSingle_delaySubscription_producesSingleElement),
+    ("testSingle_delay_producesSingleElement", PrimitiveSequenceTest.testSingle_delay_producesSingleElement),
+    ("testSingle_do_producesSingleElement", PrimitiveSequenceTest.testSingle_do_producesSingleElement),
+    ("testSingle_filter_resultIsMaybe", PrimitiveSequenceTest.testSingle_filter_resultIsMaybe),
+    ("testSingle_map_producesSingleElement", PrimitiveSequenceTest.testSingle_map_producesSingleElement),
+    ("testSingle_flatMap_producesSingleElement", PrimitiveSequenceTest.testSingle_flatMap_producesSingleElement),
+    ("testSingle_observeOn_producesSingleElement", PrimitiveSequenceTest.testSingle_observeOn_producesSingleElement),
+    ("testSingle_catchError_producesSingleElement", PrimitiveSequenceTest.testSingle_catchError_producesSingleElement),
+    ("testSingle_retry_producesSingleElement", PrimitiveSequenceTest.testSingle_retry_producesSingleElement),
+    ("testSingle_retryWhen1_producesSingleElement", PrimitiveSequenceTest.testSingle_retryWhen1_producesSingleElement),
+    ("testSingle_retryWhen2_producesSingleElement", PrimitiveSequenceTest.testSingle_retryWhen2_producesSingleElement),
+    ("testSingle_timer_producesSingleElement", PrimitiveSequenceTest.testSingle_timer_producesSingleElement),
+    ] }
+}
+
 final class VirtualSchedulerTest_ : VirtualSchedulerTest, RxTestCase {
    #if os(macOS)
    required override init() {
@ -1195,6 +1240,7 @@ func XCTMain(_ tests: [() -> ()]) {
        testCase(EventTests_.allTests),
        testCase(PublishSubjectTest_.allTests),
        testCase(AnomaliesTest_.allTests),
+        testCase(PrimitiveSequenceTest_.allTests),
        testCase(VirtualSchedulerTest_.allTests),
        testCase(ObservableBlockingTest_.allTests),
        testCase(ObservableTimeTest_.allTests),
--- a/Tests/RxSwiftTests/Single+Maybe+Completeable+Test.swift.swift
+++ b/Tests/RxSwiftTests/Single+Maybe+Completeable+Test.swift.swift
@ -0,0 +1,666 @@
+//
+//  Single+Maybe+Completeable+Test.swift.swift
+//  Tests
+//
+//  Created by Krunoslav Zaher on 3/11/17.
+//  Copyright © 2017 Krunoslav Zaher. All rights reserved.
+//
+
+import XCTest
+import RxSwift
+import RxTest
+
+class PrimitiveSequenceTest : RxTest {
+
+}
+
+// single
+extension PrimitiveSequenceTest {
+    func testSingle_Subscription_success() {
+        let xs = Single.just(1)
+
+        var events: [SingleEvent<Int>] = []
+        
+        _ = xs.subscribe { event in
+            events.append(event)
+        }
+
+        XCTAssertEqual(events, [.success(1)])
+    }
+
+    func testSingle_Subscription_error() {
+        let xs = Single<Int>.error(testError)
+
+        var events: [SingleEvent<Int>] = []
+
+        _ = xs.subscribe { event in
+            events.append(event)
+        }
+
+        XCTAssertEqual(events, [.error(testError)])
+    }
+
+    func testSingle_create_success() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        var observer: ((SingleEvent<Int>) -> ())! = nil
+
+        var disposedTime: Int? = nil
+
+        scheduler.scheduleAt(201, action: {
+            observer(.success(1))
+        })
+        scheduler.scheduleAt(202, action: {
+            observer(.success(1))
+        })
+        scheduler.scheduleAt(203, action: {
+            observer(.error(testError))
+        })
+        
+        let res = scheduler.start {
+            Single<Int>.create { _observer in
+                observer = _observer
+                return Disposables.create {
+                    disposedTime = scheduler.clock
+                }
+            }.asObservable()
+        }
+
+        XCTAssertEqual(res.events, [
+            next(201, 1),
+            completed(201)
+        ])
+
+        XCTAssertEqual(disposedTime, 201)
+    }
+
+    func testSingle_create_error() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        var observer: ((SingleEvent<Int>) -> ())! = nil
+
+        var disposedTime: Int? = nil
+
+        scheduler.scheduleAt(201, action: {
+            observer(.error(testError))
+        })
+        scheduler.scheduleAt(202, action: {
+            observer(.success(1))
+        })
+        scheduler.scheduleAt(203, action: {
+            observer(.error(testError))
+        })
+
+        let res = scheduler.start {
+            Single<Int>.create { _observer in
+                observer = _observer
+                return Disposables.create {
+                    disposedTime = scheduler.clock
+                }
+                }.asObservable()
+        }
+
+        XCTAssertEqual(res.events, [
+            error(201, testError)
+            ])
+
+        XCTAssertEqual(disposedTime, 201)
+    }
+
+    func testSingle_create_disposing() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        var observer: ((SingleEvent<Int>) -> ())! = nil
+        var disposedTime: Int? = nil
+        var subscription: Disposable! = nil
+        let res = scheduler.createObserver(Int.self)
+        
+        scheduler.scheduleAt(201, action: {
+            subscription = Single<Int>.create { _observer in
+                observer = _observer
+                return Disposables.create {
+                    disposedTime = scheduler.clock
+                }
+            }
+                .asObservable()
+                .subscribe(res)
+        })
+        scheduler.scheduleAt(202, action: {
+            subscription.dispose()
+        })
+        scheduler.scheduleAt(203, action: {
+            observer(.success(1))
+        })
+        scheduler.scheduleAt(204, action: {
+            observer(.error(testError))
+        })
+
+        scheduler.start()
+
+        XCTAssertEqual(res.events, [
+            ])
+
+        XCTAssertEqual(disposedTime, 202)
+    }
+}
+
+// maybe
+extension PrimitiveSequenceTest {
+    func testMaybe_Subscription_success() {
+        let xs = Maybe.just(1)
+
+        var events: [MaybeEvent<Int>] = []
+
+        _ = xs.subscribe { event in
+            events.append(event)
+        }
+
+        XCTAssertEqual(events, [.success(1)])
+    }
+
+    func testMaybe_Subscription_completed() {
+        let xs = Maybe<Int>.empty()
+
+        var events: [MaybeEvent<Int>] = []
+
+        _ = xs.subscribe { event in
+            events.append(event)
+        }
+
+        XCTAssertEqual(events, [.completed])
+    }
+
+    func testMaybe_Subscription_error() {
+        let xs = Maybe<Int>.error(testError)
+
+        var events: [MaybeEvent<Int>] = []
+
+        _ = xs.subscribe { event in
+            events.append(event)
+        }
+
+        XCTAssertEqual(events, [.error(testError)])
+    }
+
+    func testMaybe_create_success() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        var observer: ((MaybeEvent<Int>) -> ())! = nil
+
+        var disposedTime: Int? = nil
+
+        scheduler.scheduleAt(201, action: {
+            observer(.success(1))
+        })
+        scheduler.scheduleAt(202, action: {
+            observer(.success(1))
+        })
+        scheduler.scheduleAt(203, action: {
+            observer(.error(testError))
+        })
+        scheduler.scheduleAt(204, action: {
+            observer(.completed)
+        })
+
+        let res = scheduler.start {
+            Maybe<Int>.create { _observer in
+                observer = _observer
+                return Disposables.create {
+                    disposedTime = scheduler.clock
+                }
+            }.asObservable()
+        }
+
+        XCTAssertEqual(res.events, [
+            next(201, 1),
+            completed(201)
+            ])
+
+        XCTAssertEqual(disposedTime, 201)
+    }
+
+    func testMaybe_create_completed() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        var observer: ((MaybeEvent<Int>) -> ())! = nil
+
+        var disposedTime: Int? = nil
+
+        scheduler.scheduleAt(201, action: {
+            observer(.completed)
+        })
+        scheduler.scheduleAt(202, action: {
+            observer(.success(1))
+        })
+        scheduler.scheduleAt(203, action: {
+            observer(.error(testError))
+        })
+        scheduler.scheduleAt(204, action: {
+            observer(.completed)
+        })
+
+        let res = scheduler.start {
+            Maybe<Int>.create { _observer in
+                observer = _observer
+                return Disposables.create {
+                    disposedTime = scheduler.clock
+                }
+            }.asObservable()
+        }
+
+        XCTAssertEqual(res.events, [
+            completed(201)
+            ])
+
+        XCTAssertEqual(disposedTime, 201)
+    }
+
+    func testMaybe_create_error() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        var observer: ((MaybeEvent<Int>) -> ())! = nil
+
+        var disposedTime: Int? = nil
+
+        scheduler.scheduleAt(201, action: {
+            observer(.error(testError))
+        })
+        scheduler.scheduleAt(202, action: {
+            observer(.success(1))
+        })
+        scheduler.scheduleAt(203, action: {
+            observer(.error(testError))
+        })
+
+        let res = scheduler.start {
+            Maybe<Int>.create { _observer in
+                observer = _observer
+                return Disposables.create {
+                    disposedTime = scheduler.clock
+                }
+            }.asObservable()
+        }
+
+        XCTAssertEqual(res.events, [
+            error(201, testError)
+            ])
+
+        XCTAssertEqual(disposedTime, 201)
+    }
+
+    func testMaybe_create_disposing() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        var observer: ((MaybeEvent<Int>) -> ())! = nil
+        var disposedTime: Int? = nil
+        var subscription: Disposable! = nil
+        let res = scheduler.createObserver(Int.self)
+
+        scheduler.scheduleAt(201, action: {
+            subscription = Maybe<Int>.create { _observer in
+                observer = _observer
+                return Disposables.create {
+                    disposedTime = scheduler.clock
+                }
+            }
+                .asObservable()
+                .subscribe(res)
+        })
+        scheduler.scheduleAt(202, action: {
+            subscription.dispose()
+        })
+        scheduler.scheduleAt(203, action: {
+            observer(.success(1))
+        })
+        scheduler.scheduleAt(204, action: {
+            observer(.error(testError))
+        })
+        
+        scheduler.start()
+        
+        XCTAssertEqual(res.events, [
+            ])
+        
+        XCTAssertEqual(disposedTime, 202)
+    }
+}
+
+// completeable
+extension PrimitiveSequenceTest {
+    func testCompleteable_Subscription_completed() {
+        let xs = Completeable.empty()
+
+        var events: [CompleteableEvent] = []
+
+        _ = xs.subscribe { event in
+            events.append(event)
+        }
+
+        XCTAssertEqual(events, [.completed])
+    }
+
+    func testCompleteable_Subscription_error() {
+        let xs = Completeable.error(testError)
+
+        var events: [CompleteableEvent] = []
+
+        _ = xs.subscribe { event in
+            events.append(event)
+        }
+
+        XCTAssertEqual(events, [.error(testError)])
+    }
+
+    func testCompleteable_create_completed() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        var observer: ((CompleteableEvent) -> ())! = nil
+
+        var disposedTime: Int? = nil
+
+        scheduler.scheduleAt(201, action: {
+            observer(.completed)
+        })
+        scheduler.scheduleAt(203, action: {
+            observer(.error(testError))
+        })
+        scheduler.scheduleAt(204, action: {
+            observer(.completed)
+        })
+
+        let res = scheduler.start {
+            Completeable.create { _observer in
+                observer = _observer
+                return Disposables.create {
+                    disposedTime = scheduler.clock
+                }
+            }.asObservable()
+        }
+
+        XCTAssertEqual(res.events, [
+            completed(201, Never.self)
+            ])
+
+        XCTAssertEqual(disposedTime, 201)
+    }
+
+    func testCompleteable_create_error() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        var observer: ((CompleteableEvent) -> ())! = nil
+
+        var disposedTime: Int? = nil
+
+        scheduler.scheduleAt(201, action: {
+            observer(.error(testError))
+        })
+        scheduler.scheduleAt(202, action: {
+            observer(.completed)
+        })
+        scheduler.scheduleAt(203, action: {
+            observer(.error(testError))
+        })
+
+        let res = scheduler.start {
+            Completeable.create { _observer in
+                observer = _observer
+                return Disposables.create {
+                    disposedTime = scheduler.clock
+                }
+            }.asObservable()
+        }
+
+        XCTAssertEqual(res.events, [
+            error(201, testError)
+            ])
+
+        XCTAssertEqual(disposedTime, 201)
+    }
+
+    func testCompleteable_create_disposing() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        var observer: ((CompleteableEvent) -> ())! = nil
+        var disposedTime: Int? = nil
+        var subscription: Disposable! = nil
+        let res = scheduler.createObserver(Never.self)
+
+        scheduler.scheduleAt(201, action: {
+            subscription = Completeable.create { _observer in
+                observer = _observer
+                return Disposables.create {
+                    disposedTime = scheduler.clock
+                }
+            }
+                .asObservable()
+                .subscribe(res)
+        })
+        scheduler.scheduleAt(202, action: {
+            subscription.dispose()
+        })
+        scheduler.scheduleAt(203, action: {
+            observer(.completed)
+        })
+        scheduler.scheduleAt(204, action: {
+            observer(.error(testError))
+        })
+        
+        scheduler.start()
+        
+        XCTAssertEqual(res.events, [
+            ])
+        
+        XCTAssertEqual(disposedTime, 202)
+    }
+}
+
+// single operators
+extension PrimitiveSequenceTest {
+    func testSingle_deferred_producesSingleElement() {
+        let result = try! (Single.deferred { Single.just(1) } as Single<Int>).toBlocking().first()!
+        XCTAssertEqual(result, 1)
+    }
+
+    func testSingle_just_producesSingleElement() {
+        let result = try! (Single.just(1) as Single<Int>).toBlocking().first()!
+        XCTAssertEqual(result, 1)
+    }
+
+    func testSingle_just2_producesSingleElement() {
+        let result = try! (Single.just(1, scheduler: CurrentThreadScheduler.instance) as Single<Int>).toBlocking().first()!
+        XCTAssertEqual(result, 1)
+    }
+
+    func testSingle_error_fails() {
+        do {
+            _ = try (Single<Int>.error(testError) as Single<Int>).toBlocking().first()
+            XCTFail()
+        }
+        catch let e {
+            XCTAssertEqual(e as! TestError, testError)
+        }
+    }
+
+    func testSingle_never_producesSingleElement() {
+        var event: SingleEvent<Int>? = nil
+        let subscription = (Single<Int>.never() as Single<Int>).subscribe { _event in
+            event = _event
+        }
+
+        XCTAssertNil(event)
+        subscription.dispose()
+    }
+
+    func testSingle_delaySubscription_producesSingleElement() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        let res = scheduler.start {
+            (Single.just(1).delaySubscription(1.0, scheduler: scheduler) as Single<Int>).asObservable()
+        }
+
+        XCTAssertEqual(res.events, [
+            next(201, 1),
+            completed(201)
+            ])
+    }
+
+    func testSingle_delay_producesSingleElement() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        let res = scheduler.start {
+            (Single.just(1)
+                .delay(1.0, scheduler: scheduler) as Single<Int>).asObservable()
+        }
+
+        XCTAssertEqual(res.events, [
+            next(201, 1),
+            completed(202)
+            ])
+    }
+
+    func testSingle_do_producesSingleElement() {
+        let singleResult: Single<Int> = Single.just(1)
+            .do()
+
+        let result = try! singleResult
+            .toBlocking().first()!
+        XCTAssertEqual(result, 1)
+    }
+
+    func testSingle_filter_resultIsMaybe() {
+        let filterResult: Maybe<Int> = Single.just(1)
+            .filter { _ in false }
+
+        XCTAssertNil(try! filterResult.toBlocking().first())
+    }
+
+    func testSingle_map_producesSingleElement() {
+        let singleResult: Single<Int> = Single.just(1)
+            .map { $0 * 2 }
+
+        let result = try! singleResult
+            .toBlocking().first()!
+        XCTAssertEqual(result, 2)
+    }
+
+    func testSingle_flatMap_producesSingleElement() {
+        let singleResult: Single<Int> = Single.just(1)
+            .flatMap { Single.just($0 * 2) }
+
+        let result = try! singleResult
+            .toBlocking().first()!
+        XCTAssertEqual(result, 2)
+    }
+
+    func testSingle_observeOn_producesSingleElement() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        let res = scheduler.start { () -> Observable<Int> in
+            let singleResult: Single<Int> = Single.just(1)
+                .observeOn(scheduler)
+
+            return singleResult.asObservable()
+        }
+
+        XCTAssertEqual(res.events, [
+            next(201, 1),
+            completed(202)
+            ])
+    }
+
+    func testSingle_catchError_producesSingleElement() {
+        let singleResult: Single<Int> = Single.error(testError)
+            .catchError { _ in Single.just(2) }
+
+        let result = try! singleResult
+            .toBlocking().first()!
+        XCTAssertEqual(result, 2)
+    }
+
+    func testSingle_retry_producesSingleElement() {
+        var isFirst = true
+        let singleResult: Single<Int> = Single.error(testError)
+            .catchError { e in
+                defer {
+                    isFirst = false
+                }
+                if isFirst {
+                    return Single.error(e)
+                }
+
+                return Single.just(2)
+            }
+            .retry(2)
+
+        let result = try! singleResult
+            .toBlocking().first()!
+        XCTAssertEqual(result, 2)
+    }
+
+    func testSingle_retryWhen1_producesSingleElement() {
+        var isFirst = true
+        let singleResult: Single<Int> = Single.error(testError)
+            .catchError { e in
+                defer {
+                    isFirst = false
+                }
+                if isFirst {
+                    return Single.error(e)
+                }
+
+                return Single.just(2)
+            }
+            .retryWhen { (e: Observable<Error>) in
+                return e
+            }
+
+        let result = try! singleResult
+            .toBlocking().first()!
+        XCTAssertEqual(result, 2)
+    }
+
+    func testSingle_retryWhen2_producesSingleElement() {
+        var isFirst = true
+        let singleResult: Single<Int> = Single.error(testError)
+            .catchError { e in
+                defer {
+                    isFirst = false
+                }
+                if isFirst {
+                    return Single.error(e)
+                }
+
+                return Single.just(2)
+            }
+            .retryWhen { (e: Observable<TestError>) in
+                return e
+        }
+
+        let result = try! singleResult
+            .toBlocking().first()!
+        XCTAssertEqual(result, 2)
+    }
+
+    func testSingle_timer_producesSingleElement() {
+        let scheduler = TestScheduler(initialClock: 0)
+
+        let res = scheduler.start { () -> Observable<Int> in
+            let singleResult: Single<Int> = Single<Int>.timer(2, scheduler: scheduler)
+
+            return singleResult.asObservable()
+        }
+
+        XCTAssertEqual(res.events, [
+            next(202, 0),
+            completed(202)
+            ])
+    }
+}
+
+extension Never: Equatable {
+
+}
+
+public func == (lhs: Never, rhs: Never) -> Bool {
+    fatalError()
+}
				`@ -0,0 +1 @@`
				`../../Tests/RxSwiftTests/Single+Maybe+Completeable+Test.swift.swift`