refactor: Changes some strings to multiline

Author: NeedleInAJayStack

Tests/GraphQLTests/LanguageTests/LexerTests.swift

@@ -49,7 +49,13 @@ class LexerTests: XCTestCase {
     }
 
     func testSkipsWhitespace() throws {
-        let token = try lexOne("\n\n    foo\n\n")
+        let token = try lexOne("""
+
+
+            foo
+
+
+        """)
 
         let expected = Token(
             kind: .name,
@@ -64,7 +70,10 @@ class LexerTests: XCTestCase {
     }
 
     func testSkipsComments() throws {
-        let token = try lexOne("    #comment\r\n    foo#comment")
+        let token = try lexOne("""
+            #comment\r
+            foo#comment
+        """)
 
         let expected = Token(
             kind: .name,
@@ -94,7 +103,13 @@ class LexerTests: XCTestCase {
     }
 
     func testErrorsRespectWhitespaces() throws {
-        XCTAssertThrowsError(try lexOne("\n\n?\n\n"))
+        XCTAssertThrowsError(try lexOne("""
+
+
+        ?
+
+
+        """))
 //      'Syntax Error GraphQL (3:5) Unexpected character "?".\n' +
 //      '\n' +
 //      '2: \n' +
@@ -218,7 +233,10 @@ class LexerTests: XCTestCase {
         XCTAssertThrowsError(try lexOne("\"null-byte is not \u{0000} end of file\""))
         // "Syntax Error GraphQL (1:19) Invalid character within String: "\\u0000"."
 
-        XCTAssertThrowsError(try lexOne("\"multi\nline\""))
+        XCTAssertThrowsError(try lexOne("""
+        "multi
+        line"
+        """))
         // "Syntax Error GraphQL (1:7) Unterminated string"
 
         XCTAssertThrowsError(try lexOne("\"multi\rline\""))
@@ -700,7 +718,12 @@ class LexerTests: XCTestCase {
     }
 
     func testDoubleLinkedList() throws {
-        let q = "{\n    #comment\n    field\n    }"
+        let q = """
+        {
+            #comment
+            field
+        }
+        """
         let lexer = createLexer(source: Source(body: q))
 
         let startToken = lexer.token
@@ -749,28 +772,83 @@ class LexerTests: XCTestCase {
 
     func testBlockStringIndentAndBlankLine() throws {
         let rawString =
-            "\n\n\n    TopLevel {\n        indented\n        alsoIndented\n    }\n\n\n\t\t\n"
+            """
+
+
+
+                TopLevel {
+                    indented
+                    alsoIndented
+                }
+
+
+            \t\t
+
+            """
         let cleanedString = blockStringValue(rawValue: rawString)
 
-        XCTAssertEqual(cleanedString, "TopLevel {\n    indented\n    alsoIndented\n}")
+        XCTAssertEqual(cleanedString, """
+        TopLevel {
+            indented
+            alsoIndented
+        }
+        """)
     }
 
     func testBlockStringDoubleIndentAndBlankLine() throws {
         let rawString =
-            "\n\n\n    TopLevel {\n        indented: {\n            foo: String\n        }\n        alsoIndented\n    }\n\n\n\t\t\n"
+            """
+
+
+
+                TopLevel {
+                    indented: {
+                        foo: String
+                    }
+                    alsoIndented
+                }
+
+
+            \t\t
+
+            """
         let cleanedString = blockStringValue(rawValue: rawString)
 
         XCTAssertEqual(
             cleanedString,
-            "TopLevel {\n    indented: {\n        foo: String\n    }\n    alsoIndented\n}"
+            """
+            TopLevel {
+                indented: {
+                    foo: String
+                }
+                alsoIndented
+            }
+            """
         )
     }
 
     func testBlockStringIndentAndBlankLineFirstLineNotIndent() throws {
-        let rawString = "\n\n\nTopLevel {\n        indented\n        alsoIndented\n}\n\n\n\t\t\n"
+        let rawString = """
+
+
+
+        TopLevel {
+                indented
+                alsoIndented
+        }
+
+
+        \t\t
+
+        """
         let cleanedString = blockStringValue(rawValue: rawString)
 
-        XCTAssertEqual(cleanedString, "TopLevel {\n        indented\n        alsoIndented\n}")
+        XCTAssertEqual(cleanedString, """
+        TopLevel {
+                indented
+                alsoIndented
+        }
+        """)
     }
 
     func testBlockStringIndentBlankLineFirstLineNotIndentWeird() throws {
@@ -787,21 +865,43 @@ class LexerTests: XCTestCase {
         """
         let cleanedString = blockStringValue(rawValue: rawString)
 
-        XCTAssertEqual(cleanedString, "TopLevel {\n    indented\n    alsoIndented\n}")
+        XCTAssertEqual(cleanedString, """
+        TopLevel {
+            indented
+            alsoIndented
+        }
+        """)
     }
 
     func testBlockStringIndentMultilineWithSingleSpaceIndent() throws {
-        let rawString = " Multi-line string\n With Inner \"foo\" \n should be Valid "
+        let rawString = """
+         Multi-line string
+         With Inner \"foo\"
+         should be Valid
+        """
         let cleanedString = blockStringValue(rawValue: rawString)
 
-        XCTAssertEqual(cleanedString, " Multi-line string\nWith Inner \"foo\" \nshould be Valid ")
+        XCTAssertEqual(cleanedString, """
+         Multi-line string
+        With Inner \"foo\"
+        should be Valid
+        """)
     }
 
     func testBlockStringIndentMultilineWithSingleSpaceIndentExtraLines() throws {
-        let rawString = "\n Multi-line string\n With Inner \"foo\" \n should be Valid \n"
+        let rawString = """
+
+         Multi-line string
+         With Inner \"foo\"
+         should be Valid
+        """
         let cleanedString = blockStringValue(rawValue: rawString)
 
-        XCTAssertEqual(cleanedString, "Multi-line string\nWith Inner \"foo\" \nshould be Valid ")
+        XCTAssertEqual(cleanedString, """
+        Multi-line string
+        With Inner \"foo\"
+        should be Valid
+        """)
     }
 
     // Lexer tests for Blockstring token parsing
@@ -820,7 +920,15 @@ class LexerTests: XCTestCase {
         XCTAssertEqual(
             token,
             expected,
-            "\nexpected: \n \(dump(expected))\n\ngot: \n\(dump(token))\n"
+            """
+
+            expected:
+            \(dump(expected))
+
+            got:
+            \(dump(token))
+
+            """
         )
     }
 
@@ -838,13 +946,25 @@ class LexerTests: XCTestCase {
             end: 61,
             line: 1,
             column: 1,
-            value: "Multi-line string\nWith Inner \"foo\"\nshould be Valid"
+            value: """
+            Multi-line string
+            With Inner \"foo\"
+            should be Valid
+            """
         )
 
         XCTAssertEqual(
             token,
             expected,
-            "\nexpected: \n \(dump(expected))\n\ngot: \n\(dump(token))\n"
+            """
+
+            expected:
+             \(dump(expected))
+
+            got:
+            \(dump(token))
+
+            """
         )
     }
 
@@ -863,10 +983,20 @@ class LexerTests: XCTestCase {
             end: 59,
             line: 1,
             column: 1,
-            value: " Multi-line string\nwith Inner \"foo\"\nshould be valid"
+            value: """
+             Multi-line string
+            with Inner "foo"
+            should be valid
+            """
         )
 
-        XCTAssertEqual(token, expected, "expected: \n \(dump(expected))\ngot: \n\(dump(token))\n")
+        XCTAssertEqual(token, expected, """
+        expected:
+        \(dump(expected))
+        got:
+        \(dump(token))
+
+        """)
     }
 
     func testBlockStringUnescapedReturnsIndentTest() throws {
@@ -885,10 +1015,21 @@ class LexerTests: XCTestCase {
             end: 79,
             line: 1,
             column: 1,
-            value: "Multi-line string {\n    with Inner \"foo\"\n    should be valid indented\n}"
+            value: """
+            Multi-line string {
+                with Inner \"foo\"
+                should be valid indented
+            }
+            """
         )
 
-        XCTAssertEqual(token, expected, "expected: \n \(dump(expected))\ngot: \n\(dump(token))\n")
+        XCTAssertEqual(token, expected, """
+         expected:
+             \(dump(expected))
+            got:
+            \(dump(token))
+
+        """)
     }
 
     func testIndentedBlockStringWithIndents() throws {
@@ -910,26 +1051,47 @@ class LexerTests: XCTestCase {
             end: 103,
             line: 1,
             column: 5,
-            value: "Multi-line string {\n    with Inner \"foo\"\n    should be valid indented\n}"
+            value: """
+            Multi-line string {
+                with Inner \"foo\"
+                should be valid indented
+            }
+            """
         )
 
         print(sourceStr)
 
-        XCTAssertEqual(token, expected, "expected: \n \(dump(expected))\ngot: \n\(dump(token))\n")
+        XCTAssertEqual(token, expected, """
+        expected:
+        \(dump(expected))
+        got:
+        \(dump(token))
+
+        """)
     }
 
     // Test empty strings & multi-line string lexer token parsing
 
     func testEmptyQuote() throws {
         let token = try lexOne(#" "" "#)
         let expected = Token(kind: .string, start: 1, end: 3, line: 1, column: 2, value: "")
-        XCTAssertEqual(token, expected, "\n\(dump(expected))\n\(dump(token))\n")
+        XCTAssertEqual(token, expected, """
+
+        \(dump(expected))
+        \(dump(token))
+
+        """)
     }
 
     func testEmptySimpleBlockString() throws {
         let token = try lexOne(#" """""" "#)
         let expected = Token(kind: .blockstring, start: 1, end: 7, line: 1, column: 2, value: "")
-        XCTAssertEqual(token, expected, "\n\(dump(expected))\n\(dump(token))\n")
+        XCTAssertEqual(token, expected, """
+
+        \(dump(expected))
+        \(dump(token))
+
+        """)
     }
 
     func testEmptyTrimmedCharactersBlockString() throws {
@@ -938,7 +1100,12 @@ class LexerTests: XCTestCase {
         """
         """#)
         let expected = Token(kind: .blockstring, start: 0, end: 7, line: 1, column: 1, value: "")
-        XCTAssertEqual(token, expected, "\n\(dump(expected))\n\(dump(token))\n")
+        XCTAssertEqual(token, expected, """
+
+        \(dump(expected))
+        \(dump(token))
+
+        """)
     }
 
     func testEscapedTripleQuoteInBlockString() throws {
@@ -955,6 +1122,11 @@ class LexerTests: XCTestCase {
             column: 1,
             value: "\"\"\""
         )
-        XCTAssertEqual(token, expected, "\n\(dump(expected))\n\(dump(token))\n")
+        XCTAssertEqual(token, expected, """
+
+        \(dump(expected))
+        \(dump(token))
+
+        """)
     }
 }

Tests/GraphQLTests/LanguageTests/ParserTests.swift

@@ -12,9 +12,13 @@ class ParserTests: XCTestCase {
 
             XCTAssertEqual(
                 error.message,
-                "Syntax Error GraphQL (1:2) Expected Name, found <EOF>\n\n" +
-                    " 1: {\n" +
-                    "     ^\n"
+                """
+                Syntax Error GraphQL (1:2) Expected Name, found <EOF>
+
+                 1: {
+                     ^
+
+                """
             )
 
             XCTAssertEqual(error.positions, [1])