// Kyler Olsen
// YREA SLS
// Lexer Tests
// October 2025

#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <math.h>

#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 = 294;

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);
}

static TestResult test_Float_Default_Simple() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Simple"), SLS_STR("3.14"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){3.14})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Zero() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Zero"), SLS_STR("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_double_value(&test, result, i++, &(double){0.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Negative() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Negative"), SLS_STR("-2.5"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){-2.5})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_One() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_One"), SLS_STR("1.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_double_value(&test, result, i++, &(double){1.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Simple() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Simple"), SLS_STR("3.14:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){3.14})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_Simple() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Simple"), SLS_STR("2.718:f64"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){2.718})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Leading_Zeros() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Leading_Zeros"), SLS_STR("00042.5"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){42.5})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Leading_Zero_Decimal() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Leading_Zero_Decimal"), SLS_STR("0.5"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){0.5})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Trailing_Zeros() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Trailing_Zeros"), SLS_STR("3.1400"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){3.14})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_No_Leading_Digit() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_No_Leading_Digit"), SLS_STR(".5"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){0.5})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_No_Leading_Digit_Negative() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_No_Leading_Digit_Negative"), SLS_STR("-.25"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){-0.25})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_No_Trailing_Digits() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_No_Trailing_Digits"), 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_double_value(&test, result, i++, &(double){42.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_No_Trailing_Digits_Negative() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_No_Trailing_Digits_Negative"), SLS_STR("-7."));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){-7.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Scientific_Positive_Exp() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Scientific_Positive_Exp"), SLS_STR("1.5e10"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){15000000000.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Scientific_Negative_Exp() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Scientific_Negative_Exp"), SLS_STR("2.5e-5"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){2.5e-05})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Scientific_Capital_E() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Scientific_Capital_E"), SLS_STR("3.14E8"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){314000000.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Scientific_Plus_Sign() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Scientific_Plus_Sign"), SLS_STR("1.0e+3"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1000.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Very_Small() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Very_Small"), SLS_STR("0.000001"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1e-06})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Scientific_Very_Small() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Scientific_Very_Small"), SLS_STR("1.0e-20"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1e-20})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Very_Large() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Very_Large"), SLS_STR("1000000.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_double_value(&test, result, i++, &(double){1000000.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Scientific_Very_Large() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Scientific_Very_Large"), SLS_STR("1.0e20"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1e+20})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Underscore_Integer_Part() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Integer_Part"), SLS_STR("1_000_000.5"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1000000.5})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Underscore_Decimal_Part() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Decimal_Part"), SLS_STR("3.141_592_653"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){3.141592653})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Underscore_Both_Parts() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Both_Parts"), SLS_STR("1_234.567_89"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1234.56789})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Underscore_Scientific_Mantissa() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Scientific_Mantissa"), SLS_STR("1_000.5e10"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){10005000000000.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Underscore_Scientific_Exponent() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Scientific_Exponent"), SLS_STR("1.5e1_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_double_value(&test, result, i++, &(double){15000000000.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Underscore_Trailing() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Trailing"), SLS_STR("42.5_"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){42.5})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Underscore_Double() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Double"), SLS_STR("4__2.5"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){42.5})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_With_Underscores() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_With_Underscores"), SLS_STR("1_234.567_89:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){1234.56789})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Max_Value() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Max_Value"), SLS_STR("3.4028235e+38:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){3.4028235e+38})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Min_Value() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Min_Value"), SLS_STR("-3.4028235e+38:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){-3.4028235e+38})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Min_Positive() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Min_Positive"), SLS_STR("1.1754944e-38:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){1.1754944e-38})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Epsilon() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Epsilon"), SLS_STR("1.1920929e-07:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){1.1920929e-07})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Near_Zero_Positive() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Near_Zero_Positive"), SLS_STR("1e-30:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){1e-30})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Near_Zero_Negative() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Near_Zero_Negative"), SLS_STR("-1e-30:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){-1e-30})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Subnormal() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Subnormal"), SLS_STR("1e-40:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){1e-40})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_Max_Value() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Max_Value"), SLS_STR("1.7976931348623157e+308:f64"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1.7976931348623157e+308})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_Min_Value() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Min_Value"), SLS_STR("-1.7976931348623157e+308:f64"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){-1.7976931348623157e+308})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_Min_Positive() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Min_Positive"), SLS_STR("2.2250738585072014e-308:f64"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){2.2250738585072014e-308})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_Epsilon() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Epsilon"), SLS_STR("2.220446049250313e-16:f64"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){2.220446049250313e-16})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_Near_Zero_Positive() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Near_Zero_Positive"), SLS_STR("1e-30:f64"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1e-30})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_Near_Zero_Negative() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Near_Zero_Negative"), SLS_STR("-1e-30:f64"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){-1e-30})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_Subnormal() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Subnormal"), SLS_STR("1e-320:f64"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1e-320})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Overflow_Positive() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Overflow_Positive"), SLS_STR("1e40:f32"));
    LexerResult result = 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("Float overflow: value exceeds range for f32."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Overflow_Negative() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Overflow_Negative"), SLS_STR("-1e40:f32"));
    LexerResult result = 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("Float overflow: value exceeds range for f32."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_Overflow_Positive() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Overflow_Positive"), SLS_STR("1e310:f64"));
    LexerResult result = 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("Float overflow: value exceeds range for f64."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_Overflow_Negative() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Overflow_Negative"), SLS_STR("-1e310:f64"));
    LexerResult result = 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("Float overflow: value exceeds range for f64."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Precision_Limit() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Precision_Limit"), SLS_STR("1.2345678:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){1.2345678})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_High_Precision() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_High_Precision"), SLS_STR("3.141592653589793:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){3.141592653589793})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_Precision_Limit() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Precision_Limit"), SLS_STR("1.234567890123456:f64"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1.234567890123456})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_High_Precision() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_High_Precision"), SLS_STR("3.141592653589793238:f64"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){3.141592653589793})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_Close_Numbers_1() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Close_Numbers_1"), SLS_STR("1.0000000000000001:f64"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f64_Close_Numbers_2() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Close_Numbers_2"), SLS_STR("1.0000000000000002:f64"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1.0000000000000002})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_No_Decimal_Point() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_No_Decimal_Point"), 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_for_error(&test, result, i++, SLS_STR("Not a valid float literal: missing decimal point."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Multiple_Decimal_Points() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Multiple_Decimal_Points"), SLS_STR("3.14.159"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: multiple decimal points."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Only_Decimal_Point() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Only_Decimal_Point"), 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_for_error(&test, result, i++, SLS_STR("Invalid float literal: no digits before or after decimal point."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Characters() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Characters"), SLS_STR("3.1a4"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: unexpected 'a' in float."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Scientific_No_Exponent() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Scientific_No_Exponent"), SLS_STR("3.14e"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: missing exponent value."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Scientific_Double_E() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Scientific_Double_E"), SLS_STR("3.14e10e5"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: multiple exponent markers."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Scientific_Invalid_Exponent() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Scientific_Invalid_Exponent"), SLS_STR("3.14eX"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: invalid exponent 'X'."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Leading_Underscore() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Leading_Underscore"), SLS_STR("_3.14"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: leading underscore."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Underscore_Before_Decimal() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Underscore_Before_Decimal"), SLS_STR("3_.14"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: underscore before decimal point."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Underscore_After_Decimal() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Underscore_After_Decimal"), SLS_STR("3._14"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: underscore after decimal point."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Type_Annotation() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Type_Annotation"), SLS_STR("3.14: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("Type mismatch: float literal cannot be annotated as integer type."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Type_Name() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Type_Name"), SLS_STR("3.14:f16"));
    LexerResult result = 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 type annotation: unknown type 'f16'."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Comma_Separator() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Comma_Separator"), SLS_STR("1,234.56"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: unexpected ',' in float."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Leading_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Leading_Whitespace"), SLS_STR("  3.14"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){3.14})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Trailing_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Trailing_Whitespace"), SLS_STR("3.14  "));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){3.14})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Both_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Both_Whitespace"), SLS_STR("  3.14  "));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){3.14})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_With_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_With_Whitespace"), SLS_STR("  2.718:f32  "));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){2.718})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Pi_Approximate() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Pi_Approximate"), SLS_STR("3.141592653589793"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){3.141592653589793})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Pi_Approximate() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Pi_Approximate"), SLS_STR("3.1415927:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){3.1415927})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Euler_Approximate() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Euler_Approximate"), SLS_STR("2.718281828459045"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){2.718281828459045})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Euler_Approximate() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Euler_Approximate"), SLS_STR("2.7182817:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){2.7182817})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Golden_Ratio() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Golden_Ratio"), SLS_STR("1.618033988749895"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1.618033988749895})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Sqrt2() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Sqrt2"), SLS_STR("1.4142135623730951"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_double_value(&test, result, i++, &(double){1.4142135623730951})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Positive_Zero() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Positive_Zero"), SLS_STR("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_double_value(&test, result, i++, &(double){0.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Default_Negative_Zero() {
    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Negative_Zero"), SLS_STR("-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_double_value(&test, result, i++, &(double){-0.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Positive_Zero() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Positive_Zero"), SLS_STR("0.0:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){0.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_f32_Negative_Zero() {
    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Negative_Zero"), SLS_STR("-0.0:f32"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_float_value(&test, result, i++, &(float){-0.0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Simple_Letter_A() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Simple_Letter_A"), SLS_STR("'A'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Simple_Letter_a() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Simple_Letter_a"), SLS_STR("'a'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){97})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Simple_Letter_Z() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Simple_Letter_Z"), SLS_STR("'Z'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){90})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Simple_Letter_z() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Simple_Letter_z"), SLS_STR("'z'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){122})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Digit_0() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Digit_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_character_value(&test, result, i++, &(uint8_t){48})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Digit_5() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Digit_5"), SLS_STR("'5'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){53})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Digit_9() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Digit_9"), SLS_STR("'9'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){57})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Space() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Space"), SLS_STR("' '"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){32})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Exclamation() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Exclamation"), SLS_STR("'!'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){33})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Question_Mark() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Question_Mark"), SLS_STR("'?'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){63})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Period() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Period"), SLS_STR("'.'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){46})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Comma() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Comma"), SLS_STR("','"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){44})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Semicolon() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Semicolon"), SLS_STR("';'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){59})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Colon() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Colon"), SLS_STR("':'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){58})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Plus() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Plus"), SLS_STR("'+'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){43})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Minus() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Minus"), SLS_STR("'-'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){45})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Asterisk() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Asterisk"), SLS_STR("'*'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){42})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Slash() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Slash"), SLS_STR("'/'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){47})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Equals() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Equals"), SLS_STR("'='"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){61})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Less_Than() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Less_Than"), SLS_STR("'<'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){60})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Greater_Than() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Greater_Than"), SLS_STR("'>'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){62})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Left_Paren() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Left_Paren"), SLS_STR("'('"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){40})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Right_Paren() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Right_Paren"), SLS_STR("')'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){41})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Left_Bracket() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Left_Bracket"), SLS_STR("'['"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){91})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Right_Bracket() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Right_Bracket"), SLS_STR("']'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){93})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Left_Brace() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Left_Brace"), SLS_STR("'{'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){123})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Right_Brace() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Right_Brace"), SLS_STR("'}'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){125})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Escape_Newline() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Newline"), SLS_STR("'\n'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){10})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Escape_Null_character() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Null_character"), SLS_STR("'\0'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Escape_Double_quote() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Double_quote"), SLS_STR("'\\\"'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){34})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Escape_Single_quote() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Single_quote"), SLS_STR("'\''"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){39})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Escape_Tab() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Tab"), SLS_STR("'\t'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){9})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Escape_Backslash() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Backslash"), SLS_STR("'\\'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){92})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Escape_Carriage_return() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Carriage_return"), SLS_STR("'\r'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){13})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Newline() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Newline"), SLS_STR("'\n'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){10})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Carriage_Return() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Carriage_Return"), SLS_STR("'\r'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){13})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Tab() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Tab"), SLS_STR("'\t'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){9})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Backslash() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Backslash"), SLS_STR("'\\'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){92})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Double_Quote() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Double_Quote"), SLS_STR("'\\\"'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){34})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Single_Quote() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Single_Quote"), SLS_STR("'\''"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){39})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Null() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Null"), SLS_STR("'\0'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Escape_x41() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_x41"), SLS_STR("'\x41'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Escape_x61() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_x61"), SLS_STR("'\x61'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){97})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Escape_x20() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_x20"), SLS_STR("'\x20'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){32})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Escape_x00() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_x00"), SLS_STR("'\x00'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){0})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Escape_xFF() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_xFF"), SLS_STR("'\xFF'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){255})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Lowercase_A() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Lowercase_A"), SLS_STR("'\x61'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){97})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Uppercase_A() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Uppercase_A"), SLS_STR("'\x41'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Space() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Space"), SLS_STR("'\x20'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){32})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Tab() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Tab"), SLS_STR("'\x09'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){9})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Newline() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Newline"), SLS_STR("'\x0A'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){10})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Max_ASCII() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Max_ASCII"), SLS_STR("'\x7F'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){127})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_With_Leading_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("test_Char_With_Leading_Whitespace"), SLS_STR("  'A'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_With_Trailing_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("test_Char_With_Trailing_Whitespace"), SLS_STR("'A'  "));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_With_Both_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("test_Char_With_Both_Whitespace"), SLS_STR("  'A'  "));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Tab_Before() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Tab_Before"), SLS_STR("\t'B'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){66})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Newline_Before() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Newline_Before"), SLS_STR("\n'C'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){67})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Empty_Literal() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Empty_Literal"), 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_for_error(&test, result, i++, SLS_STR("Invalid character literal: empty character literal."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Multiple_Characters() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Multiple_Characters"), SLS_STR("'AB'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: multiple characters without escape sequence."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Unclosed_Quote() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Unclosed_Quote"), SLS_STR("'A"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: unclosed character literal."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Unescaped_Newline() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Unescaped_Newline"), SLS_STR("'\n'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: unescaped newline in character literal."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Invalid_Escape() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Invalid_Escape"), SLS_STR("'\q'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: unknown escape sequence '\q'."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Escape_Too_Short() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_Too_Short"), SLS_STR("'\x4'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: hexadecimal escape must have exactly 2 digits."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Escape_Too_Long() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_Too_Long"), SLS_STR("'\x414'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: hexadecimal escape must have exactly 2 digits."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Invalid_Digit() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Invalid_Digit"), SLS_STR("'\\xGG'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: invalid hexadecimal digit 'G'."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Double_Quotes() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Double_Quotes"), SLS_STR("\"A\""));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: character literals must use single quotes."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_No_Quotes() {
    LexerTest test = start_up_test(SLS_STR("test_Char_No_Quotes"), SLS_STR("A"));
    LexerResult result = 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("Not a character literal: missing quotes."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_ASCII_Control_SOH() {
    LexerTest test = start_up_test(SLS_STR("test_Char_ASCII_Control_SOH"), SLS_STR("'\x01'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){1})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_ASCII_Control_BEL() {
    LexerTest test = start_up_test(SLS_STR("test_Char_ASCII_Control_BEL"), SLS_STR("'\x07'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){7})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_ASCII_Control_ESC() {
    LexerTest test = start_up_test(SLS_STR("test_Char_ASCII_Control_ESC"), SLS_STR("'\x1B'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){27})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_ASCII_Control_DEL() {
    LexerTest test = start_up_test(SLS_STR("test_Char_ASCII_Control_DEL"), SLS_STR("'\x7F'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){127})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Extended_ASCII_Lower() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Extended_ASCII_Lower"), SLS_STR("'\x80'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){128})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Extended_ASCII_Upper() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Extended_ASCII_Upper"), SLS_STR("'\xFF'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){255})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Backslash_Literal() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Backslash_Literal"), SLS_STR("'\\'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){92})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Single_Quote_Escaped() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Single_Quote_Escaped"), SLS_STR("'\''"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){39})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Lowercase_x() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Lowercase_x"), SLS_STR("'\x41'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Digits_Uppercase() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Digits_Uppercase"), SLS_STR("'\xFF'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){255})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Digits_Lowercase() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Digits_Lowercase"), SLS_STR("'\xff'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){255})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Hex_Digits_Mixed() {
    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Digits_Mixed"), SLS_STR("'\xAb'"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_character_value(&test, result, i++, &(uint8_t){171})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

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();
    test_report.tests[i++] = test_Float_Default_Simple();
    test_report.tests[i++] = test_Float_Default_Zero();
    test_report.tests[i++] = test_Float_Default_Negative();
    test_report.tests[i++] = test_Float_Default_One();
    test_report.tests[i++] = test_Float_f32_Simple();
    test_report.tests[i++] = test_Float_f64_Simple();
    test_report.tests[i++] = test_Float_Default_Leading_Zeros();
    test_report.tests[i++] = test_Float_Default_Leading_Zero_Decimal();
    test_report.tests[i++] = test_Float_Default_Trailing_Zeros();
    test_report.tests[i++] = test_Float_Default_No_Leading_Digit();
    test_report.tests[i++] = test_Float_Default_No_Leading_Digit_Negative();
    test_report.tests[i++] = test_Float_Default_No_Trailing_Digits();
    test_report.tests[i++] = test_Float_Default_No_Trailing_Digits_Negative();
    test_report.tests[i++] = test_Float_Default_Scientific_Positive_Exp();
    test_report.tests[i++] = test_Float_Default_Scientific_Negative_Exp();
    test_report.tests[i++] = test_Float_Default_Scientific_Capital_E();
    test_report.tests[i++] = test_Float_Default_Scientific_Plus_Sign();
    test_report.tests[i++] = test_Float_Default_Very_Small();
    test_report.tests[i++] = test_Float_Default_Scientific_Very_Small();
    test_report.tests[i++] = test_Float_Default_Very_Large();
    test_report.tests[i++] = test_Float_Default_Scientific_Very_Large();
    test_report.tests[i++] = test_Float_Default_Underscore_Integer_Part();
    test_report.tests[i++] = test_Float_Default_Underscore_Decimal_Part();
    test_report.tests[i++] = test_Float_Default_Underscore_Both_Parts();
    test_report.tests[i++] = test_Float_Default_Underscore_Scientific_Mantissa();
    test_report.tests[i++] = test_Float_Default_Underscore_Scientific_Exponent();
    test_report.tests[i++] = test_Float_Default_Underscore_Trailing();
    test_report.tests[i++] = test_Float_Default_Underscore_Double();
    test_report.tests[i++] = test_Float_f32_With_Underscores();
    test_report.tests[i++] = test_Float_f32_Max_Value();
    test_report.tests[i++] = test_Float_f32_Min_Value();
    test_report.tests[i++] = test_Float_f32_Min_Positive();
    test_report.tests[i++] = test_Float_f32_Epsilon();
    test_report.tests[i++] = test_Float_f32_Near_Zero_Positive();
    test_report.tests[i++] = test_Float_f32_Near_Zero_Negative();
    test_report.tests[i++] = test_Float_f32_Subnormal();
    test_report.tests[i++] = test_Float_f64_Max_Value();
    test_report.tests[i++] = test_Float_f64_Min_Value();
    test_report.tests[i++] = test_Float_f64_Min_Positive();
    test_report.tests[i++] = test_Float_f64_Epsilon();
    test_report.tests[i++] = test_Float_f64_Near_Zero_Positive();
    test_report.tests[i++] = test_Float_f64_Near_Zero_Negative();
    test_report.tests[i++] = test_Float_f64_Subnormal();
    test_report.tests[i++] = test_Float_f32_Overflow_Positive();
    test_report.tests[i++] = test_Float_f32_Overflow_Negative();
    test_report.tests[i++] = test_Float_f64_Overflow_Positive();
    test_report.tests[i++] = test_Float_f64_Overflow_Negative();
    test_report.tests[i++] = test_Float_f32_Precision_Limit();
    test_report.tests[i++] = test_Float_f32_High_Precision();
    test_report.tests[i++] = test_Float_f64_Precision_Limit();
    test_report.tests[i++] = test_Float_f64_High_Precision();
    test_report.tests[i++] = test_Float_f64_Close_Numbers_1();
    test_report.tests[i++] = test_Float_f64_Close_Numbers_2();
    test_report.tests[i++] = test_Float_Invalid_No_Decimal_Point();
    test_report.tests[i++] = test_Float_Invalid_Multiple_Decimal_Points();
    test_report.tests[i++] = test_Float_Invalid_Only_Decimal_Point();
    test_report.tests[i++] = test_Float_Invalid_Characters();
    test_report.tests[i++] = test_Float_Invalid_Scientific_No_Exponent();
    test_report.tests[i++] = test_Float_Invalid_Scientific_Double_E();
    test_report.tests[i++] = test_Float_Invalid_Scientific_Invalid_Exponent();
    test_report.tests[i++] = test_Float_Invalid_Leading_Underscore();
    test_report.tests[i++] = test_Float_Invalid_Underscore_Before_Decimal();
    test_report.tests[i++] = test_Float_Invalid_Underscore_After_Decimal();
    test_report.tests[i++] = test_Float_Invalid_Type_Annotation();
    test_report.tests[i++] = test_Float_Invalid_Type_Name();
    test_report.tests[i++] = test_Float_Invalid_Comma_Separator();
    test_report.tests[i++] = test_Float_Default_Leading_Whitespace();
    test_report.tests[i++] = test_Float_Default_Trailing_Whitespace();
    test_report.tests[i++] = test_Float_Default_Both_Whitespace();
    test_report.tests[i++] = test_Float_f32_With_Whitespace();
    test_report.tests[i++] = test_Float_Default_Pi_Approximate();
    test_report.tests[i++] = test_Float_f32_Pi_Approximate();
    test_report.tests[i++] = test_Float_Default_Euler_Approximate();
    test_report.tests[i++] = test_Float_f32_Euler_Approximate();
    test_report.tests[i++] = test_Float_Default_Golden_Ratio();
    test_report.tests[i++] = test_Float_Default_Sqrt2();
    test_report.tests[i++] = test_Float_Default_Positive_Zero();
    test_report.tests[i++] = test_Float_Default_Negative_Zero();
    test_report.tests[i++] = test_Float_f32_Positive_Zero();
    test_report.tests[i++] = test_Float_f32_Negative_Zero();
    test_report.tests[i++] = test_Char_Simple_Letter_A();
    test_report.tests[i++] = test_Char_Simple_Letter_a();
    test_report.tests[i++] = test_Char_Simple_Letter_Z();
    test_report.tests[i++] = test_Char_Simple_Letter_z();
    test_report.tests[i++] = test_Char_Digit_0();
    test_report.tests[i++] = test_Char_Digit_5();
    test_report.tests[i++] = test_Char_Digit_9();
    test_report.tests[i++] = test_Char_Space();
    test_report.tests[i++] = test_Char_Exclamation();
    test_report.tests[i++] = test_Char_Question_Mark();
    test_report.tests[i++] = test_Char_Period();
    test_report.tests[i++] = test_Char_Comma();
    test_report.tests[i++] = test_Char_Semicolon();
    test_report.tests[i++] = test_Char_Colon();
    test_report.tests[i++] = test_Char_Plus();
    test_report.tests[i++] = test_Char_Minus();
    test_report.tests[i++] = test_Char_Asterisk();
    test_report.tests[i++] = test_Char_Slash();
    test_report.tests[i++] = test_Char_Equals();
    test_report.tests[i++] = test_Char_Less_Than();
    test_report.tests[i++] = test_Char_Greater_Than();
    test_report.tests[i++] = test_Char_Left_Paren();
    test_report.tests[i++] = test_Char_Right_Paren();
    test_report.tests[i++] = test_Char_Left_Bracket();
    test_report.tests[i++] = test_Char_Right_Bracket();
    test_report.tests[i++] = test_Char_Left_Brace();
    test_report.tests[i++] = test_Char_Right_Brace();
    test_report.tests[i++] = test_Char_Escape_Newline();
    test_report.tests[i++] = test_Char_Escape_Null_character();
    test_report.tests[i++] = test_Char_Escape_Double_quote();
    test_report.tests[i++] = test_Char_Escape_Single_quote();
    test_report.tests[i++] = test_Char_Escape_Tab();
    test_report.tests[i++] = test_Char_Escape_Backslash();
    test_report.tests[i++] = test_Char_Escape_Carriage_return();
    test_report.tests[i++] = test_Char_Newline();
    test_report.tests[i++] = test_Char_Carriage_Return();
    test_report.tests[i++] = test_Char_Tab();
    test_report.tests[i++] = test_Char_Backslash();
    test_report.tests[i++] = test_Char_Double_Quote();
    test_report.tests[i++] = test_Char_Single_Quote();
    test_report.tests[i++] = test_Char_Null();
    test_report.tests[i++] = test_Char_Hex_Escape_x41();
    test_report.tests[i++] = test_Char_Hex_Escape_x61();
    test_report.tests[i++] = test_Char_Hex_Escape_x20();
    test_report.tests[i++] = test_Char_Hex_Escape_x00();
    test_report.tests[i++] = test_Char_Hex_Escape_xFF();
    test_report.tests[i++] = test_Char_Hex_Lowercase_A();
    test_report.tests[i++] = test_Char_Hex_Uppercase_A();
    test_report.tests[i++] = test_Char_Hex_Space();
    test_report.tests[i++] = test_Char_Hex_Tab();
    test_report.tests[i++] = test_Char_Hex_Newline();
    test_report.tests[i++] = test_Char_Hex_Max_ASCII();
    test_report.tests[i++] = test_Char_With_Leading_Whitespace();
    test_report.tests[i++] = test_Char_With_Trailing_Whitespace();
    test_report.tests[i++] = test_Char_With_Both_Whitespace();
    test_report.tests[i++] = test_Char_Tab_Before();
    test_report.tests[i++] = test_Char_Newline_Before();
    test_report.tests[i++] = test_Char_Empty_Literal();
    test_report.tests[i++] = test_Char_Multiple_Characters();
    test_report.tests[i++] = test_Char_Unclosed_Quote();
    test_report.tests[i++] = test_Char_Unescaped_Newline();
    test_report.tests[i++] = test_Char_Invalid_Escape();
    test_report.tests[i++] = test_Char_Hex_Escape_Too_Short();
    test_report.tests[i++] = test_Char_Hex_Escape_Too_Long();
    test_report.tests[i++] = test_Char_Hex_Invalid_Digit();
    test_report.tests[i++] = test_Char_Double_Quotes();
    test_report.tests[i++] = test_Char_No_Quotes();
    test_report.tests[i++] = test_Char_ASCII_Control_SOH();
    test_report.tests[i++] = test_Char_ASCII_Control_BEL();
    test_report.tests[i++] = test_Char_ASCII_Control_ESC();
    test_report.tests[i++] = test_Char_ASCII_Control_DEL();
    test_report.tests[i++] = test_Char_Extended_ASCII_Lower();
    test_report.tests[i++] = test_Char_Extended_ASCII_Upper();
    test_report.tests[i++] = test_Char_Backslash_Literal();
    test_report.tests[i++] = test_Char_Single_Quote_Escaped();
    test_report.tests[i++] = test_Char_Hex_Lowercase_x();
    test_report.tests[i++] = test_Char_Hex_Digits_Uppercase();
    test_report.tests[i++] = test_Char_Hex_Digits_Lowercase();
    test_report.tests[i++] = test_Char_Hex_Digits_Mixed();

    return test_report;
}