How to use Awaiter class

1//2//  TaskAwaiter.swift3//  AlecrimAsyncKit4//5//  Created by Vanderlei Martinelli on 09/03/18.6//  Copyright © 2018 Alecrim. All rights reserved.7//8import Foundation9private let _taskAwaiterDefaultDispatchQueue = DispatchQueue(label: "com.alecrim.AlecrimAsyncKit.TaskAwaiter", qos: .utility, attributes: .concurrent)10// MARK: - TaskAwaiter11public final class TaskAwaiter<V, E: Swift.Error> {12    fileprivate let queue: DispatchQueue13    fileprivate let callbackQueue: DispatchQueue14    public let task: Task<V, E>15    fileprivate var thenClosure: ((V) -> Void)?16    fileprivate var catchClosure: ((E) -> Void)?17    fileprivate var cancelClosure: (() -> Void)?18    fileprivate var finallyClosure: (() -> Void)?19    fileprivate init(queue: DispatchQueue, callbackQueue: DispatchQueue, task: Task<V, E>) {20        self.queue = queue21        self.callbackQueue = callbackQueue22        self.task = task23    }24}25// MARK: -26extension TaskAwaiter where E == Error {27    @discardableResult28    public func then(_ closure: @escaping (V) -> Void) -> Self {29        self.thenClosure = closure30        return self31    }32    @discardableResult33    public func `catch`(_ closure: @escaping (E) -> Void) -> Self {34        self.catchClosure = closure35        return self36    }37    @discardableResult38    public func cancelled(_ closure: @escaping () -> Void) -> Self {39        self.cancelClosure = closure40        return self41    }42    @discardableResult43    public func finally(_ closure: @escaping () -> Void) -> Self {44        self.finallyClosure = closure45        return self46    }47}48extension TaskAwaiter where E == Never {49    @discardableResult50    public func then(_ closure: @escaping (V) -> Void) -> Self {51        self.thenClosure = closure52        return self53    }54}55// MARK: -56extension TaskAwaiter where E == Error {57    fileprivate func enqueue() {58        self.queue.async {59            defer {60                if let finallyClosure = self.finallyClosure {61                    self.finallyClosure = nil62                    self.callbackQueue.async {63                        finallyClosure()64                    }65                }66            }67            do {68                let value = try await(self.task)69                if let thenClosure = self.thenClosure {70                    self.callbackQueue.async {71                        thenClosure(value)72                        self.thenClosure = nil73                    }74                }75            }76            catch {77                if error.isUserCancelled {78                    if let cancelClosure = self.cancelClosure {79                        self.callbackQueue.async {80                            cancelClosure()81                            self.cancelClosure = nil82                        }83                    }84                }85                else {86                    if let catchClosure = self.catchClosure {87                        self.callbackQueue.async {88                            catchClosure(error)89                            self.catchClosure = nil90                        }91                    }92                }93            }94        }95    }96}97extension TaskAwaiter where E == Never {98    fileprivate func enqueue() {99        self.queue.async {100            let value = await(self.task)101            if let thenClosure = self.thenClosure {102                self.callbackQueue.async {103                    thenClosure(value)104                    self.thenClosure = nil105                }106            }107        }108    }109}110// MARK: -111extension Task where E == Error {112    @discardableResult113    public func then(on queue: DispatchQueue? = nil, callbackQueue: DispatchQueue? = nil, closure: @escaping (V) -> Void) -> TaskAwaiter<V, E> {114        let ta = TaskAwaiter(queue: queue ?? _taskAwaiterDefaultDispatchQueue, callbackQueue: callbackQueue ?? DispatchQueue.main, task: self).then(closure)115        ta.enqueue()116        return ta117    }118    @discardableResult119    public func `catch`(on queue: DispatchQueue? = nil, callbackQueue: DispatchQueue? = nil, closure: @escaping (E) -> Void) -> TaskAwaiter<V, E> {120        let ta = TaskAwaiter(queue: queue ?? _taskAwaiterDefaultDispatchQueue, callbackQueue: callbackQueue ?? DispatchQueue.main, task: self).catch(closure)121        ta.enqueue()122        return ta123    }124    @discardableResult125    public func cancelled(on queue: DispatchQueue? = nil, callbackQueue: DispatchQueue? = nil, closure: @escaping () -> Void) -> TaskAwaiter<V, E> {126        let ta = TaskAwaiter(queue: queue ?? _taskAwaiterDefaultDispatchQueue, callbackQueue: callbackQueue ?? DispatchQueue.main, task: self).cancelled(closure)127        ta.enqueue()128        return ta129    }130    @discardableResult131    public func finally(on queue: DispatchQueue? = nil, callbackQueue: DispatchQueue? = nil, closure: @escaping () -> Void) -> TaskAwaiter<V, E> {132        let ta = TaskAwaiter(queue: queue ?? _taskAwaiterDefaultDispatchQueue, callbackQueue: callbackQueue ?? DispatchQueue.main, task: self).finally(closure)133        ta.enqueue()134        return ta135    }136}137extension Task where E == Never {138    @discardableResult139    public func then(on queue: DispatchQueue? = nil, callbackQueue: DispatchQueue? = nil, closure: @escaping (V) -> Void) -> TaskAwaiter<V, E> {140        let ta = TaskAwaiter(queue: queue ?? _taskAwaiterDefaultDispatchQueue, callbackQueue: callbackQueue ?? DispatchQueue.main, task: self).then(closure)141        ta.enqueue()142        return ta143    }144}...

