diff --git a/SLS_C/tests/lexer_tests.c b/SLS_C/tests/lexer_tests.c index c237172..fe68f68 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 = 89; +static const size_t NUM_OF_TESTS = 135; static TestResult test_Empty_Statement() { LexerTest test = start_up_test("test_Empty_Statement", ""); @@ -47,6 +47,16 @@ static TestResult test_Integer_Default_Decimal_1() { return pass_test(&test, result); } +static TestResult test_Integer_Default_Decimal_42() { + LexerTest test = start_up_test("test_Integer_Default_Decimal_42", "42"); + LexerResult result = 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_Default_Decimal_Leading_Zeros() { LexerTest test = start_up_test("test_Integer_Default_Decimal_Leading_Zeros", "00042"); LexerResult result = lexical_analysis(&test.lexer_info); @@ -77,6 +87,16 @@ static TestResult test_Integer_Default_Hex_0xdeadbeef() { return pass_test(&test, result); } +static TestResult test_Integer_Default_Hex_Max() { + LexerTest test = start_up_test("test_Integer_Default_Hex_Max", "0x7FFFFFFFFFFFFFFF"); + LexerResult result = 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, 9223372036854775807})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + static TestResult test_Integer_Default_Binary_0b1010() { LexerTest test = start_up_test("test_Integer_Default_Binary_0b1010", "0b1010"); LexerResult result = lexical_analysis(&test.lexer_info); @@ -87,6 +107,16 @@ static TestResult test_Integer_Default_Binary_0b1010() { return pass_test(&test, result); } +static TestResult test_Integer_Default_Binary_All_Ones() { + LexerTest test = start_up_test("test_Integer_Default_Binary_All_Ones", "0b1111111111111111"); + LexerResult result = 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, 65535})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + static TestResult test_Integer_Default_Octal_0o755() { LexerTest test = start_up_test("test_Integer_Default_Octal_0o755", "0o755"); LexerResult result = lexical_analysis(&test.lexer_info); @@ -97,117 +127,12 @@ static TestResult test_Integer_Default_Octal_0o755() { return pass_test(&test, result); } -static TestResult test_Integer_i8_Decimal_127() { - LexerTest test = start_up_test("test_Integer_i8_Decimal_127", "127:i8"); +static TestResult test_Integer_Default_Octal_Max_Three_Digits() { + LexerTest test = start_up_test("test_Integer_Default_Octal_Max_Three_Digits", "0o777"); LexerResult result = 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_Decimal_128() { - LexerTest test = start_up_test("test_Integer_i8_Decimal_128", "-128: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_Decimal_255() { - LexerTest test = start_up_test("test_Integer_u8_Decimal_255", "255: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_Default_Decimal_with_Underscore() { - LexerTest test = start_up_test("test_Integer_Default_Decimal_with_Underscore", "1_000_000"); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 1000000})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_Default_Decimal_with_Commas_Invalid() { - LexerTest test = start_up_test("test_Integer_Default_Decimal_with_Commas_Invalid", "1,000,000"); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_for_error(&test, result, i++, &(TestErrorMessage){60, "Invalid decimal literal: unexpected ',' in decimal integer."})) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_i8_Overflow() { - LexerTest test = start_up_test("test_Integer_i8_Overflow", "128: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_for_error(&test, result, i++, &(TestErrorMessage){44, "Integer overflow: 128 exceeds range for i8."})) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_i8_Underflow() { - LexerTest test = start_up_test("test_Integer_i8_Underflow", "-129: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_for_error(&test, result, i++, &(TestErrorMessage){46, "Integer underflow: -129 exceeds range for i8."})) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_Default_Invalid_Characters() { - LexerTest test = start_up_test("test_Integer_Default_Invalid_Characters", "12a3"); - LexerResult result = 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++, &(TestErrorMessage){60, "Invalid decimal literal: unexpected 'a' in decimal integer."})) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_Default_Whitespace() { - LexerTest test = start_up_test("test_Integer_Default_Whitespace", " 42 "); - LexerResult result = 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_Default_Invalid_Prefix() { - LexerTest test = start_up_test("test_Integer_Default_Invalid_Prefix", "0b2"); - LexerResult result = 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++, &(TestErrorMessage){58, "Invalid binary literal: unexpected '2' in binary integer."})) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_Default_Underscore_End() { - LexerTest test = start_up_test("test_Integer_Default_Underscore_End", "42_"); - LexerResult result = 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_Default_Underscore_Double() { - LexerTest test = start_up_test("test_Integer_Default_Underscore_Double", "4__2"); - LexerResult result = 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_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 511})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } @@ -232,78 +157,8 @@ static TestResult test_Integer_Default_Decimal_Min_i64() { return pass_test(&test, result); } -static TestResult test_Integer_Default_Hex_Max() { - LexerTest test = start_up_test("test_Integer_Default_Hex_Max", "0x7FFFFFFFFFFFFFFF"); - LexerResult result = 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, 9223372036854775807})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_Default_Binary_All_Ones() { - LexerTest test = start_up_test("test_Integer_Default_Binary_All_Ones", "0b1111111111111111"); - LexerResult result = 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, 65535})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_Default_Octal_Max_Three_Digits() { - LexerTest test = start_up_test("test_Integer_Default_Octal_Max_Three_Digits", "0o777"); - LexerResult result = 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, 511})) 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("test_Integer_i64_Decimal_Positive", "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() { - LexerTest test = start_up_test("test_Integer_i64_Hex", "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() { - LexerTest test = start_up_test("test_Integer_i64_Binary", "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() { - LexerTest test = start_up_test("test_Integer_i64_Octal", "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_i64_With_Underscores() { - LexerTest test = start_up_test("test_Integer_i64_With_Underscores", "1_000_000:i64"); +static TestResult test_Integer_Default_Decimal_with_Underscore() { + LexerTest test = start_up_test("test_Integer_Default_Decimal_with_Underscore", "1_000_000"); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; @@ -312,160 +167,287 @@ static TestResult test_Integer_i64_With_Underscores() { return pass_test(&test, result); } -static TestResult test_Integer_i64_Max_Value() { - LexerTest test = start_up_test("test_Integer_i64_Max_Value", "9223372036854775807:i64"); +static TestResult test_Integer_Default_Underscore_End() { + LexerTest test = start_up_test("test_Integer_Default_Underscore_End", "42_"); LexerResult result = 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, 9223372036854775807})) return test.result; + 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_Min_Value() { - LexerTest test = start_up_test("test_Integer_i64_Min_Value", "-9223372036854775808:i64"); +static TestResult test_Integer_Default_Underscore_Double() { + LexerTest test = start_up_test("test_Integer_Default_Underscore_Double", "4__2"); LexerResult result = 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, -9223372036854775808})) return test.result; + 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_i32_Decimal_Positive() { - LexerTest test = start_up_test("test_Integer_i32_Decimal_Positive", "42:i32"); +static TestResult test_Integer_Default_Whitespace() { + LexerTest test = start_up_test("test_Integer_Default_Whitespace", " 42 "); LexerResult result = 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, 42})) return test.result; + 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_i32_Decimal_Negative() { - LexerTest test = start_up_test("test_Integer_i32_Decimal_Negative", "-100:i32"); +static TestResult test_Integer_Default_Hex_Zero() { + LexerTest test = start_up_test("test_Integer_Default_Hex_Zero", "0x0"); LexerResult result = 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, -100})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 0})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_i32_Hex() { - LexerTest test = start_up_test("test_Integer_i32_Hex", "0xABCD:i32"); +static TestResult test_Integer_Default_Binary_Zero() { + LexerTest test = start_up_test("test_Integer_Default_Binary_Zero", "0b0"); LexerResult result = 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_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 0})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_i32_Binary() { - LexerTest test = start_up_test("test_Integer_i32_Binary", "0b11110000:i32"); +static TestResult test_Integer_Default_Octal_Zero() { + LexerTest test = start_up_test("test_Integer_Default_Octal_Zero", "0o0"); LexerResult result = 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_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 0})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_i32_Octal() { - LexerTest test = start_up_test("test_Integer_i32_Octal", "0o777:i32"); +static TestResult test_Integer_Default_Decimal_with_Commas_Invalid() { + LexerTest test = start_up_test("test_Integer_Default_Decimal_with_Commas_Invalid", "1,000,000"); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 511})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){60, "Invalid decimal literal: unexpected ',' in decimal integer."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_Default_Invalid_Characters() { + LexerTest test = start_up_test("test_Integer_Default_Invalid_Characters", "12a3"); + LexerResult result = 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++, &(TestErrorMessage){60, "Invalid decimal literal: unexpected 'a' in decimal integer."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_Default_Invalid_Prefix() { + LexerTest test = start_up_test("test_Integer_Default_Invalid_Prefix", "0b2"); + LexerResult result = 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++, &(TestErrorMessage){58, "Invalid binary literal: unexpected '2' in binary integer."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i8_Decimal_Positive() { + LexerTest test = start_up_test("test_Integer_i8_Decimal_Positive", "42: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, 42})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_i32_Max_Value() { - LexerTest test = start_up_test("test_Integer_i32_Max_Value", "2147483647:i32"); +static TestResult test_Integer_i8_Zero() { + LexerTest test = start_up_test("test_Integer_i8_Zero", "0: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_I32, 2147483647})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 0})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_i32_Min_Value() { - LexerTest test = start_up_test("test_Integer_i32_Min_Value", "-2147483648:i32"); +static TestResult test_Integer_i8_Decimal_Negative() { + LexerTest test = start_up_test("test_Integer_i8_Decimal_Negative", "-100: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_I32, -2147483648})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, -100})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_i32_Overflow() { - LexerTest test = start_up_test("test_Integer_i32_Overflow", "2147483648:i32"); +static TestResult test_Integer_i8_Hex() { + LexerTest test = start_up_test("test_Integer_i8_Hex", "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_for_error(&test, result, i++, &(TestErrorMessage){52, "Integer overflow: 2147483648 exceeds range for i32."})) return test.result; + 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_i32_Underflow() { - LexerTest test = start_up_test("test_Integer_i32_Underflow", "-2147483649:i32"); +static TestResult test_Integer_i8_Binary() { + LexerTest test = start_up_test("test_Integer_i8_Binary", "0b1111: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_for_error(&test, result, i++, &(TestErrorMessage){54, "Integer underflow: -2147483649 exceeds range for i32."})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 15})) 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() { + LexerTest test = start_up_test("test_Integer_i8_Octal", "0o77: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, 63})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i8_Max_Value() { + LexerTest test = start_up_test("test_Integer_i8_Max_Value", "127: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_Min_Value() { + LexerTest test = start_up_test("test_Integer_i8_Min_Value", "-128: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_i8_Overflow() { + LexerTest test = start_up_test("test_Integer_i8_Overflow", "128: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_for_error(&test, result, i++, &(TestErrorMessage){44, "Integer overflow: 128 exceeds range for i8."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i8_Underflow() { + LexerTest test = start_up_test("test_Integer_i8_Underflow", "-129: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_for_error(&test, result, i++, &(TestErrorMessage){46, "Integer underflow: -129 exceeds range for i8."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i8_Hex_Max() { + LexerTest test = start_up_test("test_Integer_i8_Hex_Max", "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("test_Integer_i8_Binary_Max", "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("test_Integer_i8_Octal_Max", "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("test_Integer_i8_Negative_Hex", "-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("test_Integer_i16_Decimal_Positive", "1000:i16"); + LexerTest test = start_up_test("test_Integer_i16_Decimal_Positive", "42: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, 1000})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 42})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i16_Zero() { + LexerTest test = start_up_test("test_Integer_i16_Zero", "0: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, 0})) 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_Negative() { - LexerTest test = start_up_test("test_Integer_i16_Decimal_Negative", "-1000:i16"); + LexerTest test = start_up_test("test_Integer_i16_Decimal_Negative", "-100: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, -1000})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, -100})) 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() { - LexerTest test = start_up_test("test_Integer_i16_Hex", "0x1234:i16"); + LexerTest test = start_up_test("test_Integer_i16_Hex", "0xFF: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_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 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_Binary() { - LexerTest test = start_up_test("test_Integer_i16_Binary", "0b1111111100000000:i16"); + LexerTest test = start_up_test("test_Integer_i16_Binary", "0b1111: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_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 15})) 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() { - LexerTest test = start_up_test("test_Integer_i16_Octal", "0o1234:i16"); + LexerTest test = start_up_test("test_Integer_i16_Octal", "0o77: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_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 63})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } @@ -508,267 +490,329 @@ static TestResult test_Integer_i16_Underflow() { return pass_test(&test, result); } -static TestResult test_Integer_i8_Hex() { - LexerTest test = start_up_test("test_Integer_i8_Hex", "0x7F:i8"); +static TestResult test_Integer_i16_Hex_Sample() { + LexerTest test = start_up_test("test_Integer_i16_Hex_Sample", "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_I8, 127})) return test.result; + 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_i8_Binary() { - LexerTest test = start_up_test("test_Integer_i8_Binary", "0b01111111:i8"); +static TestResult test_Integer_i16_Binary_Sample() { + LexerTest test = start_up_test("test_Integer_i16_Binary_Sample", "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_I8, 127})) return test.result; + 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_i8_Octal() { - LexerTest test = start_up_test("test_Integer_i8_Octal", "0o177:i8"); +static TestResult test_Integer_i16_Octal_Sample() { + LexerTest test = start_up_test("test_Integer_i16_Octal_Sample", "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_I8, 127})) return test.result; + 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_i8_Zero() { - LexerTest test = start_up_test("test_Integer_i8_Zero", "0:i8"); +static TestResult test_Integer_i32_Decimal_Positive() { + LexerTest test = start_up_test("test_Integer_i32_Decimal_Positive", "42: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_I8, 0})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 42})) 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("test_Integer_i8_Negative_Hex", "-0x80:i8"); +static TestResult test_Integer_i32_Zero() { + LexerTest test = start_up_test("test_Integer_i32_Zero", "0: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_I8, -128})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 0})) 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() { - LexerTest test = start_up_test("test_Integer_u64_Decimal", "42:u64"); +static TestResult test_Integer_i32_Decimal_Negative() { + LexerTest test = start_up_test("test_Integer_i32_Decimal_Negative", "-100: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_U64, 42})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, -100})) 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() { - LexerTest test = start_up_test("test_Integer_u64_Hex", "0xFFFFFFFFFFFFFFFF:u64"); +static TestResult test_Integer_i32_Hex() { + LexerTest test = start_up_test("test_Integer_i32_Hex", "0xFF: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_U64, 18446744073709551615})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 255})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_u64_Binary() { - LexerTest test = start_up_test("test_Integer_u64_Binary", "0b1010101010101010:u64"); +static TestResult test_Integer_i32_Binary() { + LexerTest test = start_up_test("test_Integer_i32_Binary", "0b1111: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_U64, 43690})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 15})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_u64_Octal() { - LexerTest test = start_up_test("test_Integer_u64_Octal", "0o7777:u64"); +static TestResult test_Integer_i32_Octal() { + LexerTest test = start_up_test("test_Integer_i32_Octal", "0o77: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_U64, 4095})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 63})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_u64_Max_Value() { - LexerTest test = start_up_test("test_Integer_u64_Max_Value", "18446744073709551615:u64"); +static TestResult test_Integer_i32_Max_Value() { + LexerTest test = start_up_test("test_Integer_i32_Max_Value", "2147483647: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_U64, 18446744073709551615})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 2147483647})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_u64_Zero() { - LexerTest test = start_up_test("test_Integer_u64_Zero", "0:u64"); +static TestResult test_Integer_i32_Min_Value() { + LexerTest test = start_up_test("test_Integer_i32_Min_Value", "-2147483648: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_U64, 0})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, -2147483648})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_u64_Overflow() { - LexerTest test = start_up_test("test_Integer_u64_Overflow", "18446744073709551616:u64"); +static TestResult test_Integer_i32_Overflow() { + LexerTest test = start_up_test("test_Integer_i32_Overflow", "2147483648: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_for_error(&test, result, i++, &(TestErrorMessage){62, "Integer overflow: 18446744073709551616 exceeds range for u64."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){52, "Integer overflow: 2147483648 exceeds range for i32."})) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_u64_Negative_Invalid() { - LexerTest test = start_up_test("test_Integer_u64_Negative_Invalid", "-1:u64"); +static TestResult test_Integer_i32_Underflow() { + LexerTest test = start_up_test("test_Integer_i32_Underflow", "-2147483649: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_for_error(&test, result, i++, &(TestErrorMessage){45, "Integer underflow: -1 exceeds range for u64."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){54, "Integer underflow: -2147483649 exceeds range for i32."})) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_u32_Decimal() { - LexerTest test = start_up_test("test_Integer_u32_Decimal", "1000000:u32"); +static TestResult test_Integer_i32_With_Underscores() { + LexerTest test = start_up_test("test_Integer_i32_With_Underscores", "1_000_000: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_U32, 1000000})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 1000000})) 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() { - LexerTest test = start_up_test("test_Integer_u32_Hex", "0xFFFFFFFF:u32"); +static TestResult test_Integer_i32_Hex_Sample() { + LexerTest test = start_up_test("test_Integer_i32_Hex_Sample", "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_U32, 4294967295})) return test.result; + 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_u32_Binary() { - LexerTest test = start_up_test("test_Integer_u32_Binary", "0b11111111000000001111111100000000:u32"); +static TestResult test_Integer_i32_Binary_Sample() { + LexerTest test = start_up_test("test_Integer_i32_Binary_Sample", "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_U32, 4278255360})) return test.result; + 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_Octal() { - LexerTest test = start_up_test("test_Integer_u32_Octal", "0o37777777777:u32"); +static TestResult test_Integer_i64_Decimal_Positive() { + LexerTest test = start_up_test("test_Integer_i64_Decimal_Positive", "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_U32, 4294967295})) return test.result; + 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_u32_Max_Value() { - LexerTest test = start_up_test("test_Integer_u32_Max_Value", "4294967295:u32"); +static TestResult test_Integer_i64_Zero() { + LexerTest test = start_up_test("test_Integer_i64_Zero", "0: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_U32, 4294967295})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 0})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_u32_Overflow() { - LexerTest test = start_up_test("test_Integer_u32_Overflow", "4294967296:u32"); +static TestResult test_Integer_i64_Decimal_Negative() { + LexerTest test = start_up_test("test_Integer_i64_Decimal_Negative", "-100: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_for_error(&test, result, i++, &(TestErrorMessage){52, "Integer overflow: 4294967296 exceeds range for u32."})) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_u32_Negative_Invalid() { - LexerTest test = start_up_test("test_Integer_u32_Negative_Invalid", "-1: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_for_error(&test, result, i++, &(TestErrorMessage){45, "Integer underflow: -1 exceeds range for u32."})) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_u16_Decimal() { - LexerTest test = start_up_test("test_Integer_u16_Decimal", "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_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, -100})) 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() { - LexerTest test = start_up_test("test_Integer_u16_Hex", "0xFFFF:u16"); +static TestResult test_Integer_i64_Hex() { + LexerTest test = start_up_test("test_Integer_i64_Hex", "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_U16, 65535})) return test.result; + 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_u16_Binary() { - LexerTest test = start_up_test("test_Integer_u16_Binary", "0b1111111111111111:u16"); +static TestResult test_Integer_i64_Binary() { + LexerTest test = start_up_test("test_Integer_i64_Binary", "0b1111: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_U16, 65535})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 15})) 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() { - LexerTest test = start_up_test("test_Integer_u16_Octal", "0o177777:u16"); +static TestResult test_Integer_i64_Octal() { + LexerTest test = start_up_test("test_Integer_i64_Octal", "0o77: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_U16, 65535})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 63})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_u16_Max_Value() { - LexerTest test = start_up_test("test_Integer_u16_Max_Value", "65535:u16"); +static TestResult test_Integer_i64_Max_Value() { + LexerTest test = start_up_test("test_Integer_i64_Max_Value", "9223372036854775807: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_U16, 65535})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 9223372036854775807})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_u16_Overflow() { - LexerTest test = start_up_test("test_Integer_u16_Overflow", "65536:u16"); +static TestResult test_Integer_i64_Min_Value() { + LexerTest test = start_up_test("test_Integer_i64_Min_Value", "-9223372036854775808: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_for_error(&test, result, i++, &(TestErrorMessage){47, "Integer overflow: 65536 exceeds range for u16."})) return test.result; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, -9223372036854775808})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } -static TestResult test_Integer_u16_Negative_Invalid() { - LexerTest test = start_up_test("test_Integer_u16_Negative_Invalid", "-1:u16"); +static TestResult test_Integer_i64_Overflow() { + LexerTest test = start_up_test("test_Integer_i64_Overflow", "9223372036854775808: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_for_error(&test, result, i++, &(TestErrorMessage){45, "Integer underflow: -1 exceeds range for u16."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){61, "Integer overflow: 9223372036854775808 exceeds range for i64."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i64_Underflow() { + LexerTest test = start_up_test("test_Integer_i64_Underflow", "-9223372036854775809: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_for_error(&test, result, i++, &(TestErrorMessage){63, "Integer underflow: -9223372036854775809 exceeds range for i64."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i64_With_Underscores() { + LexerTest test = start_up_test("test_Integer_i64_With_Underscores", "1_000_000: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, 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("test_Integer_i64_Decimal_Positive_42", "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("test_Integer_i64_Hex_0xFF", "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("test_Integer_i64_Binary_0b1010", "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("test_Integer_i64_Octal_0o755", "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("test_Integer_u8_Decimal_Positive", "42: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, 42})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u8_Zero() { + LexerTest test = start_up_test("test_Integer_u8_Zero", "0: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, 0})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } @@ -783,17 +827,27 @@ static TestResult test_Integer_u8_Hex() { } static TestResult test_Integer_u8_Binary() { - LexerTest test = start_up_test("test_Integer_u8_Binary", "0b11111111:u8"); + LexerTest test = start_up_test("test_Integer_u8_Binary", "0b1111: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_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 15})) 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() { - LexerTest test = start_up_test("test_Integer_u8_Octal", "0o377:u8"); + LexerTest test = start_up_test("test_Integer_u8_Octal", "0o77: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, 63})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u8_Max_Value() { + LexerTest test = start_up_test("test_Integer_u8_Max_Value", "255: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; @@ -802,8 +856,8 @@ static TestResult test_Integer_u8_Octal() { return pass_test(&test, result); } -static TestResult test_Integer_u8_Zero() { - LexerTest test = start_up_test("test_Integer_u8_Zero", "0:u8"); +static TestResult test_Integer_u8_Min_Value() { + LexerTest test = start_up_test("test_Integer_u8_Min_Value", "0: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; @@ -821,8 +875,8 @@ static TestResult test_Integer_u8_Overflow() { return pass_test(&test, result); } -static TestResult test_Integer_u8_Negative_Invalid() { - LexerTest test = start_up_test("test_Integer_u8_Negative_Invalid", "-1:u8"); +static TestResult test_Integer_u8_Underflow() { + LexerTest test = start_up_test("test_Integer_u8_Underflow", "-1: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; @@ -830,6 +884,440 @@ static TestResult test_Integer_u8_Negative_Invalid() { return pass_test(&test, result); } +static TestResult test_Integer_u8_Hex_Max() { + LexerTest test = start_up_test("test_Integer_u8_Hex_Max", "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("test_Integer_u8_Binary_Max", "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("test_Integer_u8_Octal_Max", "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("test_Integer_u16_Decimal_Positive", "42: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, 42})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u16_Zero() { + LexerTest test = start_up_test("test_Integer_u16_Zero", "0: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, 0})) 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() { + LexerTest test = start_up_test("test_Integer_u16_Hex", "0xFF: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, 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_Binary() { + LexerTest test = start_up_test("test_Integer_u16_Binary", "0b1111: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, 15})) 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() { + LexerTest test = start_up_test("test_Integer_u16_Octal", "0o77: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, 63})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u16_Max_Value() { + LexerTest test = start_up_test("test_Integer_u16_Max_Value", "65535: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_Min_Value() { + LexerTest test = start_up_test("test_Integer_u16_Min_Value", "0: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, 0})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u16_Overflow() { + LexerTest test = start_up_test("test_Integer_u16_Overflow", "65536: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_for_error(&test, result, i++, &(TestErrorMessage){47, "Integer overflow: 65536 exceeds range for u16."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u16_Underflow() { + LexerTest test = start_up_test("test_Integer_u16_Underflow", "-1: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_for_error(&test, result, i++, &(TestErrorMessage){45, "Integer underflow: -1 exceeds range for u16."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u16_Hex_Max() { + LexerTest test = start_up_test("test_Integer_u16_Hex_Max", "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("test_Integer_u16_Binary_Max", "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("test_Integer_u16_Octal_Max", "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("test_Integer_u16_Decimal_Mid", "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("test_Integer_u32_Decimal_Positive", "42: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, 42})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u32_Zero() { + LexerTest test = start_up_test("test_Integer_u32_Zero", "0: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, 0})) 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() { + LexerTest test = start_up_test("test_Integer_u32_Hex", "0xFF: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, 255})) 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() { + LexerTest test = start_up_test("test_Integer_u32_Binary", "0b1111: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, 15})) 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() { + LexerTest test = start_up_test("test_Integer_u32_Octal", "0o77: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, 63})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u32_Max_Value() { + LexerTest test = start_up_test("test_Integer_u32_Max_Value", "4294967295: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_Min_Value() { + LexerTest test = start_up_test("test_Integer_u32_Min_Value", "0: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, 0})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u32_Overflow() { + LexerTest test = start_up_test("test_Integer_u32_Overflow", "4294967296: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_for_error(&test, result, i++, &(TestErrorMessage){52, "Integer overflow: 4294967296 exceeds range for u32."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u32_Underflow() { + LexerTest test = start_up_test("test_Integer_u32_Underflow", "-1: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_for_error(&test, result, i++, &(TestErrorMessage){45, "Integer underflow: -1 exceeds range for u32."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u32_With_Underscores() { + LexerTest test = start_up_test("test_Integer_u32_With_Underscores", "1_000_000: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_u32_Hex_Max() { + LexerTest test = start_up_test("test_Integer_u32_Hex_Max", "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("test_Integer_u32_Binary_Sample", "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("test_Integer_u32_Octal_Max", "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("test_Integer_u32_Decimal_Mid", "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("test_Integer_u64_Decimal_Positive", "42:u64"); + LexerResult result = 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_U64, 42})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u64_Zero() { + LexerTest test = start_up_test("test_Integer_u64_Zero", "0:u64"); + LexerResult result = 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_U64, 0})) 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() { + LexerTest test = start_up_test("test_Integer_u64_Hex", "0xFF:u64"); + LexerResult result = 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_U64, 255})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u64_Binary() { + LexerTest test = start_up_test("test_Integer_u64_Binary", "0b1111:u64"); + LexerResult result = 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_U64, 15})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u64_Octal() { + LexerTest test = start_up_test("test_Integer_u64_Octal", "0o77:u64"); + LexerResult result = 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_U64, 63})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u64_Max_Value() { + LexerTest test = start_up_test("test_Integer_u64_Max_Value", "18446744073709551615:u64"); + LexerResult result = 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_U64, 18446744073709551615})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u64_Min_Value() { + LexerTest test = start_up_test("test_Integer_u64_Min_Value", "0:u64"); + LexerResult result = 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_U64, 0})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u64_Overflow() { + LexerTest test = start_up_test("test_Integer_u64_Overflow", "18446744073709551616:u64"); + LexerResult result = 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++, &(TestErrorMessage){62, "Integer overflow: 18446744073709551616 exceeds range for u64."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u64_Underflow() { + LexerTest test = start_up_test("test_Integer_u64_Underflow", "-1:u64"); + LexerResult result = 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++, &(TestErrorMessage){45, "Integer underflow: -1 exceeds range for u64."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u64_With_Underscores() { + LexerTest test = start_up_test("test_Integer_u64_With_Underscores", "1_000_000:u64"); + LexerResult result = 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_U64, 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_Hex_Max() { + LexerTest test = start_up_test("test_Integer_u64_Hex_Max", "0xFFFFFFFFFFFFFFFF:u64"); + LexerResult result = 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_U64, 18446744073709551615})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u64_Binary_Sample() { + LexerTest test = start_up_test("test_Integer_u64_Binary_Sample", "0b1010101010101010:u64"); + LexerResult result = 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_U64, 43690})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u64_Octal_Sample() { + LexerTest test = start_up_test("test_Integer_u64_Octal_Sample", "0o7777:u64"); + LexerResult result = 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_U64, 4095})) 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() { + LexerTest test = start_up_test("test_Integer_u64_Decimal", "42:u64"); + LexerResult result = 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_U64, 42})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + static TestResult test_Integer_Hex_With_Underscores() { LexerTest test = start_up_test("test_Integer_Hex_With_Underscores", "0xDEAD_BEEF:i64"); LexerResult result = lexical_analysis(&test.lexer_info); @@ -860,36 +1348,6 @@ static TestResult test_Integer_Octal_With_Underscores() { return pass_test(&test, result); } -static TestResult test_Integer_Default_Hex_Zero() { - LexerTest test = start_up_test("test_Integer_Default_Hex_Zero", "0x0"); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 0})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_Default_Binary_Zero() { - LexerTest test = start_up_test("test_Integer_Default_Binary_Zero", "0b0"); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 0})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - -static TestResult test_Integer_Default_Octal_Zero() { - LexerTest test = start_up_test("test_Integer_Default_Octal_Zero", "0o0"); - LexerResult result = lexical_analysis(&test.lexer_info); - if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); - size_t i = 0; - if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 0})) return test.result; - if (test_eof_value(&test, result, i++, 0)) return test.result; - return pass_test(&test, result); -} - TestsReport run_lexer_tests() { TestsReport test_report = (TestsReport) { .section = "lexer_tests", @@ -902,45 +1360,43 @@ TestsReport run_lexer_tests() { test_report.tests[i++] = test_Empty_Statement(); test_report.tests[i++] = test_Integer_Default_Decimal_0(); test_report.tests[i++] = test_Integer_Default_Decimal_1(); + test_report.tests[i++] = test_Integer_Default_Decimal_42(); test_report.tests[i++] = test_Integer_Default_Decimal_Leading_Zeros(); test_report.tests[i++] = test_Integer_Default_Hex_0xFF(); test_report.tests[i++] = test_Integer_Default_Hex_0xdeadbeef(); + test_report.tests[i++] = test_Integer_Default_Hex_Max(); test_report.tests[i++] = test_Integer_Default_Binary_0b1010(); + test_report.tests[i++] = test_Integer_Default_Binary_All_Ones(); test_report.tests[i++] = test_Integer_Default_Octal_0o755(); - test_report.tests[i++] = test_Integer_i8_Decimal_127(); - test_report.tests[i++] = test_Integer_i8_Decimal_128(); - test_report.tests[i++] = test_Integer_u8_Decimal_255(); - test_report.tests[i++] = test_Integer_Default_Decimal_with_Underscore(); - test_report.tests[i++] = test_Integer_Default_Decimal_with_Commas_Invalid(); - test_report.tests[i++] = test_Integer_i8_Overflow(); - test_report.tests[i++] = test_Integer_i8_Underflow(); - test_report.tests[i++] = test_Integer_Default_Invalid_Characters(); - test_report.tests[i++] = test_Integer_Default_Whitespace(); - test_report.tests[i++] = test_Integer_Default_Invalid_Prefix(); - test_report.tests[i++] = test_Integer_Default_Underscore_End(); - test_report.tests[i++] = test_Integer_Default_Underscore_Double(); + test_report.tests[i++] = test_Integer_Default_Octal_Max_Three_Digits(); test_report.tests[i++] = test_Integer_Default_Decimal_Max_i64(); test_report.tests[i++] = test_Integer_Default_Decimal_Min_i64(); - test_report.tests[i++] = test_Integer_Default_Hex_Max(); - test_report.tests[i++] = test_Integer_Default_Binary_All_Ones(); - test_report.tests[i++] = test_Integer_Default_Octal_Max_Three_Digits(); - test_report.tests[i++] = test_Integer_i64_Decimal_Positive(); - test_report.tests[i++] = test_Integer_i64_Hex(); - test_report.tests[i++] = test_Integer_i64_Binary(); - test_report.tests[i++] = test_Integer_i64_Octal(); - test_report.tests[i++] = test_Integer_i64_With_Underscores(); - test_report.tests[i++] = test_Integer_i64_Max_Value(); - test_report.tests[i++] = test_Integer_i64_Min_Value(); - test_report.tests[i++] = test_Integer_i32_Decimal_Positive(); - test_report.tests[i++] = test_Integer_i32_Decimal_Negative(); - test_report.tests[i++] = test_Integer_i32_Hex(); - test_report.tests[i++] = test_Integer_i32_Binary(); - test_report.tests[i++] = test_Integer_i32_Octal(); - test_report.tests[i++] = test_Integer_i32_Max_Value(); - test_report.tests[i++] = test_Integer_i32_Min_Value(); - test_report.tests[i++] = test_Integer_i32_Overflow(); - test_report.tests[i++] = test_Integer_i32_Underflow(); + test_report.tests[i++] = test_Integer_Default_Decimal_with_Underscore(); + test_report.tests[i++] = test_Integer_Default_Underscore_End(); + test_report.tests[i++] = test_Integer_Default_Underscore_Double(); + test_report.tests[i++] = test_Integer_Default_Whitespace(); + test_report.tests[i++] = test_Integer_Default_Hex_Zero(); + test_report.tests[i++] = test_Integer_Default_Binary_Zero(); + test_report.tests[i++] = test_Integer_Default_Octal_Zero(); + test_report.tests[i++] = test_Integer_Default_Decimal_with_Commas_Invalid(); + test_report.tests[i++] = test_Integer_Default_Invalid_Characters(); + test_report.tests[i++] = test_Integer_Default_Invalid_Prefix(); + test_report.tests[i++] = test_Integer_i8_Decimal_Positive(); + test_report.tests[i++] = test_Integer_i8_Zero(); + test_report.tests[i++] = test_Integer_i8_Decimal_Negative(); + test_report.tests[i++] = test_Integer_i8_Hex(); + test_report.tests[i++] = test_Integer_i8_Binary(); + test_report.tests[i++] = test_Integer_i8_Octal(); + test_report.tests[i++] = test_Integer_i8_Max_Value(); + 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(); test_report.tests[i++] = test_Integer_i16_Hex(); test_report.tests[i++] = test_Integer_i16_Binary(); @@ -949,45 +1405,93 @@ 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_i8_Hex(); - test_report.tests[i++] = test_Integer_i8_Binary(); - test_report.tests[i++] = test_Integer_i8_Octal(); - test_report.tests[i++] = test_Integer_i8_Zero(); - test_report.tests[i++] = test_Integer_i8_Negative_Hex(); - test_report.tests[i++] = test_Integer_u64_Decimal(); - test_report.tests[i++] = test_Integer_u64_Hex(); - test_report.tests[i++] = test_Integer_u64_Binary(); - test_report.tests[i++] = test_Integer_u64_Octal(); - test_report.tests[i++] = test_Integer_u64_Max_Value(); - test_report.tests[i++] = test_Integer_u64_Zero(); - test_report.tests[i++] = test_Integer_u64_Overflow(); - test_report.tests[i++] = test_Integer_u64_Negative_Invalid(); - test_report.tests[i++] = test_Integer_u32_Decimal(); - test_report.tests[i++] = test_Integer_u32_Hex(); - test_report.tests[i++] = test_Integer_u32_Binary(); - test_report.tests[i++] = test_Integer_u32_Octal(); - test_report.tests[i++] = test_Integer_u32_Max_Value(); - test_report.tests[i++] = test_Integer_u32_Overflow(); - test_report.tests[i++] = test_Integer_u32_Negative_Invalid(); - test_report.tests[i++] = test_Integer_u16_Decimal(); + 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(); + test_report.tests[i++] = test_Integer_i32_Hex(); + test_report.tests[i++] = test_Integer_i32_Binary(); + test_report.tests[i++] = test_Integer_i32_Octal(); + test_report.tests[i++] = test_Integer_i32_Max_Value(); + test_report.tests[i++] = test_Integer_i32_Min_Value(); + 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(); + test_report.tests[i++] = test_Integer_i64_Hex(); + test_report.tests[i++] = test_Integer_i64_Binary(); + test_report.tests[i++] = test_Integer_i64_Octal(); + test_report.tests[i++] = test_Integer_i64_Max_Value(); + test_report.tests[i++] = test_Integer_i64_Min_Value(); + 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(); + test_report.tests[i++] = test_Integer_u8_Binary(); + test_report.tests[i++] = test_Integer_u8_Octal(); + test_report.tests[i++] = test_Integer_u8_Max_Value(); + 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(); test_report.tests[i++] = test_Integer_u16_Binary(); test_report.tests[i++] = test_Integer_u16_Octal(); test_report.tests[i++] = test_Integer_u16_Max_Value(); + test_report.tests[i++] = test_Integer_u16_Min_Value(); test_report.tests[i++] = test_Integer_u16_Overflow(); - test_report.tests[i++] = test_Integer_u16_Negative_Invalid(); - test_report.tests[i++] = test_Integer_u8_Hex(); - test_report.tests[i++] = test_Integer_u8_Binary(); - test_report.tests[i++] = test_Integer_u8_Octal(); - test_report.tests[i++] = test_Integer_u8_Zero(); - test_report.tests[i++] = test_Integer_u8_Overflow(); - test_report.tests[i++] = test_Integer_u8_Negative_Invalid(); + 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(); + test_report.tests[i++] = test_Integer_u32_Binary(); + test_report.tests[i++] = test_Integer_u32_Octal(); + test_report.tests[i++] = test_Integer_u32_Max_Value(); + test_report.tests[i++] = test_Integer_u32_Min_Value(); + 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(); + test_report.tests[i++] = test_Integer_u64_Binary(); + test_report.tests[i++] = test_Integer_u64_Octal(); + test_report.tests[i++] = test_Integer_u64_Max_Value(); + test_report.tests[i++] = test_Integer_u64_Min_Value(); + 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_u64_Hex_Max(); + test_report.tests[i++] = test_Integer_u64_Binary_Sample(); + test_report.tests[i++] = test_Integer_u64_Octal_Sample(); + test_report.tests[i++] = test_Integer_u64_Decimal(); test_report.tests[i++] = test_Integer_Hex_With_Underscores(); test_report.tests[i++] = test_Integer_Binary_With_Underscores(); test_report.tests[i++] = test_Integer_Octal_With_Underscores(); - test_report.tests[i++] = test_Integer_Default_Hex_Zero(); - test_report.tests[i++] = test_Integer_Default_Binary_Zero(); - test_report.tests[i++] = test_Integer_Default_Octal_Zero(); return test_report; } diff --git a/SLS_Tests/cases.yaml b/SLS_Tests/cases.yaml index 1585e60..f545e4b 100644 --- a/SLS_Tests/cases.yaml +++ b/SLS_Tests/cases.yaml @@ -1,35 +1,8 @@ -# Kyler Olsen -# SLS Test Cases -# November 2025 - -# Could you now help me by creating test cases. Just start by naming any new categories I should have, then I will ask you to name new tests. Token strings should have their tokens listed with in their data - -# - name: Test Name -# code: "Test Code" -# # Lexed tokens or lexer error -# tokens: -# - type: Token Type -# value: Token Value -# # Parsed operations or parsing error (if no lexer error) -# operations: -# - function: Operation Name -# # Final stack state and/or runtime error (if no lexer or parsing error) -# stack_final: -# - type: Stack Item Type -# value: Stack Item Value -# runtime_error: -# message: Error message. - - name: Empty_Statement - code: "" + code: '' tokens: [] - operations: [] - stack_final: [] - -# Basic Integers - - name: Integer Default Decimal 0 - code: "0" + code: '0' tokens: - type: i64 value: 0 @@ -40,9 +13,8 @@ stack_final: - type: i64 value: 0 - - name: Integer Default Decimal -1 - code: "-1" + code: '-1' tokens: - type: i64 value: -1 @@ -53,9 +25,20 @@ stack_final: - type: i64 value: -1 - +- name: Integer Default Decimal 42 + code: '42' + tokens: + - type: i64 + value: 42 + operations: + - function: push + type: i64 + value: 42 + stack_final: + - type: i64 + value: 42 - name: Integer Default Decimal Leading Zeros - code: "00042" + code: '00042' tokens: - type: i64 value: 42 @@ -66,9 +49,8 @@ stack_final: - type: i64 value: 42 - - name: Integer Default Hex 0xFF - code: "0xFF" + code: '0xFF' tokens: - type: i64 value: 255 @@ -79,9 +61,8 @@ stack_final: - type: i64 value: 255 - - name: Integer Default Hex 0xdeadbeef - code: "0xdeadbeef" + code: '0xdeadbeef' tokens: - type: i64 value: 3735928559 @@ -92,183 +73,8 @@ stack_final: - type: i64 value: 3735928559 - -- name: Integer Default Binary 0b1010 - code: "0b1010" - tokens: - - type: i64 - value: 10 - operations: - - function: push - type: i64 - value: 10 - stack_final: - - type: i64 - value: 10 - -- name: Integer Default Octal 0o755 - code: "0o755" - tokens: - - type: i64 - value: 493 - operations: - - function: push - type: i64 - value: 493 - stack_final: - - type: i64 - value: 493 - -- name: Integer i8 Decimal 127 - code: "127:i8" - tokens: - - type: i8 - value: 127 - operations: - - function: push - type: i8 - value: 127 - stack_final: - - type: i8 - value: 127 - -- name: Integer i8 Decimal -128 - code: "-128:i8" - tokens: - - type: i8 - value: -128 - operations: - - function: push - type: i8 - value: -128 - stack_final: - - type: i8 - value: -128 - -- name: Integer u8 Decimal 255 - code: "255:u8" - tokens: - - type: u8 - value: 255 - operations: - - function: push - type: u8 - value: 255 - stack_final: - - type: u8 - value: 255 - -- name: Integer Default Decimal with Underscore - code: "1_000_000" - tokens: - - type: i64 - value: 1000000 - operations: - - function: push - type: i64 - value: 1000000 - stack_final: - - type: i64 - value: 1000000 - -- name: Integer Default Decimal with Commas Invalid - code: "1,000,000" - tokens: - - type: error - value: "Invalid decimal literal: unexpected ',' in decimal integer." - -- name: Integer i8 Overflow - code: "128:i8" - tokens: - - type: error - value: "Integer overflow: 128 exceeds range for i8." - -- name: Integer i8 Underflow - code: "-129:i8" - tokens: - - type: error - value: "Integer underflow: -129 exceeds range for i8." - -- name: Integer Default Invalid Characters - code: "12a3" - tokens: - - type: error - value: "Invalid decimal literal: unexpected 'a' in decimal integer." - -- name: Integer Default Whitespace - code: " 42 " - tokens: - - type: i64 - value: 42 - operations: - - function: push - type: i64 - value: 42 - stack_final: - - type: i64 - value: 42 - -- name: Integer Default Invalid Prefix - code: "0b2" - tokens: - - type: error - value: "Invalid binary literal: unexpected '2' in binary integer." - -- name: Integer Default Underscore End - code: "42_" - tokens: - - type: i64 - value: 42 - operations: - - function: push - type: i64 - value: 42 - stack_final: - - type: i64 - value: 42 - -- name: Integer Default Underscore Double - code: "4__2" - tokens: - - type: i64 - value: 42 - operations: - - function: push - type: i64 - value: 42 - stack_final: - - type: i64 - value: 42 - -# Additional i64 (default) coverage -- name: Integer Default Decimal Max i64 - code: "9223372036854775807" - tokens: - - type: i64 - value: 9223372036854775807 - operations: - - function: push - type: i64 - value: 9223372036854775807 - stack_final: - - type: i64 - value: 9223372036854775807 - -- name: Integer Default Decimal Min i64 - code: "-9223372036854775808" - tokens: - - type: i64 - value: -9223372036854775808 - operations: - - function: push - type: i64 - value: -9223372036854775808 - stack_final: - - type: i64 - value: -9223372036854775808 - - name: Integer Default Hex Max - code: "0x7FFFFFFFFFFFFFFF" + code: '0x7FFFFFFFFFFFFFFF' tokens: - type: i64 value: 9223372036854775807 @@ -279,9 +85,20 @@ stack_final: - type: i64 value: 9223372036854775807 - +- name: Integer Default Binary 0b1010 + code: '0b1010' + tokens: + - type: i64 + value: 10 + operations: + - function: push + type: i64 + value: 10 + stack_final: + - type: i64 + value: 10 - name: Integer Default Binary All Ones - code: "0b1111111111111111" + code: '0b1111111111111111' tokens: - type: i64 value: 65535 @@ -292,9 +109,20 @@ stack_final: - type: i64 value: 65535 - +- name: Integer Default Octal 0o755 + code: 0o755 + tokens: + - type: i64 + value: 493 + operations: + - function: push + type: i64 + value: 493 + stack_final: + - type: i64 + value: 493 - name: Integer Default Octal Max Three Digits - code: "0o777" + code: 0o777 tokens: - type: i64 value: 511 @@ -305,75 +133,8 @@ stack_final: - type: i64 value: 511 - -# Explicit i64 coverage -- name: Integer i64 Decimal Positive - 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 - 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 - 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 - code: "0o755:i64" - tokens: - - type: i64 - value: 493 - operations: - - function: push - type: i64 - value: 493 - stack_final: - - type: i64 - value: 493 - -- name: Integer i64 With Underscores - code: "1_000_000:i64" - tokens: - - type: i64 - value: 1000000 - operations: - - function: push - type: i64 - value: 1000000 - stack_final: - - type: i64 - value: 1000000 - -- name: Integer i64 Max Value - code: "9223372036854775807:i64" +- name: Integer Default Decimal Max i64 + code: '9223372036854775807' tokens: - type: i64 value: 9223372036854775807 @@ -384,9 +145,8 @@ stack_final: - type: i64 value: 9223372036854775807 - -- name: Integer i64 Min Value - code: "-9223372036854775808:i64" +- name: Integer Default Decimal Min i64 + code: '-9223372036854775808' tokens: - type: i64 value: -9223372036854775808 @@ -397,636 +157,56 @@ stack_final: - type: i64 value: -9223372036854775808 - -# i32 coverage -- name: Integer i32 Decimal Positive - code: "42:i32" - tokens: - - type: i32 - value: 42 - operations: - - function: push - type: i32 - value: 42 - stack_final: - - type: i32 - value: 42 - -- name: Integer i32 Decimal Negative - code: "-100:i32" - tokens: - - type: i32 - value: -100 - operations: - - function: push - type: i32 - value: -100 - stack_final: - - type: i32 - value: -100 - -- name: Integer i32 Hex - 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 - code: "0b11110000:i32" - tokens: - - type: i32 - value: 240 - operations: - - function: push - type: i32 - value: 240 - stack_final: - - type: i32 - value: 240 - -- name: Integer i32 Octal - code: "0o777:i32" - tokens: - - type: i32 - value: 511 - operations: - - function: push - type: i32 - value: 511 - stack_final: - - type: i32 - value: 511 - -- name: Integer i32 Max Value - code: "2147483647:i32" - tokens: - - type: i32 - value: 2147483647 - operations: - - function: push - type: i32 - value: 2147483647 - stack_final: - - type: i32 - value: 2147483647 - -- name: Integer i32 Min Value - code: "-2147483648:i32" - tokens: - - type: i32 - value: -2147483648 - operations: - - function: push - type: i32 - value: -2147483648 - stack_final: - - type: i32 - value: -2147483648 - -- name: Integer i32 Overflow - code: "2147483648:i32" - tokens: - - type: error - value: "Integer overflow: 2147483648 exceeds range for i32." - -- name: Integer i32 Underflow - code: "-2147483649:i32" - tokens: - - type: error - value: "Integer underflow: -2147483649 exceeds range for i32." - -# i16 coverage -- name: Integer i16 Decimal Positive - code: "1000:i16" - tokens: - - type: i16 - value: 1000 - operations: - - function: push - type: i16 - value: 1000 - stack_final: - - type: i16 - value: 1000 - -- name: Integer i16 Decimal Negative - code: "-1000:i16" - tokens: - - type: i16 - value: -1000 - operations: - - function: push - type: i16 - value: -1000 - stack_final: - - type: i16 - value: -1000 - -- name: Integer i16 Hex - 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 - 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 - code: "0o1234:i16" - tokens: - - type: i16 - value: 668 - operations: - - function: push - type: i16 - value: 668 - stack_final: - - type: i16 - value: 668 - -- name: Integer i16 Max Value - code: "32767:i16" - tokens: - - type: i16 - value: 32767 - operations: - - function: push - type: i16 - value: 32767 - stack_final: - - type: i16 - value: 32767 - -- name: Integer i16 Min Value - code: "-32768:i16" - tokens: - - type: i16 - value: -32768 - operations: - - function: push - type: i16 - value: -32768 - stack_final: - - type: i16 - value: -32768 - -- name: Integer i16 Overflow - code: "32768:i16" - tokens: - - type: error - value: "Integer overflow: 32768 exceeds range for i16." - -- name: Integer i16 Underflow - code: "-32769:i16" - tokens: - - type: error - value: "Integer underflow: -32769 exceeds range for i16." - -# i8 coverage (additional to existing) -- name: Integer i8 Hex - 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 - 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 - code: "0o177:i8" - tokens: - - type: i8 - value: 127 - operations: - - function: push - type: i8 - value: 127 - stack_final: - - type: i8 - value: 127 - -- name: Integer i8 Zero - code: "0:i8" - tokens: - - type: i8 - value: 0 - operations: - - function: push - type: i8 - value: 0 - stack_final: - - type: i8 - value: 0 - -- 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 - -# u64 coverage -- name: Integer u64 Decimal - code: "42:u64" - tokens: - - type: u64 - value: 42 - operations: - - function: push - type: u64 - value: 42 - stack_final: - - type: u64 - value: 42 - -- name: Integer u64 Hex - code: "0xFFFFFFFFFFFFFFFF:u64" - tokens: - - type: u64 - value: 18446744073709551615 - operations: - - function: push - type: u64 - value: 18446744073709551615 - stack_final: - - type: u64 - value: 18446744073709551615 - -- name: Integer u64 Binary - code: "0b1010101010101010:u64" - tokens: - - type: u64 - value: 43690 - operations: - - function: push - type: u64 - value: 43690 - stack_final: - - type: u64 - value: 43690 - -- name: Integer u64 Octal - code: "0o7777:u64" - tokens: - - type: u64 - value: 4095 - operations: - - function: push - type: u64 - value: 4095 - stack_final: - - type: u64 - value: 4095 - -- name: Integer u64 Max Value - code: "18446744073709551615:u64" - tokens: - - type: u64 - value: 18446744073709551615 - operations: - - function: push - type: u64 - value: 18446744073709551615 - stack_final: - - type: u64 - value: 18446744073709551615 - -- name: Integer u64 Zero - code: "0:u64" - tokens: - - type: u64 - value: 0 - operations: - - function: push - type: u64 - value: 0 - stack_final: - - type: u64 - value: 0 - -- name: Integer u64 Overflow - code: "18446744073709551616:u64" - tokens: - - type: error - value: "Integer overflow: 18446744073709551616 exceeds range for u64." - -- name: Integer u64 Negative Invalid - code: "-1:u64" - tokens: - - type: error - value: "Integer underflow: -1 exceeds range for u64." - -# u32 coverage -- name: Integer u32 Decimal - code: "1000000:u32" - tokens: - - type: u32 - value: 1000000 - operations: - - function: push - type: u32 - value: 1000000 - stack_final: - - type: u32 - value: 1000000 - -- name: Integer u32 Hex - 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 - 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 - code: "0o37777777777:u32" - tokens: - - type: u32 - value: 4294967295 - operations: - - function: push - type: u32 - value: 4294967295 - stack_final: - - type: u32 - value: 4294967295 - -- name: Integer u32 Max Value - code: "4294967295:u32" - tokens: - - type: u32 - value: 4294967295 - operations: - - function: push - type: u32 - value: 4294967295 - stack_final: - - type: u32 - value: 4294967295 - -- name: Integer u32 Overflow - code: "4294967296:u32" - tokens: - - type: error - value: "Integer overflow: 4294967296 exceeds range for u32." - -- name: Integer u32 Negative Invalid - code: "-1:u32" - tokens: - - type: error - value: "Integer underflow: -1 exceeds range for u32." - -# u16 coverage -- name: Integer u16 Decimal - code: "50000:u16" - tokens: - - type: u16 - value: 50000 - operations: - - function: push - type: u16 - value: 50000 - stack_final: - - type: u16 - value: 50000 - -- name: Integer u16 Hex - 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 - 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 - code: "0o177777:u16" - tokens: - - type: u16 - value: 65535 - operations: - - function: push - type: u16 - value: 65535 - stack_final: - - type: u16 - value: 65535 - -- name: Integer u16 Max Value - code: "65535:u16" - tokens: - - type: u16 - value: 65535 - operations: - - function: push - type: u16 - value: 65535 - stack_final: - - type: u16 - value: 65535 - -- name: Integer u16 Overflow - code: "65536:u16" - tokens: - - type: error - value: "Integer overflow: 65536 exceeds range for u16." - -- name: Integer u16 Negative Invalid - code: "-1:u16" - tokens: - - type: error - value: "Integer underflow: -1 exceeds range for u16." - -# u8 coverage (additional to existing) -- name: Integer u8 Hex - 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 - 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 - code: "0o377:u8" - tokens: - - type: u8 - value: 255 - operations: - - function: push - type: u8 - value: 255 - stack_final: - - type: u8 - value: 255 - -- name: Integer u8 Zero - code: "0:u8" - tokens: - - type: u8 - value: 0 - operations: - - function: push - type: u8 - value: 0 - stack_final: - - type: u8 - value: 0 - -- name: Integer u8 Overflow - code: "256:u8" - tokens: - - type: error - value: "Integer overflow: 256 exceeds range for u8." - -- name: Integer u8 Negative Invalid - code: "-1:u8" - tokens: - - type: error - value: "Integer underflow: -1 exceeds range for u8." - -# Edge cases with underscores in different bases -- name: Integer Hex With Underscores - code: "0xDEAD_BEEF:i64" +- name: Integer Default Decimal with Underscore + code: '1_000_000' tokens: - type: i64 - value: 3735928559 + value: 1000000 operations: - function: push type: i64 - value: 3735928559 + value: 1000000 stack_final: - type: i64 - value: 3735928559 - -- name: Integer Binary With Underscores - code: "0b1111_0000_1010_0101:i32" + value: 1000000 +- name: Integer Default Underscore End + code: '42_' tokens: - - type: i32 - value: 61605 + - type: i64 + value: 42 operations: - function: push - type: i32 - value: 61605 + type: i64 + value: 42 stack_final: - - type: i32 - value: 61605 - -- name: Integer Octal With Underscores - code: "0o7_7_7:i16" + - type: i64 + value: 42 +- name: Integer Default Underscore Double + code: '4__2' tokens: - - type: i16 - value: 511 + - type: i64 + value: 42 operations: - function: push - type: i16 - value: 511 + type: i64 + value: 42 stack_final: - - type: i16 - value: 511 - -# Zero in different bases + - type: i64 + value: 42 +- name: Integer Default Whitespace + code: ' 42 ' + tokens: + - type: i64 + value: 42 + operations: + - function: push + type: i64 + value: 42 + stack_final: + - type: i64 + value: 42 - name: Integer Default Hex Zero - code: "0x0" + code: '0x0' tokens: - type: i64 value: 0 @@ -1037,9 +217,8 @@ stack_final: - type: i64 value: 0 - - name: Integer Default Binary Zero - code: "0b0" + code: '0b0' tokens: - type: i64 value: 0 @@ -1050,9 +229,8 @@ stack_final: - type: i64 value: 0 - - name: Integer Default Octal Zero - code: "0o0" + code: 0o0 tokens: - type: i64 value: 0 @@ -1063,66 +241,1238 @@ stack_final: - type: i64 value: 0 - -# Basic Floats -# Basic Strings -# Basic Booleans -# Basic Identifiers -# Basic Identifier Literals -# Basic Arrays -# Basic Token Strings -# Stack Operations -# Arithmetic Operations -# Comparison Operations -# Logical Operations -# Bitwise Operations -# Function Definitions -# Lambda Functions -# Conditional Statements -# While Loops -# For Loops -# Match Statements -# Structs -# Unions -# Enums -# Array Operations -# Array Combinators -# Array Arithmetic -# Array Manipulation -# Type Inference -# Type Tuples -# Trait Definition -# Trait Implementation -# Trait Inheritance -# Stackable Trait -# Addable Trait -# Multiplyable Trait -# Exponentiable Trait -# Logarithmic Trait -# Number Trait -# Orderable Trait -# Equatable Trait -# Comparable Trait -# Logical Trait -# Bitwise Trait -# Sized Trait -# Selectable Trait -# Sliceable Trait -# Concatenable Trait -# ArrayOf Trait -# Iterable Trait -# Convertible Trait -# Stringifiable Trait -# Parseable Trait -# String Trait -# Size Trait -# Identifier Trait -# Implementable Trait -# Generics -# Eval -# Std Lib IO -# Std Lib Strings -# Std Lib Type conversions -# Error Handling -# Reflection - +- name: Integer Default Decimal with Commas Invalid + code: 1,000,000 + tokens: + - type: error + value: 'Invalid decimal literal: unexpected '','' in decimal integer.' +- name: Integer Default Invalid Characters + code: 12a3 + tokens: + - type: error + value: 'Invalid decimal literal: unexpected ''a'' in decimal integer.' +- name: Integer Default Invalid Prefix + code: 0b2 + tokens: + - type: error + value: 'Invalid binary literal: unexpected ''2'' in binary integer.' +- name: Integer i8 Decimal Positive + code: 42:i8 + tokens: + - type: i8 + value: 42 + operations: + - function: push + type: i8 + value: 42 + stack_final: + - type: i8 + value: 42 +- name: Integer i8 Zero + code: 0:i8 + tokens: + - type: i8 + value: 0 + operations: + - function: push + type: i8 + value: 0 + stack_final: + - type: i8 + value: 0 +- name: Integer i8 Decimal Negative + code: -100:i8 + tokens: + - type: i8 + value: -100 + operations: + - function: push + type: i8 + value: -100 + stack_final: + - type: i8 + value: -100 +- name: Integer i8 Hex + 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 + code: 0b1111:i8 + tokens: + - type: i8 + value: 15 + operations: + - function: push + type: i8 + value: 15 + stack_final: + - type: i8 + value: 15 +- name: Integer i8 Octal + code: 0o77:i8 + tokens: + - type: i8 + value: 63 + operations: + - function: push + type: i8 + value: 63 + stack_final: + - type: i8 + value: 63 +- name: Integer i8 Max Value + code: 127:i8 + tokens: + - type: i8 + value: 127 + operations: + - function: push + type: i8 + value: 127 + stack_final: + - type: i8 + value: 127 +- name: Integer i8 Min Value + code: -128:i8 + tokens: + - type: i8 + value: -128 + operations: + - function: push + type: i8 + value: -128 + stack_final: + - type: i8 + value: -128 +- name: Integer i8 Overflow + code: 128:i8 + tokens: + - type: error + value: 'Integer overflow: 128 exceeds range for i8.' +- name: Integer i8 Underflow + code: -129:i8 + tokens: + - type: error + value: 'Integer underflow: -129 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: + - type: i16 + value: 42 + operations: + - function: push + type: i16 + value: 42 + stack_final: + - type: i16 + value: 42 +- name: Integer i16 Zero + code: 0:i16 + tokens: + - type: i16 + value: 0 + operations: + - function: push + type: i16 + value: 0 + stack_final: + - type: i16 + value: 0 +- name: Integer i16 Decimal Negative + code: -100:i16 + tokens: + - type: i16 + value: -100 + operations: + - function: push + type: i16 + value: -100 + stack_final: + - type: i16 + value: -100 +- name: Integer i16 Hex + code: 0xFF:i16 + tokens: + - type: i16 + value: 255 + operations: + - function: push + type: i16 + value: 255 + stack_final: + - type: i16 + value: 255 +- name: Integer i16 Binary + code: 0b1111:i16 + tokens: + - type: i16 + value: 15 + operations: + - function: push + type: i16 + value: 15 + stack_final: + - type: i16 + value: 15 +- name: Integer i16 Octal + code: 0o77:i16 + tokens: + - type: i16 + value: 63 + operations: + - function: push + type: i16 + value: 63 + stack_final: + - type: i16 + value: 63 +- name: Integer i16 Max Value + code: 32767:i16 + tokens: + - type: i16 + value: 32767 + operations: + - function: push + type: i16 + value: 32767 + stack_final: + - type: i16 + value: 32767 +- name: Integer i16 Min Value + code: -32768:i16 + tokens: + - type: i16 + value: -32768 + operations: + - function: push + type: i16 + value: -32768 + stack_final: + - type: i16 + value: -32768 +- name: Integer i16 Overflow + code: 32768:i16 + tokens: + - type: error + value: 'Integer overflow: 32768 exceeds range for i16.' +- name: Integer i16 Underflow + code: -32769:i16 + tokens: + - type: error + value: 'Integer underflow: -32769 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: + - type: i32 + value: 42 + operations: + - function: push + type: i32 + value: 42 + stack_final: + - type: i32 + value: 42 +- name: Integer i32 Zero + code: 0:i32 + tokens: + - type: i32 + value: 0 + operations: + - function: push + type: i32 + value: 0 + stack_final: + - type: i32 + value: 0 +- name: Integer i32 Decimal Negative + code: -100:i32 + tokens: + - type: i32 + value: -100 + operations: + - function: push + type: i32 + value: -100 + stack_final: + - type: i32 + value: -100 +- name: Integer i32 Hex + code: 0xFF:i32 + tokens: + - type: i32 + value: 255 + operations: + - function: push + type: i32 + value: 255 + stack_final: + - type: i32 + value: 255 +- name: Integer i32 Binary + code: 0b1111:i32 + tokens: + - type: i32 + value: 15 + operations: + - function: push + type: i32 + value: 15 + stack_final: + - type: i32 + value: 15 +- name: Integer i32 Octal + code: 0o77:i32 + tokens: + - type: i32 + value: 63 + operations: + - function: push + type: i32 + value: 63 + stack_final: + - type: i32 + value: 63 +- name: Integer i32 Max Value + code: 2147483647:i32 + tokens: + - type: i32 + value: 2147483647 + operations: + - function: push + type: i32 + value: 2147483647 + stack_final: + - type: i32 + value: 2147483647 +- name: Integer i32 Min Value + code: -2147483648:i32 + tokens: + - type: i32 + value: -2147483648 + operations: + - function: push + type: i32 + value: -2147483648 + stack_final: + - type: i32 + value: -2147483648 +- name: Integer i32 Overflow + code: 2147483648:i32 + tokens: + - type: error + value: 'Integer overflow: 2147483648 exceeds range for i32.' +- name: Integer i32 Underflow + code: -2147483649:i32 + tokens: + - type: error + value: 'Integer underflow: -2147483649 exceeds range for i32.' +- name: Integer i32 With Underscores + code: 1_000_000:i32 + tokens: + - type: i32 + value: 1000000 + operations: + - function: push + type: i32 + value: 1000000 + 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: + - type: i64 + value: 42 + operations: + - function: push + type: i64 + value: 42 + stack_final: + - type: i64 + value: 42 +- name: Integer i64 Zero + code: 0:i64 + tokens: + - type: i64 + value: 0 + operations: + - function: push + type: i64 + value: 0 + stack_final: + - type: i64 + value: 0 +- name: Integer i64 Decimal Negative + code: -100:i64 + tokens: + - type: i64 + value: -100 + operations: + - function: push + type: i64 + value: -100 + stack_final: + - type: i64 + value: -100 +- name: Integer i64 Hex + 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 + code: 0b1111:i64 + tokens: + - type: i64 + value: 15 + operations: + - function: push + type: i64 + value: 15 + stack_final: + - type: i64 + value: 15 +- name: Integer i64 Octal + code: 0o77:i64 + tokens: + - type: i64 + value: 63 + operations: + - function: push + type: i64 + value: 63 + stack_final: + - type: i64 + value: 63 +- name: Integer i64 Max Value + code: 9223372036854775807:i64 + tokens: + - type: i64 + value: 9223372036854775807 + operations: + - function: push + type: i64 + value: 9223372036854775807 + stack_final: + - type: i64 + value: 9223372036854775807 +- name: Integer i64 Min Value + code: -9223372036854775808:i64 + tokens: + - type: i64 + value: -9223372036854775808 + operations: + - function: push + type: i64 + value: -9223372036854775808 + stack_final: + - type: i64 + value: -9223372036854775808 +- name: Integer i64 Overflow + code: 9223372036854775808:i64 + tokens: + - type: error + value: 'Integer overflow: 9223372036854775808 exceeds range for i64.' +- name: Integer i64 Underflow + code: -9223372036854775809:i64 + tokens: + - type: error + value: 'Integer underflow: -9223372036854775809 exceeds range for i64.' +- name: Integer i64 With Underscores + code: 1_000_000:i64 + tokens: + - type: i64 + value: 1000000 + operations: + - function: push + type: i64 + value: 1000000 + 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: + - type: u8 + value: 42 + operations: + - function: push + type: u8 + value: 42 + stack_final: + - type: u8 + value: 42 +- name: Integer u8 Zero + code: 0:u8 + tokens: + - type: u8 + value: 0 + operations: + - function: push + type: u8 + value: 0 + stack_final: + - type: u8 + value: 0 +- name: Integer u8 Hex + 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 + code: 0b1111:u8 + tokens: + - type: u8 + value: 15 + operations: + - function: push + type: u8 + value: 15 + stack_final: + - type: u8 + value: 15 +- name: Integer u8 Octal + code: 0o77:u8 + tokens: + - type: u8 + value: 63 + operations: + - function: push + type: u8 + value: 63 + stack_final: + - type: u8 + value: 63 +- name: Integer u8 Max Value + code: 255:u8 + tokens: + - type: u8 + value: 255 + operations: + - function: push + type: u8 + value: 255 + stack_final: + - type: u8 + value: 255 +- name: Integer u8 Min Value + code: 0:u8 + tokens: + - type: u8 + value: 0 + operations: + - function: push + type: u8 + value: 0 + stack_final: + - type: u8 + value: 0 +- name: Integer u8 Overflow + code: 256:u8 + tokens: + - type: error + value: 'Integer overflow: 256 exceeds range for u8.' +- name: Integer u8 Underflow + code: -1:u8 + tokens: + - type: error + value: 'Integer underflow: -1 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: + - type: u16 + value: 42 + operations: + - function: push + type: u16 + value: 42 + stack_final: + - type: u16 + value: 42 +- name: Integer u16 Zero + code: 0:u16 + tokens: + - type: u16 + value: 0 + operations: + - function: push + type: u16 + value: 0 + stack_final: + - type: u16 + value: 0 +- name: Integer u16 Hex + code: 0xFF:u16 + tokens: + - type: u16 + value: 255 + operations: + - function: push + type: u16 + value: 255 + stack_final: + - type: u16 + value: 255 +- name: Integer u16 Binary + code: 0b1111:u16 + tokens: + - type: u16 + value: 15 + operations: + - function: push + type: u16 + value: 15 + stack_final: + - type: u16 + value: 15 +- name: Integer u16 Octal + code: 0o77:u16 + tokens: + - type: u16 + value: 63 + operations: + - function: push + type: u16 + value: 63 + stack_final: + - type: u16 + value: 63 +- name: Integer u16 Max Value + code: 65535:u16 + tokens: + - type: u16 + value: 65535 + operations: + - function: push + type: u16 + value: 65535 + stack_final: + - type: u16 + value: 65535 +- name: Integer u16 Min Value + code: 0:u16 + tokens: + - type: u16 + value: 0 + operations: + - function: push + type: u16 + value: 0 + stack_final: + - type: u16 + value: 0 +- name: Integer u16 Overflow + code: 65536:u16 + tokens: + - type: error + value: 'Integer overflow: 65536 exceeds range for u16.' +- name: Integer u16 Underflow + code: -1:u16 + tokens: + - type: error + value: 'Integer underflow: -1 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: + - type: u32 + value: 42 + operations: + - function: push + type: u32 + value: 42 + stack_final: + - type: u32 + value: 42 +- name: Integer u32 Zero + code: 0:u32 + tokens: + - type: u32 + value: 0 + operations: + - function: push + type: u32 + value: 0 + stack_final: + - type: u32 + value: 0 +- name: Integer u32 Hex + code: 0xFF:u32 + tokens: + - type: u32 + value: 255 + operations: + - function: push + type: u32 + value: 255 + stack_final: + - type: u32 + value: 255 +- name: Integer u32 Binary + code: 0b1111:u32 + tokens: + - type: u32 + value: 15 + operations: + - function: push + type: u32 + value: 15 + stack_final: + - type: u32 + value: 15 +- name: Integer u32 Octal + code: 0o77:u32 + tokens: + - type: u32 + value: 63 + operations: + - function: push + type: u32 + value: 63 + stack_final: + - type: u32 + value: 63 +- name: Integer u32 Max Value + code: 4294967295:u32 + tokens: + - type: u32 + value: 4294967295 + operations: + - function: push + type: u32 + value: 4294967295 + stack_final: + - type: u32 + value: 4294967295 +- name: Integer u32 Min Value + code: 0:u32 + tokens: + - type: u32 + value: 0 + operations: + - function: push + type: u32 + value: 0 + stack_final: + - type: u32 + value: 0 +- name: Integer u32 Overflow + code: 4294967296:u32 + tokens: + - type: error + value: 'Integer overflow: 4294967296 exceeds range for u32.' +- name: Integer u32 Underflow + code: -1:u32 + tokens: + - type: error + value: 'Integer underflow: -1 exceeds range for u32.' +- name: Integer u32 With Underscores + code: 1_000_000:u32 + tokens: + - type: u32 + value: 1000000 + operations: + - function: push + type: u32 + value: 1000000 + 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: + - type: u64 + value: 42 + operations: + - function: push + type: u64 + value: 42 + stack_final: + - type: u64 + value: 42 +- name: Integer u64 Zero + code: 0:u64 + tokens: + - type: u64 + value: 0 + operations: + - function: push + type: u64 + value: 0 + stack_final: + - type: u64 + value: 0 +- name: Integer u64 Hex + code: 0xFF:u64 + tokens: + - type: u64 + value: 255 + operations: + - function: push + type: u64 + value: 255 + stack_final: + - type: u64 + value: 255 +- name: Integer u64 Binary + code: 0b1111:u64 + tokens: + - type: u64 + value: 15 + operations: + - function: push + type: u64 + value: 15 + stack_final: + - type: u64 + value: 15 +- name: Integer u64 Octal + code: 0o77:u64 + tokens: + - type: u64 + value: 63 + operations: + - function: push + type: u64 + value: 63 + stack_final: + - type: u64 + value: 63 +- name: Integer u64 Max Value + code: 18446744073709551615:u64 + tokens: + - type: u64 + value: 18446744073709551615 + operations: + - function: push + type: u64 + value: 18446744073709551615 + stack_final: + - type: u64 + value: 18446744073709551615 +- name: Integer u64 Min Value + code: 0:u64 + tokens: + - type: u64 + value: 0 + operations: + - function: push + type: u64 + value: 0 + stack_final: + - type: u64 + value: 0 +- name: Integer u64 Overflow + code: 18446744073709551616:u64 + tokens: + - type: error + value: 'Integer overflow: 18446744073709551616 exceeds range for u64.' +- name: Integer u64 Underflow + code: -1:u64 + tokens: + - type: error + value: 'Integer underflow: -1 exceeds range for u64.' +- name: Integer u64 With Underscores + code: 1_000_000:u64 + tokens: + - type: u64 + value: 1000000 + operations: + - function: push + type: u64 + value: 1000000 + stack_final: + - type: u64 + value: 1000000 +- name: Integer u64 Hex Max + code: 0xFFFFFFFFFFFFFFFF:u64 + tokens: + - type: u64 + value: 18446744073709551615 + operations: + - function: push + type: u64 + value: 18446744073709551615 + stack_final: + - type: u64 + value: 18446744073709551615 +- name: Integer u64 Binary Sample + code: 0b1010101010101010:u64 + tokens: + - type: u64 + value: 43690 + operations: + - function: push + type: u64 + value: 43690 + stack_final: + - type: u64 + value: 43690 +- name: Integer u64 Octal Sample + code: 0o7777:u64 + tokens: + - type: u64 + value: 4095 + operations: + - function: push + type: u64 + value: 4095 + stack_final: + - type: u64 + value: 4095 +- name: Integer u64 Decimal + code: 42:u64 + tokens: + - type: u64 + value: 42 + operations: + - function: push + type: u64 + value: 42 + stack_final: + - type: u64 + value: 42 +- name: Integer Hex With Underscores + code: 0xDEAD_BEEF:i64 + tokens: + - type: i64 + value: 3735928559 + operations: + - function: push + type: i64 + value: 3735928559 + stack_final: + - type: i64 + value: 3735928559 +- name: Integer Binary With Underscores + code: 0b1111_0000_1010_0101:i32 + tokens: + - type: i32 + value: 61605 + operations: + - function: push + type: i32 + value: 61605 + stack_final: + - type: i32 + value: 61605 +- name: Integer Octal With Underscores + code: 0o7_7_7:i16 + tokens: + - type: i16 + value: 511 + operations: + - function: push + type: i16 + value: 511 + stack_final: + - type: i16 + value: 511 diff --git a/SLS_Tests/generate_tests.py b/SLS_Tests/generate_tests.py new file mode 100644 index 0000000..e19f140 --- /dev/null +++ b/SLS_Tests/generate_tests.py @@ -0,0 +1,355 @@ +""" +Test case generator for integer literals in the Stack Language. +Generates comprehensive test cases for all integer types and bases. +""" + +from typing import List, Dict, Any, Optional +from dataclasses import dataclass, asdict + + +@dataclass +class Token: + type: str + value: Any + + +@dataclass +class Operation: + function: str + type: str + value: Any + + +@dataclass +class StackItem: + type: str + value: Any + + +@dataclass +class RuntimeError: + message: str + + +@dataclass +class TestCase: + name: str + code: str + tokens: List[Dict[str, Any]] + operations: Optional[List[Dict[str, Any]]] = None + stack_final: Optional[List[Dict[str, Any]]] = None + runtime_error: Optional[Dict[str, str]] = None + + +def to_dict(obj): + """Convert dataclass to dict, removing None values.""" + if obj is None: + return None + d = asdict(obj) if hasattr(obj, '__dataclass_fields__') else obj + return {k: v for k, v in d.items() if v is not None} + + +class IntegerTestGenerator: + """Generate test cases for integer literals.""" + + # Type ranges + TYPE_RANGES = { + 'i8': (-128, 127), + 'i16': (-32768, 32767), + 'i32': (-2147483648, 2147483647), + 'i64': (-9223372036854775808, 9223372036854775807), + 'u8': (0, 255), + 'u16': (0, 65535), + 'u32': (0, 4294967295), + 'u64': (0, 18446744073709551615), + } + + def __init__(self): + self.tests = [] + + def add_test(self, name: str, code: str, tokens: List[Token], + operations: Optional[List[Operation]] = None, + stack_final: Optional[List[StackItem]] = None, + runtime_error: Optional[RuntimeError] = None): + """Add a test case.""" + test = TestCase( + name=name, + code=code, + tokens=[to_dict(t) for t in tokens], + operations=[to_dict(o) for o in operations] if operations else None, + stack_final=[to_dict(s) for s in stack_final] if stack_final else None, + runtime_error=to_dict(runtime_error) if runtime_error else None + ) + self.tests.append(to_dict(test)) + + def make_push_op(self, type_name: str, value: Any) -> Operation: + """Create a push operation.""" + return Operation(function="push", type=type_name, value=value) + + def make_stack_item(self, type_name: str, value: Any) -> StackItem: + """Create a stack item.""" + return StackItem(type=type_name, value=value) + + def make_error_token(self, message: str) -> Token: + """Create an error token.""" + return Token(type="error", value=message) + + def make_success_test(self, name: str, code: str, type_name: str, value: Any): + """Create a successful test case.""" + token = Token(type=type_name, value=value) + op = self.make_push_op(type_name, value) + stack = self.make_stack_item(type_name, value) + self.add_test(name, code, [token], [op], [stack]) + + def make_error_test(self, name: str, code: str, error_msg: str): + """Create an error test case.""" + token = self.make_error_token(error_msg) + self.add_test(name, code, [token]) + + def generate_basic_tests(self): + """Generate basic test cases.""" + # Empty statement + self.add_test("Empty_Statement", "", [], [], []) + + # Simple default integers + self.make_success_test("Integer Default Decimal 0", "0", "i64", 0) + self.make_success_test("Integer Default Decimal -1", "-1", "i64", -1) + self.make_success_test("Integer Default Decimal 42", "42", "i64", 42) + self.make_success_test("Integer Default Decimal Leading Zeros", "00042", "i64", 42) + + def generate_default_base_tests(self): + """Generate tests for default type with different bases.""" + # Hexadecimal + self.make_success_test("Integer Default Hex 0xFF", "0xFF", "i64", 255) + self.make_success_test("Integer Default Hex 0xdeadbeef", "0xdeadbeef", "i64", 3735928559) + self.make_success_test("Integer Default Hex Max", "0x7FFFFFFFFFFFFFFF", "i64", 9223372036854775807) + + # Binary + self.make_success_test("Integer Default Binary 0b1010", "0b1010", "i64", 10) + self.make_success_test("Integer Default Binary All Ones", "0b1111111111111111", "i64", 65535) + + # Octal + self.make_success_test("Integer Default Octal 0o755", "0o755", "i64", 493) + self.make_success_test("Integer Default Octal Max Three Digits", "0o777", "i64", 511) + + def generate_default_edge_cases(self): + """Generate edge case tests for default type.""" + # Min/max values + self.make_success_test("Integer Default Decimal Max i64", + "9223372036854775807", "i64", 9223372036854775807) + self.make_success_test("Integer Default Decimal Min i64", + "-9223372036854775808", "i64", -9223372036854775808) + + # Underscores + self.make_success_test("Integer Default Decimal with Underscore", + "1_000_000", "i64", 1000000) + self.make_success_test("Integer Default Underscore End", "42_", "i64", 42) + self.make_success_test("Integer Default Underscore Double", "4__2", "i64", 42) + + # Whitespace + self.make_success_test("Integer Default Whitespace", " 42 ", "i64", 42) + + # Zeros in different bases + self.make_success_test("Integer Default Hex Zero", "0x0", "i64", 0) + self.make_success_test("Integer Default Binary Zero", "0b0", "i64", 0) + self.make_success_test("Integer Default Octal Zero", "0o0", "i64", 0) + + def generate_default_error_tests(self): + """Generate error tests for default type.""" + self.make_error_test("Integer Default Decimal with Commas Invalid", + "1,000,000", + "Invalid decimal literal: unexpected ',' in decimal integer.") + self.make_error_test("Integer Default Invalid Characters", + "12a3", + "Invalid decimal literal: unexpected 'a' in decimal integer.") + self.make_error_test("Integer Default Invalid Prefix", + "0b2", + "Invalid binary literal: unexpected '2' in binary integer.") + + def generate_typed_tests(self, type_name: str): + """Generate tests for a specific type across all bases.""" + min_val, max_val = self.TYPE_RANGES[type_name] + is_unsigned = type_name.startswith('u') + + # Basic decimal + test_val = 42 if max_val >= 42 else max_val + self.make_success_test(f"Integer {type_name} Decimal Positive", + f"{test_val}:{type_name}", type_name, test_val) + + # Zero + self.make_success_test(f"Integer {type_name} Zero", + f"0:{type_name}", type_name, 0) + + # Negative (only for signed types) + if not is_unsigned: + neg_val = -100 if min_val <= -100 else min_val + self.make_success_test(f"Integer {type_name} Decimal Negative", + f"{neg_val}:{type_name}", type_name, neg_val) + + # Hexadecimal + hex_val = min(255, max_val) + self.make_success_test(f"Integer {type_name} Hex", + f"0x{hex_val:X}:{type_name}", type_name, hex_val) + + # Binary + bin_val = min(15, max_val) + self.make_success_test(f"Integer {type_name} Binary", + f"0b{bin_val:b}:{type_name}", type_name, bin_val) + + # Octal + oct_val = min(63, max_val) + self.make_success_test(f"Integer {type_name} Octal", + f"0o{oct_val:o}:{type_name}", type_name, oct_val) + + # Max value + self.make_success_test(f"Integer {type_name} Max Value", + f"{max_val}:{type_name}", type_name, max_val) + + # Min value + self.make_success_test(f"Integer {type_name} Min Value", + f"{min_val}:{type_name}", type_name, min_val) + + # Overflow + overflow_val = max_val + 1 + self.make_error_test(f"Integer {type_name} Overflow", + f"{overflow_val}:{type_name}", + f"Integer overflow: {overflow_val} exceeds range for {type_name}.") + + # Underflow + underflow_val = min_val - 1 + self.make_error_test(f"Integer {type_name} Underflow", + f"{underflow_val}:{type_name}", + f"Integer underflow: {underflow_val} 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: + self.make_success_test(f"Integer {type_name} With Underscores", + f"1_000_000:{type_name}", type_name, 1000000) + + # 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) + + 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) + + 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) + + 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) + + 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) + + 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) + + 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) + + elif type_name == 'u64': + self.make_success_test("Integer u64 Hex Max", + "0xFFFFFFFFFFFFFFFF:u64", + "u64", 18446744073709551615) + 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.""" + self.make_success_test("Integer Hex With Underscores", + "0xDEAD_BEEF:i64", "i64", 3735928559) + self.make_success_test("Integer Binary With Underscores", + "0b1111_0000_1010_0101:i32", "i32", 61605) + self.make_success_test("Integer Octal With Underscores", + "0o7_7_7:i16", "i16", 511) + + def generate_all_tests(self) -> List[Dict[str, Any]]: + """Generate all test cases.""" + # Basic tests + self.generate_basic_tests() + + # Default type (i64) comprehensive tests + self.generate_default_base_tests() + self.generate_default_edge_cases() + self.generate_default_error_tests() + + # 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) + + # Additional edge cases + self.generate_underscore_tests() + + return self.tests + + +def generate_integer_literal_tests() -> List[Dict[str, Any]]: + """ + Main function to generate all integer literal test cases. + + Returns: + List of test case dictionaries ready for serialization + """ + generator = IntegerTestGenerator() + return generator.generate_all_tests() + + +if __name__ == "__main__": + # import json + import yaml + + # Generate tests + tests = generate_integer_literal_tests() + + # Print summary + print(f"Generated {len(tests)} test cases") + + # # Save as JSON + # with open("integer_literal_tests.json", "w") as f: + # json.dump(tests, f, indent=2) + # print("Saved to integer_literal_tests.json") + + # # Save as YAML + # with open("integer_literal_tests.yaml", "w") as f: + # yaml.dump(tests, f, default_flow_style=False, sort_keys=False) + # print("Saved to integer_literal_tests.yaml") + + # Save as YAML + with open("cases.yaml", "w") as f: + yaml.dump(tests, f, default_flow_style=False, sort_keys=False) + + # Print first few tests as example + print("\nFirst 3 test cases:") + print(yaml.dump(tests[:3], default_flow_style=False, sort_keys=False))