From 3b1e05241eb2ccaf7ea5b90a2bf7137ed18e977e Mon Sep 17 00:00:00 2001 From: Kyler Date: Thu, 6 Nov 2025 16:16:24 -0700 Subject: [PATCH] Fixed and added more test cases --- SLS_C/tests/lexer_tests.c | 753 +++++++++++++++++++++++++++++++++- SLS_Tests/cases.yaml | 834 +++++++++++++++++++++++++++++++++++++- 2 files changed, 1580 insertions(+), 7 deletions(-) diff --git a/SLS_C/tests/lexer_tests.c b/SLS_C/tests/lexer_tests.c index c909818..c237172 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 = 20; +static const size_t NUM_OF_TESTS = 89; static TestResult test_Empty_Statement() { LexerTest test = start_up_test("test_Empty_Statement", ""); @@ -151,7 +151,7 @@ static TestResult test_Integer_i8_Overflow() { LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; - if (test_eof_value(&test, result, i++, 0)) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){44, "Integer overflow: 128 exceeds range for i8."})) return test.result; return pass_test(&test, result); } @@ -160,7 +160,7 @@ static TestResult test_Integer_i8_Underflow() { LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; - if (test_eof_value(&test, result, i++, 0)) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){46, "Integer underflow: -129 exceeds range for i8."})) return test.result; return pass_test(&test, result); } @@ -212,6 +212,684 @@ static TestResult test_Integer_Default_Underscore_Double() { return pass_test(&test, result); } +static TestResult test_Integer_Default_Decimal_Max_i64() { + LexerTest test = start_up_test("test_Integer_Default_Decimal_Max_i64", "9223372036854775807"); + LexerResult result = 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_Decimal_Min_i64() { + LexerTest test = start_up_test("test_Integer_Default_Decimal_Min_i64", "-9223372036854775808"); + LexerResult result = 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_eof_value(&test, result, i++, 0)) return test.result; + 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"); + LexerResult result = 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_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_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_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_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_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_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_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_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_i32_Hex() { + LexerTest test = start_up_test("test_Integer_i32_Hex", "0xABCD:i32"); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 43981})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i32_Binary() { + LexerTest test = start_up_test("test_Integer_i32_Binary", "0b11110000:i32"); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 240})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i32_Octal() { + LexerTest test = start_up_test("test_Integer_i32_Octal", "0o777:i32"); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 511})) 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"); + LexerResult result = 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_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"); + LexerResult result = 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_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"); + LexerResult result = 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; + return pass_test(&test, result); +} + +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){54, "Integer underflow: -2147483649 exceeds range for i32."})) 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"); + LexerResult result = 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_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"); + LexerResult result = 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_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"); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 4660})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i16_Binary() { + LexerTest test = start_up_test("test_Integer_i16_Binary", "0b1111111100000000:i16"); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 65280})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i16_Octal() { + LexerTest test = start_up_test("test_Integer_i16_Octal", "0o1234:i16"); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 668})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i16_Max_Value() { + LexerTest test = start_up_test("test_Integer_i16_Max_Value", "32767: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, 32767})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i16_Min_Value() { + LexerTest test = start_up_test("test_Integer_i16_Min_Value", "-32768: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, -32768})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i16_Overflow() { + LexerTest test = start_up_test("test_Integer_i16_Overflow", "32768: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_for_error(&test, result, i++, &(TestErrorMessage){47, "Integer overflow: 32768 exceeds range for i16."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_i16_Underflow() { + LexerTest test = start_up_test("test_Integer_i16_Underflow", "-32769: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_for_error(&test, result, i++, &(TestErrorMessage){49, "Integer underflow: -32769 exceeds range for i16."})) return test.result; + return pass_test(&test, result); +} + +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_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() { + LexerTest test = start_up_test("test_Integer_i8_Binary", "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() { + LexerTest test = start_up_test("test_Integer_i8_Octal", "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_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_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_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_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_u64_Hex() { + LexerTest test = start_up_test("test_Integer_u64_Hex", "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() { + LexerTest test = start_up_test("test_Integer_u64_Binary", "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() { + LexerTest test = start_up_test("test_Integer_u64_Octal", "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_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_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_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_Negative_Invalid() { + LexerTest test = start_up_test("test_Integer_u64_Negative_Invalid", "-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_u32_Decimal() { + LexerTest test = start_up_test("test_Integer_u32_Decimal", "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_u32_Hex() { + LexerTest test = start_up_test("test_Integer_u32_Hex", "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() { + LexerTest test = start_up_test("test_Integer_u32_Binary", "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() { + LexerTest test = start_up_test("test_Integer_u32_Octal", "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_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_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_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_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"); + LexerResult result = 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() { + LexerTest test = start_up_test("test_Integer_u16_Binary", "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() { + LexerTest test = start_up_test("test_Integer_u16_Octal", "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_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_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_Negative_Invalid() { + LexerTest test = start_up_test("test_Integer_u16_Negative_Invalid", "-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_u8_Hex() { + LexerTest test = start_up_test("test_Integer_u8_Hex", "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() { + LexerTest test = start_up_test("test_Integer_u8_Binary", "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() { + LexerTest test = start_up_test("test_Integer_u8_Octal", "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_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); +} + +static TestResult test_Integer_u8_Overflow() { + LexerTest test = start_up_test("test_Integer_u8_Overflow", "256: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_for_error(&test, result, i++, &(TestErrorMessage){44, "Integer overflow: 256 exceeds range for u8."})) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_u8_Negative_Invalid() { + LexerTest test = start_up_test("test_Integer_u8_Negative_Invalid", "-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; + if (test_for_error(&test, result, i++, &(TestErrorMessage){44, "Integer underflow: -1 exceeds range for u8."})) 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); + 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, 3735928559})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_Binary_With_Underscores() { + LexerTest test = start_up_test("test_Integer_Binary_With_Underscores", "0b1111_0000_1010_0101:i32"); + LexerResult result = lexical_analysis(&test.lexer_info); + if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); + size_t i = 0; + if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 61605})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + return pass_test(&test, result); +} + +static TestResult test_Integer_Octal_With_Underscores() { + LexerTest test = start_up_test("test_Integer_Octal_With_Underscores", "0o7_7_7: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, 511})) return test.result; + if (test_eof_value(&test, result, i++, 0)) return test.result; + 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", @@ -241,6 +919,75 @@ TestsReport run_lexer_tests() { 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_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_i16_Decimal_Positive(); + 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(); + test_report.tests[i++] = test_Integer_i16_Octal(); + test_report.tests[i++] = test_Integer_i16_Max_Value(); + 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_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_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_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 f8a0f30..1585e60 100644 --- a/SLS_Tests/cases.yaml +++ b/SLS_Tests/cases.yaml @@ -179,13 +179,15 @@ - name: Integer i8 Overflow code: "128:i8" - runtime_error: - message: "Integer overflow: 128 exceeds range for i8." + tokens: + - type: error + value: "Integer overflow: 128 exceeds range for i8." - name: Integer i8 Underflow code: "-129:i8" - runtime_error: - message: "Integer underflow: -129 exceeds range for i8." + tokens: + - type: error + value: "Integer underflow: -129 exceeds range for i8." - name: Integer Default Invalid Characters code: "12a3" @@ -238,6 +240,830 @@ - 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" + tokens: + - type: i64 + value: 9223372036854775807 + operations: + - function: push + type: i64 + value: 9223372036854775807 + stack_final: + - type: i64 + value: 9223372036854775807 + +- name: Integer Default Binary All Ones + code: "0b1111111111111111" + tokens: + - type: i64 + value: 65535 + operations: + - function: push + type: i64 + value: 65535 + stack_final: + - type: i64 + value: 65535 + +- name: Integer Default Octal Max Three Digits + code: "0o777" + tokens: + - type: i64 + value: 511 + operations: + - function: push + type: i64 + value: 511 + 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" + 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 + +# 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" + 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 + +# Zero in different bases +- name: Integer Default Hex Zero + code: "0x0" + tokens: + - type: i64 + value: 0 + operations: + - function: push + type: i64 + value: 0 + stack_final: + - type: i64 + value: 0 + +- name: Integer Default Binary Zero + code: "0b0" + tokens: + - type: i64 + value: 0 + operations: + - function: push + type: i64 + value: 0 + stack_final: + - type: i64 + value: 0 + +- name: Integer Default Octal Zero + code: "0o0" + tokens: + - type: i64 + value: 0 + operations: + - function: push + type: i64 + value: 0 + stack_final: + - type: i64 + value: 0 + # Basic Floats # Basic Strings # Basic Booleans