mirror of
https://github.com/ReactiveX/RxSwift.git
synced 2024-10-04 05:57:23 +03:00
Merge branch 'sergdort-cleanup-traits-operators' into swift4.0
This commit is contained in:
Krunoslav Zaher
commit
e29fd9e72c
@ -168,8 +168,12 @@ custom_categories:
|
||||
- name: RxSwift/Traits
|
||||
children:
|
||||
- Completable+AndThen
|
||||
- Completable
|
||||
- Maybe
|
||||
- ObservableType+PrimitiveSequence
|
||||
- PrimitiveSequence+Zip+arity
|
||||
- PrimitiveSequence
|
||||
- Single
|
||||
- name: RxCocoa/Common
|
||||
children:
|
||||
- Binder
|
||||
|
||||
@ -21,6 +21,18 @@
|
||||
1AF67DA61CED430100C310FA /* ReplaySubjectTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1AF67DA51CED430100C310FA /* ReplaySubjectTest.swift */; };
|
||||
1AF67DA71CED430100C310FA /* ReplaySubjectTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1AF67DA51CED430100C310FA /* ReplaySubjectTest.swift */; };
|
||||
1AF67DA81CED430100C310FA /* ReplaySubjectTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1AF67DA51CED430100C310FA /* ReplaySubjectTest.swift */; };
|
||||
25F6ECBC1F48C366008552FA /* Maybe.swift in Sources */ = {isa = PBXBuildFile; fileRef = 25F6ECBB1F48C366008552FA /* Maybe.swift */; };
|
||||
25F6ECBE1F48C373008552FA /* Completable.swift in Sources */ = {isa = PBXBuildFile; fileRef = 25F6ECBD1F48C373008552FA /* Completable.swift */; };
|
||||
25F6ECC01F48C37C008552FA /* Single.swift in Sources */ = {isa = PBXBuildFile; fileRef = 25F6ECBF1F48C37C008552FA /* Single.swift */; };
|
||||
25F6ECC11F48C405008552FA /* Maybe.swift in Sources */ = {isa = PBXBuildFile; fileRef = 25F6ECBB1F48C366008552FA /* Maybe.swift */; };
|
||||
25F6ECC21F48C405008552FA /* Completable.swift in Sources */ = {isa = PBXBuildFile; fileRef = 25F6ECBD1F48C373008552FA /* Completable.swift */; };
|
||||
25F6ECC31F48C405008552FA /* Single.swift in Sources */ = {isa = PBXBuildFile; fileRef = 25F6ECBF1F48C37C008552FA /* Single.swift */; };
|
||||
25F6ECC41F48C406008552FA /* Maybe.swift in Sources */ = {isa = PBXBuildFile; fileRef = 25F6ECBB1F48C366008552FA /* Maybe.swift */; };
|
||||
25F6ECC51F48C406008552FA /* Completable.swift in Sources */ = {isa = PBXBuildFile; fileRef = 25F6ECBD1F48C373008552FA /* Completable.swift */; };
|
||||
25F6ECC61F48C406008552FA /* Single.swift in Sources */ = {isa = PBXBuildFile; fileRef = 25F6ECBF1F48C37C008552FA /* Single.swift */; };
|
||||
25F6ECC71F48C407008552FA /* Maybe.swift in Sources */ = {isa = PBXBuildFile; fileRef = 25F6ECBB1F48C366008552FA /* Maybe.swift */; };
|
||||
25F6ECC81F48C407008552FA /* Completable.swift in Sources */ = {isa = PBXBuildFile; fileRef = 25F6ECBD1F48C373008552FA /* Completable.swift */; };
|
||||
25F6ECC91F48C407008552FA /* Single.swift in Sources */ = {isa = PBXBuildFile; fileRef = 25F6ECBF1F48C37C008552FA /* Single.swift */; };
|
||||
271A97411CFC996B00D64125 /* UIViewController+Rx.swift in Sources */ = {isa = PBXBuildFile; fileRef = 271A97401CFC996B00D64125 /* UIViewController+Rx.swift */; };
|
||||
271A97441CFC9F7B00D64125 /* UIViewController+RxTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 271A97421CFC99FE00D64125 /* UIViewController+RxTests.swift */; };
|
||||
4613456F1D9A4467001ABAF2 /* UIWebView+RxTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4613456E1D9A4467001ABAF2 /* UIWebView+RxTests.swift */; };
|
||||
@ -97,6 +109,22 @@
|
||||
AAE623771C82475700FC7801 /* UIProgressView+Rx.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAE623751C82475700FC7801 /* UIProgressView+Rx.swift */; };
|
||||
B44D73EC1EE6D4A300EBFBE8 /* UIViewController+RxTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 271A97421CFC99FE00D64125 /* UIViewController+RxTests.swift */; };
|
||||
B44D73ED1EE6D57600EBFBE8 /* UIViewController+Rx.swift in Sources */ = {isa = PBXBuildFile; fileRef = 271A97401CFC996B00D64125 /* UIViewController+Rx.swift */; };
|
||||
C801DE361F6EAD3C008DB060 /* SingleTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE351F6EAD3C008DB060 /* SingleTest.swift */; };
|
||||
C801DE371F6EAD3C008DB060 /* SingleTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE351F6EAD3C008DB060 /* SingleTest.swift */; };
|
||||
C801DE381F6EAD3C008DB060 /* SingleTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE351F6EAD3C008DB060 /* SingleTest.swift */; };
|
||||
C801DE3A1F6EAD48008DB060 /* MaybeTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE391F6EAD48008DB060 /* MaybeTest.swift */; };
|
||||
C801DE3B1F6EAD48008DB060 /* MaybeTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE391F6EAD48008DB060 /* MaybeTest.swift */; };
|
||||
C801DE3C1F6EAD48008DB060 /* MaybeTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE391F6EAD48008DB060 /* MaybeTest.swift */; };
|
||||
C801DE3E1F6EAD57008DB060 /* CompletableTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE3D1F6EAD57008DB060 /* CompletableTest.swift */; };
|
||||
C801DE3F1F6EAD57008DB060 /* CompletableTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE3D1F6EAD57008DB060 /* CompletableTest.swift */; };
|
||||
C801DE401F6EAD57008DB060 /* CompletableTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE3D1F6EAD57008DB060 /* CompletableTest.swift */; };
|
||||
C801DE451F6EBB32008DB060 /* ObservableType+PrimitiveSequence.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE411F6EBB29008DB060 /* ObservableType+PrimitiveSequence.swift */; };
|
||||
C801DE461F6EBB32008DB060 /* ObservableType+PrimitiveSequence.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE411F6EBB29008DB060 /* ObservableType+PrimitiveSequence.swift */; };
|
||||
C801DE471F6EBB33008DB060 /* ObservableType+PrimitiveSequence.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE411F6EBB29008DB060 /* ObservableType+PrimitiveSequence.swift */; };
|
||||
C801DE481F6EBB33008DB060 /* ObservableType+PrimitiveSequence.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE411F6EBB29008DB060 /* ObservableType+PrimitiveSequence.swift */; };
|
||||
C801DE4A1F6EBB84008DB060 /* Observable+PrimitiveSequenceTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE491F6EBB84008DB060 /* Observable+PrimitiveSequenceTest.swift */; };
|
||||
C801DE4B1F6EBB84008DB060 /* Observable+PrimitiveSequenceTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE491F6EBB84008DB060 /* Observable+PrimitiveSequenceTest.swift */; };
|
||||
C801DE4C1F6EBB84008DB060 /* Observable+PrimitiveSequenceTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C801DE491F6EBB84008DB060 /* Observable+PrimitiveSequenceTest.swift */; };
|
||||
C8093CC51B8A72BE0088E94D /* Cancelable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C491B8A72BE0088E94D /* Cancelable.swift */; };
|
||||
C8093CC61B8A72BE0088E94D /* Cancelable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C491B8A72BE0088E94D /* Cancelable.swift */; };
|
||||
C8093CC71B8A72BE0088E94D /* AsyncLock.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C4B1B8A72BE0088E94D /* AsyncLock.swift */; };
|
||||
@ -827,9 +855,6 @@
|
||||
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 /* PrimitiveSequenceTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C850F3D31E749F5C006C417C /* PrimitiveSequenceTest.swift */; };
|
||||
C850F3D51E749F5C006C417C /* PrimitiveSequenceTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C850F3D31E749F5C006C417C /* PrimitiveSequenceTest.swift */; };
|
||||
C850F3D61E749F5C006C417C /* PrimitiveSequenceTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C850F3D31E749F5C006C417C /* PrimitiveSequenceTest.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 */; };
|
||||
@ -1716,6 +1741,9 @@
|
||||
0BA9496B1E224B9C0036DD06 /* AsyncSubjectTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AsyncSubjectTests.swift; sourceTree = "<group>"; };
|
||||
1AF67DA11CED420A00C310FA /* PublishSubjectTest.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = PublishSubjectTest.swift; sourceTree = "<group>"; };
|
||||
1AF67DA51CED430100C310FA /* ReplaySubjectTest.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ReplaySubjectTest.swift; sourceTree = "<group>"; };
|
||||
25F6ECBB1F48C366008552FA /* Maybe.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Maybe.swift; sourceTree = "<group>"; };
|
||||
25F6ECBD1F48C373008552FA /* Completable.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Completable.swift; sourceTree = "<group>"; };
|
||||
25F6ECBF1F48C37C008552FA /* Single.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Single.swift; sourceTree = "<group>"; };
|
||||
271A97401CFC996B00D64125 /* UIViewController+Rx.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "UIViewController+Rx.swift"; sourceTree = "<group>"; };
|
||||
271A97421CFC99FE00D64125 /* UIViewController+RxTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "UIViewController+RxTests.swift"; sourceTree = "<group>"; };
|
||||
4613456E1D9A4467001ABAF2 /* UIWebView+RxTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "UIWebView+RxTests.swift"; sourceTree = "<group>"; };
|
||||
@ -1748,6 +1776,11 @@
|
||||
A520FFFB1F0D291500573734 /* RxPickerViewDataSourceProxy.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = RxPickerViewDataSourceProxy.swift; sourceTree = "<group>"; };
|
||||
A5CD03891F1660F40005A376 /* RxPickerViewAdapter.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = RxPickerViewAdapter.swift; sourceTree = "<group>"; };
|
||||
AAE623751C82475700FC7801 /* UIProgressView+Rx.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "UIProgressView+Rx.swift"; sourceTree = "<group>"; };
|
||||
C801DE351F6EAD3C008DB060 /* SingleTest.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SingleTest.swift; sourceTree = "<group>"; };
|
||||
C801DE391F6EAD48008DB060 /* MaybeTest.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MaybeTest.swift; sourceTree = "<group>"; };
|
||||
C801DE3D1F6EAD57008DB060 /* CompletableTest.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CompletableTest.swift; sourceTree = "<group>"; };
|
||||
C801DE411F6EBB29008DB060 /* ObservableType+PrimitiveSequence.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "ObservableType+PrimitiveSequence.swift"; sourceTree = "<group>"; };
|
||||
C801DE491F6EBB84008DB060 /* Observable+PrimitiveSequenceTest.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Observable+PrimitiveSequenceTest.swift"; sourceTree = "<group>"; };
|
||||
C809396D1B8A71760088E94D /* RxCocoa.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = RxCocoa.framework; sourceTree = BUILT_PRODUCTS_DIR; };
|
||||
C80939E71B8A71840088E94D /* RxCocoa.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = RxCocoa.framework; sourceTree = BUILT_PRODUCTS_DIR; };
|
||||
C8093BC71B8A71F00088E94D /* RxBlocking.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = RxBlocking.framework; sourceTree = BUILT_PRODUCTS_DIR; };
|
||||
@ -1997,7 +2030,6 @@
|
||||
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 /* PrimitiveSequenceTest.swift */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.swift; path = PrimitiveSequenceTest.swift; sourceTree = "<group>"; tabWidth = 4; };
|
||||
C85106871C2D550E0075150C /* String+Rx.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "String+Rx.swift"; sourceTree = "<group>"; };
|
||||
C85217E81E3374970015DD38 /* GroupedObservable.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = GroupedObservable.swift; sourceTree = "<group>"; };
|
||||
C85217F41E33F9D70015DD38 /* RecursiveLock.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; lineEnding = 0; path = RecursiveLock.swift; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.swift; };
|
||||
@ -2610,9 +2642,13 @@
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
C81A09861E6C702700900B3B /* PrimitiveSequence.swift */,
|
||||
25F6ECBF1F48C37C008552FA /* Single.swift */,
|
||||
25F6ECBB1F48C366008552FA /* Maybe.swift */,
|
||||
25F6ECBD1F48C373008552FA /* Completable.swift */,
|
||||
C89814751E75A18A0035949C /* PrimitiveSequence+Zip+arity.tt */,
|
||||
C89814771E75A7D70035949C /* PrimitiveSequence+Zip+arity.swift */,
|
||||
C8A53ADF1F09178700490535 /* Completable+AndThen.swift */,
|
||||
C801DE411F6EBB29008DB060 /* ObservableType+PrimitiveSequence.swift */,
|
||||
);
|
||||
path = Traits;
|
||||
sourceTree = "<group>";
|
||||
@ -2800,7 +2836,6 @@
|
||||
C83509111C38706D0027C24C /* Observable+ZipTests+arity.swift */,
|
||||
C83509121C38706D0027C24C /* Observable+ZipTests+arity.tt */,
|
||||
C83509181C38706D0027C24C /* ObserverTests.swift */,
|
||||
C850F3D31E749F5C006C417C /* PrimitiveSequenceTest.swift */,
|
||||
C898147D1E75AD380035949C /* PrimitiveSequenceTest+zip+arity.swift */,
|
||||
C898147C1E75A98A0035949C /* PrimitiveSequenceTest+zip+arity.tt */,
|
||||
1AF67DA11CED420A00C310FA /* PublishSubjectTest.swift */,
|
||||
@ -2813,6 +2848,10 @@
|
||||
C835091B1C38706D0027C24C /* VariableTest.swift */,
|
||||
C835091C1C38706D0027C24C /* VirtualSchedulerTest.swift */,
|
||||
C8B0F70C1F530A1700548EBE /* SharingSchedulerTests.swift */,
|
||||
C801DE351F6EAD3C008DB060 /* SingleTest.swift */,
|
||||
C801DE391F6EAD48008DB060 /* MaybeTest.swift */,
|
||||
C801DE3D1F6EAD57008DB060 /* CompletableTest.swift */,
|
||||
C801DE491F6EBB84008DB060 /* Observable+PrimitiveSequenceTest.swift */,
|
||||
);
|
||||
path = RxSwiftTests;
|
||||
sourceTree = "<group>";
|
||||
@ -4264,6 +4303,7 @@
|
||||
C8C217D51CB7100E0038A2E6 /* UITableView+RxTests.swift in Sources */,
|
||||
C835092E1C38706E0027C24C /* ControlEventTests.swift in Sources */,
|
||||
844BC8BB1CE5024500F5C7CB /* UIPickerView+RxTests.swift in Sources */,
|
||||
C801DE361F6EAD3C008DB060 /* SingleTest.swift in Sources */,
|
||||
C896A68B1E6B7DC60073A3A8 /* Observable+CombineLatestTests.swift in Sources */,
|
||||
C820A9AA1EB505A800D431BC /* Observable+WithLatestFromTests.swift in Sources */,
|
||||
C8D970E61F532FD30058F2FE /* SharedSequence+Test.swift in Sources */,
|
||||
@ -4274,6 +4314,7 @@
|
||||
C820A9761EB4F92100D431BC /* Observable+GenerateTests.swift in Sources */,
|
||||
C8353CDC1DA19BA000BE3F5C /* MessageProcessingStage.swift in Sources */,
|
||||
C820AA0A1EB513C800D431BC /* Observable+WindowTests.swift in Sources */,
|
||||
C801DE3A1F6EAD48008DB060 /* MaybeTest.swift in Sources */,
|
||||
C8C4F16B1DE9D4C100003FA7 /* UIAlertAction+RxTests.swift in Sources */,
|
||||
1AF67DA61CED430100C310FA /* ReplaySubjectTest.swift in Sources */,
|
||||
C835095A1C38706E0027C24C /* Observable+ZipTests+arity.swift in Sources */,
|
||||
@ -4286,6 +4327,7 @@
|
||||
C85218011E33FC160015DD38 /* RecursiveLock.swift in Sources */,
|
||||
C822BACA1DB4058000F98810 /* Event+Test.swift in Sources */,
|
||||
C83509421C38706E0027C24C /* MainThreadPrimitiveHotObservable.swift in Sources */,
|
||||
C801DE4A1F6EBB84008DB060 /* Observable+PrimitiveSequenceTest.swift in Sources */,
|
||||
C820A98A1EB4FBD600D431BC /* Observable+CatchTests.swift in Sources */,
|
||||
C835093A1C38706E0027C24C /* RuntimeStateSnapshot.swift in Sources */,
|
||||
C8561B661DFE1169005E97F1 /* ExampleTests.swift in Sources */,
|
||||
@ -4336,6 +4378,7 @@
|
||||
C820A9E61EB50DB900D431BC /* Observable+TimerTests.swift in Sources */,
|
||||
C8353CE91DA19BC500BE3F5C /* TestErrors.swift in Sources */,
|
||||
C820A9521EB4ECC000D431BC /* Observable+ToArrayTests.swift in Sources */,
|
||||
C801DE3E1F6EAD57008DB060 /* CompletableTest.swift in Sources */,
|
||||
C83509581C38706E0027C24C /* Observable+CombineLatestTests+arity.swift in Sources */,
|
||||
C8A53AE51F09292A00490535 /* Completable+AndThen.swift in Sources */,
|
||||
C820A99A1EB5001C00D431BC /* Observable+MergeTests.swift in Sources */,
|
||||
@ -4400,7 +4443,6 @@
|
||||
C81A097D1E6C27A100900B3B /* Observable+ZipTests.swift in Sources */,
|
||||
C83509321C38706E0027C24C /* DelegateProxyTest.swift in Sources */,
|
||||
0BA9496C1E224B9C0036DD06 /* AsyncSubjectTests.swift in Sources */,
|
||||
C850F3D41E749F5C006C417C /* PrimitiveSequenceTest.swift in Sources */,
|
||||
C8F27DC01CE68DA600D5FB4F /* UITextView+RxTests.swift in Sources */,
|
||||
C820A9B21EB507D300D431BC /* Observable+TakeWhileTests.swift in Sources */,
|
||||
C820A9FA1EB510D500D431BC /* Observable+MaterializeTests.swift in Sources */,
|
||||
@ -4453,6 +4495,7 @@
|
||||
C8C4F17E1DE9DF0200003FA7 /* UILabel+RxTests.swift in Sources */,
|
||||
C83509C01C3875220027C24C /* DelegateProxyTest.swift in Sources */,
|
||||
C820A9F31EB5109300D431BC /* Observable+DefaultIfEmpty.swift in Sources */,
|
||||
C801DE371F6EAD3C008DB060 /* SingleTest.swift in Sources */,
|
||||
C8350A131C38756A0027C24C /* Observable+SubscriptionTest.swift in Sources */,
|
||||
C83509E01C3875500027C24C /* Observable+Extensions.swift in Sources */,
|
||||
C8C4F1801DE9DF0200003FA7 /* UIProgressView+RxTests.swift in Sources */,
|
||||
@ -4479,6 +4522,7 @@
|
||||
1AF67DA71CED430100C310FA /* ReplaySubjectTest.swift in Sources */,
|
||||
C820A9531EB4ECC000D431BC /* Observable+ToArrayTests.swift in Sources */,
|
||||
C81B6AAB1DB2C15C0047CF86 /* Platform.Darwin.swift in Sources */,
|
||||
C801DE3B1F6EAD48008DB060 /* MaybeTest.swift in Sources */,
|
||||
C820A98B1EB4FBD600D431BC /* Observable+CatchTests.swift in Sources */,
|
||||
C83509F11C3875580027C24C /* TestConnectableObservable.swift in Sources */,
|
||||
C83509F51C38755D0027C24C /* BehaviorSubjectTest.swift in Sources */,
|
||||
@ -4500,6 +4544,7 @@
|
||||
C8350A161C38756A0027C24C /* QueueTests.swift in Sources */,
|
||||
C820A9DB1EB50CAA00D431BC /* Observable+DoOnTests.swift in Sources */,
|
||||
C820A9971EB4FF7000D431BC /* Observable+ConcatTests.swift in Sources */,
|
||||
C801DE3F1F6EAD57008DB060 /* CompletableTest.swift in Sources */,
|
||||
C898147F1E75AD380035949C /* PrimitiveSequenceTest+zip+arity.swift in Sources */,
|
||||
C89CFA0D1DAAB4670079D23B /* RxTest.swift in Sources */,
|
||||
C83509C51C3875220027C24C /* NotificationCenterTests.swift in Sources */,
|
||||
@ -4550,8 +4595,8 @@
|
||||
C820A9E31EB50D6C00D431BC /* Observable+SampleTests.swift in Sources */,
|
||||
C8D970EA1F532FD30058F2FE /* Driver+Test.swift in Sources */,
|
||||
7FE849481C5D0D6B00845C0E /* UIRefreshControl+RxTests.swift in Sources */,
|
||||
C850F3D51E749F5C006C417C /* PrimitiveSequenceTest.swift in Sources */,
|
||||
C820A9FB1EB510D500D431BC /* Observable+MaterializeTests.swift in Sources */,
|
||||
C801DE4B1F6EBB84008DB060 /* Observable+PrimitiveSequenceTest.swift in Sources */,
|
||||
C820AA0F1EB5140100D431BC /* Observable+TimeoutTests.swift in Sources */,
|
||||
C820A9BB1EB5097700D431BC /* Observable+TakeTests.swift in Sources */,
|
||||
C820A96B1EB4F64800D431BC /* Observable+JustTests.swift in Sources */,
|
||||
@ -4584,7 +4629,6 @@
|
||||
C820A9781EB4F92100D431BC /* Observable+GenerateTests.swift in Sources */,
|
||||
0BA9496E1E224B9C0036DD06 /* AsyncSubjectTests.swift in Sources */,
|
||||
C83509E71C3875580027C24C /* PrimitiveHotObservable.swift in Sources */,
|
||||
C850F3D61E749F5C006C417C /* PrimitiveSequenceTest.swift in Sources */,
|
||||
C83509CE1C3875230027C24C /* NSObject+RxTests.swift in Sources */,
|
||||
C820A9D81EB50C5C00D431BC /* Observable+DistinctUntilChangedTests.swift in Sources */,
|
||||
C820A9B81EB5081400D431BC /* Observable+MapTests.swift in Sources */,
|
||||
@ -4642,6 +4686,7 @@
|
||||
C8350A231C38756B0027C24C /* VirtualSchedulerTest.swift in Sources */,
|
||||
C83509E51C3875580027C24C /* MySubject.swift in Sources */,
|
||||
C820A94C1EB4E75E00D431BC /* Observable+AmbTests.swift in Sources */,
|
||||
C801DE4C1F6EBB84008DB060 /* Observable+PrimitiveSequenceTest.swift in Sources */,
|
||||
C83509B91C38750D0027C24C /* ControlPropertyTests.swift in Sources */,
|
||||
C820AA081EB5139C00D431BC /* Observable+BufferTests.swift in Sources */,
|
||||
C820A9D01EB50AD400D431BC /* Observable+SingleTests.swift in Sources */,
|
||||
@ -4692,6 +4737,7 @@
|
||||
C820A99C1EB5001C00D431BC /* Observable+MergeTests.swift in Sources */,
|
||||
C8350A051C38755E0027C24C /* DisposableTest.swift in Sources */,
|
||||
C820A96C1EB4F64800D431BC /* Observable+JustTests.swift in Sources */,
|
||||
C801DE401F6EAD57008DB060 /* CompletableTest.swift in Sources */,
|
||||
C820A9741EB4F84000D431BC /* Observable+OptionalTests.swift in Sources */,
|
||||
C820A9C41EB509FC00D431BC /* Observable+SkipTests.swift in Sources */,
|
||||
C820A9701EB4F7AC00D431BC /* Observable+SequenceTests.swift in Sources */,
|
||||
@ -4699,8 +4745,10 @@
|
||||
C8350A211C38756B0027C24C /* SubjectConcurrencyTest.swift in Sources */,
|
||||
C8353CEE1DA19BC500BE3F5C /* XCTest+AllTests.swift in Sources */,
|
||||
C8D970E51F532FD30058F2FE /* Signal+Test.swift in Sources */,
|
||||
C801DE381F6EAD3C008DB060 /* SingleTest.swift in Sources */,
|
||||
C81B6AAF1DB2C15C0047CF86 /* Platform.Linux.swift in Sources */,
|
||||
C83509B51C3875050027C24C /* Control+RxTests+Cocoa.swift in Sources */,
|
||||
C801DE3C1F6EAD48008DB060 /* MaybeTest.swift in Sources */,
|
||||
C8C4F1771DE9D84900003FA7 /* NSButton+RxTests.swift in Sources */,
|
||||
C820A9A81EB5056C00D431BC /* Observable+SkipUntilTests.swift in Sources */,
|
||||
C83509E61C3875580027C24C /* Observable.Extensions.swift in Sources */,
|
||||
@ -4730,10 +4778,12 @@
|
||||
C8093CCC1B8A72BE0088E94D /* ConnectableObservableType.swift in Sources */,
|
||||
C820A8811EB4DA5A00D431BC /* Filter.swift in Sources */,
|
||||
C820A86D1EB4DA5A00D431BC /* ElementAt.swift in Sources */,
|
||||
25F6ECC11F48C405008552FA /* Maybe.swift in Sources */,
|
||||
C83D73BD1C1DBAEE003DC470 /* InvocableScheduledItem.swift in Sources */,
|
||||
C8093CE61B8A72BE0088E94D /* NopDisposable.swift in Sources */,
|
||||
C89814791E75A7E70035949C /* PrimitiveSequence+Zip+arity.swift in Sources */,
|
||||
C86781751DB8129E00B2029A /* InfiniteSequence.swift in Sources */,
|
||||
C801DE461F6EBB32008DB060 /* ObservableType+PrimitiveSequence.swift in Sources */,
|
||||
C820A8A51EB4DA5A00D431BC /* DistinctUntilChanged.swift in Sources */,
|
||||
C8093CD41B8A72BE0088E94D /* Disposable.swift in Sources */,
|
||||
C820A8351EB4DA5900D431BC /* Delay.swift in Sources */,
|
||||
@ -4776,6 +4826,7 @@
|
||||
C83D73C11C1DBAEE003DC470 /* InvocableType.swift in Sources */,
|
||||
C820A9151EB4DA5A00D431BC /* ToArray.swift in Sources */,
|
||||
C820A8751EB4DA5A00D431BC /* SkipWhile.swift in Sources */,
|
||||
25F6ECC21F48C405008552FA /* Completable.swift in Sources */,
|
||||
C820A91D1EB4DA5A00D431BC /* AsSingle.swift in Sources */,
|
||||
C8093D741B8A72BE0088E94D /* ObserverBase.swift in Sources */,
|
||||
C85106891C2D550E0075150C /* String+Rx.swift in Sources */,
|
||||
@ -4828,6 +4879,7 @@
|
||||
C820A8691EB4DA5A00D431BC /* SingleAsync.swift in Sources */,
|
||||
C81A09881E6C702700900B3B /* PrimitiveSequence.swift in Sources */,
|
||||
C8093CD61B8A72BE0088E94D /* AnonymousDisposable.swift in Sources */,
|
||||
25F6ECC31F48C405008552FA /* Single.swift in Sources */,
|
||||
C820A8A11EB4DA5A00D431BC /* Do.swift in Sources */,
|
||||
C8093D901B8A72BE0088E94D /* ConcurrentDispatchQueueScheduler.swift in Sources */,
|
||||
C820A83D1EB4DA5900D431BC /* Window.swift in Sources */,
|
||||
@ -4965,10 +5017,12 @@
|
||||
C8093CCB1B8A72BE0088E94D /* ConnectableObservableType.swift in Sources */,
|
||||
C820A8801EB4DA5A00D431BC /* Filter.swift in Sources */,
|
||||
C820A86C1EB4DA5A00D431BC /* ElementAt.swift in Sources */,
|
||||
25F6ECBC1F48C366008552FA /* Maybe.swift in Sources */,
|
||||
C83D73BC1C1DBAEE003DC470 /* InvocableScheduledItem.swift in Sources */,
|
||||
C8093CE51B8A72BE0088E94D /* NopDisposable.swift in Sources */,
|
||||
C86781741DB8129E00B2029A /* InfiniteSequence.swift in Sources */,
|
||||
C8093CD31B8A72BE0088E94D /* Disposable.swift in Sources */,
|
||||
C801DE451F6EBB32008DB060 /* ObservableType+PrimitiveSequence.swift in Sources */,
|
||||
C820A8A41EB4DA5A00D431BC /* DistinctUntilChanged.swift in Sources */,
|
||||
C8093CED1B8A72BE0088E94D /* SingleAssignmentDisposable.swift in Sources */,
|
||||
C820A8341EB4DA5900D431BC /* Delay.swift in Sources */,
|
||||
@ -5011,6 +5065,7 @@
|
||||
C85106881C2D550E0075150C /* String+Rx.swift in Sources */,
|
||||
C820A9141EB4DA5A00D431BC /* ToArray.swift in Sources */,
|
||||
C820A8741EB4DA5A00D431BC /* SkipWhile.swift in Sources */,
|
||||
25F6ECBE1F48C373008552FA /* Completable.swift in Sources */,
|
||||
C820A91C1EB4DA5A00D431BC /* AsSingle.swift in Sources */,
|
||||
C8BF34CF1C2E426800416CAE /* Platform.Linux.swift in Sources */,
|
||||
C8093D791B8A72BE0088E94D /* TailRecursiveSink.swift in Sources */,
|
||||
@ -5063,6 +5118,7 @@
|
||||
C820A8681EB4DA5A00D431BC /* SingleAsync.swift in Sources */,
|
||||
C81A09871E6C702700900B3B /* PrimitiveSequence.swift in Sources */,
|
||||
C8093D8F1B8A72BE0088E94D /* ConcurrentDispatchQueueScheduler.swift in Sources */,
|
||||
25F6ECC01F48C37C008552FA /* Single.swift in Sources */,
|
||||
C820A8A01EB4DA5A00D431BC /* Do.swift in Sources */,
|
||||
C8093D9F1B8A72BE0088E94D /* BehaviorSubject.swift in Sources */,
|
||||
C820A83C1EB4DA5900D431BC /* Window.swift in Sources */,
|
||||
@ -5124,10 +5180,12 @@
|
||||
C8F0BF931BBBFB8B001B112F /* ConnectableObservableType.swift in Sources */,
|
||||
C820A8831EB4DA5A00D431BC /* Filter.swift in Sources */,
|
||||
C820A86F1EB4DA5A00D431BC /* ElementAt.swift in Sources */,
|
||||
25F6ECC71F48C407008552FA /* Maybe.swift in Sources */,
|
||||
C83D73BF1C1DBAEE003DC470 /* InvocableScheduledItem.swift in Sources */,
|
||||
C8F0BF951BBBFB8B001B112F /* NopDisposable.swift in Sources */,
|
||||
C898147B1E75A7E80035949C /* PrimitiveSequence+Zip+arity.swift in Sources */,
|
||||
C86781771DB8129E00B2029A /* InfiniteSequence.swift in Sources */,
|
||||
C801DE481F6EBB33008DB060 /* ObservableType+PrimitiveSequence.swift in Sources */,
|
||||
C820A8A71EB4DA5A00D431BC /* DistinctUntilChanged.swift in Sources */,
|
||||
C8F0BF961BBBFB8B001B112F /* Disposable.swift in Sources */,
|
||||
C820A8371EB4DA5900D431BC /* Delay.swift in Sources */,
|
||||
@ -5170,6 +5228,7 @@
|
||||
C83D73C31C1DBAEE003DC470 /* InvocableType.swift in Sources */,
|
||||
C820A9171EB4DA5A00D431BC /* ToArray.swift in Sources */,
|
||||
C820A8771EB4DA5A00D431BC /* SkipWhile.swift in Sources */,
|
||||
25F6ECC81F48C407008552FA /* Completable.swift in Sources */,
|
||||
C820A91F1EB4DA5A00D431BC /* AsSingle.swift in Sources */,
|
||||
C8F0BFAF1BBBFB8B001B112F /* ObserverBase.swift in Sources */,
|
||||
C851068B1C2D550E0075150C /* String+Rx.swift in Sources */,
|
||||
@ -5222,6 +5281,7 @@
|
||||
C820A86B1EB4DA5A00D431BC /* SingleAsync.swift in Sources */,
|
||||
C81A098A1E6C702700900B3B /* PrimitiveSequence.swift in Sources */,
|
||||
C8F0BFD01BBBFB8B001B112F /* AnonymousDisposable.swift in Sources */,
|
||||
25F6ECC91F48C407008552FA /* Single.swift in Sources */,
|
||||
C820A8A31EB4DA5A00D431BC /* Do.swift in Sources */,
|
||||
C8F0BFD11BBBFB8B001B112F /* ConcurrentDispatchQueueScheduler.swift in Sources */,
|
||||
C820A83F1EB4DA5900D431BC /* Window.swift in Sources */,
|
||||
@ -5491,10 +5551,12 @@
|
||||
D2EBEADF1BB9B697003A27DC /* Errors.swift in Sources */,
|
||||
C820A8821EB4DA5A00D431BC /* Filter.swift in Sources */,
|
||||
C820A86E1EB4DA5A00D431BC /* ElementAt.swift in Sources */,
|
||||
25F6ECC41F48C406008552FA /* Maybe.swift in Sources */,
|
||||
C83D73BE1C1DBAEE003DC470 /* InvocableScheduledItem.swift in Sources */,
|
||||
D2EBEAF01BB9B6AE003A27DC /* AnonymousDisposable.swift in Sources */,
|
||||
D2EBEAEB1BB9B69E003A27DC /* AsyncLock.swift in Sources */,
|
||||
C898147A1E75A7E80035949C /* PrimitiveSequence+Zip+arity.swift in Sources */,
|
||||
C801DE471F6EBB33008DB060 /* ObservableType+PrimitiveSequence.swift in Sources */,
|
||||
C820A8A61EB4DA5A00D431BC /* DistinctUntilChanged.swift in Sources */,
|
||||
C86781761DB8129E00B2029A /* InfiniteSequence.swift in Sources */,
|
||||
C820A8361EB4DA5900D431BC /* Delay.swift in Sources */,
|
||||
@ -5537,6 +5599,7 @@
|
||||
C820A89A1EB4DA5A00D431BC /* Catch.swift in Sources */,
|
||||
D2EBEB421BB9B6DE003A27DC /* ReplaySubject.swift in Sources */,
|
||||
C820A9161EB4DA5A00D431BC /* ToArray.swift in Sources */,
|
||||
25F6ECC51F48C406008552FA /* Completable.swift in Sources */,
|
||||
C820A8761EB4DA5A00D431BC /* SkipWhile.swift in Sources */,
|
||||
C820A91E1EB4DA5A00D431BC /* AsSingle.swift in Sources */,
|
||||
D2EBEB381BB9B6D8003A27DC /* ConcurrentDispatchQueueScheduler.swift in Sources */,
|
||||
@ -5589,6 +5652,7 @@
|
||||
C820A86A1EB4DA5A00D431BC /* SingleAsync.swift in Sources */,
|
||||
D2EBEADD1BB9B697003A27DC /* ConnectableObservableType.swift in Sources */,
|
||||
D2EBEB361BB9B6D2003A27DC /* TailRecursiveSink.swift in Sources */,
|
||||
25F6ECC61F48C406008552FA /* Single.swift in Sources */,
|
||||
C820A8A21EB4DA5A00D431BC /* Do.swift in Sources */,
|
||||
D2EBEAE91BB9B697003A27DC /* RxMutableBox.swift in Sources */,
|
||||
C820A83E1EB4DA5900D431BC /* Window.swift in Sources */,
|
||||
|
||||
245
RxSwift/Traits/Completable.swift
Normal file
245
RxSwift/Traits/Completable.swift
Normal file
@ -0,0 +1,245 @@
|
||||
//
|
||||
// Completable.swift
|
||||
// RxSwift
|
||||
//
|
||||
// Created by sergdort on 19/08/2017.
|
||||
// Copyright © 2017 Krunoslav Zaher. All rights reserved.
|
||||
//
|
||||
|
||||
/// Sequence containing 0 elements
|
||||
public enum CompletableTrait { }
|
||||
/// Represents a push style sequence containing 0 elements.
|
||||
public typealias Completable = PrimitiveSequence<CompletableTrait, Swift.Never>
|
||||
|
||||
public enum CompletableEvent {
|
||||
/// Sequence terminated with an error. (underlying observable sequence emits: `.error(Error)`)
|
||||
case error(Swift.Error)
|
||||
|
||||
/// Sequence completed successfully.
|
||||
case completed
|
||||
}
|
||||
|
||||
public extension PrimitiveSequenceType where TraitType == CompletableTrait, ElementType == Swift.Never {
|
||||
public typealias CompletableObserver = (CompletableEvent) -> ()
|
||||
|
||||
/**
|
||||
Creates an observable sequence from a specified subscribe method implementation.
|
||||
|
||||
- seealso: [create operator on reactivex.io](http://reactivex.io/documentation/operators/create.html)
|
||||
|
||||
- parameter subscribe: Implementation of the resulting observable sequence's `subscribe` method.
|
||||
- returns: The observable sequence with the specified implementation for the `subscribe` method.
|
||||
*/
|
||||
public static func create(subscribe: @escaping (@escaping CompletableObserver) -> Disposable) -> PrimitiveSequence<TraitType, ElementType> {
|
||||
let source = Observable<ElementType>.create { observer in
|
||||
return subscribe { event in
|
||||
switch event {
|
||||
case .error(let error):
|
||||
observer.on(.error(error))
|
||||
case .completed:
|
||||
observer.on(.completed)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return PrimitiveSequence(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Subscribes `observer` to receive events for this sequence.
|
||||
|
||||
- returns: Subscription for `observer` that can be used to cancel production of sequence elements and free resources.
|
||||
*/
|
||||
public func subscribe(_ observer: @escaping (CompletableEvent) -> ()) -> Disposable {
|
||||
var stopped = false
|
||||
return self.primitiveSequence.asObservable().subscribe { event in
|
||||
if stopped { return }
|
||||
stopped = true
|
||||
|
||||
switch event {
|
||||
case .next:
|
||||
rxFatalError("Completables can't emit values")
|
||||
case .error(let error):
|
||||
observer(.error(error))
|
||||
case .completed:
|
||||
observer(.completed)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Subscribes a completion handler and an error handler for this sequence.
|
||||
|
||||
- parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
|
||||
- parameter onError: Action to invoke upon errored termination of the observable sequence.
|
||||
- returns: Subscription object used to unsubscribe from the observable sequence.
|
||||
*/
|
||||
public func subscribe(onCompleted: (() -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil) -> Disposable {
|
||||
return self.primitiveSequence.subscribe { event in
|
||||
switch event {
|
||||
case .error(let error):
|
||||
onError?(error)
|
||||
case .completed:
|
||||
onCompleted?()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public extension PrimitiveSequenceType where TraitType == CompletableTrait, ElementType == Swift.Never {
|
||||
/**
|
||||
Returns an observable sequence that terminates with an `error`.
|
||||
|
||||
- seealso: [throw operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
|
||||
|
||||
- returns: The observable sequence that terminates with specified error.
|
||||
*/
|
||||
public static func error(_ error: Swift.Error) -> Completable {
|
||||
return PrimitiveSequence(raw: Observable.error(error))
|
||||
}
|
||||
|
||||
/**
|
||||
Returns a non-terminating observable sequence, which can be used to denote an infinite duration.
|
||||
|
||||
- seealso: [never operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
|
||||
|
||||
- returns: An observable sequence whose observers will never get called.
|
||||
*/
|
||||
public static func never() -> Completable {
|
||||
return PrimitiveSequence(raw: Observable.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() -> Completable {
|
||||
return Completable(raw: Observable.empty())
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public extension PrimitiveSequenceType where TraitType == CompletableTrait, ElementType == Swift.Never {
|
||||
/**
|
||||
Invokes an action for each event in the observable sequence, and propagates all observer messages through the result sequence.
|
||||
|
||||
- seealso: [do operator on reactivex.io](http://reactivex.io/documentation/operators/do.html)
|
||||
|
||||
- parameter onNext: Action to invoke for each element in the observable sequence.
|
||||
- parameter onError: Action to invoke upon errored termination of the observable sequence.
|
||||
- parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
|
||||
- parameter onSubscribe: Action to invoke before subscribing to source observable sequence.
|
||||
- parameter onSubscribed: Action to invoke after subscribing to source observable sequence.
|
||||
- parameter onDispose: Action to invoke after subscription to source observable has been disposed for any reason. It can be either because sequence terminates for some reason or observer subscription being disposed.
|
||||
- returns: The source sequence with the side-effecting behavior applied.
|
||||
*/
|
||||
public func `do`(onError: ((Swift.Error) throws -> Void)? = nil,
|
||||
onCompleted: (() throws -> Void)? = nil,
|
||||
onSubscribe: (() -> ())? = nil,
|
||||
onSubscribed: (() -> ())? = nil,
|
||||
onDispose: (() -> ())? = nil)
|
||||
-> Completable {
|
||||
return Completable(raw: primitiveSequence.source.do(
|
||||
onError: onError,
|
||||
onCompleted: onCompleted,
|
||||
onSubscribe: onSubscribe,
|
||||
onSubscribed: onSubscribed,
|
||||
onDispose: onDispose)
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Concatenates the second observable sequence to `self` upon successful termination of `self`.
|
||||
|
||||
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
|
||||
|
||||
- parameter second: Second observable sequence.
|
||||
- returns: An observable sequence that contains the elements of `self`, followed by those of the second sequence.
|
||||
*/
|
||||
public func concat(_ second: Completable) -> Completable {
|
||||
return Completable.concat(primitiveSequence, second)
|
||||
}
|
||||
|
||||
/**
|
||||
Concatenates all observable sequences in the given sequence, as long as the previous observable sequence terminated successfully.
|
||||
|
||||
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
|
||||
|
||||
- returns: An observable sequence that contains the elements of each given sequence, in sequential order.
|
||||
*/
|
||||
public static func concat<S: Sequence>(_ sequence: S) -> Completable
|
||||
where S.Iterator.Element == Completable {
|
||||
let source = Observable.concat(sequence.lazy.map { $0.asObservable() })
|
||||
return Completable(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Concatenates all observable sequences in the given sequence, as long as the previous observable sequence terminated successfully.
|
||||
|
||||
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
|
||||
|
||||
- returns: An observable sequence that contains the elements of each given sequence, in sequential order.
|
||||
*/
|
||||
public static func concat<C: Collection>(_ collection: C) -> Completable
|
||||
where C.Iterator.Element == Completable {
|
||||
let source = Observable.concat(collection.map { $0.asObservable() })
|
||||
return Completable(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Concatenates all observable sequences in the given sequence, as long as the previous observable sequence terminated successfully.
|
||||
|
||||
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
|
||||
|
||||
- returns: An observable sequence that contains the elements of each given sequence, in sequential order.
|
||||
*/
|
||||
public static func concat(_ sources: Completable ...) -> Completable {
|
||||
let source = Observable.concat(sources.map { $0.asObservable() })
|
||||
return Completable(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Merges elements from all observable sequences from collection into a single observable sequence.
|
||||
|
||||
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
|
||||
|
||||
- parameter sources: Collection of observable sequences to merge.
|
||||
- returns: The observable sequence that merges the elements of the observable sequences.
|
||||
*/
|
||||
public static func merge<C: Collection>(_ sources: C) -> Completable
|
||||
where C.Iterator.Element == Completable {
|
||||
let source = Observable.merge(sources.map { $0.asObservable() })
|
||||
return Completable(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Merges elements from all observable sequences from array into a single observable sequence.
|
||||
|
||||
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
|
||||
|
||||
- parameter sources: Array of observable sequences to merge.
|
||||
- returns: The observable sequence that merges the elements of the observable sequences.
|
||||
*/
|
||||
public static func merge(_ sources: [Completable]) -> Completable {
|
||||
let source = Observable.merge(sources.map { $0.asObservable() })
|
||||
return Completable(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Merges elements from all observable sequences into a single observable sequence.
|
||||
|
||||
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
|
||||
|
||||
- parameter sources: Collection of observable sequences to merge.
|
||||
- returns: The observable sequence that merges the elements of the observable sequences.
|
||||
*/
|
||||
public static func merge(_ sources: Completable...) -> Completable {
|
||||
let source = Observable.merge(sources.map { $0.asObservable() })
|
||||
return Completable(raw: source)
|
||||
}
|
||||
}
|
||||
230
RxSwift/Traits/Maybe.swift
Normal file
230
RxSwift/Traits/Maybe.swift
Normal file
@ -0,0 +1,230 @@
|
||||
//
|
||||
// Maybe.swift
|
||||
// RxSwift
|
||||
//
|
||||
// Created by sergdort on 19/08/2017.
|
||||
// Copyright © 2017 Krunoslav Zaher. All rights reserved.
|
||||
//
|
||||
|
||||
/// Sequence containing 0 or 1 elements
|
||||
public enum MaybeTrait { }
|
||||
/// Represents a push style sequence containing 0 or 1 element.
|
||||
public typealias Maybe<Element> = PrimitiveSequence<MaybeTrait, Element>
|
||||
|
||||
public enum MaybeEvent<Element> {
|
||||
/// One and only sequence element is produced. (underlying observable sequence emits: `.next(Element)`, `.completed`)
|
||||
case success(Element)
|
||||
|
||||
/// Sequence terminated with an error. (underlying observable sequence emits: `.error(Error)`)
|
||||
case error(Swift.Error)
|
||||
|
||||
/// Sequence completed successfully.
|
||||
case completed
|
||||
}
|
||||
|
||||
public extension PrimitiveSequenceType where TraitType == MaybeTrait {
|
||||
public typealias MaybeObserver = (MaybeEvent<ElementType>) -> ()
|
||||
|
||||
/**
|
||||
Creates an observable sequence from a specified subscribe method implementation.
|
||||
|
||||
- seealso: [create operator on reactivex.io](http://reactivex.io/documentation/operators/create.html)
|
||||
|
||||
- parameter subscribe: Implementation of the resulting observable sequence's `subscribe` method.
|
||||
- returns: The observable sequence with the specified implementation for the `subscribe` method.
|
||||
*/
|
||||
public static func create(subscribe: @escaping (@escaping MaybeObserver) -> Disposable) -> PrimitiveSequence<TraitType, ElementType> {
|
||||
let source = Observable<ElementType>.create { observer in
|
||||
return subscribe { event in
|
||||
switch event {
|
||||
case .success(let element):
|
||||
observer.on(.next(element))
|
||||
observer.on(.completed)
|
||||
case .error(let error):
|
||||
observer.on(.error(error))
|
||||
case .completed:
|
||||
observer.on(.completed)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return PrimitiveSequence(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Subscribes `observer` to receive events for this sequence.
|
||||
|
||||
- returns: Subscription for `observer` that can be used to cancel production of sequence elements and free resources.
|
||||
*/
|
||||
public func subscribe(_ observer: @escaping (MaybeEvent<ElementType>) -> ()) -> Disposable {
|
||||
var stopped = false
|
||||
return self.primitiveSequence.asObservable().subscribe { event in
|
||||
if stopped { return }
|
||||
stopped = true
|
||||
|
||||
switch event {
|
||||
case .next(let element):
|
||||
observer(.success(element))
|
||||
case .error(let error):
|
||||
observer(.error(error))
|
||||
case .completed:
|
||||
observer(.completed)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Subscribes a success handler, an error handler, and a completion handler for this sequence.
|
||||
|
||||
- parameter onSuccess: Action to invoke for each element in the observable sequence.
|
||||
- parameter onError: Action to invoke upon errored termination of the observable sequence.
|
||||
- parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
|
||||
- returns: Subscription object used to unsubscribe from the observable sequence.
|
||||
*/
|
||||
public func subscribe(onSuccess: ((ElementType) -> Void)? = nil,
|
||||
onError: ((Swift.Error) -> Void)? = nil,
|
||||
onCompleted: (() -> Void)? = nil) -> Disposable {
|
||||
return self.primitiveSequence.subscribe { event in
|
||||
switch event {
|
||||
case .success(let element):
|
||||
onSuccess?(element)
|
||||
case .error(let error):
|
||||
onError?(error)
|
||||
case .completed:
|
||||
onCompleted?()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public extension PrimitiveSequenceType where TraitType == MaybeTrait {
|
||||
/**
|
||||
Returns an observable sequence that contains a single element.
|
||||
|
||||
- seealso: [just operator on reactivex.io](http://reactivex.io/documentation/operators/just.html)
|
||||
|
||||
- parameter element: Single element in the resulting observable sequence.
|
||||
- returns: An observable sequence containing the single specified element.
|
||||
*/
|
||||
public static func just(_ element: ElementType) -> Maybe<ElementType> {
|
||||
return Maybe(raw: Observable.just(element))
|
||||
}
|
||||
|
||||
/**
|
||||
Returns an observable sequence that contains a single element.
|
||||
|
||||
- seealso: [just operator on reactivex.io](http://reactivex.io/documentation/operators/just.html)
|
||||
|
||||
- parameter element: Single element in the resulting observable sequence.
|
||||
- parameter: Scheduler to send the single element on.
|
||||
- returns: An observable sequence containing the single specified element.
|
||||
*/
|
||||
public static func just(_ element: ElementType, scheduler: ImmediateSchedulerType) -> Maybe<ElementType> {
|
||||
return Maybe(raw: Observable.just(element, scheduler: scheduler))
|
||||
}
|
||||
|
||||
/**
|
||||
Returns an observable sequence that terminates with an `error`.
|
||||
|
||||
- seealso: [throw operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
|
||||
|
||||
- returns: The observable sequence that terminates with specified error.
|
||||
*/
|
||||
public static func error(_ error: Swift.Error) -> Maybe<ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.error(error))
|
||||
}
|
||||
|
||||
/**
|
||||
Returns a non-terminating observable sequence, which can be used to denote an infinite duration.
|
||||
|
||||
- seealso: [never operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
|
||||
|
||||
- returns: An observable sequence whose observers will never get called.
|
||||
*/
|
||||
public static func never() -> Maybe<ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.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() -> Maybe<ElementType> {
|
||||
return Maybe(raw: Observable.empty())
|
||||
}
|
||||
}
|
||||
|
||||
public extension PrimitiveSequenceType where TraitType == MaybeTrait {
|
||||
/**
|
||||
Invokes an action for each event in the observable sequence, and propagates all observer messages through the result sequence.
|
||||
|
||||
- seealso: [do operator on reactivex.io](http://reactivex.io/documentation/operators/do.html)
|
||||
|
||||
- parameter onNext: Action to invoke for each element in the observable sequence.
|
||||
- parameter onError: Action to invoke upon errored termination of the observable sequence.
|
||||
- parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
|
||||
- parameter onSubscribe: Action to invoke before subscribing to source observable sequence.
|
||||
- parameter onSubscribed: Action to invoke after subscribing to source observable sequence.
|
||||
- parameter onDispose: Action to invoke after subscription to source observable has been disposed for any reason. It can be either because sequence terminates for some reason or observer subscription being disposed.
|
||||
- returns: The source sequence with the side-effecting behavior applied.
|
||||
*/
|
||||
public func `do`(onNext: ((ElementType) throws -> Void)? = nil,
|
||||
onError: ((Swift.Error) throws -> Void)? = nil,
|
||||
onCompleted: (() throws -> Void)? = nil,
|
||||
onSubscribe: (() -> ())? = nil,
|
||||
onSubscribed: (() -> ())? = nil,
|
||||
onDispose: (() -> ())? = nil)
|
||||
-> Maybe<ElementType> {
|
||||
return Maybe(raw: primitiveSequence.source.do(
|
||||
onNext: onNext,
|
||||
onError: onError,
|
||||
onCompleted: onCompleted,
|
||||
onSubscribe: onSubscribe,
|
||||
onSubscribed: onSubscribed,
|
||||
onDispose: onDispose)
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
Filters the elements of an observable sequence based on a predicate.
|
||||
|
||||
- seealso: [filter operator on reactivex.io](http://reactivex.io/documentation/operators/filter.html)
|
||||
|
||||
- parameter predicate: A function to test each source element for a condition.
|
||||
- returns: An observable sequence that contains elements from the input sequence that satisfy the condition.
|
||||
*/
|
||||
public func filter(_ predicate: @escaping (ElementType) throws -> Bool)
|
||||
-> Maybe<ElementType> {
|
||||
return Maybe(raw: primitiveSequence.source.filter(predicate))
|
||||
}
|
||||
|
||||
/**
|
||||
Projects each element of an observable sequence into a new form.
|
||||
|
||||
- seealso: [map operator on reactivex.io](http://reactivex.io/documentation/operators/map.html)
|
||||
|
||||
- parameter transform: A transform function to apply to each source element.
|
||||
- returns: An observable sequence whose elements are the result of invoking the transform function on each element of source.
|
||||
|
||||
*/
|
||||
public func map<R>(_ transform: @escaping (ElementType) throws -> R)
|
||||
-> Maybe<R> {
|
||||
return Maybe(raw: primitiveSequence.source.map(transform))
|
||||
}
|
||||
|
||||
/**
|
||||
Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
|
||||
|
||||
- seealso: [flatMap operator on reactivex.io](http://reactivex.io/documentation/operators/flatmap.html)
|
||||
|
||||
- parameter selector: A transform function to apply to each element.
|
||||
- returns: An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.
|
||||
*/
|
||||
public func flatMap<R>(_ selector: @escaping (ElementType) throws -> Maybe<R>)
|
||||
-> Maybe<R> {
|
||||
return Maybe<R>(raw: primitiveSequence.source.flatMap(selector))
|
||||
}
|
||||
}
|
||||
43
RxSwift/Traits/ObservableType+PrimitiveSequence.swift
Normal file
43
RxSwift/Traits/ObservableType+PrimitiveSequence.swift
Normal file
@ -0,0 +1,43 @@
|
||||
//
|
||||
// ObservableType+PrimitiveSequence.swift
|
||||
// RxSwift
|
||||
//
|
||||
// Created by Krunoslav Zaher on 9/17/17.
|
||||
// Copyright © 2017 Krunoslav Zaher. All rights reserved.
|
||||
//
|
||||
|
||||
extension ObservableType {
|
||||
/**
|
||||
The `asSingle` operator throws a `RxError.noElements` or `RxError.moreThanOneElement`
|
||||
if the source Observable does not emit exactly one element before successfully completing.
|
||||
|
||||
- seealso: [single operator on reactivex.io](http://reactivex.io/documentation/operators/first.html)
|
||||
|
||||
- returns: An observable sequence that emits a single element or throws an exception if more (or none) of them are emitted.
|
||||
*/
|
||||
public func asSingle() -> Single<E> {
|
||||
return PrimitiveSequence(raw: AsSingle(source: self.asObservable()))
|
||||
}
|
||||
|
||||
/**
|
||||
The `asMaybe` operator throws a ``RxError.moreThanOneElement`
|
||||
if the source Observable does not emit at most one element before successfully completing.
|
||||
|
||||
- seealso: [single operator on reactivex.io](http://reactivex.io/documentation/operators/first.html)
|
||||
|
||||
- returns: An observable sequence that emits a single element, completes or throws an exception if more of them are emitted.
|
||||
*/
|
||||
public func asMaybe() -> Maybe<E> {
|
||||
return PrimitiveSequence(raw: AsMaybe(source: self.asObservable()))
|
||||
}
|
||||
}
|
||||
|
||||
extension ObservableType where E == Never {
|
||||
/**
|
||||
- returns: An observable sequence that completes.
|
||||
*/
|
||||
public func asCompletable()
|
||||
-> Completable {
|
||||
return PrimitiveSequence(raw: self.asObservable())
|
||||
}
|
||||
}
|
||||
@ -11,7 +11,7 @@
|
||||
|
||||
// 2
|
||||
|
||||
extension PrimitiveSequenceType {
|
||||
extension PrimitiveSequenceType where TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -29,7 +29,41 @@ extension PrimitiveSequenceType {
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any {
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>)
|
||||
-> PrimitiveSequence<TraitType, (E1, E2)> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable())
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>, resultSelector: @escaping (E1, E2) throws -> ElementType)
|
||||
-> PrimitiveSequence<TraitType, ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable(),
|
||||
resultSelector: resultSelector)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -47,9 +81,10 @@ extension PrimitiveSequenceType where ElementType == Any {
|
||||
|
||||
|
||||
|
||||
|
||||
// 3
|
||||
|
||||
extension PrimitiveSequenceType {
|
||||
extension PrimitiveSequenceType where TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -67,7 +102,41 @@ extension PrimitiveSequenceType {
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any {
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2, E3>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>, _ source3: PrimitiveSequence<TraitType, E3>)
|
||||
-> PrimitiveSequence<TraitType, (E1, E2, E3)> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable(), source3.asObservable())
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2, E3>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>, _ source3: PrimitiveSequence<TraitType, E3>, resultSelector: @escaping (E1, E2, E3) throws -> ElementType)
|
||||
-> PrimitiveSequence<TraitType, ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable(), source3.asObservable(),
|
||||
resultSelector: resultSelector)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -85,9 +154,10 @@ extension PrimitiveSequenceType where ElementType == Any {
|
||||
|
||||
|
||||
|
||||
|
||||
// 4
|
||||
|
||||
extension PrimitiveSequenceType {
|
||||
extension PrimitiveSequenceType where TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -105,7 +175,41 @@ extension PrimitiveSequenceType {
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any {
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2, E3, E4>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>, _ source3: PrimitiveSequence<TraitType, E3>, _ source4: PrimitiveSequence<TraitType, E4>)
|
||||
-> PrimitiveSequence<TraitType, (E1, E2, E3, E4)> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable())
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2, E3, E4>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>, _ source3: PrimitiveSequence<TraitType, E3>, _ source4: PrimitiveSequence<TraitType, E4>, resultSelector: @escaping (E1, E2, E3, E4) throws -> ElementType)
|
||||
-> PrimitiveSequence<TraitType, ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(),
|
||||
resultSelector: resultSelector)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -123,9 +227,10 @@ extension PrimitiveSequenceType where ElementType == Any {
|
||||
|
||||
|
||||
|
||||
|
||||
// 5
|
||||
|
||||
extension PrimitiveSequenceType {
|
||||
extension PrimitiveSequenceType where TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -143,7 +248,41 @@ extension PrimitiveSequenceType {
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any {
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2, E3, E4, E5>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>, _ source3: PrimitiveSequence<TraitType, E3>, _ source4: PrimitiveSequence<TraitType, E4>, _ source5: PrimitiveSequence<TraitType, E5>)
|
||||
-> PrimitiveSequence<TraitType, (E1, E2, E3, E4, E5)> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(), source5.asObservable())
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2, E3, E4, E5>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>, _ source3: PrimitiveSequence<TraitType, E3>, _ source4: PrimitiveSequence<TraitType, E4>, _ source5: PrimitiveSequence<TraitType, E5>, resultSelector: @escaping (E1, E2, E3, E4, E5) throws -> ElementType)
|
||||
-> PrimitiveSequence<TraitType, ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(), source5.asObservable(),
|
||||
resultSelector: resultSelector)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -161,9 +300,10 @@ extension PrimitiveSequenceType where ElementType == Any {
|
||||
|
||||
|
||||
|
||||
|
||||
// 6
|
||||
|
||||
extension PrimitiveSequenceType {
|
||||
extension PrimitiveSequenceType where TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -181,7 +321,41 @@ extension PrimitiveSequenceType {
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any {
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2, E3, E4, E5, E6>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>, _ source3: PrimitiveSequence<TraitType, E3>, _ source4: PrimitiveSequence<TraitType, E4>, _ source5: PrimitiveSequence<TraitType, E5>, _ source6: PrimitiveSequence<TraitType, E6>)
|
||||
-> PrimitiveSequence<TraitType, (E1, E2, E3, E4, E5, E6)> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(), source5.asObservable(), source6.asObservable())
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2, E3, E4, E5, E6>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>, _ source3: PrimitiveSequence<TraitType, E3>, _ source4: PrimitiveSequence<TraitType, E4>, _ source5: PrimitiveSequence<TraitType, E5>, _ source6: PrimitiveSequence<TraitType, E6>, resultSelector: @escaping (E1, E2, E3, E4, E5, E6) throws -> ElementType)
|
||||
-> PrimitiveSequence<TraitType, ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(), source5.asObservable(), source6.asObservable(),
|
||||
resultSelector: resultSelector)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -199,9 +373,10 @@ extension PrimitiveSequenceType where ElementType == Any {
|
||||
|
||||
|
||||
|
||||
|
||||
// 7
|
||||
|
||||
extension PrimitiveSequenceType {
|
||||
extension PrimitiveSequenceType where TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -219,7 +394,41 @@ extension PrimitiveSequenceType {
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any {
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2, E3, E4, E5, E6, E7>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>, _ source3: PrimitiveSequence<TraitType, E3>, _ source4: PrimitiveSequence<TraitType, E4>, _ source5: PrimitiveSequence<TraitType, E5>, _ source6: PrimitiveSequence<TraitType, E6>, _ source7: PrimitiveSequence<TraitType, E7>)
|
||||
-> PrimitiveSequence<TraitType, (E1, E2, E3, E4, E5, E6, E7)> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(), source5.asObservable(), source6.asObservable(), source7.asObservable())
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2, E3, E4, E5, E6, E7>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>, _ source3: PrimitiveSequence<TraitType, E3>, _ source4: PrimitiveSequence<TraitType, E4>, _ source5: PrimitiveSequence<TraitType, E5>, _ source6: PrimitiveSequence<TraitType, E6>, _ source7: PrimitiveSequence<TraitType, E7>, resultSelector: @escaping (E1, E2, E3, E4, E5, E6, E7) throws -> ElementType)
|
||||
-> PrimitiveSequence<TraitType, ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(), source5.asObservable(), source6.asObservable(), source7.asObservable(),
|
||||
resultSelector: resultSelector)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -237,9 +446,10 @@ extension PrimitiveSequenceType where ElementType == Any {
|
||||
|
||||
|
||||
|
||||
|
||||
// 8
|
||||
|
||||
extension PrimitiveSequenceType {
|
||||
extension PrimitiveSequenceType where TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -257,7 +467,41 @@ extension PrimitiveSequenceType {
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any {
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2, E3, E4, E5, E6, E7, E8>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>, _ source3: PrimitiveSequence<TraitType, E3>, _ source4: PrimitiveSequence<TraitType, E4>, _ source5: PrimitiveSequence<TraitType, E5>, _ source6: PrimitiveSequence<TraitType, E6>, _ source7: PrimitiveSequence<TraitType, E7>, _ source8: PrimitiveSequence<TraitType, E8>)
|
||||
-> PrimitiveSequence<TraitType, (E1, E2, E3, E4, E5, E6, E7, E8)> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(), source5.asObservable(), source6.asObservable(), source7.asObservable(), source8.asObservable())
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<E1, E2, E3, E4, E5, E6, E7, E8>(_ source1: PrimitiveSequence<TraitType, E1>, _ source2: PrimitiveSequence<TraitType, E2>, _ source3: PrimitiveSequence<TraitType, E3>, _ source4: PrimitiveSequence<TraitType, E4>, _ source5: PrimitiveSequence<TraitType, E5>, _ source6: PrimitiveSequence<TraitType, E6>, _ source7: PrimitiveSequence<TraitType, E7>, _ source8: PrimitiveSequence<TraitType, E8>, resultSelector: @escaping (E1, E2, E3, E4, E5, E6, E7, E8) throws -> ElementType)
|
||||
-> PrimitiveSequence<TraitType, ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(), source5.asObservable(), source6.asObservable(), source7.asObservable(), source8.asObservable(),
|
||||
resultSelector: resultSelector)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -274,3 +518,4 @@ extension PrimitiveSequenceType where ElementType == Any {
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
// <%= i %>
|
||||
|
||||
extension PrimitiveSequenceType {
|
||||
extension PrimitiveSequenceType where TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -28,7 +28,7 @@ extension PrimitiveSequenceType {
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any {
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == SingleTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
@ -44,4 +44,39 @@ extension PrimitiveSequenceType where ElementType == Any {
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<<%= (Array(1...i).map { "E\($0)" }).joined(separator: ", ") %>>(<%= (Array(1...i).map { "_ source\($0): PrimitiveSequence<TraitType, E\($0)>" }).joined(separator: ", ") %>, resultSelector: @escaping (<%= (Array(1...i).map { "E\($0)" }).joined(separator: ", ") %>) throws -> ElementType)
|
||||
-> PrimitiveSequence<TraitType, ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
<%= (Array(1...i).map { "source\($0).asObservable()" }).joined(separator: ", ") %>,
|
||||
resultSelector: resultSelector)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where ElementType == Any, TraitType == MaybeTrait {
|
||||
/**
|
||||
Merges the specified observable sequences into one observable sequence of tuples whenever all of the observable sequences have produced an element at a corresponding index.
|
||||
|
||||
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
|
||||
|
||||
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
|
||||
*/
|
||||
public static func zip<<%= (Array(1...i).map { "E\($0)" }).joined(separator: ", ") %>>(<%= (Array(1...i).map { "_ source\($0): PrimitiveSequence<TraitType, E\($0)>" }).joined(separator: ", ") %>)
|
||||
-> PrimitiveSequence<TraitType, (<%= (Array(1...i).map { "E\($0)" }).joined(separator: ", ") %>)> {
|
||||
return PrimitiveSequence(raw: Observable.zip(
|
||||
<%= (Array(1...i).map { "source\($0).asObservable()" }).joined(separator: ", ") %>)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
<% } %>
|
||||
|
||||
@ -8,28 +8,13 @@
|
||||
|
||||
/// Observable sequences containing 0 or 1 element.
|
||||
public struct PrimitiveSequence<Trait, Element> {
|
||||
fileprivate let source: Observable<Element>
|
||||
let source: Observable<Element>
|
||||
|
||||
init(raw: Observable<Element>) {
|
||||
self.source = raw
|
||||
}
|
||||
}
|
||||
|
||||
/// Sequence containing exactly 1 element
|
||||
public enum SingleTrait { }
|
||||
/// Represents a push style sequence containing 1 element.
|
||||
public typealias Single<Element> = PrimitiveSequence<SingleTrait, Element>
|
||||
|
||||
/// Sequence containing 0 or 1 elements
|
||||
public enum MaybeTrait { }
|
||||
/// Represents a push style sequence containing 0 or 1 element.
|
||||
public typealias Maybe<Element> = PrimitiveSequence<MaybeTrait, Element>
|
||||
|
||||
/// Sequence containing 0 elements
|
||||
public enum CompletableTrait { }
|
||||
/// Represents a push style sequence containing 0 elements.
|
||||
public typealias Completable = PrimitiveSequence<CompletableTrait, Swift.Never>
|
||||
|
||||
/// Observable sequences containing 0 or 1 element
|
||||
public protocol PrimitiveSequenceType {
|
||||
/// Additional constraints
|
||||
@ -69,254 +54,6 @@ extension PrimitiveSequence: ObservableConvertibleType {
|
||||
}
|
||||
}
|
||||
|
||||
// <Single>
|
||||
|
||||
public enum SingleEvent<Element> {
|
||||
/// One and only sequence element is produced. (underlying observable sequence emits: `.next(Element)`, `.completed`)
|
||||
case success(Element)
|
||||
|
||||
/// Sequence terminated with an error. (underlying observable sequence emits: `.error(Error)`)
|
||||
case error(Swift.Error)
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where TraitType == SingleTrait {
|
||||
public typealias SingleObserver = (SingleEvent<ElementType>) -> ()
|
||||
|
||||
/**
|
||||
Creates an observable sequence from a specified subscribe method implementation.
|
||||
|
||||
- seealso: [create operator on reactivex.io](http://reactivex.io/documentation/operators/create.html)
|
||||
|
||||
- parameter subscribe: Implementation of the resulting observable sequence's `subscribe` method.
|
||||
- returns: The observable sequence with the specified implementation for the `subscribe` method.
|
||||
*/
|
||||
public static func create(subscribe: @escaping (@escaping SingleObserver) -> Disposable) -> PrimitiveSequence<TraitType, ElementType> {
|
||||
let source = Observable<ElementType>.create { observer in
|
||||
return subscribe { event in
|
||||
switch event {
|
||||
case .success(let element):
|
||||
observer.on(.next(element))
|
||||
observer.on(.completed)
|
||||
case .error(let error):
|
||||
observer.on(.error(error))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return PrimitiveSequence(raw: source)
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Subscribes `observer` to receive events for this sequence.
|
||||
|
||||
- returns: Subscription for `observer` that can be used to cancel production of sequence elements and free resources.
|
||||
*/
|
||||
public func subscribe(_ observer: @escaping (SingleEvent<ElementType>) -> ()) -> Disposable {
|
||||
var stopped = false
|
||||
return self.primitiveSequence.asObservable().subscribe { event in
|
||||
if stopped { return }
|
||||
stopped = true
|
||||
|
||||
switch event {
|
||||
case .next(let element):
|
||||
observer(.success(element))
|
||||
case .error(let error):
|
||||
observer(.error(error))
|
||||
case .completed:
|
||||
rxFatalErrorInDebug("Singles can't emit a completion event")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Subscribes a success handler, and an error handler for this sequence.
|
||||
|
||||
- parameter onSuccess: Action to invoke for each element in the observable sequence.
|
||||
- parameter onError: Action to invoke upon errored termination of the observable sequence.
|
||||
- returns: Subscription object used to unsubscribe from the observable sequence.
|
||||
*/
|
||||
public func subscribe(onSuccess: ((ElementType) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil) -> Disposable {
|
||||
return self.primitiveSequence.subscribe { event in
|
||||
switch event {
|
||||
case .success(let element):
|
||||
onSuccess?(element)
|
||||
case .error(let error):
|
||||
onError?(error)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// </Single>
|
||||
|
||||
// <Maybe>
|
||||
|
||||
public enum MaybeEvent<Element> {
|
||||
/// One and only sequence element is produced. (underlying observable sequence emits: `.next(Element)`, `.completed`)
|
||||
case success(Element)
|
||||
|
||||
/// Sequence terminated with an error. (underlying observable sequence emits: `.error(Error)`)
|
||||
case error(Swift.Error)
|
||||
|
||||
/// Sequence completed successfully.
|
||||
case completed
|
||||
}
|
||||
|
||||
public extension PrimitiveSequenceType where TraitType == MaybeTrait {
|
||||
public typealias MaybeObserver = (MaybeEvent<ElementType>) -> ()
|
||||
|
||||
/**
|
||||
Creates an observable sequence from a specified subscribe method implementation.
|
||||
|
||||
- seealso: [create operator on reactivex.io](http://reactivex.io/documentation/operators/create.html)
|
||||
|
||||
- parameter subscribe: Implementation of the resulting observable sequence's `subscribe` method.
|
||||
- returns: The observable sequence with the specified implementation for the `subscribe` method.
|
||||
*/
|
||||
public static func create(subscribe: @escaping (@escaping MaybeObserver) -> Disposable) -> PrimitiveSequence<TraitType, ElementType> {
|
||||
let source = Observable<ElementType>.create { observer in
|
||||
return subscribe { event in
|
||||
switch event {
|
||||
case .success(let element):
|
||||
observer.on(.next(element))
|
||||
observer.on(.completed)
|
||||
case .error(let error):
|
||||
observer.on(.error(error))
|
||||
case .completed:
|
||||
observer.on(.completed)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return PrimitiveSequence(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Subscribes `observer` to receive events for this sequence.
|
||||
|
||||
- returns: Subscription for `observer` that can be used to cancel production of sequence elements and free resources.
|
||||
*/
|
||||
public func subscribe(_ observer: @escaping (MaybeEvent<ElementType>) -> ()) -> Disposable {
|
||||
var stopped = false
|
||||
return self.primitiveSequence.asObservable().subscribe { event in
|
||||
if stopped { return }
|
||||
stopped = true
|
||||
|
||||
switch event {
|
||||
case .next(let element):
|
||||
observer(.success(element))
|
||||
case .error(let error):
|
||||
observer(.error(error))
|
||||
case .completed:
|
||||
observer(.completed)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Subscribes a success handler, an error handler, and a completion handler for this sequence.
|
||||
|
||||
- parameter onSuccess: Action to invoke for each element in the observable sequence.
|
||||
- parameter onError: Action to invoke upon errored termination of the observable sequence.
|
||||
- parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
|
||||
- returns: Subscription object used to unsubscribe from the observable sequence.
|
||||
*/
|
||||
public func subscribe(onSuccess: ((ElementType) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil) -> Disposable {
|
||||
return self.primitiveSequence.subscribe { event in
|
||||
switch event {
|
||||
case .success(let element):
|
||||
onSuccess?(element)
|
||||
case .error(let error):
|
||||
onError?(error)
|
||||
case .completed:
|
||||
onCompleted?()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// </Maybe>
|
||||
|
||||
// <Completable>
|
||||
|
||||
public enum CompletableEvent {
|
||||
/// Sequence terminated with an error. (underlying observable sequence emits: `.error(Error)`)
|
||||
case error(Swift.Error)
|
||||
|
||||
/// Sequence completed successfully.
|
||||
case completed
|
||||
}
|
||||
|
||||
public extension PrimitiveSequenceType where TraitType == CompletableTrait, ElementType == Swift.Never {
|
||||
public typealias CompletableObserver = (CompletableEvent) -> ()
|
||||
|
||||
/**
|
||||
Creates an observable sequence from a specified subscribe method implementation.
|
||||
|
||||
- seealso: [create operator on reactivex.io](http://reactivex.io/documentation/operators/create.html)
|
||||
|
||||
- parameter subscribe: Implementation of the resulting observable sequence's `subscribe` method.
|
||||
- returns: The observable sequence with the specified implementation for the `subscribe` method.
|
||||
*/
|
||||
public static func create(subscribe: @escaping (@escaping CompletableObserver) -> Disposable) -> PrimitiveSequence<TraitType, ElementType> {
|
||||
let source = Observable<ElementType>.create { observer in
|
||||
return subscribe { event in
|
||||
switch event {
|
||||
case .error(let error):
|
||||
observer.on(.error(error))
|
||||
case .completed:
|
||||
observer.on(.completed)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return PrimitiveSequence(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Subscribes `observer` to receive events for this sequence.
|
||||
|
||||
- returns: Subscription for `observer` that can be used to cancel production of sequence elements and free resources.
|
||||
*/
|
||||
public func subscribe(_ observer: @escaping (CompletableEvent) -> ()) -> Disposable {
|
||||
var stopped = false
|
||||
return self.primitiveSequence.asObservable().subscribe { event in
|
||||
if stopped { return }
|
||||
stopped = true
|
||||
|
||||
switch event {
|
||||
case .next:
|
||||
rxFatalError("Completables can't emit values")
|
||||
case .error(let error):
|
||||
observer(.error(error))
|
||||
case .completed:
|
||||
observer(.completed)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Subscribes a completion handler and an error handler for this sequence.
|
||||
|
||||
- parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
|
||||
- parameter onError: Action to invoke upon errored termination of the observable sequence.
|
||||
- returns: Subscription object used to unsubscribe from the observable sequence.
|
||||
*/
|
||||
public func subscribe(onCompleted: (() -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil) -> Disposable {
|
||||
return self.primitiveSequence.subscribe { event in
|
||||
switch event {
|
||||
case .error(let error):
|
||||
onError?(error)
|
||||
case .completed:
|
||||
onCompleted?()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// </Completable>
|
||||
|
||||
extension PrimitiveSequence {
|
||||
/**
|
||||
Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes.
|
||||
@ -334,51 +71,17 @@ extension PrimitiveSequence {
|
||||
}
|
||||
|
||||
/**
|
||||
Returns an observable sequence that contains a single element.
|
||||
Returns an observable sequence by the source observable sequence shifted forward in time by a specified delay. Error events from the source observable sequence are not delayed.
|
||||
|
||||
- seealso: [just operator on reactivex.io](http://reactivex.io/documentation/operators/just.html)
|
||||
- seealso: [delay operator on reactivex.io](http://reactivex.io/documentation/operators/delay.html)
|
||||
|
||||
- parameter element: Single element in the resulting observable sequence.
|
||||
- returns: An observable sequence containing the single specified element.
|
||||
- parameter dueTime: Relative time shift of the source by.
|
||||
- parameter scheduler: Scheduler to run the subscription delay timer on.
|
||||
- returns: the source Observable shifted in time by the specified delay.
|
||||
*/
|
||||
public static func just(_ element: Element) -> PrimitiveSequence<Trait, ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.just(element))
|
||||
}
|
||||
|
||||
/**
|
||||
Returns an observable sequence that contains a single element.
|
||||
|
||||
- seealso: [just operator on reactivex.io](http://reactivex.io/documentation/operators/just.html)
|
||||
|
||||
- parameter element: Single element in the resulting observable sequence.
|
||||
- parameter: Scheduler to send the single element on.
|
||||
- returns: An observable sequence containing the single specified element.
|
||||
*/
|
||||
public static func just(_ element: Element, scheduler: ImmediateSchedulerType) -> PrimitiveSequence<Trait, ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.just(element, scheduler: scheduler))
|
||||
}
|
||||
|
||||
/**
|
||||
Returns an observable sequence that terminates with an `error`.
|
||||
|
||||
- seealso: [throw operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
|
||||
|
||||
- returns: The observable sequence that terminates with specified error.
|
||||
*/
|
||||
public static func error(_ error: Swift.Error) -> PrimitiveSequence<Trait, Element> {
|
||||
return PrimitiveSequence(raw: Observable.error(error))
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Returns a non-terminating observable sequence, which can be used to denote an infinite duration.
|
||||
|
||||
- seealso: [never operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
|
||||
|
||||
- returns: An observable sequence whose observers will never get called.
|
||||
*/
|
||||
public static func never() -> PrimitiveSequence<Trait, Element> {
|
||||
return PrimitiveSequence(raw: Observable.never())
|
||||
public func delay(_ dueTime: RxTimeInterval, scheduler: SchedulerType)
|
||||
-> PrimitiveSequence<Trait, Element> {
|
||||
return PrimitiveSequence(raw: primitiveSequence.source.delay(dueTime, scheduler: scheduler))
|
||||
}
|
||||
|
||||
/**
|
||||
@ -394,86 +97,7 @@ extension PrimitiveSequence {
|
||||
-> PrimitiveSequence<Trait, Element> {
|
||||
return PrimitiveSequence(raw: source.delaySubscription(dueTime, scheduler: scheduler))
|
||||
}
|
||||
|
||||
/**
|
||||
Returns an observable sequence by the source observable sequence shifted forward in time by a specified delay. Error events from the source observable sequence are not delayed.
|
||||
|
||||
- seealso: [delay operator on reactivex.io](http://reactivex.io/documentation/operators/delay.html)
|
||||
|
||||
- parameter dueTime: Relative time shift of the source by.
|
||||
- parameter scheduler: Scheduler to run the subscription delay timer on.
|
||||
- returns: the source Observable shifted in time by the specified delay.
|
||||
*/
|
||||
public func delay(_ dueTime: RxTimeInterval, scheduler: SchedulerType)
|
||||
-> PrimitiveSequence<Trait, Element> {
|
||||
return PrimitiveSequence(raw: source.delay(dueTime, scheduler: scheduler))
|
||||
}
|
||||
|
||||
/**
|
||||
Invokes an action for each event in the observable sequence, and propagates all observer messages through the result sequence.
|
||||
|
||||
- seealso: [do operator on reactivex.io](http://reactivex.io/documentation/operators/do.html)
|
||||
|
||||
- parameter onNext: Action to invoke for each element in the observable sequence.
|
||||
- parameter onError: Action to invoke upon errored termination of the observable sequence.
|
||||
- parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
|
||||
- parameter onSubscribe: Action to invoke before subscribing to source observable sequence.
|
||||
- parameter onSubscribed: Action to invoke after subscribing to source observable sequence.
|
||||
- parameter onDispose: Action to invoke after subscription to source observable has been disposed for any reason. It can be either because sequence terminates for some reason or observer subscription being disposed.
|
||||
- returns: The source sequence with the side-effecting behavior applied.
|
||||
*/
|
||||
public func `do`(onNext: ((E) throws -> Void)? = nil, onError: ((Swift.Error) throws -> Void)? = nil, onCompleted: (() throws -> Void)? = nil, onSubscribe: (() -> ())? = nil, onSubscribed: (() -> ())? = nil, onDispose: (() -> ())? = nil)
|
||||
-> PrimitiveSequence<Trait, Element> {
|
||||
return PrimitiveSequence(raw: source.do(
|
||||
onNext: onNext,
|
||||
onError: onError,
|
||||
onCompleted: onCompleted,
|
||||
onSubscribe: onSubscribe,
|
||||
onSubscribed: onSubscribed,
|
||||
onDispose: onDispose)
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
Filters the elements of an observable sequence based on a predicate.
|
||||
|
||||
- seealso: [filter operator on reactivex.io](http://reactivex.io/documentation/operators/filter.html)
|
||||
|
||||
- parameter predicate: A function to test each source element for a condition.
|
||||
- returns: An observable sequence that contains elements from the input sequence that satisfy the condition.
|
||||
*/
|
||||
public func filter(_ predicate: @escaping (E) throws -> Bool)
|
||||
-> Maybe<Element> {
|
||||
return Maybe(raw: source.filter(predicate))
|
||||
}
|
||||
|
||||
/**
|
||||
Projects each element of an observable sequence into a new form.
|
||||
|
||||
- seealso: [map operator on reactivex.io](http://reactivex.io/documentation/operators/map.html)
|
||||
|
||||
- parameter transform: A transform function to apply to each source element.
|
||||
- returns: An observable sequence whose elements are the result of invoking the transform function on each element of source.
|
||||
|
||||
*/
|
||||
public func map<R>(_ transform: @escaping (E) throws -> R)
|
||||
-> PrimitiveSequence<Trait, R> {
|
||||
return PrimitiveSequence<Trait, R>(raw: source.map(transform))
|
||||
}
|
||||
|
||||
/**
|
||||
Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
|
||||
|
||||
- seealso: [flatMap operator on reactivex.io](http://reactivex.io/documentation/operators/flatmap.html)
|
||||
|
||||
- parameter selector: A transform function to apply to each element.
|
||||
- returns: An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.
|
||||
*/
|
||||
public func flatMap<R>(_ selector: @escaping (ElementType) throws -> PrimitiveSequence<Trait, R>)
|
||||
-> PrimitiveSequence<Trait, R> {
|
||||
return PrimitiveSequence<Trait, R>(raw: source.flatMap(selector))
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Wraps the source sequence in order to run its observer callbacks on the specified scheduler.
|
||||
|
||||
@ -598,31 +222,32 @@ extension PrimitiveSequence {
|
||||
|
||||
/**
|
||||
Applies a timeout policy for each element in the observable sequence. If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutError is propagated to the observer.
|
||||
|
||||
|
||||
- seealso: [timeout operator on reactivex.io](http://reactivex.io/documentation/operators/timeout.html)
|
||||
|
||||
|
||||
- parameter dueTime: Maximum duration between values before a timeout occurs.
|
||||
- parameter scheduler: Scheduler to run the timeout timer on.
|
||||
- returns: An observable sequence with a `RxError.timeout` in case of a timeout.
|
||||
*/
|
||||
public func timeout(_ dueTime: RxTimeInterval, scheduler: SchedulerType)
|
||||
-> PrimitiveSequence<Trait, Element> {
|
||||
return PrimitiveSequence(raw: source.timeout(dueTime, scheduler: scheduler))
|
||||
-> PrimitiveSequence<Trait, Element> {
|
||||
return PrimitiveSequence<Trait, Element>(raw: primitiveSequence.source.timeout(dueTime, scheduler: scheduler))
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on.
|
||||
|
||||
|
||||
- seealso: [timeout operator on reactivex.io](http://reactivex.io/documentation/operators/timeout.html)
|
||||
|
||||
|
||||
- parameter dueTime: Maximum duration between values before a timeout occurs.
|
||||
- parameter other: Sequence to return in case of a timeout.
|
||||
- parameter scheduler: Scheduler to run the timeout timer on.
|
||||
- returns: The source sequence switching to the other sequence in case of a timeout.
|
||||
*/
|
||||
public func timeout(_ dueTime: RxTimeInterval, other: PrimitiveSequence<Trait, Element>, scheduler: SchedulerType)
|
||||
-> PrimitiveSequence<Trait, Element> {
|
||||
return PrimitiveSequence(raw: source.timeout(dueTime, other: other.source, scheduler: scheduler))
|
||||
public func timeout(_ dueTime: RxTimeInterval,
|
||||
other: PrimitiveSequence<Trait, Element>,
|
||||
scheduler: SchedulerType) -> PrimitiveSequence<Trait, Element> {
|
||||
return PrimitiveSequence<Trait, Element>(raw: primitiveSequence.source.timeout(dueTime, other: other.source, scheduler: scheduler))
|
||||
}
|
||||
}
|
||||
|
||||
@ -643,154 +268,4 @@ extension PrimitiveSequenceType where ElementType: RxAbstractInteger
|
||||
}
|
||||
}
|
||||
|
||||
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 == CompletableTrait, 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<CompletableTrait, Never> {
|
||||
return PrimitiveSequence(raw: Observable.empty())
|
||||
}
|
||||
|
||||
/**
|
||||
Concatenates the second observable sequence to `self` upon successful termination of `self`.
|
||||
|
||||
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
|
||||
|
||||
- parameter second: Second observable sequence.
|
||||
- returns: An observable sequence that contains the elements of `self`, followed by those of the second sequence.
|
||||
*/
|
||||
public func concat(_ second: PrimitiveSequence<CompletableTrait, Never>) -> PrimitiveSequence<CompletableTrait, Never> {
|
||||
return Completable.concat(primitiveSequence, second)
|
||||
}
|
||||
|
||||
/**
|
||||
Concatenates all observable sequences in the given sequence, as long as the previous observable sequence terminated successfully.
|
||||
|
||||
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
|
||||
|
||||
- returns: An observable sequence that contains the elements of each given sequence, in sequential order.
|
||||
*/
|
||||
public static func concat<S: Sequence>(_ sequence: S) -> PrimitiveSequence<CompletableTrait, Never>
|
||||
where S.Iterator.Element == PrimitiveSequence<CompletableTrait, Never> {
|
||||
let source = Observable.concat(sequence.lazy.map { $0.asObservable() })
|
||||
return PrimitiveSequence<CompletableTrait, Never>(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Concatenates all observable sequences in the given sequence, as long as the previous observable sequence terminated successfully.
|
||||
|
||||
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
|
||||
|
||||
- returns: An observable sequence that contains the elements of each given sequence, in sequential order.
|
||||
*/
|
||||
public static func concat<C: Collection>(_ collection: C) -> PrimitiveSequence<CompletableTrait, Never>
|
||||
where C.Iterator.Element == PrimitiveSequence<CompletableTrait, Never> {
|
||||
let source = Observable.concat(collection.map { $0.asObservable() })
|
||||
return PrimitiveSequence<CompletableTrait, Never>(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Concatenates all observable sequences in the given sequence, as long as the previous observable sequence terminated successfully.
|
||||
|
||||
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
|
||||
|
||||
- returns: An observable sequence that contains the elements of each given sequence, in sequential order.
|
||||
*/
|
||||
public static func concat(_ sources: PrimitiveSequence<CompletableTrait, Never> ...) -> PrimitiveSequence<CompletableTrait, Never> {
|
||||
let source = Observable.concat(sources.map { $0.asObservable() })
|
||||
return PrimitiveSequence<CompletableTrait, Never>(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Merges elements from all observable sequences from collection into a single observable sequence.
|
||||
|
||||
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
|
||||
|
||||
- parameter sources: Collection of observable sequences to merge.
|
||||
- returns: The observable sequence that merges the elements of the observable sequences.
|
||||
*/
|
||||
public static func merge<C: Collection>(_ sources: C) -> PrimitiveSequence<CompletableTrait, Never>
|
||||
where C.Iterator.Element == PrimitiveSequence<CompletableTrait, Never> {
|
||||
let source = Observable.merge(sources.map { $0.asObservable() })
|
||||
return PrimitiveSequence<CompletableTrait, Never>(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Merges elements from all observable sequences from array into a single observable sequence.
|
||||
|
||||
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
|
||||
|
||||
- parameter sources: Array of observable sequences to merge.
|
||||
- returns: The observable sequence that merges the elements of the observable sequences.
|
||||
*/
|
||||
public static func merge(_ sources: [PrimitiveSequence<CompletableTrait, Never>]) -> PrimitiveSequence<CompletableTrait, Never> {
|
||||
let source = Observable.merge(sources.map { $0.asObservable() })
|
||||
return PrimitiveSequence<CompletableTrait, Never>(raw: source)
|
||||
}
|
||||
|
||||
/**
|
||||
Merges elements from all observable sequences into a single observable sequence.
|
||||
|
||||
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
|
||||
|
||||
- parameter sources: Collection of observable sequences to merge.
|
||||
- returns: The observable sequence that merges the elements of the observable sequences.
|
||||
*/
|
||||
public static func merge(_ sources: PrimitiveSequence<CompletableTrait, Never>...) -> PrimitiveSequence<CompletableTrait, Never> {
|
||||
let source = Observable.merge(sources.map { $0.asObservable() })
|
||||
return PrimitiveSequence<CompletableTrait, Never>(raw: source)
|
||||
}
|
||||
}
|
||||
|
||||
extension ObservableType {
|
||||
/**
|
||||
The `asSingle` operator throws a `RxError.noElements` or `RxError.moreThanOneElement`
|
||||
if the source Observable does not emit exactly one element before successfully completing.
|
||||
|
||||
- seealso: [single operator on reactivex.io](http://reactivex.io/documentation/operators/first.html)
|
||||
|
||||
- returns: An observable sequence that emits a single element or throws an exception if more (or none) of them are emitted.
|
||||
*/
|
||||
public func asSingle() -> Single<E> {
|
||||
return PrimitiveSequence(raw: AsSingle(source: self.asObservable()))
|
||||
}
|
||||
|
||||
/**
|
||||
The `asMaybe` operator throws a ``RxError.moreThanOneElement`
|
||||
if the source Observable does not emit at most one element before successfully completing.
|
||||
|
||||
- seealso: [single operator on reactivex.io](http://reactivex.io/documentation/operators/first.html)
|
||||
|
||||
- returns: An observable sequence that emits a single element, completes or throws an exception if more of them are emitted.
|
||||
*/
|
||||
public func asMaybe() -> Maybe<E> {
|
||||
return PrimitiveSequence(raw: AsMaybe(source: self.asObservable()))
|
||||
}
|
||||
}
|
||||
|
||||
extension ObservableType where E == Never {
|
||||
/**
|
||||
- returns: An observable sequence that completes.
|
||||
*/
|
||||
public func asCompletable()
|
||||
-> Completable {
|
||||
return PrimitiveSequence(raw: self.asObservable())
|
||||
}
|
||||
}
|
||||
|
||||
208
RxSwift/Traits/Single.swift
Normal file
208
RxSwift/Traits/Single.swift
Normal file
@ -0,0 +1,208 @@
|
||||
//
|
||||
// Single.swift
|
||||
// RxSwift
|
||||
//
|
||||
// Created by sergdort on 19/08/2017.
|
||||
// Copyright © 2017 Krunoslav Zaher. All rights reserved.
|
||||
//
|
||||
|
||||
/// Sequence containing exactly 1 element
|
||||
public enum SingleTrait { }
|
||||
/// Represents a push style sequence containing 1 element.
|
||||
public typealias Single<Element> = PrimitiveSequence<SingleTrait, Element>
|
||||
|
||||
public enum SingleEvent<Element> {
|
||||
/// One and only sequence element is produced. (underlying observable sequence emits: `.next(Element)`, `.completed`)
|
||||
case success(Element)
|
||||
|
||||
/// Sequence terminated with an error. (underlying observable sequence emits: `.error(Error)`)
|
||||
case error(Swift.Error)
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where TraitType == SingleTrait {
|
||||
public typealias SingleObserver = (SingleEvent<ElementType>) -> ()
|
||||
|
||||
/**
|
||||
Creates an observable sequence from a specified subscribe method implementation.
|
||||
|
||||
- seealso: [create operator on reactivex.io](http://reactivex.io/documentation/operators/create.html)
|
||||
|
||||
- parameter subscribe: Implementation of the resulting observable sequence's `subscribe` method.
|
||||
- returns: The observable sequence with the specified implementation for the `subscribe` method.
|
||||
*/
|
||||
public static func create(subscribe: @escaping (@escaping SingleObserver) -> Disposable) -> Single<ElementType> {
|
||||
let source = Observable<ElementType>.create { observer in
|
||||
return subscribe { event in
|
||||
switch event {
|
||||
case .success(let element):
|
||||
observer.on(.next(element))
|
||||
observer.on(.completed)
|
||||
case .error(let error):
|
||||
observer.on(.error(error))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return PrimitiveSequence(raw: source)
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Subscribes `observer` to receive events for this sequence.
|
||||
|
||||
- returns: Subscription for `observer` that can be used to cancel production of sequence elements and free resources.
|
||||
*/
|
||||
public func subscribe(_ observer: @escaping (SingleEvent<ElementType>) -> ()) -> Disposable {
|
||||
var stopped = false
|
||||
return self.primitiveSequence.asObservable().subscribe { event in
|
||||
if stopped { return }
|
||||
stopped = true
|
||||
|
||||
switch event {
|
||||
case .next(let element):
|
||||
observer(.success(element))
|
||||
case .error(let error):
|
||||
observer(.error(error))
|
||||
case .completed:
|
||||
rxFatalErrorInDebug("Singles can't emit a completion event")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Subscribes a success handler, and an error handler for this sequence.
|
||||
|
||||
- parameter onSuccess: Action to invoke for each element in the observable sequence.
|
||||
- parameter onError: Action to invoke upon errored termination of the observable sequence.
|
||||
- returns: Subscription object used to unsubscribe from the observable sequence.
|
||||
*/
|
||||
public func subscribe(onSuccess: ((ElementType) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil) -> Disposable {
|
||||
return self.primitiveSequence.subscribe { event in
|
||||
switch event {
|
||||
case .success(let element):
|
||||
onSuccess?(element)
|
||||
case .error(let error):
|
||||
onError?(error)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where TraitType == SingleTrait {
|
||||
/**
|
||||
Returns an observable sequence that contains a single element.
|
||||
|
||||
- seealso: [just operator on reactivex.io](http://reactivex.io/documentation/operators/just.html)
|
||||
|
||||
- parameter element: Single element in the resulting observable sequence.
|
||||
- returns: An observable sequence containing the single specified element.
|
||||
*/
|
||||
public static func just(_ element: ElementType) -> Single<ElementType> {
|
||||
return Single(raw: Observable.just(element))
|
||||
}
|
||||
|
||||
/**
|
||||
Returns an observable sequence that contains a single element.
|
||||
|
||||
- seealso: [just operator on reactivex.io](http://reactivex.io/documentation/operators/just.html)
|
||||
|
||||
- parameter element: Single element in the resulting observable sequence.
|
||||
- parameter: Scheduler to send the single element on.
|
||||
- returns: An observable sequence containing the single specified element.
|
||||
*/
|
||||
public static func just(_ element: ElementType, scheduler: ImmediateSchedulerType) -> Single<ElementType> {
|
||||
return Single(raw: Observable.just(element, scheduler: scheduler))
|
||||
}
|
||||
|
||||
/**
|
||||
Returns an observable sequence that terminates with an `error`.
|
||||
|
||||
- seealso: [throw operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
|
||||
|
||||
- returns: The observable sequence that terminates with specified error.
|
||||
*/
|
||||
public static func error(_ error: Swift.Error) -> Single<ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.error(error))
|
||||
}
|
||||
|
||||
/**
|
||||
Returns a non-terminating observable sequence, which can be used to denote an infinite duration.
|
||||
|
||||
- seealso: [never operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
|
||||
|
||||
- returns: An observable sequence whose observers will never get called.
|
||||
*/
|
||||
public static func never() -> Single<ElementType> {
|
||||
return PrimitiveSequence(raw: Observable.never())
|
||||
}
|
||||
}
|
||||
|
||||
extension PrimitiveSequenceType where TraitType == SingleTrait {
|
||||
/**
|
||||
Invokes an action for each event in the observable sequence, and propagates all observer messages through the result sequence.
|
||||
|
||||
- seealso: [do operator on reactivex.io](http://reactivex.io/documentation/operators/do.html)
|
||||
|
||||
- parameter onNext: Action to invoke for each element in the observable sequence.
|
||||
- parameter onError: Action to invoke upon errored termination of the observable sequence.
|
||||
- parameter onSubscribe: Action to invoke before subscribing to source observable sequence.
|
||||
- parameter onSubscribed: Action to invoke after subscribing to source observable sequence.
|
||||
- parameter onDispose: Action to invoke after subscription to source observable has been disposed for any reason. It can be either because sequence terminates for some reason or observer subscription being disposed.
|
||||
- returns: The source sequence with the side-effecting behavior applied.
|
||||
*/
|
||||
public func `do`(onNext: ((ElementType) throws -> Void)? = nil,
|
||||
onError: ((Swift.Error) throws -> Void)? = nil,
|
||||
onSubscribe: (() -> ())? = nil,
|
||||
onSubscribed: (() -> ())? = nil,
|
||||
onDispose: (() -> ())? = nil)
|
||||
-> Single<ElementType> {
|
||||
return Single(raw: primitiveSequence.source.do(
|
||||
onNext: onNext,
|
||||
onError: onError,
|
||||
onSubscribe: onSubscribe,
|
||||
onSubscribed: onSubscribed,
|
||||
onDispose: onDispose)
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
Filters the elements of an observable sequence based on a predicate.
|
||||
|
||||
- seealso: [filter operator on reactivex.io](http://reactivex.io/documentation/operators/filter.html)
|
||||
|
||||
- parameter predicate: A function to test each source element for a condition.
|
||||
- returns: An observable sequence that contains elements from the input sequence that satisfy the condition.
|
||||
*/
|
||||
public func filter(_ predicate: @escaping (ElementType) throws -> Bool)
|
||||
-> Maybe<ElementType> {
|
||||
return Maybe(raw: primitiveSequence.source.filter(predicate))
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Projects each element of an observable sequence into a new form.
|
||||
|
||||
- seealso: [map operator on reactivex.io](http://reactivex.io/documentation/operators/map.html)
|
||||
|
||||
- parameter transform: A transform function to apply to each source element.
|
||||
- returns: An observable sequence whose elements are the result of invoking the transform function on each element of source.
|
||||
|
||||
*/
|
||||
public func map<R>(_ transform: @escaping (ElementType) throws -> R)
|
||||
-> Single<R> {
|
||||
return Single(raw: primitiveSequence.source.map(transform))
|
||||
}
|
||||
|
||||
/**
|
||||
Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
|
||||
|
||||
- seealso: [flatMap operator on reactivex.io](http://reactivex.io/documentation/operators/flatmap.html)
|
||||
|
||||
- parameter selector: A transform function to apply to each element.
|
||||
- returns: An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.
|
||||
*/
|
||||
public func flatMap<R>(_ selector: @escaping (ElementType) throws -> Single<R>)
|
||||
-> Single<R> {
|
||||
return Single<R>(raw: primitiveSequence.source.flatMap(selector))
|
||||
}
|
||||
}
|
||||
1
Sources/AllTestz/CompletableTest.swift
Symbolic link
1
Sources/AllTestz/CompletableTest.swift
Symbolic link
@ -0,0 +1 @@
|
||||
../../Tests/RxSwiftTests/CompletableTest.swift
|
||||
1
Sources/AllTestz/MaybeTest.swift
Symbolic link
1
Sources/AllTestz/MaybeTest.swift
Symbolic link
@ -0,0 +1 @@
|
||||
../../Tests/RxSwiftTests/MaybeTest.swift
|
||||
1
Sources/AllTestz/Observable+PrimitiveSequenceTest.swift
Symbolic link
1
Sources/AllTestz/Observable+PrimitiveSequenceTest.swift
Symbolic link
@ -0,0 +1 @@
|
||||
../../Tests/RxSwiftTests/Observable+PrimitiveSequenceTest.swift
|
||||
@ -1 +0,0 @@
|
||||
../../Tests/RxSwiftTests/PrimitiveSequenceTest.swift
|
||||
1
Sources/AllTestz/SingleTest.swift
Symbolic link
1
Sources/AllTestz/SingleTest.swift
Symbolic link
@ -0,0 +1 @@
|
||||
../../Tests/RxSwiftTests/SingleTest.swift
|
||||
@ -81,97 +81,6 @@ final class ObservableTakeLastTest_ : ObservableTakeLastTest, RxTestCase {
|
||||
] }
|
||||
}
|
||||
|
||||
final class PrimitiveSequenceTest_ : PrimitiveSequenceTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
super.init()
|
||||
}
|
||||
#endif
|
||||
|
||||
static var allTests: [(String, (PrimitiveSequenceTest_) -> () -> ())] { return [
|
||||
("testZip2_selector_producesSingleElement", PrimitiveSequenceTest.testZip2_selector_producesSingleElement),
|
||||
("testZip2_producesSingleElement", PrimitiveSequenceTest.testZip2_producesSingleElement),
|
||||
("testZip3_selector_producesSingleElement", PrimitiveSequenceTest.testZip3_selector_producesSingleElement),
|
||||
("testZip3_producesSingleElement", PrimitiveSequenceTest.testZip3_producesSingleElement),
|
||||
("testZip4_selector_producesSingleElement", PrimitiveSequenceTest.testZip4_selector_producesSingleElement),
|
||||
("testZip4_producesSingleElement", PrimitiveSequenceTest.testZip4_producesSingleElement),
|
||||
("testZip5_selector_producesSingleElement", PrimitiveSequenceTest.testZip5_selector_producesSingleElement),
|
||||
("testZip5_producesSingleElement", PrimitiveSequenceTest.testZip5_producesSingleElement),
|
||||
("testZip6_selector_producesSingleElement", PrimitiveSequenceTest.testZip6_selector_producesSingleElement),
|
||||
("testZip6_producesSingleElement", PrimitiveSequenceTest.testZip6_producesSingleElement),
|
||||
("testZip7_selector_producesSingleElement", PrimitiveSequenceTest.testZip7_selector_producesSingleElement),
|
||||
("testZip7_producesSingleElement", PrimitiveSequenceTest.testZip7_producesSingleElement),
|
||||
("testZip8_selector_producesSingleElement", PrimitiveSequenceTest.testZip8_selector_producesSingleElement),
|
||||
("testZip8_producesSingleElement", PrimitiveSequenceTest.testZip8_producesSingleElement),
|
||||
("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),
|
||||
("testCompletable_Subscription_completed", PrimitiveSequenceTest.testCompletable_Subscription_completed),
|
||||
("testCompletable_Subscription_error", PrimitiveSequenceTest.testCompletable_Subscription_error),
|
||||
("testCompletable_create_completed", PrimitiveSequenceTest.testCompletable_create_completed),
|
||||
("testCompletable_create_error", PrimitiveSequenceTest.testCompletable_create_error),
|
||||
("testCompletable_create_disposing", PrimitiveSequenceTest.testCompletable_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_subscribeOn_producesSingleElement", PrimitiveSequenceTest.testSingle_subscribeOn_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),
|
||||
("testSingle_using_producesSingleElement", PrimitiveSequenceTest.testSingle_using_producesSingleElement),
|
||||
("testSingle_timeout", PrimitiveSequenceTest.testSingle_timeout),
|
||||
("testSingle_timeout_other", PrimitiveSequenceTest.testSingle_timeout_other),
|
||||
("testMaybe_timeout", PrimitiveSequenceTest.testMaybe_timeout),
|
||||
("testMaybe_timeout_other", PrimitiveSequenceTest.testMaybe_timeout_other),
|
||||
("testCompletable_timeout", PrimitiveSequenceTest.testCompletable_timeout),
|
||||
("testCompletable_timeout_other", PrimitiveSequenceTest.testCompletable_timeout_other),
|
||||
("testCompletable_timeout_succeeds", PrimitiveSequenceTest.testCompletable_timeout_succeeds),
|
||||
("testCompletable_timeout_other_succeeds", PrimitiveSequenceTest.testCompletable_timeout_other_succeeds),
|
||||
("testAsSingle_Empty", PrimitiveSequenceTest.testAsSingle_Empty),
|
||||
("testAsSingle_One", PrimitiveSequenceTest.testAsSingle_One),
|
||||
("testAsSingle_Many", PrimitiveSequenceTest.testAsSingle_Many),
|
||||
("testAsSingle_Error", PrimitiveSequenceTest.testAsSingle_Error),
|
||||
("testAsSingle_Error2", PrimitiveSequenceTest.testAsSingle_Error2),
|
||||
("testAsSingle_subscribeOnSuccess", PrimitiveSequenceTest.testAsSingle_subscribeOnSuccess),
|
||||
("testAsSingle_subscribeOnError", PrimitiveSequenceTest.testAsSingle_subscribeOnError),
|
||||
("testAsMaybe_Empty", PrimitiveSequenceTest.testAsMaybe_Empty),
|
||||
("testAsMaybe_One", PrimitiveSequenceTest.testAsMaybe_One),
|
||||
("testAsMaybe_Many", PrimitiveSequenceTest.testAsMaybe_Many),
|
||||
("testAsMaybe_Error", PrimitiveSequenceTest.testAsMaybe_Error),
|
||||
("testAsMaybe_Error2", PrimitiveSequenceTest.testAsMaybe_Error2),
|
||||
("testAsMaybe_subscribeOnSuccess", PrimitiveSequenceTest.testAsMaybe_subscribeOnSuccess),
|
||||
("testAsMaybe_subscribeOnError", PrimitiveSequenceTest.testAsMaybe_subscribeOnError),
|
||||
("testAsMaybe_subscribeOnCompleted", PrimitiveSequenceTest.testAsMaybe_subscribeOnCompleted),
|
||||
("testAsCompletable_Empty", PrimitiveSequenceTest.testAsCompletable_Empty),
|
||||
("testAsCompletable_Error", PrimitiveSequenceTest.testAsCompletable_Error),
|
||||
("testAsCompletable_subscribeOnCompleted", PrimitiveSequenceTest.testAsCompletable_subscribeOnCompleted),
|
||||
("testAsCompletable_subscribeOnError", PrimitiveSequenceTest.testAsCompletable_subscribeOnError),
|
||||
("testCompletable_merge", PrimitiveSequenceTest.testCompletable_merge),
|
||||
("testCompletable_concat", PrimitiveSequenceTest.testCompletable_concat),
|
||||
("testDebug_producesSingleElement", PrimitiveSequenceTest.testDebug_producesSingleElement),
|
||||
] }
|
||||
}
|
||||
|
||||
final class VirtualSchedulerTest_ : VirtualSchedulerTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
@ -440,25 +349,44 @@ final class ReplaySubjectTest_ : ReplaySubjectTest, RxTestCase {
|
||||
] }
|
||||
}
|
||||
|
||||
final class DisposableTest_ : DisposableTest, RxTestCase {
|
||||
final class CompletableTest_ : CompletableTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
super.init()
|
||||
}
|
||||
#endif
|
||||
|
||||
static var allTests: [(String, (DisposableTest_) -> () -> ())] { return [
|
||||
("testActionDisposable", DisposableTest.testActionDisposable),
|
||||
("testHotObservable_Disposing", DisposableTest.testHotObservable_Disposing),
|
||||
("testCompositeDisposable_TestNormal", DisposableTest.testCompositeDisposable_TestNormal),
|
||||
("testCompositeDisposable_TestInitWithNumberOfDisposables", DisposableTest.testCompositeDisposable_TestInitWithNumberOfDisposables),
|
||||
("testCompositeDisposable_TestRemoving", DisposableTest.testCompositeDisposable_TestRemoving),
|
||||
("testDisposables_TestCreateWithNumberOfDisposables", DisposableTest.testDisposables_TestCreateWithNumberOfDisposables),
|
||||
("testRefCountDisposable_RefCounting", DisposableTest.testRefCountDisposable_RefCounting),
|
||||
("testRefCountDisposable_PrimaryDisposesFirst", DisposableTest.testRefCountDisposable_PrimaryDisposesFirst),
|
||||
("testSingleAssignmentDisposable_firstDisposedThenSet", DisposableTest.testSingleAssignmentDisposable_firstDisposedThenSet),
|
||||
("testSingleAssignmentDisposable_firstSetThenDisposed", DisposableTest.testSingleAssignmentDisposable_firstSetThenDisposed),
|
||||
("testSingleAssignmentDisposable_stress", DisposableTest.testSingleAssignmentDisposable_stress),
|
||||
static var allTests: [(String, (CompletableTest_) -> () -> ())] { return [
|
||||
("testCompletable_Subscription_completed", CompletableTest.testCompletable_Subscription_completed),
|
||||
("testCompletable_Subscription_error", CompletableTest.testCompletable_Subscription_error),
|
||||
("testCompletable_create_completed", CompletableTest.testCompletable_create_completed),
|
||||
("testCompletable_create_error", CompletableTest.testCompletable_create_error),
|
||||
("testCompletable_create_disposing", CompletableTest.testCompletable_create_disposing),
|
||||
("test_error_fails", CompletableTest.test_error_fails),
|
||||
("test_never_producesElement", CompletableTest.test_never_producesElement),
|
||||
("test_deferred", CompletableTest.test_deferred),
|
||||
("test_delaySubscription", CompletableTest.test_delaySubscription),
|
||||
("test_delay", CompletableTest.test_delay),
|
||||
("test_observeOn", CompletableTest.test_observeOn),
|
||||
("test_subscribeOn", CompletableTest.test_subscribeOn),
|
||||
("test_catchError", CompletableTest.test_catchError),
|
||||
("test_retry", CompletableTest.test_retry),
|
||||
("test_retryWhen1", CompletableTest.test_retryWhen1),
|
||||
("test_retryWhen2", CompletableTest.test_retryWhen2),
|
||||
("test_debug", CompletableTest.test_debug),
|
||||
("test_using", CompletableTest.test_using),
|
||||
("test_timeout", CompletableTest.test_timeout),
|
||||
("test_timeout_other", CompletableTest.test_timeout_other),
|
||||
("test_timeout_succeeds", CompletableTest.test_timeout_succeeds),
|
||||
("test_timeout_other_succeeds", CompletableTest.test_timeout_other_succeeds),
|
||||
("test_do", CompletableTest.test_do),
|
||||
("test_concat", CompletableTest.test_concat),
|
||||
("test_concat_sequence", CompletableTest.test_concat_sequence),
|
||||
("test_concat_collection", CompletableTest.test_concat_collection),
|
||||
("test_concat_variadic", CompletableTest.test_concat_variadic),
|
||||
("test_merge_collection", CompletableTest.test_merge_collection),
|
||||
("test_merge_array", CompletableTest.test_merge_array),
|
||||
("test_merge_variadic", CompletableTest.test_merge_variadic),
|
||||
] }
|
||||
}
|
||||
|
||||
@ -491,6 +419,28 @@ final class CompletableAndThenTest_ : CompletableAndThenTest, RxTestCase {
|
||||
] }
|
||||
}
|
||||
|
||||
final class DisposableTest_ : DisposableTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
super.init()
|
||||
}
|
||||
#endif
|
||||
|
||||
static var allTests: [(String, (DisposableTest_) -> () -> ())] { return [
|
||||
("testActionDisposable", DisposableTest.testActionDisposable),
|
||||
("testHotObservable_Disposing", DisposableTest.testHotObservable_Disposing),
|
||||
("testCompositeDisposable_TestNormal", DisposableTest.testCompositeDisposable_TestNormal),
|
||||
("testCompositeDisposable_TestInitWithNumberOfDisposables", DisposableTest.testCompositeDisposable_TestInitWithNumberOfDisposables),
|
||||
("testCompositeDisposable_TestRemoving", DisposableTest.testCompositeDisposable_TestRemoving),
|
||||
("testDisposables_TestCreateWithNumberOfDisposables", DisposableTest.testDisposables_TestCreateWithNumberOfDisposables),
|
||||
("testRefCountDisposable_RefCounting", DisposableTest.testRefCountDisposable_RefCounting),
|
||||
("testRefCountDisposable_PrimaryDisposesFirst", DisposableTest.testRefCountDisposable_PrimaryDisposesFirst),
|
||||
("testSingleAssignmentDisposable_firstDisposedThenSet", DisposableTest.testSingleAssignmentDisposable_firstDisposedThenSet),
|
||||
("testSingleAssignmentDisposable_firstSetThenDisposed", DisposableTest.testSingleAssignmentDisposable_firstSetThenDisposed),
|
||||
("testSingleAssignmentDisposable_stress", DisposableTest.testSingleAssignmentDisposable_stress),
|
||||
] }
|
||||
}
|
||||
|
||||
final class RecursiveLockTests_ : RecursiveLockTests, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
@ -714,6 +664,62 @@ final class SharedSequenceOperatorTests_ : SharedSequenceOperatorTests, RxTestCa
|
||||
] }
|
||||
}
|
||||
|
||||
final class SingleTest_ : SingleTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
super.init()
|
||||
}
|
||||
#endif
|
||||
|
||||
static var allTests: [(String, (SingleTest_) -> () -> ())] { return [
|
||||
("testZip2_selector", SingleTest.testZip2_selector),
|
||||
("testZip2_tuple", SingleTest.testZip2_tuple),
|
||||
("testZip3_selector", SingleTest.testZip3_selector),
|
||||
("testZip3_tuple", SingleTest.testZip3_tuple),
|
||||
("testZip4_selector", SingleTest.testZip4_selector),
|
||||
("testZip4_tuple", SingleTest.testZip4_tuple),
|
||||
("testZip5_selector", SingleTest.testZip5_selector),
|
||||
("testZip5_tuple", SingleTest.testZip5_tuple),
|
||||
("testZip6_selector", SingleTest.testZip6_selector),
|
||||
("testZip6_tuple", SingleTest.testZip6_tuple),
|
||||
("testZip7_selector", SingleTest.testZip7_selector),
|
||||
("testZip7_tuple", SingleTest.testZip7_tuple),
|
||||
("testZip8_selector", SingleTest.testZip8_selector),
|
||||
("testZip8_tuple", SingleTest.testZip8_tuple),
|
||||
("testSingle_Subscription_success", SingleTest.testSingle_Subscription_success),
|
||||
("testSingle_Subscription_error", SingleTest.testSingle_Subscription_error),
|
||||
("testSingle_create_success", SingleTest.testSingle_create_success),
|
||||
("testSingle_create_error", SingleTest.testSingle_create_error),
|
||||
("testSingle_create_disposing", SingleTest.testSingle_create_disposing),
|
||||
("test_just_producesElement", SingleTest.test_just_producesElement),
|
||||
("test_just2_producesElement", SingleTest.test_just2_producesElement),
|
||||
("test_error_fails", SingleTest.test_error_fails),
|
||||
("test_never_producesElement", SingleTest.test_never_producesElement),
|
||||
("test_deferred", SingleTest.test_deferred),
|
||||
("test_delay", SingleTest.test_delay),
|
||||
("test_delaySubscription", SingleTest.test_delaySubscription),
|
||||
("test_observeOn", SingleTest.test_observeOn),
|
||||
("test_subscribeOn", SingleTest.test_subscribeOn),
|
||||
("test_catchError", SingleTest.test_catchError),
|
||||
("test_retry", SingleTest.test_retry),
|
||||
("test_retryWhen1", SingleTest.test_retryWhen1),
|
||||
("test_retryWhen2", SingleTest.test_retryWhen2),
|
||||
("test_debug", SingleTest.test_debug),
|
||||
("test_using", SingleTest.test_using),
|
||||
("test_timeout", SingleTest.test_timeout),
|
||||
("test_timeout_other", SingleTest.test_timeout_other),
|
||||
("test_timeout_succeeds", SingleTest.test_timeout_succeeds),
|
||||
("test_timeout_other_succeeds", SingleTest.test_timeout_other_succeeds),
|
||||
("test_timer", SingleTest.test_timer),
|
||||
("test_do", SingleTest.test_do),
|
||||
("test_filter", SingleTest.test_filter),
|
||||
("test_map", SingleTest.test_map),
|
||||
("test_flatMap", SingleTest.test_flatMap),
|
||||
("test_zip_tuple", SingleTest.test_zip_tuple),
|
||||
("test_zip_resultSelector", SingleTest.test_zip_resultSelector),
|
||||
] }
|
||||
}
|
||||
|
||||
final class ObservableZipTest_ : ObservableZipTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
@ -1243,6 +1249,64 @@ final class ReactiveTests_ : ReactiveTests, RxTestCase {
|
||||
] }
|
||||
}
|
||||
|
||||
final class MaybeTest_ : MaybeTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
super.init()
|
||||
}
|
||||
#endif
|
||||
|
||||
static var allTests: [(String, (MaybeTest_) -> () -> ())] { return [
|
||||
("testMaybe_Subscription_success", MaybeTest.testMaybe_Subscription_success),
|
||||
("testMaybe_Subscription_completed", MaybeTest.testMaybe_Subscription_completed),
|
||||
("testMaybe_Subscription_error", MaybeTest.testMaybe_Subscription_error),
|
||||
("testMaybe_create_success", MaybeTest.testMaybe_create_success),
|
||||
("testMaybe_create_completed", MaybeTest.testMaybe_create_completed),
|
||||
("testMaybe_create_error", MaybeTest.testMaybe_create_error),
|
||||
("testMaybe_create_disposing", MaybeTest.testMaybe_create_disposing),
|
||||
("test_just_producesElement", MaybeTest.test_just_producesElement),
|
||||
("test_just2_producesElement", MaybeTest.test_just2_producesElement),
|
||||
("test_error_fails", MaybeTest.test_error_fails),
|
||||
("test_never_producesElement", MaybeTest.test_never_producesElement),
|
||||
("test_deferred", MaybeTest.test_deferred),
|
||||
("test_delaySubscription", MaybeTest.test_delaySubscription),
|
||||
("test_delay", MaybeTest.test_delay),
|
||||
("test_observeOn", MaybeTest.test_observeOn),
|
||||
("test_subscribeOn", MaybeTest.test_subscribeOn),
|
||||
("test_catchError", MaybeTest.test_catchError),
|
||||
("test_retry", MaybeTest.test_retry),
|
||||
("test_retryWhen1", MaybeTest.test_retryWhen1),
|
||||
("test_retryWhen2", MaybeTest.test_retryWhen2),
|
||||
("test_debug", MaybeTest.test_debug),
|
||||
("test_using", MaybeTest.test_using),
|
||||
("test_timeout", MaybeTest.test_timeout),
|
||||
("test_timeout_other", MaybeTest.test_timeout_other),
|
||||
("test_timeout_succeeds", MaybeTest.test_timeout_succeeds),
|
||||
("test_timeout_other_succeeds", MaybeTest.test_timeout_other_succeeds),
|
||||
("test_timer", MaybeTest.test_timer),
|
||||
("test_do", MaybeTest.test_do),
|
||||
("test_filter", MaybeTest.test_filter),
|
||||
("test_map", MaybeTest.test_map),
|
||||
("test_flatMap", MaybeTest.test_flatMap),
|
||||
("test_zip_tuple", MaybeTest.test_zip_tuple),
|
||||
("test_zip_resultSelector", MaybeTest.test_zip_resultSelector),
|
||||
("testZip2_selector", MaybeTest.testZip2_selector),
|
||||
("testZip2_tuple", MaybeTest.testZip2_tuple),
|
||||
("testZip3_selector", MaybeTest.testZip3_selector),
|
||||
("testZip3_tuple", MaybeTest.testZip3_tuple),
|
||||
("testZip4_selector", MaybeTest.testZip4_selector),
|
||||
("testZip4_tuple", MaybeTest.testZip4_tuple),
|
||||
("testZip5_selector", MaybeTest.testZip5_selector),
|
||||
("testZip5_tuple", MaybeTest.testZip5_tuple),
|
||||
("testZip6_selector", MaybeTest.testZip6_selector),
|
||||
("testZip6_tuple", MaybeTest.testZip6_tuple),
|
||||
("testZip7_selector", MaybeTest.testZip7_selector),
|
||||
("testZip7_tuple", MaybeTest.testZip7_tuple),
|
||||
("testZip8_selector", MaybeTest.testZip8_selector),
|
||||
("testZip8_tuple", MaybeTest.testZip8_tuple),
|
||||
] }
|
||||
}
|
||||
|
||||
final class ObservableMaterializeTest_ : ObservableMaterializeTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
@ -1398,6 +1462,38 @@ final class ObservableCombineLatestTest_ : ObservableCombineLatestTest, RxTestCa
|
||||
] }
|
||||
}
|
||||
|
||||
final class ObservablePrimitiveSequenceTest_ : ObservablePrimitiveSequenceTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
super.init()
|
||||
}
|
||||
#endif
|
||||
|
||||
static var allTests: [(String, (ObservablePrimitiveSequenceTest_) -> () -> ())] { return [
|
||||
("testAsSingle_Empty", ObservablePrimitiveSequenceTest.testAsSingle_Empty),
|
||||
("testAsSingle_One", ObservablePrimitiveSequenceTest.testAsSingle_One),
|
||||
("testAsSingle_Many", ObservablePrimitiveSequenceTest.testAsSingle_Many),
|
||||
("testAsSingle_Error", ObservablePrimitiveSequenceTest.testAsSingle_Error),
|
||||
("testAsSingle_Error2", ObservablePrimitiveSequenceTest.testAsSingle_Error2),
|
||||
("testAsSingle_subscribeOnSuccess", ObservablePrimitiveSequenceTest.testAsSingle_subscribeOnSuccess),
|
||||
("testAsSingle_subscribeOnError", ObservablePrimitiveSequenceTest.testAsSingle_subscribeOnError),
|
||||
("testAsMaybe_Empty", ObservablePrimitiveSequenceTest.testAsMaybe_Empty),
|
||||
("testAsMaybe_One", ObservablePrimitiveSequenceTest.testAsMaybe_One),
|
||||
("testAsMaybe_Many", ObservablePrimitiveSequenceTest.testAsMaybe_Many),
|
||||
("testAsMaybe_Error", ObservablePrimitiveSequenceTest.testAsMaybe_Error),
|
||||
("testAsMaybe_Error2", ObservablePrimitiveSequenceTest.testAsMaybe_Error2),
|
||||
("testAsMaybe_subscribeOnSuccess", ObservablePrimitiveSequenceTest.testAsMaybe_subscribeOnSuccess),
|
||||
("testAsMaybe_subscribeOnError", ObservablePrimitiveSequenceTest.testAsMaybe_subscribeOnError),
|
||||
("testAsMaybe_subscribeOnCompleted", ObservablePrimitiveSequenceTest.testAsMaybe_subscribeOnCompleted),
|
||||
("testAsCompletable_Empty", ObservablePrimitiveSequenceTest.testAsCompletable_Empty),
|
||||
("testAsCompletable_Error", ObservablePrimitiveSequenceTest.testAsCompletable_Error),
|
||||
("testAsCompletable_subscribeOnCompleted", ObservablePrimitiveSequenceTest.testAsCompletable_subscribeOnCompleted),
|
||||
("testAsCompletable_subscribeOnError", ObservablePrimitiveSequenceTest.testAsCompletable_subscribeOnError),
|
||||
("testCompletable_merge", ObservablePrimitiveSequenceTest.testCompletable_merge),
|
||||
("testCompletable_concat", ObservablePrimitiveSequenceTest.testCompletable_concat),
|
||||
] }
|
||||
}
|
||||
|
||||
final class ObservableSubscriptionTests_ : ObservableSubscriptionTests, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
@ -1413,23 +1509,6 @@ final class ObservableSubscriptionTests_ : ObservableSubscriptionTests, RxTestCa
|
||||
] }
|
||||
}
|
||||
|
||||
final class ObservableToArrayTest_ : ObservableToArrayTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
super.init()
|
||||
}
|
||||
#endif
|
||||
|
||||
static var allTests: [(String, (ObservableToArrayTest_) -> () -> ())] { return [
|
||||
("test_ToArrayWithSingleItem_Return", ObservableToArrayTest.test_ToArrayWithSingleItem_Return),
|
||||
("test_ToArrayWithMultipleItems_Return", ObservableToArrayTest.test_ToArrayWithMultipleItems_Return),
|
||||
("test_ToArrayWithNoItems_Empty", ObservableToArrayTest.test_ToArrayWithNoItems_Empty),
|
||||
("test_ToArrayWithSingleItem_Never", ObservableToArrayTest.test_ToArrayWithSingleItem_Never),
|
||||
("test_ToArrayWithImmediateError_Throw", ObservableToArrayTest.test_ToArrayWithImmediateError_Throw),
|
||||
("test_ToArrayWithMultipleItems_Throw", ObservableToArrayTest.test_ToArrayWithMultipleItems_Throw),
|
||||
] }
|
||||
}
|
||||
|
||||
final class ObservableCatchTest_ : ObservableCatchTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
@ -1459,6 +1538,23 @@ final class ObservableCatchTest_ : ObservableCatchTest, RxTestCase {
|
||||
] }
|
||||
}
|
||||
|
||||
final class ObservableToArrayTest_ : ObservableToArrayTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
super.init()
|
||||
}
|
||||
#endif
|
||||
|
||||
static var allTests: [(String, (ObservableToArrayTest_) -> () -> ())] { return [
|
||||
("test_ToArrayWithSingleItem_Return", ObservableToArrayTest.test_ToArrayWithSingleItem_Return),
|
||||
("test_ToArrayWithMultipleItems_Return", ObservableToArrayTest.test_ToArrayWithMultipleItems_Return),
|
||||
("test_ToArrayWithNoItems_Empty", ObservableToArrayTest.test_ToArrayWithNoItems_Empty),
|
||||
("test_ToArrayWithSingleItem_Never", ObservableToArrayTest.test_ToArrayWithSingleItem_Never),
|
||||
("test_ToArrayWithImmediateError_Throw", ObservableToArrayTest.test_ToArrayWithImmediateError_Throw),
|
||||
("test_ToArrayWithMultipleItems_Throw", ObservableToArrayTest.test_ToArrayWithMultipleItems_Throw),
|
||||
] }
|
||||
}
|
||||
|
||||
final class ObserverTests_ : ObserverTests, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
@ -1477,21 +1573,6 @@ final class ObserverTests_ : ObserverTests, RxTestCase {
|
||||
] }
|
||||
}
|
||||
|
||||
final class ConcurrentDispatchQueueSchedulerTests_ : ConcurrentDispatchQueueSchedulerTests, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
super.init()
|
||||
}
|
||||
#endif
|
||||
|
||||
static var allTests: [(String, (ConcurrentDispatchQueueSchedulerTests_) -> () -> ())] { return [
|
||||
("test_scheduleRelative", ConcurrentDispatchQueueSchedulerTests.test_scheduleRelative),
|
||||
("test_scheduleRelativeCancel", ConcurrentDispatchQueueSchedulerTests.test_scheduleRelativeCancel),
|
||||
("test_schedulePeriodic", ConcurrentDispatchQueueSchedulerTests.test_schedulePeriodic),
|
||||
("test_schedulePeriodicCancel", ConcurrentDispatchQueueSchedulerTests.test_schedulePeriodicCancel),
|
||||
] }
|
||||
}
|
||||
|
||||
final class ObservableObserveOnTestConcurrentSchedulerTest_ : ObservableObserveOnTestConcurrentSchedulerTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
@ -1537,6 +1618,21 @@ final class ObservableTimeoutTest_ : ObservableTimeoutTest, RxTestCase {
|
||||
] }
|
||||
}
|
||||
|
||||
final class ConcurrentDispatchQueueSchedulerTests_ : ConcurrentDispatchQueueSchedulerTests, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
super.init()
|
||||
}
|
||||
#endif
|
||||
|
||||
static var allTests: [(String, (ConcurrentDispatchQueueSchedulerTests_) -> () -> ())] { return [
|
||||
("test_scheduleRelative", ConcurrentDispatchQueueSchedulerTests.test_scheduleRelative),
|
||||
("test_scheduleRelativeCancel", ConcurrentDispatchQueueSchedulerTests.test_scheduleRelativeCancel),
|
||||
("test_schedulePeriodic", ConcurrentDispatchQueueSchedulerTests.test_schedulePeriodic),
|
||||
("test_schedulePeriodicCancel", ConcurrentDispatchQueueSchedulerTests.test_schedulePeriodicCancel),
|
||||
] }
|
||||
}
|
||||
|
||||
final class ObservableBufferTest_ : ObservableBufferTest, RxTestCase {
|
||||
#if os(macOS)
|
||||
required override init() {
|
||||
@ -1868,7 +1964,6 @@ func XCTMain(_ tests: [() -> ()]) {
|
||||
testCase(ObservableOptionalTest_.allTests),
|
||||
testCase(AnomaliesTest_.allTests),
|
||||
testCase(ObservableTakeLastTest_.allTests),
|
||||
testCase(PrimitiveSequenceTest_.allTests),
|
||||
testCase(VirtualSchedulerTest_.allTests),
|
||||
testCase(ObservableBlockingTest_.allTests),
|
||||
testCase(ObservableRetryWhenTest_.allTests),
|
||||
@ -1882,8 +1977,9 @@ func XCTMain(_ tests: [() -> ()]) {
|
||||
testCase(ObservableRangeTest_.allTests),
|
||||
testCase(ObservableScanTest_.allTests),
|
||||
testCase(ReplaySubjectTest_.allTests),
|
||||
testCase(DisposableTest_.allTests),
|
||||
testCase(CompletableTest_.allTests),
|
||||
testCase(CompletableAndThenTest_.allTests),
|
||||
testCase(DisposableTest_.allTests),
|
||||
testCase(RecursiveLockTests_.allTests),
|
||||
testCase(ObservableEnumeratedTest_.allTests),
|
||||
testCase(QueueTest_.allTests),
|
||||
@ -1895,6 +1991,7 @@ func XCTMain(_ tests: [() -> ()]) {
|
||||
testCase(ObservableSubscribeOnTest_.allTests),
|
||||
testCase(ObservableWindowTest_.allTests),
|
||||
testCase(SharedSequenceOperatorTests_.allTests),
|
||||
testCase(SingleTest_.allTests),
|
||||
testCase(ObservableZipTest_.allTests),
|
||||
testCase(ObservableSkipUntilTest_.allTests),
|
||||
testCase(ObservableDefaultIfEmptyTest_.allTests),
|
||||
@ -1920,18 +2017,20 @@ func XCTMain(_ tests: [() -> ()]) {
|
||||
testCase(ObservableTimerTest_.allTests),
|
||||
testCase(ObservableShareReplayScopeTests_.allTests),
|
||||
testCase(ReactiveTests_.allTests),
|
||||
testCase(MaybeTest_.allTests),
|
||||
testCase(ObservableMaterializeTest_.allTests),
|
||||
testCase(NSNotificationCenterTests_.allTests),
|
||||
testCase(HistoricalSchedulerTest_.allTests),
|
||||
testCase(MainSchedulerTest_.allTests),
|
||||
testCase(ObservableCombineLatestTest_.allTests),
|
||||
testCase(ObservablePrimitiveSequenceTest_.allTests),
|
||||
testCase(ObservableSubscriptionTests_.allTests),
|
||||
testCase(ObservableToArrayTest_.allTests),
|
||||
testCase(ObservableCatchTest_.allTests),
|
||||
testCase(ObservableToArrayTest_.allTests),
|
||||
testCase(ObserverTests_.allTests),
|
||||
testCase(ConcurrentDispatchQueueSchedulerTests_.allTests),
|
||||
testCase(ObservableObserveOnTestConcurrentSchedulerTest_.allTests),
|
||||
testCase(ObservableTimeoutTest_.allTests),
|
||||
testCase(ConcurrentDispatchQueueSchedulerTests_.allTests),
|
||||
testCase(ObservableBufferTest_.allTests),
|
||||
testCase(BehaviorSubjectTest_.allTests),
|
||||
testCase(ObservableDebugTest_.allTests),
|
||||
|
||||
1
Sources/RxSwift/Completable.swift
Symbolic link
1
Sources/RxSwift/Completable.swift
Symbolic link
@ -0,0 +1 @@
|
||||
../../RxSwift/Traits/Completable.swift
|
||||
1
Sources/RxSwift/Maybe.swift
Symbolic link
1
Sources/RxSwift/Maybe.swift
Symbolic link
@ -0,0 +1 @@
|
||||
../../RxSwift/Traits/Maybe.swift
|
||||
1
Sources/RxSwift/ObservableType+PrimitiveSequence.swift
Symbolic link
1
Sources/RxSwift/ObservableType+PrimitiveSequence.swift
Symbolic link
@ -0,0 +1 @@
|
||||
../../RxSwift/Traits/ObservableType+PrimitiveSequence.swift
|
||||
1
Sources/RxSwift/Single.swift
Symbolic link
1
Sources/RxSwift/Single.swift
Symbolic link
@ -0,0 +1 @@
|
||||
../../RxSwift/Traits/Single.swift
|
||||
544
Tests/RxSwiftTests/CompletableTest.swift
Normal file
544
Tests/RxSwiftTests/CompletableTest.swift
Normal file
@ -0,0 +1,544 @@
|
||||
//
|
||||
// CompletableTest.swift
|
||||
// Tests
|
||||
//
|
||||
// Created by Krunoslav Zaher on 9/17/17.
|
||||
// Copyright © 2017 Krunoslav Zaher. All rights reserved.
|
||||
//
|
||||
|
||||
import XCTest
|
||||
import RxSwift
|
||||
import RxTest
|
||||
|
||||
class CompletableTest : RxTest {
|
||||
|
||||
}
|
||||
|
||||
// completable
|
||||
extension CompletableTest {
|
||||
func testCompletable_Subscription_completed() {
|
||||
let xs = Completable.empty()
|
||||
|
||||
var events: [CompletableEvent] = []
|
||||
|
||||
_ = xs.subscribe { event in
|
||||
events.append(event)
|
||||
}
|
||||
|
||||
XCTAssertEqual(events, [.completed])
|
||||
}
|
||||
|
||||
func testCompletable_Subscription_error() {
|
||||
let xs = Completable.error(testError)
|
||||
|
||||
var events: [CompletableEvent] = []
|
||||
|
||||
_ = xs.subscribe { event in
|
||||
events.append(event)
|
||||
}
|
||||
|
||||
XCTAssertEqual(events, [.error(testError)])
|
||||
}
|
||||
|
||||
func testCompletable_create_completed() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var observer: ((CompletableEvent) -> ())! = 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 {
|
||||
Completable.create { _observer in
|
||||
observer = _observer
|
||||
return Disposables.create {
|
||||
disposedTime = scheduler.clock
|
||||
}
|
||||
}.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(201, Never.self)
|
||||
])
|
||||
|
||||
XCTAssertEqual(disposedTime, 201)
|
||||
}
|
||||
|
||||
func testCompletable_create_error() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var observer: ((CompletableEvent) -> ())! = 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 {
|
||||
Completable.create { _observer in
|
||||
observer = _observer
|
||||
return Disposables.create {
|
||||
disposedTime = scheduler.clock
|
||||
}
|
||||
}.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
error(201, testError)
|
||||
])
|
||||
|
||||
XCTAssertEqual(disposedTime, 201)
|
||||
}
|
||||
|
||||
func testCompletable_create_disposing() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var observer: ((CompletableEvent) -> ())! = nil
|
||||
var disposedTime: Int? = nil
|
||||
var subscription: Disposable! = nil
|
||||
let res = scheduler.createObserver(Never.self)
|
||||
|
||||
scheduler.scheduleAt(201, action: {
|
||||
subscription = Completable.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)
|
||||
}
|
||||
}
|
||||
|
||||
extension CompletableTest {
|
||||
func test_error_fails() {
|
||||
do {
|
||||
_ = try Completable.error(testError).toBlocking().first()
|
||||
XCTFail()
|
||||
}
|
||||
catch let e {
|
||||
XCTAssertEqual(e as! TestError, testError)
|
||||
}
|
||||
}
|
||||
|
||||
func test_never_producesElement() {
|
||||
var event: CompletableEvent? = nil
|
||||
let subscription = Completable.never().subscribe { _event in
|
||||
event = _event
|
||||
}
|
||||
|
||||
XCTAssertNil(event)
|
||||
subscription.dispose()
|
||||
}
|
||||
|
||||
func test_deferred() {
|
||||
let result = try! (Completable.deferred { Completable.empty() } as Completable).toBlocking().toArray()
|
||||
XCTAssertEqual(result, [])
|
||||
}
|
||||
|
||||
func test_delaySubscription() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.empty().delaySubscription(2.0, scheduler: scheduler) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(202)
|
||||
])
|
||||
}
|
||||
|
||||
func test_delay() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.empty().delay(2.0, scheduler: scheduler) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(202)
|
||||
])
|
||||
}
|
||||
|
||||
func test_observeOn() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.empty().observeOn(scheduler) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(201)
|
||||
])
|
||||
}
|
||||
|
||||
func test_subscribeOn() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.empty().subscribeOn(scheduler) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(201)
|
||||
])
|
||||
}
|
||||
|
||||
func test_catchError() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.error(testError).catchError { _ in Completable.empty() } as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_retry() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var isFirst = true
|
||||
let res = scheduler.start {
|
||||
(Completable.error(testError)
|
||||
.catchError { e in
|
||||
defer {
|
||||
isFirst = false
|
||||
}
|
||||
if isFirst {
|
||||
return Completable.error(e)
|
||||
}
|
||||
|
||||
return Completable.empty()
|
||||
}
|
||||
.retry(2) as Completable
|
||||
).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_retryWhen1() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var isFirst = true
|
||||
let res = scheduler.start {
|
||||
(Completable.error(testError)
|
||||
.catchError { e in
|
||||
defer {
|
||||
isFirst = false
|
||||
}
|
||||
if isFirst {
|
||||
return Completable.error(e)
|
||||
}
|
||||
|
||||
return Completable.empty()
|
||||
}
|
||||
.retryWhen { (e: Observable<Error>) in
|
||||
return e
|
||||
} as Completable
|
||||
).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_retryWhen2() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var isFirst = true
|
||||
let res = scheduler.start {
|
||||
(Completable.error(testError)
|
||||
.catchError { e in
|
||||
defer {
|
||||
isFirst = false
|
||||
}
|
||||
if isFirst {
|
||||
return Completable.error(e)
|
||||
}
|
||||
|
||||
return Completable.empty()
|
||||
}
|
||||
.retryWhen { (e: Observable<TestError>) in
|
||||
return e
|
||||
} as Completable
|
||||
).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_debug() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.empty().debug() as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_using() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var disposeInvoked = 0
|
||||
var createInvoked = 0
|
||||
|
||||
var disposable: MockDisposable!
|
||||
var xs: TestableObservable<Never>!
|
||||
var _d: MockDisposable!
|
||||
|
||||
let res = scheduler.start {
|
||||
Completable.using({ () -> MockDisposable in
|
||||
disposeInvoked += 1
|
||||
disposable = MockDisposable(scheduler: scheduler)
|
||||
return disposable
|
||||
}, primitiveSequenceFactory: { (d: MockDisposable) -> Completable in
|
||||
_d = d
|
||||
createInvoked += 1
|
||||
xs = scheduler.createColdObservable([
|
||||
completed(100)
|
||||
])
|
||||
return xs.asObservable().asCompletable()
|
||||
}).asObservable()
|
||||
}
|
||||
|
||||
XCTAssert(disposable === _d)
|
||||
|
||||
XCTAssertEqual(1, createInvoked)
|
||||
XCTAssertEqual(1, disposeInvoked)
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(300)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 300)
|
||||
])
|
||||
|
||||
XCTAssertEqual(disposable.ticks, [
|
||||
200,
|
||||
300
|
||||
])
|
||||
}
|
||||
|
||||
func test_timeout() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createColdObservable([
|
||||
completed(20)
|
||||
]).asCompletable()
|
||||
|
||||
let res = scheduler.start {
|
||||
(xs.timeout(5.0, scheduler: scheduler) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
error(205, RxError.timeout)
|
||||
])
|
||||
}
|
||||
|
||||
func test_timeout_other() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createColdObservable([
|
||||
completed(20)
|
||||
]).asCompletable()
|
||||
|
||||
let xs2 = scheduler.createColdObservable([
|
||||
completed(20)
|
||||
]).asCompletable()
|
||||
|
||||
let res = scheduler.start {
|
||||
(xs.timeout(5.0, other: xs2, scheduler: scheduler) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(225)
|
||||
])
|
||||
}
|
||||
|
||||
func test_timeout_succeeds() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createColdObservable([
|
||||
completed(20)
|
||||
]).asCompletable()
|
||||
|
||||
let res = scheduler.start {
|
||||
(xs.timeout(30.0, scheduler: scheduler) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(220)
|
||||
])
|
||||
}
|
||||
|
||||
func test_timeout_other_succeeds() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createColdObservable([
|
||||
completed(20)
|
||||
]).asCompletable()
|
||||
|
||||
let xs2 = scheduler.createColdObservable([
|
||||
completed(20)
|
||||
]).asCompletable()
|
||||
|
||||
let res = scheduler.start {
|
||||
(xs.timeout(30.0, other: xs2, scheduler: scheduler) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(220)
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
extension CompletableTest {
|
||||
func test_do() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.empty().do(onError: { _ in () }, onSubscribe: { () in () }, onSubscribed: { () in () }, onDispose: { () in () }) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_concat() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.empty().concat(Completable.empty()) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_concat_sequence() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.concat(AnySequence([Completable.empty()])) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_concat_collection() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.concat([Completable.empty()]) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_concat_variadic() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.concat(Completable.empty(), Completable.empty()) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_merge_collection() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.merge(AnyCollection([Completable.empty(), Completable.empty()])) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_merge_array() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.merge([Completable.empty(), Completable.empty()]) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_merge_variadic() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Completable.merge(Completable.empty(), Completable.empty()) as Completable).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
extension Never: Equatable {
|
||||
|
||||
}
|
||||
|
||||
public func == (lhs: Never, rhs: Never) -> Bool {
|
||||
fatalError()
|
||||
}
|
||||
618
Tests/RxSwiftTests/MaybeTest.swift
Normal file
618
Tests/RxSwiftTests/MaybeTest.swift
Normal file
@ -0,0 +1,618 @@
|
||||
//
|
||||
// MaybeTest.swift
|
||||
// Tests
|
||||
//
|
||||
// Created by Krunoslav Zaher on 9/17/17.
|
||||
// Copyright © 2017 Krunoslav Zaher. All rights reserved.
|
||||
//
|
||||
|
||||
import XCTest
|
||||
import RxSwift
|
||||
import RxTest
|
||||
|
||||
class MaybeTest : RxTest {
|
||||
|
||||
}
|
||||
|
||||
// maybe
|
||||
extension MaybeTest {
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
extension MaybeTest {
|
||||
func test_just_producesElement() {
|
||||
let result = try! (Maybe.just(1) as Maybe<Int>).toBlocking().first()!
|
||||
XCTAssertEqual(result, 1)
|
||||
}
|
||||
|
||||
func test_just2_producesElement() {
|
||||
let result = try! (Maybe.just(1, scheduler: CurrentThreadScheduler.instance) as Maybe<Int>).toBlocking().first()!
|
||||
XCTAssertEqual(result, 1)
|
||||
}
|
||||
|
||||
func test_error_fails() {
|
||||
do {
|
||||
_ = try (Maybe<Int>.error(testError) as Maybe<Int>).toBlocking().first()
|
||||
XCTFail()
|
||||
}
|
||||
catch let e {
|
||||
XCTAssertEqual(e as! TestError, testError)
|
||||
}
|
||||
}
|
||||
|
||||
func test_never_producesElement() {
|
||||
var event: MaybeEvent<Int>? = nil
|
||||
let subscription = (Maybe<Int>.never() as Maybe<Int>).subscribe { _event in
|
||||
event = _event
|
||||
}
|
||||
|
||||
XCTAssertNil(event)
|
||||
subscription.dispose()
|
||||
}
|
||||
|
||||
func test_deferred() {
|
||||
let result = try! (Maybe.deferred { Maybe.just(1) } as Maybe<Int>).toBlocking().toArray()
|
||||
XCTAssertEqual(result, [1])
|
||||
}
|
||||
|
||||
func test_delaySubscription() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Maybe.just(1).delaySubscription(2.0, scheduler: scheduler) as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(202, 1),
|
||||
completed(202)
|
||||
])
|
||||
}
|
||||
|
||||
func test_delay() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Maybe.just(1).delay(2.0, scheduler: scheduler) as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(202, 1),
|
||||
completed(203)
|
||||
])
|
||||
}
|
||||
|
||||
func test_observeOn() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Maybe.just(1).observeOn(scheduler) as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(201, 1),
|
||||
completed(202)
|
||||
])
|
||||
}
|
||||
|
||||
func test_subscribeOn() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Maybe.just(1).subscribeOn(scheduler) as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(201, 1),
|
||||
completed(201)
|
||||
])
|
||||
}
|
||||
|
||||
func test_catchError() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Maybe.error(testError).catchError { _ in Maybe.just(2) } as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 2),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_retry() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var isFirst = true
|
||||
let res = scheduler.start {
|
||||
(Maybe.error(testError)
|
||||
.catchError { e in
|
||||
defer {
|
||||
isFirst = false
|
||||
}
|
||||
if isFirst {
|
||||
return Maybe.error(e)
|
||||
}
|
||||
|
||||
return Maybe.just(2)
|
||||
}
|
||||
.retry(2) as Maybe<Int>
|
||||
).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 2),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_retryWhen1() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var isFirst = true
|
||||
let res = scheduler.start {
|
||||
(Maybe.error(testError)
|
||||
.catchError { e in
|
||||
defer {
|
||||
isFirst = false
|
||||
}
|
||||
if isFirst {
|
||||
return Maybe.error(e)
|
||||
}
|
||||
|
||||
return Maybe.just(2)
|
||||
}
|
||||
.retryWhen { (e: Observable<Error>) in
|
||||
return e
|
||||
} as Maybe<Int>
|
||||
).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 2),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_retryWhen2() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var isFirst = true
|
||||
let res = scheduler.start {
|
||||
(Maybe.error(testError)
|
||||
.catchError { e in
|
||||
defer {
|
||||
isFirst = false
|
||||
}
|
||||
if isFirst {
|
||||
return Maybe.error(e)
|
||||
}
|
||||
|
||||
return Maybe.just(2)
|
||||
}
|
||||
.retryWhen { (e: Observable<TestError>) in
|
||||
return e
|
||||
} as Maybe<Int>
|
||||
).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 2),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_debug() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Maybe.just(1).debug() as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 1),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_using() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var disposeInvoked = 0
|
||||
var createInvoked = 0
|
||||
|
||||
var disposable: MockDisposable!
|
||||
var xs: TestableObservable<Int>!
|
||||
var _d: MockDisposable!
|
||||
|
||||
let res = scheduler.start {
|
||||
Maybe.using({ () -> MockDisposable in
|
||||
disposeInvoked += 1
|
||||
disposable = MockDisposable(scheduler: scheduler)
|
||||
return disposable
|
||||
}, primitiveSequenceFactory: { (d: MockDisposable) -> Maybe<Int> in
|
||||
_d = d
|
||||
createInvoked += 1
|
||||
xs = scheduler.createColdObservable([
|
||||
next(100, scheduler.clock),
|
||||
completed(100)
|
||||
])
|
||||
return xs.asObservable().asMaybe()
|
||||
}).asObservable()
|
||||
}
|
||||
|
||||
XCTAssert(disposable === _d)
|
||||
|
||||
XCTAssertEqual(1, createInvoked)
|
||||
XCTAssertEqual(1, disposeInvoked)
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(300, 200),
|
||||
completed(300)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 300)
|
||||
])
|
||||
|
||||
XCTAssertEqual(disposable.ticks, [
|
||||
200,
|
||||
300
|
||||
])
|
||||
}
|
||||
|
||||
func test_timeout() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createColdObservable([
|
||||
next(10, 1),
|
||||
completed(20)
|
||||
]).asMaybe()
|
||||
|
||||
let res = scheduler.start {
|
||||
(xs.timeout(5.0, scheduler: scheduler) as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
error(205, RxError.timeout)
|
||||
])
|
||||
}
|
||||
|
||||
func test_timeout_other() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createColdObservable([
|
||||
next(10, 1),
|
||||
completed(20)
|
||||
]).asMaybe()
|
||||
|
||||
let xs2 = scheduler.createColdObservable([
|
||||
next(20, 2),
|
||||
completed(20)
|
||||
]).asMaybe()
|
||||
|
||||
let res = scheduler.start {
|
||||
(xs.timeout(5.0, other: xs2, scheduler: scheduler) as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(225, 2),
|
||||
completed(225)
|
||||
])
|
||||
}
|
||||
|
||||
func test_timeout_succeeds() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createColdObservable([
|
||||
next(10, 1),
|
||||
completed(20)
|
||||
]).asMaybe()
|
||||
|
||||
let res = scheduler.start {
|
||||
(xs.timeout(30.0, scheduler: scheduler) as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(220, 1),
|
||||
completed(220)
|
||||
])
|
||||
}
|
||||
|
||||
func test_timeout_other_succeeds() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createColdObservable([
|
||||
next(10, 1),
|
||||
completed(20)
|
||||
]).asMaybe()
|
||||
|
||||
let xs2 = scheduler.createColdObservable([
|
||||
next(20, 2),
|
||||
completed(20)
|
||||
]).asMaybe()
|
||||
|
||||
let res = scheduler.start {
|
||||
(xs.timeout(30.0, other: xs2, scheduler: scheduler) as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(220, 1),
|
||||
completed(220)
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
extension MaybeTest {
|
||||
func test_timer() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Maybe<Int>.timer(2, scheduler: scheduler) as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(202, 0),
|
||||
completed(202)
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
extension MaybeTest {
|
||||
func test_do() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Maybe<Int>.just(1).do(onNext: { _ in () }, onError: { _ in () }, onSubscribe: { () in () }, onSubscribed: { () in () }, onDispose: { () in () }) as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 1),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_filter() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Maybe<Int>.just(1).filter { _ in false } as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_map() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Maybe<Int>.just(1).map { $0 * 2 } as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 2),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_flatMap() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Maybe<Int>.just(1).flatMap { .just($0 * 2) } as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 2),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
extension MaybeTest {
|
||||
func test_zip_tuple() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Maybe.zip(Maybe.just(1), Maybe.just(2)) as Maybe<(Int, Int)>).map { $0.0 + $0.1 }.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 3),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_zip_resultSelector() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Maybe.zip(Maybe.just(1), Maybe.just(2)) { $0 + $1 } as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 3),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
511
Tests/RxSwiftTests/Observable+PrimitiveSequenceTest.swift
Normal file
511
Tests/RxSwiftTests/Observable+PrimitiveSequenceTest.swift
Normal file
@ -0,0 +1,511 @@
|
||||
//
|
||||
// Observable+PrimitiveSequenceTest.swift
|
||||
// Tests
|
||||
//
|
||||
// Created by Krunoslav Zaher on 9/17/17.
|
||||
// Copyright © 2017 Krunoslav Zaher. All rights reserved.
|
||||
//
|
||||
|
||||
import XCTest
|
||||
import RxSwift
|
||||
import RxTest
|
||||
|
||||
class ObservablePrimitiveSequenceTest : RxTest {
|
||||
|
||||
}
|
||||
|
||||
extension ObservablePrimitiveSequenceTest {
|
||||
func testAsSingle_Empty() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createHotObservable([
|
||||
next(150, 1),
|
||||
completed(250),
|
||||
error(260, testError)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Int> in
|
||||
let single: Single<Int> = xs.asSingle()
|
||||
return single.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
error(250, RxError.noElements)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 250)
|
||||
])
|
||||
}
|
||||
|
||||
func testAsSingle_One() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createHotObservable([
|
||||
next(150, 1),
|
||||
next(210, 2),
|
||||
completed(250),
|
||||
error(260, testError)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Int> in
|
||||
let single: Single<Int> = xs.asSingle()
|
||||
return single.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(250, 2),
|
||||
completed(250)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 250)
|
||||
])
|
||||
}
|
||||
|
||||
func testAsSingle_Many() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createHotObservable([
|
||||
next(150, 1),
|
||||
next(210, 2),
|
||||
next(220, 3),
|
||||
completed(250),
|
||||
error(260, testError)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Int> in
|
||||
let single: Single<Int> = xs.asSingle()
|
||||
return single.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
error(220, RxError.moreThanOneElement)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 220)
|
||||
])
|
||||
}
|
||||
|
||||
func testAsSingle_Error() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createHotObservable([
|
||||
next(150, 1),
|
||||
error(210, testError)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Int> in
|
||||
let single: Single<Int> = xs.asSingle()
|
||||
return single.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
error(210, testError)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 210)
|
||||
])
|
||||
}
|
||||
|
||||
func testAsSingle_Error2() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createHotObservable([
|
||||
next(150, 1),
|
||||
next(205, 2),
|
||||
error(210, testError)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Int> in
|
||||
let single: Single<Int> = xs.asSingle()
|
||||
return single.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
error(210, testError)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 210)
|
||||
])
|
||||
}
|
||||
|
||||
func testAsSingle_subscribeOnSuccess() {
|
||||
var events: [SingleEvent<Int>] = []
|
||||
|
||||
_ = Single.just(1).subscribe(onSuccess: { element in
|
||||
events.append(.success(element))
|
||||
}, onError: { error in
|
||||
events.append(.error(error))
|
||||
})
|
||||
|
||||
XCTAssertEqual(events, [.success(1)])
|
||||
}
|
||||
|
||||
func testAsSingle_subscribeOnError() {
|
||||
var events: [SingleEvent<Int>] = []
|
||||
|
||||
_ = Single.error(testError).subscribe(onSuccess: { element in
|
||||
events.append(.success(element))
|
||||
}, onError: { error in
|
||||
events.append(.error(error))
|
||||
})
|
||||
|
||||
XCTAssertEqual(events, [.error(testError)])
|
||||
}
|
||||
|
||||
#if TRACE_RESOURCES
|
||||
func testAsSingleReleasesResourcesOnComplete() {
|
||||
_ = Observable<Int>.just(1).asSingle().subscribe({ _ in })
|
||||
}
|
||||
|
||||
func testAsSingleReleasesResourcesOnError1() {
|
||||
_ = Observable<Int>.error(testError).asSingle().subscribe({ _ in })
|
||||
}
|
||||
|
||||
func testAsSingleReleasesResourcesOnError2() {
|
||||
_ = Observable<Int>.of(1, 2).asSingle().subscribe({ _ in })
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
extension ObservablePrimitiveSequenceTest {
|
||||
func testAsMaybe_Empty() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createHotObservable([
|
||||
next(150, 1),
|
||||
completed(250),
|
||||
error(260, testError)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Int> in
|
||||
let maybe: Maybe<Int> = xs.asMaybe()
|
||||
return maybe.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(250)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 250)
|
||||
])
|
||||
}
|
||||
|
||||
func testAsMaybe_One() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createHotObservable([
|
||||
next(150, 1),
|
||||
next(210, 2),
|
||||
completed(250),
|
||||
error(260, testError)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Int> in
|
||||
let maybe: Maybe<Int> = xs.asMaybe()
|
||||
return maybe.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(250, 2),
|
||||
completed(250)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 250)
|
||||
])
|
||||
}
|
||||
|
||||
func testAsMaybe_Many() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createHotObservable([
|
||||
next(150, 1),
|
||||
next(210, 2),
|
||||
next(220, 3),
|
||||
completed(250),
|
||||
error(260, testError)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Int> in
|
||||
let maybe: Maybe<Int> = xs.asMaybe()
|
||||
return maybe.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
error(220, RxError.moreThanOneElement)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 220)
|
||||
])
|
||||
}
|
||||
|
||||
func testAsMaybe_Error() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createHotObservable([
|
||||
next(150, 1),
|
||||
error(210, testError)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Int> in
|
||||
let maybe: Maybe<Int> = xs.asMaybe()
|
||||
return maybe.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
error(210, testError)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 210)
|
||||
])
|
||||
}
|
||||
|
||||
func testAsMaybe_Error2() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createHotObservable([
|
||||
next(150, 1),
|
||||
next(205, 2),
|
||||
error(210, testError)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Int> in
|
||||
let maybe: Maybe<Int> = xs.asMaybe()
|
||||
return maybe.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
error(210, testError)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 210)
|
||||
])
|
||||
}
|
||||
|
||||
func testAsMaybe_subscribeOnSuccess() {
|
||||
var events: [MaybeEvent<Int>] = []
|
||||
|
||||
_ = Maybe.just(1).subscribe(onSuccess: { element in
|
||||
events.append(.success(element))
|
||||
}, onError: { error in
|
||||
events.append(.error(error))
|
||||
}, onCompleted: {
|
||||
events.append(.completed)
|
||||
})
|
||||
|
||||
XCTAssertEqual(events, [.success(1)])
|
||||
}
|
||||
|
||||
func testAsMaybe_subscribeOnError() {
|
||||
var events: [MaybeEvent<Int>] = []
|
||||
|
||||
_ = Maybe.error(testError).subscribe(onSuccess: { element in
|
||||
events.append(.success(element))
|
||||
}, onError: { error in
|
||||
events.append(.error(error))
|
||||
}, onCompleted: {
|
||||
events.append(.completed)
|
||||
})
|
||||
|
||||
XCTAssertEqual(events, [.error(testError)])
|
||||
}
|
||||
|
||||
func testAsMaybe_subscribeOnCompleted() {
|
||||
var events: [MaybeEvent<Int>] = []
|
||||
|
||||
_ = Maybe.empty().subscribe(onSuccess: { element in
|
||||
events.append(.success(element))
|
||||
}, onError: { error in
|
||||
events.append(.error(error))
|
||||
}, onCompleted: {
|
||||
events.append(.completed)
|
||||
})
|
||||
|
||||
XCTAssertEqual(events, [.completed])
|
||||
}
|
||||
|
||||
#if TRACE_RESOURCES
|
||||
func testAsMaybeReleasesResourcesOnComplete1() {
|
||||
_ = Observable<Int>.empty().asMaybe().subscribe({ _ in })
|
||||
}
|
||||
|
||||
func testAsMaybeReleasesResourcesOnComplete2() {
|
||||
_ = Observable<Int>.just(1).asMaybe().subscribe({ _ in })
|
||||
}
|
||||
|
||||
func testAsMaybeReleasesResourcesOnError1() {
|
||||
_ = Observable<Int>.error(testError).asMaybe().subscribe({ _ in })
|
||||
}
|
||||
|
||||
func testAsMaybeReleasesResourcesOnError2() {
|
||||
_ = Observable<Int>.of(1, 2).asMaybe().subscribe({ _ in })
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
extension ObservablePrimitiveSequenceTest {
|
||||
func testAsCompletable_Empty() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createHotObservable([
|
||||
completed(250, Never.self),
|
||||
error(260, testError)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Never> in
|
||||
let completable: Completable = xs.asCompletable()
|
||||
return completable.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(250)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 250)
|
||||
])
|
||||
}
|
||||
|
||||
func testAsCompletable_Error() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createHotObservable([
|
||||
error(210, testError, Never.self)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Never> in
|
||||
let completable: Completable = xs.asCompletable()
|
||||
return completable.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
error(210, testError)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 210)
|
||||
])
|
||||
}
|
||||
|
||||
func testAsCompletable_subscribeOnCompleted() {
|
||||
var events: [CompletableEvent] = []
|
||||
|
||||
_ = Completable.empty().subscribe(onCompleted: {
|
||||
events.append(.completed)
|
||||
}, onError: { error in
|
||||
events.append(.error(error))
|
||||
})
|
||||
|
||||
XCTAssertEqual(events, [.completed])
|
||||
}
|
||||
|
||||
func testAsCompletable_subscribeOnError() {
|
||||
var events: [CompletableEvent] = []
|
||||
|
||||
_ = Completable.error(testError).subscribe(onCompleted: {
|
||||
events.append(.completed)
|
||||
}, onError: { error in
|
||||
events.append(.error(error))
|
||||
})
|
||||
|
||||
XCTAssertEqual(events, [.error(testError)])
|
||||
}
|
||||
|
||||
#if TRACE_RESOURCES
|
||||
func testAsCompletableReleasesResourcesOnComplete() {
|
||||
_ = Observable<Never>.empty().asCompletable().subscribe({ _ in })
|
||||
}
|
||||
|
||||
func testAsCompletableReleasesResourcesOnError() {
|
||||
_ = Observable<Never>.error(testError).asCompletable().subscribe({ _ in })
|
||||
}
|
||||
#endif
|
||||
|
||||
func testCompletable_merge() {
|
||||
let factories: [(Completable, Completable) -> Completable] =
|
||||
[
|
||||
{ ys1, ys2 in Completable.merge(ys1, ys2) },
|
||||
{ ys1, ys2 in Completable.merge([ys1, ys2]) },
|
||||
{ ys1, ys2 in Completable.merge(AnyCollection([ys1, ys2])) },
|
||||
]
|
||||
|
||||
for factory in factories {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let ys1 = scheduler.createHotObservable([
|
||||
completed(250, Never.self),
|
||||
error(260, testError)
|
||||
])
|
||||
|
||||
let ys2 = scheduler.createHotObservable([
|
||||
completed(300, Never.self)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Never> in
|
||||
let completable: Completable = factory(ys1.asCompletable(), ys2.asCompletable())
|
||||
return completable.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(300)
|
||||
])
|
||||
|
||||
XCTAssertEqual(ys1.subscriptions, [
|
||||
Subscription(200, 250),
|
||||
])
|
||||
|
||||
XCTAssertEqual(ys2.subscriptions, [
|
||||
Subscription(200, 300),
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
func testCompletable_concat() {
|
||||
let factories: [(Completable, Completable) -> Completable] =
|
||||
[
|
||||
{ ys1, ys2 in Completable.concat(ys1, ys2) },
|
||||
{ ys1, ys2 in Completable.concat([ys1, ys2]) },
|
||||
{ ys1, ys2 in Completable.concat(AnyCollection([ys1, ys2])) },
|
||||
{ ys1, ys2 in ys1.concat(ys2) }
|
||||
]
|
||||
|
||||
for factory in factories {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let ys1 = scheduler.createHotObservable([
|
||||
completed(250, Never.self),
|
||||
error(260, testError)
|
||||
])
|
||||
|
||||
let ys2 = scheduler.createHotObservable([
|
||||
completed(300, Never.self)
|
||||
])
|
||||
|
||||
let res = scheduler.start { () -> Observable<Never> in
|
||||
let completable: Completable = factory(ys1.asCompletable(), ys2.asCompletable())
|
||||
return completable.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(300)
|
||||
])
|
||||
|
||||
XCTAssertEqual(ys1.subscriptions, [
|
||||
Subscription(200, 250),
|
||||
])
|
||||
|
||||
XCTAssertEqual(ys2.subscriptions, [
|
||||
Subscription(250, 300),
|
||||
])
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -15,8 +15,8 @@ import RxTest
|
||||
|
||||
// 2
|
||||
|
||||
extension PrimitiveSequenceTest {
|
||||
func testZip2_selector_producesSingleElement() {
|
||||
extension SingleTest {
|
||||
func testZip2_selector() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1)) { $0 + $1 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -24,7 +24,7 @@ extension PrimitiveSequenceTest {
|
||||
XCTAssertEqual(result, 2)
|
||||
}
|
||||
|
||||
func testZip2_producesSingleElement() {
|
||||
func testZip2_tuple() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1)).map { $0 + $1 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -33,12 +33,30 @@ extension PrimitiveSequenceTest {
|
||||
}
|
||||
}
|
||||
|
||||
extension MaybeTest {
|
||||
func testZip2_selector() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1)) { $0 + $1 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 2)
|
||||
}
|
||||
|
||||
func testZip2_tuple() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1)).map { $0 + $1 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 2)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// 3
|
||||
|
||||
extension PrimitiveSequenceTest {
|
||||
func testZip3_selector_producesSingleElement() {
|
||||
extension SingleTest {
|
||||
func testZip3_selector() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1)) { $0 + $1 + $2 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -46,7 +64,7 @@ extension PrimitiveSequenceTest {
|
||||
XCTAssertEqual(result, 3)
|
||||
}
|
||||
|
||||
func testZip3_producesSingleElement() {
|
||||
func testZip3_tuple() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1)).map { $0 + $1 + $2 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -55,12 +73,30 @@ extension PrimitiveSequenceTest {
|
||||
}
|
||||
}
|
||||
|
||||
extension MaybeTest {
|
||||
func testZip3_selector() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1)) { $0 + $1 + $2 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 3)
|
||||
}
|
||||
|
||||
func testZip3_tuple() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1)).map { $0 + $1 + $2 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 3)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// 4
|
||||
|
||||
extension PrimitiveSequenceTest {
|
||||
func testZip4_selector_producesSingleElement() {
|
||||
extension SingleTest {
|
||||
func testZip4_selector() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1)) { $0 + $1 + $2 + $3 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -68,7 +104,7 @@ extension PrimitiveSequenceTest {
|
||||
XCTAssertEqual(result, 4)
|
||||
}
|
||||
|
||||
func testZip4_producesSingleElement() {
|
||||
func testZip4_tuple() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1)).map { $0 + $1 + $2 + $3 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -77,12 +113,30 @@ extension PrimitiveSequenceTest {
|
||||
}
|
||||
}
|
||||
|
||||
extension MaybeTest {
|
||||
func testZip4_selector() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1)) { $0 + $1 + $2 + $3 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 4)
|
||||
}
|
||||
|
||||
func testZip4_tuple() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1)).map { $0 + $1 + $2 + $3 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 4)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// 5
|
||||
|
||||
extension PrimitiveSequenceTest {
|
||||
func testZip5_selector_producesSingleElement() {
|
||||
extension SingleTest {
|
||||
func testZip5_selector() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1)) { $0 + $1 + $2 + $3 + $4 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -90,7 +144,7 @@ extension PrimitiveSequenceTest {
|
||||
XCTAssertEqual(result, 5)
|
||||
}
|
||||
|
||||
func testZip5_producesSingleElement() {
|
||||
func testZip5_tuple() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1)).map { $0 + $1 + $2 + $3 + $4 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -99,12 +153,30 @@ extension PrimitiveSequenceTest {
|
||||
}
|
||||
}
|
||||
|
||||
extension MaybeTest {
|
||||
func testZip5_selector() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1)) { $0 + $1 + $2 + $3 + $4 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 5)
|
||||
}
|
||||
|
||||
func testZip5_tuple() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1)).map { $0 + $1 + $2 + $3 + $4 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 5)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// 6
|
||||
|
||||
extension PrimitiveSequenceTest {
|
||||
func testZip6_selector_producesSingleElement() {
|
||||
extension SingleTest {
|
||||
func testZip6_selector() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1)) { $0 + $1 + $2 + $3 + $4 + $5 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -112,7 +184,7 @@ extension PrimitiveSequenceTest {
|
||||
XCTAssertEqual(result, 6)
|
||||
}
|
||||
|
||||
func testZip6_producesSingleElement() {
|
||||
func testZip6_tuple() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1)).map { $0 + $1 + $2 + $3 + $4 + $5 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -121,12 +193,30 @@ extension PrimitiveSequenceTest {
|
||||
}
|
||||
}
|
||||
|
||||
extension MaybeTest {
|
||||
func testZip6_selector() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1)) { $0 + $1 + $2 + $3 + $4 + $5 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 6)
|
||||
}
|
||||
|
||||
func testZip6_tuple() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1)).map { $0 + $1 + $2 + $3 + $4 + $5 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 6)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// 7
|
||||
|
||||
extension PrimitiveSequenceTest {
|
||||
func testZip7_selector_producesSingleElement() {
|
||||
extension SingleTest {
|
||||
func testZip7_selector() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1)) { $0 + $1 + $2 + $3 + $4 + $5 + $6 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -134,7 +224,7 @@ extension PrimitiveSequenceTest {
|
||||
XCTAssertEqual(result, 7)
|
||||
}
|
||||
|
||||
func testZip7_producesSingleElement() {
|
||||
func testZip7_tuple() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1)).map { $0 + $1 + $2 + $3 + $4 + $5 + $6 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -143,12 +233,30 @@ extension PrimitiveSequenceTest {
|
||||
}
|
||||
}
|
||||
|
||||
extension MaybeTest {
|
||||
func testZip7_selector() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1)) { $0 + $1 + $2 + $3 + $4 + $5 + $6 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 7)
|
||||
}
|
||||
|
||||
func testZip7_tuple() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1)).map { $0 + $1 + $2 + $3 + $4 + $5 + $6 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 7)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// 8
|
||||
|
||||
extension PrimitiveSequenceTest {
|
||||
func testZip8_selector_producesSingleElement() {
|
||||
extension SingleTest {
|
||||
func testZip8_selector() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1)) { $0 + $1 + $2 + $3 + $4 + $5 + $6 + $7 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -156,7 +264,7 @@ extension PrimitiveSequenceTest {
|
||||
XCTAssertEqual(result, 8)
|
||||
}
|
||||
|
||||
func testZip8_producesSingleElement() {
|
||||
func testZip8_tuple() {
|
||||
let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1)).map { $0 + $1 + $2 + $3 + $4 + $5 + $6 + $7 }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -165,4 +273,22 @@ extension PrimitiveSequenceTest {
|
||||
}
|
||||
}
|
||||
|
||||
extension MaybeTest {
|
||||
func testZip8_selector() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1)) { $0 + $1 + $2 + $3 + $4 + $5 + $6 + $7 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 8)
|
||||
}
|
||||
|
||||
func testZip8_tuple() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1)).map { $0 + $1 + $2 + $3 + $4 + $5 + $6 + $7 }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, 8)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -14,8 +14,8 @@ import RxTest
|
||||
|
||||
// <%= i %>
|
||||
|
||||
extension PrimitiveSequenceTest {
|
||||
func testZip<%= i %>_selector_producesSingleElement() {
|
||||
extension SingleTest {
|
||||
func testZip<%= i %>_selector() {
|
||||
let singleResult: Single<Int> = Single.zip(<%= (Array(1...i).map { _ in "Single.just(1)" }).joined(separator: ", ") %>) { <%= (Array(0..<i).map { "$\($0)" }).joined(separator: " + ") %> }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -23,7 +23,7 @@ extension PrimitiveSequenceTest {
|
||||
XCTAssertEqual(result, <%= i %>)
|
||||
}
|
||||
|
||||
func testZip<%= i %>_producesSingleElement() {
|
||||
func testZip<%= i %>_tuple() {
|
||||
let singleResult: Single<Int> = Single.zip(<%= (Array(1...i).map { _ in "Single.just(1)" }).joined(separator: ", ") %>).map { <%= (Array(0..<i).map { "$\($0)" }).joined(separator: " + ") %> }
|
||||
|
||||
let result = try! singleResult
|
||||
@ -32,4 +32,22 @@ extension PrimitiveSequenceTest {
|
||||
}
|
||||
}
|
||||
|
||||
extension MaybeTest {
|
||||
func testZip<%= i %>_selector() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(<%= (Array(1...i).map { _ in "Maybe.just(1)" }).joined(separator: ", ") %>) { <%= (Array(0..<i).map { "$\($0)" }).joined(separator: " + ") %> }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, <%= i %>)
|
||||
}
|
||||
|
||||
func testZip<%= i %>_tuple() {
|
||||
let singleResult: Maybe<Int> = Maybe.zip(<%= (Array(1...i).map { _ in "Maybe.just(1)" }).joined(separator: ", ") %>).map { <%= (Array(0..<i).map { "$\($0)" }).joined(separator: " + ") %> }
|
||||
|
||||
let result = try! singleResult
|
||||
.toBlocking().first()!
|
||||
XCTAssertEqual(result, <%= i %>)
|
||||
}
|
||||
}
|
||||
|
||||
<% } %>
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
565
Tests/RxSwiftTests/SingleTest.swift
Normal file
565
Tests/RxSwiftTests/SingleTest.swift
Normal file
@ -0,0 +1,565 @@
|
||||
//
|
||||
// SingleTest.swift
|
||||
// Tests
|
||||
//
|
||||
// Created by Krunoslav Zaher on 9/17/17.
|
||||
// Copyright © 2017 Krunoslav Zaher. All rights reserved.
|
||||
//
|
||||
|
||||
import XCTest
|
||||
import RxSwift
|
||||
import RxTest
|
||||
|
||||
class SingleTest : RxTest {
|
||||
|
||||
}
|
||||
|
||||
// single
|
||||
extension SingleTest {
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
extension SingleTest {
|
||||
func test_just_producesElement() {
|
||||
let result = try! (Single.just(1) as Single<Int>).toBlocking().first()!
|
||||
XCTAssertEqual(result, 1)
|
||||
}
|
||||
|
||||
func test_just2_producesElement() {
|
||||
let result = try! (Single.just(1, scheduler: CurrentThreadScheduler.instance) as Single<Int>).toBlocking().first()!
|
||||
XCTAssertEqual(result, 1)
|
||||
}
|
||||
|
||||
func test_error_fails() {
|
||||
do {
|
||||
_ = try (Single<Int>.error(testError) as Single<Int>).toBlocking().first()
|
||||
XCTFail()
|
||||
}
|
||||
catch let e {
|
||||
XCTAssertEqual(e as! TestError, testError)
|
||||
}
|
||||
}
|
||||
|
||||
func test_never_producesElement() {
|
||||
var event: SingleEvent<Int>? = nil
|
||||
let subscription = (Single<Int>.never() as Single<Int>).subscribe { _event in
|
||||
event = _event
|
||||
}
|
||||
|
||||
XCTAssertNil(event)
|
||||
subscription.dispose()
|
||||
}
|
||||
|
||||
func test_deferred() {
|
||||
let result = try! (Single.deferred { Single.just(1) } as Single<Int>).toBlocking().toArray()
|
||||
XCTAssertEqual(result, [1])
|
||||
}
|
||||
|
||||
func test_delay() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Single.just(1).delay(2.0, scheduler: scheduler) as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(202, 1),
|
||||
completed(203)
|
||||
])
|
||||
}
|
||||
|
||||
func test_delaySubscription() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Single.just(1).delaySubscription(2.0, scheduler: scheduler) as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(202, 1),
|
||||
completed(202)
|
||||
])
|
||||
}
|
||||
|
||||
func test_observeOn() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Single.just(1).observeOn(scheduler) as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(201, 1),
|
||||
completed(202)
|
||||
])
|
||||
}
|
||||
|
||||
func test_subscribeOn() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Single.just(1).subscribeOn(scheduler) as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(201, 1),
|
||||
completed(201)
|
||||
])
|
||||
}
|
||||
|
||||
func test_catchError() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Single.error(testError).catchError { _ in Single.just(2) } as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 2),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_retry() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var isFirst = true
|
||||
let res = scheduler.start {
|
||||
(Single.error(testError)
|
||||
.catchError { e in
|
||||
defer {
|
||||
isFirst = false
|
||||
}
|
||||
if isFirst {
|
||||
return Single.error(e)
|
||||
}
|
||||
|
||||
return Single.just(2)
|
||||
}
|
||||
.retry(2) as Single<Int>
|
||||
).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 2),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_retryWhen1() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var isFirst = true
|
||||
let res = scheduler.start {
|
||||
(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
|
||||
} as Single<Int>
|
||||
).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 2),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_retryWhen2() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var isFirst = true
|
||||
let res = scheduler.start {
|
||||
(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
|
||||
} as Single<Int>
|
||||
).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 2),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_debug() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Single.just(1).debug() as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 1),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_using() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
var disposeInvoked = 0
|
||||
var createInvoked = 0
|
||||
|
||||
var disposable: MockDisposable!
|
||||
var xs: TestableObservable<Int>!
|
||||
var _d: MockDisposable!
|
||||
|
||||
let res = scheduler.start {
|
||||
Single.using({ () -> MockDisposable in
|
||||
disposeInvoked += 1
|
||||
disposable = MockDisposable(scheduler: scheduler)
|
||||
return disposable
|
||||
}, primitiveSequenceFactory: { (d: MockDisposable) -> Single<Int> in
|
||||
_d = d
|
||||
createInvoked += 1
|
||||
xs = scheduler.createColdObservable([
|
||||
next(100, scheduler.clock),
|
||||
completed(100)
|
||||
])
|
||||
return xs.asObservable().asSingle()
|
||||
}).asObservable()
|
||||
}
|
||||
|
||||
XCTAssert(disposable === _d)
|
||||
|
||||
XCTAssertEqual(1, createInvoked)
|
||||
XCTAssertEqual(1, disposeInvoked)
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(300, 200),
|
||||
completed(300)
|
||||
])
|
||||
|
||||
XCTAssertEqual(xs.subscriptions, [
|
||||
Subscription(200, 300)
|
||||
])
|
||||
|
||||
XCTAssertEqual(disposable.ticks, [
|
||||
200,
|
||||
300
|
||||
])
|
||||
}
|
||||
|
||||
func test_timeout() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createColdObservable([
|
||||
next(10, 1),
|
||||
completed(20)
|
||||
]).asSingle()
|
||||
|
||||
let res = scheduler.start {
|
||||
(xs.timeout(5.0, scheduler: scheduler) as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
error(205, RxError.timeout)
|
||||
])
|
||||
}
|
||||
|
||||
func test_timeout_other() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createColdObservable([
|
||||
next(10, 1),
|
||||
completed(20)
|
||||
]).asSingle()
|
||||
|
||||
let xs2 = scheduler.createColdObservable([
|
||||
next(20, 2),
|
||||
completed(20)
|
||||
]).asSingle()
|
||||
|
||||
let res = scheduler.start {
|
||||
(xs.timeout(5.0, other: xs2, scheduler: scheduler) as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(225, 2),
|
||||
completed(225)
|
||||
])
|
||||
}
|
||||
|
||||
func test_timeout_succeeds() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createColdObservable([
|
||||
next(10, 1),
|
||||
completed(20)
|
||||
]).asSingle()
|
||||
|
||||
let res = scheduler.start {
|
||||
(xs.timeout(30.0, scheduler: scheduler) as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(220, 1),
|
||||
completed(220)
|
||||
])
|
||||
}
|
||||
|
||||
func test_timeout_other_succeeds() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let xs = scheduler.createColdObservable([
|
||||
next(10, 1),
|
||||
completed(20)
|
||||
]).asSingle()
|
||||
|
||||
let xs2 = scheduler.createColdObservable([
|
||||
next(20, 2),
|
||||
completed(20)
|
||||
]).asSingle()
|
||||
|
||||
let res = scheduler.start {
|
||||
(xs.timeout(30.0, other: xs2, scheduler: scheduler) as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(220, 1),
|
||||
completed(220)
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
extension SingleTest {
|
||||
func test_timer() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Single<Int>.timer(2, scheduler: scheduler) as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(202, 0),
|
||||
completed(202)
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
extension SingleTest {
|
||||
func test_do() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Single<Int>.just(1).do(onNext: { _ in () }, onError: { _ in () }, onSubscribe: { () in () }, onSubscribed: { () in () }, onDispose: { () in () }) as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 1),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_filter() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Single<Int>.just(1).filter { _ in false } as Maybe<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_map() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Single<Int>.just(1).map { $0 * 2 } as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 2),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_flatMap() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Single<Int>.just(1).flatMap { .just($0 * 2) } as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 2),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
extension SingleTest {
|
||||
func test_zip_tuple() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Single.zip(Single.just(1), Single.just(2)) as Single<(Int, Int)>).map { $0.0 + $0.1 }.asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 3),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
|
||||
func test_zip_resultSelector() {
|
||||
let scheduler = TestScheduler(initialClock: 0)
|
||||
|
||||
let res = scheduler.start {
|
||||
(Single.zip(Single.just(1), Single.just(2)) { $0 + $1 } as Single<Int>).asObservable()
|
||||
}
|
||||
|
||||
XCTAssertEqual(res.events, [
|
||||
next(200, 3),
|
||||
completed(200)
|
||||
])
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user