     ///
     func testStrikeStyleEffectivelyMapsIntoItsTreeRepresentation() {
         let attributes = StrikethroughFormatter().apply(to: Constants.sampleAttributes)
-        let string = NSAttributedString(string: "Strike!", attributes: attributes)
-
-        // Convert + Verify
-        let node = rootNode(from: string)
+        let testingString = NSAttributedString(string: "Strike!", attributes: attributes)
+
+        // Convert + Verify
+        let node = rootNode(from: testingString)
         XCTAssert(node.children.count == 1)
 
         let strike = node.children.first as? ElementNode

    ///
    private struct Constants {
        static let sampleAttributes: [String : Any] = [
            NSFontAttributeName: UIFont.systemFont(ofSize: UIFont.systemFontSize)
        ]
    }


    }


    ///
    ///
    func testCommentsArePreservedAndSerializedBack() {
        let attachment = CommentAttachment()
        attachment.text = "I'm a comment. YEAH!"
        let stringWithAttachment = NSAttributedString(attachment: attachment)

        let text = "Payload here"
        let testingString = NSMutableAttributedString(string: text)
        testingString.insert(stringWithAttachment, at: 0)
        testingString.append(stringWithAttachment)

        // Convert + Verify
        let node = rootNode(from: testingString)
        XCTAssert(node.children.count == 3)

        guard let headNode = node.children[0] as? CommentNode,
            let textNode = node.children[1] as? TextNode,
            let tailNode = node.children[2] as? CommentNode
        else {
            XCTFail()
            return
        }

        XCTAssertEqual(headNode.comment, attachment.text)
        XCTAssertEqual(tailNode.comment, attachment.text)
        XCTAssertEqual(textNode.contents, text)
    }


    ///
    ///
    func testLineElementGetsProperlySerialiedBackIntoItsHtmlRepresentation() {
        let attachment = LineAttachment()

        let stringWithAttachment = NSAttributedString(attachment: attachment)
        let stringWithText = NSAttributedString(string: "I'm a text line")

        let testingString = NSMutableAttributedString()

        testingString.append(stringWithAttachment)
        testingString.append(stringWithText)
        testingString.append(stringWithAttachment)
        testingString.append(stringWithText)
        testingString.append(stringWithAttachment)

        // Convert + Verify
        let node = rootNode(from: testingString)
        XCTAssert(node.children.count == 5)

        guard let firstLine = node.children[0] as? ElementNode,
            let firstText = node.children[1] as? TextNode,
            let secondLine = node.children[2] as? ElementNode,
            let secondText = node.children[3] as? TextNode,
            let thirdLine = node.children[4] as? ElementNode
        else {
            XCTFail()
            return
        }

        XCTAssertEqual(firstLine.name, "hr")
        XCTAssertEqual(secondLine.name, "hr")
        XCTAssertEqual(thirdLine.name, "hr")
        XCTAssertEqual(firstText.contents, stringWithText.string)
        XCTAssertEqual(secondText.contents, stringWithText.string)
    }


    ///
    ///
    func testHeaderElementGetsProperlySerialiedBackIntoItsHtmlRepresentation() {

        let levels: [HeaderFormatter.HeaderType] = [.h1, .h2, .h3, .h4, .h5, .h6]

        for level in levels {
            let formatter = HeaderFormatter(headerLevel: level, placeholderAttributes: [:])

            let headingStyle = formatter.apply(to: Constants.sampleAttributes)
            let headingText = NSAttributedString(string: "Aztec Rocks\n", attributes: headingStyle)
            let regularText = NSAttributedString(string: "Newline?", attributes: Constants.sampleAttributes)

            let testingString = NSMutableAttributedString()
            testingString.append(headingText)
            testingString.append(regularText)

            // Convert + Verify
            let node = rootNode(from: testingString)
            XCTAssert(node.children.count == 2)

            guard let headerNode = node.children[0] as? ElementNode,
                let headerTextNode = headerNode.children[0] as? TextNode,
                let regularTextNode = node.children[1] as? TextNode
            else {
                XCTFail()
                return
            }

            XCTAssertEqual(headerNode.name, "h\(level.rawValue)")
            XCTAssertEqual(headerTextNode.contents, "Aztec Rocks")
            XCTAssertEqual(regularTextNode.contents, "Newline?")
        }
    }


    ///
    ///
    func testUnknownHtmlDoesNotGetNuked() {
        let htmlAttachment = HTMLAttachment()
        htmlAttachment.rawHTML = "<table><tr><td>ROW ROW</td></tr></table>"

        let commentAttachment = CommentAttachment()
        commentAttachment.text = "Tail Comment"

        let htmlString = NSAttributedString(attachment: htmlAttachment)
        let textString = NSAttributedString(string: "Some Text here?")
        let commentString = NSAttributedString(attachment: commentAttachment)

        let testingString = NSMutableAttributedString()
        testingString.append(htmlString)
        testingString.append(textString)
        testingString.append(commentString)

        // Convert + Verify
        let node = rootNode(from: testingString)
        XCTAssert(node.children.count == 3)

        guard let htmlNode = node.children[0] as? ElementNode,
            let textNode = node.children[1] as? TextNode,
            let commentNode = node.children[2] as? CommentNode
        else {
            XCTFail()
            return
        }

        let reconvertedHTML = Libxml2.Out.HTMLConverter().convert(htmlNode)

        XCTAssertEqual(reconvertedHTML, htmlAttachment.rawHTML)
        XCTAssertEqual(textNode.contents, textString.string)
        XCTAssertEqual(commentNode.comment, commentAttachment.text)
    }


//    ///
//    ///
//    func testContiguousUnorderedListsGetHeirItemsmerged() {
//        let input = "<ul><li>First Line</li></ul><ul><li>Second Line</li></ul>"
//        let expected = "<ul><li>First Line</li><li>Second Line</li></ul>"
//
//        let generated = generatedHTML(input: input)
//        XCTAssertEqual(generated, expected)
