TestOperationQueue.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
import Dispatch

classTestOperationQueue:XCTestCase{
func test_OperationCount(){
letqueue=OperationQueue()
letop1=BlockOperation(block:{Thread.sleep(forTimeInterval:2)})
 queue.addOperation(op1)
XCTAssertEqual(queue.operationCount,1)
 queue.waitUntilAllOperationsAreFinished()
XCTAssertEqual(queue.operationCount,0)

letop2=BlockOperation(block:{Thread.sleep(forTimeInterval:0.5)})
letop3=BlockOperation(block:{Thread.sleep(forTimeInterval:0.5)})
 queue.addOperation(op2)
 queue.addOperation(op3)
XCTAssertEqual(queue.operationCount,2)
letoperations= queue.operations
XCTAssertEqual(operations.count,2)
if(operations.count ==2){
XCTAssertEqual(operations[0], op2)
XCTAssertEqual(operations[1], op3)
}
 queue.waitUntilAllOperationsAreFinished()
XCTAssertEqual(queue.operationCount,0)
XCTAssertEqual(queue.operations.count,0)
}

func test_OperationPriorities(){
letmsgOperations=Mutex([String]())
letoperation1:BlockOperation=BlockOperation(block:{
 msgOperations.withLock{ $0.append("Operation1 executed")}
})
letoperation2:BlockOperation=BlockOperation(block:{
 msgOperations.withLock{ $0.append("Operation2 executed")}
})
letoperation3:BlockOperation=BlockOperation(block:{
 msgOperations.withLock{ $0.append("Operation3 executed")}
})
letoperation4:BlockOperation=BlockOperation(block:{
 msgOperations.withLock{ $0.append("Operation4 executed")}
})
 operation4.queuePriority =.veryLow
 operation3.queuePriority =.veryHigh
 operation2.queuePriority =.low
 operation1.queuePriority =.normal
varoperations=[Operation]()
 operations.append(operation1)
 operations.append(operation2)
 operations.append(operation3)
 operations.append(operation4)
letqueue=OperationQueue()
 queue.maxConcurrentOperationCount =1
 queue.addOperations(operations, waitUntilFinished:true)
 msgOperations.withLock{
XCTAssertEqual($0[0],"Operation3 executed")
XCTAssertEqual($0[1],"Operation1 executed")
XCTAssertEqual($0[2],"Operation2 executed")
XCTAssertEqual($0[3],"Operation4 executed")
}
}

func test_isExecutingWorks(){
finalclass_OperationBox:Sendable{
 // Only mutate this before kicking off the operation
nonisolated(unsafe)var operation:Operation?
init(){
self.operation =nil
}
}
letqueue=OperationQueue()
letopBox=_OperationBox()
letop=BlockOperation(block:{XCTAssertEqual(true, opBox.operation?.isExecuting)})
 opBox.operation = op
XCTAssertFalse(op.isExecuting)

 queue.addOperation(op)
 queue.waitUntilAllOperationsAreFinished()
XCTAssertFalse(op.isExecuting)

 opBox.operation =nil /* break the reference cycle op -> <closure> -> opBox -> op */
}

func test_AsyncOperation(){
letoperation=AsyncOperation()
XCTAssertFalse(operation.isExecuting)
XCTAssertFalse(operation.isFinished)

 operation.start()

while !operation.isFinished {
 // do nothing
}

XCTAssertFalse(operation.isExecuting)
XCTAssertTrue(operation.isFinished)
}

func test_SyncOperationWithoutAQueue(){
letoperation=SyncOperation()
XCTAssertFalse(operation.isExecuting)
XCTAssertFalse(operation.isFinished)

 operation.start()

XCTAssertFalse(operation.isExecuting)
XCTAssertTrue(operation.isFinished)
XCTAssertTrue(operation.hasRun)
}

func test_MainQueueGetter(){
XCTAssertTrue(OperationQueue.main ===OperationQueue.main)

 /*
 This call is only to check if OperationQueue.main returns a living instance.
 There used to be a bug where subsequent OperationQueue.main call would return a "dangling pointer".
 */
XCTAssertFalse(OperationQueue.main.isSuspended)
}

func test_CancelOneOperation(){
varoperations=[Operation]()
letvalueOperations=Mutex([Int]())
foriin0..<5{
letoperation=BlockOperation{
 valueOperations.withLock{ $0.append(i)}
Thread.sleep(forTimeInterval:2)
}
 operations.append(operation)
}

letqueue=OperationQueue()
 queue.maxConcurrentOperationCount =1
 queue.addOperations(operations, waitUntilFinished:false)
 operations.remove(at:2).cancel()
 queue.waitUntilAllOperationsAreFinished()
XCTAssertTrue(!valueOperations.withLock({ $0.contains(2)}))
}

func test_CancelOperationsOfSpecificQueuePriority(){
varoperations=[Operation]()
letvalueOperations=Mutex([Int]())

letoperation1=BlockOperation{
 valueOperations.withLock{ $0.append(0)}
Thread.sleep(forTimeInterval:2)
}
 operation1.queuePriority =.high
 operations.append(operation1)

letoperation2=BlockOperation{
 valueOperations.withLock{ $0.append(1)}
Thread.sleep(forTimeInterval:2)
}
 operation2.queuePriority =.high
 operations.append(operation2)

letoperation3=BlockOperation{
 valueOperations.withLock{ $0.append(2)}
}
 operation3.queuePriority =.normal
 operations.append(operation3)

letoperation4=BlockOperation{
 valueOperations.withLock{ $0.append(3)}
}
 operation4.queuePriority =.normal
 operations.append(operation4)

letoperation5=BlockOperation{
 valueOperations.withLock{ $0.append(4)}
}
 operation5.queuePriority =.normal
 operations.append(operation5)

letqueue=OperationQueue()
 queue.maxConcurrentOperationCount =1
 queue.addOperations(operations, waitUntilFinished:false)
foroperationin operations {
if operation.queuePriority ==.normal {
 operation.cancel()
}
}
 queue.waitUntilAllOperationsAreFinished()
 valueOperations.withLock{
XCTAssertTrue($0.count ==2)
XCTAssertTrue($0[0]==0)
XCTAssertTrue($0[1]==1)
}
}

func test_CurrentQueueOnMainQueue(){
XCTAssertTrue(OperationQueue.main ===OperationQueue.current)
}

func test_CurrentQueueOnBackgroundQueue(){
letexpectation=self.expectation(description:"Background execution")

letoperationQueue=OperationQueue()
 operationQueue.addOperation{
XCTAssertEqual(operationQueue,OperationQueue.current)
 expectation.fulfill()
}

waitForExpectations(timeout:1)
}

func test_CurrentQueueOnBackgroundQueueWithSelfCancel(){
letoperationQueue=OperationQueue()
 operationQueue.maxConcurrentOperationCount =1
letexpectation=self.expectation(description:"Background execution")
 operationQueue.addOperation{
XCTAssertEqual(operationQueue,OperationQueue.current)
 expectation.fulfill()
 // Canceling operation X from inside operation X should not cause the app to a crash
 operationQueue.cancelAllOperations()
}

waitForExpectations(timeout:1)
}

func test_CurrentQueueWithCustomUnderlyingQueue(){
letexpectation=self.expectation(description:"Background execution")

letoperationQueue=OperationQueue()
letunderlyingQueue=DispatchQueue(label:"underlying_queue")
 operationQueue.underlyingQueue = underlyingQueue

 operationQueue.addOperation{
XCTAssertEqual(operationQueue,OperationQueue.current)
 expectation.fulfill()
}

waitForExpectations(timeout:1)
}

func test_isSuspended(){
letexpectation1=self.expectation(description:"DispatchQueue execution")
letexpectation2=self.expectation(description:"OperationQueue execution")

letdispatchQueue=DispatchQueue(label:"underlying_queue")
letoperationQueue=OperationQueue()
 operationQueue.maxConcurrentOperationCount =1
 operationQueue.underlyingQueue = dispatchQueue
 operationQueue.isSuspended =true

 operationQueue.addOperation{
XCTAssert(OperationQueue.current?.underlyingQueue === dispatchQueue)
 expectation2.fulfill()
}

 dispatchQueue.async{
 operationQueue.isSuspended =false
 expectation1.fulfill()
}

waitForExpectations(timeout:1)
}

func test_CurrentQueueWithUnderlyingQueueResetToNil(){
letexpectation=self.expectation(description:"Background execution")

letoperationQueue=OperationQueue()
letunderlyingQueue=DispatchQueue(label:"underlying_queue")
 operationQueue.underlyingQueue = underlyingQueue
 operationQueue.underlyingQueue =nil

 operationQueue.addOperation{
XCTAssertEqual(operationQueue,OperationQueue.current)
 expectation.fulfill()
}

waitForExpectations(timeout:1)
}

func test_OperationDependencyCount(){
letop1=BlockOperation{
}
 op1.name ="op1"
letop2=BlockOperation{
}
 op2.name ="op2"
 op1.addDependency(op2)
XCTAssert(op1.dependencies.count ==1)
}

func test_CancelDependency(){
letexpectation=self.expectation(description:"Operation should finish")

letqueue=OperationQueue()
 queue.maxConcurrentOperationCount =1

letop1=BlockOperation(){
XCTAssert(false,"Should not run")
}
letop2=BlockOperation(){
 expectation.fulfill()
}

 op2.addDependency(op1)
 op1.cancel()

 queue.addOperation(op1)
 queue.addOperation(op2)

waitForExpectations(timeout:1)
}

func test_Deadlock(){
letexpectation1=self.expectation(description:"Operation should finish")
letexpectation2=self.expectation(description:"Operation should finish")

letop1=BlockOperation{
 expectation1.fulfill()
}
 op1.name ="op1"

letop2=BlockOperation{
 expectation2.fulfill()
}
 op2.name ="op2"

 op1.addDependency(op2)

 // Narrow scope to force early release of queue object
 _ ={
letqueue=OperationQueue()
 queue.maxConcurrentOperationCount =1
 queue.addOperation(op1)
 queue.addOperation(op2)
}()

waitForExpectations(timeout:1)
Thread.sleep(forTimeInterval:1)
}

publicfunc test_CancelOutOfQueue(){
letop=Operation()
 op.cancel()

XCTAssert(op.isCancelled)
XCTAssertFalse(op.isExecuting)
XCTAssertFalse(op.isFinished)
}

publicfunc test_CrossQueueDependency(){
letqueue=OperationQueue()
letqueue2=OperationQueue()

letexpectation1=self.expectation(description:"Operation should finish")
letexpectation2=self.expectation(description:"Operation should finish")

letop1=BlockOperation{
 expectation1.fulfill()
}
 op1.name ="op1"

letop2=BlockOperation{
 expectation2.fulfill()
}
 op2.name ="op2"

 op1.addDependency(op2)

 queue.addOperation(op1)
 queue2.addOperation(op2)

waitForExpectations(timeout:1)
}

publicfunc test_CancelWhileSuspended(){
letqueue=OperationQueue()
 queue.isSuspended =true

letop1=BlockOperation{}
 op1.name ="op1"

letop2=BlockOperation{}
 op2.name ="op2"

 queue.addOperation(op1)
 queue.addOperation(op2)

 op1.cancel()
 op2.cancel()

 queue.isSuspended =false
 queue.waitUntilAllOperationsAreFinished()

XCTAssert(op1.isCancelled)
XCTAssertFalse(op1.isExecuting)
XCTAssert(op1.isFinished)
XCTAssert(op2.isCancelled)
XCTAssertFalse(op2.isExecuting)
XCTAssert(op2.isFinished)
}

publicfunc test_OperationOrder(){
letqueue=OperationQueue()
 queue.maxConcurrentOperationCount =1
 queue.isSuspended =true

letarray=Mutex([Int]())

letop1=BlockOperation{
 array.withLock{ $0.append(1)}
}
 op1.queuePriority =.normal
 op1.name ="op1"

letop2=BlockOperation{
 array.withLock{ $0.append(2)}
}
 op2.queuePriority =.normal
 op2.name ="op2"

letop3=BlockOperation{
 array.withLock{ $0.append(3)}
}
 op3.queuePriority =.normal
 op3.name ="op3"

letop4=BlockOperation{
 array.withLock{ $0.append(4)}
}
 op4.queuePriority =.normal
 op4.name ="op4"

letop5=BlockOperation{
 array.withLock{ $0.append(5)}
}
 op5.queuePriority =.normal
 op5.name ="op5"

 queue.addOperation(op1)
 queue.addOperation(op2)
 queue.addOperation(op3)
 queue.addOperation(op4)
 queue.addOperation(op5)

 queue.isSuspended =false
 queue.waitUntilAllOperationsAreFinished()

 array.withLock{
XCTAssertEqual($0,[1,2,3,4,5])
}
}

publicfunc test_OperationOrder2(){
letqueue=OperationQueue()
 queue.maxConcurrentOperationCount =1
 queue.isSuspended =true

letarray=Mutex([Int]())

letop1=BlockOperation{
 array.withLock{ $0.append(1)}
}
 op1.queuePriority =.veryLow
 op1.name ="op1"

letop2=BlockOperation{
 array.withLock{ $0.append(2)}
}
 op2.queuePriority =.low
 op2.name ="op2"

letop3=BlockOperation{
 array.withLock{ $0.append(3)}
}
 op3.queuePriority =.normal
 op3.name ="op3"

letop4=BlockOperation{
 array.withLock{ $0.append(4)}
}
 op4.queuePriority =.high
 op4.name ="op4"

letop5=BlockOperation{
 array.withLock{ $0.append(5)}
}
 op5.queuePriority =.veryHigh
 op5.name ="op5"

 queue.addOperation(op1)
 queue.addOperation(op2)
 queue.addOperation(op3)
 queue.addOperation(op4)
 queue.addOperation(op5)

 queue.isSuspended =false
 queue.waitUntilAllOperationsAreFinished()

 array.withLock{
XCTAssertEqual($0,[5,4,3,2,1])
}
}

func test_ExecutionOrder(){
letqueue=OperationQueue()

letdidRunOp1=expectation(description:"Did run first operation")
letdidRunOp1Dependency=expectation(description:"Did run first operation dependency")
letdidRunOp2=expectation(description:"Did run second operation")
 // Protected by the ordering of execution, which we are testing here
nonisolated(unsafe)vardidRunOp1DependencyFirst=false

letop1=BlockOperation{
 didRunOp1.fulfill()
XCTAssertTrue(didRunOp1DependencyFirst,"Dependency should be executed first")
}
letop1Dependency=BlockOperation{
 didRunOp1Dependency.fulfill()
 didRunOp1DependencyFirst =true
}
 op1.addDependency(op1Dependency)
 queue.addOperations([op1, op1Dependency], waitUntilFinished:false)

 queue.addOperation{
 didRunOp2.fulfill()
}

waitForExpectations(timeout:1.0)
}

func test_WaitUntilFinished(){
letqueue1=OperationQueue()
letqueue2=OperationQueue()

letop1=BlockOperation{Thread.sleep(forTimeInterval:1)}
letop2=BlockOperation{}

 op2.addDependency(op1)

 queue1.addOperation(op1)
 queue2.addOperation(op2)

 queue2.waitUntilAllOperationsAreFinished()
XCTAssertEqual(queue2.operationCount,0)
}

func test_OperationWaitUntilFinished(){
letqueue1=OperationQueue()
letop1=BlockOperation{Thread.sleep(forTimeInterval:1)}
 queue1.addOperation(op1)
 op1.waitUntilFinished()

 // Operation is not removed from Queue simultaneously
 // with transitioning to "Finished" state. Wait a bit
 // to allow OperationQueue to deal with finished op.
Thread.sleep(forTimeInterval:0.1)
XCTAssertEqual(queue1.operationCount,0)
}

func test_CustomOperationReady()throws{
throwXCTSkip("Flaky test: https://bugs.swift.org/browse/SR-14657")
#if false
classCustomOperation:Operation{

privatevar_isReady=false

overridevarisReady:Bool{
return _isReady
}

func setIsReady(){
willChangeValue(forKey:"isReady")
 _isReady =true
didChangeValue(forKey:"isReady")
}

}

letexpectation=self.expectation(description:"Operation should finish")

letqueue1=OperationQueue()
letop1=CustomOperation()
letop2=BlockOperation(block:{
 expectation.fulfill()
})

 queue1.addOperation(op1)
 queue1.addOperation(op2)

waitForExpectations(timeout:1)

XCTAssertEqual(queue1.operationCount,1)
 op1.setIsReady()
 queue1.waitUntilAllOperationsAreFinished()
XCTAssertEqual(queue1.operationCount,0)
#endif
}

func test_DependencyCycleBreak(){
letop1DidRun=expectation(description:"op1 supposed to be run")
letop2DidRun=expectation(description:"op2 supposed to be run")
letop2Finished=expectation(description:"op2 supposed to be finished")
letop3Cancelled=expectation(description:"op3 supposed to be cancelled")
letop3DidRun=expectation(description:"op3 is not supposed to be run")
 op3DidRun.isInverted =true

structOps{
varop1:Operation!
varop2:Operation!
varop3:Operation!
init(){
 op1 =nil
 op2 =nil
 op3 =nil
}
}
letops=Mutex(Ops())

letqueue1=OperationQueue()
 ops.withLock{
 $0.op1 =BlockOperation{
 op1DidRun.fulfill()
 ops.withLock{
if $0.op2.isFinished {
 op2Finished.fulfill()
}
}
}
 $0.op2 =BlockOperation{
 op2DidRun.fulfill()
 ops.withLock{
if $0.op3.isCancelled {
 op3Cancelled.fulfill()
}
}
}
 $0.op3 =BlockOperation{
 op3DidRun.fulfill()
}

 // Create dependency cycle
 $0.op1.addDependency($0.op2)
 $0.op2.addDependency($0.op3)
 $0.op3.addDependency($0.op1)

 queue1.addOperation($0.op1)
 queue1.addOperation($0.op2)
 queue1.addOperation($0.op3)

XCTAssertEqual(queue1.operationCount,3)

 //Break dependency cycle
 $0.op3.cancel()
}

waitForExpectations(timeout:1)
}

func test_Lifecycle(){
letopStarted=expectation(description:"Operation supposed to start")
letopDone=expectation(description:"Operation supposed to be done")

letop1=BlockOperation{
Thread.sleep(forTimeInterval:0.3)
}
letop2=BlockOperation{
 opStarted.fulfill()
Thread.sleep(forTimeInterval:0.3)
 opDone.fulfill()
}

 op1.addDependency(op2)

 weak varweakQueue:OperationQueue?
 _ ={
letqueue=OperationQueue()
 weakQueue = queue
 queue.addOperation(op1)
 queue.addOperation(op2)
}()

wait(for:[opStarted], timeout:1)
 op2.cancel()
wait(for:[opDone], timeout:1)

Thread.sleep(forTimeInterval:1) // Let queue to be deallocated
XCTAssertNil(weakQueue,"Queue should be deallocated at this point")
}

func test_ConcurrentOperations(){
letqueue=OperationQueue()
 queue.maxConcurrentOperationCount =2

 // Running several iterations helps to reveal use-after-dealloc crashes
for_in0..<3{
letdidRunOp1=expectation(description:"Did run first operation")
letdidRunOp2=expectation(description:"Did run second operation")

nonisolated(unsafe)letnonisolatedSelf=self
 queue.addOperation{
 nonisolatedSelf.wait(for:[didRunOp2], timeout:0.2)
 didRunOp1.fulfill()
}
 queue.addOperation{
 didRunOp2.fulfill()
}

self.wait(for:[didRunOp1], timeout:0.3)
}
}

func test_ConcurrentOperationsWithDependenciesAndCompletions(){
letqueue=OperationQueue()
 queue.maxConcurrentOperationCount =2

 // Running several iterations helps to reveal use-after-dealloc crashes
for_in0..<3{
letdidRunOp1=expectation(description:"Did run first operation")
letdidRunOp1Completion=expectation(description:"Did run first operation completion")
letdidRunOp1Dependency=expectation(description:"Did run first operation dependency")
letdidRunOp2=expectation(description:"Did run second operation")

nonisolated(unsafe)letnonisolatedSelf=self
letop1=BlockOperation{
 nonisolatedSelf.wait(for:[didRunOp1Dependency, didRunOp2], timeout:0.2)
 didRunOp1.fulfill()
}
 op1.completionBlock ={
 didRunOp1Completion.fulfill()
}
letop1Dependency=BlockOperation{
 didRunOp1Dependency.fulfill()
}
 queue.addOperations([op1, op1Dependency], waitUntilFinished:false)
 queue.addOperation{
 didRunOp2.fulfill()
}

self.wait(for:[didRunOp1, didRunOp1Completion], timeout:0.3)
}
}

func test_BlockOperationAddExecutionBlock(){
letblock1Expectation=expectation(description:"Block 1 executed")
letblock2Expectation=expectation(description:"Block 2 executed")

letblockOperation=BlockOperation{
 block1Expectation.fulfill()
}
 blockOperation.addExecutionBlock{
 block2Expectation.fulfill()
}
XCTAssert(blockOperation.executionBlocks.count ==2)
letqueue=OperationQueue()
 queue.addOperation(blockOperation)
waitForExpectations(timeout:1.0)
}
}

