     }
  
 	
+    // MARK: - Swift 3.x dispatch stuff
+    
+    
+    func testBasicSwift3xDispatchMainAfter() {
+        
+        let spin = MainSpin()
+        let time1: CFAbsoluteTime = CFAbsoluteTimeGetCurrent()
+        var time2: CFAbsoluteTime = 0
+        var qPassed = false
+        
+        spin.start()
+        DispatchQueue.main.async(after: 0.5) {
+            time2 = CFAbsoluteTimeGetCurrent()
+            qPassed = onMainEverything()
+            spin.done()
+        }
+        spin.wait()
+        
+        XCTAssertGreaterThan(time2 - time1, 0.25, "diff must be greater than 0.25")
+        XCTAssertTrue(qPassed, "on incorrect queue")
+    }
+    
+    func testBasicSwift3xDispatchAsyncAfter() {
+        
+        let spin = AsyncSpin()
+        let time1: CFAbsoluteTime = CFAbsoluteTimeGetCurrent()
+        var time2: CFAbsoluteTime = 0
+        var qPassed = false
+        
+        spin.start()
+        dispatch_after(0.5, backgroundQueue) {
+            time2 = CFAbsoluteTimeGetCurrent()
+            qPassed = !onMainQueue()
+            spin.done()
+        }
+        spin.wait()
+        
+        XCTAssertGreaterThan(time2 - time1, 0.25, "diff must be greater than 0.5")
+        XCTAssertTrue(qPassed, "on incorrect queue")
+    }
+    
+    
+    func testBasicSwift3xDispatchMainOnce() {
+        
+        let spin = MainSpin()
+        let time1: CFAbsoluteTime = CFAbsoluteTimeGetCurrent()
+        var time2: CFAbsoluteTime = 0
+        var qPassed = false
+        var count = 0
+        
+        spin.start()
+        let block = {
+            time2 = CFAbsoluteTimeGetCurrent()
+            count += 1
+            qPassed = onMainEverything()
+            spin.done()
+        }
+        for _ in 0 ..< 10 {
+            dispatch_main_once_after(0.5, operationId: "testop2") {
+                block()
+            }
+        }
+        spin.wait()
+        
+        XCTAssertEqual(count, 1, "counted more than once")
+        XCTAssertGreaterThan(time2 - time1, 0.25, "diff must be greater than 0.5")
+        XCTAssertTrue(qPassed, "on incorrect queue")
+        
+    }
+    
+    
+    func testBasicSwift3xDispatchAsyncOnce() {
+        
+        let spin = AsyncSpin()
+        let time1: CFAbsoluteTime = CFAbsoluteTimeGetCurrent()
+        var time2: CFAbsoluteTime = 0
+        var qPassed = false
+        var count = 0
+        
+        spin.start()
+        let block = {
+            time2 = CFAbsoluteTimeGetCurrent()
+            count += 1
+            qPassed = !onMainQueue()
+            spin.done()
+        }
+        for _ in 0 ..< 10 {
+            dispatch_once_after(0.5, operationId: "testop", onQueue: backgroundQueue) {
+                block()
+            }
+        }
+        spin.wait()
+        
+        XCTAssertEqual(count, 1, "counted more than once")
+        XCTAssertGreaterThan(time2 - time1, 0.25, "diff must be greater than 0.5")
+        XCTAssertTrue(qPassed, "on incorrect queue")
+        
+    }
+    
+    
+    func testBasicSwift3xDispatchEveryMain() {
+        
+        let spin = MainSpin()
+        var count = 0
+        var qPassed = true
+        
+        spin.start()
+        dispatch_main_every(0.1) { t in
+            count += 1
+            if !onMainEverything() { qPassed = false }
+            if count == 10 {
+                spin.done()
+                t.cancel()
+            }
+        }
+        spin.wait()
+        
+        XCTAssertEqual(count, 10, "counted incorrect times")
+        XCTAssertTrue(qPassed, "on incorrect queue")
+    }
+    
+    func testBasicSwift3xDispatchEveryMainExact() {
+        
+        let spin = MainSpin()
+        var count = 0
+        var qPassed = true
+        
+        spin.start()
+        dispatch_main_every_exact(0.1) { t in
+            count += 1
+            if !onMainEverything() { qPassed = false }
+            if count == 10 {
+                spin.done()
+                t.cancel()
+            }
+        }
+        spin.wait()
+        
+        XCTAssertEqual(count, 10, "counted incorrect times")
+        XCTAssertTrue(qPassed, "on incorrect queue")
+    }
+    
+    func testBasicSwift3xDispatchEveryAsync() {
+        
+        let spin = AsyncSpin()
+        var count = 0
+        var qPassed = true
+        
+        spin.start()
+        dispatch_every(0.1, backgroundQueue) { t in
+            count += 1
+            if onMainQueue() { qPassed = false }
+            if count == 10 {
+                spin.done()
+                t.cancel()
+            }
+        }
+        spin.wait()
+        
+        XCTAssertEqual(count, 10, "counted incorrect times")
+        XCTAssertTrue(qPassed, "on incorrect queue")
+    }
+    
+    
+    func testBasicSwift3xDispatchEveryAsyncExact() {
+        
+        let spin = AsyncSpin()
+        var count = 0
+        var qPassed = true
+        
+        spin.start()
+        dispatch_every_exact(0.1, backgroundQueue) { t in
+            count += 1
+            if onMainQueue() { qPassed = false }
+            if count == 10 {
+                spin.done()
+                t.cancel()
+            }
+        }
+        spin.wait()
+        
+        XCTAssertEqual(count, 10, "counted incorrect times")
+        XCTAssertTrue(qPassed, "on incorrect queue")
+    }
+
+    
+    
 	// MARK: - Async To Sync
 	
     

        XCTAssertTrue(qPassed, "on incorrect queue")
    }
    
    func testBasicDispatchEveryAsyncExact() {
        
        let spin = AsyncSpin()
        var count = 0

        XCTAssertTrue(qPassed, "on incorrect queue")
    }
    
    func testBasicSwift2xDispatchEveryMainExact() {
        
        let spin = MainSpin()
        var count = 0
