How to use testBeIdenticalToPositive method of BeIdenticalToObjectTester class

1import Foundation
2import XCTest
3import Nimble
4
5class BeIdenticalToObjectTest: XCTestCase, XCTestCaseProvider {
6    var allTests: [(String, () throws -> Void)] {
7        return [
8            ("testBeIdenticalToPositive", testBeIdenticalToPositive),
9            ("testBeIdenticalToNegative", testBeIdenticalToNegative),
10            ("testBeIdenticalToPositiveMessage", testBeIdenticalToPositiveMessage),
11            ("testBeIdenticalToNegativeMessage", testBeIdenticalToNegativeMessage),
12            ("testFailsOnNils", testFailsOnNils),
13            ("testOperators", testOperators),
14        ]
15    }
16
17    private class BeIdenticalToObjectTester {}
18    private let testObjectA = BeIdenticalToObjectTester()
19    private let testObjectB = BeIdenticalToObjectTester()
20
21    func testBeIdenticalToPositive() {
22        expect(self.testObjectA).to(beIdenticalTo(testObjectA))
23    }
24    
25    func testBeIdenticalToNegative() {
26        expect(self.testObjectA).toNot(beIdenticalTo(testObjectB))
27    }
28    
29    func testBeIdenticalToPositiveMessage() {
30        let message = String(NSString(format: "expected to be identical to <%p>, got <%p>",
31            unsafeBitCast(testObjectB, Int.self), unsafeBitCast(testObjectA, Int.self)))
32        failsWithErrorMessage(message) {
33            expect(self.testObjectA).to(beIdenticalTo(self.testObjectB))
34        }
35    }
36    
37    func testBeIdenticalToNegativeMessage() {
38        let message = String(NSString(format: "expected to not be identical to <%p>, got <%p>",
39            unsafeBitCast(testObjectA, Int.self), unsafeBitCast(testObjectA, Int.self)))
40        failsWithErrorMessage(message) {
41            expect(self.testObjectA).toNot(beIdenticalTo(self.testObjectA))
42        }
43    }
44
45    func testFailsOnNils() {
46        let message1 = String(NSString(format: "expected to be identical to <%p>, got nil",
47            unsafeBitCast(testObjectA, Int.self)))
48        failsWithErrorMessageForNil(message1) {
49            expect(nil as BeIdenticalToObjectTester?).to(beIdenticalTo(self.testObjectA))
50        }
51
52        let message2 = String(NSString(format: "expected to not be identical to <%p>, got nil",
53            unsafeBitCast(testObjectA, Int.self)))
54        failsWithErrorMessageForNil(message2) {
55            expect(nil as BeIdenticalToObjectTester?).toNot(beIdenticalTo(self.testObjectA))
56        }
57    }
58    
59    func testOperators() {
60        expect(self.testObjectA) === testObjectA
61        expect(self.testObjectA) !== testObjectB
62    }
63
64}
65

Source: BeIdenticalToObjectTest.swift

import Foundation
import XCTest
import Nimble

class BeIdenticalToObjectTest: XCTestCase, XCTestCaseProvider {
    var allTests: [(String, () throws -> Void)] {
        return [
            ("testBeIdenticalToPositive", testBeIdenticalToPositive),
            ("testBeIdenticalToNegative", testBeIdenticalToNegative),
            ("testBeIdenticalToPositiveMessage", testBeIdenticalToPositiveMessage),
            ("testBeIdenticalToNegativeMessage", testBeIdenticalToNegativeMessage),
            ("testFailsOnNils", testFailsOnNils),
            ("testOperators", testOperators),
        ]
    }

    private class BeIdenticalToObjectTester {}
    private let testObjectA = BeIdenticalToObjectTester()
    private let testObjectB = BeIdenticalToObjectTester()

    func testBeIdenticalToPositive() {
        expect(self.testObjectA).to(beIdenticalTo(testObjectA))
    }
    
    func testBeIdenticalToNegative() {
        expect(self.testObjectA).toNot(beIdenticalTo(testObjectB))
    }
    
    func testBeIdenticalToPositiveMessage() {
        let message = String(NSString(format: "expected to be identical to <%p>, got <%p>",
            unsafeBitCast(testObjectB, Int.self), unsafeBitCast(testObjectA, Int.self)))
        failsWithErrorMessage(message) {
            expect(self.testObjectA).to(beIdenticalTo(self.testObjectB))
        }
    }
    
    func testBeIdenticalToNegativeMessage() {
        let message = String(NSString(format: "expected to not be identical to <%p>, got <%p>",
            unsafeBitCast(testObjectA, Int.self), unsafeBitCast(testObjectA, Int.self)))
        failsWithErrorMessage(message) {
            expect(self.testObjectA).toNot(beIdenticalTo(self.testObjectA))
        }
    }

    func testFailsOnNils() {
        let message1 = String(NSString(format: "expected to be identical to <%p>, got nil",
            unsafeBitCast(testObjectA, Int.self)))
        failsWithErrorMessageForNil(message1) {
            expect(nil as BeIdenticalToObjectTester?).to(beIdenticalTo(self.testObjectA))
        }

        let message2 = String(NSString(format: "expected to not be identical to <%p>, got nil",
            unsafeBitCast(testObjectA, Int.self)))
        failsWithErrorMessageForNil(message2) {
            expect(nil as BeIdenticalToObjectTester?).toNot(beIdenticalTo(self.testObjectA))
        }
    }
    
    func testOperators() {
        expect(self.testObjectA) === testObjectA
        expect(self.testObjectA) !== testObjectB
    }

}