How to use appendedBeNilHint method of NMBExpectationMessage class

...53            return .details(expectation.appended(message: message), msg)54        }55    }56    /// Appends a message hinting to use beNil() for when the actual value given was nil.57    public func appendedBeNilHint() -> ExpectationMessage {58        return appended(message: " (use beNil() to match nils)")59    }60    /// Appends a detailed (aka - multiline) message after the primary expectation message61    /// Detailed messages will be placed after .appended(message:) calls.62    public func appended(details: String) -> ExpectationMessage {63        return .details(self, details)64    }65    internal func visitLeafs(_ f: (ExpectationMessage) -> ExpectationMessage) -> ExpectationMessage {66        switch self {67        case .fail, .expectedTo, .expectedActualValueTo, .expectedCustomValueTo:68            return f(self)69        case let .prepends(msg, expectation):70            return .prepends(msg, expectation.visitLeafs(f))71        case let .appends(expectation, msg):72            return .appends(expectation.visitLeafs(f), msg)73        case let .details(expectation, msg):74            return .details(expectation.visitLeafs(f), msg)75        }76    }77    /// Replaces a primary expectation with one returned by f. Preserves all composite expectations78    /// that were built upon it (aka - all appended(message:) and appended(details:).79    public func replacedExpectation(_ f: @escaping (ExpectationMessage) -> ExpectationMessage) -> ExpectationMessage {80        func walk(_ msg: ExpectationMessage) -> ExpectationMessage {81            switch msg {82            case .fail, .expectedTo, .expectedActualValueTo, .expectedCustomValueTo:83                return f(msg)84            default:85                return msg86            }87        }88        return visitLeafs(walk)89    }90    /// Wraps a primary expectation with text before and after it.91    /// Alias to prepended(message: before).appended(message: after)92    public func wrappedExpectation(before: String, after: String) -> ExpectationMessage {93        return prepended(expectation: before).appended(message: after)94    }95    /// Prepends a message by modifying the primary expectation96    public func prepended(expectation message: String) -> ExpectationMessage {97        func walk(_ msg: ExpectationMessage) -> ExpectationMessage {98            switch msg {99            case let .expectedTo(msg):100                return .expectedTo(message + msg)101            case let .expectedActualValueTo(msg):102                return .expectedActualValueTo(message + msg)103            case let .expectedCustomValueTo(msg, actual):104                return .expectedCustomValueTo(message + msg, actual)105            default:106                return msg.visitLeafs(walk)107            }108        }109        return visitLeafs(walk)110    }111    // TODO: test & verify correct behavior112    internal func prepended(message: String) -> ExpectationMessage {113        return .prepends(message, self)114    }115    /// Converts the tree of ExpectationMessages into a final built string.116    public func toString(actual: String, expected: String = "expected", to: String = "to") -> String {117        switch self {118        case let .fail(msg):119            return msg120        case let .expectedTo(msg):121            return "\(expected) \(to) \(msg)"122        case let .expectedActualValueTo(msg):123            return "\(expected) \(to) \(msg), got \(actual)"124        case let .expectedCustomValueTo(msg, actual):125            return "\(expected) \(to) \(msg), got \(actual)"126        case let .prepends(msg, expectation):127            return "\(msg)\(expectation.toString(actual: actual, expected: expected, to: to))"128        case let .appends(expectation, msg):129            return "\(expectation.toString(actual: actual, expected: expected, to: to))\(msg)"130        case let .details(expectation, msg):131            return "\(expectation.toString(actual: actual, expected: expected, to: to))\n\n\(msg)"132        }133    }134    // Backwards compatibility: converts ExpectationMessage tree to FailureMessage135    internal func update(failureMessage: FailureMessage) {136        switch self {137        case let .fail(msg):138            failureMessage.stringValue = msg139        case let .expectedTo(msg):140            failureMessage.actualValue = nil141            failureMessage.postfixMessage = msg142        case let .expectedActualValueTo(msg):143            failureMessage.postfixMessage = msg144        case let .expectedCustomValueTo(msg, actual):145            failureMessage.postfixMessage = msg146            failureMessage.actualValue = actual147        case let .prepends(msg, expectation):148            expectation.update(failureMessage: failureMessage)149            if let desc = failureMessage.userDescription {150                failureMessage.userDescription = "\(msg)\(desc)"151            } else {152                failureMessage.userDescription = msg153            }154        case let .appends(expectation, msg):155            expectation.update(failureMessage: failureMessage)156            failureMessage.appendMessage(msg)157        case let .details(expectation, msg):158            expectation.update(failureMessage: failureMessage)159            failureMessage.appendDetails(msg)160        }161    }162}163extension FailureMessage {164    internal func toExpectationMessage() -> ExpectationMessage {165        let defaultMsg = FailureMessage()166        if expected != defaultMsg.expected || _stringValueOverride != nil {167            return .fail(stringValue)168        }169        var msg: ExpectationMessage = .fail(userDescription ?? "")170        if actualValue != "" && actualValue != nil {171            msg = .expectedCustomValueTo(postfixMessage, actualValue ?? "")172        } else if postfixMessage != defaultMsg.postfixMessage {173            if actualValue == nil {174                msg = .expectedTo(postfixMessage)175            } else {176                msg = .expectedActualValueTo(postfixMessage)177            }178        }179        if postfixActual != defaultMsg.postfixActual {180            msg = .appends(msg, postfixActual)181        }182        if let m = extendedMessage {183            msg = .details(msg, m)184        }185        return msg186    }187}188#if _runtime(_ObjC)189public class NMBExpectationMessage: NSObject {190    private let msg: ExpectationMessage191    internal init(swift msg: ExpectationMessage) {192        self.msg = msg193    }194    public init(expectedTo message: String) {195        self.msg = .expectedTo(message)196    }197    public init(expectedActualValueTo message: String) {198        self.msg = .expectedActualValueTo(message)199    }200    public init(expectedActualValueTo message: String, customActualValue actual: String) {201        self.msg = .expectedCustomValueTo(message, actual)202    }203    public init(fail message: String) {204        self.msg = .fail(message)205    }206    public init(prepend message: String, child: NMBExpectationMessage) {207        self.msg = .prepends(message, child.msg)208    }209    public init(appendedMessage message: String, child: NMBExpectationMessage) {210        self.msg = .appends(child.msg, message)211    }212    public init(prependedMessage message: String, child: NMBExpectationMessage) {213        self.msg = .prepends(message, child.msg)214    }215    public init(details message: String, child: NMBExpectationMessage) {216        self.msg = .details(child.msg, message)217    }218    public func appendedBeNilHint() -> NMBExpectationMessage {219        return NMBExpectationMessage(swift: msg.appendedBeNilHint())220    }221    public func toSwift() -> ExpectationMessage { return self.msg }222}223extension ExpectationMessage {224    func toObjectiveC() -> NMBExpectationMessage {225        return NMBExpectationMessage(swift: self)226    }227}228#endif...

