From 5a390609caeb2c535f38fb438f16fbbfb4c8d251 Mon Sep 17 00:00:00 2001
From: "Hirose.Yudai" <hirose.yudai@moneyforward.co.jp>
Date: Mon, 1 Feb 2016 11:50:52 +0900
Subject: [PATCH 1/2] Implement when function

---
 SwiftTask/SwiftTask.swift           | 50 +++++++++++++++++++++++++++++
 SwiftTaskTests/SwiftTaskTests.swift | 30 +++++++++++++++++
 2 files changed, 80 insertions(+)

diff --git a/SwiftTask/SwiftTask.swift b/SwiftTask/SwiftTask.swift
index 6415a1b..493e0e5 100644
--- a/SwiftTask/SwiftTask.swift
+++ b/SwiftTask/SwiftTask.swift
@@ -821,6 +821,56 @@ extension Task
         }.name("Task.some")
     }
     
+    private func toAnyTask() -> Task<Progress, AnyObject, Error>
+    {
+        return self.then{ (value, failureInfo) -> Task<Progress, AnyObject, Error> in
+            if let value = value as? AnyObject {
+                return Task<Progress, AnyObject ,Error>(value: value)
+            }
+            if let error = failureInfo?.error {
+                return Task<Progress, AnyObject, Error>(error: error)
+            }
+            fatalError()
+        }
+    }
+    
+    public class func when<Progress, Error, V, V2>(tasks: (Task<Progress, V, Error>, Task<Progress, V2, Error>)) -> Task<BulkProgress, (V, V2), Error>
+    {
+        return Task<BulkProgress, (V, V2), Error> { progress, fulfill, reject, _ in
+            Task<Progress, AnyObject, Error>.all([tasks.0.toAnyTask(), tasks.1.toAnyTask()]).success { values in
+                guard   let v1 = values[0] as? V,
+                    let v2 = values[1] as? V2 else {
+                        fatalError()
+                }
+                fulfill((v1, v2))
+                }.failure { error, _ in
+                    guard let error = error else { return }
+                    reject(error)
+                }.progress { (oldProgress, newProgress) -> Void in
+                    progress(newProgress)
+                }.name("Task.when")
+        }
+    }
+    
+    public class func when<Progress, Error, V, V2, V3>(tasks: (Task<Progress, V, Error>, Task<Progress, V2, Error>, Task<Progress, V3, Error>)) -> Task<BulkProgress, (V, V2, V3), Error>
+    {
+        return Task<BulkProgress, (V, V2, V3), Error> { progress, fulfill, reject, _ in
+            Task<Progress, AnyObject, Error>.all([tasks.0.toAnyTask(), tasks.1.toAnyTask(), tasks.2.toAnyTask()]).success { values in
+                guard   let v1 = values[0] as? V,
+                    let v2 = values[1] as? V2,
+                    let v3 = values[2] as? V3 else {
+                        fatalError()
+                }
+                fulfill((v1, v2, v3))
+                }.failure { error, _ in
+                    guard let error = error else { return }
+                    reject(error)
+                }.progress { (oldProgress, newProgress) -> Void in
+                    progress(newProgress)
+                }.name("Task.when")
+        }
+    }
+    
     public class func cancelAll(tasks: [Task])
     {
         for task in tasks {
diff --git a/SwiftTaskTests/SwiftTaskTests.swift b/SwiftTaskTests/SwiftTaskTests.swift
index f9be681..b6b9cb9 100644
--- a/SwiftTaskTests/SwiftTaskTests.swift
+++ b/SwiftTaskTests/SwiftTaskTests.swift
@@ -1565,4 +1565,34 @@ class SwiftTaskTests: _TestCase
         
         self.wait()
     }
+    
+    //--------------------------------------------------
+    // MARK: - When
+    //--------------------------------------------------
+   
+    func testWhen_success() {
+        let task1 = Task<Float, String, NSError?> { fulfill, reject in fulfill("Success") }
+        let task2 = Task<Float, Int, NSError?> { fulfill, reject in fulfill(1) }
+        let task3 = Task<Float, Double, NSError?> { fulfill, reject in fulfill(1.1) }
+        
+        Task<Float, (String, Int), NSError>.when((task1, task2, task3)).success { (string, int, double) -> Void in
+            XCTAssertEqual(string, "Success")
+            XCTAssertEqual(int, 1)
+            XCTAssertEqual(double, 1.1)
+            }.failure { _ in
+                XCTFail()
+        }
+    }
+    
+    func testWhen_failure() {
+        let task1 = Task<Float, String, String> { fulfill, reject in fulfill("Success") }
+        let task2 = Task<Float, Int, String> { fulfill, reject in fulfill(1) }
+        let task3 = Task<Float, Double, String> { fulfill, reject in  reject("Rejected") }
+        
+        Task<Float, (String, Int), NSError>.when((task1, task2, task3)).success { (string, int, double) -> Void in
+            XCTFail()
+            }.failure { (error, isCancelled) -> Void in
+                XCTAssertEqual(error, "Rejected")
+        }
+    }
 }

From 8ab343ce9e0a58e76bcf3fcafc1b071047e64696 Mon Sep 17 00:00:00 2001
From: "Hirose.Yudai" <hirose.yudai@moneyforward.co.jp>
Date: Mon, 1 Feb 2016 13:50:16 +0900
Subject: [PATCH 2/2] Fix: mistake generics type

---
 SwiftTaskTests/SwiftTaskTests.swift | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/SwiftTaskTests/SwiftTaskTests.swift b/SwiftTaskTests/SwiftTaskTests.swift
index b6b9cb9..ffd70cd 100644
--- a/SwiftTaskTests/SwiftTaskTests.swift
+++ b/SwiftTaskTests/SwiftTaskTests.swift
@@ -1575,7 +1575,7 @@ class SwiftTaskTests: _TestCase
         let task2 = Task<Float, Int, NSError?> { fulfill, reject in fulfill(1) }
         let task3 = Task<Float, Double, NSError?> { fulfill, reject in fulfill(1.1) }
         
-        Task<Float, (String, Int), NSError>.when((task1, task2, task3)).success { (string, int, double) -> Void in
+        Task<Float, (String, Int, Double), NSError>.when((task1, task2, task3)).success { (string, int, double) -> Void in
             XCTAssertEqual(string, "Success")
             XCTAssertEqual(int, 1)
             XCTAssertEqual(double, 1.1)
@@ -1589,7 +1589,7 @@ class SwiftTaskTests: _TestCase
         let task2 = Task<Float, Int, String> { fulfill, reject in fulfill(1) }
         let task3 = Task<Float, Double, String> { fulfill, reject in  reject("Rejected") }
         
-        Task<Float, (String, Int), NSError>.when((task1, task2, task3)).success { (string, int, double) -> Void in
+        Task<Float, (String, Int, Double), String>.when((task1, task2, task3)).success { (string, int, double) -> Void in
             XCTFail()
             }.failure { (error, isCancelled) -> Void in
                 XCTAssertEqual(error, "Rejected")