Memory leaks and retain cycles

final class ProductViewController: UIViewController {
    private let viewModel: ProductViewModel
    private var cancellables = Set<AnyCancellable>()
    private var observer: NSObjectProtocol?

    override func viewDidLoad() {
        super.viewDidLoad()

        // 1. A callback stored by an object self owns
        viewModel.onChange = { [weak self] state in
            self?.render(state)
        }

        // 2. A Combine subscription stored in self's own set
        viewModel.$price
            .receive(on: DispatchQueue.main)
            .sink { [weak self] price in self?.priceLabel.text = price.formatted() }
            .store(in: &cancellables)

        // 3. A block-based notification observer
        observer = NotificationCenter.default.addObserver(
            forName: UIApplication.didBecomeActiveNotification, object: nil, queue: .main
        ) { [weak self] _ in
            self?.viewModel.refresh()
        }
    }

    deinit {
        if let observer { NotificationCenter.default.removeObserver(observer) }
        print("ProductViewController deinit")          // proof that it was freed
    }
}

@MainActor
final class ChatViewModel {
    private(set) var messages: [Message] = []
    private var listenTask: Task<Void, Never>?
    private let service: ChatService

    init(service: ChatService) { self.service = service }

    func start() {
        listenTask = Task { [weak self, service] in
            for await message in service.messages() {
                guard let self else { return }      // checked per message, not pinned for the loop
                self.messages.append(message)
            }
        }
    }

    func stop() {
        listenTask?.cancel()
        listenTask = nil
    }
}

// In SwiftUI, let the view own the lifetime instead:
struct ChatView: View {
    @State private var model: ChatModel
    var body: some View {
        MessageList(messages: model.messages)
            .task { await model.listen() }          // cancelled automatically when the view disappears
    }
}

extension XCTestCase {
    func assertNoLeak(_ instance: AnyObject, file: StaticString = #filePath, line: UInt = #line) {
        addTeardownBlock { [weak instance] in
            XCTAssertNil(instance, "Instance should have been deallocated. Potential retain cycle.",
                         file: file, line: line)
        }
    }
}

final class CartViewControllerTests: XCTestCase {
    @MainActor
    func testCartScreenIsReleased() {
        let cart = CartModel()
        let sut = CartViewController(cart: cart)
        assertNoLeak(sut)
        sut.loadViewIfNeeded()          // runs viewDidLoad, where the closures are set up
    }
}