1let message = NMBExpectationMessage()2let _ = message.appendedBeNilHint()3let message = NMBExpectationMessage()4let _ = message.appendedBeNilHint()5let message = NMBExpectationMessage()6let _ = message.appendedBeNilHint()7let message = NMBExpectationMessage()8let _ = message.appendedBeNilHint()9let message = NMBExpectationMessage()10let _ = message.appendedBeNilHint()11let message = NMBExpectationMessage()12let _ = message.appendedBeNilHint()13let message = NMBExpectationMessage()14let _ = message.appendedBeNilHint()15let message = NMBExpectationMessage()16let _ = message.appendedBeNilHint()17let message = NMBExpectationMessage()18let _ = message.appendedBeNilHint()19let message = NMBExpectationMessage()20let _ = message.appendedBeNilHint()21let message = NMBExpectationMessage()22let _ = message.appendedBeNilHint()23let message = NMBExpectationMessage()24let _ = message.appendedBeNilHint()

1func testAppendedBeNilHint() {2    let message = NMBExpectationMessage()3    message.appendedBeNilHint()4    expect(message.stringValue()).to(equal("be nil"))5}6func testAppendedBeNilHint() {7    let message = NMBFailureMessage()8    message.appendedBeNilHint()9    expect(message.stringValue()).to(equal("be nil"))10}11func testAppendedBeNilHint() {12    let message = NMBObjCMatcher()13    message.appendedBeNilHint()14    expect(message.stringValue()).to(equal("be nil"))15}16func testAppendedBeNilHint() {17    let message = NMBObjCBeNil()18    message.appendedBeNilHint()19    expect(message.stringValue()).to(equal("be nil"))20}21func testAppendedBeNilHint() {22    let message = NMBObjCBeEmpty()23    message.appendedBeNilHint()24    expect(message.stringValue()).to(equal("be nil"))25}26func testAppendedBeNilHint() {27    let message = NMBObjCBeGreaterThan()28    message.appendedBeNilHint()29    expect(message.stringValue()).to(equal("be nil"))30}31func testAppendedBeNilHint() {32    let message = NMBObjCBeGreaterThanOrEqualTo()33    message.appendedBeNilHint()34    expect(message.stringValue()).to(equal("be nil"))35}36func testAppendedBeNilHint() {37    let message = NMBObjCBeLessThan()38    message.appendedBeNilHint()39    expect(message.stringValue()).to(equal("be nil"))40}

