                 "name"
         ]
 
-        let path = JsonPath(components: components)
-
-        XCTAssertEqual(path.components, components,
-                "Path components must be equal to the source components."
-        )
-
-        XCTAssertEqual(path.description, components.joined(separator: JsonPath.separator),
-                "Path description must be equal to the source components joined by `JsonPath.separator`."
-        )
+        XCTAssertEqual(JsonPath(components: components).components, components)
     }
 
     /// Tests `appending(_:)`.
-    public func testAppending() {
+    func testAppending() {
         let lhs = JsonPath(string: "response.items.0")
         let rhs = JsonPath(string: "name")
 
-        let path = lhs.appending(rhs)
-
-        XCTAssertEqual(path.components, lhs.components + rhs.components,
-                "Path components must be equal to concatenated components of the source paths."
-        )
-
-        XCTAssertEqual(path.description, [lhs.description, rhs.description].joined(separator: JsonPath.separator),
-                "Path description must be equal to the source descriptions joined by `JsonPath.separator`."
-        )
+        XCTAssertEqual(lhs.appending(rhs).components, lhs.components + rhs.components)
     }
 
     /// Tests `subpath(to:)`.
-    public func testSubpath() {
+    func testSubpath() {
         let components = [
                 "response",
                 "items",

                "name"
        ]

        let path = JsonPath(components: components)

        for index in 0..<components.count + 1 {
            let subpath = path.subpath(to: index)

            XCTAssertEqual(subpath.components, Array(path.components.prefix(index)),
                    "Subpath components must be equal to prefixed path components by the given index."
            )
        }
    }

    /// Tests `==(lhs:rhs:)`.
    public func testEquals() {
        let components = [
                "response",
                "items",

                "name"
        ]

        let string = components.joined(separator: JsonPath.separator)

        XCTAssert(JsonPath(components: components) == JsonPath(string: string))
    }

    /// Tests `description`.
    func testDescription() {
        XCTAssertEqual(JsonPath().description, "")

        let components = [
                "response",
                "items",
                "42",
                "name"
        ]

        XCTAssertEqual(JsonPath(components: components).description, components.joined(separator: JsonPath.separator))

        let string = "response.items.42.name"

        XCTAssertEqual(JsonPath(string: string).description, string)

        let index = 42

        XCTAssertEqual(JsonPath(index: index).description, String(index))
    }

    /// Tests `init(stringLiteral:)`.
    func testInitStringLiteral() {
        XCTAssertEqual("response.items.42.name", JsonPath(string: "response.items.42.name"))
    }

    /// Tests `init(extendedGraphemeClusterLiteral:)`.
    func testInitExtendedGraphemeClusterLiteral() {
        let string = "response.items.42.name"

        XCTAssertEqual(JsonPath(extendedGraphemeClusterLiteral: string), JsonPath(string: string))
    }

    /// Tests `init(unicodeScalarLiteral:)`.
    func testInitUnicodeScalarLiteral() {
        let string = "response.items.42.name"

        XCTAssertEqual(JsonPath(unicodeScalarLiteral: string), JsonPath(string: string))
    }

    /// Tests `init(integerLiteral:)`.
    func testInitIntegerLiteral() {
        XCTAssertEqual(42, JsonPath(index: 42))
    }

    /// Tests `init(arrayLiteral:)`.
    func testInitArrayLiteral() {
        XCTAssertEqual(["response", "items", "42", "name"], JsonPath(components: ["response", "items", "42", "name"]))
    }
}
