YREA-SLS/SLS_C/tests/lexer_tests.c

// 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 = 356;

static TestResult test_Empty_Statement() {
    LexerTest test = start_up_test(SLS_STR("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("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("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("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("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("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("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("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("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("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("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("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("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("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, INT64_MIN})) 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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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, INT64_MIN})) 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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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, UINT64_MAX})) 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("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("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("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("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("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, UINT64_MAX})) 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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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_Very_Small() {
    LexerTest test = start_up_test(SLS_STR("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_Very_Large() {
    LexerTest test = start_up_test(SLS_STR("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_Underscore_Integer_Part() {
    LexerTest test = start_up_test(SLS_STR("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("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("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_Trailing() {
    LexerTest test = start_up_test(SLS_STR("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("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("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_Precision_Limit() {
    LexerTest test = start_up_test(SLS_STR("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("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("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("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("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("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_Multiple_Decimal_Points() {
    LexerTest test = start_up_test(SLS_STR("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: unexpected '.' in float."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Characters() {
    LexerTest test = start_up_test(SLS_STR("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_Type_Annotation() {
    LexerTest test = start_up_test(SLS_STR("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("Invalid float type: must be of type 'f64' or 'f32'."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Type_Name() {
    LexerTest test = start_up_test(SLS_STR("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 float type: must be of type 'f64' or 'f32'."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Float_Invalid_Comma_Separator() {
    LexerTest test = start_up_test(SLS_STR("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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_Carriage_return() {
    LexerTest test = start_up_test(SLS_STR("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_Escape_Tab() {
    LexerTest test = start_up_test(SLS_STR("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_Null_character() {
    LexerTest test = start_up_test(SLS_STR("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_Single_quote() {
    LexerTest test = start_up_test(SLS_STR("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_Backslash() {
    LexerTest test = start_up_test(SLS_STR("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_Newline() {
    LexerTest test = start_up_test(SLS_STR("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_Hex_Lowercase_A() {
    LexerTest test = start_up_test(SLS_STR("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("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("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("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("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("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("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("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("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("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("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("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("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: unexpected 'B' in character."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Unclosed_Quote() {
    LexerTest test = start_up_test(SLS_STR("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("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: unclosed character literal."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Char_Invalid_Escape() {
    LexerTest test = start_up_test(SLS_STR("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("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("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("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_ASCII_Control_SOH() {
    LexerTest test = start_up_test(SLS_STR("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("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("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("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("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("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_Hex_Lowercase_x() {
    LexerTest test = start_up_test(SLS_STR("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("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("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("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);
}

static TestResult test_Identifier_Simple_Lowercase() {
    LexerTest test = start_up_test(SLS_STR("Identifier Simple Lowercase"), SLS_STR("hello"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("hello")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Simple_Uppercase() {
    LexerTest test = start_up_test(SLS_STR("Identifier Simple Uppercase"), SLS_STR("HELLO"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("HELLO")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Mixed_Case() {
    LexerTest test = start_up_test(SLS_STR("Identifier Mixed Case"), SLS_STR("HelloWorld"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("HelloWorld")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Single_Letter() {
    LexerTest test = start_up_test(SLS_STR("Identifier Single Letter"), SLS_STR("x"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("x")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Single_Letter_Upper() {
    LexerTest test = start_up_test(SLS_STR("Identifier Single Letter Upper"), SLS_STR("X"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("X")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_Numbers() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Numbers"), SLS_STR("var123"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("var123")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Numbers_End() {
    LexerTest test = start_up_test(SLS_STR("Identifier Numbers End"), SLS_STR("myVar2"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("myVar2")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Mixed_Numbers() {
    LexerTest test = start_up_test(SLS_STR("Identifier Mixed Numbers"), SLS_STR("a1b2c3"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("a1b2c3")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_Underscore() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Underscore"), SLS_STR("hello_world"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("hello_world")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Leading_Underscore() {
    LexerTest test = start_up_test(SLS_STR("Identifier Leading Underscore"), SLS_STR("_private"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("_private")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Multiple_Underscores() {
    LexerTest test = start_up_test(SLS_STR("Identifier Multiple Underscores"), SLS_STR("my_long_var_name"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("my_long_var_name")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Double_Underscore() {
    LexerTest test = start_up_test(SLS_STR("Identifier Double Underscore"), SLS_STR("my__var"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("my__var")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Trailing_Underscore() {
    LexerTest test = start_up_test(SLS_STR("Identifier Trailing Underscore"), SLS_STR("var_"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("var_")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Only_Underscores() {
    LexerTest test = start_up_test(SLS_STR("Identifier Only Underscores"), 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_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("___")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Snake_Case() {
    LexerTest test = start_up_test(SLS_STR("Identifier Snake Case"), SLS_STR("my_variable_name"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("my_variable_name")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Camel_Case() {
    LexerTest test = start_up_test(SLS_STR("Identifier Camel Case"), SLS_STR("myVariableName"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("myVariableName")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Pascal_Case() {
    LexerTest test = start_up_test(SLS_STR("Identifier Pascal Case"), SLS_STR("MyClassName"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("MyClassName")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_All_Caps() {
    LexerTest test = start_up_test(SLS_STR("Identifier All Caps"), SLS_STR("MY_CONSTANT"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("MY_CONSTANT")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_Dash() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Dash"), SLS_STR("my-var"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("my-var")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Simple() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Simple"), SLS_STR("::hello"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("hello")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Uppercase() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Uppercase"), SLS_STR("::Point"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("Point")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Snake_Case() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Snake Case"), SLS_STR("::my_var"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("my_var")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Type_i64() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Type i64"), SLS_STR("::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_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("i64")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Type_String() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Type String"), SLS_STR("::String"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("String")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Type_Point() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Type Point"), SLS_STR("::Point"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("Point")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Trait_Addable() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Trait Addable"), SLS_STR("::Addable"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("Addable")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Trait_Drawable() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Trait Drawable"), SLS_STR("::Drawable"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("Drawable")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Field_x() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Field x"), SLS_STR("::x"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("x")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Field_width() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Field width"), SLS_STR("::width"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("width")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_With_Underscore() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal With Underscore"), SLS_STR("::_private"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("_private")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Multiple_Underscores() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Multiple Underscores"), SLS_STR("::my_long_name"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("my_long_name")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_With_Numbers() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal With Numbers"), SLS_STR("::var123"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("var123")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Leading_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("Identifier Leading Whitespace"), SLS_STR("  hello"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("hello")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Trailing_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("Identifier Trailing Whitespace"), SLS_STR("hello  "));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("hello")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Both_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("Identifier Both Whitespace"), SLS_STR("  hello  "));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("hello")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Tab_Before() {
    LexerTest test = start_up_test(SLS_STR("Identifier Tab Before"), SLS_STR("\thello"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("hello")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Leading_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Leading Whitespace"), SLS_STR("  ::hello"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("hello")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Trailing_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Trailing Whitespace"), SLS_STR("::hello  "));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("hello")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Both_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Both Whitespace"), SLS_STR("  ::hello  "));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, SLS_STR("hello")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Moderate_Length() {
    LexerTest test = start_up_test(SLS_STR("Identifier Moderate Length"), SLS_STR("thisIsAReasonablyLongVariableName"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("thisIsAReasonablyLongVariableName")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Very_Long() {
    LexerTest test = start_up_test(SLS_STR("Identifier Very Long"), SLS_STR("this_is_a_very_long_identifier_name_that_someone_might_use_for_some_reason"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("this_is_a_very_long_identifier_name_that_someone_might_use_for_some_reason")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Long_With_Numbers() {
    LexerTest test = start_up_test(SLS_STR("Identifier Long With Numbers"), SLS_STR("variable_with_many_numbers_123_456_789_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_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("variable_with_many_numbers_123_456_789_000")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Starting_With_Number() {
    LexerTest test = start_up_test(SLS_STR("Identifier Starting With Number"), SLS_STR("123abc"));
    LexerResult result = 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_Identifier_With_Hash() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Hash"), SLS_STR("my#var"));
    LexerResult result = 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 identifier: '#' is not allowed in identifiers."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_Dot() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Dot"), SLS_STR("my.var"));
    LexerResult result = 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 identifier: '.' is not allowed in identifiers."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_Space() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Space"), SLS_STR("my var"));
    LexerResult result = 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 identifier: whitespace not allowed in identifiers."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_Colon() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Colon"), SLS_STR("my:var"));
    LexerResult result = 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 identifier: ':' is not allowed in identifiers."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Double_Colon_Inside() {
    LexerTest test = start_up_test(SLS_STR("Identifier Double Colon Inside"), SLS_STR("my::var"));
    LexerResult result = 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 identifier: '::' only allowed as prefix for identifier literals."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_At() {
    LexerTest test = start_up_test(SLS_STR("Identifier With At"), SLS_STR("@variable"));
    LexerResult result = 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 identifier: '@' is not allowed in identifiers."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_Dollar() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Dollar"), SLS_STR("$variable"));
    LexerResult result = 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 identifier: '$' is not allowed in identifiers."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_Percent() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Percent"), SLS_STR("%variable"));
    LexerResult result = 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 identifier: '%' is not allowed in identifiers."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_Brackets() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Brackets"), SLS_STR("my[var]"));
    LexerResult result = 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 identifier: brackets not allowed in identifiers."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_Braces() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Braces"), SLS_STR("my{var}"));
    LexerResult result = 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 identifier: braces not allowed in identifiers."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_Parens() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Parens"), SLS_STR("my(var)"));
    LexerResult result = 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 identifier: parentheses not allowed in identifiers."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_Single_Quote() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Single Quote"), SLS_STR("my'var"));
    LexerResult result = 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 identifier: quotes not allowed in identifiers."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_With_Double_Quote() {
    LexerTest test = start_up_test(SLS_STR("Identifier With Double Quote"), SLS_STR("my\"var"));
    LexerResult result = 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 identifier: quotes not allowed in identifiers."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Only_Numbers() {
    LexerTest test = start_up_test(SLS_STR("Identifier Only Numbers"), SLS_STR("123"));
    LexerResult result = 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 an identifier: numeric literal."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Literal_Empty() {
    LexerTest test = start_up_test(SLS_STR("Identifier Literal Empty"), 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 identifier literal: empty identifier after '::'."))) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Case_Lower() {
    LexerTest test = start_up_test(SLS_STR("Identifier Case Lower"), SLS_STR("variable"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("variable")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Case_Upper() {
    LexerTest test = start_up_test(SLS_STR("Identifier Case Upper"), SLS_STR("VARIABLE"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("VARIABLE")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Case_Mixed() {
    LexerTest test = start_up_test(SLS_STR("Identifier Case Mixed"), SLS_STR("Variable"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("Variable")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Case_Camel() {
    LexerTest test = start_up_test(SLS_STR("Identifier Case Camel"), SLS_STR("variableName"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("variableName")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Case_Pascal() {
    LexerTest test = start_up_test(SLS_STR("Identifier Case Pascal"), SLS_STR("VariableName"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("VariableName")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_true() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word true"), SLS_STR("true"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("true")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_false() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word false"), SLS_STR("false"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("false")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_if() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word if"), SLS_STR("if"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("if")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_while() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word while"), SLS_STR("while"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("while")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_for() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word for"), SLS_STR("for"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("for")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_match() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word match"), SLS_STR("match"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("match")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_break() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word break"), SLS_STR("break"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("break")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_continue() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word continue"), SLS_STR("continue"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("continue")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_fn() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word fn"), SLS_STR("fn"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("fn")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_struct() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word struct"), SLS_STR("struct"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("struct")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_union() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word union"), SLS_STR("union"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("union")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_enum() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word enum"), SLS_STR("enum"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("enum")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_trait() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word trait"), SLS_STR("trait"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("trait")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_impl() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word impl"), SLS_STR("impl"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("impl")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_inher() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word inher"), SLS_STR("inher"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("inher")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_dup() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word dup"), SLS_STR("dup"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("dup")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_drop() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word drop"), SLS_STR("drop"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("drop")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_swap() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word swap"), SLS_STR("swap"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("swap")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_over() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word over"), SLS_STR("over"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("over")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_rot() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word rot"), SLS_STR("rot"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("rot")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_pick() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word pick"), SLS_STR("pick"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("pick")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_roll() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word roll"), SLS_STR("roll"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("roll")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Identifier_Reserved_Word_depth() {
    LexerTest test = start_up_test(SLS_STR("Identifier Reserved Word depth"), SLS_STR("depth"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("depth")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_True() {
    LexerTest test = start_up_test(SLS_STR("Bool True"), SLS_STR("true"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_False() {
    LexerTest test = start_up_test(SLS_STR("Bool False"), SLS_STR("false"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_True_Leading_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("Bool True Leading Whitespace"), SLS_STR("  true"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_True_Trailing_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("Bool True Trailing Whitespace"), SLS_STR("true  "));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_True_Both_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("Bool True Both Whitespace"), SLS_STR("  true  "));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_True_Tab_Before() {
    LexerTest test = start_up_test(SLS_STR("Bool True Tab Before"), SLS_STR("\ttrue"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_False_Leading_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("Bool False Leading Whitespace"), SLS_STR("  false"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_False_Trailing_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("Bool False Trailing Whitespace"), SLS_STR("false  "));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_False_Both_Whitespace() {
    LexerTest test = start_up_test(SLS_STR("Bool False Both Whitespace"), SLS_STR("  false  "));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_False_Tab_Before() {
    LexerTest test = start_up_test(SLS_STR("Bool False Tab Before"), SLS_STR("\tfalse"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_True_Capitalized() {
    LexerTest test = start_up_test(SLS_STR("Bool True Capitalized"), SLS_STR("True"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("True")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_False_Capitalized() {
    LexerTest test = start_up_test(SLS_STR("Bool False Capitalized"), SLS_STR("False"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("False")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_True_All_Caps() {
    LexerTest test = start_up_test(SLS_STR("Bool True All Caps"), SLS_STR("TRUE"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("TRUE")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_False_All_Caps() {
    LexerTest test = start_up_test(SLS_STR("Bool False All Caps"), SLS_STR("FALSE"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("FALSE")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_True_Mixed_Case() {
    LexerTest test = start_up_test(SLS_STR("Bool True Mixed Case"), SLS_STR("tRuE"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("tRuE")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_False_Mixed_Case() {
    LexerTest test = start_up_test(SLS_STR("Bool False Mixed Case"), SLS_STR("fAlSe"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("fAlSe")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_Numeric_1() {
    LexerTest test = start_up_test(SLS_STR("Bool Numeric 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_Bool_Numeric_0() {
    LexerTest test = start_up_test(SLS_STR("Bool Numeric 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_Bool_String_True() {
    LexerTest test = start_up_test(SLS_STR("Bool String True"), SLS_STR("\"true\""));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_string_value(&test, result, i++, &SLS_STR("true"))) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_String_False() {
    LexerTest test = start_up_test(SLS_STR("Bool String False"), SLS_STR("\"false\""));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_string_value(&test, result, i++, &SLS_STR("false"))) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_Yes() {
    LexerTest test = start_up_test(SLS_STR("Bool Yes"), SLS_STR("yes"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("yes")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_No() {
    LexerTest test = start_up_test(SLS_STR("Bool No"), SLS_STR("no"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("no")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_Typo_Ture() {
    LexerTest test = start_up_test(SLS_STR("Bool Typo Ture"), SLS_STR("ture"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("ture")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_Typo_Flase() {
    LexerTest test = start_up_test(SLS_STR("Bool Typo Flase"), SLS_STR("flase"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, SLS_STR("flase")})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_Multiple_True_False() {
    LexerTest test = start_up_test(SLS_STR("Bool Multiple True False"), SLS_STR("true false"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result;
    if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_Multiple_Same() {
    LexerTest test = start_up_test(SLS_STR("Bool Multiple Same"), SLS_STR("true true"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result;
    if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result;
    if (test_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Bool_Three_Values() {
    LexerTest test = start_up_test(SLS_STR("Bool Three Values"), SLS_STR("true false true"));
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) return test.result;
    if (test_boolean_value(&test, result, i++, &(Boolean){FALSE})) return test.result;
    if (test_boolean_value(&test, result, i++, &(Boolean){TRUE})) 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_Very_Small();
    test_report.tests[i++] = test_Float_Default_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_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_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_Multiple_Decimal_Points();
    test_report.tests[i++] = test_Float_Invalid_Characters();
    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_Carriage_return();
    test_report.tests[i++] = test_Char_Escape_Tab();
    test_report.tests[i++] = test_Char_Escape_Null_character();
    test_report.tests[i++] = test_Char_Escape_Single_quote();
    test_report.tests[i++] = test_Char_Escape_Backslash();
    test_report.tests[i++] = test_Char_Escape_Newline();
    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_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_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();
    test_report.tests[i++] = test_Identifier_Simple_Lowercase();
    test_report.tests[i++] = test_Identifier_Simple_Uppercase();
    test_report.tests[i++] = test_Identifier_Mixed_Case();
    test_report.tests[i++] = test_Identifier_Single_Letter();
    test_report.tests[i++] = test_Identifier_Single_Letter_Upper();
    test_report.tests[i++] = test_Identifier_With_Numbers();
    test_report.tests[i++] = test_Identifier_Numbers_End();
    test_report.tests[i++] = test_Identifier_Mixed_Numbers();
    test_report.tests[i++] = test_Identifier_With_Underscore();
    test_report.tests[i++] = test_Identifier_Leading_Underscore();
    test_report.tests[i++] = test_Identifier_Multiple_Underscores();
    test_report.tests[i++] = test_Identifier_Double_Underscore();
    test_report.tests[i++] = test_Identifier_Trailing_Underscore();
    test_report.tests[i++] = test_Identifier_Only_Underscores();
    test_report.tests[i++] = test_Identifier_Snake_Case();
    test_report.tests[i++] = test_Identifier_Camel_Case();
    test_report.tests[i++] = test_Identifier_Pascal_Case();
    test_report.tests[i++] = test_Identifier_All_Caps();
    test_report.tests[i++] = test_Identifier_With_Dash();
    test_report.tests[i++] = test_Identifier_Literal_Simple();
    test_report.tests[i++] = test_Identifier_Literal_Uppercase();
    test_report.tests[i++] = test_Identifier_Literal_Snake_Case();
    test_report.tests[i++] = test_Identifier_Literal_Type_i64();
    test_report.tests[i++] = test_Identifier_Literal_Type_String();
    test_report.tests[i++] = test_Identifier_Literal_Type_Point();
    test_report.tests[i++] = test_Identifier_Literal_Trait_Addable();
    test_report.tests[i++] = test_Identifier_Literal_Trait_Drawable();
    test_report.tests[i++] = test_Identifier_Literal_Field_x();
    test_report.tests[i++] = test_Identifier_Literal_Field_width();
    test_report.tests[i++] = test_Identifier_Literal_With_Underscore();
    test_report.tests[i++] = test_Identifier_Literal_Multiple_Underscores();
    test_report.tests[i++] = test_Identifier_Literal_With_Numbers();
    test_report.tests[i++] = test_Identifier_Leading_Whitespace();
    test_report.tests[i++] = test_Identifier_Trailing_Whitespace();
    test_report.tests[i++] = test_Identifier_Both_Whitespace();
    test_report.tests[i++] = test_Identifier_Tab_Before();
    test_report.tests[i++] = test_Identifier_Literal_Leading_Whitespace();
    test_report.tests[i++] = test_Identifier_Literal_Trailing_Whitespace();
    test_report.tests[i++] = test_Identifier_Literal_Both_Whitespace();
    test_report.tests[i++] = test_Identifier_Moderate_Length();
    test_report.tests[i++] = test_Identifier_Very_Long();
    test_report.tests[i++] = test_Identifier_Long_With_Numbers();
    test_report.tests[i++] = test_Identifier_Starting_With_Number();
    test_report.tests[i++] = test_Identifier_With_Hash();
    test_report.tests[i++] = test_Identifier_With_Dot();
    test_report.tests[i++] = test_Identifier_With_Space();
    test_report.tests[i++] = test_Identifier_With_Colon();
    test_report.tests[i++] = test_Identifier_Double_Colon_Inside();
    test_report.tests[i++] = test_Identifier_With_At();
    test_report.tests[i++] = test_Identifier_With_Dollar();
    test_report.tests[i++] = test_Identifier_With_Percent();
    test_report.tests[i++] = test_Identifier_With_Brackets();
    test_report.tests[i++] = test_Identifier_With_Braces();
    test_report.tests[i++] = test_Identifier_With_Parens();
    test_report.tests[i++] = test_Identifier_With_Single_Quote();
    test_report.tests[i++] = test_Identifier_With_Double_Quote();
    test_report.tests[i++] = test_Identifier_Only_Numbers();
    test_report.tests[i++] = test_Identifier_Literal_Empty();
    test_report.tests[i++] = test_Identifier_Case_Lower();
    test_report.tests[i++] = test_Identifier_Case_Upper();
    test_report.tests[i++] = test_Identifier_Case_Mixed();
    test_report.tests[i++] = test_Identifier_Case_Camel();
    test_report.tests[i++] = test_Identifier_Case_Pascal();
    test_report.tests[i++] = test_Identifier_Reserved_Word_true();
    test_report.tests[i++] = test_Identifier_Reserved_Word_false();
    test_report.tests[i++] = test_Identifier_Reserved_Word_if();
    test_report.tests[i++] = test_Identifier_Reserved_Word_while();
    test_report.tests[i++] = test_Identifier_Reserved_Word_for();
    test_report.tests[i++] = test_Identifier_Reserved_Word_match();
    test_report.tests[i++] = test_Identifier_Reserved_Word_break();
    test_report.tests[i++] = test_Identifier_Reserved_Word_continue();
    test_report.tests[i++] = test_Identifier_Reserved_Word_fn();
    test_report.tests[i++] = test_Identifier_Reserved_Word_struct();
    test_report.tests[i++] = test_Identifier_Reserved_Word_union();
    test_report.tests[i++] = test_Identifier_Reserved_Word_enum();
    test_report.tests[i++] = test_Identifier_Reserved_Word_trait();
    test_report.tests[i++] = test_Identifier_Reserved_Word_impl();
    test_report.tests[i++] = test_Identifier_Reserved_Word_inher();
    test_report.tests[i++] = test_Identifier_Reserved_Word_dup();
    test_report.tests[i++] = test_Identifier_Reserved_Word_drop();
    test_report.tests[i++] = test_Identifier_Reserved_Word_swap();
    test_report.tests[i++] = test_Identifier_Reserved_Word_over();
    test_report.tests[i++] = test_Identifier_Reserved_Word_rot();
    test_report.tests[i++] = test_Identifier_Reserved_Word_pick();
    test_report.tests[i++] = test_Identifier_Reserved_Word_roll();
    test_report.tests[i++] = test_Identifier_Reserved_Word_depth();
    test_report.tests[i++] = test_Bool_True();
    test_report.tests[i++] = test_Bool_False();
    test_report.tests[i++] = test_Bool_True_Leading_Whitespace();
    test_report.tests[i++] = test_Bool_True_Trailing_Whitespace();
    test_report.tests[i++] = test_Bool_True_Both_Whitespace();
    test_report.tests[i++] = test_Bool_True_Tab_Before();
    test_report.tests[i++] = test_Bool_False_Leading_Whitespace();
    test_report.tests[i++] = test_Bool_False_Trailing_Whitespace();
    test_report.tests[i++] = test_Bool_False_Both_Whitespace();
    test_report.tests[i++] = test_Bool_False_Tab_Before();
    test_report.tests[i++] = test_Bool_True_Capitalized();
    test_report.tests[i++] = test_Bool_False_Capitalized();
    test_report.tests[i++] = test_Bool_True_All_Caps();
    test_report.tests[i++] = test_Bool_False_All_Caps();
    test_report.tests[i++] = test_Bool_True_Mixed_Case();
    test_report.tests[i++] = test_Bool_False_Mixed_Case();
    test_report.tests[i++] = test_Bool_Numeric_1();
    test_report.tests[i++] = test_Bool_Numeric_0();
    test_report.tests[i++] = test_Bool_String_True();
    test_report.tests[i++] = test_Bool_String_False();
    test_report.tests[i++] = test_Bool_Yes();
    test_report.tests[i++] = test_Bool_No();
    test_report.tests[i++] = test_Bool_Typo_Ture();
    test_report.tests[i++] = test_Bool_Typo_Flase();
    test_report.tests[i++] = test_Bool_Multiple_True_False();
    test_report.tests[i++] = test_Bool_Multiple_Same();
    test_report.tests[i++] = test_Bool_Three_Values();

    return test_report;
}