Worked on test case parts

SLS_C/tests/lexer_tests.c

@@ -43,6 +43,11 @@ static const char *INTEGER_TYPES_NAMES[] = {
     "u8",
 };
 
+typedef struct {
+    const char *value;
+    size_t length;
+} ArrayStringValues;
+
 // Test start and end helpers
 
 static LexerTest start_up_test(const char *test_name, const char *test_code) {
@@ -169,7 +174,7 @@ static char *token_name_should_be(size_t i, TokenType type, size_t length, const
 
 // Test parts
 
-static Boolean test_integer_value(LexerTest *test, LexerResult result, size_t i, IntegerBuiltInType type, uint64_t value) {
+static Boolean test_eof_value(LexerTest *test, LexerResult result, size_t i) {
     LexerTokenResult *head = get_token(result.result, i);
     if (head == 0) {
         logic_fail_test(test, result, unexpected_end_of_token_stream(i + 1));
@@ -177,14 +182,11 @@ static Boolean test_integer_value(LexerTest *test, LexerResult result, size_t i,
     } if (head->type == SLS_ERROR) {
         error_fail_test(test, result, result.error);
         return TRUE;
-    } if (head->result.type != TOKEN_INTEGER) {
+    } if (head->result.type != TOKEN_EOF) {
-        logic_fail_test(test, result, token_should_be(i + 1, TOKEN_INTEGER, head->result.type));
+        logic_fail_test(test, result, token_should_be(i + 1, TOKEN_EOF, head->result.type));
         return TRUE;
-    } if (head->result.integer_literal.type != type) {
+    } if (head->next != 0) {
-        logic_fail_test(test, result, integer_type_should_be(i + 1, type, head->result.integer_literal.type));
+        logic_fail_test(test, result, expected_end_of_token_stream(i + 1));
-        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));
         return TRUE;
     }
     return FALSE;
@@ -214,7 +216,7 @@ static Boolean test_identifier_value(LexerTest *test, LexerResult result, size_t
     return FALSE;
 }
 
-static Boolean test_eof_value(LexerTest *test, LexerResult result, size_t i) {
+static Boolean test_integer_value(LexerTest *test, LexerResult result, size_t i, IntegerBuiltInType type, uint64_t value) {
     LexerTokenResult *head = get_token(result.result, i);
     if (head == 0) {
         logic_fail_test(test, result, unexpected_end_of_token_stream(i + 1));
@@ -222,16 +224,115 @@ static Boolean test_eof_value(LexerTest *test, LexerResult result, size_t i) {
     } if (head->type == SLS_ERROR) {
         error_fail_test(test, result, result.error);
         return TRUE;
-    } if (head->result.type != TOKEN_EOF) {
+    } if (head->result.type != TOKEN_INTEGER) {
-        logic_fail_test(test, result, token_should_be(i + 1, TOKEN_EOF, head->result.type));
+        logic_fail_test(test, result, token_should_be(i + 1, TOKEN_INTEGER, head->result.type));
         return TRUE;
-    } if (head->next != 0) {
+    } if (head->result.integer_literal.type != type) {
-        logic_fail_test(test, result, expected_end_of_token_stream(i + 1));
+        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));
         return TRUE;
     }
     return FALSE;
 }
 
+static Boolean test_float_value(LexerTest *test, LexerResult result, size_t i, float value) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
+    // TODO
+    return TRUE;
+}
+
+static Boolean test_double_value(LexerTest *test, LexerResult result, size_t i, double value) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
+    // TODO
+    return TRUE;
+}
+
+static Boolean test_string_value(LexerTest *test, LexerResult result, size_t i, const char *value) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
+    // TODO
+    return TRUE;
+}
+
+static Boolean test_boolean_value(LexerTest *test, LexerResult result, size_t i, Boolean value) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
+    // TODO
+    return TRUE;
+}
+
+static Boolean test_array_identifier_value(LexerTest *test, LexerResult result, size_t i, ArrayStringValues *values, size_t length) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
+    // TODO
+    return TRUE;
+}
+
+static Boolean test_array_integer_value(LexerTest *test, LexerResult result, size_t i, IntegerBuiltInType type, uint64_t *values, size_t length) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
+    // TODO
+    return TRUE;
+}
+
+static Boolean test_array_float_value(LexerTest *test, LexerResult result, size_t i, float *values, size_t length) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
+    // TODO
+    return TRUE;
+}
+
+static Boolean test_array_double_value(LexerTest *test, LexerResult result, size_t i, double *values, size_t length) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
+    // TODO
+    return TRUE;
+}
+
+static Boolean test_array_string_value(LexerTest *test, LexerResult result, size_t i, ArrayStringValues *values, size_t length) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
+    // TODO
+    return TRUE;
+}
+
+static Boolean test_array_boolean_value(LexerTest *test, LexerResult result, size_t i, Boolean *values, size_t length) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
+    // TODO
+    return TRUE;
+}
+
+static Boolean test_array_array_value(LexerTest *test, LexerResult result, size_t i, void *values, size_t length) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
+    // TODO
+    return TRUE;
+}
+
+static Boolean test_array_token_string_value(LexerTest *test, LexerResult result, size_t i, void *values, size_t length) {
+    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 length) {
+    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 length) {
+    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 length) {
+    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) {
+    error_test(test, result, (SlsError) { .message = "Test case not implemented!", .code = 984, });
+    // TODO
+    return TRUE;
+}
+
 // Test cases
 
 static TestResult test_add_statement() {