[Test] Add more examples for different Error type handling.

Author: inamiy

SwiftTaskTests/MultipleErrorTypesTests.swift

@@ -12,9 +12,10 @@ import XCTest
 
 class MultipleErrorTypesTests: _TestCase
 {
-    enum MyEnum
+    enum MyEnum: Printable
     {
         case Default
+        var description: String { return "MyEnumDefault" }
     }
 
     struct Dummy {}
@@ -25,7 +26,7 @@ class MultipleErrorTypesTests: _TestCase
     var flow = [Int]()
 
     // delayed task + counting flow 1 & 2
-    func _task1(#success: Bool) -> Task1
+    func _task1(#ok: Bool) -> Task1
     {
         return Task1 { progress, fulfill, reject, configure in
             println("[task1] start")
@@ -35,14 +36,14 @@ class MultipleErrorTypesTests: _TestCase
                 println("[task1] end")
                 self.flow += [2]
 
-                success ? fulfill("OK") : reject("NG")
+                ok ? fulfill("OK") : reject("NG")
             }
             return
         }
     }
 
     // delayed task + counting flow 4 & 5
-    func _task2(#success: Bool) -> Task2
+    func _task2(#ok: Bool) -> Task2
     {
         return Task2 { progress, fulfill, reject, configure in
             println("[task2] start")
@@ -52,7 +53,7 @@ class MultipleErrorTypesTests: _TestCase
                 println("[task2] end")
                 self.flow += [5]
 
-                success ? fulfill(.Default) : reject(.Default)
+                ok ? fulfill(.Default) : reject(.Default)
             }
             return
         }
@@ -62,13 +63,13 @@ class MultipleErrorTypesTests: _TestCase
     {
         var expect = self.expectationWithDescription(__FUNCTION__)
 
-        self._task1(success: true)
+        self._task1(ok: true)
             .then { value, errorInfo -> Task2 in
 
                 println("task1.then")
                 self.flow += [3]
 
-                return self._task2(success: true)
+                return self._task2(ok: true)
 
             }
             .then { value, errorInfo -> Void in
@@ -88,13 +89,13 @@ class MultipleErrorTypesTests: _TestCase
     {
         var expect = self.expectationWithDescription(__FUNCTION__)
 
-        self._task1(success: true)
+        self._task1(ok: true)
             .success { value -> Task2 in
 
                 println("task1.success")
                 self.flow += [3]
 
-                return self._task2(success: true)
+                return self._task2(ok: true)
 
             }
             .success { value -> Void in
@@ -110,11 +111,89 @@ class MultipleErrorTypesTests: _TestCase
         self.wait()
     }
 
+    func testMultipleErrorTypes_success_differentErrorType()
+    {
+        var expect = self.expectationWithDescription(__FUNCTION__)
+        
+        self._task1(ok: true)
+            .success { value -> Task2 in
+                
+                println("task1.success")
+                self.flow += [3]
+                
+                //
+                // NOTE: 
+                // If Task1 and Task2 have different Error types,
+                // returning `self._task2(ok: false)` inside `self._task1.success()` will fail error conversion 
+                // (Task2.Error -> Task1.Error).
+                //
+                return self._task2(ok: false) // inner rejection with different Error type
+                
+            }
+            .then { value, errorInfo -> Void in
+                
+                println("task1.success.success (task2 should end at this point)")
+                self.flow += [6]
+                
+                XCTAssertEqual(self.flow, Array(1...6), "Tasks should flow in order from 1 to 6.")
+                
+                XCTAssertTrue(value == nil)
+                XCTAssertTrue(errorInfo != nil)
+                XCTAssertTrue(errorInfo!.error == nil, "Though `errorInfo` will still be non-nil, `errorInfo!.error` will become as `nil` if Task1 and Task2 have different Error types.")
+                XCTAssertTrue(errorInfo!.isCancelled == false)
+                
+                expect.fulfill()
+                
+            }
+        
+        self.wait()
+    }
+    
+    func testMultipleErrorTypes_success_differentErrorType_conversion()
+    {
+        var expect = self.expectationWithDescription(__FUNCTION__)
+        
+        self._task1(ok: true)
+            .success { value -> Task<Void, MyEnum, String> in
+                
+                println("task1.success")
+                self.flow += [3]
+                
+                //
+                // NOTE:
+                // Since returning `self._task2(ok: false)` inside `self._task1.success()` will fail error conversion
+                // (Task2.Error -> Task1.Error) as seen in above test case,
+                // it is **user's responsibility** to add conversion logic to maintain same Error type throughout task-flow.
+                //
+                return self._task2(ok: false)
+                    .failure { Task<Void, MyEnum, String>(error: "Mapping errorInfo=\($0.error!) to String") }  // error-conversion
+                
+            }
+            .then { value, errorInfo -> Void in
+                
+                println("task1.success.success (task2 should end at this point)")
+                self.flow += [6]
+                
+                XCTAssertEqual(self.flow, Array(1...6), "Tasks should flow in order from 1 to 6.")
+                
+                XCTAssertTrue(value == nil)
+                XCTAssertTrue(errorInfo != nil)
+                XCTAssertEqual(errorInfo!.error!, "Mapping errorInfo=MyEnumDefault to String",
+                    "Now `self._task2()`'s error is catched by this scope by adding manual error-conversion logic by user side.")
+                XCTAssertTrue(errorInfo!.isCancelled == false)
+                
+                expect.fulfill()
+                
+        }
+        
+        self.wait()
+    }
+
     func testMultipleErrorTypes_failure()
     {
         var expect = self.expectationWithDescription(__FUNCTION__)
 
-        self._task1(success: false)
+        self._task1(ok: false)
             .failure { errorInfo -> Task<Dummy, String /* must be task1's value type to recover */, Dummy> in
 
                 println("task1.failure")
@@ -125,7 +204,7 @@ class MultipleErrorTypesTests: _TestCase
                 // Returning `Task2` won't work since same Value type as `task1` is required inside `task1.failure()`,
                 // so use `then()` to promote `Task2` to `Task<..., Task1.Value, ...>`.
                 //
-                return self._task2(success: false).then { value, errorInfo in
+                return self._task2(ok: false).then { value, errorInfo in
                     return Task<Dummy, String, Dummy>(error: Dummy())  // error task
                 }
             }