...24        get { return NimbleAssertionHandler }25        set { NimbleAssertionHandler = newValue }26    }27    var suppressTVOSAssertionWarning: Bool = false28    var awaiter: Awaiter29    override init() {30        let timeoutQueue = DispatchQueue.global(qos: .userInitiated)31        awaiter = Awaiter(32            waitLock: AssertionWaitLock(),33            asyncQueue: .main,34            timeoutQueue: timeoutQueue35        )36        super.init()37    }38}...

1import Nimble2func test() {3    let awaiter = Awaiter()4    awaiter.await { done in5        done()6    }7}8import Nimble9func test() {10    let awaiter = Awaiter()11    awaiter.await { done in12        done()13    }14}15import Nimble16func test() {17    let awaiter = Awaiter()18    awaiter.await { done in19        done()20    }21}22import Nimble23func test() {24    let awaiter = Awaiter()25    awaiter.await { done in26        done()27    }28}29import Nimble30func test() {31    let awaiter = Awaiter()32    awaiter.await { done in33        done()34    }35}36import Nimble37func test() {38    let awaiter = Awaiter()39    awaiter.await { done in40        done()41    }42}43import Nimble44func test() {45    let awaiter = Awaiter()46    awaiter.await { done in47        done()48    }49}50import Nimble51func test() {52    let awaiter = Awaiter()53    awaiter.await { done in54        done()55    }56}57import Nimble58func test() {59    let awaiter = Awaiter()60    awaiter.await { done in61        done()62    }63}64import Nimble65func test() {66    let awaiter = Awaiter()67    awaiter.await {

1let result = try awaiter.await { (completion) in2    doSomethingAsynchronous(completion)3}4let result = try awaiter.await { (completion) in5    doSomethingAsynchronous(completion)6}7let result = try awaiter.await { (completion) in8    doSomethingAsynchronous(completion)9}10let result = try awaiter.await { (completion) in11    doSomethingAsynchronous(completion)12}13let result = try awaiter.await { (completion) in14    doSomethingAsynchronous(completion)15}16let result = try awaiter.await { (completion) in17    doSomethingAsynchronous(completion)18}19let result = try awaiter.await { (completion) in20    doSomethingAsynchronous(completion)21}22let result = try awaiter.await { (completion) in23    doSomethingAsynchronous(completion)24}25let result = try awaiter.await { (completion) in26    doSomethingAsynchronous(completion)27}28let result = try awaiter.await { (completion) in29    doSomethingAsynchronous(completion)30}31let result = try awaiter.await { (completion) in32    doSomethingAsynchronous(completion)33}34let result = try awaiter.await { (completion) in35    doSomethingAsynchronous(completion)36}37let result = try awaiter.await { (completion) in

1import Nimble2import XCTest3class AwaiterTest: XCTestCase {4    func testAwaiter() {5        let awaiter = Awaiter()6        awaiter.wait(for: 1)7        expect(awaiter.isDone).to(beTrue())8    }9}10import XCTest11class Awaiter {12    func wait(for seconds: TimeInterval) {13        let wait = DispatchTime.now() + seconds14        DispatchQueue.main.asyncAfter(deadline: wait) {15        }16    }17}18I am trying to use the Nimble framework in my project. I have added it to my Podfile and run pod install. I can see the framework in my Pods folder, but I am not able to import it in my project. I have tried the following: import Nimble import Nimble/Nimble import Nimble/Nimble.framework import Nimble/Nimble.framework/Headers import Nimble/Nimble.framework/Headers/Nimble import Nimble/Nimble.framework/Headers/Nimble.h import Nimble/Nimble.framework/Headers/Nimble.h import Nimble/Nimble.framework/Modules import Nimble/Nimble.framework/Modules/Nimble import Nimble/Nimble.framework/Modules/Nimble.swiftmodule import Nimble/Nimble.framework/Modules/Nimble.swiftmodule/x86_64.swiftmodule import Nimble/Nimble.framework/Modules/Nimble.swiftmodule/x86_64.swiftmodule/Nimble.swiftmodule import Nimble/Nimble.framework/Modules/Nimble.swiftmodule/x86_64.swiftmodule/Nimble.swiftmodule/Nimble.swiftmodule import Nimble/Nimble.framework/Modules/Nimble.swiftmodule/x86_64.swiftmodule/Nimble.swiftmodule/Nimble.swiftmodule/Nimble.swiftmodule import Nimble/Nimble.framework/Modules/Nimble.swiftmodule/x86_64.swiftmodule/Nimble.swiftmodule/Nimble.swiftmodule/Nimble.swiftmodule/Nimble.swiftmodule import Nimble/Nimble.framework/Modules/Nimble.swiftmodule/x86_64.swiftmodule/Nimble.swiftmodule/Nimble.swiftmodule/Nimble.swiftmodule/Nimble.swiftmodule/Nimble.swiftmodule import Nimble/Nimble.framework/Modules/Nimble.swiftmodule/x86_64.swiftmodule/Nimble.swiftmodule/Nimble.swiftmodule/Nimble.swiftmodule

1let result = try awaiter.await { (completion) in2    doSomethingAsynchronous(completion)3}4let result = try awaiter.await { (completion) in5    doSomethingAsynchronous(completion)6}7let result = try awaiter.await { (completion) in8    doSomethingAsynchronous(completion)9}10let result = try awaiter.await { (completion) in11    doSomethingAsynchronous(completion)12}13let result = try awaiter.await { (completion) in14    doSomethingAsynchronous(completion)15}16let result = try awaiter.await { (completion) in17    doSomethingAsynchronous(completion)18}19let result = try awaiter.await { (completion) in20    doSomethingAsynchronous(completion)21}22let result = try awaiter.await { (completion) in23    doSomethingAsynchronous(completion)24}25let result = try awaiter.await { (completion) in26    doSomethingAsynchronous(completion)27}28let result = try awaiter.await { (completion) in29    doSomethingAsynchronous(completion)30}31let result = try awaiter.await { (completion) in32    doSomethingAsynchronous(completion)33}34let result = try awaiter.await { (completion) in35    doSomethingAsynchronous(completion)36}37let result = try awaiter.await { (completion) in

1import Foundation2import Nimble3func main() {4    let awaiter = Awaiter()5    awaiter.expectation = expectation(description: "Waiting for 1 second")6    DispatchQueue.global().asyncAfter(deadline: .now() + 1) {7        awaiter.fulfill()8    }9    waitForExpectations(timeout: 2)10}11main()12import Foundation13import XCTest14class Awaiter {15    func fulfill() {16        expectation?.fulfill()17    }18}19func main() {20    let awaiter = Awaiter()21    awaiter.expectation = expectation(description: "Waiting for 1 second")22    DispatchQueue.global().asyncAfter(deadline: .now() + 1) {23        awaiter.fulfill()24    }25    waitForExpectations(timeout: 2)26}27main()28	 Executed 1 test, with 0 failures (0 unexpected) in 1.000 (1.000) seconds29	 Executed 1 test, with 0 failures (0 unexpected) in 1.000 (1.000) seconds

1import Nimble2import Foundation3import XCTest4class Test: XCTestCase {5    func test() {6        let waiter = Waiter()7        let result = waiter.waitUntil(timeout: 10) { done in8            DispatchQueue.global().async {9                done(.completed)10            }11        }12        expect(result).to(equal(.completed))13    }14}15import Nimble16import Foundation17import XCTest18class Test: XCTestCase {19    func test() {20        let waiter = Waiter()21        let result = waiter.waitUntil(timeout: 10) { done in22            DispatchQueue.global().async {23                done(.completed)24            }25        }26        expect(result).to(equal(.completed))27    }28}29import Nimble30import Foundation31import XCTest32class Test: XCTestCase {33    func test() {34        let waiter = Waiter()35        let result = waiter.waitUntil(timeout: 10) { done in36            DispatchQueue.global().async {37                done(.completed)38            }39        }40        expect(result).to(equal(.completed))41    }42}43import Nimble44import Foundation45import XCTest46class Test: XCTestCase {47    func test() {48        let waiter = Waiter()49        let result = waiter.waitUntil(timeout: 10) { done in50            DispatchQueue.global().async {51                done(.completed)52            }53        }54        expect(result).to(equal(.completed))55    }56}57import Nimble58import Foundation59import XCTest60class Test: XCTestCase {61    func test() {62        let waiter = Waiter()63        let result = waiter.waitUntil(timeout: 10) { done in64            DispatchQueue.global().async {65                done(.completed)66            }67        }68        expect(result).to(equal(.completed))69    }70}71import Nimble72import Foundation73import XCTest74class Test: XCTestCase {75    func test() {76        let waiter = Waiter()77        let result = waiter.waitUntil(timeout: 10) { done in78            DispatchQueue.global().async {79                done(.completed)80            }81        }

1import Nimble2import XCTest3class ATest: XCTestCase {4    func test() {5        let exp = expectation(description: "wait")6        let awaiter = Awaiter()7        awaiter.await { exp.fulfill() }8        waitForExpectations(timeout: 1, handler: nil)9    }10}11import Nimble12import XCTest13class BTest: XCTestCase {14    func test() {15        let exp = expectation(description: "wait")16        let awaiter = Awaiter()17        awaiter.await { exp.fulfill() }18        waitForExpectations(timeout: 1, handler: nil)19    }20}21import Nimble22import XCTest23class CTest: XCTestCase {24    func test() {25        let exp = expectation(description: "wait")26        let awaiter = Awaiter()27        awaiter.await { exp.fulfill() }28        waitForExpectations(timeout: 1, handler: nil)29    }30}31import Nimble32import XCTest33class DTest: XCTestCase {34    func test() {35        let exp = expectation(description: "wait")36        let awaiter = Awaiter()37        awaiter.await { exp.fulfill() }38        waitForExpectations(timeout: 1, handler: nil)39    }40}41import Nimble42import XCTest43class ETest: XCTestCase {44    func test() {45        let exp = expectation(description: "wait")46        let awaiter = Awaiter()47        awaiter.await { exp.fulfill() }48        waitForExpectations(timeout: 1, handler: nil)49    }50}51import Nimble52import XCTest53class FTest: XCTestCase {54    func test() {55        let exp = expectation(description: "wait")56        let awaiter = Awaiter()57        awaiter.await { exp.fulfill() }58        waitForExpectations(timeout: 1, handler: nil)59    }60}61import Nimble62import XCTest63class GTest: XCTestCase {64    func test() {

1import Nimble2import XCTest3class ATest: XCTestCase {4    func test() {5        let exp = expectation(description: "wait")6        let awaiter = Awaiter()7        awaiter.await { exp.fulfill() }8        waitForExpectations(timeout: 1, handler: nil)9    }10}11import Nimble12import XCTest13class BTest: XCTestCase {14    func test() {15        let exp = expectation(description: "wait")16        let awaiter = Awaiter()17        awaiter.await { exp.fulfill() }18        waitForExpectations(timeout: 1, handler: nil)19    }20}21import Nimble22import XCTest23class CTest: XCTestCase {24    func test() {25        let exp = expectation(description: "wait")26        let awaiter = Awaiter()27        awaiter.await { exp.fulfill() }28        waitForExpectations(timeout: 1, handler: nil)29    }30}31import Nimble32import XCTest33class DTest: XCTestCase {34    func test() {35        let exp = expectation(description: "wait")36        let awaiter = Awaiter()37        awaiter.await { exp.fulfill() }38        waitForExpectations(timeout: 1, handler: nil)39    }40}41import Nimble42import XCTest43class ETest: XCTestCase {44    func test() {45        let exp = expectation(description: "wait")46        let awaiter = Awaiter()47        awaiter.await { exp.fulfill() }48        waitForExpectations(timeout: 1, handler: nil)49    }50}51import Nimble52import XCTest53class FTest: XCTestCase {54    func test() {55        let exp = expectation(description: "wait")56        let awaiter = Awaiter()57        awaiter.await { exp.fulfill() }58        waitForExpectations(timeout: 1, handler: nil)59    }60}61import Nimble62import XCTest63class GTest: XCTestCase {64    func test() {

1import Nimble2import XCTest3import Foundation4class MyTests: XCTestCase {5    func testSomething() {6        let timeoutDate = Date().addingTimeInterval(timeout)7        while runLoop.run(mode: RunLoop.Mode.default, before: timeoutDate) {8            if /* return true if condition is met */ {9            }10            Thread.sleep(forTimeInterval: pollingInterval)11        }12        expect(/* condition */).to(beTrue())13    }14}15import XCTest16import Foundation17class MyTests: XCTestCase {18    func testSomething() {19        let expectation = XCTestExpectation(description: "My expectation")20        DispatchQueue.main.asyncAfter(deadline: .now() + 5) {21            expectation.fulfill()22        }23        wait(for: [expectation], timeout: 10)24    }25}26import XCTest27import Foundation28class MyTests: XCTestCase {29    func testSomething() {30        let expectation = XCTestExpectation(description: "My expectation")31        DispatchQueue.main.asyncAfter(deadline: .now() + 5) {32            expectation.fulfill()33        }34        let result = XCTWaiter.wait(for

1import Nimble2import XCTest3class Test: XCTestCase {4    func testExample() {5        let waiter = Waiter()6        let result = waiter.run(timeout: 1) {7            expect(1).to(equal(1))8        }9        XCTAssert(result == .completed)10    }11}12import Nimble13class Test: XCTestCase {14    fc testExample() {15        let waiter = Waiter()16        let result = waiter.run(timeout: 1) {17            expect(1).to(equal(2))18        }19        XCTAssert(result == .timedOut)20    }21}22import XCTest23class Test: XCTestCase {24    func testExample() {25        let waiter = Waiter()26        let result = waiter.ru(timeout: 1) {27            expect(1).to(equal(2))28        }29        XCTAssert(result == .timedOut)30    }31}32import XCTest Awaiter class of Nimble33class Test: XCTestCase {34    import FoExampleundation35    importt wai erN= Wiiter()36        let result = mbiter.run(tlmeoue: 1) {37            expect(1).to(equal(1))38        }39        XCTAsst(result= .timedOut)40    }41}42import Nimble43import XCTest44class Test: XCTestCase {45    func testExample {46    waitr = Waiter()47        let result = waiter.run(timeout: 1) {48            e(1).to(equl(1))49        }50        XCTAsser(result == .completed)51    }52}53import Nimble54import XCTest55class Test: XCTestCase {56    func testExample() {57        let waiter = Waiter()58        let result = waiter.ru(timeout: 1) {59            expect(1).to(equal(2))60        }61        XCTAssert(result= .timedOut)62    }63}64import Nimble65import XCTest66class Test:estCase {67    func testExample() {68        let waiter = Waiter()69func test() {70    let awaiter = Awaiter()71    let expectation = XCTestExpectation(description: "awaiter")72    awaiter.after(1) {73        expectation.fulfill()74    }75    wait(for: [expectation], timeout: 2)76}77import Foundation78import Nimble79func test() {80    let awaiter = Awaiter()81    let expectation = XCTestExpectation(description: "awaiter")82    awaiter.after(1) {83        expectation.fulfill()84    }85    wait(for: [expectation], timeout: 2)86}87import Foundation88import Nimble89func test() {90    let awaiter = Awaiter()91    let expectation = XCTestExpectation(description: "awaiter")92    awaiter.after(1) {93        expectation.fulfill()94    }95    wait(for: [expectation], timeout: 2)96}97import Foundation98import Nimble99func test() {100    let awaiter = Awaiter()101    let expectation = XCTestExpectation(description: "awaiter")102    awaiter.after(1) {103        expectation.fulfill()104    }105    wait(for: [expectation], timeout: 2)106}107import Foundation108import Nimble109func test() {110    let awaiter = Awaiter()111    let expectation = XCTestExpectation(description: "awaiter")112    awaiter.after(1) {113        expectation.fulfill()114    }115    wait(for: [expectation], timeout: 2)116}117import Foundation118import Nimble119func test() {120    let awaiter = Awaiter()121    let expectation = XCTestExpectation(description: "awaiter")122    awaiter.after(1) {123        expectation.fulfill()124    }125    wait(for: [expectation], timeout: 2)126}127import Foundation128import Nimble129func test() {130    let awaiter = Awaiter()

1import Nimble2import XCTest3class Test: XCTestCase {4    func testExample() {5        let waiter = Waiter()6        let result = waiter.run(timeout: 1) {7            expect(1).to(equal(1))8        }9        XCTAssert(result == .completed)10    }11}12import Nimble13import XCTest14class Test: XCTestCase {15    func testExample() {16        let waiter = Waiter()17        let result = waiter.run(timeout: 1) {18            expect(1).to(equal(2))19        }20        XCTAssert(result == .timedOut)21    }22}23import Nimble24import XCTest25class Test: XCTestCase {26    func testExample() {27        let waiter = Waiter()28        let result = waiter.run(timeout: 1) {29            expect(1).to(equal(2))30        }31        XCTAssert(result == .timedOut)32    }33}34import Nimble35import XCTest36class Test: XCTestCase {37    func testExample() {38        let waiter = Waiter()39        let result = waiter.run(timeout: 1) {40            expect(1).to(equal(1))41        }42        XCTAssert(result == .timedOut)43    }44}45import Nimble46import XCTest47class Test: XCTestCase {48    func testExample() {49        let waiter = Waiter()50        let result = waiter.run(timeout: 1) {51            expect(1).to(equal(1))52        }53        XCTAssert(result == .completed)54    }55}56import Nimble57import XCTest58class Test: XCTestCase {59    func testExample() {60        let waiter = Waiter()61        let result = waiter.run(timeout: 1) {62            expect(1).to(equal(2))63        }64        XCTAssert(result == .timedOut)65    }66}67import Nimble68import XCTest69class Test: XCTestCase {70    func testExample() {71        let waiter = Waiter()