classAsyncOperation:Operation,@uncheckedSendable{

privateletqueue=DispatchQueue(label:"async.operation.queue")
privateletlock=NSLock()

privatevar_executing=false
privatevar_finished=false

overridevarisExecuting:Bool{
get{
 lock.lock()
letwasExecuting= _executing
 lock.unlock()
return wasExecuting
}
set{
if isExecuting != newValue {
willChangeValue(forKey:"isExecuting")
 lock.lock()
 _executing = newValue
 lock.unlock()
didChangeValue(forKey:"isExecuting")
}
}
}

overridevarisFinished:Bool{
get{
 lock.lock()
letwasFinished= _finished
 lock.unlock()
return wasFinished
}
set{
if isFinished != newValue {
willChangeValue(forKey:"isFinished")
 lock.lock()
 _finished = newValue
 lock.unlock()
didChangeValue(forKey:"isFinished")
}
}
}

overridevarisAsynchronous:Bool{
returntrue
}

overridefunc start(){
if isCancelled {
 isFinished =true
return
}

 isExecuting =true

 queue.async{
Thread.sleep(forTimeInterval:1)
self.isExecuting =false
self.isFinished =true
}
}

}

classSyncOperation:Operation,@uncheckedSendable{

varhasRun=false

overridefunc main(){
Thread.sleep(forTimeInterval:1)
 hasRun =true
}

}