diff --git a/SLS_C/tests/lexer_tests.c b/SLS_C/tests/lexer_tests.c
index e54e02c..c2157bd 100644
--- a/SLS_C/tests/lexer_tests.c
+++ b/SLS_C/tests/lexer_tests.c
@@ -41,11 +41,7 @@ static void clean_up_test(LexerResult result) {
         clean_token_result(result.result);
 }
 
-static TestResult logic_fail_test(
-    LexerTest *test,
-    LexerResult result,
-    const char *message
-) {
+static TestResult logic_fail_test(LexerTest *test, LexerResult result, const char *message) {
     if (message == 0) return error_test(test, result, (SlsError) {
         .message = "Out of Memory Error!", .code = 3458, });
     clean_up_test(result);
@@ -54,22 +50,14 @@ static TestResult logic_fail_test(
     return test->result;
 }
 
-static TestResult error_fail_test(
-    LexerTest *test,
-    LexerResult result,
-    SlsError error
-) {
+static TestResult error_fail_test(LexerTest *test, LexerResult result, SlsError error) {
     clean_up_test(result);
     test->result.status = TEST_ERROR_FAIL;
     test->result.error = error;
     return test->result;
 }
 
-static TestResult error_test(
-    LexerTest *test,
-    LexerResult result,
-    SlsError error
-) {
+static TestResult error_test(LexerTest *test, LexerResult result, SlsError error) {
     clean_up_test(result);
     test->result.status = TEST_ERROR;
     test->result.error = error;
@@ -94,12 +82,7 @@ static char *unexpected_end_of_token_stream(size_t i) {
     size_t length = ceil(log10(i)) + 47;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Unexpected end of token stream (%d tokens found)",
-        i - 1
-    );
+    snprintf(string, length, "Unexpected end of token stream (%d tokens found)", i-1);
     return string;
 }
 
@@ -107,96 +90,39 @@ static char *expected_end_of_token_stream(size_t i) {
     size_t length = ceil(log10(i)) + 47;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Expected end of token stream (more than %d tokens found)",
-        i - 1
-    );
+    snprintf(string, length, "Expected end of token stream (more than %d tokens found)", i-1);
     return string;
 }
 
 static char *token_should_be(size_t i, TokenType should, TokenType found) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        strnlen(TOKEN_TYPES_NAMES[should], TYPE_NAMES_SAFE_LENGTH) +
-        strnlen(TOKEN_TYPES_NAMES[found], TYPE_NAMES_SAFE_LENGTH) +
-        35;
+    size_t length = ceil(log10(i + 1)) + strnlen(TOKEN_TYPES_NAMES[should], TYPE_NAMES_SAFE_LENGTH) + strnlen(TOKEN_TYPES_NAMES[found], TYPE_NAMES_SAFE_LENGTH) + 35;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d should be a %s, but found a %s",
-        i,
-        TOKEN_TYPES_NAMES[should],
-        TOKEN_TYPES_NAMES[found]
-    );
+    snprintf(string, length, "Token #%d should be a %s, but found a %s", i, TOKEN_TYPES_NAMES[should], TOKEN_TYPES_NAMES[found]);
     return string;
 }
 
-static char *integer_type_should_be(
-    size_t i,
-    TokenType should,
-    TokenType found
-) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        strnlen(INTEGER_TYPES_NAMES[should], 5) +
-        strnlen(INTEGER_TYPES_NAMES[found], 5) +
-        48;
+static char *integer_type_should_be(size_t i, TokenType should, TokenType found) {
+    size_t length = ceil(log10(i + 1)) + strnlen(INTEGER_TYPES_NAMES[should], 5) + strnlen(INTEGER_TYPES_NAMES[found], 5) + 48;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d integer type should be a %s, but found a %s",
-        i,
-        TOKEN_TYPES_NAMES[should],
-        TOKEN_TYPES_NAMES[found]
-    );
+    snprintf(string, length, "Token #%d integer type should be a %s, but found a %s", i, TOKEN_TYPES_NAMES[should], TOKEN_TYPES_NAMES[found]);
     return string;
 }
 
-static char *integer_value_should_be(
-    size_t i,
-    uint64_t should,
-    uint64_t found
-) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        ceil(log10(should + 1)) +
-        ceil(log10(found + 1)) +
-        45;
+static char *integer_value_should_be(size_t i, uint64_t should, uint64_t found) {
+    size_t length = ceil(log10(i + 1)) + ceil(log10(should + 1)) + ceil(log10(found + 1)) + 45;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d integer value should be %d, but found %d",
-        i,
-        should,
-        found
-    );
+    snprintf(string, length, "Token #%d integer value should be %d, but found %d", i, should, found);
     return string;
 }
 
 static char *float_value_should_be(size_t i, double should, double found) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        ceil(log10(should + 1) + 3) +
-        ceil(log10(found + 1) + 3) +
-        43;
+    size_t length = ceil(log10(i + 1)) + ceil(log10(should + 1) + 3) + ceil(log10(found + 1) + 3) + 43;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d float value should be %.2f, but found %.2f",
-        i,
-        should,
-        found
-    );
+    snprintf(string, length, "Token #%d float value should be %.2f, but found %.2f", i, should, found);
     return string;
 }
 
@@ -204,12 +130,7 @@ static char *identifier_should_be_literal(size_t i) {
     size_t length = ceil(log10(i + 1)) + 51;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d identifier should be an identifier literal",
-        i
-    );
+    snprintf(string, length, "Token #%d identifier should be an identifier literal", i);
     return string;
 }
 
@@ -217,65 +138,23 @@ static char *identifier_should_not_be_literal(size_t i) {
     size_t length = ceil(log10(i + 1)) + 55;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d identifier should not be an identifier literal",
-        i
-    );
+    snprintf(string, length, "Token #%d identifier should not be an identifier literal", i);
     return string;
 }
 
