From 74d53b3a8d4271647d9331395a8ac4506bdb19f2 Mon Sep 17 00:00:00 2001 From: Kyler Date: Sun, 16 Nov 2025 20:55:59 -0700 Subject: [PATCH] Got all current tests compile now --- SLS_C/tests/lexer_tests.c | 1264 +++++++++++++++++++++++++++++++++- SLS_Tests/cases.yaml | 1221 +++++++++++++++++++++++++++++++- SLS_Tests/yaml_to_c_tests.py | 6 +- 3 files changed, 2438 insertions(+), 53 deletions(-) diff --git a/SLS_C/tests/lexer_tests.c b/SLS_C/tests/lexer_tests.c index 286a4b8..2e0e000 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 = 369; +static const size_t NUM_OF_TESTS = 482; static TestResult test_Empty_Statement() { LexerTest test = start_up_test(SLS_STR("Empty_Statement"), SLS_STR("")); @@ -2401,12 +2401,22 @@ 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_Backslash() { + LexerTest test = start_up_test(SLS_STR("Char Escape Backslash"), 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_character_value(&test, result, i++, &(uint8_t){92})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Char_Escape_Double_quote() { + LexerTest test = start_up_test(SLS_STR("Char Escape Double 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){34})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } @@ -2421,12 +2431,12 @@ static TestResult test_Char_Escape_Newline() { 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_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){13})) return test.result; + 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); } @@ -2451,22 +2461,12 @@ static TestResult test_Char_Escape_Null_character() { return pass_test(&test, result); } -static TestResult test_Char_Escape_Double_quote() { - LexerTest test = start_up_test(SLS_STR("Char Escape Double 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){34})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Char_Escape_Backslash() { - LexerTest test = start_up_test(SLS_STR("Char Escape Backslash"), 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){92})) 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); } @@ -3653,6 +3653,1109 @@ static TestResult test_String_Many_Escapes() { 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_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(" 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_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 identifier: cannot start with digit."))) 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_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_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(" 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_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(" 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_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_for_error(&test, result, i++, SLS_STR("Invalid boolean: 'True' is not a boolean literal (use lowercase 'true')."))) 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_for_error(&test, result, i++, SLS_STR("Invalid boolean: 'False' is not a boolean literal (use lowercase 'false')."))) 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_for_error(&test, result, i++, SLS_STR("Invalid boolean: 'TRUE' is not a boolean literal (use lowercase 'true')."))) 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_for_error(&test, result, i++, SLS_STR("Invalid boolean: 'FALSE' is not a boolean literal (use lowercase 'false')."))) 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_for_error(&test, result, i++, SLS_STR("Invalid boolean: 'tRuE' is not a boolean literal (use lowercase 'true')."))) 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_for_error(&test, result, i++, SLS_STR("Invalid boolean: 'fAlSe' is not a boolean literal (use lowercase 'false')."))) 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_for_error(&test, result, i++, SLS_STR("Not a boolean: numeric literal."))) 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_for_error(&test, result, i++, SLS_STR("Not a boolean: numeric literal."))) 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_for_error(&test, result, i++, SLS_STR("Not a boolean: string literal."))) 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_for_error(&test, result, i++, SLS_STR("Not a boolean: string literal."))) 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_for_error(&test, result, i++, SLS_STR("Invalid boolean: 'yes' is not a boolean literal."))) 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_for_error(&test, result, i++, SLS_STR("Invalid boolean: 'no' is not a boolean literal."))) 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_for_error(&test, result, i++, SLS_STR("Invalid boolean: 'ture' is not a boolean literal."))) 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_for_error(&test, result, i++, SLS_STR("Invalid boolean: 'flase' is not a boolean literal."))) 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"), @@ -3904,13 +5007,13 @@ 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_Backslash(); + test_report.tests[i++] = test_Char_Escape_Double_quote(); test_report.tests[i++] = test_Char_Escape_Newline(); - test_report.tests[i++] = test_Char_Escape_Carriage_return(); + test_report.tests[i++] = test_Char_Escape_Single_quote(); test_report.tests[i++] = test_Char_Escape_Tab(); test_report.tests[i++] = test_Char_Escape_Null_character(); - test_report.tests[i++] = test_Char_Escape_Double_quote(); - test_report.tests[i++] = test_Char_Escape_Backslash(); + test_report.tests[i++] = test_Char_Escape_Carriage_return(); test_report.tests[i++] = test_Char_Newline(); test_report.tests[i++] = test_Char_Carriage_Return(); test_report.tests[i++] = test_Char_Tab(); @@ -4031,6 +5134,119 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_String_Only_Escapes(); test_report.tests[i++] = test_String_With_Nulls(); test_report.tests[i++] = test_String_Many_Escapes(); + 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_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_Dash(); + 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 ff21a83..1649c97 100644 --- a/SLS_Tests/cases.yaml +++ b/SLS_Tests/cases.yaml @@ -2641,18 +2641,30 @@ stack_final: - type: char value: '}' -- name: Char Escape Single quote - code: '''\''''' +- name: Char Escape Backslash + code: '''\\''' tokens: - type: char - value: '''' + value: \ operations: - function: push type: char - value: '''' + value: \ stack_final: - type: char - value: '''' + value: \ +- name: Char Escape Double quote + code: '''\\"''' + tokens: + - type: char + value: '"' + operations: + - function: push + type: char + value: '"' + stack_final: + - type: char + value: '"' - name: Char Escape Newline code: '''\n''' tokens: @@ -2671,18 +2683,18 @@ value: ' ' -- name: Char Escape Carriage return - code: '''\r''' +- name: Char Escape Single quote + code: '''\''''' tokens: - type: char - value: "\r" + value: '''' operations: - function: push type: char - value: "\r" + value: '''' stack_final: - type: char - value: "\r" + value: '''' - name: Char Escape Tab code: '''\t''' tokens: @@ -2707,30 +2719,18 @@ stack_final: - type: char value: "\0" -- name: Char Escape Double quote - code: '''\\"''' +- name: Char Escape Carriage return + code: '''\r''' tokens: - type: char - value: '"' + value: "\r" operations: - function: push type: char - value: '"' + value: "\r" stack_final: - type: char - value: '"' -- name: Char Escape Backslash - code: '''\\''' - tokens: - - type: char - value: \ - operations: - - function: push - type: char - value: \ - stack_final: - - type: char - value: \ + value: "\r" - name: Char Newline code: '''\n''' tokens: @@ -4061,3 +4061,1170 @@ stack_final: - type: string value: \n\n\n\n\n\n\n\n\n\n +- 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 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 identifier: cannot start with digit.' +- name: Identifier With Hash + code: my#var + tokens: + - type: error + value: 'Invalid identifier: ''#'' is not allowed in identifiers.' +- name: Identifier With Dash + 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: error + value: 'Invalid boolean: ''True'' is not a boolean literal (use lowercase ''true'').' +- name: Bool False Capitalized + code: 'False' + tokens: + - type: error + value: 'Invalid boolean: ''False'' is not a boolean literal (use lowercase ''false'').' +- name: Bool True All Caps + code: 'TRUE' + tokens: + - type: error + value: 'Invalid boolean: ''TRUE'' is not a boolean literal (use lowercase ''true'').' +- name: Bool False All Caps + code: 'FALSE' + tokens: + - type: error + value: 'Invalid boolean: ''FALSE'' is not a boolean literal (use lowercase ''false'').' +- name: Bool True Mixed Case + code: tRuE + tokens: + - type: error + value: 'Invalid boolean: ''tRuE'' is not a boolean literal (use lowercase ''true'').' +- name: Bool False Mixed Case + code: fAlSe + tokens: + - type: error + value: 'Invalid boolean: ''fAlSe'' is not a boolean literal (use lowercase ''false'').' +- name: Bool Numeric 1 + code: '1' + tokens: + - type: error + value: 'Not a boolean: numeric literal.' +- name: Bool Numeric 0 + code: '0' + tokens: + - type: error + value: 'Not a boolean: numeric literal.' +- name: Bool String True + code: '"true"' + tokens: + - type: error + value: 'Not a boolean: string literal.' +- name: Bool String False + code: '"false"' + tokens: + - type: error + value: 'Not a boolean: string literal.' +- name: Bool Yes + code: 'yes' + tokens: + - type: error + value: 'Invalid boolean: ''yes'' is not a boolean literal.' +- name: Bool No + code: 'no' + tokens: + - type: error + value: 'Invalid boolean: ''no'' is not a boolean literal.' +- name: Bool Typo Ture + code: ture + tokens: + - type: error + value: 'Invalid boolean: ''ture'' is not a boolean literal.' +- name: Bool Typo Flase + code: flase + tokens: + - type: error + value: 'Invalid boolean: ''flase'' is not a boolean literal.' +- 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/yaml_to_c_tests.py b/SLS_Tests/yaml_to_c_tests.py index 444bd0a..d5d8f31 100644 --- a/SLS_Tests/yaml_to_c_tests.py +++ b/SLS_Tests/yaml_to_c_tests.py @@ -77,9 +77,11 @@ def _token_to_c_call(token: dict, idx_var="i") -> str: elif ttype == "string": return f'test_string_value(&test, result, {idx_var}++, &SLS_STR("{value}"))' # type: ignore elif ttype == "identifier": - return f'test_identifier_value(&test, result, {idx_var}++, &(TestIdentifierValue){{FALSE, {len(value)}, "{value}"}})' # type: ignore + return f'test_identifier_value(&test, result, {idx_var}++, &(TestIdentifierValue){{FALSE, SLS_STR("{value}")}})' # type: ignore elif ttype == "identifier_literal": - return f'test_identifier_value(&test, result, {idx_var}++, &(TestIdentifierValue){{TRUE, {len(value)}, "{value}"}})' # type: ignore + return f'test_identifier_value(&test, result, {idx_var}++, &(TestIdentifierValue){{TRUE, SLS_STR("{value}")}})' # type: ignore + elif ttype == "bool": + return f'test_boolean_value(&test, result, {idx_var}++, &(Boolean){{{"TRUE" if value else "FALSE"}}})' # type: ignore elif ttype == "error": return f'test_for_error(&test, result, i++, SLS_STR("{c_string_literal(value)}"))' # type: ignore else: