TestRunLoop.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
//

classTestRunLoop:XCTestCase{
func test_constants(){
XCTAssertEqual(RunLoop.Mode.common.rawValue,"kCFRunLoopCommonModes",
"\(RunLoop.Mode.common.rawValue) is not equal to kCFRunLoopCommonModes")

XCTAssertEqual(RunLoop.Mode.default.rawValue,"kCFRunLoopDefaultMode",
"\(RunLoop.Mode.default.rawValue) is not equal to kCFRunLoopDefaultMode")
}

func test_runLoopInit(){
letmainRunLoop=RunLoop.main
letcurrentRunLoop=RunLoop.current

letsecondAccessOfMainLoop=RunLoop.main
XCTAssertEqual(mainRunLoop, secondAccessOfMainLoop,"fetching the main loop a second time should be equal")
XCTAssertTrue(mainRunLoop === secondAccessOfMainLoop,"fetching the main loop a second time should be identical")

letsecondAccessOfCurrentLoop=RunLoop.current
XCTAssertEqual(currentRunLoop, secondAccessOfCurrentLoop,"fetching the current loop a second time should be equal")
XCTAssertTrue(currentRunLoop === secondAccessOfCurrentLoop,"fetching the current loop a second time should be identical")

 // We can assume that the tests will be run on the main run loop
 // so the current loop should be the main loop
XCTAssertEqual(mainRunLoop, currentRunLoop,"the current run loop should be the main loop")
}

func test_runLoopRunMode(){
 // RunLoop is not sendable, but we do want to verify that the current run loop here is the one we access below in the Timer block
nonisolated(unsafe)letrunLoop=RunLoop.current
lettimeInterval=TimeInterval(0.05)
letendDate=Date(timeInterval: timeInterval, since:Date())

 // Protected by the ordering of the run loop - that is what this test verifies
nonisolated(unsafe)varflag=false

letdummyTimer=Timer.scheduledTimer(withTimeInterval:0.01, repeats:false){ _ in
 flag =true
guardlet runLoopMode = runLoop.currentMode else{
XCTFail("Run loop mode is not defined")
return
}

XCTAssertEqual(runLoopMode,RunLoop.Mode.default)
}
 runLoop.add(dummyTimer, forMode:.default)
letresult= runLoop.run(mode:.default, before: endDate)

XCTAssertTrue(result)
XCTAssertTrue(flag)
}

func test_runLoopLimitDate(){
letrunLoop=RunLoop.current
lettimeInterval=TimeInterval(1)
letexpectedTimeInterval=Date(timeInterval: timeInterval, since:Date()).timeIntervalSince1970

letdummyTimer=Timer.scheduledTimer(withTimeInterval: timeInterval, repeats:false){ _ in}
 runLoop.add(dummyTimer, forMode:.default)

guardlet timerTickInterval = runLoop.limitDate(forMode:.default)?.timeIntervalSince1970 else{
return
}

XCTAssertLessThan(abs(timerTickInterval - expectedTimeInterval),0.01)
}

func test_runLoopPoll(){
letrunLoop=RunLoop.current

letstartDate=Date()
 runLoop.run(until:Date())
letendDate=Date()

XCTAssertLessThan(endDate.timeIntervalSince(startDate),0.5)
}

func test_commonModes(){
letrunLoop=RunLoop.current
letdone=expectation(description:"The timer has fired")
lettimer=Timer(timeInterval:1, repeats:false){(_)in
 done.fulfill()
}

 runLoop.add(timer, forMode:.common)

waitForExpectations(timeout:10)
}

func test_addingRemovingPorts(){
letrunLoop=RunLoop.current
vardidDeallocate=false

do{
letport=TestPort{
 didDeallocate =true
}
letcustomMode=RunLoop.Mode(rawValue:"Custom")

XCTAssertEqual(port.scheduledModes,[])

 runLoop.add(port, forMode:.default)
XCTAssertEqual(port.scheduledModes,[.default])

 runLoop.add(port, forMode:.default)
XCTAssertEqual(port.scheduledModes,[.default])

 runLoop.add(port, forMode: customMode)
XCTAssertEqual(port.scheduledModes,[.default, customMode])

 runLoop.remove(port, forMode: customMode)
XCTAssertEqual(port.scheduledModes,[.default])

 runLoop.add(port, forMode: customMode)
XCTAssertEqual(port.scheduledModes,[.default, customMode])

 port.invalidate()
}

XCTAssertTrue(didDeallocate)
}

nonisolated(unsafe)varasyncExecuted=false

func test_mainDispatchQueueCallout(){
letrunLoop=RunLoop.current

nonisolated(unsafe)letnonisolatedSelf=self
DispatchQueue.main.async{
 nonisolatedSelf.asyncExecuted =true
}

 // RunLoop should service main queue
 _ = runLoop.run(mode:.default, before:Date(timeIntervalSinceNow:2))
XCTAssertTrue(asyncExecuted,"Main queue async code should be executed")

 asyncExecuted =false
DispatchQueue.main.async{
 nonisolatedSelf.asyncExecuted =true
}

 // Second run to be sure RunLoop will not stuck
 _ = runLoop.run(mode:.default, before:Date(timeIntervalSinceNow:2))
XCTAssertTrue(asyncExecuted,"Main queue async code should be executed")

 // Protected by the ordering of the run loop - that is what this test verifies
nonisolated(unsafe)vartimerFired=false
letdummyTimer=Timer.scheduledTimer(withTimeInterval:0.5, repeats:false){ _ in
 timerFired =true
}
 runLoop.add(dummyTimer, forMode:.default)

 // At this moment RunLoop has no work to do except waiting for timer.
 // But RunLoop will exit prematurely if event from previous async calls
 // got stuck in wrong state.
 _ = runLoop.run(mode:.default, before:Date(timeIntervalSinceNow:2))

XCTAssertTrue(timerFired,"Time should fire already")
}
}

classTestPort:Port{
letsentinel:()->Void
init(sentinel:@escaping()->Void){
self.sentinel = sentinel
 super.init()
}

 // Required on Darwin
requiredinit?(coder:NSCoder){
fatalError("init(coder:) has not been implemented")
}

deinit{
invalidate()
sentinel()
}

privatevar_isValid=true
openoverridevarisValid:Bool{return _isValid }

openoverridefunc invalidate(){
guard isValid else{return}

 _isValid =false
NotificationCenter.default.post(name:Port.didBecomeInvalidNotification, object:self)
}

varscheduledModes:[RunLoop.Mode]=[]

openoverridefunc schedule(in runLoop:RunLoop, forMode mode:RunLoop.Mode){
 scheduledModes.append(mode)
}

openoverridefunc remove(from runLoop:RunLoop, forMode mode:RunLoop.Mode){
 scheduledModes = scheduledModes.filter{ $0 != mode }
}
}