             }
             
             iteration++
-            timer.setTimer(1.0 * (iteration + 1.0))
+            
+            previousTimestamp = CFAbsoluteTimeGetCurrent()
+            timer.setTimer(Double(iteration + 1))
         }
         XCTAssertTrue(timer.isRunning, "Timer's isRunning property is not true")
         

        }
        let suspendExpectation = self.expectationWithDescription("timer suspended")
        
        var previousTimestamp = NSDate().timeIntervalSince1970
        var iteration = 0.0
        let timer = GCDTimer.createAutoStart(.Default, interval: (1.0 * (iteration + 1.0))) { (timer) -> Void in
            
            XCTAssertTrue(GCDQueue.Default.isCurrentExecutionContext())
            
            let currentTimestamp = NSDate().timeIntervalSince1970
            XCTAssertGreaterThanOrEqual(currentTimestamp - previousTimestamp, (1.0 * (iteration + 1.0)), "Timer fired before expected time")
            XCTAssertTrue(timer.isRunning, "Timer's isRunning property is not true")
            
            previousTimestamp = currentTimestamp
            
            if Int(iteration) < runningExpectations.count {
                

    
    func testGCDQueue() {
        
        let mainQueue = GCDQueue.Main
        XCTAssertNotNil(mainQueue.dispatchQueue());
        XCTAssertEqual(mainQueue.dispatchQueue(), dispatch_get_main_queue())
        
        let allQueues: [GCDQueue] = [.Main, .UserInteractive, .UserInitiated, .Default, .Utility, .Background, .createSerial("serial"), .createConcurrent("serial")]
        var allQueuesExpectations = [XCTestExpectation]()
        for queue in allQueues {
            
            if queue != .Main {
                
                queue.sync {
                    
                    XCTAssertTrue(queue.isCurrentExecutionContext())
                    for otherQueue in allQueues {
                        
                        if queue != otherQueue {
                            
                            XCTAssertFalse(otherQueue.isCurrentExecutionContext())
                        }
                    }
                }
            }
            
            let dispatchExpectation = self.expectationWithDescription("main queue block")
            allQueuesExpectations.append(dispatchExpectation)
            
            queue.async {
                
                XCTAssertTrue(queue.isCurrentExecutionContext())
                for otherQueue in allQueues {
                    
                    if queue != otherQueue {
                        
                        XCTAssertFalse(otherQueue.isCurrentExecutionContext())
                    }
                }
                dispatchExpectation.fulfill()
