Tests are compiling and running again
This commit is contained in:
parent
ad26c41463
commit
1566c7bf60
|
|
@ -124,6 +124,6 @@ Boolean test_array_boolean_value(LexerTest *test, LexerResult result, size_t i,
|
|||
Boolean test_array_struct_inline_value(LexerTest *test, LexerResult result, size_t i, TestArrayStructInlineValue *values);
|
||||
Boolean test_token_string_value(LexerTest *test, LexerResult result, size_t i, TestTokenStringValue *values);
|
||||
Boolean test_type_tuple_value(LexerTest *test, LexerResult result, size_t i, TestTypeTupleValue *values);
|
||||
Boolean test_for_error(LexerTest *test, LexerResult result, size_t i, SlsStr error);
|
||||
Boolean test_for_error(LexerTest *test, LexerResult result, size_t i, SlsStr *error);
|
||||
|
||||
#endif // SLS_LEXER_TEST_HELPERS_H
|
||||
|
|
|
|||
|
|
@ -551,13 +551,13 @@ Boolean test_type_tuple_value(LexerTest *test, LexerResult result, size_t i, Tes
|
|||
return FALSE;
|
||||
}
|
||||
|
||||
Boolean test_for_error(LexerTest *test, LexerResult result, size_t i, SlsStr error) {
|
||||
Boolean test_for_error(LexerTest *test, LexerResult result, size_t i, SlsStr *error) {
|
||||
LexerTokenResult *head = get_token(result.result, i);
|
||||
if (head->type != SLS_ERROR) {
|
||||
logic_fail_test(test, result, token_should_be_error(i + 1, error, head->result.type));
|
||||
logic_fail_test(test, result, token_should_be_error(i + 1, *error, head->result.type));
|
||||
return TRUE;
|
||||
} if (sls_str_cmp(head->error.message, error) != 0) {
|
||||
logic_fail_test(test, result, error_should_be(i + 1, error, head->error));
|
||||
} if (sls_str_cmp(head->error.message, *error) != 0) {
|
||||
logic_fail_test(test, result, error_should_be(i + 1, *error, head->error));
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
|
|
|
|||
|
|
@ -232,7 +232,7 @@ static TestResult test_Integer_Default_Decimal_with_Commas_Invalid() {
|
|||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, SLS_STR("Invalid decimal literal: unexpected ',' in decimal integer."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid decimal literal: unexpected ',' in decimal integer."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -241,7 +241,7 @@ static TestResult test_Integer_Default_Invalid_Characters() {
|
|||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, SLS_STR("Invalid decimal literal: unexpected 'a' in decimal integer."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid decimal literal: unexpected 'a' in decimal integer."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -250,7 +250,7 @@ static TestResult test_Integer_Default_Invalid_Prefix() {
|
|||
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 binary literal: unexpected '2' in binary integer."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid binary literal: unexpected '2' in binary integer."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -339,7 +339,7 @@ static TestResult test_Integer_i8_Overflow() {
|
|||
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("Integer overflow: value exceeds range for i8."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i8."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -348,7 +348,7 @@ static TestResult test_Integer_i8_Underflow() {
|
|||
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("Integer overflow: value exceeds range for i8."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i8."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -477,7 +477,7 @@ static TestResult test_Integer_i16_Overflow() {
|
|||
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("Integer overflow: value exceeds range for i16."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i16."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -486,7 +486,7 @@ static TestResult test_Integer_i16_Underflow() {
|
|||
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("Integer overflow: value exceeds range for i16."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i16."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -605,7 +605,7 @@ static TestResult test_Integer_i32_Overflow() {
|
|||
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("Integer overflow: value exceeds range for i32."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i32."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -614,7 +614,7 @@ static TestResult test_Integer_i32_Underflow() {
|
|||
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("Integer overflow: value exceeds range for i32."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i32."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -733,7 +733,7 @@ static TestResult test_Integer_i64_Overflow() {
|
|||
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("Integer overflow: value exceeds range for i64."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i64."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -742,7 +742,7 @@ static TestResult test_Integer_i64_Underflow() {
|
|||
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("Integer overflow: value exceeds range for i64."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i64."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -871,7 +871,7 @@ static TestResult test_Integer_u8_Overflow() {
|
|||
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("Integer overflow: value exceeds range for u8."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u8."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -880,7 +880,7 @@ static TestResult test_Integer_u8_Underflow() {
|
|||
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("Integer overflow: value exceeds range for u8."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u8."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -989,7 +989,7 @@ static TestResult test_Integer_u16_Overflow() {
|
|||
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("Integer overflow: value exceeds range for u16."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u16."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -998,7 +998,7 @@ static TestResult test_Integer_u16_Underflow() {
|
|||
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("Integer overflow: value exceeds range for u16."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u16."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -1117,7 +1117,7 @@ static TestResult test_Integer_u32_Overflow() {
|
|||
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("Integer overflow: value exceeds range for u32."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u32."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -1126,7 +1126,7 @@ static TestResult test_Integer_u32_Underflow() {
|
|||
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("Integer overflow: value exceeds range for u32."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u32."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -1255,7 +1255,7 @@ static TestResult test_Integer_u64_Overflow() {
|
|||
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("Integer overflow: value exceeds range for u64."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u64."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -1264,7 +1264,7 @@ static TestResult test_Integer_u64_Underflow() {
|
|||
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("Integer overflow: value exceeds range for u64."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u64."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -1623,7 +1623,7 @@ static TestResult test_Float_Invalid_Multiple_Decimal_Points() {
|
|||
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 float literal: unexpected '.' in float."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid float literal: unexpected '.' in float."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -1632,7 +1632,7 @@ static TestResult test_Float_Invalid_Characters() {
|
|||
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 float literal: unexpected 'a' in float."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid float literal: unexpected 'a' in float."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -1641,7 +1641,7 @@ static TestResult test_Float_Invalid_Type_Annotation() {
|
|||
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 float type: must be of type 'f64' or 'f32'."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid float type: must be of type 'f64' or 'f32'."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -1650,7 +1650,7 @@ static TestResult test_Float_Invalid_Type_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_for_error(&test, result, i++, SLS_STR("Invalid float type: must be of type 'f64' or 'f32'."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid float type: must be of type 'f64' or 'f32'."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -1659,7 +1659,7 @@ static TestResult test_Float_Invalid_Comma_Separator() {
|
|||
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 float literal: unexpected ',' in float."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid float literal: unexpected ',' in float."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -2073,16 +2073,6 @@ static TestResult test_Char_Right_Brace() {
|
|||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Char_Escape_Tab() {
|
||||
LexerTest test = start_up_test(SLS_STR("Char Escape Tab"), SLS_STR("'\\t'"));
|
||||
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){9})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Char_Escape_Null_character() {
|
||||
LexerTest test = start_up_test(SLS_STR("Char Escape Null character"), SLS_STR("'\\0'"));
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
|
|
@ -2113,6 +2103,16 @@ static TestResult test_Char_Escape_Newline() {
|
|||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Char_Escape_Single_quote() {
|
||||
LexerTest test = start_up_test(SLS_STR("Char Escape Single quote"), SLS_STR("'\\''"));
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_character_value(&test, result, i++, &(uint8_t){39})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
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);
|
||||
|
|
@ -2123,12 +2123,12 @@ static TestResult test_Char_Escape_Backslash() {
|
|||
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_Tab() {
|
||||
LexerTest test = start_up_test(SLS_STR("Char Escape Tab"), SLS_STR("'\\t'"));
|
||||
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){9})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -2248,7 +2248,7 @@ static TestResult test_Char_Empty_Literal() {
|
|||
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 character literal: empty character literal."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: empty character literal."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -2257,7 +2257,7 @@ static TestResult test_Char_Multiple_Characters() {
|
|||
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 character literal: unexpected 'B' in character."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: unexpected 'B' in character."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -2266,7 +2266,7 @@ static TestResult test_Char_Unclosed_Quote() {
|
|||
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 character literal: unclosed character literal."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: unclosed character literal."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -2275,7 +2275,7 @@ static TestResult test_Char_Unescaped_Newline() {
|
|||
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 character literal: unclosed character literal."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: unclosed character literal."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -2284,7 +2284,7 @@ static TestResult test_Char_Invalid_Escape() {
|
|||
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 character literal: unknown escape sequence '\\q'."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: unknown escape sequence '\\q'."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -2293,7 +2293,7 @@ static TestResult test_Char_Hex_Escape_Too_Short() {
|
|||
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 character literal: hexadecimal escape must have exactly 2 digits."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: hexadecimal escape must have exactly 2 digits."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -2302,7 +2302,7 @@ static TestResult test_Char_Hex_Escape_Too_Long() {
|
|||
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 character literal: hexadecimal escape must have exactly 2 digits."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: hexadecimal escape must have exactly 2 digits."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -2311,7 +2311,7 @@ static TestResult test_Char_Hex_Invalid_Digit() {
|
|||
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 character literal: invalid hexadecimal digit 'G'."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: invalid hexadecimal digit 'G'."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -2840,7 +2840,7 @@ static TestResult test_Identifier_Starting_With_Number() {
|
|||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, SLS_STR("Invalid decimal literal: unexpected 'a' in decimal integer."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid decimal literal: unexpected 'a' in decimal integer."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -2859,7 +2859,7 @@ static TestResult test_Identifier_With_Colon() {
|
|||
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;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid identifier: ':' is not allowed in identifiers."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -2868,7 +2868,7 @@ static TestResult test_Identifier_Double_Colon_Inside() {
|
|||
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;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Invalid identifier: ':' is not allowed in identifiers."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -2887,7 +2887,7 @@ static TestResult test_Identifier_Literal_Empty() {
|
|||
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("Unexpected character: unexpected ':' during parsing."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Unexpected character: unexpected ':' during parsing."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -3430,7 +3430,7 @@ static TestResult test_TokenString_Empty() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){0, NULL})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){0, NULL})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3440,7 +3440,7 @@ static TestResult test_TokenString_Single_Integer() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 42}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 42}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3450,7 +3450,7 @@ static TestResult test_TokenString_Single_Identifier() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3460,7 +3460,7 @@ static TestResult test_TokenString_Two_Integers() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3470,7 +3470,7 @@ static TestResult test_TokenString_Simple_Expression() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3480,7 +3480,7 @@ static TestResult test_TokenString_Stack_Ops() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3490,7 +3490,7 @@ static TestResult test_TokenString_Integer_Literals() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){4, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 0}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 42}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, -10}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 1000}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){4, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 0}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 42}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, -10}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 1000}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3500,7 +3500,7 @@ static TestResult test_TokenString_Float_Literals() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_double_value, .value = &(double){3.14}}, {.token_handler = test_double_value, .value = &(double){-2.5}}, {.token_handler = test_double_value, .value = &(double){0.0}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_double_value, &(double){3.14}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_double_value, &(double){-2.5}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_double_value, &(double){0.0}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3510,7 +3510,7 @@ static TestResult test_TokenString_Char_Literal() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_character_value, .value = &(uint8_t){65}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_character_value, &(uint8_t){65}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3520,7 +3520,7 @@ static TestResult test_TokenString_Boolean_Literals() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_boolean_value, .value = &(Boolean){TRUE}}, {.token_handler = test_boolean_value, .value = &(Boolean){FALSE}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_boolean_value, &(Boolean){TRUE}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_boolean_value, &(Boolean){FALSE}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3530,7 +3530,7 @@ static TestResult test_TokenString_Multiple_Identifiers() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("swap")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("over")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("swap")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("over")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3540,7 +3540,7 @@ static TestResult test_TokenString_Identifier_Literals() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){TRUE, SLS_STR("x")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){TRUE, SLS_STR("y")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){TRUE, SLS_STR("x")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){TRUE, SLS_STR("y")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3550,7 +3550,7 @@ static TestResult test_TokenString_Mixed_Identifiers() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){4, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){TRUE, SLS_STR("Point")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("get")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("x")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("swap")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){4, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){TRUE, SLS_STR("Point")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("get")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("x")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("swap")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3560,7 +3560,7 @@ static TestResult test_TokenString_Nested_Single() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_token_string_value, .value = &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3570,7 +3570,7 @@ static TestResult test_TokenString_Nested_With_Others() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("x")}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("x")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3580,7 +3580,7 @@ static TestResult test_TokenString_Multiple_Nested() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_token_string_value, .value = &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 4}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 5}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 4}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 5}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3590,7 +3590,7 @@ static TestResult test_TokenString_Double_Nested() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_token_string_value, .value = &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_token_string_value, .value = &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 42}}}}}}}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 42}}}}}}}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3600,7 +3600,7 @@ static TestResult test_TokenString_Complex_Nesting() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 1}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}}}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 4}}}}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 5}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 1}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}}}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 4}}}}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 5}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3610,7 +3610,7 @@ static TestResult test_TokenString_No_Whitespace() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3620,7 +3620,7 @@ static TestResult test_TokenString_Extra_Whitespace() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3630,7 +3630,7 @@ static TestResult test_TokenString_Leading_Whitespace_Outside() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3640,7 +3640,7 @@ static TestResult test_TokenString_Trailing_Whitespace_Outside() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3650,7 +3650,7 @@ static TestResult test_TokenString_With_Tabs() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3660,7 +3660,7 @@ static TestResult test_TokenString_Multiline_Simple() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3670,7 +3670,7 @@ static TestResult test_TokenString_Multiline_Multiple() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){4, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){4, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3680,7 +3680,7 @@ static TestResult test_TokenString_Mixed_Line_Breaks() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){6, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 1}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 4}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 5}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 6}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){6, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 1}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 4}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 5}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 6}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3690,7 +3690,7 @@ static TestResult test_TokenString_Indented_Multiline() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){6, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 0}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR(">")}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){0, NULL}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 0}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("swap")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("-")}}}}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("if")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){6, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 0}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR(">")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){0, NULL}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 0}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("swap")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("-")}}}}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("if")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3700,7 +3700,7 @@ static TestResult test_TokenString_Comment_End_Of_Line() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3710,7 +3710,7 @@ static TestResult test_TokenString_Multiple_Comments() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3720,7 +3720,7 @@ static TestResult test_TokenString_Comment_Own_Line() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3730,7 +3730,7 @@ static TestResult test_TokenString_Comment_At_Start() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3740,7 +3740,7 @@ static TestResult test_TokenString_Multiple_Comment_Lines() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3750,7 +3750,7 @@ static TestResult test_TokenString_Comments_Nested() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_token_string_value, .value = &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3760,7 +3760,7 @@ static TestResult test_TokenString_Unclosed() {
|
|||
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("Unclosed token string: missing closing brace '}'."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Unclosed token string: missing closing brace '}'."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -3769,7 +3769,7 @@ static TestResult test_TokenString_Unclosed_Nested() {
|
|||
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("Unclosed token string: missing closing brace '}'."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Unclosed token string: missing closing brace '}'."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -3778,8 +3778,8 @@ static TestResult test_TokenString_Extra_Closing_Brace() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_for_error(&test, result, i++, SLS_STR("Unexpected closing brace '}' without matching opening brace."))) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Unexpected closing brace '}' without matching opening brace."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -3788,7 +3788,7 @@ static TestResult test_TokenString_Only_Closing_Brace() {
|
|||
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("Unexpected closing brace '}' without matching opening brace."))) return test.result;
|
||||
if (test_for_error(&test, result, i++, &SLS_STR("Unexpected closing brace '}' without matching opening brace."))) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -3797,7 +3797,7 @@ static TestResult test_TokenString_Error_Inside() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_for_error, .value = SLS_STR("Invalid decimal literal: unexpected 'a' in decimal integer.")}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_for_error, &SLS_STR("Invalid decimal literal: unexpected 'a' in decimal integer.")}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3807,7 +3807,7 @@ static TestResult test_TokenString_Unclosed_String_Inside() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_for_error, .value = SLS_STR("Invalid string literal: unclosed string literal.")}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_for_error, &SLS_STR("Invalid string literal: unclosed string literal.")}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3817,7 +3817,7 @@ static TestResult test_TokenString_Function_Body() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3827,7 +3827,7 @@ static TestResult test_TokenString_Loop_Body() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){4, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("print")}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 1}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){4, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("print")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 1}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3837,7 +3837,7 @@ static TestResult test_TokenString_Struct_Fields() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){4, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("x")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR(":")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("y")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR(":")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){4, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("x")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR(":")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("y")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR(":")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3847,7 +3847,7 @@ static TestResult test_TokenString_Lambda() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3857,7 +3857,7 @@ static TestResult test_TokenString_Array_Map() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -3867,7 +3867,7 @@ static TestResult test_TokenString_Conditional_Complex() {
|
|||
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_token_string_value(&test, result, i, &(TestTokenStringValue){6, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 0}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR(">")}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("drop")}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 0}}}}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("if")}}}})) return test.result;
|
||||
if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){6, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 0}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR(">")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("drop")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 0}}}}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("if")}}}})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
|
@ -4089,12 +4089,12 @@ TestsReport run_lexer_tests() {
|
|||
test_report.tests[i++] = test_Char_Right_Bracket();
|
||||
test_report.tests[i++] = test_Char_Left_Brace();
|
||||
test_report.tests[i++] = test_Char_Right_Brace();
|
||||
test_report.tests[i++] = test_Char_Escape_Tab();
|
||||
test_report.tests[i++] = test_Char_Escape_Null_character();
|
||||
test_report.tests[i++] = test_Char_Escape_Carriage_return();
|
||||
test_report.tests[i++] = test_Char_Escape_Newline();
|
||||
test_report.tests[i++] = test_Char_Escape_Backslash();
|
||||
test_report.tests[i++] = test_Char_Escape_Single_quote();
|
||||
test_report.tests[i++] = test_Char_Escape_Backslash();
|
||||
test_report.tests[i++] = test_Char_Escape_Tab();
|
||||
test_report.tests[i++] = test_Char_Hex_Lowercase_A();
|
||||
test_report.tests[i++] = test_Char_Hex_Uppercase_A();
|
||||
test_report.tests[i++] = test_Char_Hex_Space();
|
||||
|
|
|
|||
|
|
@ -2317,18 +2317,6 @@
|
|||
stack_final:
|
||||
- type: char
|
||||
value: '}'
|
||||
- name: Char Escape Tab
|
||||
code: '''\\t'''
|
||||
tokens:
|
||||
- type: char
|
||||
value: "\t"
|
||||
operations:
|
||||
- function: push
|
||||
type: char
|
||||
value: "\t"
|
||||
stack_final:
|
||||
- type: char
|
||||
value: "\t"
|
||||
- name: Char Escape Null character
|
||||
code: '''\\0'''
|
||||
tokens:
|
||||
|
|
@ -2371,18 +2359,6 @@
|
|||
value: '
|
||||
|
||||
'
|
||||
- name: Char Escape Backslash
|
||||
code: '''\\\\'''
|
||||
tokens:
|
||||
- type: char
|
||||
value: \
|
||||
operations:
|
||||
- function: push
|
||||
type: char
|
||||
value: \
|
||||
stack_final:
|
||||
- type: char
|
||||
value: \
|
||||
- name: Char Escape Single quote
|
||||
code: '''\\'''''
|
||||
tokens:
|
||||
|
|
@ -2395,6 +2371,30 @@
|
|||
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: \
|
||||
- name: Char Escape Tab
|
||||
code: '''\\t'''
|
||||
tokens:
|
||||
- type: char
|
||||
value: "\t"
|
||||
operations:
|
||||
- function: push
|
||||
type: char
|
||||
value: "\t"
|
||||
stack_final:
|
||||
- type: char
|
||||
value: "\t"
|
||||
- name: Char Hex Lowercase A
|
||||
code: '''\\x61'''
|
||||
tokens:
|
||||
|
|
|
|||
|
|
@ -83,162 +83,149 @@ def _token_to_c_call(token: dict, idx_var="i") -> str:
|
|||
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
|
||||
return f'test_for_error(&test, result, i++, &SLS_STR("{c_string_literal(value)}"))' # type: ignore
|
||||
elif ttype == "token_string":
|
||||
return _token_string_c_call(token, idx_var, value) # type: ignore
|
||||
return _token_string_c_call(idx_var, value) # type: ignore
|
||||
else:
|
||||
raise ValueError(f' Unhandled token type: {ttype}')
|
||||
|
||||
def _token_string_c_call(token: dict, idx_var: str, value: list[dict]) -> str:
|
||||
def _token_string_c_call(idx_var: str, value: list[dict]) -> str:
|
||||
"""Generate C code for testing a token string value."""
|
||||
# Build the array of TestTokenValue structures
|
||||
token_values = []
|
||||
if not value: # Empty token string
|
||||
return (
|
||||
f'test_token_string_value(&test, result, {idx_var}++, '
|
||||
f'&(TestTokenStringValue){{0, NULL}})'
|
||||
)
|
||||
|
||||
# Generate token handler calls for each token in the string
|
||||
token_handlers = []
|
||||
for i, inner_token in enumerate(value):
|
||||
inner_type = inner_token.get("type")
|
||||
inner_value = inner_token.get("value")
|
||||
|
||||
# Determine the handler function and value initialization
|
||||
if inner_type == "i64":
|
||||
handler = "test_integer_value"
|
||||
val_init = f'&(TestIntegerValue){{INTEGER_I64, {inner_value}}}'
|
||||
elif inner_type == "i32":
|
||||
handler = "test_integer_value"
|
||||
val_init = f'&(TestIntegerValue){{INTEGER_I32, {inner_value}}}'
|
||||
elif inner_type == "i16":
|
||||
handler = "test_integer_value"
|
||||
val_init = f'&(TestIntegerValue){{INTEGER_I16, {inner_value}}}'
|
||||
elif inner_type == "i8":
|
||||
handler = "test_integer_value"
|
||||
val_init = f'&(TestIntegerValue){{INTEGER_I8, {inner_value}}}'
|
||||
elif inner_type == "u64":
|
||||
handler = "test_integer_value"
|
||||
val_init = f'&(TestIntegerValue){{INTEGER_U64, {inner_value}}}'
|
||||
elif inner_type == "u32":
|
||||
handler = "test_integer_value"
|
||||
val_init = f'&(TestIntegerValue){{INTEGER_U32, {inner_value}}}'
|
||||
elif inner_type == "u16":
|
||||
handler = "test_integer_value"
|
||||
val_init = f'&(TestIntegerValue){{INTEGER_U16, {inner_value}}}'
|
||||
elif inner_type == "u8":
|
||||
handler = "test_integer_value"
|
||||
val_init = f'&(TestIntegerValue){{INTEGER_U8, {inner_value}}}'
|
||||
elif inner_type == "f64":
|
||||
handler = "test_double_value"
|
||||
val_init = f'&(double){{{inner_value}}}'
|
||||
elif inner_type == "f32":
|
||||
handler = "test_float_value"
|
||||
val_init = f'&(float){{{inner_value}}}'
|
||||
elif inner_type == "char":
|
||||
handler = "test_character_value"
|
||||
val_init = f'&(uint8_t){{{ord(inner_value)}}}' # type: ignore
|
||||
elif inner_type == "string":
|
||||
handler = "test_string_value"
|
||||
val_init = f'&SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
|
||||
elif inner_type == "identifier":
|
||||
handler = "test_identifier_value"
|
||||
val_init = f'&(TestIdentifierValue){{FALSE, SLS_STR("{inner_value}")}}'
|
||||
elif inner_type == "identifier_literal":
|
||||
handler = "test_identifier_value"
|
||||
val_init = f'&(TestIdentifierValue){{TRUE, SLS_STR("{inner_value}")}}'
|
||||
elif inner_type == "bool":
|
||||
handler = "test_boolean_value"
|
||||
val_init = f'&(Boolean){{{"TRUE" if inner_value else "FALSE"}}}'
|
||||
elif inner_type == "error":
|
||||
handler = "test_for_error"
|
||||
val_init = f'&SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
|
||||
elif inner_type == "token_string":
|
||||
# Nested token string - recursive call
|
||||
handler = "test_token_string_value"
|
||||
val_init = _token_string_value_init(inner_token.get("value", []))
|
||||
else:
|
||||
raise ValueError(f'Unhandled token type in token string: {inner_type}')
|
||||
|
||||
token_handlers.append(
|
||||
f'{{(Boolean (*)(LexerTest *, LexerResult, size_t, void *)){handler}, '
|
||||
f'{val_init}}}'
|
||||
)
|
||||
|
||||
# Generate the array initialization
|
||||
tokens_array = f'(TestTokenStringToken[]){{{", ".join(token_handlers)}}}'
|
||||
|
||||
return (
|
||||
f'test_token_string_value(&test, result, {idx_var}++, '
|
||||
f'&(TestTokenStringValue){{{len(value)}, {tokens_array}}})'
|
||||
)
|
||||
|
||||
def _token_string_value_init(value: list[dict]) -> str:
|
||||
"""Generate initialization code for a TestTokenStringValue (for nested token strings)."""
|
||||
if not value:
|
||||
return '&(TestTokenStringValue){0, NULL}'
|
||||
|
||||
token_handlers = []
|
||||
for inner_token in value:
|
||||
inner_type = inner_token.get("type")
|
||||
inner_value = inner_token.get("value")
|
||||
|
||||
# Map token types to their C test handler and value structure
|
||||
if inner_type == "i64":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_I64, {inner_value}}}"
|
||||
val_init = f'&(TestIntegerValue){{INTEGER_I64, {inner_value}}}'
|
||||
elif inner_type == "i32":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_I32, {inner_value}}}"
|
||||
elif inner_type == "i16":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_I16, {inner_value}}}"
|
||||
elif inner_type == "i8":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_I8, {inner_value}}}"
|
||||
elif inner_type == "u64":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_U64, {inner_value}}}"
|
||||
elif inner_type == "u32":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_U32, {inner_value}}}"
|
||||
elif inner_type == "u16":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_U16, {inner_value}}}"
|
||||
elif inner_type == "u8":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_U8, {inner_value}}}"
|
||||
val_init = f'&(TestIntegerValue){{INTEGER_I32, {inner_value}}}'
|
||||
elif inner_type == "f64":
|
||||
handler = "test_double_value"
|
||||
value_struct = f"&(double){{{inner_value}}}"
|
||||
val_init = f'&(double){{{inner_value}}}'
|
||||
elif inner_type == "f32":
|
||||
handler = "test_float_value"
|
||||
value_struct = f"&(float){{{inner_value}}}"
|
||||
val_init = f'&(float){{{inner_value}}}'
|
||||
elif inner_type == "char":
|
||||
handler = "test_character_value"
|
||||
value_struct = f"&(uint8_t){{{ord(inner_value)}}}" # type: ignore
|
||||
val_init = f'&(uint8_t){{{ord(inner_value)}}}' # type: ignore
|
||||
elif inner_type == "string":
|
||||
handler = "test_string_value"
|
||||
value_struct = f'&SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
|
||||
val_init = f'&SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
|
||||
elif inner_type == "identifier":
|
||||
handler = "test_identifier_value"
|
||||
value_struct = f'&(TestIdentifierValue){{FALSE, SLS_STR("{inner_value}")}}'
|
||||
val_init = f'&(TestIdentifierValue){{FALSE, SLS_STR("{inner_value}")}}'
|
||||
elif inner_type == "identifier_literal":
|
||||
handler = "test_identifier_value"
|
||||
value_struct = f'&(TestIdentifierValue){{TRUE, SLS_STR("{inner_value}")}}'
|
||||
val_init = f'&(TestIdentifierValue){{TRUE, SLS_STR("{inner_value}")}}'
|
||||
elif inner_type == "bool":
|
||||
handler = "test_boolean_value"
|
||||
bool_str = "TRUE" if inner_value else "FALSE"
|
||||
value_struct = f"&(Boolean){{{bool_str}}}"
|
||||
val_init = f'&(Boolean){{{"TRUE" if inner_value else "FALSE"}}}'
|
||||
elif inner_type == "error":
|
||||
handler = "test_for_error"
|
||||
value_struct = f'SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
|
||||
val_init = f'&SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
|
||||
elif inner_type == "token_string":
|
||||
# Recursive case: nested token string
|
||||
handler = "test_token_string_value"
|
||||
nested_tokens = inner_value if isinstance(inner_value, list) else []
|
||||
value_struct = _build_token_string_value_struct(nested_tokens)
|
||||
val_init = _token_string_value_init(inner_token.get("value", []))
|
||||
# Add other types as needed
|
||||
else:
|
||||
raise ValueError(f'Unhandled inner token type in token_string: {inner_type}')
|
||||
raise ValueError(f'Unhandled token type in nested token string: {inner_type}')
|
||||
|
||||
token_values.append(f"{{.token_handler = {handler}, .value = {value_struct}}}")
|
||||
token_handlers.append(
|
||||
f'{{(Boolean (*)(LexerTest *, LexerResult, size_t, void *)){handler}, '
|
||||
f'{val_init}}}'
|
||||
)
|
||||
|
||||
# Generate the TestTokenStringValue initialization
|
||||
num_tokens = len(value)
|
||||
if num_tokens == 0:
|
||||
# Empty token string
|
||||
return f'test_token_string_value(&test, result, {idx_var}, &(TestTokenStringValue){{0, NULL}})'
|
||||
else:
|
||||
# Token string with values
|
||||
values_array = f"(TestTokenValue[]){{{', '.join(token_values)}}}"
|
||||
return f'test_token_string_value(&test, result, {idx_var}, &(TestTokenStringValue){{{num_tokens}, {values_array}}})'
|
||||
|
||||
|
||||
def _build_token_string_value_struct(nested_tokens: list[dict]) -> str:
|
||||
"""Helper to build a TestTokenStringValue structure for nested token strings."""
|
||||
if not nested_tokens:
|
||||
return "&(TestTokenStringValue){0, NULL}"
|
||||
|
||||
token_values = []
|
||||
for inner_token in nested_tokens:
|
||||
inner_type = inner_token.get("type")
|
||||
inner_value = inner_token.get("value")
|
||||
|
||||
if inner_type == "i64":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_I64, {inner_value}}}"
|
||||
elif inner_type == "i32":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_I32, {inner_value}}}"
|
||||
elif inner_type == "i16":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_I16, {inner_value}}}"
|
||||
elif inner_type == "i8":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_I8, {inner_value}}}"
|
||||
elif inner_type == "u64":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_U64, {inner_value}}}"
|
||||
elif inner_type == "u32":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_U32, {inner_value}}}"
|
||||
elif inner_type == "u16":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_U16, {inner_value}}}"
|
||||
elif inner_type == "u8":
|
||||
handler = "test_integer_value"
|
||||
value_struct = f"&(TestIntegerValue){{INTEGER_U8, {inner_value}}}"
|
||||
elif inner_type == "f64":
|
||||
handler = "test_double_value"
|
||||
value_struct = f"&(double){{{inner_value}}}"
|
||||
elif inner_type == "f32":
|
||||
handler = "test_float_value"
|
||||
value_struct = f"&(float){{{inner_value}}}"
|
||||
elif inner_type == "char":
|
||||
handler = "test_character_value"
|
||||
value_struct = f"&(uint8_t){{{ord(inner_value)}}}" # type: ignore
|
||||
elif inner_type == "string":
|
||||
handler = "test_string_value"
|
||||
value_struct = f'&SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
|
||||
elif inner_type == "identifier":
|
||||
handler = "test_identifier_value"
|
||||
value_struct = f'&(TestIdentifierValue){{FALSE, SLS_STR("{inner_value}")}}'
|
||||
elif inner_type == "identifier_literal":
|
||||
handler = "test_identifier_value"
|
||||
value_struct = f'&(TestIdentifierValue){{TRUE, SLS_STR("{inner_value}")}}'
|
||||
elif inner_type == "bool":
|
||||
handler = "test_boolean_value"
|
||||
bool_str = "TRUE" if inner_value else "FALSE"
|
||||
value_struct = f"&(Boolean){{{bool_str}}}"
|
||||
elif inner_type == "error":
|
||||
handler = "test_for_error"
|
||||
value_struct = f'SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
|
||||
elif inner_type == "token_string":
|
||||
# Recursive case
|
||||
handler = "test_token_string_value"
|
||||
value_struct = _build_token_string_value_struct(inner_value if isinstance(inner_value, list) else [])
|
||||
else:
|
||||
raise ValueError(f'Unhandled nested token type in token_string: {inner_type}')
|
||||
|
||||
token_values.append(f"{{.token_handler = {handler}, .value = {value_struct}}}")
|
||||
|
||||
num_tokens = len(nested_tokens)
|
||||
values_array = f"(TestTokenValue[]){{{', '.join(token_values)}}}"
|
||||
return f"&(TestTokenStringValue){{{num_tokens}, {values_array}}}"
|
||||
tokens_array = f'(TestTokenStringToken[]){{{", ".join(token_handlers)}}}'
|
||||
return f'&(TestTokenStringValue){{{len(value)}, {tokens_array}}}'
|
||||
|
||||
def token_to_c_call(token: dict, idx_var="i") -> str:
|
||||
"""Generate a C 'test_*_value' call based on token type."""
|
||||
|
|
|
|||
Loading…
Reference in New Issue