-static char *token_length_should_be(
-    size_t i,
-    TokenType type,
-    uint64_t should,
-    uint64_t found
-) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        strnlen(TOKEN_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) +
-        ceil(log10(should + 1)) +
-        ceil(log10(found + 1)) +
-        47;
+static char *token_length_should_be(size_t i, TokenType type, uint64_t should, uint64_t found) {
+    size_t length = ceil(log10(i + 1)) + strnlen(TOKEN_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) + ceil(log10(should + 1)) + ceil(log10(found + 1)) + 47;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d of type %s length should be %d, but found %d",
-        i,
-        TOKEN_TYPES_NAMES[type],
-        should,
-        found
-    );
+    snprintf(string, length, "Token #%d of type %s length should be %d, but found %d", i, TOKEN_TYPES_NAMES[type], should, found);
     return string;
 }
 
-static char *token_value_string_should_be(
-    size_t i,
-    TokenType type,
-    size_t value_length,
-    const char *should,
-    const char *found
-) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        strnlen(TOKEN_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) +
-        strnlen(should, value_length) +
-        strnlen(found, value_length) +
-        53;
+static char *token_value_string_should_be(size_t i, TokenType type, size_t value_length, const char *should, const char *found) {
+    size_t length = ceil(log10(i + 1)) + strnlen(TOKEN_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) + strnlen(should, value_length) + strnlen(found, value_length) + 53;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d of type %s string value should be %s, but found %s",
-        i,
-        TOKEN_TYPES_NAMES[type],
-        should,
-        found
-    );
+    snprintf(string, length, "Token #%d of type %s string value should be %s, but found %s", i, TOKEN_TYPES_NAMES[type], should, found);
     return string;
 }
 
@@ -283,300 +162,96 @@ static char *boolean_should_be(size_t i, Boolean value) {
     size_t length = ceil(log10(i + 1)) + 45;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    if (value)
-        snprintf(
-            string,
-            length,
-            "Token #%d boolean should be true, but is false",
-            i
-        );
-    else
-        snprintf(
-            string,
-            length,
-            "Token #%d boolean should be false, but is true",
-            i
-        );
+    if (value) snprintf(string, length, "Token #%d boolean should be true, but is false", i);
+    else snprintf(string, length, "Token #%d boolean should be false, but is true", i);
     return string;
 }
 
 static char *array_type_should_be(size_t i, ArrayType should, ArrayType found) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        strnlen(ARRAY_TYPES_NAMES[should], TYPE_NAMES_SAFE_LENGTH) +
-        strnlen(ARRAY_TYPES_NAMES[found], TYPE_NAMES_SAFE_LENGTH) +
-        35;
+    size_t length = ceil(log10(i + 1)) + strnlen(ARRAY_TYPES_NAMES[should], TYPE_NAMES_SAFE_LENGTH) + strnlen(ARRAY_TYPES_NAMES[found], TYPE_NAMES_SAFE_LENGTH) + 35;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d should be a %s, but found a %s",
-        i,
-        ARRAY_TYPES_NAMES[should],
-        ARRAY_TYPES_NAMES[found]
-    );
+    snprintf(string, length, "Token #%d should be a %s, but found a %s", i, ARRAY_TYPES_NAMES[should], ARRAY_TYPES_NAMES[found]);
     return string;
 }
 
 static char *array_dimensions_should_be(size_t i, size_t should, size_t found) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        ceil(log10(should + 1)) +
-        ceil(log10(found + 1)) +
-        48;
+    size_t length = ceil(log10(i + 1)) + ceil(log10(should + 1)) + ceil(log10(found + 1)) + 48;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d array dimensions should be %s, but found %s",
-        i,
-        should,
-        found
-    );
+    snprintf(string, length, "Token #%d array dimensions should be %s, but found %s", i, should, found);
     return string;
 }
 
-static char *array_element_shape_should_be(
-    size_t i,
-    size_t j,
-    ArrayType type,
-    uint64_t should,
-    uint64_t found
-) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        ceil(log10(j + 1)) +
-        strnlen(ARRAY_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) +
-        ceil(log10(should + 1) + 3) +
-        ceil(log10(found + 1) + 3) +
-        63;
+static char *array_element_shape_should_be(size_t i, size_t j, ArrayType type, uint64_t should, uint64_t found) {
+    size_t length = ceil(log10(i + 1)) + ceil(log10(j + 1)) + strnlen(ARRAY_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) + ceil(log10(should + 1) + 3) + ceil(log10(found + 1) + 3) + 63;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d dimension %d of array type %s should be shape %d, but found %d",
-        i,
-        j,
-        TOKEN_TYPES_NAMES[type],
-        should,
-        found
-    );
+    snprintf(string, length, "Token #%d dimension %d of array type %s should be shape %d, but found %d", i, j, TOKEN_TYPES_NAMES[type], should, found);
     return string;
 }
 
-static char *array_element_integer_should_be(
-    size_t i,
-    size_t j,
-    ArrayType type,
-    uint64_t should,
-    uint64_t found
-) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        ceil(log10(j + 1)) +
-        strnlen(ARRAY_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) +
-        ceil(log10(should + 1) + 3) +
-        ceil(log10(found + 1) + 3) +
-        55;
+static char *array_element_integer_should_be(size_t i, size_t j, ArrayType type, uint64_t should, uint64_t found) {
+    size_t length = ceil(log10(i + 1)) + ceil(log10(j + 1)) + strnlen(ARRAY_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) + ceil(log10(should + 1) + 3) + ceil(log10(found + 1) + 3) + 55;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d element %d of array type %s should be %d, but found %d",
-        i,
-        j,
-        TOKEN_TYPES_NAMES[type],
-        should,
-        found
-    );
+    snprintf(string, length, "Token #%d element %d of array type %s should be %d, but found %d", i, j, TOKEN_TYPES_NAMES[type], should, found);
     return string;
 }
 
-static char *array_element_float_should_be(
-    size_t i,
-    size_t j,
-    ArrayType type,
-    double should,
-    double found
-) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        ceil(log10(j + 1)) +
-        strnlen(ARRAY_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) +
-        ceil(log10(should + 1)) +
-        ceil(log10(found + 1)) +
-        55;
+static char *array_element_float_should_be(size_t i, size_t j, ArrayType type, double should, double found) {
+    size_t length = ceil(log10(i + 1)) + ceil(log10(j + 1)) + strnlen(ARRAY_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) + ceil(log10(should + 1)) + ceil(log10(found + 1)) + 55;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d element %d of array type %s should be %.2f, but found %.2f",
-        i,
-        j,
-        TOKEN_TYPES_NAMES[type],
-        should,
-        found
-    );
+    snprintf(string, length, "Token #%d element %d of array type %s should be %.2f, but found %.2f", i, j, TOKEN_TYPES_NAMES[type], should, found);
     return string;
 }
 
