即使在满足期望后 XCTest 也失败了

如何解决即使在满足期望后 XCTest 也失败了

我有一个任务聚合器，它以同步方式聚合和执行任务。它是线程安全的等等。这是它的样子

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 中的一个错误。