How to use satisfies method of NMBPredicate class

...25    /// Uses a predicate on a given value to see if it passes the predicate.26    ///27    /// @param expression The value to run the predicate's logic against28    /// @returns A predicate result indicate passing or failing and an associated error message.29    public func satisfies(_ expression: Expression<T>) throws -> PredicateResult {30        return try matcher(expression)31    }32}33/// Provides convenience helpers to defining predicates34extension Predicate {35    /// Like Predicate() constructor, but automatically guard against nil (actual) values36    public static func define(matcher: @escaping (Expression<T>) throws -> PredicateResult) -> Predicate<T> {37        return Predicate<T> { actual in38            return try matcher(actual)39        }.requireNonNil40    }41    /// Defines a predicate with a default message that can be returned in the closure42    /// Also ensures the predicate's actual value cannot pass with `nil` given.43    public static func define(_ msg: String, matcher: @escaping (Expression<T>, ExpectationMessage) throws -> PredicateResult) -> Predicate<T> {44        return Predicate<T> { actual in45            return try matcher(actual, .expectedActualValueTo(msg))46        }.requireNonNil47    }48    /// Defines a predicate with a default message that can be returned in the closure49    /// Unlike `define`, this allows nil values to succeed if the given closure chooses to.50    public static func defineNilable(_ msg: String, matcher: @escaping (Expression<T>, ExpectationMessage) throws -> PredicateResult) -> Predicate<T> {51        return Predicate<T> { actual in52            return try matcher(actual, .expectedActualValueTo(msg))53        }54    }55}56extension Predicate {57    /// Provides a simple predicate definition that provides no control over the predefined58    /// error message.59    ///60    /// Also ensures the predicate's actual value cannot pass with `nil` given.61    public static func simple(_ msg: String, matcher: @escaping (Expression<T>) throws -> PredicateStatus) -> Predicate<T> {62        return Predicate<T> { actual in63            return PredicateResult(status: try matcher(actual), message: .expectedActualValueTo(msg))64        }.requireNonNil65    }66    /// Provides a simple predicate definition that provides no control over the predefined67    /// error message.68    ///69    /// Unlike `simple`, this allows nil values to succeed if the given closure chooses to.70    public static func simpleNilable(_ msg: String, matcher: @escaping (Expression<T>) throws -> PredicateStatus) -> Predicate<T> {71        return Predicate<T> { actual in72            return PredicateResult(status: try matcher(actual), message: .expectedActualValueTo(msg))73        }74    }75}76// Question: Should this be exposed? It's safer to not for now and decide later.77internal enum ExpectationStyle {78    case toMatch, toNotMatch79}80/// The value that a Predicates return to describe if the given (actual) value matches the81/// predicate.82public struct PredicateResult {83    /// Status indicates if the predicate matches, does not match, or fails.84    var status: PredicateStatus85    /// The error message that can be displayed if it does not match86    var message: ExpectationMessage87    /// Constructs a new PredicateResult with a given status and error message88    public init(status: PredicateStatus, message: ExpectationMessage) {89        self.status = status90        self.message = message91    }92    /// Shorthand to PredicateResult(status: PredicateStatus(bool: bool), message: message)93    public init(bool: Bool, message: ExpectationMessage) {94        self.status = PredicateStatus(bool: bool)95        self.message = message96    }97    /// Converts the result to a boolean based on what the expectation intended98    internal func toBoolean(expectation style: ExpectationStyle) -> Bool {99        return status.toBoolean(expectation: style)100    }101}102/// PredicateStatus is a trinary that indicates if a Predicate matches a given value or not103public enum PredicateStatus {104    /// Matches indicates if the predicate / matcher passes with the given value105    ///106    /// For example, `equals(1)` returns `.matches` for `expect(1).to(equal(1))`.107    case matches108    /// DoesNotMatch indicates if the predicate / matcher fails with the given value, but *would*109    /// succeed if the expectation was inverted.110    ///111    /// For example, `equals(2)` returns `.doesNotMatch` for `expect(1).toNot(equal(2))`.112    case doesNotMatch113    /// Fail indicates the predicate will never satisfy with the given value in any case.114    /// A perfect example is that most matchers fail whenever given `nil`.115    ///116    /// Using `equal(1)` fails both `expect(nil).to(equal(1))` and `expect(nil).toNot(equal(1))`.117    /// Note: Predicate's `requireNonNil` property will also provide this feature mostly for free.118    ///       Your predicate will still need to guard against nils, but error messaging will be119    ///       handled for you.120    case fail121    /// Converts a boolean to either .matches (if true) or .doesNotMatch (if false).122    public init(bool matches: Bool) {123        if matches {124            self = .matches125        } else {126            self = .doesNotMatch127        }128    }129    private func shouldMatch() -> Bool {130        switch self {131        case .matches: return true132        case .doesNotMatch, .fail: return false133        }134    }135    private func shouldNotMatch() -> Bool {136        switch self {137        case .doesNotMatch: return true138        case .matches, .fail: return false139        }140    }141    /// Converts the PredicateStatus result to a boolean based on what the expectation intended142    internal func toBoolean(expectation style: ExpectationStyle) -> Bool {143        if style == .toMatch {144            return shouldMatch()145        } else {146            return shouldNotMatch()147        }148    }149}150// Backwards compatibility until Old Matcher API removal151extension Predicate: Matcher {152    /// Compatibility layer for old Matcher API, deprecated153    public static func fromDeprecatedFullClosure(_ matcher: @escaping (Expression<T>, FailureMessage, Bool) throws -> Bool) -> Predicate {154        return Predicate { actual in155            let failureMessage = FailureMessage()156            let result = try matcher(actual, failureMessage, true)157            return PredicateResult(158                status: PredicateStatus(bool: result),159                message: failureMessage.toExpectationMessage()160            )161        }162    }163    /// Compatibility layer for old Matcher API, deprecated.164    /// Emulates the MatcherFunc API165    public static func fromDeprecatedClosure(_ matcher: @escaping (Expression<T>, FailureMessage) throws -> Bool) -> Predicate {166        return Predicate { actual in167            let failureMessage = FailureMessage()168            let result = try matcher(actual, failureMessage)169            return PredicateResult(170                status: PredicateStatus(bool: result),171                message: failureMessage.toExpectationMessage()172            )173        }174    }175    /// Compatibility layer for old Matcher API, deprecated.176    /// Same as calling .predicate on a MatcherFunc or NonNilMatcherFunc type.177    public static func fromDeprecatedMatcher<M>(_ matcher: M) -> Predicate where M: Matcher, M.ValueType == T {178        return self.fromDeprecatedFullClosure(matcher.toClosure)179    }180    /// Deprecated Matcher API, use satisfies(_:_) instead181    public func matches(_ actualExpression: Expression<T>, failureMessage: FailureMessage) throws -> Bool {182        let result = try satisfies(actualExpression)183        result.message.update(failureMessage: failureMessage)184        return result.toBoolean(expectation: .toMatch)185    }186    /// Deprecated Matcher API, use satisfies(_:_) instead187    public func doesNotMatch(_ actualExpression: Expression<T>, failureMessage: FailureMessage) throws -> Bool {188        let result = try satisfies(actualExpression)189        result.message.update(failureMessage: failureMessage)190        return result.toBoolean(expectation: .toNotMatch)191    }192}193extension Predicate {194    // Someday, make this public? Needs documentation195    internal func after(f: @escaping (Expression<T>, PredicateResult) throws -> PredicateResult) -> Predicate<T> {196        return Predicate { actual -> PredicateResult in197            let result = try self.satisfies(actual)198            return try f(actual, result)199        }200    }201    /// Returns a new Predicate based on the current one that always fails if nil is given as202    /// the actual value.203    ///204    /// This replaces `NonNilMatcherFunc`.205    public var requireNonNil: Predicate<T> {206        return after { actual, result in207            if try actual.evaluate() == nil {208                return PredicateResult(209                    status: .fail,210                    message: result.message.appendedBeNilHint()211                )212            }213            return result214        }215    }216}217#if _runtime(_ObjC)218public typealias PredicateBlock = (_ actualExpression: Expression<NSObject>) -> NMBPredicateResult219public class NMBPredicate: NSObject {220    private let predicate: PredicateBlock221    public init(predicate: @escaping PredicateBlock) {222        self.predicate = predicate223    }224    func satisfies(_ expression: @escaping () -> NSObject!, location: SourceLocation) -> NMBPredicateResult {225        let expr = Expression(expression: expression, location: location)226        return self.predicate(expr)227    }228}229extension NMBPredicate: NMBMatcher {230    public func matches(_ actualBlock: @escaping () -> NSObject!, failureMessage: FailureMessage, location: SourceLocation) -> Bool {231        let result = satisfies(actualBlock, location: location).toSwift()232        result.message.update(failureMessage: failureMessage)233        return result.status.toBoolean(expectation: .toMatch)234    }235    public func doesNotMatch(_ actualBlock: @escaping () -> NSObject!, failureMessage: FailureMessage, location: SourceLocation) -> Bool {236        let result = satisfies(actualBlock, location: location).toSwift()237        result.message.update(failureMessage: failureMessage)238        return result.status.toBoolean(expectation: .toNotMatch)239    }240}241final public class NMBPredicateResult: NSObject {242    public var status: NMBPredicateStatus243    public var message: NMBExpectationMessage244    public init(status: NMBPredicateStatus, message: NMBExpectationMessage) {245        self.status = status246        self.message = message247    }248    public init(bool success: Bool, message: NMBExpectationMessage) {249        self.status = NMBPredicateStatus.from(bool: success)250        self.message = message...

