TestTimer.swift

// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//

import Synchronization

classTestTimer:XCTestCase{
func test_timerInit(){
letfireDate=Date()
lettimeInterval:TimeInterval=0.3

lettimer=Timer(fire: fireDate, interval: timeInterval, repeats:false){ _ in}
XCTAssertEqual(timer.fireDate, fireDate)
XCTAssertEqual(timer.timeInterval,0,"Time interval should be 0 for a non repeating Timer")
XCTAssert(timer.isValid)

letrepeatingTimer=Timer(fire: fireDate, interval: timeInterval, repeats:true){ _ in}
XCTAssertEqual(repeatingTimer.fireDate, fireDate)
XCTAssertEqual(repeatingTimer.timeInterval, timeInterval)
XCTAssert(timer.isValid)
}

func test_timerTickOnce(){
letflag=Atomic(false)

letdummyTimer=Timer.scheduledTimer(withTimeInterval:0.01, repeats:false){ timer in

let(exchanged, original)= flag.compareExchange(expected:false, desired:true, ordering:.relaxed)
XCTAssertFalse(original)
XCTAssertTrue(exchanged)
 timer.invalidate()
}

letrunLoop=RunLoop.current
 runLoop.add(dummyTimer, forMode:.default)
 runLoop.run(until:Date(timeIntervalSinceNow:0.05))

XCTAssertTrue(flag.load(ordering:.relaxed))
}

func test_timerRepeats(){
letflag=Mutex(0)
letinterval=TimeInterval(0.1)
letnumberOfRepeats=3
letpreviousInterval=Mutex(Date().timeIntervalSince1970)

letdummyTimer=Timer.scheduledTimer(withTimeInterval: interval, repeats:true){ timer in
XCTAssertEqual(timer.timeInterval, interval)

letcurrentInterval=Date().timeIntervalSince1970
 previousInterval.withLock{
XCTAssertEqual(currentInterval, $0 + interval, accuracy:0.2)
 $0 = currentInterval
}

letinvalidate= flag.withLock{
 $0 +=1
if $0 == numberOfRepeats {
returntrue
}else{
returnfalse
}
}

if invalidate {
 timer.invalidate()
}
}

letrunLoop=RunLoop.current
 runLoop.add(dummyTimer, forMode:.default)
 runLoop.run(until:Date(timeIntervalSinceNow: interval * Double(numberOfRepeats +1)))

 flag.withLock{
XCTAssertEqual($0, numberOfRepeats)
}
}

func test_timerInvalidate(){
 // Only mutated once, protected by behavior of RunLoop validated in this test
nonisolated(unsafe)varflag=false

letdummyTimer=Timer.scheduledTimer(withTimeInterval:0.01, repeats:true){ timer in
XCTAssertTrue(timer.isValid)
XCTAssertFalse(flag) // timer should tick only once

 flag =true

 timer.invalidate()
XCTAssertFalse(timer.isValid)
}

letrunLoop=RunLoop.current
 runLoop.add(dummyTimer, forMode:.default)
 runLoop.run(until:Date(timeIntervalSinceNow:0.05))

XCTAssertTrue(flag)
}

}