How to use startObserving method of NotificationCollector class

1import Foundation
2
3internal class NotificationCollector {
4    private(set) var observedNotifications: [Notification]
5    private let notificationCenter: NotificationCenter
6    private var token: NSObjectProtocol?
7
8    required init(notificationCenter: NotificationCenter) {
9        self.notificationCenter = notificationCenter
10        self.observedNotifications = []
11    }
12
13    func startObserving() {
14        // swiftlint:disable:next line_length
15        self.token = self.notificationCenter.addObserver(forName: nil, object: nil, queue: nil) { [weak self] notification in
16            // linux-swift gets confused by .append(n)
17            self?.observedNotifications.append(notification)
18        }
19    }
20
21    deinit {
22        if let token = self.token {
23            self.notificationCenter.removeObserver(token)
24        }
25    }
26}
27
28private let mainThread = pthread_self()
29
30public func postNotifications(
31    _ predicate: Predicate<[Notification]>,
32    fromNotificationCenter center: NotificationCenter = .default
33) -> Predicate<Any> {
34    _ = mainThread // Force lazy-loading of this value
35    let collector = NotificationCollector(notificationCenter: center)
36    collector.startObserving()
37    var once: Bool = false
38
39    return Predicate { actualExpression in
40        let collectorNotificationsExpression = Expression(
41            memoizedExpression: { _ in
42                return collector.observedNotifications
43            },
44            location: actualExpression.location,
45            withoutCaching: true
46        )
47
48        assert(pthread_equal(mainThread, pthread_self()) != 0, "Only expecting closure to be evaluated on main thread.")
49        if !once {
50            once = true
51            _ = try actualExpression.evaluate()
52        }
53
54        let actualValue: String
55        if collector.observedNotifications.isEmpty {
56            actualValue = "no notifications"
57        } else {
58            actualValue = "<\(stringify(collector.observedNotifications))>"
59        }
60
61        var result = try predicate.satisfies(collectorNotificationsExpression)
62        result.message = result.message.replacedExpectation { message in
63            return .expectedCustomValueTo(message.expectedMessage, actualValue)
64        }
65        return result
66    }
67}
68
69public func postNotifications<T>(
70    _ notificationsMatcher: T,
71    fromNotificationCenter center: NotificationCenter = .default)
72    -> Predicate<Any>
73    where T: Matcher, T.ValueType == [Notification]
74{
75    _ = mainThread // Force lazy-loading of this value
76    let collector = NotificationCollector(notificationCenter: center)
77    collector.startObserving()
78    var once: Bool = false
79
80    return Predicate { actualExpression in
81        let collectorNotificationsExpression = Expression(memoizedExpression: { _ in
82            return collector.observedNotifications
83            }, location: actualExpression.location, withoutCaching: true)
84
85        assert(pthread_equal(mainThread, pthread_self()) != 0, "Only expecting closure to be evaluated on main thread.")
86        if !once {
87            once = true
88            _ = try actualExpression.evaluate()
89        }
90
91        let failureMessage = FailureMessage()
92        let match = try notificationsMatcher.matches(collectorNotificationsExpression, failureMessage: failureMessage)
93        if collector.observedNotifications.isEmpty {
94            failureMessage.actualValue = "no notifications"
95        } else {
96            failureMessage.actualValue = "<\(stringify(collector.observedNotifications))>"
97        }
98        return PredicateResult(bool: match, message: failureMessage.toExpectationMessage())
99    }
100}
101

Source: PostNotification.swift

import Foundation

internal class NotificationCollector {
    private(set) var observedNotifications: [Notification]
    private let notificationCenter: NotificationCenter
    private var token: NSObjectProtocol?

    required init(notificationCenter: NotificationCenter) {
        self.notificationCenter = notificationCenter
        self.observedNotifications = []
    }

    func startObserving() {
        // swiftlint:disable:next line_length
        self.token = self.notificationCenter.addObserver(forName: nil, object: nil, queue: nil) { [weak self] notification in
            // linux-swift gets confused by .append(n)
            self?.observedNotifications.append(notification)
        }
    }

    deinit {
        if let token = self.token {
            self.notificationCenter.removeObserver(token)
        }
    }
}

private let mainThread = pthread_self()

public func postNotifications(
    _ predicate: Predicate<[Notification]>,
    fromNotificationCenter center: NotificationCenter = .default
) -> Predicate<Any> {
    _ = mainThread // Force lazy-loading of this value
    let collector = NotificationCollector(notificationCenter: center)
    collector.startObserving()
    var once: Bool = false

    return Predicate { actualExpression in
        let collectorNotificationsExpression = Expression(
            memoizedExpression: { _ in
                return collector.observedNotifications
            },
            location: actualExpression.location,
            withoutCaching: true
        )

        assert(pthread_equal(mainThread, pthread_self()) != 0, "Only expecting closure to be evaluated on main thread.")
        if !once {
            once = true
            _ = try actualExpression.evaluate()
        }

        let actualValue: String
        if collector.observedNotifications.isEmpty {
            actualValue = "no notifications"
        } else {
            actualValue = "<\(stringify(collector.observedNotifications))>"
        }

        var result = try predicate.satisfies(collectorNotificationsExpression)
        result.message = result.message.replacedExpectation { message in
            return .expectedCustomValueTo(message.expectedMessage, actualValue)
        }
        return result
    }
}

public func postNotifications<T>(
    _ notificationsMatcher: T,
    fromNotificationCenter center: NotificationCenter = .default)
    -> Predicate<Any>
    where T: Matcher, T.ValueType == [Notification]
{
    _ = mainThread // Force lazy-loading of this value
    let collector = NotificationCollector(notificationCenter: center)
    collector.startObserving()
    var once: Bool = false

    return Predicate { actualExpression in
        let collectorNotificationsExpression = Expression(memoizedExpression: { _ in
            return collector.observedNotifications
            }, location: actualExpression.location, withoutCaching: true)

        assert(pthread_equal(mainThread, pthread_self()) != 0, "Only expecting closure to be evaluated on main thread.")
        if !once {
            once = true
            _ = try actualExpression.evaluate()
        }

        let failureMessage = FailureMessage()
        let match = try notificationsMatcher.matches(collectorNotificationsExpression, failureMessage: failureMessage)
        if collector.observedNotifications.isEmpty {
            failureMessage.actualValue = "no notifications"
        } else {
            failureMessage.actualValue = "<\(stringify(collector.observedNotifications))>"
        }
        return PredicateResult(bool: match, message: failureMessage.toExpectationMessage())
    }
}