1import Foundation2import Nimble3class User {4    init(id: Int, name: String, age: Int) {5    }6}7func testUser() {8    let user = User(id: 1, name: "John", age: 30)9    expect(user).to(satisfy { (user) -> Bool in10    })11}12testUser()

1expect(view).toEventually(satisfyAllOf(beAnInstanceOf(UIView.self), haveValidSnapshot()))2expect(view).toEventually(satisfyAllOf(beAnInstanceOf(UIView.self), haveValidSnapshot()), timeout: 5, pollInterval: 0.5)3expect(view).toEventually(beValidSnapshot())4expect(view).toEventually(beValidSnapshot(), timeout: 5, pollInterval: 0.5)5expect(view).toEventually(beValidSnapshot(named: "mySnapshotName"))6expect(view).toEventually(beValidSnapshot(named: "mySnapshotName"), timeout: 5, pollInterval: 0.5)7expect(view).toEventually(beValidSnapshot(named: "mySnapshotName", device: .iPhone6))8expect(view).toEventually(beValidSnapshot(named: "mySnapshotName", device: .iPhone6), timeout: 5, pollInterval: 0.5)9expect(view).toEventually(beValidSnapshot(named: "mySnapshotName", device: .iPhone6, traits: .init(userInterfaceStyle: .dark)))10expect(view).toEventually(beValidSnapshot(named: "mySnapshotName", device: .iPhone6, traits: .init(userInterfaceStyle: .dark)), timeout: 5, pollInterval: 0.5)11expect(view).toEventually(beValidSnapshot(named: "mySnapshotName", device: .iPhone6, traits: .init(userInterfaceStyle: .dark), identifier: "myIdentifier"))12expect(view).toEventually(beValidSnapshot(named: "mySnapshotName", device: .iPhone6, traits: .init(userInterfaceStyle: .dark), identifier: "myIdentifier"), timeout: 5, pollInterval: 0.5)