1func testAppendedBeNilHint() {2    let message = NMBExpectationMessage()3    message.appendedBeNilHint()4    XCTAssertEqual(message.stringValue, "be nil")5}6func testAppendedBeNilHint() {7    let message = NMBFailureMessage()8    message.appendedBeNilHint()9    XCTAssertEqual(message.stringValue, "be nil")10}11func testAppendedBeNilHint() {12    let message = NMBPredicateFailureMessage()13    message.appendedBeNilHint()14    XCTAssertEqual(message.stringValue, "be nil")15}16func testAppendedBeNilHint() {17    let message = NMBTestFailure()18    message.appendedBeNilHint()19    XCTAssertEqual(message.stringValue, "be nil")20}21func testAppendedBeNilHint() {22    let message = NMBTestFailure()23    message.appendedBeNilHint()24    XCTAssertEqual(message.stringValue, "be nil")25}26func testAppendedBeNilHint() {27    let message = NMBTestFailure()28    message.appendedBeNilHint()29    XCTAssertEqual(message.stringValue, "be nil")30}31func testAppendedBeNilHint() {32    let message = NMBTestFailure()33    message.appendedBeNilHint()34    XCTAssertEqual(message.stringValue, "be nil")35}36func testAppendedBeNilHint() {37    let message = NMBTestFailure()38    message.appendedBeNilHint()39    XCTAssertEqual(message.stringValue, "be nil")40}41func testAppendedBeNilHint() {42    let message = NMBTestFailure()

1expect(1).to(beNil(), description: "1 should be nil")2expect(1).to(beNil(), description: "1 should be nil", file: "1.swift", line: 1)3expect(1).to(beNil(), description: "1 should be nil", file: "1.swift", line: 1, functionName: "test")4expect(1).to(beNil(), description: "1 should be nil")5expect(1).to(beNil(), description: "1 should be nil", file: "2.swift", line: 2)6expect(1).to(beNil(), description: "1 should be nil", file: "2.swift", line: 2, functionName: "test")7expect(1).to(beNil(), description: "1 should be nil")8expect(1).to(beNil(), description: "1 should be nil", file: "3.swift", line: 3)9expect(1).to(beNil(), description: "1 should be nil", file: "3.swift", line: 3, functionName: "test")10expect(1).to(beNil(), description: "1 should be nil")11expect(1).to(beNil(), description: "1 should be nil", file: "4.swift", line: 4)12expect(1).to(beNil(), description: "1 should be nil", file: "4.swift",

1import Nimble2import Quick3class TestClass: QuickSpec {4    override func spec() {5        describe("test") {6            it("test") {7                expect(nil).to(beNil())8            }9        }10    }11}12![Test Results](

1import Nimble2import Quick3import Foundation4class NMBExpectationMessage_1 : QuickSpec {5    override func spec() {6        describe("NMBExpectationMessage") {7            it("appendedBeNilHint method") {8                let message = NMBExpectationMessage.to("be nil")9                let result = message.appendedBeNilHint()10                expect(result.description) == "to be nil or be an instance of NSNull"11            }12        }13    }14}15import Nimble16import Quick17import Foundation18class NMBExpectationMessage_2 : QuickSpec {19    override func spec() {20        describe("NMBExpectationMessage") {21            it("appendedBeNilHint method") {22                let message = NMBExpectationMessage.to("be nil")23                let result = message.appendedBeNilHint()24                expect(result.description) == "to be nil or be an instance of NSNull"25            }26        }27    }28}

1var message = NMBExpectationMessage()2message.appendedBeNilHint(actual)3expect(message.stringValue).to(equal("to be nil, got <Actual>"))4func appendedBeNilHint(actual: String) {5    if let actual = actual {6        self.appendedMessage("got <\(actual)>")7    }8}9describe("appendedBeNilHint") {10    it("appends the hint for beNil") {11        let message = NMBExpectationMessage()12        message.appendedBeNilHint(actual)13        expect(message.stringValue).to(equal("to be nil, got <Actual>"))14    }15}