-static char *array_element_string_should_be(
-    size_t i,
-    size_t j,
-    ArrayType type,
-    size_t value_length,
-    const char *should,
-    const char *found
-) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        ceil(log10(j + 1)) +
-        strnlen(ARRAY_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) +
-        strnlen(should, value_length) +
-        strnlen(found, value_length) +
-        55;
+static char *array_element_string_should_be(size_t i, size_t j, ArrayType type, size_t value_length, const char *should, const char *found) {
+    size_t length = ceil(log10(i + 1)) + ceil(log10(j + 1)) + strnlen(ARRAY_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) + strnlen(should, value_length) + strnlen(found, value_length) + 55;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d element %d of array type %s should be %s, but found %s",
-        i,
-        j,
-        TOKEN_TYPES_NAMES[type],
-        should,
-        found
-    );
+    snprintf(string, length, "Token #%d element %d of array type %s should be %s, but found %s", i, j, TOKEN_TYPES_NAMES[type], should, found);
     return string;
 }
 
-static char *array_element_boolean_should_be(
-    size_t i,
-    size_t j,
-    ArrayType type,
-    Boolean value
-) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        ceil(log10(j + 1)) +
-        strnlen(ARRAY_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) +
-        64;
+static char *array_element_boolean_should_be(size_t i, size_t j, ArrayType type, Boolean value) {
+    size_t length = ceil(log10(i + 1)) + ceil(log10(j + 1)) + strnlen(ARRAY_TYPES_NAMES[type], TYPE_NAMES_SAFE_LENGTH) + 64;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    if (value)
-        snprintf(
-            string,
-            length,
-            "Token #%d element %d of array type %s should be true, but found false",
-            i,
-            j,
-            TOKEN_TYPES_NAMES[type]
-        );
-    else
-        snprintf(
-            string,
-            length,
-            "Token #%d element %d of array type %s should be false, but found true",
-            i,
-            j,
-            TOKEN_TYPES_NAMES[type]
-        );
+    if (value) snprintf(string, length, "Token #%d element %d of array type %s should be true, but found false", i, j, TOKEN_TYPES_NAMES[type]);
+    else snprintf(string, length, "Token #%d element %d of array type %s should be false, but found true", i, j, TOKEN_TYPES_NAMES[type]);
     return string;
 }
 
-static char *type_tuple_element_integer_should_be(
-    size_t i,
-    size_t j,
-    uint64_t should,
-    uint64_t found
-) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        ceil(log10(j + 1)) +
-        ceil(log10(should + 1) + 3) +
-        ceil(log10(found + 1) + 3) +
-        54;
+static char *type_tuple_element_integer_should_be(size_t i, size_t j, uint64_t should, uint64_t found) {
+    size_t length = ceil(log10(i + 1)) + ceil(log10(j + 1)) + ceil(log10(should + 1) + 3) + ceil(log10(found + 1) + 3) + 54;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d element %d of type tuple should be %d, but found %d",
-        i,
-        j,
-        should,
-        found
-    );
+    snprintf(string, length, "Token #%d element %d of type tuple should be %d, but found %d", i, j, should, found);
     return string;
 }
 
