// Kyler Olsen // YREA SLS // Lexer Tests // October 2025 #include #include #include #include #include #include "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(SLS_STR("test_Empty_Statement"), SLS_STR("")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_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(SLS_STR("test_Integer_Default_Decimal_0"), SLS_STR("0")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_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(SLS_STR("test_Integer_Default_Decimal_1"), SLS_STR("-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(SLS_STR("test_Integer_Default_Decimal_42"), SLS_STR("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(SLS_STR("test_Integer_Default_Decimal_Leading_Zeros"), SLS_STR("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(SLS_STR("test_Integer_Default_Hex_0xFF"), SLS_STR("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(SLS_STR("test_Integer_Default_Hex_0xdeadbeef"), SLS_STR("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(SLS_STR("test_Integer_Default_Hex_Max"), SLS_STR("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(SLS_STR("test_Integer_Default_Binary_0b1010"), SLS_STR("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(SLS_STR("test_Integer_Default_Binary_All_Ones"), SLS_STR("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(SLS_STR("test_Integer_Default_Octal_0o755"), SLS_STR("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(SLS_STR("test_Integer_Default_Octal_Max_Three_Digits"), SLS_STR("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(SLS_STR("test_Integer_Default_Decimal_Max_i64"), SLS_STR("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(SLS_STR("test_Integer_Default_Decimal_Min_i64"), SLS_STR("-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(SLS_STR("test_Integer_Default_Decimal_with_Underscore"), SLS_STR("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(SLS_STR("test_Integer_Default_Underscore_End"), SLS_STR("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(SLS_STR("test_Integer_Default_Underscore_Double"), SLS_STR("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(SLS_STR("test_Integer_Default_Whitespace"), SLS_STR(" 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(SLS_STR("test_Integer_Default_Hex_Zero"), SLS_STR("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(SLS_STR("test_Integer_Default_Binary_Zero"), SLS_STR("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(SLS_STR("test_Integer_Default_Octal_Zero"), SLS_STR("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(SLS_STR("test_Integer_Default_Decimal_with_Commas_Invalid"), SLS_STR("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++, SLS_STR("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(SLS_STR("test_Integer_Default_Invalid_Characters"), SLS_STR("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++, SLS_STR("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(SLS_STR("test_Integer_Default_Invalid_Prefix"), SLS_STR("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++, SLS_STR("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(SLS_STR("test_Integer_i8_Decimal_Positive"), SLS_STR("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(SLS_STR("test_Integer_i8_Zero"), SLS_STR("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(SLS_STR("test_Integer_i8_Decimal_Negative"), SLS_STR("-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(SLS_STR("test_Integer_i8_Hex"), SLS_STR("0x7F:i8")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i8_Binary() { LexerTest test = start_up_test(SLS_STR("test_Integer_i8_Binary"), SLS_STR("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(SLS_STR("test_Integer_i8_Octal"), SLS_STR("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(SLS_STR("test_Integer_i8_Max_Value"), SLS_STR("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(SLS_STR("test_Integer_i8_Min_Value"), SLS_STR("-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(SLS_STR("test_Integer_i8_Overflow"), SLS_STR("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++, SLS_STR("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(SLS_STR("test_Integer_i8_Underflow"), SLS_STR("-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++, SLS_STR("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(SLS_STR("test_Integer_i8_Hex_Max"), SLS_STR("0x7F:i8")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i8_Binary_Max() { LexerTest test = start_up_test(SLS_STR("test_Integer_i8_Binary_Max"), SLS_STR("0b01111111:i8")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i8_Octal_Max() { LexerTest test = start_up_test(SLS_STR("test_Integer_i8_Octal_Max"), SLS_STR("0o177:i8")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i8_Negative_Hex() { LexerTest test = start_up_test(SLS_STR("test_Integer_i8_Negative_Hex"), SLS_STR("-0x80:i8")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, -128})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i16_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("test_Integer_i16_Decimal_Positive"), SLS_STR("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(SLS_STR("test_Integer_i16_Zero"), SLS_STR("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(SLS_STR("test_Integer_i16_Decimal_Negative"), SLS_STR("-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(SLS_STR("test_Integer_i16_Hex"), SLS_STR("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(SLS_STR("test_Integer_i16_Binary"), SLS_STR("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(SLS_STR("test_Integer_i16_Octal"), SLS_STR("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(SLS_STR("test_Integer_i16_Max_Value"), SLS_STR("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(SLS_STR("test_Integer_i16_Min_Value"), SLS_STR("-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(SLS_STR("test_Integer_i16_Overflow"), SLS_STR("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++, SLS_STR("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(SLS_STR("test_Integer_i16_Underflow"), SLS_STR("-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++, SLS_STR("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(SLS_STR("test_Integer_i16_Hex_Sample"), SLS_STR("0x1234:i16")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 4660})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i16_Binary_Sample() { LexerTest test = start_up_test(SLS_STR("test_Integer_i16_Binary_Sample"), SLS_STR("0b1111111100000000:i16")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 65280})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i16_Octal_Sample() { LexerTest test = start_up_test(SLS_STR("test_Integer_i16_Octal_Sample"), SLS_STR("0o1234:i16")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 668})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i32_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("test_Integer_i32_Decimal_Positive"), SLS_STR("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(SLS_STR("test_Integer_i32_Zero"), SLS_STR("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(SLS_STR("test_Integer_i32_Decimal_Negative"), SLS_STR("-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(SLS_STR("test_Integer_i32_Hex"), SLS_STR("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(SLS_STR("test_Integer_i32_Binary"), SLS_STR("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(SLS_STR("test_Integer_i32_Octal"), SLS_STR("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(SLS_STR("test_Integer_i32_Max_Value"), SLS_STR("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(SLS_STR("test_Integer_i32_Min_Value"), SLS_STR("-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(SLS_STR("test_Integer_i32_Overflow"), SLS_STR("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++, SLS_STR("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(SLS_STR("test_Integer_i32_Underflow"), SLS_STR("-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++, SLS_STR("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(SLS_STR("test_Integer_i32_With_Underscores"), SLS_STR("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(SLS_STR("test_Integer_i32_Hex_Sample"), SLS_STR("0xABCD:i32")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 43981})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i32_Binary_Sample() { LexerTest test = start_up_test(SLS_STR("test_Integer_i32_Binary_Sample"), SLS_STR("0b11110000:i32")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 240})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i64_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("test_Integer_i64_Decimal_Positive"), SLS_STR("42:i64")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 42})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i64_Zero() { LexerTest test = start_up_test(SLS_STR("test_Integer_i64_Zero"), SLS_STR("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(SLS_STR("test_Integer_i64_Decimal_Negative"), SLS_STR("-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(SLS_STR("test_Integer_i64_Hex"), SLS_STR("0xFF:i64")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 255})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i64_Binary() { LexerTest test = start_up_test(SLS_STR("test_Integer_i64_Binary"), SLS_STR("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(SLS_STR("test_Integer_i64_Octal"), SLS_STR("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(SLS_STR("test_Integer_i64_Max_Value"), SLS_STR("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(SLS_STR("test_Integer_i64_Min_Value"), SLS_STR("-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(SLS_STR("test_Integer_i64_Overflow"), SLS_STR("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++, SLS_STR("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(SLS_STR("test_Integer_i64_Underflow"), SLS_STR("-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++, SLS_STR("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(SLS_STR("test_Integer_i64_With_Underscores"), SLS_STR("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(SLS_STR("test_Integer_i64_Decimal_Positive_42"), SLS_STR("42:i64")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 42})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i64_Hex_0xFF() { LexerTest test = start_up_test(SLS_STR("test_Integer_i64_Hex_0xFF"), SLS_STR("0xFF:i64")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 255})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i64_Binary_0b1010() { LexerTest test = start_up_test(SLS_STR("test_Integer_i64_Binary_0b1010"), SLS_STR("0b1010:i64")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 10})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_i64_Octal_0o755() { LexerTest test = start_up_test(SLS_STR("test_Integer_i64_Octal_0o755"), SLS_STR("0o755:i64")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 493})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_u8_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("test_Integer_u8_Decimal_Positive"), SLS_STR("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(SLS_STR("test_Integer_u8_Zero"), SLS_STR("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(SLS_STR("test_Integer_u8_Hex"), SLS_STR("0xFF:u8")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_u8_Binary() { LexerTest test = start_up_test(SLS_STR("test_Integer_u8_Binary"), SLS_STR("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(SLS_STR("test_Integer_u8_Octal"), SLS_STR("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(SLS_STR("test_Integer_u8_Max_Value"), SLS_STR("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(SLS_STR("test_Integer_u8_Min_Value"), SLS_STR("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(SLS_STR("test_Integer_u8_Overflow"), SLS_STR("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++, SLS_STR("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(SLS_STR("test_Integer_u8_Underflow"), SLS_STR("-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++, SLS_STR("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(SLS_STR("test_Integer_u8_Hex_Max"), SLS_STR("0xFF:u8")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_u8_Binary_Max() { LexerTest test = start_up_test(SLS_STR("test_Integer_u8_Binary_Max"), SLS_STR("0b11111111:u8")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_u8_Octal_Max() { LexerTest test = start_up_test(SLS_STR("test_Integer_u8_Octal_Max"), SLS_STR("0o377:u8")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_u16_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("test_Integer_u16_Decimal_Positive"), SLS_STR("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(SLS_STR("test_Integer_u16_Zero"), SLS_STR("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(SLS_STR("test_Integer_u16_Hex"), SLS_STR("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(SLS_STR("test_Integer_u16_Binary"), SLS_STR("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(SLS_STR("test_Integer_u16_Octal"), SLS_STR("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(SLS_STR("test_Integer_u16_Max_Value"), SLS_STR("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(SLS_STR("test_Integer_u16_Min_Value"), SLS_STR("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(SLS_STR("test_Integer_u16_Overflow"), SLS_STR("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++, SLS_STR("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(SLS_STR("test_Integer_u16_Underflow"), SLS_STR("-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++, SLS_STR("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(SLS_STR("test_Integer_u16_Hex_Max"), SLS_STR("0xFFFF:u16")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_u16_Binary_Max() { LexerTest test = start_up_test(SLS_STR("test_Integer_u16_Binary_Max"), SLS_STR("0b1111111111111111:u16")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_u16_Octal_Max() { LexerTest test = start_up_test(SLS_STR("test_Integer_u16_Octal_Max"), SLS_STR("0o177777:u16")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_u16_Decimal_Mid() { LexerTest test = start_up_test(SLS_STR("test_Integer_u16_Decimal_Mid"), SLS_STR("50000:u16")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 50000})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_u32_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("test_Integer_u32_Decimal_Positive"), SLS_STR("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(SLS_STR("test_Integer_u32_Zero"), SLS_STR("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(SLS_STR("test_Integer_u32_Hex"), SLS_STR("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(SLS_STR("test_Integer_u32_Binary"), SLS_STR("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(SLS_STR("test_Integer_u32_Octal"), SLS_STR("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(SLS_STR("test_Integer_u32_Max_Value"), SLS_STR("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(SLS_STR("test_Integer_u32_Min_Value"), SLS_STR("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(SLS_STR("test_Integer_u32_Overflow"), SLS_STR("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++, SLS_STR("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(SLS_STR("test_Integer_u32_Underflow"), SLS_STR("-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++, SLS_STR("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(SLS_STR("test_Integer_u32_With_Underscores"), SLS_STR("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(SLS_STR("test_Integer_u32_Hex_Max"), SLS_STR("0xFFFFFFFF:u32")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4294967295})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_u32_Binary_Sample() { LexerTest test = start_up_test(SLS_STR("test_Integer_u32_Binary_Sample"), SLS_STR("0b11111111000000001111111100000000:u32")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4278255360})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_u32_Octal_Max() { LexerTest test = start_up_test(SLS_STR("test_Integer_u32_Octal_Max"), SLS_STR("0o37777777777:u32")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4294967295})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_u32_Decimal_Mid() { LexerTest test = start_up_test(SLS_STR("test_Integer_u32_Decimal_Mid"), SLS_STR("1000000:u32")); LexerResult result = lexical_analysis(&test.lexer_info); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); size_t i = 0; if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 1000000})) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result; return pass_test(&test, result); } static TestResult test_Integer_u64_Decimal_Positive() { LexerTest test = start_up_test(SLS_STR("test_Integer_u64_Decimal_Positive"), SLS_STR("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(SLS_STR("test_Integer_u64_Zero"), SLS_STR("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(SLS_STR("test_Integer_u64_Hex"), SLS_STR("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(SLS_STR("test_Integer_u64_Binary"), SLS_STR("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(SLS_STR("test_Integer_u64_Octal"), SLS_STR("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(SLS_STR("test_Integer_u64_Max_Value"), SLS_STR("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(SLS_STR("test_Integer_u64_Min_Value"), SLS_STR("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(SLS_STR("test_Integer_u64_Overflow"), SLS_STR("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++, SLS_STR("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(SLS_STR("test_Integer_u64_Underflow"), SLS_STR("-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++, SLS_STR("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(SLS_STR("test_Integer_u64_With_Underscores"), SLS_STR("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(SLS_STR("test_Integer_u64_Hex_Max"), SLS_STR("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(SLS_STR("test_Integer_u64_Binary_Sample"), SLS_STR("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(SLS_STR("test_Integer_u64_Octal_Sample"), SLS_STR("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(SLS_STR("test_Integer_u64_Decimal"), SLS_STR("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(SLS_STR("test_Integer_Hex_With_Underscores"), SLS_STR("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(SLS_STR("test_Integer_Binary_With_Underscores"), SLS_STR("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(SLS_STR("test_Integer_Octal_With_Underscores"), SLS_STR("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 = SLS_STR("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; }