         let hexadecimal = GenericTokenParser<()>.hexadecimal
         
         // Test for success.
-        let matching = ["x1f", "x2F", "x3ffff", "x4FFFF", "xABCDEF", "X12345", "X67890"]
-        let expected = [0x1f, 0x2F, 0x3ffff, 0x4FFFF, 0xABCDEF, 0x12345, 0x67890]
+        let matching = [
+            "x1f", "x2F", "x3ffff", "x4FFFF", "xABCDEF", "X12345", "X67890"
+        ]
+        let expected = [
+            0x1f, 0x2F, 0x3ffff, 0x4FFFF, 0xABCDEF, 0x12345, 0x67890
+        ]
         var index = 0
         
         let errorMessage = "GenericTokenParser.hexadecimal did not succeed."
         
-        testStringParserSuccess(hexadecimal, inputs: matching) { input, result in
+        testStringParserSuccess(hexadecimal, inputs: matching)
+        { input, result in
             
             defer { index += 1 }
-            XCTAssertEqual(expected[index], result, self.formatErrorMessage(errorMessage, input: input, result: result))
-            
-        }
-        
-        // Test when not matching.
-        let notMatching = ["1", "1234", "001234", "-1", "-1234", "-0xf", "+0xF", "-0xffff", "+0xFFFF", "-0o1", "-0o1234", "xFFFFFFFFFFFFFFFFFFFFFFFFFF"]
-        let shouldFailMessage = "GenericTokenParser.hexadecimal should have failed."
-        
-        testStringParserFailure(hexadecimal, inputs: notMatching) { input, result in
-            
-            XCTFail(self.formatErrorMessage(shouldFailMessage, input: input, result: result))
+            XCTAssertEqual(
+                expected[index],
+                result,
+                self.formatErrorMessage(
+                    errorMessage,
+                    input: input,
+                    result: result
+                )
+            )
+            
+        }
+        
+        // Test when not matching.
+        let notMatching = [
+            "1", "1234", "001234", "-1", "-1234", "-0xf", "+0xF", "-0xffff",
+            "+0xFFFF", "-0o1", "-0o1234", "xFFFFFFFFFFFFFFFFFFFFFFFFFF"
+        ]
+        let shouldFailMessage =
+            "GenericTokenParser.hexadecimal should have failed."
+        
+        testStringParserFailure(hexadecimal, inputs: notMatching)
+        { input, result in
+            
+            XCTFail(
+                self.formatErrorMessage(
+                    shouldFailMessage,
+                    input: input,
+                    result: result
+                )
+            )
             
         }
         

        var emptyCommentLine = LanguageDefinition<()>.empty
        emptyCommentLine.commentStart = "/*"
        emptyCommentLine.commentEnd   = "*/"
        let emptyCommentLineWhiteSpace = GenericTokenParser(languageDefinition: emptyCommentLine).whiteSpace
        
        let removeCommentLine = emptyCommentLineWhiteSpace *> strParser
        
        var emptyMultiLine = LanguageDefinition<()>.empty
        emptyMultiLine.commentLine = "//"
        let emptyMultiLineWhiteSpace = GenericTokenParser(languageDefinition: emptyMultiLine).whiteSpace
        
        let removeMultiLine = emptyMultiLineWhiteSpace *> strParser
        
        var nonNested = LanguageDefinition<()>.javaStyle
        nonNested.allowNestedComments = false
        let nonNestedWhiteSpace = GenericTokenParser(languageDefinition: nonNested).whiteSpace
        
        let removeNonNested = nonNestedWhiteSpace *> strParser
        
        let notMatchingParsers = [removeWhiteSpace, removeJavaWhiteSpace, removeCommentLine, removeMultiLine, removeNonNested]
        let notMatching = [["/*\nMulti line\n*/" + str, "// One line\n" + str, "/*/* Nested */*/" + str], ["/*/* adsf */" + str], ["// Line comment\n" + str], ["/* Multi line */" + str], ["/*/* Nested */*/" + str]]
        let shouldFailMessage = "GenericTokenParser.whiteSpace should have failed."
        
        for (parser, input) in zip(notMatchingParsers, notMatching) {
            
            testStringParserFailure(parser, inputs: input) { input, result in
                
                XCTFail(self.formatErrorMessage(shouldFailMessage, input: input, result: result))
                
            }
            

        let names = ["if", "let", "var", "case"]
        let symbols = names.map { symbol($0) }
        
        let matching = ["if\n\t\r ", "let/* adsfadsfadsfadsf // */",
                        "var// adsfadsfadsf",
                        "case\u{000B}\u{000C}/*/* adsf*/*/"
        ]
        var index = 0
        
        let errorMessage = "GenericTokenParser.symbol did not succeed."
