diff --git a/SLS_C/tests/lexer_tests.c b/SLS_C/tests/lexer_tests.c index 52be2d1..3490a1e 100644 --- a/SLS_C/tests/lexer_tests.c +++ b/SLS_C/tests/lexer_tests.c @@ -16,7 +16,7 @@ #include "tests/tests.h" -static const size_t NUM_OF_TESTS = 389; +static const size_t NUM_OF_TESTS = 368; static TestResult test_Empty_Statement() { LexerTest test = start_up_test(SLS_STR("Empty_Statement"), SLS_STR("")); @@ -352,46 +352,6 @@ static TestResult test_Integer_i8_Underflow() { return pass_test(&test, result); } -static TestResult test_Integer_i8_Hex_Max() { - LexerTest test = start_up_test(SLS_STR("Integer i8 Hex Max"), SLS_STR("0x7F:i8")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_i8_Binary_Max() { - LexerTest test = start_up_test(SLS_STR("Integer i8 Binary Max"), SLS_STR("0b01111111:i8")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_i8_Octal_Max() { - LexerTest test = start_up_test(SLS_STR("Integer i8 Octal Max"), SLS_STR("0o177:i8")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_i8_Negative_Hex() { - LexerTest test = start_up_test(SLS_STR("Integer i8 Negative Hex"), SLS_STR("-0x80:i8")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, -128})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - static TestResult test_Integer_i16_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("Integer i16 Decimal Positive"), SLS_STR("42:i16")); LexerResult result = lexical_analysis(&test.lexer_info); @@ -490,36 +450,6 @@ static TestResult test_Integer_i16_Underflow() { return pass_test(&test, result); } -static TestResult test_Integer_i16_Hex_Sample() { - LexerTest test = start_up_test(SLS_STR("Integer i16 Hex Sample"), SLS_STR("0x1234:i16")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 4660})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_i16_Binary_Sample() { - LexerTest test = start_up_test(SLS_STR("Integer i16 Binary Sample"), SLS_STR("0b1111111100000000:i16")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 65280})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_i16_Octal_Sample() { - LexerTest test = start_up_test(SLS_STR("Integer i16 Octal Sample"), SLS_STR("0o1234:i16")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 668})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - static TestResult test_Integer_i32_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("Integer i32 Decimal Positive"), SLS_STR("42:i32")); LexerResult result = lexical_analysis(&test.lexer_info); @@ -628,26 +558,6 @@ static TestResult test_Integer_i32_With_Underscores() { return pass_test(&test, result); } -static TestResult test_Integer_i32_Hex_Sample() { - LexerTest test = start_up_test(SLS_STR("Integer i32 Hex Sample"), SLS_STR("0xABCD:i32")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 43981})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_i32_Binary_Sample() { - LexerTest test = start_up_test(SLS_STR("Integer i32 Binary Sample"), SLS_STR("0b11110000:i32")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 240})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - static TestResult test_Integer_i64_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("Integer i64 Decimal Positive"), SLS_STR("42:i64")); LexerResult result = lexical_analysis(&test.lexer_info); @@ -756,46 +666,6 @@ static TestResult test_Integer_i64_With_Underscores() { return pass_test(&test, result); } -static TestResult test_Integer_i64_Decimal_Positive_42() { - LexerTest test = start_up_test(SLS_STR("Integer i64 Decimal Positive 42"), SLS_STR("42:i64")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 42})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_i64_Hex_0xFF() { - LexerTest test = start_up_test(SLS_STR("Integer i64 Hex 0xFF"), SLS_STR("0xFF:i64")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 255})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_i64_Binary_0b1010() { - LexerTest test = start_up_test(SLS_STR("Integer i64 Binary 0b1010"), SLS_STR("0b1010:i64")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 10})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_i64_Octal_0o755() { - LexerTest test = start_up_test(SLS_STR("Integer i64 Octal 0o755"), SLS_STR("0o755:i64")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 493})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - static TestResult test_Integer_u8_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("Integer u8 Decimal Positive"), SLS_STR("42:u8")); LexerResult result = lexical_analysis(&test.lexer_info); @@ -884,36 +754,6 @@ static TestResult test_Integer_u8_Underflow() { return pass_test(&test, result); } -static TestResult test_Integer_u8_Hex_Max() { - LexerTest test = start_up_test(SLS_STR("Integer u8 Hex Max"), SLS_STR("0xFF:u8")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_u8_Binary_Max() { - LexerTest test = start_up_test(SLS_STR("Integer u8 Binary Max"), SLS_STR("0b11111111:u8")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_u8_Octal_Max() { - LexerTest test = start_up_test(SLS_STR("Integer u8 Octal Max"), SLS_STR("0o377:u8")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - static TestResult test_Integer_u16_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("Integer u16 Decimal Positive"), SLS_STR("42:u16")); LexerResult result = lexical_analysis(&test.lexer_info); @@ -1002,46 +842,6 @@ static TestResult test_Integer_u16_Underflow() { return pass_test(&test, result); } -static TestResult test_Integer_u16_Hex_Max() { - LexerTest test = start_up_test(SLS_STR("Integer u16 Hex Max"), SLS_STR("0xFFFF:u16")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_u16_Binary_Max() { - LexerTest test = start_up_test(SLS_STR("Integer u16 Binary Max"), SLS_STR("0b1111111111111111:u16")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_u16_Octal_Max() { - LexerTest test = start_up_test(SLS_STR("Integer u16 Octal Max"), SLS_STR("0o177777:u16")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_u16_Decimal_Mid() { - LexerTest test = start_up_test(SLS_STR("Integer u16 Decimal Mid"), SLS_STR("50000:u16")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 50000})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - static TestResult test_Integer_u32_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("Integer u32 Decimal Positive"), SLS_STR("42:u32")); LexerResult result = lexical_analysis(&test.lexer_info); @@ -1140,46 +940,6 @@ static TestResult test_Integer_u32_With_Underscores() { return pass_test(&test, result); } -static TestResult test_Integer_u32_Hex_Max() { - LexerTest test = start_up_test(SLS_STR("Integer u32 Hex Max"), SLS_STR("0xFFFFFFFF:u32")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4294967295})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_u32_Binary_Sample() { - LexerTest test = start_up_test(SLS_STR("Integer u32 Binary Sample"), SLS_STR("0b11111111000000001111111100000000:u32")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4278255360})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_u32_Octal_Max() { - LexerTest test = start_up_test(SLS_STR("Integer u32 Octal Max"), SLS_STR("0o37777777777:u32")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4294967295})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_u32_Decimal_Mid() { - LexerTest test = start_up_test(SLS_STR("Integer u32 Decimal Mid"), SLS_STR("1000000:u32")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 1000000})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - static TestResult test_Integer_u64_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("Integer u64 Decimal Positive"), SLS_STR("42:u64")); LexerResult result = lexical_analysis(&test.lexer_info); @@ -1278,6 +1038,246 @@ static TestResult test_Integer_u64_With_Underscores() { return pass_test(&test, result); } +static TestResult test_Integer_i8_Hex_Max() { + LexerTest test = start_up_test(SLS_STR("Integer i8 Hex Max"), SLS_STR("0x7F:i8")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i8_Binary_Max() { + LexerTest test = start_up_test(SLS_STR("Integer i8 Binary Max"), SLS_STR("0b01111111:i8")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i8_Octal_Max() { + LexerTest test = start_up_test(SLS_STR("Integer i8 Octal Max"), SLS_STR("0o177:i8")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i8_Negative_Hex() { + LexerTest test = start_up_test(SLS_STR("Integer i8 Negative Hex"), SLS_STR("-0x80:i8")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, -128})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u8_Hex_Max() { + LexerTest test = start_up_test(SLS_STR("Integer u8 Hex Max"), SLS_STR("0xFF:u8")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u8_Binary_Max() { + LexerTest test = start_up_test(SLS_STR("Integer u8 Binary Max"), SLS_STR("0b11111111:u8")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u8_Octal_Max() { + LexerTest test = start_up_test(SLS_STR("Integer u8 Octal Max"), SLS_STR("0o377:u8")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i16_Hex_Sample() { + LexerTest test = start_up_test(SLS_STR("Integer i16 Hex Sample"), SLS_STR("0x1234:i16")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 4660})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i16_Binary_Sample() { + LexerTest test = start_up_test(SLS_STR("Integer i16 Binary Sample"), SLS_STR("0b1111111100000000:i16")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, -256})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i16_Octal_Sample() { + LexerTest test = start_up_test(SLS_STR("Integer i16 Octal Sample"), SLS_STR("0o1234:i16")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 668})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u16_Hex_Max() { + LexerTest test = start_up_test(SLS_STR("Integer u16 Hex Max"), SLS_STR("0xFFFF:u16")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u16_Binary_Max() { + LexerTest test = start_up_test(SLS_STR("Integer u16 Binary Max"), SLS_STR("0b1111111111111111:u16")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u16_Octal_Max() { + LexerTest test = start_up_test(SLS_STR("Integer u16 Octal Max"), SLS_STR("0o177777:u16")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u16_Decimal_Mid() { + LexerTest test = start_up_test(SLS_STR("Integer u16 Decimal Mid"), SLS_STR("50000:u16")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 50000})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i32_Hex_Sample() { + LexerTest test = start_up_test(SLS_STR("Integer i32 Hex Sample"), SLS_STR("0xABCD:i32")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 43981})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i32_Binary_Sample() { + LexerTest test = start_up_test(SLS_STR("Integer i32 Binary Sample"), SLS_STR("0b11110000:i32")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 240})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u32_Hex_Max() { + LexerTest test = start_up_test(SLS_STR("Integer u32 Hex Max"), SLS_STR("0xFFFFFFFF:u32")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4294967295})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u32_Binary_Sample() { + LexerTest test = start_up_test(SLS_STR("Integer u32 Binary Sample"), SLS_STR("0b11111111000000001111111100000000:u32")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4278255360})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u32_Octal_Max() { + LexerTest test = start_up_test(SLS_STR("Integer u32 Octal Max"), SLS_STR("0o37777777777:u32")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4294967295})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u32_Decimal_Mid() { + LexerTest test = start_up_test(SLS_STR("Integer u32 Decimal Mid"), SLS_STR("1000000:u32")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 1000000})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i64_Decimal_Positive_42() { + LexerTest test = start_up_test(SLS_STR("Integer i64 Decimal Positive 42"), SLS_STR("42:i64")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 42})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i64_Hex_0xFF() { + LexerTest test = start_up_test(SLS_STR("Integer i64 Hex 0xFF"), SLS_STR("0xFF:i64")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 255})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i64_Binary_0b1010() { + LexerTest test = start_up_test(SLS_STR("Integer i64 Binary 0b1010"), SLS_STR("0b1010:i64")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 10})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i64_Octal_0o755() { + LexerTest test = start_up_test(SLS_STR("Integer i64 Octal 0o755"), SLS_STR("0o755:i64")); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 493})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + static TestResult test_Integer_u64_Hex_Max() { LexerTest test = start_up_test(SLS_STR("Integer u64 Hex Max"), SLS_STR("0xFFFFFFFFFFFFFFFF:u64")); LexerResult result = lexical_analysis(&test.lexer_info); @@ -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 decimal literal: unexpected ',' in decimal integer."))) return test.result; return pass_test(&test, result); } @@ -2073,12 +2073,12 @@ static TestResult test_Char_Right_Brace() { 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'")); +static TestResult test_Char_Escape_Backslash() { + LexerTest test = start_up_test(SLS_STR("Char Escape Backslash"), SLS_STR("'\\\\'")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; - if (test_character_value(&test, result, i++, &(uint8_t){0})) return test.result; + if (test_character_value(&test, result, i++, &(uint8_t){92})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } @@ -2103,26 +2103,6 @@ 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); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_character_value(&test, result, i++, &(uint8_t){92})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - 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); @@ -2133,62 +2113,22 @@ static TestResult test_Char_Escape_Tab() { return pass_test(&test, result); } -static TestResult test_Char_Hex_Lowercase_A() { - LexerTest test = start_up_test(SLS_STR("Char Hex Lowercase A"), SLS_STR("'\\x61'")); +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){97})) return test.result; + if (test_character_value(&test, result, i++, &(uint8_t){39})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Char_Hex_Uppercase_A() { - LexerTest test = start_up_test(SLS_STR("Char Hex Uppercase A"), SLS_STR("'\\x41'")); +static TestResult test_Char_Escape_Null_character() { + LexerTest test = start_up_test(SLS_STR("Char Escape Null character"), SLS_STR("'\\0'")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; - if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Char_Hex_Space() { - LexerTest test = start_up_test(SLS_STR("Char Hex Space"), SLS_STR("'\\x20'")); - LexerResult result = 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){32})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Char_Hex_Tab() { - LexerTest test = start_up_test(SLS_STR("Char Hex Tab"), SLS_STR("'\\x09'")); - LexerResult result = 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_Hex_Newline() { - LexerTest test = start_up_test(SLS_STR("Char Hex Newline"), SLS_STR("'\\x0A'")); - LexerResult result = 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){10})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Char_Hex_Max_ASCII() { - LexerTest test = start_up_test(SLS_STR("Char Hex Max ASCII"), SLS_STR("'\\x7F'")); - LexerResult result = 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){127})) return test.result; + if (test_character_value(&test, result, i++, &(uint8_t){0})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } @@ -2288,133 +2228,6 @@ static TestResult test_Char_Invalid_Escape() { return pass_test(&test, result); } -static TestResult test_Char_Hex_Escape_Too_Short() { - LexerTest test = start_up_test(SLS_STR("Char Hex Escape Too Short"), SLS_STR("'\\x4'")); - LexerResult result = 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; - return pass_test(&test, result); -} - -static TestResult test_Char_Hex_Escape_Too_Long() { - LexerTest test = start_up_test(SLS_STR("Char Hex Escape Too Long"), SLS_STR("'\\x414'")); - LexerResult result = 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; - return pass_test(&test, result); -} - -static TestResult test_Char_Hex_Invalid_Digit() { - LexerTest test = start_up_test(SLS_STR("Char Hex Invalid Digit"), SLS_STR("'\\xGG'")); - LexerResult result = 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; - return pass_test(&test, result); -} - -static TestResult test_Char_ASCII_Control_SOH() { - LexerTest test = start_up_test(SLS_STR("Char ASCII Control SOH"), SLS_STR("'\\x01'")); - LexerResult result = 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){1})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Char_ASCII_Control_BEL() { - LexerTest test = start_up_test(SLS_STR("Char ASCII Control BEL"), SLS_STR("'\\x07'")); - LexerResult result = 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){7})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Char_ASCII_Control_ESC() { - LexerTest test = start_up_test(SLS_STR("Char ASCII Control ESC"), SLS_STR("'\\x1B'")); - LexerResult result = 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){27})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Char_ASCII_Control_DEL() { - LexerTest test = start_up_test(SLS_STR("Char ASCII Control DEL"), SLS_STR("'\\x7F'")); - LexerResult result = 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){127})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Char_Extended_ASCII_Lower() { - LexerTest test = start_up_test(SLS_STR("Char Extended ASCII Lower"), SLS_STR("'\\x80'")); - LexerResult result = 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){128})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Char_Extended_ASCII_Upper() { - LexerTest test = start_up_test(SLS_STR("Char Extended ASCII Upper"), SLS_STR("'\\xFF'")); - LexerResult result = 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){255})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Char_Hex_Lowercase_x() { - LexerTest test = start_up_test(SLS_STR("Char Hex Lowercase x"), SLS_STR("'\\x41'")); - LexerResult result = 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){65})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Char_Hex_Digits_Uppercase() { - LexerTest test = start_up_test(SLS_STR("Char Hex Digits Uppercase"), SLS_STR("'\\xFF'")); - LexerResult result = 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){255})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Char_Hex_Digits_Lowercase() { - LexerTest test = start_up_test(SLS_STR("Char Hex Digits Lowercase"), SLS_STR("'\\xff'")); - LexerResult result = 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){255})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Char_Hex_Digits_Mixed() { - LexerTest test = start_up_test(SLS_STR("Char Hex Digits Mixed"), SLS_STR("'\\xAb'")); - LexerResult result = 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){171})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - static TestResult test_Identifier_Simple_Lowercase() { LexerTest test = start_up_test(SLS_STR("Identifier Simple Lowercase"), SLS_STR("hello")); LexerResult result = lexical_analysis(&test.lexer_info); @@ -2887,7 +2700,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("Invalid identifier literal: empty identifier after '::'."))) return test.result; return pass_test(&test, result); } @@ -3331,26 +3144,6 @@ static TestResult test_Bool_Numeric_0() { return pass_test(&test, result); } -static TestResult test_Bool_String_True() { - LexerTest test = start_up_test(SLS_STR("Bool String True"), SLS_STR("\"true\"")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_string_value(&test, result, i++, &SLS_STR("true"))) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Bool_String_False() { - LexerTest test = start_up_test(SLS_STR("Bool String False"), SLS_STR("\"false\"")); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_string_value(&test, result, i++, &SLS_STR("false"))) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - static TestResult test_Bool_Yes() { LexerTest test = start_up_test(SLS_STR("Bool Yes"), SLS_STR("yes")); LexerResult result = lexical_analysis(&test.lexer_info); @@ -3915,10 +3708,6 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_Integer_i8_Min_Value(); test_report.tests[i++] = test_Integer_i8_Overflow(); test_report.tests[i++] = test_Integer_i8_Underflow(); - test_report.tests[i++] = test_Integer_i8_Hex_Max(); - test_report.tests[i++] = test_Integer_i8_Binary_Max(); - test_report.tests[i++] = test_Integer_i8_Octal_Max(); - test_report.tests[i++] = test_Integer_i8_Negative_Hex(); test_report.tests[i++] = test_Integer_i16_Decimal_Positive(); test_report.tests[i++] = test_Integer_i16_Zero(); test_report.tests[i++] = test_Integer_i16_Decimal_Negative(); @@ -3929,9 +3718,6 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_Integer_i16_Min_Value(); test_report.tests[i++] = test_Integer_i16_Overflow(); test_report.tests[i++] = test_Integer_i16_Underflow(); - test_report.tests[i++] = test_Integer_i16_Hex_Sample(); - test_report.tests[i++] = test_Integer_i16_Binary_Sample(); - test_report.tests[i++] = test_Integer_i16_Octal_Sample(); test_report.tests[i++] = test_Integer_i32_Decimal_Positive(); test_report.tests[i++] = test_Integer_i32_Zero(); test_report.tests[i++] = test_Integer_i32_Decimal_Negative(); @@ -3943,8 +3729,6 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_Integer_i32_Overflow(); test_report.tests[i++] = test_Integer_i32_Underflow(); test_report.tests[i++] = test_Integer_i32_With_Underscores(); - test_report.tests[i++] = test_Integer_i32_Hex_Sample(); - test_report.tests[i++] = test_Integer_i32_Binary_Sample(); test_report.tests[i++] = test_Integer_i64_Decimal_Positive(); test_report.tests[i++] = test_Integer_i64_Zero(); test_report.tests[i++] = test_Integer_i64_Decimal_Negative(); @@ -3956,10 +3740,6 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_Integer_i64_Overflow(); test_report.tests[i++] = test_Integer_i64_Underflow(); test_report.tests[i++] = test_Integer_i64_With_Underscores(); - test_report.tests[i++] = test_Integer_i64_Decimal_Positive_42(); - test_report.tests[i++] = test_Integer_i64_Hex_0xFF(); - test_report.tests[i++] = test_Integer_i64_Binary_0b1010(); - test_report.tests[i++] = test_Integer_i64_Octal_0o755(); test_report.tests[i++] = test_Integer_u8_Decimal_Positive(); test_report.tests[i++] = test_Integer_u8_Zero(); test_report.tests[i++] = test_Integer_u8_Hex(); @@ -3969,9 +3749,6 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_Integer_u8_Min_Value(); test_report.tests[i++] = test_Integer_u8_Overflow(); test_report.tests[i++] = test_Integer_u8_Underflow(); - test_report.tests[i++] = test_Integer_u8_Hex_Max(); - test_report.tests[i++] = test_Integer_u8_Binary_Max(); - test_report.tests[i++] = test_Integer_u8_Octal_Max(); test_report.tests[i++] = test_Integer_u16_Decimal_Positive(); test_report.tests[i++] = test_Integer_u16_Zero(); test_report.tests[i++] = test_Integer_u16_Hex(); @@ -3981,10 +3758,6 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_Integer_u16_Min_Value(); test_report.tests[i++] = test_Integer_u16_Overflow(); test_report.tests[i++] = test_Integer_u16_Underflow(); - test_report.tests[i++] = test_Integer_u16_Hex_Max(); - test_report.tests[i++] = test_Integer_u16_Binary_Max(); - test_report.tests[i++] = test_Integer_u16_Octal_Max(); - test_report.tests[i++] = test_Integer_u16_Decimal_Mid(); test_report.tests[i++] = test_Integer_u32_Decimal_Positive(); test_report.tests[i++] = test_Integer_u32_Zero(); test_report.tests[i++] = test_Integer_u32_Hex(); @@ -3995,10 +3768,6 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_Integer_u32_Overflow(); test_report.tests[i++] = test_Integer_u32_Underflow(); test_report.tests[i++] = test_Integer_u32_With_Underscores(); - test_report.tests[i++] = test_Integer_u32_Hex_Max(); - test_report.tests[i++] = test_Integer_u32_Binary_Sample(); - test_report.tests[i++] = test_Integer_u32_Octal_Max(); - test_report.tests[i++] = test_Integer_u32_Decimal_Mid(); test_report.tests[i++] = test_Integer_u64_Decimal_Positive(); test_report.tests[i++] = test_Integer_u64_Zero(); test_report.tests[i++] = test_Integer_u64_Hex(); @@ -4009,6 +3778,30 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_Integer_u64_Overflow(); test_report.tests[i++] = test_Integer_u64_Underflow(); test_report.tests[i++] = test_Integer_u64_With_Underscores(); + test_report.tests[i++] = test_Integer_i8_Hex_Max(); + test_report.tests[i++] = test_Integer_i8_Binary_Max(); + test_report.tests[i++] = test_Integer_i8_Octal_Max(); + test_report.tests[i++] = test_Integer_i8_Negative_Hex(); + test_report.tests[i++] = test_Integer_u8_Hex_Max(); + test_report.tests[i++] = test_Integer_u8_Binary_Max(); + test_report.tests[i++] = test_Integer_u8_Octal_Max(); + test_report.tests[i++] = test_Integer_i16_Hex_Sample(); + test_report.tests[i++] = test_Integer_i16_Binary_Sample(); + test_report.tests[i++] = test_Integer_i16_Octal_Sample(); + test_report.tests[i++] = test_Integer_u16_Hex_Max(); + test_report.tests[i++] = test_Integer_u16_Binary_Max(); + test_report.tests[i++] = test_Integer_u16_Octal_Max(); + test_report.tests[i++] = test_Integer_u16_Decimal_Mid(); + test_report.tests[i++] = test_Integer_i32_Hex_Sample(); + test_report.tests[i++] = test_Integer_i32_Binary_Sample(); + test_report.tests[i++] = test_Integer_u32_Hex_Max(); + test_report.tests[i++] = test_Integer_u32_Binary_Sample(); + test_report.tests[i++] = test_Integer_u32_Octal_Max(); + test_report.tests[i++] = test_Integer_u32_Decimal_Mid(); + test_report.tests[i++] = test_Integer_i64_Decimal_Positive_42(); + test_report.tests[i++] = test_Integer_i64_Hex_0xFF(); + test_report.tests[i++] = test_Integer_i64_Binary_0b1010(); + test_report.tests[i++] = test_Integer_i64_Octal_0o755(); test_report.tests[i++] = test_Integer_u64_Hex_Max(); test_report.tests[i++] = test_Integer_u64_Binary_Sample(); test_report.tests[i++] = test_Integer_u64_Octal_Sample(); @@ -4089,18 +3882,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_Null_character(); + test_report.tests[i++] = test_Char_Escape_Backslash(); test_report.tests[i++] = test_Char_Escape_Carriage_return(); test_report.tests[i++] = test_Char_Escape_Newline(); - 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(); - test_report.tests[i++] = test_Char_Hex_Tab(); - test_report.tests[i++] = test_Char_Hex_Newline(); - test_report.tests[i++] = test_Char_Hex_Max_ASCII(); + test_report.tests[i++] = test_Char_Escape_Single_quote(); + test_report.tests[i++] = test_Char_Escape_Null_character(); test_report.tests[i++] = test_Char_With_Leading_Whitespace(); test_report.tests[i++] = test_Char_With_Trailing_Whitespace(); test_report.tests[i++] = test_Char_With_Both_Whitespace(); @@ -4111,19 +3898,6 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_Char_Unclosed_Quote(); test_report.tests[i++] = test_Char_Unescaped_Newline(); test_report.tests[i++] = test_Char_Invalid_Escape(); - test_report.tests[i++] = test_Char_Hex_Escape_Too_Short(); - test_report.tests[i++] = test_Char_Hex_Escape_Too_Long(); - test_report.tests[i++] = test_Char_Hex_Invalid_Digit(); - test_report.tests[i++] = test_Char_ASCII_Control_SOH(); - test_report.tests[i++] = test_Char_ASCII_Control_BEL(); - test_report.tests[i++] = test_Char_ASCII_Control_ESC(); - test_report.tests[i++] = test_Char_ASCII_Control_DEL(); - test_report.tests[i++] = test_Char_Extended_ASCII_Lower(); - test_report.tests[i++] = test_Char_Extended_ASCII_Upper(); - test_report.tests[i++] = test_Char_Hex_Lowercase_x(); - test_report.tests[i++] = test_Char_Hex_Digits_Uppercase(); - test_report.tests[i++] = test_Char_Hex_Digits_Lowercase(); - test_report.tests[i++] = test_Char_Hex_Digits_Mixed(); test_report.tests[i++] = test_Identifier_Simple_Lowercase(); test_report.tests[i++] = test_Identifier_Simple_Uppercase(); test_report.tests[i++] = test_Identifier_Mixed_Case(); @@ -4216,8 +3990,6 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_Bool_False_Mixed_Case(); test_report.tests[i++] = test_Bool_Numeric_1(); test_report.tests[i++] = test_Bool_Numeric_0(); - test_report.tests[i++] = test_Bool_String_True(); - test_report.tests[i++] = test_Bool_String_False(); test_report.tests[i++] = test_Bool_Yes(); test_report.tests[i++] = test_Bool_No(); test_report.tests[i++] = test_Bool_Typo_Ture(); diff --git a/SLS_Tests/cases.yaml b/SLS_Tests/cases.yaml index ce33736..fd82916 100644 --- a/SLS_Tests/cases.yaml +++ b/SLS_Tests/cases.yaml @@ -362,54 +362,6 @@ tokens: - type: error value: 'Integer overflow: value exceeds range for i8.' -- name: Integer i8 Hex Max - code: 0x7F:i8 - tokens: - - type: i8 - value: 127 - operations: - - function: push - type: i8 - value: 127 - stack_final: - - type: i8 - value: 127 -- name: Integer i8 Binary Max - code: 0b01111111:i8 - tokens: - - type: i8 - value: 127 - operations: - - function: push - type: i8 - value: 127 - stack_final: - - type: i8 - value: 127 -- name: Integer i8 Octal Max - code: 0o177:i8 - tokens: - - type: i8 - value: 127 - operations: - - function: push - type: i8 - value: 127 - stack_final: - - type: i8 - value: 127 -- name: Integer i8 Negative Hex - code: -0x80:i8 - tokens: - - type: i8 - value: -128 - operations: - - function: push - type: i8 - value: -128 - stack_final: - - type: i8 - value: -128 - name: Integer i16 Decimal Positive code: 42:i16 tokens: @@ -516,42 +468,6 @@ tokens: - type: error value: 'Integer overflow: value exceeds range for i16.' -- name: Integer i16 Hex Sample - code: 0x1234:i16 - tokens: - - type: i16 - value: 4660 - operations: - - function: push - type: i16 - value: 4660 - stack_final: - - type: i16 - value: 4660 -- name: Integer i16 Binary Sample - code: 0b1111111100000000:i16 - tokens: - - type: i16 - value: 65280 - operations: - - function: push - type: i16 - value: 65280 - stack_final: - - type: i16 - value: 65280 -- name: Integer i16 Octal Sample - code: 0o1234:i16 - tokens: - - type: i16 - value: 668 - operations: - - function: push - type: i16 - value: 668 - stack_final: - - type: i16 - value: 668 - name: Integer i32 Decimal Positive code: 42:i32 tokens: @@ -670,30 +586,6 @@ stack_final: - type: i32 value: 1000000 -- name: Integer i32 Hex Sample - code: 0xABCD:i32 - tokens: - - type: i32 - value: 43981 - operations: - - function: push - type: i32 - value: 43981 - stack_final: - - type: i32 - value: 43981 -- name: Integer i32 Binary Sample - code: 0b11110000:i32 - tokens: - - type: i32 - value: 240 - operations: - - function: push - type: i32 - value: 240 - stack_final: - - type: i32 - value: 240 - name: Integer i64 Decimal Positive code: 42:i64 tokens: @@ -812,54 +704,6 @@ stack_final: - type: i64 value: 1000000 -- name: Integer i64 Decimal Positive 42 - code: 42:i64 - tokens: - - type: i64 - value: 42 - operations: - - function: push - type: i64 - value: 42 - stack_final: - - type: i64 - value: 42 -- name: Integer i64 Hex 0xFF - code: 0xFF:i64 - tokens: - - type: i64 - value: 255 - operations: - - function: push - type: i64 - value: 255 - stack_final: - - type: i64 - value: 255 -- name: Integer i64 Binary 0b1010 - code: 0b1010:i64 - tokens: - - type: i64 - value: 10 - operations: - - function: push - type: i64 - value: 10 - stack_final: - - type: i64 - value: 10 -- name: Integer i64 Octal 0o755 - code: 0o755:i64 - tokens: - - type: i64 - value: 493 - operations: - - function: push - type: i64 - value: 493 - stack_final: - - type: i64 - value: 493 - name: Integer u8 Decimal Positive code: 42:u8 tokens: @@ -954,42 +798,6 @@ tokens: - type: error value: 'Integer overflow: value exceeds range for u8.' -- name: Integer u8 Hex Max - code: 0xFF:u8 - tokens: - - type: u8 - value: 255 - operations: - - function: push - type: u8 - value: 255 - stack_final: - - type: u8 - value: 255 -- name: Integer u8 Binary Max - code: 0b11111111:u8 - tokens: - - type: u8 - value: 255 - operations: - - function: push - type: u8 - value: 255 - stack_final: - - type: u8 - value: 255 -- name: Integer u8 Octal Max - code: 0o377:u8 - tokens: - - type: u8 - value: 255 - operations: - - function: push - type: u8 - value: 255 - stack_final: - - type: u8 - value: 255 - name: Integer u16 Decimal Positive code: 42:u16 tokens: @@ -1084,54 +892,6 @@ tokens: - type: error value: 'Integer overflow: value exceeds range for u16.' -- name: Integer u16 Hex Max - code: 0xFFFF:u16 - tokens: - - type: u16 - value: 65535 - operations: - - function: push - type: u16 - value: 65535 - stack_final: - - type: u16 - value: 65535 -- name: Integer u16 Binary Max - code: 0b1111111111111111:u16 - tokens: - - type: u16 - value: 65535 - operations: - - function: push - type: u16 - value: 65535 - stack_final: - - type: u16 - value: 65535 -- name: Integer u16 Octal Max - code: 0o177777:u16 - tokens: - - type: u16 - value: 65535 - operations: - - function: push - type: u16 - value: 65535 - stack_final: - - type: u16 - value: 65535 -- name: Integer u16 Decimal Mid - code: 50000:u16 - tokens: - - type: u16 - value: 50000 - operations: - - function: push - type: u16 - value: 50000 - stack_final: - - type: u16 - value: 50000 - name: Integer u32 Decimal Positive code: 42:u32 tokens: @@ -1238,54 +998,6 @@ stack_final: - type: u32 value: 1000000 -- name: Integer u32 Hex Max - code: 0xFFFFFFFF:u32 - tokens: - - type: u32 - value: 4294967295 - operations: - - function: push - type: u32 - value: 4294967295 - stack_final: - - type: u32 - value: 4294967295 -- name: Integer u32 Binary Sample - code: 0b11111111000000001111111100000000:u32 - tokens: - - type: u32 - value: 4278255360 - operations: - - function: push - type: u32 - value: 4278255360 - stack_final: - - type: u32 - value: 4278255360 -- name: Integer u32 Octal Max - code: 0o37777777777:u32 - tokens: - - type: u32 - value: 4294967295 - operations: - - function: push - type: u32 - value: 4294967295 - stack_final: - - type: u32 - value: 4294967295 -- name: Integer u32 Decimal Mid - code: 1000000:u32 - tokens: - - type: u32 - value: 1000000 - operations: - - function: push - type: u32 - value: 1000000 - stack_final: - - type: u32 - value: 1000000 - name: Integer u64 Decimal Positive code: 42:u64 tokens: @@ -1392,6 +1104,294 @@ stack_final: - type: u64 value: 1000000 +- name: Integer i8 Hex Max + code: 0x7F:i8 + tokens: + - type: i8 + value: 127 + operations: + - function: push + type: i8 + value: 127 + stack_final: + - type: i8 + value: 127 +- name: Integer i8 Binary Max + code: 0b01111111:i8 + tokens: + - type: i8 + value: 127 + operations: + - function: push + type: i8 + value: 127 + stack_final: + - type: i8 + value: 127 +- name: Integer i8 Octal Max + code: 0o177:i8 + tokens: + - type: i8 + value: 127 + operations: + - function: push + type: i8 + value: 127 + stack_final: + - type: i8 + value: 127 +- name: Integer i8 Negative Hex + code: -0x80:i8 + tokens: + - type: i8 + value: -128 + operations: + - function: push + type: i8 + value: -128 + stack_final: + - type: i8 + value: -128 +- name: Integer u8 Hex Max + code: 0xFF:u8 + tokens: + - type: u8 + value: 255 + operations: + - function: push + type: u8 + value: 255 + stack_final: + - type: u8 + value: 255 +- name: Integer u8 Binary Max + code: 0b11111111:u8 + tokens: + - type: u8 + value: 255 + operations: + - function: push + type: u8 + value: 255 + stack_final: + - type: u8 + value: 255 +- name: Integer u8 Octal Max + code: 0o377:u8 + tokens: + - type: u8 + value: 255 + operations: + - function: push + type: u8 + value: 255 + stack_final: + - type: u8 + value: 255 +- name: Integer i16 Hex Sample + code: 0x1234:i16 + tokens: + - type: i16 + value: 4660 + operations: + - function: push + type: i16 + value: 4660 + stack_final: + - type: i16 + value: 4660 +- name: Integer i16 Binary Sample + code: 0b1111111100000000:i16 + tokens: + - type: i16 + value: -256 + operations: + - function: push + type: i16 + value: -256 + stack_final: + - type: i16 + value: -256 +- name: Integer i16 Octal Sample + code: 0o1234:i16 + tokens: + - type: i16 + value: 668 + operations: + - function: push + type: i16 + value: 668 + stack_final: + - type: i16 + value: 668 +- name: Integer u16 Hex Max + code: 0xFFFF:u16 + tokens: + - type: u16 + value: 65535 + operations: + - function: push + type: u16 + value: 65535 + stack_final: + - type: u16 + value: 65535 +- name: Integer u16 Binary Max + code: 0b1111111111111111:u16 + tokens: + - type: u16 + value: 65535 + operations: + - function: push + type: u16 + value: 65535 + stack_final: + - type: u16 + value: 65535 +- name: Integer u16 Octal Max + code: 0o177777:u16 + tokens: + - type: u16 + value: 65535 + operations: + - function: push + type: u16 + value: 65535 + stack_final: + - type: u16 + value: 65535 +- name: Integer u16 Decimal Mid + code: 50000:u16 + tokens: + - type: u16 + value: 50000 + operations: + - function: push + type: u16 + value: 50000 + stack_final: + - type: u16 + value: 50000 +- name: Integer i32 Hex Sample + code: 0xABCD:i32 + tokens: + - type: i32 + value: 43981 + operations: + - function: push + type: i32 + value: 43981 + stack_final: + - type: i32 + value: 43981 +- name: Integer i32 Binary Sample + code: 0b11110000:i32 + tokens: + - type: i32 + value: 240 + operations: + - function: push + type: i32 + value: 240 + stack_final: + - type: i32 + value: 240 +- name: Integer u32 Hex Max + code: 0xFFFFFFFF:u32 + tokens: + - type: u32 + value: 4294967295 + operations: + - function: push + type: u32 + value: 4294967295 + stack_final: + - type: u32 + value: 4294967295 +- name: Integer u32 Binary Sample + code: 0b11111111000000001111111100000000:u32 + tokens: + - type: u32 + value: 4278255360 + operations: + - function: push + type: u32 + value: 4278255360 + stack_final: + - type: u32 + value: 4278255360 +- name: Integer u32 Octal Max + code: 0o37777777777:u32 + tokens: + - type: u32 + value: 4294967295 + operations: + - function: push + type: u32 + value: 4294967295 + stack_final: + - type: u32 + value: 4294967295 +- name: Integer u32 Decimal Mid + code: 1000000:u32 + tokens: + - type: u32 + value: 1000000 + operations: + - function: push + type: u32 + value: 1000000 + stack_final: + - type: u32 + value: 1000000 +- name: Integer i64 Decimal Positive 42 + code: 42:i64 + tokens: + - type: i64 + value: 42 + operations: + - function: push + type: i64 + value: 42 + stack_final: + - type: i64 + value: 42 +- name: Integer i64 Hex 0xFF + code: 0xFF:i64 + tokens: + - type: i64 + value: 255 + operations: + - function: push + type: i64 + value: 255 + stack_final: + - type: i64 + value: 255 +- name: Integer i64 Binary 0b1010 + code: 0b1010:i64 + tokens: + - type: i64 + value: 10 + operations: + - function: push + type: i64 + value: 10 + stack_final: + - type: i64 + value: 10 +- name: Integer i64 Octal 0o755 + code: 0o755:i64 + tokens: + - type: i64 + value: 493 + operations: + - function: push + type: i64 + value: 493 + stack_final: + - type: i64 + value: 493 - name: Integer u64 Hex Max code: 0xFFFFFFFFFFFFFFFF:u64 tokens: @@ -1824,7 +1824,7 @@ code: 1,234.56 tokens: - type: error - value: 'Invalid float literal: unexpected '','' in float.' + value: 'Invalid decimal literal: unexpected '','' in decimal integer.' - name: Float Default Leading Whitespace code: ' 3.14' tokens: @@ -2317,18 +2317,18 @@ stack_final: - type: char value: '}' -- name: Char Escape Null character - code: '''\\0''' +- name: Char Escape Backslash + code: '''\\\\''' tokens: - type: char - value: "\0" + value: \ operations: - function: push type: char - value: "\0" + value: \ stack_final: - type: char - value: "\0" + value: \ - name: Char Escape Carriage return code: '''\\r''' tokens: @@ -2359,30 +2359,6 @@ value: ' ' -- name: Char Escape Single quote - code: '''\\''''' - tokens: - - type: char - value: '''' - operations: - - function: push - type: char - value: '''' - stack_final: - - type: char - value: '''' -- name: Char Escape Backslash - code: '''\\\\''' - tokens: - - type: char - value: \ - operations: - - function: push - type: char - value: \ - stack_final: - - type: char - value: \ - name: Char Escape Tab code: '''\\t''' tokens: @@ -2395,84 +2371,30 @@ stack_final: - type: char value: "\t" -- name: Char Hex Lowercase A - code: '''\\x61''' +- name: Char Escape Single quote + code: '''\\''''' tokens: - type: char - value: a + value: '''' operations: - function: push type: char - value: a + value: '''' stack_final: - type: char - value: a -- name: Char Hex Uppercase A - code: '''\\x41''' + value: '''' +- name: Char Escape Null character + code: '''\\0''' tokens: - type: char - value: A + value: "\0" operations: - function: push type: char - value: A + value: "\0" stack_final: - type: char - value: A -- name: Char Hex Space - code: '''\\x20''' - tokens: - - type: char - value: ' ' - operations: - - function: push - type: char - value: ' ' - stack_final: - - type: char - value: ' ' -- name: Char Hex Tab - code: '''\\x09''' - tokens: - - type: char - value: "\t" - operations: - - function: push - type: char - value: "\t" - stack_final: - - type: char - value: "\t" -- name: Char Hex Newline - code: '''\\x0A''' - tokens: - - type: char - value: ' - - ' - operations: - - function: push - type: char - value: ' - - ' - stack_final: - - type: char - value: ' - - ' -- name: Char Hex Max ASCII - code: '''\\x7F''' - tokens: - - type: char - value: "\x7F" - operations: - - function: push - type: char - value: "\x7F" - stack_final: - - type: char - value: "\x7F" + value: "\0" - name: Char With Leading Whitespace code: ' ''A''' tokens: @@ -2558,141 +2480,6 @@ tokens: - type: error value: 'Invalid character literal: unknown escape sequence ''\\q''.' -- name: Char Hex Escape Too Short - code: '''\\x4''' - tokens: - - type: error - value: 'Invalid character literal: hexadecimal escape must have exactly 2 digits.' -- name: Char Hex Escape Too Long - code: '''\\x414''' - tokens: - - type: error - value: 'Invalid character literal: hexadecimal escape must have exactly 2 digits.' -- name: Char Hex Invalid Digit - code: '''\\xGG''' - tokens: - - type: error - value: 'Invalid character literal: invalid hexadecimal digit ''G''.' -- name: Char ASCII Control SOH - code: '''\\x01''' - tokens: - - type: char - value: "\x01" - operations: - - function: push - type: char - value: "\x01" - stack_final: - - type: char - value: "\x01" -- name: Char ASCII Control BEL - code: '''\\x07''' - tokens: - - type: char - value: "\a" - operations: - - function: push - type: char - value: "\a" - stack_final: - - type: char - value: "\a" -- name: Char ASCII Control ESC - code: '''\\x1B''' - tokens: - - type: char - value: "\e" - operations: - - function: push - type: char - value: "\e" - stack_final: - - type: char - value: "\e" -- name: Char ASCII Control DEL - code: '''\\x7F''' - tokens: - - type: char - value: "\x7F" - operations: - - function: push - type: char - value: "\x7F" - stack_final: - - type: char - value: "\x7F" -- name: Char Extended ASCII Lower - code: '''\\x80''' - tokens: - - type: char - value: "\x80" - operations: - - function: push - type: char - value: "\x80" - stack_final: - - type: char - value: "\x80" -- name: Char Extended ASCII Upper - code: '''\\xFF''' - tokens: - - type: char - value: "\xFF" - operations: - - function: push - type: char - value: "\xFF" - stack_final: - - type: char - value: "\xFF" -- name: Char Hex Lowercase x - code: '''\\x41''' - tokens: - - type: char - value: A - operations: - - function: push - type: char - value: A - stack_final: - - type: char - value: A -- name: Char Hex Digits Uppercase - code: '''\\xFF''' - tokens: - - type: char - value: "\xFF" - operations: - - function: push - type: char - value: "\xFF" - stack_final: - - type: char - value: "\xFF" -- name: Char Hex Digits Lowercase - code: '''\\xff''' - tokens: - - type: char - value: "\xFF" - operations: - - function: push - type: char - value: "\xFF" - stack_final: - - type: char - value: "\xFF" -- name: Char Hex Digits Mixed - code: '''\\xAb''' - tokens: - - type: char - value: "\xAB" - operations: - - function: push - type: char - value: "\xAB" - stack_final: - - type: char - value: "\xAB" - name: Identifier Simple Lowercase code: hello tokens: @@ -3240,7 +3027,7 @@ code: '::' tokens: - type: error - value: 'Unexpected character: unexpected '':'' during parsing.' + value: 'Invalid identifier literal: empty identifier after ''::''.' - name: Identifier Case Lower code: variable tokens: @@ -3769,30 +3556,6 @@ stack_final: - type: i64 value: 0 -- name: Bool String True - code: '"true"' - tokens: - - type: string - value: 'true' - operations: - - function: push - type: string - value: 'true' - stack_final: - - type: string - value: 'true' -- name: Bool String False - code: '"false"' - tokens: - - type: string - value: 'false' - operations: - - function: push - type: string - value: 'false' - stack_final: - - type: string - value: 'false' - name: Bool Yes code: 'yes' tokens: diff --git a/SLS_Tests/generate_tests/base_tests.py b/SLS_Tests/generate_tests/base_tests.py index d4e60d6..685ba45 100644 --- a/SLS_Tests/generate_tests/base_tests.py +++ b/SLS_Tests/generate_tests/base_tests.py @@ -54,6 +54,7 @@ class BaseTestGenerator(ABC): ENABLE_UNICODE = False ENABLE_EXPONENTIAL_LITERALS = False + ENABLE_CHAR_HEX_ESCAPE = False ENABLE_STRINGS = False __generators: "ClassVar[List[Type[BaseTestGenerator]]]" = [] diff --git a/SLS_Tests/generate_tests/char_tests.py b/SLS_Tests/generate_tests/char_tests.py index 1ef2b3e..f461606 100644 --- a/SLS_Tests/generate_tests/char_tests.py +++ b/SLS_Tests/generate_tests/char_tests.py @@ -74,13 +74,14 @@ class CharTestGenerator(BaseTestGenerator): def generate_hexadecimal_escape_tests(self): """Generate tests for hexadecimal escape sequences.""" - # Additional specific hex escapes - self.make_success_test("Char Hex Lowercase A", "'\\\\x61'", "char", 'a') - self.make_success_test("Char Hex Uppercase A", "'\\\\x41'", "char", 'A') - self.make_success_test("Char Hex Space", "'\\\\x20'", "char", ' ') - self.make_success_test("Char Hex Tab", "'\\\\x09'", "char", '\t') - self.make_success_test("Char Hex Newline", "'\\\\x0A'", "char", '\n') - self.make_success_test("Char Hex Max ASCII", "'\\\\x7F'", "char", '\x7F') + if self.ENABLE_CHAR_HEX_ESCAPE: + # Additional specific hex escapes + self.make_success_test("Char Hex Lowercase A", "'\\\\x61'", "char", 'a') + self.make_success_test("Char Hex Uppercase A", "'\\\\x41'", "char", 'A') + self.make_success_test("Char Hex Space", "'\\\\x20'", "char", ' ') + self.make_success_test("Char Hex Tab", "'\\\\x09'", "char", '\t') + self.make_success_test("Char Hex Newline", "'\\\\x0A'", "char", '\n') + self.make_success_test("Char Hex Max ASCII", "'\\\\x7F'", "char", '\x7F') def generate_unicode_escape_tests(self): """Generate tests for Unicode escape sequences.""" @@ -165,18 +166,19 @@ class CharTestGenerator(BaseTestGenerator): "Invalid character literal: unknown escape sequence '\\\\q'.") # Invalid hex escape (not 2 digits) - self.make_error_test("Char Hex Escape Too Short", - "'\\\\x4'", - "Invalid character literal: hexadecimal escape must have exactly 2 digits.") - - self.make_error_test("Char Hex Escape Too Long", - "'\\\\x414'", - "Invalid character literal: hexadecimal escape must have exactly 2 digits.") - - # Invalid hex digits - self.make_error_test("Char Hex Invalid Digit", - "'\\\\xGG'", - "Invalid character literal: invalid hexadecimal digit 'G'.") + if self.ENABLE_CHAR_HEX_ESCAPE: + self.make_error_test("Char Hex Escape Too Short", + "'\\\\x4'", + "Invalid character literal: hexadecimal escape must have exactly 2 digits.") + + self.make_error_test("Char Hex Escape Too Long", + "'\\\\x414'", + "Invalid character literal: hexadecimal escape must have exactly 2 digits.") + + # Invalid hex digits + self.make_error_test("Char Hex Invalid Digit", + "'\\\\xGG'", + "Invalid character literal: invalid hexadecimal digit 'G'.") if self.ENABLE_UNICODE: # Invalid Unicode escape (no braces) @@ -215,15 +217,16 @@ class CharTestGenerator(BaseTestGenerator): def generate_edge_case_tests(self): """Generate edge case tests.""" - # ASCII control characters - self.make_success_test("Char ASCII Control SOH", "'\\\\x01'", "char", '\x01') - self.make_success_test("Char ASCII Control BEL", "'\\\\x07'", "char", '\x07') - self.make_success_test("Char ASCII Control ESC", "'\\\\x1B'", "char", '\x1B') - self.make_success_test("Char ASCII Control DEL", "'\\\\x7F'", "char", '\x7F') - - # Extended ASCII - self.make_success_test("Char Extended ASCII Lower", "'\\\\x80'", "char", '\x80') - self.make_success_test("Char Extended ASCII Upper", "'\\\\xFF'", "char", '\xFF') + if self.ENABLE_CHAR_HEX_ESCAPE: + # ASCII control characters + self.make_success_test("Char ASCII Control SOH", "'\\\\x01'", "char", '\x01') + self.make_success_test("Char ASCII Control BEL", "'\\\\x07'", "char", '\x07') + self.make_success_test("Char ASCII Control ESC", "'\\\\x1B'", "char", '\x1B') + self.make_success_test("Char ASCII Control DEL", "'\\\\x7F'", "char", '\x7F') + + # Extended ASCII + self.make_success_test("Char Extended ASCII Lower", "'\\\\x80'", "char", '\x80') + self.make_success_test("Char Extended ASCII Upper", "'\\\\xFF'", "char", '\xFF') if self.ENABLE_UNICODE: # Zero-width characters @@ -245,13 +248,14 @@ class CharTestGenerator(BaseTestGenerator): def generate_case_sensitivity_tests(self): """Generate tests for case sensitivity in escape sequences.""" - # Hex escapes - lowercase x - self.make_success_test("Char Hex Lowercase x", "'\\\\x41'", "char", 'A') - - # Hex digits - both cases - self.make_success_test("Char Hex Digits Uppercase", "'\\\\xFF'", "char", '\xFF') - self.make_success_test("Char Hex Digits Lowercase", "'\\\\xff'", "char", '\xff') - self.make_success_test("Char Hex Digits Mixed", "'\\\\xAb'", "char", '\xAB') + if self.ENABLE_CHAR_HEX_ESCAPE: + # Hex escapes - lowercase x + self.make_success_test("Char Hex Lowercase x", "'\\\\x41'", "char", 'A') + + # Hex digits - both cases + self.make_success_test("Char Hex Digits Uppercase", "'\\\\xFF'", "char", '\xFF') + self.make_success_test("Char Hex Digits Lowercase", "'\\\\xff'", "char", '\xff') + self.make_success_test("Char Hex Digits Mixed", "'\\\\xAb'", "char", '\xAB') if self.ENABLE_UNICODE: # Unicode escapes - lowercase u diff --git a/SLS_Tests/generate_tests/float_tests.py b/SLS_Tests/generate_tests/float_tests.py index f4769da..f430453 100644 --- a/SLS_Tests/generate_tests/float_tests.py +++ b/SLS_Tests/generate_tests/float_tests.py @@ -221,7 +221,7 @@ class FloatTestGenerator(BaseTestGenerator): # Comma separators not allowed self.make_error_test("Float Invalid Comma Separator", "1,234.56", - "Invalid float literal: unexpected ',' in float.") + "Invalid decimal literal: unexpected ',' in decimal integer.") def generate_whitespace_tests(self): """Generate tests with whitespace.""" diff --git a/SLS_Tests/generate_tests/idents_and_bools_tests.py b/SLS_Tests/generate_tests/idents_and_bools_tests.py index 105912a..cfba7fd 100644 --- a/SLS_Tests/generate_tests/idents_and_bools_tests.py +++ b/SLS_Tests/generate_tests/idents_and_bools_tests.py @@ -210,7 +210,7 @@ class IdentifierTestGenerator(BaseTestGenerator): # Empty identifier literal self.make_error_test("Identifier Literal Empty", "::", - "Unexpected character: unexpected ':' during parsing.") + "Invalid identifier literal: empty identifier after '::'.") def generate_case_sensitivity_tests(self): """Generate tests showing case sensitivity.""" @@ -322,11 +322,12 @@ class BooleanTestGenerator(BaseTestGenerator): self.make_success_test("Bool Numeric 0", "0", "i64", 0) # String representations - self.make_success_test("Bool String True", '"true"', - "string", "true") - - self.make_success_test("Bool String False", '"false"', - "string", "false") + if self.ENABLE_STRINGS: + self.make_success_test("Bool String True", '"true"', + "string", "true") + + self.make_success_test("Bool String False", '"false"', + "string", "false") # Other languages self.make_success_test("Bool Yes", "yes", diff --git a/SLS_Tests/generate_tests/integer_tests.py b/SLS_Tests/generate_tests/integer_tests.py index e8ba75c..fc10831 100644 --- a/SLS_Tests/generate_tests/integer_tests.py +++ b/SLS_Tests/generate_tests/integer_tests.py @@ -141,69 +141,59 @@ class IntegerTestGenerator(BaseTestGenerator): f"{underflow_val}:{type_name}", f"Integer overflow: value exceeds range for {type_name}.") - def generate_special_typed_tests(self, type_name: str): - """Generate special tests for specific types.""" - min_val, max_val = self.TYPE_RANGES[type_name] - is_unsigned = type_name.startswith('u') - # Underscores with type annotation - if max_val >= 1000000: + if max_range >= 1000000: self.make_success_test(f"Integer {type_name} With Underscores", f"1_000_000:{type_name}", type_name, 1000000) + def generate_special_typed_tests(self): + """Generate special tests for specific types.""" + # Special values for specific types - if type_name == 'i8': - self.make_success_test("Integer i8 Hex Max", "0x7F:i8", "i8", 127) - self.make_success_test("Integer i8 Binary Max", "0b01111111:i8", "i8", 127) - self.make_success_test("Integer i8 Octal Max", "0o177:i8", "i8", 127) - self.make_success_test("Integer i8 Negative Hex", "-0x80:i8", "i8", -128) + self.make_success_test("Integer i8 Hex Max", "0x7F:i8", "i8", 127) + self.make_success_test("Integer i8 Binary Max", "0b01111111:i8", "i8", 127) + self.make_success_test("Integer i8 Octal Max", "0o177:i8", "i8", 127) + self.make_success_test("Integer i8 Negative Hex", "-0x80:i8", "i8", -128) - elif type_name == 'u8': - self.make_success_test("Integer u8 Hex Max", "0xFF:u8", "u8", 255) - self.make_success_test("Integer u8 Binary Max", "0b11111111:u8", "u8", 255) - self.make_success_test("Integer u8 Octal Max", "0o377:u8", "u8", 255) + self.make_success_test("Integer u8 Hex Max", "0xFF:u8", "u8", 255) + self.make_success_test("Integer u8 Binary Max", "0b11111111:u8", "u8", 255) + self.make_success_test("Integer u8 Octal Max", "0o377:u8", "u8", 255) - elif type_name == 'i16': - self.make_success_test("Integer i16 Hex Sample", "0x1234:i16", "i16", 4660) - self.make_success_test("Integer i16 Binary Sample", - "0b1111111100000000:i16", "i16", 65280) - self.make_success_test("Integer i16 Octal Sample", "0o1234:i16", "i16", 668) + self.make_success_test("Integer i16 Hex Sample", "0x1234:i16", "i16", 4660) + self.make_success_test("Integer i16 Binary Sample", + "0b1111111100000000:i16", "i16", -256) + self.make_success_test("Integer i16 Octal Sample", "0o1234:i16", "i16", 668) - elif type_name == 'u16': - self.make_success_test("Integer u16 Hex Max", "0xFFFF:u16", "u16", 65535) - self.make_success_test("Integer u16 Binary Max", - "0b1111111111111111:u16", "u16", 65535) - self.make_success_test("Integer u16 Octal Max", "0o177777:u16", "u16", 65535) - self.make_success_test("Integer u16 Decimal Mid", "50000:u16", "u16", 50000) + self.make_success_test("Integer u16 Hex Max", "0xFFFF:u16", "u16", 65535) + self.make_success_test("Integer u16 Binary Max", + "0b1111111111111111:u16", "u16", 65535) + self.make_success_test("Integer u16 Octal Max", "0o177777:u16", "u16", 65535) + self.make_success_test("Integer u16 Decimal Mid", "50000:u16", "u16", 50000) - elif type_name == 'i32': - self.make_success_test("Integer i32 Hex Sample", "0xABCD:i32", "i32", 43981) - self.make_success_test("Integer i32 Binary Sample", - "0b11110000:i32", "i32", 240) + self.make_success_test("Integer i32 Hex Sample", "0xABCD:i32", "i32", 43981) + self.make_success_test("Integer i32 Binary Sample", + "0b11110000:i32", "i32", 240) - elif type_name == 'u32': - self.make_success_test("Integer u32 Hex Max", "0xFFFFFFFF:u32", "u32", 4294967295) - self.make_success_test("Integer u32 Binary Sample", - "0b11111111000000001111111100000000:u32", - "u32", 4278255360) - self.make_success_test("Integer u32 Octal Max", - "0o37777777777:u32", "u32", 4294967295) - self.make_success_test("Integer u32 Decimal Mid", "1000000:u32", "u32", 1000000) + self.make_success_test("Integer u32 Hex Max", "0xFFFFFFFF:u32", "u32", 4294967295) + self.make_success_test("Integer u32 Binary Sample", + "0b11111111000000001111111100000000:u32", + "u32", 4278255360) + self.make_success_test("Integer u32 Octal Max", + "0o37777777777:u32", "u32", 4294967295) + self.make_success_test("Integer u32 Decimal Mid", "1000000:u32", "u32", 1000000) - elif type_name == 'i64': - self.make_success_test("Integer i64 Decimal Positive 42", "42:i64", "i64", 42) - self.make_success_test("Integer i64 Hex 0xFF", "0xFF:i64", "i64", 255) - self.make_success_test("Integer i64 Binary 0b1010", "0b1010:i64", "i64", 10) - self.make_success_test("Integer i64 Octal 0o755", "0o755:i64", "i64", 493) + self.make_success_test("Integer i64 Decimal Positive 42", "42:i64", "i64", 42) + self.make_success_test("Integer i64 Hex 0xFF", "0xFF:i64", "i64", 255) + self.make_success_test("Integer i64 Binary 0b1010", "0b1010:i64", "i64", 10) + self.make_success_test("Integer i64 Octal 0o755", "0o755:i64", "i64", 493) - elif type_name == 'u64': - self.make_success_test("Integer u64 Hex Max", - "0xFFFFFFFFFFFFFFFF:u64", - "u64", "UINT64_MAX") - self.make_success_test("Integer u64 Binary Sample", - "0b1010101010101010:u64", "u64", 43690) - self.make_success_test("Integer u64 Octal Sample", "0o7777:u64", "u64", 4095) - self.make_success_test("Integer u64 Decimal", "42:u64", "u64", 42) + self.make_success_test("Integer u64 Hex Max", + "0xFFFFFFFFFFFFFFFF:u64", + "u64", "UINT64_MAX") + self.make_success_test("Integer u64 Binary Sample", + "0b1010101010101010:u64", "u64", 43690) + self.make_success_test("Integer u64 Octal Sample", "0o7777:u64", "u64", 4095) + self.make_success_test("Integer u64 Decimal", "42:u64", "u64", 42) def generate_underscore_tests(self): """Generate tests for underscores in different bases.""" @@ -227,7 +217,7 @@ class IntegerTestGenerator(BaseTestGenerator): # Tests for each specific type for type_name in ['i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64']: self.generate_typed_tests(type_name) - self.generate_special_typed_tests(type_name) + self.generate_special_typed_tests() # Additional edge cases self.generate_underscore_tests()