1let predicate = NMBPredicate(format: "self contains 'test'")2expect("this is a test").to(satisfy(predicate))3let predicate = NMBPredicate(format: "self contains 'test'")4expect("this is a test").to(match(predicate))5let predicate = NMBPredicate(format: "self contains 'test'")6expect("this is a test").to(match(predicate))7let predicate = NMBPredicate(format: "self contains 'test'")8expect("this is a test").to(match(predicate))9let predicate = NMBPredicate(format: "self contains 'test'")10expect("this is a test").to(match(predicate))11let predicate = NMBPredicate(format: "self contains 'test'")12expect("this is a test").to(match(predicate))13let predicate = NMBPredicate(format: "self contains 'test'")14expect("this is a test").to(match(predicate))15let predicate = NMBPredicate(format: "self contains 'test'")16expect("this is a test").to(match(predicate))17let predicate = NMBPredicate(format: "self contains 'test'")18expect("this is a test").to(match(predicate))19let predicate = NMBPredicate(format: "self contains 'test'")20expect("this is a test").to(match(predicate))21let predicate = NMBPredicate(format: "self contains 'test'")22expect("this is a test").to(match(predicate))23let predicate = NMBPredicate(format: "self contains '

1let predicate = NMBPredicate { (actualExpression, failureMessage) -> Bool in2    let actual = try actualExpression.evaluate()3    failureMessage.postfixMessage = "match " + (matches ? "foo" : "bar")4}5expect("foo").to(satisfy(predicate))6let predicate = NMBObjCMatcher { (actualExpression, failureMessage, location) -> Bool in7    let actual = try actualExpression.evaluate() as! String8    failureMessage.postfixMessage = "match " + (matches ? "foo" : "bar")9}10expect("foo").to(satisfy(predicate))11let predicate = NMBObjCMatcher { (actualExpression, failureMessage, location) -> Bool in12    let actual = try actualExpression.evaluate() as! String13    failureMessage.postfixMessage = "match " + (matches ? "foo" : "bar")14}15expect("foo").toEventually(satisfy(predicate))16let predicate = NMBPredicate { (actualExpression, failureMessage) -> Bool in17    let actual = try actualExpression.evaluate()18    failureMessage.postfixMessage = "match " + (matches ? "foo" : "bar")19}20expect("foo").toEventually(satisfy(predicate))21let predicate = NMBObjCMatcher { (actualExpression, failureMessage, location) -> Bool in22    let actual = try actualExpression.evaluate() as! String23    failureMessage.postfixMessage = "match " + (matches ? "foo" : "bar")24}25expect("foo").toEventually(satisfy(predicate), timeout: 5)

1import Nimble2import Quick3class QuickSpecTest: QuickSpec {4    override func spec() {5        describe("QuickSpecTest") {6            it("should be able to use satisfies method of NMBPredicate class") {7                expect("abc").to(satisfy { (s: String) -> Bool in8                })9            }10        }11    }12}13import Nimble14import Quick15class QuickSpecTest: QuickSpec {16    override func spec() {17        describe("QuickSpecTest") {18            it("should be able to use beAKindOf method of NMBObjCMatcher class") {19                expect("abc" as Any).to(beAKindOf(NSString.self))20            }21        }22    }23}24import Nimble25import Quick26class QuickSpecTest: QuickSpec {27    override func spec() {28        describe("QuickSpecTest") {29            it("should be able to use beAKindOf method of NMBObjCMatcher class") {30                expect(1 as Any).to(beAKindOf(NSNumber.self))31            }32        }33    }34}35import Nimble36import Quick37class QuickSpecTest: QuickSpec {38    override func spec() {39        describe("QuickSpecTest") {40            it("should be able to use beAKindOf method of NMBObjCMatcher class") {41                expect(1.0 as Any).to(beAKindOf(NSNumber.self))42            }43        }44    }45}46import Nimble47import Quick48class QuickSpecTest: QuickSpec {49    override func spec() {50        describe("QuickSpecTest") {51            it("should be able to use beAKindOf method of NMBObjCMatcher class") {52                expect(1 as Any).to(beAKindOf(NSString.self))53            }54        }55    }56}

1expect("Hello").to(satisfy({ (string) -> Bool in2    return string.contains("Hello")3}))4expect("Hello").toNot(satisfy({ (string) -> Bool in5    return string.contains("World")6}))7expect("Hello").to(NMBPredicate.satisfy({ (string) -> Bool in8    return string.contains("Hello")9}))10expect("Hello").toNot(NMBPredicate.satisfy({ (string) -> Bool in11    return string.contains("World")12}))13expect("Hello").to(NMBPredicate.satisfy({ (string) -> Bool in14    return string.contains("Hello")15}, description: "string contains Hello"))16expect("Hello").toNot(NMBPredicate.satisfy({ (string) -> Bool in17    return string.contains("World")18}, description: "string does not contain World"))19expect("Hello").to(NMBPredicate.satisfy({ (string) -> Bool in20    return string.contains("Hello")21}, failureMessage: { (string) -> String in22    return "expected \(string) to contain Hello"23}))24expect("Hello").toNot(NMBPredicate.satisfy({ (string) -> Bool in25    return string.contains("World")26}, failureMessage: { (string) -> String in27    return "expected \(string) not to contain World"28}))29expect("Hello").to(NMBPredicate.satisfy({ (string) -> Bool in30    return string.contains("Hello")31}, failureMessage: { (string) -> String in32    return "expected \(string) to contain Hello"33}, description: "string contains Hello"))34expect("Hello").toNot(NMBPredicate.satisfy({ (string) -> Bool in

1import Nimble2import Quick3class QuickSpecTest: QuickSpec {4    override func spec() {5        describe("QuickSpecTest") {6            it("should satisfy predicate") {7                expect(string).to(satisfy {8                })9            }10        }11    }12}13import Nimble14import Quick15class QuickSpecTest: QuickSpec {16    override func spec() {17        describe("QuickSpecTest") {18            it("should satisfy predicate") {19                expect(string).to(NMBPredicate { $0 == "Hello World" })20            }21        }22    }23}24import Nimble25import Quick26class QuickSpecTest: QuickSpec {27    override func spec() {28        describe("QuickSpecTest") {29            it("should satisfy predicate") {30                expect(string).toNot(NMBPredicate { $0 == "Hello World" })31            }32        }33    }34}35import Nimble36import Quick37class QuickSpecTest: QuickSpec {38    override func spec() {39        describe("QuickSpecTest") {40            it("should satisfy predicate") {41                expect(string).toNot(satisfy {42                })43            }44        }45    }46}47import Nimble48import Quick49class QuickSpecTest: QuickSpec {50    override func spec() {51        describe("QuickSpecTest") {52            it("should satisfy predicate") {53                expect(string).toNot(satisfy {54                })55            }56        }57    }58}59import Nimble60import Quick61class QuickSpecTest: QuickSpec {62    override func spec() {63        describe("QuickSpecTest") {64            it("should satisfy predicate") {65                expect(string

1import Nimble2class MyTest: XCTestCase {3    func testMyTest() {4        expect(1).to(satisfy { (num) -> Bool in5        })6    }7}8import Nimble9class MyTest: XCTestCase {10    func testMyTest() {11        expect(1).to(equal(1))12    }13}14public class func satisfies(_ predicate: @escaping PredicateClosure) -> NMBPredicate {15        return NMBPredicate { actualExpression in16            let msg = NMBMessage()17            let expr = try actualExpression.evaluate()18            let matches = try predicate(expr)19            return PredicateResult(status: matches, message: msg)20        }21    }22expect("Hello").toNot(NMBPredicate.satisfy({ (string) -> Bool in23    return string.contains("World")24}))25expect("Hello").to(NMBPredicate.satisfy({ (string) -> Bool in26    return string.contains("Hello")27}, description: "string contains Hello"))28expect("Hello").toNot(NMBPredicate.satisfy({ (string) -> Bool in29    return string.contains("World")30}, description: "string does not contain World"))31expect("Hello").to(NMBPredicate.satisfy({ (string) -> Bool in32    return string.contains("Hello")33}, failureMessage: { (string) -> String in34    return "expected \(string) to contain Hello"35}))36expect("Hello").toNot(NMBPredicate.satisfy({ (string) -> Bool in37    return string.contains("World")38}, failureMessage: { (string) -> String in39    return "expected \(string) not to contain World"40}))41expect("Hello").to(NMBPredicate.satisfy({ (string) -> Bool in42    return string.contains("Hello")43}, failureMessage: { (string) -> String in44    return "expected \(string) to contain Hello"45}, description: "string contains Hello"))46expect("Hello").toNot(NMBPredicate.satisfy({ (string) -> Bool in

1import Nimble2import Quick3class QuickSpecTest: QuickSpec {4    override func spec() {5        describe("QuickSpecTest") {6            it("should satisfy predicate") {7                expect(string).to(satisfy {8                })9            }10        }11    }12}13import Nimble14import Quick15class QuickSpecTest: QuickSpec {16    override func spec() {17        describe("QuickSpecTest") {18            it("should satisfy predicate") {19                expect(string).to(NMBPredicate { $0 == "Hello World" })20            }21        }22    }23}24import Nimble25import Quick26class QuickSpecTest: QuickSpec {27    override func spec() {28        describe("QuickSpecTest") {29            it("should satisfy predicate") {30                expect(string).toNot(NMBPredicate { $0 == "Hello World" })31            }32        }33    }34}35import Nimble36import Quick37class QuickSpecTest: QuickSpec {38    override func spec() {39        describe("QuickSpecTest") {40            it("should satisfy predicate") {41                expect(string).toNot(satisfy {42                })43            }44        }45    }46}47import Nimble48import Quick49class QuickSpecTest: QuickSpec {50    override func spec() {51        describe("QuickSpecTest") {52            it("should satisfy predicate") {53                expect(string).toNot(satisfy {54                })55            }56        }57    }58}59import Nimble60import Quick61class QuickSpecTest: QuickSpec {62    override func spec() {63        describe("QuickSpecTest") {64            it("should satisfy predicate") {65                expect(string return matches66}67expect("foo").to(satisfy(predicate))68let predicate = NMBObjCMatcher { (actualExpression, failureMessage, location) -> Bool in69    let actual = try actualExpression.evaluate() as! String70    failureMessage.postfixMessage = "match " + (matches ? "foo" : "bar")71}72expect("foo").toEventually(satisfy(predicate))73let predicate = NMBPredicate { (actualExpression, failureMessage) -> Bool in74    let actual = try actualExpression.evaluate()75    failureMessage.postfixMessage = "match " + (matches ? "foo" : "bar")76}77expect("foo").toEventually(satisfy(predicate))78let predicate = NMBObjCMatcher { (actualExpression, failureMessage, location) -> Bool in79    let actual = try actualExpression.evaluate() as! String80    failureMessage.postfixMessage = "match " + (matches ? "foo" : "bar")81}82expect("foo").toEventually(satisfy(predicate), timeout: 5)

1import Nimble2import Quick3class QuickSpecTest: QuickSpec {4    override func spec() {5        describe("QuickSpecTest") {6            it("should satisfy predicate") {7                expect(string).to(satisfy {8                })9            }10        }11    }12}13import Nimble14import Quick15class QuickSpecTest: QuickSpec {16    override func spec() {17        describe("QuickSpecTest") {18            it("should satisfy predicate") {19                expect(string).to(NMBPredicate { $0 == "Hello World" })20            }21        }22    }23}24import Nimble25import Quick26class QuickSpecTest: QuickSpec {27    override func spec() {28        describe("QuickSpecTest") {29            it("should satisfy predicate") {30                expect(string).toNot(NMBPredicate { $0 == "Hello World" })31            }32        }33    }34}35import Nimble36import Quick37class QuickSpecTest: QuickSpec {38    override func spec() {39        describe("QuickSpecTest") {40            it("should satisfy predicate") {41                expect(string).toNot(satisfy {42                })43            }44        }45    }46}47import Nimble48import Quick49class QuickSpecTest: QuickSpec {50    override func spec() {51        describe("QuickSpecTest") {52            it("should satisfy predicate") {53                expect(string).toNot(satisfy {54                })55            }56        }57    }58}59import Nimble60import Quick61class QuickSpecTest: QuickSpec {62    override func spec() {63        describe("QuickSpecTest") {64            it("should satisfy predicate") {65                expect(string