-static char *type_tuple_element_string_should_be(
-    size_t i,
-    size_t j,
-    size_t value_length,
-    const char *should,
-    const char *found
-) {
-    size_t length =
-        ceil(log10(i + 1)) +
-        ceil(log10(j + 1)) +
-        strnlen(should, value_length) +
-        strnlen(found, value_length) +
-        54;
+static char *type_tuple_element_string_should_be(size_t i, size_t j, size_t value_length, const char *should, const char *found) {
+    size_t length = ceil(log10(i + 1)) + ceil(log10(j + 1)) + strnlen(should, value_length) + strnlen(found, value_length) + 54;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    snprintf(
-        string,
-        length,
-        "Token #%d element %d of type tuple should be %s, but found %s",
-        i,
-        j,
-        should,
-        found
-    );
+    snprintf(string, length, "Token #%d element %d of type tuple should be %s, but found %s", i, j, should, found);
     return string;
 }
 
-static char *type_tuple_element_boolean_should_be(
-    size_t i,
-    size_t j,
-    Boolean value
-) {
+static char *type_tuple_element_boolean_should_be(size_t i, size_t j, Boolean value) {
     size_t length = ceil(log10(i + 1)) + ceil(log10(j + 1)) + 63;
     char *string = malloc(sizeof(char) * length);
     if (string = 0) return string;
-    if (value)
-        snprintf(
-            string,
-            length,
-            "Token #%d element %d of type tuple should be true, but found false",
-            i,
-            j
-        );
-    else
-        snprintf(
-            string,
-            length,
-            "Token #%d element %d of type tuple should be false, but found true",
-            i,
-            j
-        );
+    if (value) snprintf(string, length, "Token #%d element %d of type tuple should be true, but found false", i, j);
+    else snprintf(string, length, "Token #%d element %d of type tuple should be false, but found true", i, j);
     return string;
 }
 
 // Test parts
 
-static Boolean test_token_type(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    TokenType token_type
-) {
+static Boolean test_token_type(LexerTest *test, LexerResult result, size_t i, TokenType token_type) {
     LexerTokenResult *head = get_token(result.result, i);
     if (head == 0) {
         logic_fail_test(test, result, unexpected_end_of_token_stream(i + 1));
@@ -585,11 +260,7 @@ static Boolean test_token_type(
         error_fail_test(test, result, result.error);
         return TRUE;
     } if (head->result.type != token_type) {
-        logic_fail_test(
-            test,
-            result,
-            token_should_be(i + 1, token_type, head->result.type)
-        );
+        logic_fail_test(test, result, token_should_be(i + 1, token_type, head->result.type));
         return TRUE;
     }
     return FALSE;
@@ -607,187 +278,79 @@ static Boolean test_eof_value(LexerTest *test, LexerResult result, size_t i) {
     return FALSE;
 }
 
-static Boolean test_identifier_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    Boolean is_literal,
-    size_t length,
-    const char *name
-) {
+static Boolean test_identifier_value(LexerTest *test, LexerResult result, size_t i, Boolean is_literal, size_t length, const char *name) {
     static const TokenType token_type = TOKEN_IDENTIFIER;
     LexerTokenResult *head = get_token(result.result, i);
     if (test_token_type(test, result, i, token_type)) {
         return TRUE;
     } if (head->result.identifier.is_literal != is_literal) {
-        logic_fail_test(
-            test,
-            result,
-            is_literal
-                ? identifier_should_be_literal(i + 1)
-                : identifier_should_not_be_literal(i + 1)
-        );
+        logic_fail_test(test, result, is_literal ? identifier_should_be_literal(i + 1) : identifier_should_not_be_literal(i + 1));
         return TRUE;
     } if (head->result.identifier.length == strnlen(name, length)) {
-        logic_fail_test(
-            test,
-            result,
-            token_length_should_be(
-                i + 1,
-                token_type,
-                strnlen(name, length),
-                head->result.identifier.length
-            )
-        );
+        logic_fail_test(test, result, token_length_should_be(i + 1, token_type, strnlen(name, length), head->result.identifier.length));
         return TRUE;
     } if (strncmp(head->result.identifier.name, name, length) != 0) {
-        logic_fail_test(
-            test,
-            result,
-            token_value_string_should_be(
-                i + 1,
-                token_type,
-                fmax(
-                    strnlen(name, length),
-                    strnlen(head->result.string_literal.value, length)
-                ),
-                head->result.identifier.name,
-                name
-            )
-        );
+        logic_fail_test(test, result, token_value_string_should_be(i + 1, token_type, strnlen(name, length), head->result.identifier.name, name));
         return TRUE;
     }
     return FALSE;
 }
 
-static Boolean test_integer_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    IntegerBuiltInType type,
-    uint64_t value
-) {
+static Boolean test_integer_value(LexerTest *test, LexerResult result, size_t i, IntegerBuiltInType type, uint64_t value) {
     static const TokenType token_type = TOKEN_INTEGER;
     LexerTokenResult *head = get_token(result.result, i);
     if (test_token_type(test, result, i, token_type)) {
         return TRUE;
     } if (head->result.integer_literal.type != type) {
-        logic_fail_test(
-            test,
-            result,
-            integer_type_should_be(
-                i + 1,
-                type,
-                head->result.integer_literal.type
-            )
-        );
+        logic_fail_test(test, result, integer_type_should_be(i + 1, type, head->result.integer_literal.type));
         return TRUE;
     } if (head->result.integer_literal.value != value) {
-        logic_fail_test(
-            test,
-            result,
-            integer_value_should_be(
-                i + 1,
-                value,
-                head->result.integer_literal.value
-            )
-        );
+        logic_fail_test(test, result, integer_value_should_be(i + 1, value, head->result.integer_literal.value));
         return TRUE;
     }
     return FALSE;
 }
 
-static Boolean test_float_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    float value
-) {
+static Boolean test_float_value(LexerTest *test, LexerResult result, size_t i, float value) {
     static const TokenType token_type = TOKEN_FLOAT;
     LexerTokenResult *head = get_token(result.result, i);
     if (test_token_type(test, result, i, token_type)) {
         return TRUE;
     } if (fabsf(head->result.float_literal - value) >= FLOAT_TEST_PRECISION) {
-        logic_fail_test(
-            test,
-            result,
-            float_value_should_be(i + 1, value, head->result.float_literal)
-        );
+        logic_fail_test(test, result, float_value_should_be(i + 1, value, head->result.float_literal));
         return TRUE;
     }
     return FALSE;
 }
 
-static Boolean test_double_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    double value
-) {
+static Boolean test_double_value(LexerTest *test, LexerResult result, size_t i, double value) {
     static const TokenType token_type = TOKEN_DOUBLE;
     LexerTokenResult *head = get_token(result.result, i);
     if (test_token_type(test, result, i, token_type)) {
         return TRUE;
     } if (fabs(head->result.float_literal - value) >= FLOAT_TEST_PRECISION) {
-        logic_fail_test(
-            test,
-            result,
-            float_value_should_be(i + 1, value, head->result.float_literal)
-        );
+        logic_fail_test(test, result, float_value_should_be(i + 1, value, head->result.float_literal));
         return TRUE;
     }
     return FALSE;
 }
 
-static Boolean test_string_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    size_t length,
-    const char *value
-) {
+static Boolean test_string_value(LexerTest *test, LexerResult result, size_t i, size_t length, const char *value) {
     static const TokenType token_type = TOKEN_STRING;
     LexerTokenResult *head = get_token(result.result, i);
     if (test_token_type(test, result, i, token_type)) {
         return TRUE;
     } if (head->result.string_literal.length == strnlen(value, length)) {
-        logic_fail_test(
-            test,
-            result,
-            token_length_should_be(
-                i + 1,
-                token_type,
-                strnlen(value, length),
-                head->result.string_literal.length
-            )
-        );
+        logic_fail_test(test, result, token_length_should_be(i + 1, token_type, strnlen(value, length), head->result.string_literal.length));
         return TRUE;
     } if (strncmp(head->result.string_literal.value, value, length) != 0) {
-        logic_fail_test(
-            test,
-            result,
-            token_value_string_should_be(
-                i + 1,
-                token_type,
-                fmax(
-                    strnlen(value, length),
-                    strnlen(head->result.string_literal.value, length)
-                ),
-                value,
-                head->result.string_literal.value
-            )
-        );
+        logic_fail_test(test, result, token_value_string_should_be(i + 1, token_type, fmax(strnlen(value, length), strnlen(head->result.string_literal.value, length)), value, head->result.string_literal.value));
         return TRUE;
     }
     return FALSE;
 }
 
-static Boolean test_boolean_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    Boolean value
-) {
+static Boolean test_boolean_value(LexerTest *test, LexerResult result, size_t i, Boolean value) {
     static const TokenType token_type = TOKEN_BOOLEAN;
     LexerTokenResult *head = get_token(result.result, i);
     if (test_token_type(test, result, i, token_type)) {
@@ -799,67 +362,27 @@ static Boolean test_boolean_value(
     return FALSE;
 }
 
-static Boolean test_array_type(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    ArrayType array_type,
-    size_t *shape,
-    size_t dimensions
-) {
+static Boolean test_array_type(LexerTest *test, LexerResult result, size_t i, ArrayType array_type, size_t *shape, size_t dimensions) {
     LexerTokenResult *head = get_token(result.result, i);
     if (test_token_type(test, result, i, TOKEN_ARRAY)) {
         return TRUE;
     } if (head->result.array_literal.type != array_type) {
-        logic_fail_test(
-            test,
-            result,
-            array_type_should_be(
-                i + 1,
-                array_type,
-                head->result.array_literal.type
-            )
-        );
+        logic_fail_test(test, result, array_type_should_be(i + 1, array_type, head->result.array_literal.type));
         return TRUE;
     } if (head->result.array_literal.dimensions != dimensions) {
-        logic_fail_test(
-            test,
-            result,
-            array_dimensions_should_be(
-                i + 1,
-                dimensions,
-                head->result.array_literal.dimensions
-            )
-        );
+        logic_fail_test(test, result, array_dimensions_should_be(i + 1, dimensions, head->result.array_literal.dimensions));
         return TRUE;
     }
     for (int j = 0; j < dimensions; j++) {
         if (head->result.array_literal.shape[j] != shape[j]) {
-            logic_fail_test(
-                test,
-                result,
-                array_element_shape_should_be(
-                    i + 1,
-                    j,
-                    array_type,
-                    shape[j],
-                    head->result.array_literal.shape[j]
-                )
-            );
+            logic_fail_test(test, result, array_element_shape_should_be(i + 1, j, array_type, shape[j], head->result.array_literal.shape[j]));
             return TRUE;
         }
     }
     return FALSE;
 }
 
-static Boolean test_array_identifier_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    ArrayStringValues *values,
-    size_t *shape,
-    size_t dimensions
-) {
+static Boolean test_array_identifier_value(LexerTest *test, LexerResult result, size_t i, ArrayStringValues *values, size_t *shape, size_t dimensions) {
     static const ArrayType array_type = ARRAY_IDENTIFIER;
     LexerTokenResult *head = get_token(result.result, i);
     if (test_array_type(test, result, i, array_type, shape, dimensions)) {
@@ -868,68 +391,21 @@ static Boolean test_array_identifier_value(
     size_t length = 1;
     for (int j = 0; j < dimensions; j++) length *= shape[j];
     for (int j = 0; j < length; j++) {
-        if (
-            head->result.array_literal.identifiers[j].length ==
-            values[j].length
-        ) {
-            logic_fail_test(
-                test,
-                result,
-                array_element_integer_should_be(
-                    i + 1,
-                    j,
-                    array_type,
-                    values[j].length,
-                    head->result.array_literal.identifiers[j].length
-                )
-            );
+        if (head->result.array_literal.identifiers[j].length == values[j].length) {
+            logic_fail_test(test, result, array_element_integer_should_be(i + 1, j, array_type, values[j].length, head->result.array_literal.identifiers[j].length));
             return TRUE;
-        } if (
-            strncmp(
-                head->result.array_literal.identifiers[j].name,
-                values[j].value,
-                values[j].length
-            )
-        ) {
-            logic_fail_test(
-                test,
-                result,
-                array_element_string_should_be(
-                    i + 1,
-                    j,
-                    array_type,
-                    values[j].length,
-                    values[j].value,
-                    head->result.array_literal.identifiers[j].name
-                )
-            );
+        } if (strncmp(head->result.array_literal.identifiers[j].name, values[j].value, values[j].length)) {
+            logic_fail_test(test, result, array_element_string_should_be(i + 1, j, array_type, values[j].length, values[j].value, head->result.array_literal.identifiers[j].name));
             return TRUE;
-        } if (!head->result.array_literal.identifiers[j].is_literal) {
-            logic_fail_test(
-                test,
-                result,
-                array_element_boolean_should_be(
-                    i + 1,
-                    j,
-                    array_type,
-                    TRUE
-                )
-            );
+        } if (head->result.array_literal.identifiers[j].is_literal) {
+            logic_fail_test(test, result, array_element_boolean_should_be(i + 1, j, array_type, TRUE));
             return TRUE;
         }
     }
     return FALSE;
 }
 
-static Boolean test_array_integer_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    IntegerBuiltInType array_type,
-    uint64_t *values,
-    size_t *shape,
-    size_t dimensions
-) {
+static Boolean test_array_integer_value(LexerTest *test, LexerResult result, size_t i, IntegerBuiltInType array_type, uint64_t *values, size_t *shape, size_t dimensions) {
     LexerTokenResult *head = get_token(result.result, i);
     if (test_array_type(test, result, i, array_type, shape, dimensions)) {
         return TRUE;
@@ -938,31 +414,14 @@ static Boolean test_array_integer_value(
     for (int j = 0; j < dimensions; j++) length *= shape[j];
     for (int j = 0; j < length; j++) {
         if (head->result.array_literal.integer_literals[j] == values[j]) {
-            logic_fail_test(
-                test,
-                result,
-                array_element_integer_should_be(
-                    i + 1,
-                    j,
-                    array_type,
-                    values[j],
-                    head->result.array_literal.integer_literals[j]
-                )
-            );
+            logic_fail_test(test, result, array_element_integer_should_be(i + 1, j, array_type, values[j], head->result.array_literal.integer_literals[j]));
             return TRUE;
         }
     }
     return FALSE;
 }
 
-static Boolean test_array_float_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    float *values,
-    size_t *shape,
-    size_t dimensions
-) {
+static Boolean test_array_float_value(LexerTest *test, LexerResult result, size_t i, float *values, size_t *shape, size_t dimensions) {
     static const ArrayType array_type = ARRAY_FLOAT;
     LexerTokenResult *head = get_token(result.result, i);
     if (test_array_type(test, result, i, array_type, shape, dimensions)) {
@@ -971,36 +430,15 @@ static Boolean test_array_float_value(
     size_t length = 1;
     for (int j = 0; j < dimensions; j++) length *= shape[j];
     for (int j = 0; j < length; j++) {
-        if (
-            fabsf(
-                head->result.array_literal.float_literals[j] - values[j]
-            ) >= FLOAT_TEST_PRECISION
-        ) {
-            logic_fail_test(
-                test,
-                result,
-                array_element_float_should_be(
-                    i + 1,
-                    j,
-                    array_type,
-                    values[j],
-                    head->result.array_literal.float_literals[j]
-                )
-            );
+        if (fabsf(head->result.array_literal.float_literals[j] - values[j]) >= FLOAT_TEST_PRECISION) {
+            logic_fail_test(test, result, array_element_float_should_be(i + 1, j, array_type, values[j], head->result.array_literal.float_literals[j]));
             return TRUE;
         }
     }
     return FALSE;
 }
 
-static Boolean test_array_double_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    double *values,
-    size_t *shape,
-    size_t dimensions
-) {
+static Boolean test_array_double_value(LexerTest *test, LexerResult result, size_t i, double *values, size_t *shape, size_t dimensions) {
     static const ArrayType array_type = ARRAY_DOUBLE;
     LexerTokenResult *head = get_token(result.result, i);
     if (test_array_type(test, result, i, array_type, shape, dimensions)) {
@@ -1009,36 +447,15 @@ static Boolean test_array_double_value(
     size_t length = 1;
     for (int j = 0; j < dimensions; j++) length *= shape[j];
     for (int j = 0; j < length; j++) {
-        if (
-            fabs(
-                head->result.array_literal.float_literals[j] - values[j]
-            ) >= FLOAT_TEST_PRECISION
-        ) {
-            logic_fail_test(
-                test,
-                result,
-                array_element_float_should_be(
-                    i + 1,
-                    j,
-                    array_type,
-                    values[j],
-                    head->result.array_literal.float_literals[j]
-                )
-            );
+        if (fabs(head->result.array_literal.float_literals[j] - values[j]) >= FLOAT_TEST_PRECISION) {
+            logic_fail_test(test, result, array_element_float_should_be(i + 1, j, array_type, values[j], head->result.array_literal.float_literals[j]));
             return TRUE;
         }
     }
     return FALSE;
 }
 
-static Boolean test_array_string_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    ArrayStringValues *values,
-    size_t *shape,
-    size_t dimensions
-) {
+static Boolean test_array_string_value(LexerTest *test, LexerResult result, size_t i, ArrayStringValues *values, size_t *shape, size_t dimensions) {
     static const ArrayType array_type = ARRAY_STRING;
     LexerTokenResult *head = get_token(result.result, i);
     if (test_array_type(test, result, i, array_type, shape, dimensions)) {
@@ -1047,55 +464,18 @@ static Boolean test_array_string_value(
     size_t length = 1;
     for (int j = 0; j < dimensions; j++) length *= shape[j];
     for (int j = 0; j < length; j++) {
-        if (
-            head->result.array_literal.string_literals[j].length ==
-            values[j].length
-        ) {
-            logic_fail_test(
-                test,
-                result,
-                array_element_integer_should_be(
-                    i + 1,
-                    j,
-                    array_type,
-                    values[j].length,
-                    head->result.array_literal.string_literals[j].length
-                )
-            );
+        if (head->result.array_literal.string_literals[j].length == values[j].length) {
+            logic_fail_test(test, result, array_element_integer_should_be(i + 1, j, array_type, values[j].length, head->result.array_literal.string_literals[j].length));
             return TRUE;
-        } if (
-            strncmp(
-                head->result.array_literal.string_literals[j].value,
-                values[j].value,
-                values[j].length
-            )
-        ) {
-            logic_fail_test(
-                test,
-                result,
-                array_element_string_should_be(
-                    i + 1,
-                    j,
-                    array_type,
-                    values[j].length,
-                    values[j].value,
-                    head->result.array_literal.string_literals[j].value
-                )
-            );
+        } if (strncmp(head->result.array_literal.string_literals[j].value, values[j].value, values[j].length)) {
+            logic_fail_test(test, result, array_element_string_should_be(i + 1, j, array_type, values[j].length, values[j].value, head->result.array_literal.string_literals[j].value));
             return TRUE;
         }
     }
     return FALSE;
 }
 
-static Boolean test_array_boolean_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    Boolean *values,
-    size_t *shape,
-    size_t dimensions
-) {
+static Boolean test_array_boolean_value(LexerTest *test, LexerResult result, size_t i, Boolean *values, size_t *shape, size_t dimensions) {
     static const ArrayType array_type = ARRAY_BOOLEAN;
     LexerTokenResult *head = get_token(result.result, i);
     if (test_array_type(test, result, i, array_type, shape, dimensions)) {
@@ -1105,211 +485,68 @@ static Boolean test_array_boolean_value(
     for (int j = 0; j < dimensions; j++) length *= shape[j];
     for (int j = 0; j < length; j++) {
         if (head->result.array_literal.boolean_literals[j] == values[j]) {
-            logic_fail_test(
-                test,
-                result,
-                array_element_boolean_should_be(
-                    i + 1,
-                    j,
-                    array_type,
-                    values[j]
-                )
-            );
+            logic_fail_test(test, result, array_element_boolean_should_be(i + 1, j, array_type, values[j]));
             return TRUE;
         }
     }
     return FALSE;
 }
 
-static Boolean test_array_token_string_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    void *values,
-    size_t *shape,
-    size_t dimensions
-) {
-    error_test(
-        test,
-        result,
-        (SlsError) { .message = "Test case not implemented!", .code = 984, }
-    );
+static Boolean test_array_token_string_value(LexerTest *test, LexerResult result, size_t i, void *values, size_t *shape, size_t dimensions) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
     // TODO
     return TRUE;
 }
 
-static Boolean test_array_type_tuple_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    void *values,
-    size_t *shape,
-    size_t dimensions
-) {
-    error_test(
-        test,
-        result,
-        (SlsError) { .message = "Test case not implemented!", .code = 984, }
-    );
+static Boolean test_array_type_tuple_value(LexerTest *test, LexerResult result, size_t i, void *values, size_t *shape, size_t dimensions) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
     // TODO
     return TRUE;
 }
 
-static Boolean test_array_struct_inline_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    void *values,
-    size_t *shape,
-    size_t dimensions
-) {
-    error_test(
-        test,
-        result,
-        (SlsError) { .message = "Test case not implemented!", .code = 984, }
-    );
+static Boolean test_array_struct_inline_value(LexerTest *test, LexerResult result, size_t i, void *values, size_t *shape, size_t dimensions) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
     // TODO
     return TRUE;
 }
 
-static Boolean test_token_string_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    void *value,
-    size_t *shape,
-    size_t dimensions
-) {
-    error_test(
-        test,
-        result,
-        (SlsError) { .message = "Test case not implemented!", .code = 984, }
-    );
+static Boolean test_token_string_value(LexerTest *test, LexerResult result, size_t i, void *value, size_t *shape, size_t dimensions) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
     // TODO
     return TRUE;
 }
 
-static Boolean test_type_tuple_value(
-    LexerTest *test,
-    LexerResult result,
-    size_t i,
-    ArrayStringValues *input_values,
-    size_t input_length,
-    ArrayStringValues *output_values,
-    size_t output_length
-) {
+static Boolean test_type_tuple_value(LexerTest *test, LexerResult result, size_t i, ArrayStringValues *input_values, size_t input_length, ArrayStringValues *output_values, size_t output_length) {
     static const TokenType token_type = TOKEN_TYPE_TUPLE;
     LexerTokenResult *head = get_token(result.result, i);
     if (test_token_type(test, result, i, token_type)) {
         return TRUE;
     } if (head->result.type_tuple.input_length != input_length) {
-        logic_fail_test(
-            test,
-            result,
-            token_length_should_be(
-                i + 1,
-                token_type,
-                input_length,
-                head->result.type_tuple.input_length
-            )
-        );
+        logic_fail_test(test, result, token_length_should_be(i + 1, token_type, input_length, head->result.type_tuple.input_length));
         return TRUE;
     } if (head->result.type_tuple.output_length != output_length) {
-        logic_fail_test(
-            test,
-            result,
-            token_length_should_be(
-                i + 1,
-                token_type,
-                output_length,
-                head->result.type_tuple.output_length
-            )
-        );
+        logic_fail_test(test, result, token_length_should_be(i + 1, token_type, output_length, head->result.type_tuple.output_length));
         return TRUE;
     } for (int j = 0; j < input_length; j++) {
-        if (
-            head->result.type_tuple.input_identifiers[j].length ==
-            input_values[j].length
-        ) {
-            logic_fail_test(
-                test,
-                result,
-                type_tuple_element_integer_should_be(
-                    i + 1,
-                    j,
-                    input_values[j].length,
-                    head->result.type_tuple.input_identifiers[j].length
-                )
-            );
+        if (head->result.type_tuple.input_identifiers[j].length == input_values[j].length) {
+            logic_fail_test(test, result, type_tuple_element_integer_should_be(i + 1, j, input_values[j].length, head->result.type_tuple.input_identifiers[j].length));
             return TRUE;
-        } if (
-            strncmp(
-                head->result.type_tuple.input_identifiers[j].name,
-                input_values[j].value,
-                input_values[j].length
-            )
-        ) {
-            logic_fail_test(
-                test,
-                result,
-                type_tuple_element_string_should_be(
-                    i + 1,
-                    j,
-                    input_values[j].length,
-                    input_values[j].value,
-                    head->result.type_tuple.input_identifiers[j].name
-                )
-            );
+        } if (strncmp(head->result.type_tuple.input_identifiers[j].name, input_values[j].value, input_values[j].length)) {
+            logic_fail_test(test, result, type_tuple_element_string_should_be(i + 1, j, input_values[j].length, input_values[j].value, head->result.type_tuple.input_identifiers[j].name));
             return TRUE;
-        } if (!head->result.type_tuple.input_identifiers[j].is_literal) {
-            logic_fail_test(
-                test,
-                result,
-                type_tuple_element_boolean_should_be(i + 1, j, TRUE)
-            );
+        } if (head->result.type_tuple.input_identifiers[j].is_literal) {
+            logic_fail_test(test, result, type_tuple_element_boolean_should_be(i + 1, j, TRUE));
             return TRUE;
         }
     } for (int j = 0; j < output_length; j++) {
-        if (
-            head->result.type_tuple.output_identifiers[j].length ==
-            output_values[j].length
-        ) {
-            logic_fail_test(
-                test,
-                result,
-                type_tuple_element_integer_should_be(
-                    i + 1,
-                    j,
-                    output_values[j].length,
-                    head->result.type_tuple.output_identifiers[j].length
-                )
-            );
+        if (head->result.type_tuple.output_identifiers[j].length == output_values[j].length) {
+            logic_fail_test(test, result, type_tuple_element_integer_should_be(i + 1, j, output_values[j].length, head->result.type_tuple.output_identifiers[j].length));
             return TRUE;
-        } if (
-            strncmp(
-                head->result.type_tuple.output_identifiers[j].name,
-                output_values[j].value,
-                input_values[j].length
-            )
-        ) {
-            logic_fail_test(
-                test,
-                result,
-                type_tuple_element_string_should_be(
-                    i + 1,
-                    j,
-                    output_values[j].length,
-                    output_values[j].value,
-                    head->result.type_tuple.output_identifiers[j].name
-                )
-            );
+        } if (strncmp(head->result.type_tuple.output_identifiers[j].name, output_values[j].value, input_values[j].length)) {
+            logic_fail_test(test, result, type_tuple_element_string_should_be(i + 1, j, output_values[j].length, output_values[j].value, head->result.type_tuple.output_identifiers[j].name));
             return TRUE;
-        } if (!head->result.type_tuple.output_identifiers[j].is_literal) {
-            logic_fail_test(
-                test,
-                result,
-                type_tuple_element_boolean_should_be(i + 1, j, TRUE)
-            );
+        } if (head->result.type_tuple.output_identifiers[j].is_literal) {
+            logic_fail_test(test, result, type_tuple_element_boolean_should_be(i + 1, j, TRUE));
             return TRUE;
         }
     }
@@ -1321,106 +558,74 @@ static Boolean test_type_tuple_value(
 static TestResult test_add_statement() {
     LexerTest test = start_up_test("test_add_statement", "3 4 +");
     LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR)
-        return error_fail_test(&test, result, result.error);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_integer_value(&test, result, i++, INTEGER_I64, 3))
-        return test.result;
-    if (test_integer_value(&test, result, i++, INTEGER_I64, 4))
-        return test.result;
-    if (test_identifier_value(&test, result, i++, FALSE, 1, "+"))
-        return test.result;
-    if (test_eof_value(&test, result, i++))
-        return test.result;
+    if (test_integer_value(&test, result, i++, INTEGER_I64, 3)) return test.result;
+    if (test_integer_value(&test, result, i++, INTEGER_I64, 4)) return test.result;
+    if (test_identifier_value(&test, result, i++, FALSE, 1, "+")) return test.result;
+    if (test_eof_value(&test, result, i++)) return test.result;
     return pass_test(&test, result);
 }
 
 static TestResult test_sub_statement() {
     LexerTest test = start_up_test("test_sub_statement", "10 3 -");
     LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR)
-        return error_fail_test(&test, result, result.error);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_integer_value(&test, result, i++, INTEGER_I64, 10))
-        return test.result;
-    if (test_integer_value(&test, result, i++, INTEGER_I64, 3))
-        return test.result;
-    if (test_identifier_value(&test, result, i++, FALSE, 1, "-"))
-        return test.result;
-    if (test_eof_value(&test, result, i++))
-        return test.result;
+    if (test_integer_value(&test, result, i++, INTEGER_I64, 10)) return test.result;
+    if (test_integer_value(&test, result, i++, INTEGER_I64, 3)) return test.result;
+    if (test_identifier_value(&test, result, i++, FALSE, 1, "-")) return test.result;
+    if (test_eof_value(&test, result, i++)) return test.result;
     return pass_test(&test, result);
 }
 
 static TestResult test_mult_statement() {
     LexerTest test = start_up_test("test_mult_statement", "5 6 *");
     LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR)
-        return error_fail_test(&test, result, result.error);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_integer_value(&test, result, i++, INTEGER_I64, 5))
-        return test.result;
-    if (test_integer_value(&test, result, i++, INTEGER_I64, 6))
-        return test.result;
-    if (test_identifier_value(&test, result, i++, FALSE, 1, "*"))
-        return test.result;
-    if (test_eof_value(&test, result, i++))
-        return test.result;
+    if (test_integer_value(&test, result, i++, INTEGER_I64, 5)) return test.result;
+    if (test_integer_value(&test, result, i++, INTEGER_I64, 6)) return test.result;
+    if (test_identifier_value(&test, result, i++, FALSE, 1, "*")) return test.result;
+    if (test_eof_value(&test, result, i++)) return test.result;
     return pass_test(&test, result);
 }
 
 static TestResult test_div_statement() {
     LexerTest test = start_up_test("test_div_statement", "20 4 /");
     LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR)
-        return error_fail_test(&test, result, result.error);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_integer_value(&test, result, i++, INTEGER_I64, 20))
-        return test.result;
-    if (test_integer_value(&test, result, i++, INTEGER_I64, 4))
-        return test.result;
-    if (test_identifier_value(&test, result, i++, FALSE, 1, "/"))
-        return test.result;
-    if (test_eof_value(&test, result, i++))
-        return test.result;
+    if (test_integer_value(&test, result, i++, INTEGER_I64, 20)) return test.result;
+    if (test_integer_value(&test, result, i++, INTEGER_I64, 4)) return test.result;
+    if (test_identifier_value(&test, result, i++, FALSE, 1, "/")) return test.result;
+    if (test_eof_value(&test, result, i++)) return test.result;
     return pass_test(&test, result);
 }
 
 static TestResult test_add_and_mult_statement() {
     LexerTest test = start_up_test("test_add_and_mult_statement", "2 3 + 4 *");
     LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR)
-        return error_fail_test(&test, result, result.error);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_integer_value(&test, result, i++, INTEGER_I64, 2))
-        return test.result;
-    if (test_integer_value(&test, result, i++, INTEGER_I64, 3))
-        return test.result;
-    if (test_identifier_value(&test, result, i++, FALSE, 1, "+"))
-        return test.result;
-    if (test_integer_value(&test, result, i++, INTEGER_I64, 4))
-        return test.result;
-    if (test_identifier_value(&test, result, i++, FALSE, 1, "*"))
-        return test.result;
-    if (test_eof_value(&test, result, i++))
-        return test.result;
+    if (test_integer_value(&test, result, i++, INTEGER_I64, 2)) return test.result;
+    if (test_integer_value(&test, result, i++, INTEGER_I64, 3)) return test.result;
+    if (test_identifier_value(&test, result, i++, FALSE, 1, "+")) return test.result;
+    if (test_integer_value(&test, result, i++, INTEGER_I64, 4)) return test.result;
+    if (test_identifier_value(&test, result, i++, FALSE, 1, "*")) return test.result;
+    if (test_eof_value(&test, result, i++)) return test.result;
     return pass_test(&test, result);
 }
 
 static TestResult test_dup_and_mult_statement() {
     LexerTest test = start_up_test("test_dup_and_mult_statement", "10 dup *");
     LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR)
-        return error_fail_test(&test, result, result.error);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_integer_value(&test, result, i++, INTEGER_I64, 10))
-        return test.result;
-    if (test_identifier_value(&test, result, i++, FALSE, 3, "dup"))
-        return test.result;
-    if (test_identifier_value(&test, result, i++, FALSE, 1, "*"))
-        return test.result;
-    if (test_eof_value(&test, result, i++))
-        return test.result;
+    if (test_integer_value(&test, result, i++, INTEGER_I64, 10)) return test.result;
+    if (test_identifier_value(&test, result, i++, FALSE, 3, "dup")) return test.result;
+    if (test_identifier_value(&test, result, i++, FALSE, 1, "*")) return test.result;
+    if (test_eof_value(&test, result, i++)) return test.result;
     return pass_test(&test, result);
 }