Add PromiseKit dependency

- Added PromiseKit dependency

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

@@ -0,0 +1,146 @@
+import PromiseKit
+import XCTest
+
+class Test224: XCTestCase {
+    func test() {
+        describe("2.2.4: `onFulfilled` or `onRejected` must not be called until the execution context stack contains only platform code.") {
+
+            describe("`then` returns before the promise becomes fulfilled or rejected") {
+                testFulfilled { promise, expectation, dummy in
+                    var thenHasReturned = false
+                    promise.done { _ in
+                        XCTAssert(thenHasReturned)
+                        expectation.fulfill()
+                    }.silenceWarning()
+                    thenHasReturned = true
+                }
+                testRejected { promise, expectation, memo in
+                    var catchHasReturned = false
+                    promise.catch { _->() in
+                        XCTAssert(catchHasReturned)
+                        expectation.fulfill()
+                    }
+                    catchHasReturned = true
+                }
+
+            }
+
+            describe("Clean-stack execution ordering tests (fulfillment case)") {
+                specify("when `onFulfilled` is added immediately before the promise is fulfilled") { d, expectation in
+                    var onFulfilledCalled = false
+                    d.promise.done {
+                        onFulfilledCalled = true
+                        expectation.fulfill()
+                    }.silenceWarning()
+                    d.fulfill()
+                    XCTAssertFalse(onFulfilledCalled)
+                }
+                specify("when `onFulfilled` is added immediately after the promise is fulfilled") { d, expectation in
+                    var onFulfilledCalled = false
+                    d.fulfill()
+                    d.promise.done {
+                        onFulfilledCalled = true
+                        expectation.fulfill()
+                    }.silenceWarning()
+                    XCTAssertFalse(onFulfilledCalled)
+                }
+                specify("when one `onFulfilled` is added inside another `onFulfilled`") { _, expectation in
+                    var firstOnFulfilledFinished = false
+                    let promise = Promise()
+                    promise.done {
+                        promise.done {
+                            XCTAssertTrue(firstOnFulfilledFinished)
+                            expectation.fulfill()
+                        }.silenceWarning()
+                        firstOnFulfilledFinished = true
+                    }.silenceWarning()
+                }
+
+                specify("when `onFulfilled` is added inside an `onRejected`") { _, expectation in
+                    let promise1 = Promise<Void>(error: Error.dummy)
+                    let promise2 = Promise()
+                    var firstOnRejectedFinished = false
+
+                    promise1.catch { _ in
+                        promise2.done {
+                            XCTAssertTrue(firstOnRejectedFinished)
+                            expectation.fulfill()
+                        }.silenceWarning()
+                        firstOnRejectedFinished = true
+                    }
+                }
+                
+                specify("when the promise is fulfilled asynchronously") { d, expectation in
+                    var firstStackFinished = false
+
+                    after(ticks: 1) {
+                        d.fulfill()
+                        firstStackFinished = true
+                    }
+
+                    d.promise.done {
+                        XCTAssertTrue(firstStackFinished)
+                        expectation.fulfill()
+                    }.silenceWarning()
+                }
+            }
+
+            describe("Clean-stack execution ordering tests (rejection case)") {
+                specify("when `onRejected` is added immediately before the promise is rejected") { d, expectation in
+                    var onRejectedCalled = false
+                    d.promise.catch { _ in
+                        onRejectedCalled = true
+                        expectation.fulfill()
+                    }
+                    d.reject(Error.dummy)
+                    XCTAssertFalse(onRejectedCalled)
+                }
+                specify("when `onRejected` is added immediately after the promise is rejected") { d, expectation in
+                    var onRejectedCalled = false
+                    d.reject(Error.dummy)
+                    d.promise.catch { _ in
+                        onRejectedCalled = true
+                        expectation.fulfill()
+                    }
+                    XCTAssertFalse(onRejectedCalled)
+                }
+                specify("when `onRejected` is added inside an `onFulfilled`") { d, expectation in
+                    let promise1 = Promise()
+                    let promise2 = Promise<Void>(error: Error.dummy)
+                    var firstOnFulfilledFinished = false
+
+                    promise1.done { _ in
+                        promise2.catch { _ in
+                            XCTAssertTrue(firstOnFulfilledFinished)
+                            expectation.fulfill()
+                        }
+                        firstOnFulfilledFinished = true
+                    }.silenceWarning()
+                }
+                specify("when one `onRejected` is added inside another `onRejected`") { d, expectation in
+                    let promise = Promise<Void>(error: Error.dummy)
+                    var firstOnRejectedFinished = false;
+
+                    promise.catch { _ in
+                        promise.catch { _ in
+                            XCTAssertTrue(firstOnRejectedFinished)
+                            expectation.fulfill()
+                        }
+                        firstOnRejectedFinished = true
+                    }
+                }
+                specify("when the promise is rejected asynchronously") { d, expectation in
+                    var firstStackFinished = false
+                    after(ticks: 1) {
+                        d.reject(Error.dummy)
+                        firstStackFinished = true
+                    }
+                    d.promise.catch { _ in
+                        XCTAssertTrue(firstStackFinished)
+                        expectation.fulfill()
+                    }
+                }
+            }
+        }
+    }
+}