         let strParser = StringParser.string(str)
         
         let empty = LanguageDefinition<()>.empty
-        let simpleWhiteSpace = GenericTokenParser(languageDefinition: empty).whiteSpace
+        let simpleWhiteSpace =
+            GenericTokenParser(languageDefinition: empty).whiteSpace
         
         let removeWhiteSpace = simpleWhiteSpace *> strParser
         
         let java = LanguageDefinition<()>.javaStyle
-        let javaWhiteSpace = GenericTokenParser(languageDefinition: java).whiteSpace
+        let javaWhiteSpace =
+            GenericTokenParser(languageDefinition: java).whiteSpace
         
         let removeJavaWhiteSpace = javaWhiteSpace *> strParser
         
         // Test for success.
         let matchingParsers = [removeWhiteSpace, removeJavaWhiteSpace]
-        let matching = [[" " + str, "\t" + str, "\n" + str, "\r" + str, "\r\n" + str, "\u{000B}" + str, "\u{000C}" + str], ["/*\nMulti line\n*/" + str, "// One line\n" + str, "/*/* Nested */*/" + str]]
+        let matching = [
+            [
+                " " + str, "\t" + str, "\n" + str, "\r" + str, "\r\n" + str,
+                "\u{000B}" + str, "\u{000C}" + str
+            ],
+            [
+                "/*\nMulti line\n*/" + str, "// One line\n" + str,
+                "/*/* Nested */*/" + str
+            ]
+        ]
+        
         let errorMessage = "GenericTokenParser.whiteSpace did not succeed."
         
         for (parser, input) in zip(matchingParsers, matching) {
             
             testStringParserSuccess(parser, inputs: input) { input, result in
                 
-                XCTAssertEqual(str, result, self.formatErrorMessage(errorMessage, input: input, result: result))
+                XCTAssertEqual(
+                    str,
+                    result,
+                    self.formatErrorMessage(
+                        errorMessage,
+                        input: input,
+                        result: result
+                    )
+                )
                 
             }
             

    func testLegalOperator() {
        
        let swift = LanguageDefinition<()>.swift
        let legalOperator = GenericTokenParser(languageDefinition: swift).legalOperator
        
        // Test for success.
        let matching = ["/>", "=>", "-<", "+", "!>", "*", "%>", "<>", "><", "&>", "|>", "^>", "?>", "~>"]
        let errorMessage = "GenericTokenParser.legalOperator did not succeed."
        
        testStringParserSuccess(legalOperator, inputs: matching) {input, result in
            
            XCTAssertEqual(input, result, self.formatErrorMessage(errorMessage, input: input, result: result))
            
        }
        
        // Test when not matching.
        let notMatching = swift.reservedOperators
        let shouldFailMessage = "GenericTokenParser.legalOperator should have failed."
        
        testStringParserFailure(legalOperator, inputs: notMatching) { input, result in
            
            XCTFail(self.formatErrorMessage(shouldFailMessage, input: input, result: result))
            
        }
        

            
            testStringParserSuccess(parser, inputs: [match]) { input, result in
                
                XCTAssertEqual(
                    input,
                    result,
                    self.formatErrorMessage(
                        errorMessage,
                        input: input,
                        result: result
                    )
                )
                
            }
            
