From f2033e30e9c2d8a2626592dc7c4bd2b5b4596d66 Mon Sep 17 00:00:00 2001 From: Kyler Date: Thu, 20 Nov 2025 15:42:40 -0700 Subject: [PATCH] White space breaks stuff, but other than that its good --- SLS_C/src/lexer.c | 46 +- SLS_C/tests/lexer_test_helpers.c | 2 +- SLS_C/tests/lexer_tests.c | 1271 +++++++++++++++- SLS_Tests/cases.yaml | 1344 ++++++++++++++++- .../generate_tests/idents_and_bools_tests.py | 84 +- 5 files changed, 2637 insertions(+), 110 deletions(-) diff --git a/SLS_C/src/lexer.c b/SLS_C/src/lexer.c index 4e4232d..1094770 100644 --- a/SLS_C/src/lexer.c +++ b/SLS_C/src/lexer.c @@ -657,9 +657,48 @@ static LexerResult parse_type_tuples(LexerInfo *lexer_info, char c, size_t start return (LexerResult){SLS_ERROR, .error = (SlsError){SLS_STR("Lexer: Type Tuples Not Implemented Error."), 1}}; } +Boolean is_identifier_continue(LexerInfo *lexer_info, char c) { + if (!isprint(c)) return FALSE; + if (c == '/' && far_peek(lexer_info, 1) == '/') return FALSE; + if (c == '{' || c == '}') return FALSE; + if (c == '[' || c == ']') return FALSE; + if (c == '(' || c == ')') return FALSE; + if (c == '\'' || c == '"') return FALSE; + if (c == '.' || c == ':' || c == '#') return FALSE; + if (isspace(c) || c == '\0') return FALSE; + return TRUE; +} + +Boolean is_identifier_start(LexerInfo *lexer_info, char c) { + if (c == ':' && far_peek(lexer_info, 1) == ':') c = far_peek(lexer_info, 2); + if ((!isdigit(c)) && is_identifier_continue(lexer_info, c)) return TRUE; + else return FALSE; +} + static LexerResult parse_identifiers_and_booleans(LexerInfo *lexer_info, char c, size_t start, size_t start_line) { - (void)lexer_info; (void)c; (void)start; (void)start_line; - return (LexerResult){SLS_ERROR, .error = (SlsError){SLS_STR("Lexer: Identifiers and Booleans Not Implemented Error."), 1}}; + Boolean literal = FALSE; + if (c == ':' && far_peek(lexer_info, 1) == ':') { + literal = TRUE; + c = advance(lexer_info); + c = advance(lexer_info); + } + + size_t length = 0; + while (is_identifier_continue(lexer_info, c)) { + c = advance(lexer_info); + length++; + } + char *name_value = (char *)calloc(length+1, sizeof(char)); + for (size_t i = 0; i < length; i++) + name_value[i] = lexer_info->source_code.str[i + (2 * literal)]; + SlsStr name = sls_str_malloc(name_value, length); + free(name_value); + if (sls_str_cmp(name, SLS_STR("false")) == 0) + return lexer_result(lexer_info, (Token){TOKEN_BOOLEAN, .boolean_literal = FALSE}, start, start_line); + else if (sls_str_cmp(name, SLS_STR("true")) == 0) + return lexer_result(lexer_info, (Token){TOKEN_BOOLEAN, .boolean_literal = TRUE}, start, start_line); + else + return lexer_result(lexer_info, (Token){TOKEN_IDENTIFIER, .identifier = (Identifier){.is_literal = literal, .name = name}}, start, start_line); } static LexerResult lexer_next(LexerInfo *lexer_info) { @@ -697,7 +736,8 @@ static LexerResult lexer_next(LexerInfo *lexer_info) { // Type Tuples if (c == '(') return parse_type_tuples(lexer_info, c, start, start_line); // Identifiers and Booleans - if (sls_isascii(c)) return parse_identifiers_and_booleans(lexer_info, c, start, start_line); + if (is_identifier_start(lexer_info, c)) + return parse_identifiers_and_booleans(lexer_info, c, start, start_line); // Lexing Error return (LexerResult){SLS_ERROR, .error = (SlsError){SLS_STR("Lexer: Unknown Character Error."), 1}}; } diff --git a/SLS_C/tests/lexer_test_helpers.c b/SLS_C/tests/lexer_test_helpers.c index 1c43161..b8ffbc3 100644 --- a/SLS_C/tests/lexer_test_helpers.c +++ b/SLS_C/tests/lexer_test_helpers.c @@ -265,7 +265,7 @@ Boolean test_identifier_value(LexerTest *test, LexerResult result, size_t i, Tes } if (head->result.identifier.is_literal != value->is_literal) { logic_fail_test(test, result, value->is_literal ? identifier_should_be_literal(i + 1) : identifier_should_not_be_literal(i + 1)); return TRUE; - } if (head->result.identifier.name.len == value->name.len) { + } if (head->result.identifier.name.len != value->name.len) { logic_fail_test(test, result, token_length_should_be(i + 1, token_type, value->name.len, head->result.identifier.name.len)); return TRUE; } if (sls_str_cmp(head->result.identifier.name, value->name) != 0) { diff --git a/SLS_C/tests/lexer_tests.c b/SLS_C/tests/lexer_tests.c index 912380b..4e7209a 100644 --- a/SLS_C/tests/lexer_tests.c +++ b/SLS_C/tests/lexer_tests.c @@ -16,7 +16,7 @@ #include "tests/tests.h" -static const size_t NUM_OF_TESTS = 243; +static const size_t NUM_OF_TESTS = 356; static TestResult test_Empty_Statement() { LexerTest test = start_up_test(SLS_STR("Empty_Statement"), SLS_STR("")); @@ -2073,12 +2073,12 @@ static TestResult test_Char_Right_Brace() { return pass_test(&test, result); } -static TestResult test_Char_Escape_Single_quote() { - LexerTest test = start_up_test(SLS_STR("Char Escape Single quote"), SLS_STR("'\\''")); +static TestResult test_Char_Escape_Carriage_return() { + LexerTest test = start_up_test(SLS_STR("Char Escape Carriage return"), SLS_STR("'\\r'")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; - if (test_character_value(&test, result, i++, &(uint8_t){39})) return test.result; + if (test_character_value(&test, result, i++, &(uint8_t){13})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } @@ -2093,12 +2093,22 @@ static TestResult test_Char_Escape_Tab() { return pass_test(&test, result); } -static TestResult test_Char_Escape_Carriage_return() { - LexerTest test = start_up_test(SLS_STR("Char Escape Carriage return"), SLS_STR("'\\r'")); +static TestResult test_Char_Escape_Null_character() { + LexerTest test = start_up_test(SLS_STR("Char Escape Null character"), SLS_STR("'\\0'")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; - if (test_character_value(&test, result, i++, &(uint8_t){13})) return test.result; + if (test_character_value(&test, result, i++, &(uint8_t){0})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Char_Escape_Single_quote() { + LexerTest test = start_up_test(SLS_STR("Char Escape Single quote"), SLS_STR("'\\''")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_character_value(&test, result, i++, &(uint8_t){39})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } @@ -2123,16 +2133,6 @@ static TestResult test_Char_Escape_Newline() { return pass_test(&test, result); } -static TestResult test_Char_Escape_Null_character() { - LexerTest test = start_up_test(SLS_STR("Char Escape Null character"), SLS_STR("'\\0'")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_character_value(&test, result, i++, &(uint8_t){0})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - static TestResult test_Char_Hex_Lowercase_A() { LexerTest test = start_up_test(SLS_STR("Char Hex Lowercase A"), SLS_STR("'\\x61'")); LexerResult result = lexical_analysis(&test.lexer_info); @@ -2415,6 +2415,1124 @@ static TestResult test_Char_Hex_Digits_Mixed() { return pass_test(&test, result); } +static TestResult test_Identifier_Simple_Lowercase() { + LexerTest test = start_up_test(SLS_STR("Identifier Simple Lowercase"), SLS_STR("hello")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("hello")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Simple_Uppercase() { + LexerTest test = start_up_test(SLS_STR("Identifier Simple Uppercase"), SLS_STR("HELLO")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("HELLO")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Mixed_Case() { + LexerTest test = start_up_test(SLS_STR("Identifier Mixed Case"), SLS_STR("HelloWorld")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("HelloWorld")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Single_Letter() { + LexerTest test = start_up_test(SLS_STR("Identifier Single Letter"), SLS_STR("x")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("x")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Single_Letter_Upper() { + LexerTest test = start_up_test(SLS_STR("Identifier Single Letter Upper"), SLS_STR("X")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("X")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Numbers() { + LexerTest test = start_up_test(SLS_STR("Identifier With Numbers"), SLS_STR("var123")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("var123")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Numbers_End() { + LexerTest test = start_up_test(SLS_STR("Identifier Numbers End"), SLS_STR("myVar2")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("myVar2")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Mixed_Numbers() { + LexerTest test = start_up_test(SLS_STR("Identifier Mixed Numbers"), SLS_STR("a1b2c3")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("a1b2c3")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Underscore() { + LexerTest test = start_up_test(SLS_STR("Identifier With Underscore"), SLS_STR("hello_world")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("hello_world")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Leading_Underscore() { + LexerTest test = start_up_test(SLS_STR("Identifier Leading Underscore"), SLS_STR("_private")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("_private")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Multiple_Underscores() { + LexerTest test = start_up_test(SLS_STR("Identifier Multiple Underscores"), SLS_STR("my_long_var_name")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("my_long_var_name")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Double_Underscore() { + LexerTest test = start_up_test(SLS_STR("Identifier Double Underscore"), SLS_STR("my__var")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("my__var")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Trailing_Underscore() { + LexerTest test = start_up_test(SLS_STR("Identifier Trailing Underscore"), SLS_STR("var_")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("var_")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Only_Underscores() { + LexerTest test = start_up_test(SLS_STR("Identifier Only Underscores"), SLS_STR("___")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("___")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Snake_Case() { + LexerTest test = start_up_test(SLS_STR("Identifier Snake Case"), SLS_STR("my_variable_name")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("my_variable_name")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Camel_Case() { + LexerTest test = start_up_test(SLS_STR("Identifier Camel Case"), SLS_STR("myVariableName")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("myVariableName")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Pascal_Case() { + LexerTest test = start_up_test(SLS_STR("Identifier Pascal Case"), SLS_STR("MyClassName")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("MyClassName")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_All_Caps() { + LexerTest test = start_up_test(SLS_STR("Identifier All Caps"), SLS_STR("MY_CONSTANT")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("MY_CONSTANT")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Dash() { + LexerTest test = start_up_test(SLS_STR("Identifier With Dash"), SLS_STR("my-var")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("my-var")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Simple() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Simple"), SLS_STR("::hello")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("hello")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Uppercase() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Uppercase"), SLS_STR("::Point")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("Point")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Snake_Case() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Snake Case"), SLS_STR("::my_var")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("my_var")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Type_i64() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Type i64"), SLS_STR("::i64")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("i64")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Type_String() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Type String"), SLS_STR("::String")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("String")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Type_Point() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Type Point"), SLS_STR("::Point")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("Point")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Trait_Addable() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Trait Addable"), SLS_STR("::Addable")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("Addable")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Trait_Drawable() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Trait Drawable"), SLS_STR("::Drawable")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("Drawable")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Field_x() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Field x"), SLS_STR("::x")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("x")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Field_width() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Field width"), SLS_STR("::width")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("width")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_With_Underscore() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal With Underscore"), SLS_STR("::_private")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("_private")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Multiple_Underscores() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Multiple Underscores"), SLS_STR("::my_long_name")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("my_long_name")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_With_Numbers() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal With Numbers"), SLS_STR("::var123")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("var123")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Leading_Whitespace() { + LexerTest test = start_up_test(SLS_STR("Identifier Leading Whitespace"), SLS_STR(" hello")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("hello")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Trailing_Whitespace() { + LexerTest test = start_up_test(SLS_STR("Identifier Trailing Whitespace"), SLS_STR("hello ")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("hello")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Both_Whitespace() { + LexerTest test = start_up_test(SLS_STR("Identifier Both Whitespace"), SLS_STR(" hello ")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("hello")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Tab_Before() { + LexerTest test = start_up_test(SLS_STR("Identifier Tab Before"), SLS_STR("\thello")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("hello")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Leading_Whitespace() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Leading Whitespace"), SLS_STR(" ::hello")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("hello")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Trailing_Whitespace() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Trailing Whitespace"), SLS_STR("::hello ")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("hello")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Both_Whitespace() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Both Whitespace"), SLS_STR(" ::hello ")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("hello")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Moderate_Length() { + LexerTest test = start_up_test(SLS_STR("Identifier Moderate Length"), SLS_STR("thisIsAReasonablyLongVariableName")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("thisIsAReasonablyLongVariableName")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Very_Long() { + LexerTest test = start_up_test(SLS_STR("Identifier Very Long"), SLS_STR("this_is_a_very_long_identifier_name_that_someone_might_use_for_some_reason")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("this_is_a_very_long_identifier_name_that_someone_might_use_for_some_reason")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Long_With_Numbers() { + LexerTest test = start_up_test(SLS_STR("Identifier Long With Numbers"), SLS_STR("variable_with_many_numbers_123_456_789_000")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("variable_with_many_numbers_123_456_789_000")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Starting_With_Number() { + LexerTest test = start_up_test(SLS_STR("Identifier Starting With Number"), SLS_STR("123abc")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid decimal literal: unexpected 'a' in decimal integer."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Hash() { + LexerTest test = start_up_test(SLS_STR("Identifier With Hash"), SLS_STR("my#var")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: '#' is not allowed in identifiers."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Dot() { + LexerTest test = start_up_test(SLS_STR("Identifier With Dot"), SLS_STR("my.var")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: '.' is not allowed in identifiers."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Space() { + LexerTest test = start_up_test(SLS_STR("Identifier With Space"), SLS_STR("my var")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: whitespace not allowed in identifiers."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Colon() { + LexerTest test = start_up_test(SLS_STR("Identifier With Colon"), SLS_STR("my:var")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: ':' is not allowed in identifiers."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Double_Colon_Inside() { + LexerTest test = start_up_test(SLS_STR("Identifier Double Colon Inside"), SLS_STR("my::var")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: '::' only allowed as prefix for identifier literals."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_At() { + LexerTest test = start_up_test(SLS_STR("Identifier With At"), SLS_STR("@variable")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: '@' is not allowed in identifiers."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Dollar() { + LexerTest test = start_up_test(SLS_STR("Identifier With Dollar"), SLS_STR("$variable")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: '$' is not allowed in identifiers."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Percent() { + LexerTest test = start_up_test(SLS_STR("Identifier With Percent"), SLS_STR("%variable")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: '%' is not allowed in identifiers."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Brackets() { + LexerTest test = start_up_test(SLS_STR("Identifier With Brackets"), SLS_STR("my[var]")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: brackets not allowed in identifiers."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Braces() { + LexerTest test = start_up_test(SLS_STR("Identifier With Braces"), SLS_STR("my{var}")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: braces not allowed in identifiers."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Parens() { + LexerTest test = start_up_test(SLS_STR("Identifier With Parens"), SLS_STR("my(var)")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: parentheses not allowed in identifiers."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Single_Quote() { + LexerTest test = start_up_test(SLS_STR("Identifier With Single Quote"), SLS_STR("my'var")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: quotes not allowed in identifiers."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_With_Double_Quote() { + LexerTest test = start_up_test(SLS_STR("Identifier With Double Quote"), SLS_STR("my\"var")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: quotes not allowed in identifiers."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Only_Numbers() { + LexerTest test = start_up_test(SLS_STR("Identifier Only Numbers"), SLS_STR("123")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Not an identifier: numeric literal."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Literal_Empty() { + LexerTest test = start_up_test(SLS_STR("Identifier Literal Empty"), SLS_STR("::")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier literal: empty identifier after '::'."))) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Case_Lower() { + LexerTest test = start_up_test(SLS_STR("Identifier Case Lower"), SLS_STR("variable")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("variable")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Case_Upper() { + LexerTest test = start_up_test(SLS_STR("Identifier Case Upper"), SLS_STR("VARIABLE")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("VARIABLE")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Case_Mixed() { + LexerTest test = start_up_test(SLS_STR("Identifier Case Mixed"), SLS_STR("Variable")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("Variable")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Case_Camel() { + LexerTest test = start_up_test(SLS_STR("Identifier Case Camel"), SLS_STR("variableName")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("variableName")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Case_Pascal() { + LexerTest test = start_up_test(SLS_STR("Identifier Case Pascal"), SLS_STR("VariableName")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("VariableName")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_true() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word true"), SLS_STR("true")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("true")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_false() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word false"), SLS_STR("false")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("false")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_if() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word if"), SLS_STR("if")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("if")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_while() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word while"), SLS_STR("while")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("while")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_for() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word for"), SLS_STR("for")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("for")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_match() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word match"), SLS_STR("match")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("match")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_break() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word break"), SLS_STR("break")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("break")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_continue() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word continue"), SLS_STR("continue")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("continue")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_fn() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word fn"), SLS_STR("fn")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("fn")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_struct() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word struct"), SLS_STR("struct")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("struct")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_union() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word union"), SLS_STR("union")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("union")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_enum() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word enum"), SLS_STR("enum")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("enum")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_trait() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word trait"), SLS_STR("trait")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("trait")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_impl() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word impl"), SLS_STR("impl")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("impl")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_inher() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word inher"), SLS_STR("inher")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("inher")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_dup() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word dup"), SLS_STR("dup")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("dup")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_drop() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word drop"), SLS_STR("drop")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("drop")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_swap() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word swap"), SLS_STR("swap")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("swap")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_over() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word over"), SLS_STR("over")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("over")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_rot() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word rot"), SLS_STR("rot")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("rot")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_pick() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word pick"), SLS_STR("pick")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("pick")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_roll() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word roll"), SLS_STR("roll")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("roll")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Identifier_Reserved_Word_depth() { + LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word depth"), SLS_STR("depth")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("depth")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_True() { + LexerTest test = start_up_test(SLS_STR("Bool True"), SLS_STR("true")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_False() { + LexerTest test = start_up_test(SLS_STR("Bool False"), SLS_STR("false")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_True_Leading_Whitespace() { + LexerTest test = start_up_test(SLS_STR("Bool True Leading Whitespace"), SLS_STR(" true")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_True_Trailing_Whitespace() { + LexerTest test = start_up_test(SLS_STR("Bool True Trailing Whitespace"), SLS_STR("true ")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_True_Both_Whitespace() { + LexerTest test = start_up_test(SLS_STR("Bool True Both Whitespace"), SLS_STR(" true ")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_True_Tab_Before() { + LexerTest test = start_up_test(SLS_STR("Bool True Tab Before"), SLS_STR("\ttrue")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_False_Leading_Whitespace() { + LexerTest test = start_up_test(SLS_STR("Bool False Leading Whitespace"), SLS_STR(" false")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_False_Trailing_Whitespace() { + LexerTest test = start_up_test(SLS_STR("Bool False Trailing Whitespace"), SLS_STR("false ")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_False_Both_Whitespace() { + LexerTest test = start_up_test(SLS_STR("Bool False Both Whitespace"), SLS_STR(" false ")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_False_Tab_Before() { + LexerTest test = start_up_test(SLS_STR("Bool False Tab Before"), SLS_STR("\tfalse")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_True_Capitalized() { + LexerTest test = start_up_test(SLS_STR("Bool True Capitalized"), SLS_STR("True")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("True")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_False_Capitalized() { + LexerTest test = start_up_test(SLS_STR("Bool False Capitalized"), SLS_STR("False")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("False")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_True_All_Caps() { + LexerTest test = start_up_test(SLS_STR("Bool True All Caps"), SLS_STR("TRUE")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("TRUE")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_False_All_Caps() { + LexerTest test = start_up_test(SLS_STR("Bool False All Caps"), SLS_STR("FALSE")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("FALSE")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_True_Mixed_Case() { + LexerTest test = start_up_test(SLS_STR("Bool True Mixed Case"), SLS_STR("tRuE")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("tRuE")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_False_Mixed_Case() { + LexerTest test = start_up_test(SLS_STR("Bool False Mixed Case"), SLS_STR("fAlSe")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("fAlSe")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_Numeric_1() { + LexerTest test = start_up_test(SLS_STR("Bool Numeric 1"), SLS_STR("1")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 1})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_Numeric_0() { + LexerTest test = start_up_test(SLS_STR("Bool Numeric 0"), SLS_STR("0")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 0})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_String_True() { + LexerTest test = start_up_test(SLS_STR("Bool String True"), SLS_STR("\"true\"")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_string_value(&test, result, i++, &SLS_STR("true"))) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_String_False() { + LexerTest test = start_up_test(SLS_STR("Bool String False"), SLS_STR("\"false\"")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_string_value(&test, result, i++, &SLS_STR("false"))) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_Yes() { + LexerTest test = start_up_test(SLS_STR("Bool Yes"), SLS_STR("yes")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("yes")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_No() { + LexerTest test = start_up_test(SLS_STR("Bool No"), SLS_STR("no")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("no")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_Typo_Ture() { + LexerTest test = start_up_test(SLS_STR("Bool Typo Ture"), SLS_STR("ture")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("ture")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_Typo_Flase() { + LexerTest test = start_up_test(SLS_STR("Bool Typo Flase"), SLS_STR("flase")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("flase")})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_Multiple_True_False() { + LexerTest test = start_up_test(SLS_STR("Bool Multiple True False"), SLS_STR("true false")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result; + if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_Multiple_Same() { + LexerTest test = start_up_test(SLS_STR("Bool Multiple Same"), SLS_STR("true true")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result; + if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Bool_Three_Values() { + LexerTest test = start_up_test(SLS_STR("Bool Three Values"), SLS_STR("true false true")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result; + if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result; + if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + TestsReport run_lexer_tests() { TestsReport test_report = (TestsReport) { .section = SLS_STR("lexer_tests"), @@ -2632,12 +3750,12 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_Char_Right_Bracket(); test_report.tests[i++] = test_Char_Left_Brace(); test_report.tests[i++] = test_Char_Right_Brace(); - test_report.tests[i++] = test_Char_Escape_Single_quote(); - test_report.tests[i++] = test_Char_Escape_Tab(); test_report.tests[i++] = test_Char_Escape_Carriage_return(); + test_report.tests[i++] = test_Char_Escape_Tab(); + test_report.tests[i++] = test_Char_Escape_Null_character(); + test_report.tests[i++] = test_Char_Escape_Single_quote(); test_report.tests[i++] = test_Char_Escape_Backslash(); test_report.tests[i++] = test_Char_Escape_Newline(); - test_report.tests[i++] = test_Char_Escape_Null_character(); test_report.tests[i++] = test_Char_Hex_Lowercase_A(); test_report.tests[i++] = test_Char_Hex_Uppercase_A(); test_report.tests[i++] = test_Char_Hex_Space(); @@ -2667,6 +3785,119 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_Char_Hex_Digits_Uppercase(); test_report.tests[i++] = test_Char_Hex_Digits_Lowercase(); test_report.tests[i++] = test_Char_Hex_Digits_Mixed(); + test_report.tests[i++] = test_Identifier_Simple_Lowercase(); + test_report.tests[i++] = test_Identifier_Simple_Uppercase(); + test_report.tests[i++] = test_Identifier_Mixed_Case(); + test_report.tests[i++] = test_Identifier_Single_Letter(); + test_report.tests[i++] = test_Identifier_Single_Letter_Upper(); + test_report.tests[i++] = test_Identifier_With_Numbers(); + test_report.tests[i++] = test_Identifier_Numbers_End(); + test_report.tests[i++] = test_Identifier_Mixed_Numbers(); + test_report.tests[i++] = test_Identifier_With_Underscore(); + test_report.tests[i++] = test_Identifier_Leading_Underscore(); + test_report.tests[i++] = test_Identifier_Multiple_Underscores(); + test_report.tests[i++] = test_Identifier_Double_Underscore(); + test_report.tests[i++] = test_Identifier_Trailing_Underscore(); + test_report.tests[i++] = test_Identifier_Only_Underscores(); + test_report.tests[i++] = test_Identifier_Snake_Case(); + test_report.tests[i++] = test_Identifier_Camel_Case(); + test_report.tests[i++] = test_Identifier_Pascal_Case(); + test_report.tests[i++] = test_Identifier_All_Caps(); + test_report.tests[i++] = test_Identifier_With_Dash(); + test_report.tests[i++] = test_Identifier_Literal_Simple(); + test_report.tests[i++] = test_Identifier_Literal_Uppercase(); + test_report.tests[i++] = test_Identifier_Literal_Snake_Case(); + test_report.tests[i++] = test_Identifier_Literal_Type_i64(); + test_report.tests[i++] = test_Identifier_Literal_Type_String(); + test_report.tests[i++] = test_Identifier_Literal_Type_Point(); + test_report.tests[i++] = test_Identifier_Literal_Trait_Addable(); + test_report.tests[i++] = test_Identifier_Literal_Trait_Drawable(); + test_report.tests[i++] = test_Identifier_Literal_Field_x(); + test_report.tests[i++] = test_Identifier_Literal_Field_width(); + test_report.tests[i++] = test_Identifier_Literal_With_Underscore(); + test_report.tests[i++] = test_Identifier_Literal_Multiple_Underscores(); + test_report.tests[i++] = test_Identifier_Literal_With_Numbers(); + test_report.tests[i++] = test_Identifier_Leading_Whitespace(); + test_report.tests[i++] = test_Identifier_Trailing_Whitespace(); + test_report.tests[i++] = test_Identifier_Both_Whitespace(); + test_report.tests[i++] = test_Identifier_Tab_Before(); + test_report.tests[i++] = test_Identifier_Literal_Leading_Whitespace(); + test_report.tests[i++] = test_Identifier_Literal_Trailing_Whitespace(); + test_report.tests[i++] = test_Identifier_Literal_Both_Whitespace(); + test_report.tests[i++] = test_Identifier_Moderate_Length(); + test_report.tests[i++] = test_Identifier_Very_Long(); + test_report.tests[i++] = test_Identifier_Long_With_Numbers(); + test_report.tests[i++] = test_Identifier_Starting_With_Number(); + test_report.tests[i++] = test_Identifier_With_Hash(); + test_report.tests[i++] = test_Identifier_With_Dot(); + test_report.tests[i++] = test_Identifier_With_Space(); + test_report.tests[i++] = test_Identifier_With_Colon(); + test_report.tests[i++] = test_Identifier_Double_Colon_Inside(); + test_report.tests[i++] = test_Identifier_With_At(); + test_report.tests[i++] = test_Identifier_With_Dollar(); + test_report.tests[i++] = test_Identifier_With_Percent(); + test_report.tests[i++] = test_Identifier_With_Brackets(); + test_report.tests[i++] = test_Identifier_With_Braces(); + test_report.tests[i++] = test_Identifier_With_Parens(); + test_report.tests[i++] = test_Identifier_With_Single_Quote(); + test_report.tests[i++] = test_Identifier_With_Double_Quote(); + test_report.tests[i++] = test_Identifier_Only_Numbers(); + test_report.tests[i++] = test_Identifier_Literal_Empty(); + test_report.tests[i++] = test_Identifier_Case_Lower(); + test_report.tests[i++] = test_Identifier_Case_Upper(); + test_report.tests[i++] = test_Identifier_Case_Mixed(); + test_report.tests[i++] = test_Identifier_Case_Camel(); + test_report.tests[i++] = test_Identifier_Case_Pascal(); + test_report.tests[i++] = test_Identifier_Reserved_Word_true(); + test_report.tests[i++] = test_Identifier_Reserved_Word_false(); + test_report.tests[i++] = test_Identifier_Reserved_Word_if(); + test_report.tests[i++] = test_Identifier_Reserved_Word_while(); + test_report.tests[i++] = test_Identifier_Reserved_Word_for(); + test_report.tests[i++] = test_Identifier_Reserved_Word_match(); + test_report.tests[i++] = test_Identifier_Reserved_Word_break(); + test_report.tests[i++] = test_Identifier_Reserved_Word_continue(); + test_report.tests[i++] = test_Identifier_Reserved_Word_fn(); + test_report.tests[i++] = test_Identifier_Reserved_Word_struct(); + test_report.tests[i++] = test_Identifier_Reserved_Word_union(); + test_report.tests[i++] = test_Identifier_Reserved_Word_enum(); + test_report.tests[i++] = test_Identifier_Reserved_Word_trait(); + test_report.tests[i++] = test_Identifier_Reserved_Word_impl(); + test_report.tests[i++] = test_Identifier_Reserved_Word_inher(); + test_report.tests[i++] = test_Identifier_Reserved_Word_dup(); + test_report.tests[i++] = test_Identifier_Reserved_Word_drop(); + test_report.tests[i++] = test_Identifier_Reserved_Word_swap(); + test_report.tests[i++] = test_Identifier_Reserved_Word_over(); + test_report.tests[i++] = test_Identifier_Reserved_Word_rot(); + test_report.tests[i++] = test_Identifier_Reserved_Word_pick(); + test_report.tests[i++] = test_Identifier_Reserved_Word_roll(); + test_report.tests[i++] = test_Identifier_Reserved_Word_depth(); + test_report.tests[i++] = test_Bool_True(); + test_report.tests[i++] = test_Bool_False(); + test_report.tests[i++] = test_Bool_True_Leading_Whitespace(); + test_report.tests[i++] = test_Bool_True_Trailing_Whitespace(); + test_report.tests[i++] = test_Bool_True_Both_Whitespace(); + test_report.tests[i++] = test_Bool_True_Tab_Before(); + test_report.tests[i++] = test_Bool_False_Leading_Whitespace(); + test_report.tests[i++] = test_Bool_False_Trailing_Whitespace(); + test_report.tests[i++] = test_Bool_False_Both_Whitespace(); + test_report.tests[i++] = test_Bool_False_Tab_Before(); + test_report.tests[i++] = test_Bool_True_Capitalized(); + test_report.tests[i++] = test_Bool_False_Capitalized(); + test_report.tests[i++] = test_Bool_True_All_Caps(); + test_report.tests[i++] = test_Bool_False_All_Caps(); + test_report.tests[i++] = test_Bool_True_Mixed_Case(); + test_report.tests[i++] = test_Bool_False_Mixed_Case(); + test_report.tests[i++] = test_Bool_Numeric_1(); + test_report.tests[i++] = test_Bool_Numeric_0(); + test_report.tests[i++] = test_Bool_String_True(); + test_report.tests[i++] = test_Bool_String_False(); + test_report.tests[i++] = test_Bool_Yes(); + test_report.tests[i++] = test_Bool_No(); + test_report.tests[i++] = test_Bool_Typo_Ture(); + test_report.tests[i++] = test_Bool_Typo_Flase(); + test_report.tests[i++] = test_Bool_Multiple_True_False(); + test_report.tests[i++] = test_Bool_Multiple_Same(); + test_report.tests[i++] = test_Bool_Three_Values(); return test_report; } diff --git a/SLS_Tests/cases.yaml b/SLS_Tests/cases.yaml index d6b6c97..aa9f029 100644 --- a/SLS_Tests/cases.yaml +++ b/SLS_Tests/cases.yaml @@ -2317,30 +2317,6 @@ stack_final: - type: char value: '}' -- name: Char Escape Single quote - code: '''\\''''' - tokens: - - type: char - value: '''' - operations: - - function: push - type: char - value: '''' - stack_final: - - type: char - value: '''' -- name: Char Escape Tab - code: '''\\t''' - tokens: - - type: char - value: "\t" - operations: - - function: push - type: char - value: "\t" - stack_final: - - type: char - value: "\t" - name: Char Escape Carriage return code: '''\\r''' tokens: @@ -2353,6 +2329,42 @@ stack_final: - type: char value: "\r" +- name: Char Escape Tab + code: '''\\t''' + tokens: + - type: char + value: "\t" + operations: + - function: push + type: char + value: "\t" + stack_final: + - type: char + value: "\t" +- name: Char Escape Null character + code: '''\\0''' + tokens: + - type: char + value: "\0" + operations: + - function: push + type: char + value: "\0" + stack_final: + - type: char + value: "\0" +- name: Char Escape Single quote + code: '''\\''''' + tokens: + - type: char + value: '''' + operations: + - function: push + type: char + value: '''' + stack_final: + - type: char + value: '''' - name: Char Escape Backslash code: '''\\\\''' tokens: @@ -2383,18 +2395,6 @@ value: ' ' -- name: Char Escape Null character - code: '''\\0''' - tokens: - - type: char - value: "\0" - operations: - - function: push - type: char - value: "\0" - stack_final: - - type: char - value: "\0" - name: Char Hex Lowercase A code: '''\\x61''' tokens: @@ -2693,3 +2693,1275 @@ stack_final: - type: char value: "\xAB" +- name: Identifier Simple Lowercase + code: hello + tokens: + - type: identifier + value: hello + operations: + - function: push + type: identifier + value: hello + stack_final: + - type: identifier + value: hello +- name: Identifier Simple Uppercase + code: HELLO + tokens: + - type: identifier + value: HELLO + operations: + - function: push + type: identifier + value: HELLO + stack_final: + - type: identifier + value: HELLO +- name: Identifier Mixed Case + code: HelloWorld + tokens: + - type: identifier + value: HelloWorld + operations: + - function: push + type: identifier + value: HelloWorld + stack_final: + - type: identifier + value: HelloWorld +- name: Identifier Single Letter + code: x + tokens: + - type: identifier + value: x + operations: + - function: push + type: identifier + value: x + stack_final: + - type: identifier + value: x +- name: Identifier Single Letter Upper + code: X + tokens: + - type: identifier + value: X + operations: + - function: push + type: identifier + value: X + stack_final: + - type: identifier + value: X +- name: Identifier With Numbers + code: var123 + tokens: + - type: identifier + value: var123 + operations: + - function: push + type: identifier + value: var123 + stack_final: + - type: identifier + value: var123 +- name: Identifier Numbers End + code: myVar2 + tokens: + - type: identifier + value: myVar2 + operations: + - function: push + type: identifier + value: myVar2 + stack_final: + - type: identifier + value: myVar2 +- name: Identifier Mixed Numbers + code: a1b2c3 + tokens: + - type: identifier + value: a1b2c3 + operations: + - function: push + type: identifier + value: a1b2c3 + stack_final: + - type: identifier + value: a1b2c3 +- name: Identifier With Underscore + code: hello_world + tokens: + - type: identifier + value: hello_world + operations: + - function: push + type: identifier + value: hello_world + stack_final: + - type: identifier + value: hello_world +- name: Identifier Leading Underscore + code: _private + tokens: + - type: identifier + value: _private + operations: + - function: push + type: identifier + value: _private + stack_final: + - type: identifier + value: _private +- name: Identifier Multiple Underscores + code: my_long_var_name + tokens: + - type: identifier + value: my_long_var_name + operations: + - function: push + type: identifier + value: my_long_var_name + stack_final: + - type: identifier + value: my_long_var_name +- name: Identifier Double Underscore + code: my__var + tokens: + - type: identifier + value: my__var + operations: + - function: push + type: identifier + value: my__var + stack_final: + - type: identifier + value: my__var +- name: Identifier Trailing Underscore + code: var_ + tokens: + - type: identifier + value: var_ + operations: + - function: push + type: identifier + value: var_ + stack_final: + - type: identifier + value: var_ +- name: Identifier Only Underscores + code: ___ + tokens: + - type: identifier + value: ___ + operations: + - function: push + type: identifier + value: ___ + stack_final: + - type: identifier + value: ___ +- name: Identifier Snake Case + code: my_variable_name + tokens: + - type: identifier + value: my_variable_name + operations: + - function: push + type: identifier + value: my_variable_name + stack_final: + - type: identifier + value: my_variable_name +- name: Identifier Camel Case + code: myVariableName + tokens: + - type: identifier + value: myVariableName + operations: + - function: push + type: identifier + value: myVariableName + stack_final: + - type: identifier + value: myVariableName +- name: Identifier Pascal Case + code: MyClassName + tokens: + - type: identifier + value: MyClassName + operations: + - function: push + type: identifier + value: MyClassName + stack_final: + - type: identifier + value: MyClassName +- name: Identifier All Caps + code: MY_CONSTANT + tokens: + - type: identifier + value: MY_CONSTANT + operations: + - function: push + type: identifier + value: MY_CONSTANT + stack_final: + - type: identifier + value: MY_CONSTANT +- name: Identifier With Dash + code: my-var + tokens: + - type: identifier_literal + value: my-var + operations: + - function: push + type: identifier_literal + value: my-var + stack_final: + - type: identifier_literal + value: my-var +- name: Identifier Literal Simple + code: ::hello + tokens: + - type: identifier_literal + value: hello + operations: + - function: push + type: identifier_literal + value: hello + stack_final: + - type: identifier_literal + value: hello +- name: Identifier Literal Uppercase + code: ::Point + tokens: + - type: identifier_literal + value: Point + operations: + - function: push + type: identifier_literal + value: Point + stack_final: + - type: identifier_literal + value: Point +- name: Identifier Literal Snake Case + code: ::my_var + tokens: + - type: identifier_literal + value: my_var + operations: + - function: push + type: identifier_literal + value: my_var + stack_final: + - type: identifier_literal + value: my_var +- name: Identifier Literal Type i64 + code: ::i64 + tokens: + - type: identifier_literal + value: i64 + operations: + - function: push + type: identifier_literal + value: i64 + stack_final: + - type: identifier_literal + value: i64 +- name: Identifier Literal Type String + code: ::String + tokens: + - type: identifier_literal + value: String + operations: + - function: push + type: identifier_literal + value: String + stack_final: + - type: identifier_literal + value: String +- name: Identifier Literal Type Point + code: ::Point + tokens: + - type: identifier_literal + value: Point + operations: + - function: push + type: identifier_literal + value: Point + stack_final: + - type: identifier_literal + value: Point +- name: Identifier Literal Trait Addable + code: ::Addable + tokens: + - type: identifier_literal + value: Addable + operations: + - function: push + type: identifier_literal + value: Addable + stack_final: + - type: identifier_literal + value: Addable +- name: Identifier Literal Trait Drawable + code: ::Drawable + tokens: + - type: identifier_literal + value: Drawable + operations: + - function: push + type: identifier_literal + value: Drawable + stack_final: + - type: identifier_literal + value: Drawable +- name: Identifier Literal Field x + code: ::x + tokens: + - type: identifier_literal + value: x + operations: + - function: push + type: identifier_literal + value: x + stack_final: + - type: identifier_literal + value: x +- name: Identifier Literal Field width + code: ::width + tokens: + - type: identifier_literal + value: width + operations: + - function: push + type: identifier_literal + value: width + stack_final: + - type: identifier_literal + value: width +- name: Identifier Literal With Underscore + code: ::_private + tokens: + - type: identifier_literal + value: _private + operations: + - function: push + type: identifier_literal + value: _private + stack_final: + - type: identifier_literal + value: _private +- name: Identifier Literal Multiple Underscores + code: ::my_long_name + tokens: + - type: identifier_literal + value: my_long_name + operations: + - function: push + type: identifier_literal + value: my_long_name + stack_final: + - type: identifier_literal + value: my_long_name +- name: Identifier Literal With Numbers + code: ::var123 + tokens: + - type: identifier_literal + value: var123 + operations: + - function: push + type: identifier_literal + value: var123 + stack_final: + - type: identifier_literal + value: var123 +- name: Identifier Leading Whitespace + code: ' hello' + tokens: + - type: identifier + value: hello + operations: + - function: push + type: identifier + value: hello + stack_final: + - type: identifier + value: hello +- name: Identifier Trailing Whitespace + code: 'hello ' + tokens: + - type: identifier + value: hello + operations: + - function: push + type: identifier + value: hello + stack_final: + - type: identifier + value: hello +- name: Identifier Both Whitespace + code: ' hello ' + tokens: + - type: identifier + value: hello + operations: + - function: push + type: identifier + value: hello + stack_final: + - type: identifier + value: hello +- name: Identifier Tab Before + code: \thello + tokens: + - type: identifier + value: hello + operations: + - function: push + type: identifier + value: hello + stack_final: + - type: identifier + value: hello +- name: Identifier Literal Leading Whitespace + code: ' ::hello' + tokens: + - type: identifier_literal + value: hello + operations: + - function: push + type: identifier_literal + value: hello + stack_final: + - type: identifier_literal + value: hello +- name: Identifier Literal Trailing Whitespace + code: '::hello ' + tokens: + - type: identifier_literal + value: hello + operations: + - function: push + type: identifier_literal + value: hello + stack_final: + - type: identifier_literal + value: hello +- name: Identifier Literal Both Whitespace + code: ' ::hello ' + tokens: + - type: identifier_literal + value: hello + operations: + - function: push + type: identifier_literal + value: hello + stack_final: + - type: identifier_literal + value: hello +- name: Identifier Moderate Length + code: thisIsAReasonablyLongVariableName + tokens: + - type: identifier + value: thisIsAReasonablyLongVariableName + operations: + - function: push + type: identifier + value: thisIsAReasonablyLongVariableName + stack_final: + - type: identifier + value: thisIsAReasonablyLongVariableName +- name: Identifier Very Long + code: this_is_a_very_long_identifier_name_that_someone_might_use_for_some_reason + tokens: + - type: identifier + value: this_is_a_very_long_identifier_name_that_someone_might_use_for_some_reason + operations: + - function: push + type: identifier + value: this_is_a_very_long_identifier_name_that_someone_might_use_for_some_reason + stack_final: + - type: identifier + value: this_is_a_very_long_identifier_name_that_someone_might_use_for_some_reason +- name: Identifier Long With Numbers + code: variable_with_many_numbers_123_456_789_000 + tokens: + - type: identifier + value: variable_with_many_numbers_123_456_789_000 + operations: + - function: push + type: identifier + value: variable_with_many_numbers_123_456_789_000 + stack_final: + - type: identifier + value: variable_with_many_numbers_123_456_789_000 +- name: Identifier Starting With Number + code: 123abc + tokens: + - type: error + value: 'Invalid decimal literal: unexpected ''a'' in decimal integer.' +- name: Identifier With Hash + code: my#var + tokens: + - type: error + value: 'Invalid identifier: ''#'' is not allowed in identifiers.' +- name: Identifier With Dot + code: my.var + tokens: + - type: error + value: 'Invalid identifier: ''.'' is not allowed in identifiers.' +- name: Identifier With Space + code: my var + tokens: + - type: error + value: 'Invalid identifier: whitespace not allowed in identifiers.' +- name: Identifier With Colon + code: my:var + tokens: + - type: error + value: 'Invalid identifier: '':'' is not allowed in identifiers.' +- name: Identifier Double Colon Inside + code: my::var + tokens: + - type: error + value: 'Invalid identifier: ''::'' only allowed as prefix for identifier literals.' +- name: Identifier With At + code: '@variable' + tokens: + - type: error + value: 'Invalid identifier: ''@'' is not allowed in identifiers.' +- name: Identifier With Dollar + code: $variable + tokens: + - type: error + value: 'Invalid identifier: ''$'' is not allowed in identifiers.' +- name: Identifier With Percent + code: '%variable' + tokens: + - type: error + value: 'Invalid identifier: ''%'' is not allowed in identifiers.' +- name: Identifier With Brackets + code: my[var] + tokens: + - type: error + value: 'Invalid identifier: brackets not allowed in identifiers.' +- name: Identifier With Braces + code: my{var} + tokens: + - type: error + value: 'Invalid identifier: braces not allowed in identifiers.' +- name: Identifier With Parens + code: my(var) + tokens: + - type: error + value: 'Invalid identifier: parentheses not allowed in identifiers.' +- name: Identifier With Single Quote + code: my'var + tokens: + - type: error + value: 'Invalid identifier: quotes not allowed in identifiers.' +- name: Identifier With Double Quote + code: my"var + tokens: + - type: error + value: 'Invalid identifier: quotes not allowed in identifiers.' +- name: Identifier Only Numbers + code: '123' + tokens: + - type: error + value: 'Not an identifier: numeric literal.' +- name: Identifier Literal Empty + code: '::' + tokens: + - type: error + value: 'Invalid identifier literal: empty identifier after ''::''.' +- name: Identifier Case Lower + code: variable + tokens: + - type: identifier + value: variable + operations: + - function: push + type: identifier + value: variable + stack_final: + - type: identifier + value: variable +- name: Identifier Case Upper + code: VARIABLE + tokens: + - type: identifier + value: VARIABLE + operations: + - function: push + type: identifier + value: VARIABLE + stack_final: + - type: identifier + value: VARIABLE +- name: Identifier Case Mixed + code: Variable + tokens: + - type: identifier + value: Variable + operations: + - function: push + type: identifier + value: Variable + stack_final: + - type: identifier + value: Variable +- name: Identifier Case Camel + code: variableName + tokens: + - type: identifier + value: variableName + operations: + - function: push + type: identifier + value: variableName + stack_final: + - type: identifier + value: variableName +- name: Identifier Case Pascal + code: VariableName + tokens: + - type: identifier + value: VariableName + operations: + - function: push + type: identifier + value: VariableName + stack_final: + - type: identifier + value: VariableName +- name: Identifier Reserved Word true + code: 'true' + tokens: + - type: identifier + value: 'true' + operations: + - function: push + type: identifier + value: 'true' + stack_final: + - type: identifier + value: 'true' +- name: Identifier Reserved Word false + code: 'false' + tokens: + - type: identifier + value: 'false' + operations: + - function: push + type: identifier + value: 'false' + stack_final: + - type: identifier + value: 'false' +- name: Identifier Reserved Word if + code: if + tokens: + - type: identifier + value: if + operations: + - function: push + type: identifier + value: if + stack_final: + - type: identifier + value: if +- name: Identifier Reserved Word while + code: while + tokens: + - type: identifier + value: while + operations: + - function: push + type: identifier + value: while + stack_final: + - type: identifier + value: while +- name: Identifier Reserved Word for + code: for + tokens: + - type: identifier + value: for + operations: + - function: push + type: identifier + value: for + stack_final: + - type: identifier + value: for +- name: Identifier Reserved Word match + code: match + tokens: + - type: identifier + value: match + operations: + - function: push + type: identifier + value: match + stack_final: + - type: identifier + value: match +- name: Identifier Reserved Word break + code: break + tokens: + - type: identifier + value: break + operations: + - function: push + type: identifier + value: break + stack_final: + - type: identifier + value: break +- name: Identifier Reserved Word continue + code: continue + tokens: + - type: identifier + value: continue + operations: + - function: push + type: identifier + value: continue + stack_final: + - type: identifier + value: continue +- name: Identifier Reserved Word fn + code: fn + tokens: + - type: identifier + value: fn + operations: + - function: push + type: identifier + value: fn + stack_final: + - type: identifier + value: fn +- name: Identifier Reserved Word struct + code: struct + tokens: + - type: identifier + value: struct + operations: + - function: push + type: identifier + value: struct + stack_final: + - type: identifier + value: struct +- name: Identifier Reserved Word union + code: union + tokens: + - type: identifier + value: union + operations: + - function: push + type: identifier + value: union + stack_final: + - type: identifier + value: union +- name: Identifier Reserved Word enum + code: enum + tokens: + - type: identifier + value: enum + operations: + - function: push + type: identifier + value: enum + stack_final: + - type: identifier + value: enum +- name: Identifier Reserved Word trait + code: trait + tokens: + - type: identifier + value: trait + operations: + - function: push + type: identifier + value: trait + stack_final: + - type: identifier + value: trait +- name: Identifier Reserved Word impl + code: impl + tokens: + - type: identifier + value: impl + operations: + - function: push + type: identifier + value: impl + stack_final: + - type: identifier + value: impl +- name: Identifier Reserved Word inher + code: inher + tokens: + - type: identifier + value: inher + operations: + - function: push + type: identifier + value: inher + stack_final: + - type: identifier + value: inher +- name: Identifier Reserved Word dup + code: dup + tokens: + - type: identifier + value: dup + operations: + - function: push + type: identifier + value: dup + stack_final: + - type: identifier + value: dup +- name: Identifier Reserved Word drop + code: drop + tokens: + - type: identifier + value: drop + operations: + - function: push + type: identifier + value: drop + stack_final: + - type: identifier + value: drop +- name: Identifier Reserved Word swap + code: swap + tokens: + - type: identifier + value: swap + operations: + - function: push + type: identifier + value: swap + stack_final: + - type: identifier + value: swap +- name: Identifier Reserved Word over + code: over + tokens: + - type: identifier + value: over + operations: + - function: push + type: identifier + value: over + stack_final: + - type: identifier + value: over +- name: Identifier Reserved Word rot + code: rot + tokens: + - type: identifier + value: rot + operations: + - function: push + type: identifier + value: rot + stack_final: + - type: identifier + value: rot +- name: Identifier Reserved Word pick + code: pick + tokens: + - type: identifier + value: pick + operations: + - function: push + type: identifier + value: pick + stack_final: + - type: identifier + value: pick +- name: Identifier Reserved Word roll + code: roll + tokens: + - type: identifier + value: roll + operations: + - function: push + type: identifier + value: roll + stack_final: + - type: identifier + value: roll +- name: Identifier Reserved Word depth + code: depth + tokens: + - type: identifier + value: depth + operations: + - function: push + type: identifier + value: depth + stack_final: + - type: identifier + value: depth +- name: Bool True + code: 'true' + tokens: + - type: bool + value: true + operations: + - function: push + type: bool + value: true + stack_final: + - type: bool + value: true +- name: Bool False + code: 'false' + tokens: + - type: bool + value: false + operations: + - function: push + type: bool + value: false + stack_final: + - type: bool + value: false +- name: Bool True Leading Whitespace + code: ' true' + tokens: + - type: bool + value: true + operations: + - function: push + type: bool + value: true + stack_final: + - type: bool + value: true +- name: Bool True Trailing Whitespace + code: 'true ' + tokens: + - type: bool + value: true + operations: + - function: push + type: bool + value: true + stack_final: + - type: bool + value: true +- name: Bool True Both Whitespace + code: ' true ' + tokens: + - type: bool + value: true + operations: + - function: push + type: bool + value: true + stack_final: + - type: bool + value: true +- name: Bool True Tab Before + code: \ttrue + tokens: + - type: bool + value: true + operations: + - function: push + type: bool + value: true + stack_final: + - type: bool + value: true +- name: Bool False Leading Whitespace + code: ' false' + tokens: + - type: bool + value: false + operations: + - function: push + type: bool + value: false + stack_final: + - type: bool + value: false +- name: Bool False Trailing Whitespace + code: 'false ' + tokens: + - type: bool + value: false + operations: + - function: push + type: bool + value: false + stack_final: + - type: bool + value: false +- name: Bool False Both Whitespace + code: ' false ' + tokens: + - type: bool + value: false + operations: + - function: push + type: bool + value: false + stack_final: + - type: bool + value: false +- name: Bool False Tab Before + code: \tfalse + tokens: + - type: bool + value: false + operations: + - function: push + type: bool + value: false + stack_final: + - type: bool + value: false +- name: Bool True Capitalized + code: 'True' + tokens: + - type: identifier + value: 'True' + operations: + - function: push + type: identifier + value: 'True' + stack_final: + - type: identifier + value: 'True' +- name: Bool False Capitalized + code: 'False' + tokens: + - type: identifier + value: 'False' + operations: + - function: push + type: identifier + value: 'False' + stack_final: + - type: identifier + value: 'False' +- name: Bool True All Caps + code: 'TRUE' + tokens: + - type: identifier + value: 'TRUE' + operations: + - function: push + type: identifier + value: 'TRUE' + stack_final: + - type: identifier + value: 'TRUE' +- name: Bool False All Caps + code: 'FALSE' + tokens: + - type: identifier + value: 'FALSE' + operations: + - function: push + type: identifier + value: 'FALSE' + stack_final: + - type: identifier + value: 'FALSE' +- name: Bool True Mixed Case + code: tRuE + tokens: + - type: identifier + value: tRuE + operations: + - function: push + type: identifier + value: tRuE + stack_final: + - type: identifier + value: tRuE +- name: Bool False Mixed Case + code: fAlSe + tokens: + - type: identifier + value: fAlSe + operations: + - function: push + type: identifier + value: fAlSe + stack_final: + - type: identifier + value: fAlSe +- name: Bool Numeric 1 + code: '1' + tokens: + - type: i64 + value: 1 + operations: + - function: push + type: i64 + value: 1 + stack_final: + - type: i64 + value: 1 +- name: Bool Numeric 0 + code: '0' + tokens: + - type: i64 + value: 0 + operations: + - function: push + type: i64 + value: 0 + stack_final: + - type: i64 + value: 0 +- name: Bool String True + code: '"true"' + tokens: + - type: string + value: 'true' + operations: + - function: push + type: string + value: 'true' + stack_final: + - type: string + value: 'true' +- name: Bool String False + code: '"false"' + tokens: + - type: string + value: 'false' + operations: + - function: push + type: string + value: 'false' + stack_final: + - type: string + value: 'false' +- name: Bool Yes + code: 'yes' + tokens: + - type: identifier + value: 'yes' + operations: + - function: push + type: identifier + value: 'yes' + stack_final: + - type: identifier + value: 'yes' +- name: Bool No + code: 'no' + tokens: + - type: identifier + value: 'no' + operations: + - function: push + type: identifier + value: 'no' + stack_final: + - type: identifier + value: 'no' +- name: Bool Typo Ture + code: ture + tokens: + - type: identifier + value: ture + operations: + - function: push + type: identifier + value: ture + stack_final: + - type: identifier + value: ture +- name: Bool Typo Flase + code: flase + tokens: + - type: identifier + value: flase + operations: + - function: push + type: identifier + value: flase + stack_final: + - type: identifier + value: flase +- name: Bool Multiple True False + code: true false + tokens: + - type: bool + value: true + - type: bool + value: false + operations: + - function: push + type: bool + value: true + - function: push + type: bool + value: false + stack_final: + - type: bool + value: true + - type: bool + value: false +- name: Bool Multiple Same + code: true true + tokens: + - type: bool + value: true + - type: bool + value: true + operations: + - function: push + type: bool + value: true + - function: push + type: bool + value: true + stack_final: + - type: bool + value: true + - type: bool + value: true +- name: Bool Three Values + code: true false true + tokens: + - type: bool + value: true + - type: bool + value: false + - type: bool + value: true + operations: + - function: push + type: bool + value: true + - function: push + type: bool + value: false + - function: push + type: bool + value: true + stack_final: + - type: bool + value: true + - type: bool + value: false + - type: bool + value: true diff --git a/SLS_Tests/generate_tests/idents_and_bools_tests.py b/SLS_Tests/generate_tests/idents_and_bools_tests.py index 36db72d..6082457 100644 --- a/SLS_Tests/generate_tests/idents_and_bools_tests.py +++ b/SLS_Tests/generate_tests/idents_and_bools_tests.py @@ -63,6 +63,10 @@ class IdentifierTestGenerator(BaseTestGenerator): # All caps with underscores self.make_success_test("Identifier All Caps", "MY_CONSTANT", "identifier", "MY_CONSTANT") + + # Others + self.make_success_test("Identifier With Dash", "my-var", + "identifier_literal", "my-var") def generate_identifier_literal_tests(self): """Generate identifier literal tests (with :: prefix).""" @@ -113,7 +117,7 @@ class IdentifierTestGenerator(BaseTestGenerator): "identifier", "hello") self.make_success_test("Identifier Both Whitespace", " hello ", "identifier", "hello") - self.make_success_test("Identifier Tab Before", "\thello", + self.make_success_test("Identifier Tab Before", "\\thello", "identifier", "hello") # Identifier literals with whitespace @@ -146,17 +150,13 @@ class IdentifierTestGenerator(BaseTestGenerator): # Starting with number self.make_error_test("Identifier Starting With Number", "123abc", - "Invalid identifier: cannot start with digit.") + "Invalid decimal literal: unexpected 'a' in decimal integer.") # Invalid characters self.make_error_test("Identifier With Hash", "my#var", "Invalid identifier: '#' is not allowed in identifiers.") - self.make_error_test("Identifier With Dash", - "my-var", - "Invalid identifier: '-' is not allowed in identifiers.") - self.make_error_test("Identifier With Dot", "my.var", "Invalid identifier: '.' is not allowed in identifiers.") @@ -287,7 +287,7 @@ class BooleanTestGenerator(BaseTestGenerator): "bool", True) self.make_success_test("Bool True Both Whitespace", " true ", "bool", True) - self.make_success_test("Bool True Tab Before", "\ttrue", + self.make_success_test("Bool True Tab Before", "\\ttrue", "bool", True) # False with whitespace @@ -297,73 +297,57 @@ class BooleanTestGenerator(BaseTestGenerator): "bool", False) self.make_success_test("Bool False Both Whitespace", " false ", "bool", False) - self.make_success_test("Bool False Tab Before", "\tfalse", + self.make_success_test("Bool False Tab Before", "\\tfalse", "bool", False) def generate_error_tests(self): """Generate error test cases for booleans.""" # Capitalized (case sensitive) - self.make_error_test("Bool True Capitalized", - "True", - "Invalid boolean: 'True' is not a boolean literal (use lowercase 'true').") + self.make_success_test("Bool True Capitalized", "True", + "identifier", "True") - self.make_error_test("Bool False Capitalized", - "False", - "Invalid boolean: 'False' is not a boolean literal (use lowercase 'false').") + self.make_success_test("Bool False Capitalized", "False", + "identifier", "False") # All caps - self.make_error_test("Bool True All Caps", - "TRUE", - "Invalid boolean: 'TRUE' is not a boolean literal (use lowercase 'true').") + self.make_success_test("Bool True All Caps", "TRUE", + "identifier", "TRUE") - self.make_error_test("Bool False All Caps", - "FALSE", - "Invalid boolean: 'FALSE' is not a boolean literal (use lowercase 'false').") + self.make_success_test("Bool False All Caps", "FALSE", + "identifier", "FALSE") # Mixed case - self.make_error_test("Bool True Mixed Case", - "tRuE", - "Invalid boolean: 'tRuE' is not a boolean literal (use lowercase 'true').") + self.make_success_test("Bool True Mixed Case", "tRuE", + "identifier", "tRuE") - self.make_error_test("Bool False Mixed Case", - "fAlSe", - "Invalid boolean: 'fAlSe' is not a boolean literal (use lowercase 'false').") + self.make_success_test("Bool False Mixed Case", "fAlSe", + "identifier", "fAlSe") # Numeric representations - self.make_error_test("Bool Numeric 1", - "1", - "Not a boolean: numeric literal.") + self.make_success_test("Bool Numeric 1", "1", "i64", 1) - self.make_error_test("Bool Numeric 0", - "0", - "Not a boolean: numeric literal.") + self.make_success_test("Bool Numeric 0", "0", "i64", 0) # String representations - self.make_error_test("Bool String True", - '"true"', - "Not a boolean: string literal.") + self.make_success_test("Bool String True", '"true"', + "string", "true") - self.make_error_test("Bool String False", - '"false"', - "Not a boolean: string literal.") + self.make_success_test("Bool String False", '"false"', + "string", "false") # Other languages - self.make_error_test("Bool Yes", - "yes", - "Invalid boolean: 'yes' is not a boolean literal.") + self.make_success_test("Bool Yes", "yes", + "identifier", "yes") - self.make_error_test("Bool No", - "no", - "Invalid boolean: 'no' is not a boolean literal.") + self.make_success_test("Bool No", "no", + "identifier", "no") # Typos - self.make_error_test("Bool Typo Ture", - "ture", - "Invalid boolean: 'ture' is not a boolean literal.") + self.make_success_test("Bool Typo Ture", "ture", + "identifier", "ture") - self.make_error_test("Bool Typo Flase", - "flase", - "Invalid boolean: 'flase' is not a boolean literal.") + self.make_success_test("Bool Typo Flase", "flase", + "identifier", "flase") def generate_multiple_bool_tests(self): """Generate tests with multiple boolean values."""