Add PromiseKit dependency

- Added PromiseKit dependency

Carthage/Checkouts/PromiseKit/Tests/A+/2.2.3.swift

@@ -0,0 +1,93 @@
+import PromiseKit
+import XCTest
+
+class Test223: XCTestCase {
+    func test() {
+        describe("2.2.3: If `onRejected` is a function,") {
+            describe("2.2.3.1: it must be called after `promise` is rejected, with `promise`’s rejection reason as its first argument.") {
+                testRejected { promise, expectation, sentinel in
+                    promise.catch { error in
+                        if case Error.sentinel(let value) = error {
+                            XCTAssertEqual(value, sentinel)
+                        } else {
+                            XCTFail()
+                        }
+                        expectation.fulfill()
+                    }
+                }
+            }
+            describe("2.2.3.2: it must not be called before `promise` is rejected") {
+                specify("rejected after a delay") { d, expectation in
+                    var called = false
+                    d.promise.catch { _ in
+                        called = true
+                        expectation.fulfill()
+                    }
+                    after(ticks: 1) {
+                        XCTAssertFalse(called)
+                        d.reject(Error.dummy)
+                    }
+                }
+                specify("never rejected") { d, expectation in
+                    d.promise.catch { _ in XCTFail() }
+                    after(ticks: 1, execute: expectation.fulfill)
+                }
+            }
+            describe("2.2.3.3: it must not be called more than once.") {
+                specify("already-rejected") { d, expectation in
+                    var timesCalled = 0
+                    Promise<Int>(error: Error.dummy).catch { _ in
+                        XCTAssertEqual(++timesCalled, 1)
+                    }
+                    after(ticks: 2) {
+                        XCTAssertEqual(timesCalled, 1)
+                        expectation.fulfill()
+                    }
+                }
+                specify("trying to reject a pending promise more than once, immediately") { d, expectation in
+                    d.promise.catch{_ in expectation.fulfill() }
+                    d.reject(Error.dummy)
+                    d.reject(Error.dummy)
+                }
+                specify("trying to reject a pending promise more than once, delayed") { d, expectation in
+                    d.promise.catch{_ in expectation.fulfill() }
+                    after(ticks: 1) {
+                        d.reject(Error.dummy)
+                        d.reject(Error.dummy)
+                    }
+                }
+                specify("trying to reject a pending promise more than once, immediately then delayed") { d, expectation in
+                    d.promise.catch{_ in expectation.fulfill() }
+                    d.reject(Error.dummy)
+                    after(ticks: 1) {
+                        d.reject(Error.dummy)
+                    }
+                }
+                specify("when multiple `then` calls are made, spaced apart in time") { d, expectation in
+                    let mk = { self.expectation(description: "") }
+                    let ex = (expectation, mk(), mk(), mk())
+
+                    do {
+                        d.promise.catch{ _ in ex.0.fulfill() }
+                    }
+                    after(ticks: 1) {
+                        d.promise.catch{ _ in ex.1.fulfill() }
+                    }
+                    after(ticks: 2) {
+                        d.promise.catch{ _ in ex.2.fulfill() }
+                    }
+                    after(ticks: 3) {
+                        d.reject(Error.dummy)
+                        ex.3.fulfill()
+                    }
+                }
+                specify("when `then` is interleaved with rejection") { d, expectation in
+                    let ex = (expectation, self.expectation(description: ""))
+                    d.promise.catch{ _ in ex.0.fulfill() }
+                    d.reject(Error.dummy)
+                    d.promise.catch{ _ in ex.1.fulfill() }
+                }
+            }
+        }
+    }
+}