How to use satisfyAllOfMatcher method of func class

1import Foundation
2
3/// A Nimble matcher that succeeds when the actual value matches with all of the matchers
4/// provided in the variable list of matchers.
5public func satisfyAllOf<T, U>(_ matchers: U...) -> Predicate<T>
6    where U: Matcher, U.ValueType == T {
7        return satisfyAllOf(matchers.map { $0.predicate })
8}
9
10internal func satisfyAllOf<T>(_ predicates: [Predicate<T>]) -> Predicate<T> {
11	return Predicate.define { actualExpression in
12        var postfixMessages = [String]()
13        var matches = true
14        for predicate in predicates {
15            let result = try predicate.satisfies(actualExpression)
16            if result.toBoolean(expectation: .toNotMatch) {
17                matches = false
18            }
19            postfixMessages.append("{\(result.message.expectedMessage)}")
20        }
21
22        var msg: ExpectationMessage
23        if let actualValue = try actualExpression.evaluate() {
24            msg = .expectedCustomValueTo(
25                "match all of: " + postfixMessages.joined(separator: ", and "),
26                "\(actualValue)"
27            )
28        } else {
29            msg = .expectedActualValueTo(
30                "match all of: " + postfixMessages.joined(separator: ", and ")
31            )
32        }
33
34        return PredicateResult(bool: matches, message: msg)
35    }
36}
37
38public func && <T>(left: Predicate<T>, right: Predicate<T>) -> Predicate<T> {
39    return satisfyAllOf(left, right)
40}
41
42#if canImport(Darwin)
43extension NMBObjCMatcher {
44    @objc public class func satisfyAllOfMatcher(_ matchers: [NMBMatcher]) -> NMBPredicate {
45        return NMBPredicate { actualExpression in
46            if matchers.isEmpty {
47                return NMBPredicateResult(
48                    status: NMBPredicateStatus.fail,
49                    message: NMBExpectationMessage(
50                        fail: "satisfyAllOf must be called with at least one matcher"
51                    )
52                )
53            }
54
55            var elementEvaluators = [Predicate<NSObject>]()
56            for matcher in matchers {
57                let elementEvaluator = Predicate<NSObject> { expression in
58                    if let predicate = matcher as? NMBPredicate {
59                        // swiftlint:disable:next line_length
60                        return predicate.satisfies({ try expression.evaluate() }, location: actualExpression.location).toSwift()
61                    } else {
62                        let failureMessage = FailureMessage()
63                        let success = matcher.matches(
64                            // swiftlint:disable:next force_try
65                            { try! expression.evaluate() },
66                            failureMessage: failureMessage,
67                            location: actualExpression.location
68                        )
69                        return PredicateResult(bool: success, message: failureMessage.toExpectationMessage())
70                    }
71                }
72
73                elementEvaluators.append(elementEvaluator)
74            }
75
76            return try satisfyAllOf(elementEvaluators).satisfies(actualExpression).toObjectiveC()
77        }
78    }
79}
80#endif
81

Source: SatisfyAllOf.swift

import Foundation

/// A Nimble matcher that succeeds when the actual value matches with all of the matchers
/// provided in the variable list of matchers.
public func satisfyAllOf<T, U>(_ matchers: U...) -> Predicate<T>
    where U: Matcher, U.ValueType == T {
        return satisfyAllOf(matchers.map { $0.predicate })
}

internal func satisfyAllOf<T>(_ predicates: [Predicate<T>]) -> Predicate<T> {
	return Predicate.define { actualExpression in
        var postfixMessages = [String]()
        var matches = true
        for predicate in predicates {
            let result = try predicate.satisfies(actualExpression)
            if result.toBoolean(expectation: .toNotMatch) {
                matches = false
            }
            postfixMessages.append("{\(result.message.expectedMessage)}")
        }

        var msg: ExpectationMessage
        if let actualValue = try actualExpression.evaluate() {
            msg = .expectedCustomValueTo(
                "match all of: " + postfixMessages.joined(separator: ", and "),
                "\(actualValue)"
            )
        } else {
            msg = .expectedActualValueTo(
                "match all of: " + postfixMessages.joined(separator: ", and ")
            )
        }

        return PredicateResult(bool: matches, message: msg)
    }
}

public func && <T>(left: Predicate<T>, right: Predicate<T>) -> Predicate<T> {
    return satisfyAllOf(left, right)
}

#if canImport(Darwin)
extension NMBObjCMatcher {
    @objc public class func satisfyAllOfMatcher(_ matchers: [NMBMatcher]) -> NMBPredicate {
        return NMBPredicate { actualExpression in
            if matchers.isEmpty {
                return NMBPredicateResult(
                    status: NMBPredicateStatus.fail,
                    message: NMBExpectationMessage(
                        fail: "satisfyAllOf must be called with at least one matcher"
                    )
                )
            }

            var elementEvaluators = [Predicate<NSObject>]()
            for matcher in matchers {
                let elementEvaluator = Predicate<NSObject> { expression in
                    if let predicate = matcher as? NMBPredicate {
                        // swiftlint:disable:next line_length
                        return predicate.satisfies({ try expression.evaluate() }, location: actualExpression.location).toSwift()
                    } else {
                        let failureMessage = FailureMessage()
                        let success = matcher.matches(
                            // swiftlint:disable:next force_try
                            { try! expression.evaluate() },
                            failureMessage: failureMessage,
                            location: actualExpression.location
                        )
                        return PredicateResult(bool: success, message: failureMessage.toExpectationMessage())
                    }
                }

                elementEvaluators.append(elementEvaluator)
            }

            return try satisfyAllOf(elementEvaluators).satisfies(actualExpression).toObjectiveC()
        }
    }
}
#endif