// Kyler Olsen // YREA SLS // Lexer Tests // October 2025 #include #include #include #include #include #include "sls/sls_errors.h" #include "sls/lexer.h" #include "sls/string.h" #include "tests/lexer_test_helpers.h" #include "tests/tests.h" static const size_t NUM_OF_TESTS = 135; static TestResult test_Empty_Statement() { LexerTest test = start_up_test("test_Empty_Statement", ""); LexerResult result = 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; return pass_test(&test, result); } static TestResult test_Integer_Default_Decimal_0() { LexerTest test = start_up_test("test_Integer_Default_Decimal_0", "0"); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_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_Decimal_1() { LexerTest test = start_up_test("test_Integer_Default_Decimal_1", "-1"); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, -1})) 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_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); 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_Hex_0xFF() { LexerTest test = start_up_test("test_Integer_Default_Hex_0xFF", "0xFF"); LexerResult result = 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_Default_Hex_0xdeadbeef() { LexerTest test = start_up_test("test_Integer_Default_Hex_0xdeadbeef", "0xdeadbeef"); LexerResult result = 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_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); 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_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); 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_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_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_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_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_eof_value(&test, result, i++, 0)) 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_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); } 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_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_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_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_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_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", "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_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){46, "Integer overflow: value 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 overflow: value 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", "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, 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", "-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, -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", "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, 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", "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, 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", "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, 63})) 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: value 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){47, "Integer overflow: value exceeds range for i16."})) return test.result; return pass_test(&test, result); } 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_I16, 4660})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i16_Binary_Sample() { LexerTest test = start_up_test("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_I16, 65280})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i16_Octal_Sample() { LexerTest test = start_up_test("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_I16, 668})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i32_Decimal_Positive() { LexerTest test = start_up_test("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_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_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_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", "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_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_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_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_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_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_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){47, "Integer overflow: value 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){47, "Integer overflow: value exceeds range for i32."})) return test.result; return pass_test(&test, result); } 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_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_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_I32, 43981})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i32_Binary_Sample() { LexerTest test = start_up_test("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_I32, 240})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i64_Decimal_Positive() { LexerTest test = start_up_test("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_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_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_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_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_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", "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_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_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_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_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_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){47, "Integer overflow: value 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){47, "Integer overflow: value 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); } 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", "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, 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", "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; 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_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; 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){46, "Integer overflow: value exceeds range for u8."})) return test.result; return pass_test(&test, result); } 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; if (test_for_error(&test, result, i++, &(TestErrorMessage){46, "Integer overflow: value exceeds range for u8."})) return test.result; 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: value 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){47, "Integer overflow: value 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){47, "Integer overflow: value 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){47, "Integer overflow: value 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){47, "Integer overflow: value 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){47, "Integer overflow: value 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); 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); } TestsReport run_lexer_tests() { TestsReport test_report = (TestsReport) { .section = "lexer_tests", .count = NUM_OF_TESTS, .tests = (TestResult *)malloc(sizeof(TestResult) * NUM_OF_TESTS), }; size_t i = 0; 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_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_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(); 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_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_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(); return test_report; }