Блог

У меня есть агрегатор задач, который объединяет и выполняет задачи синхронизированным образом. Это потокобезопасно и все такое. Вот как это выглядит

 class DaddysMagicalTaskAggregator {
  private let tasks: ThreadSafeValueContainer<[KewlTask]>
  private let cancelled: ThreadSafeValueContainer<Bool>
  private var completion: ((Result<Bool, Error>) -> Void)?
  private var alreadyCompleted: Result<Bool, Error>?

  private var getTasks: [KewlTask] {
    return tasks.value ?? []
  }

  private var isCancelled: Bool {
    return cancelled.value ?? true
  }

  init(queue: DispatchQueue = DispatchQueue(label: "DaddysMagicalTaskAggregator")) {
    self.tasks = ThreadSafeValueContainer(value: [], queue: queue)
    self.cancelled = ThreadSafeValueContainer(value: false, queue: queue)
  }

  /// Add a task to the list of tasks
  func addTask(_ task: KewlTask) -> DaddysMagicalTaskAggregator {
    self.tasks.value = getTasks   [task]
    return self
  }

  /// Add tasks to the list of tasks
  func addTasks(_ tasks: [KewlTask]) -> DaddysMagicalTaskAggregator {
    self.tasks.value = getTasks   tasks
    return self
  }
  
  /// Start executing tasks
  @discardableResult
  func run() -> DaddysMagicalTaskAggregator {
    guard !isCancelled else {
      return self
    }
    
    guard !getTasks.isEmpty else {
      alreadyCompleted = .success(true)
      completion?(.success(true))
      return self
    }
    
    var currentTasks = getTasks
    let taskToExecute = currentTasks.removeFirst()
    self.tasks.value = currentTasks
    
    taskToExecute.execute { (result) in
      switch result {
      case .success:
        self.run()
      case.failure(let error):
        self.taskFailed(with: error)
      }
    }
    return self
  }
  
  private func taskFailed(with error: Error) {
    tasks.value = []
    alreadyCompleted = .failure(error)
    completion?(.failure(error))
    completion = nil
  }
  
  /// Add a completion block which executes after all the tasks have executed or upon failing a task.
  func onCompletion(_ completion: @escaping (Result<Bool, Error>) -> Void) {
    if let result = alreadyCompleted {
      completion(result)
    } else {
      self.completion = completion
    }
  }
  
  /// Cancel all tasks
  func cancelAllTasks(with error: Error) {
    cancelled.value = true
    taskFailed(with: error)
  }
  
}

public class KewlTask {
  private let closure: ((KewlTask) -> Void)
  private var completion: ((Result<Bool, Error>) -> Void)?
  
  public init(_ closure: @escaping (KewlTask) -> Void) {
    self.closure = closure
  }
  
  public func execute(_ completion: @escaping (Result<Bool, Error>) -> Void) {
    self.completion = completion
    closure(self)
  }
  
  /// Task succeeded
  func succeeded() {
    completion?(.success(true))
  }
  
  /// Task failed with given error
  func failed(with error: Error) {
    completion?(.failure(error))
  }
  
  /// Take action based on the result received
  func processResult(_ result: Result<Bool, Error>) {
    switch result {
    case .success:
      succeeded()
    case .failure(let error):
      failed(with: error)
    }
  }
  
}

public class ThreadSafeContainer {
  fileprivate let queue: DispatchQueue
  
  public init(queue: DispatchQueue) {
    self.queue = queue
  }
  
}

public class ThreadSafeValueContainer<T>: ThreadSafeContainer {
  private var _value: T
  
  public init(value: T, queue: DispatchQueue) {
    self._value = value
    super.init(queue: queue)
  }
  
  public var value: T? {
    get {
      return queue.sync { [weak self] in
        self?._value
      }
    }
    set(newValue) {
      queue.sync { [weak self] in
        guard let newValue = newValue else { return }
        self?._value = newValue
      }
    }
  }
  
}
 

Это работает так, как и ожидалось. Однако, когда я пишу тест, чтобы убедиться, что он освобождается, тест продолжает терпеть неудачу даже после того, как ожидания оправдались.

Пожалуйста, посмотрите на тестовый код ниже

 import XCTest

class AggregatorTests: XCTestCase {
 
  func testTaskAggregatorShouldDeallocatateUponSuccess() {
    
    class TaskContainer {
      let aggregator: CustomKewlAggregator
      
      init(aggregator: CustomKewlAggregator = CustomKewlAggregator()) {
        self.aggregator = aggregator
      }
    }

    class CustomKewlAggregator: DaddysMagicalTaskAggregator {
      var willDeinit: (() -> Void)?
      
      deinit {
        willDeinit?()
      }
    }
    
    let myExpecation = self.expectation(description: "Task Aggregator should deallocate")
    var container: TaskContainer? = TaskContainer()
    
    let t1 = KewlTask { t in
        t.succeeded()
    }
    
    let t2 = KewlTask {
      $0.succeeded()
    }
    
    container?.aggregator.willDeinit = {
      myExpecation.fulfill()
    }
    
    container?.aggregator
      .addTasks([t1, t2])
      .run()
      .onCompletion { (result) in
        container = nil
      }
    
    waitForExpectations(timeout: 4, handler: nil)
  }
}
 

Я добавил точки останова и все остальное, чтобы гарантировать выполнение кода выполнения ожиданий.

Похоже, это не проблема с xCode, так как я протестировал ее на XCode 11.7, 12.1, 12.2 и 12.4.

Есть идеи, что здесь происходит? Для меня это похоже на ошибку в XCTests.