diff --git a/SLS_C/tests/lexer_tests.c b/SLS_C/tests/lexer_tests.c
index 3b57536..6404d9d 100644
--- a/SLS_C/tests/lexer_tests.c
+++ b/SLS_C/tests/lexer_tests.c
@@ -16,7 +16,7 @@
 #include "tests/tests.h"
 
 
-static const size_t NUM_OF_TESTS = 135;
+static const size_t NUM_OF_TESTS = 294;
 
 static TestResult test_Empty_Statement() {
     LexerTest test = start_up_test(SLS_STR("test_Empty_Statement"), SLS_STR(""));
@@ -1348,6 +1348,1569 @@ static TestResult test_Integer_Octal_With_Underscores() {
     return pass_test(&test, result);
 }
 
+static TestResult test_Float_Default_Simple() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Simple"), SLS_STR("3.14"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){3.14})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Zero() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Zero"), SLS_STR("0.0"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){0.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Negative() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Negative"), SLS_STR("-2.5"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){-2.5})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_One() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_One"), SLS_STR("1.0"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Simple() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Simple"), SLS_STR("3.14:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){3.14})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_Simple() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Simple"), SLS_STR("2.718:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){2.718})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Leading_Zeros() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Leading_Zeros"), SLS_STR("00042.5"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){42.5})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Leading_Zero_Decimal() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Leading_Zero_Decimal"), SLS_STR("0.5"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){0.5})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Trailing_Zeros() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Trailing_Zeros"), SLS_STR("3.1400"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){3.14})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_No_Leading_Digit() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_No_Leading_Digit"), SLS_STR(".5"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){0.5})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_No_Leading_Digit_Negative() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_No_Leading_Digit_Negative"), SLS_STR("-.25"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){-0.25})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_No_Trailing_Digits() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_No_Trailing_Digits"), SLS_STR("42."));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){42.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_No_Trailing_Digits_Negative() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_No_Trailing_Digits_Negative"), SLS_STR("-7."));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){-7.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Scientific_Positive_Exp() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Scientific_Positive_Exp"), SLS_STR("1.5e10"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){15000000000.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Scientific_Negative_Exp() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Scientific_Negative_Exp"), SLS_STR("2.5e-5"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){2.5e-05})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Scientific_Capital_E() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Scientific_Capital_E"), SLS_STR("3.14E8"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){314000000.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Scientific_Plus_Sign() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Scientific_Plus_Sign"), SLS_STR("1.0e+3"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1000.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Very_Small() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Very_Small"), SLS_STR("0.000001"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1e-06})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Scientific_Very_Small() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Scientific_Very_Small"), SLS_STR("1.0e-20"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1e-20})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Very_Large() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Very_Large"), SLS_STR("1000000.0"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1000000.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Scientific_Very_Large() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Scientific_Very_Large"), SLS_STR("1.0e20"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1e+20})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Underscore_Integer_Part() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Integer_Part"), SLS_STR("1_000_000.5"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1000000.5})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Underscore_Decimal_Part() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Decimal_Part"), SLS_STR("3.141_592_653"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){3.141592653})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Underscore_Both_Parts() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Both_Parts"), SLS_STR("1_234.567_89"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1234.56789})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Underscore_Scientific_Mantissa() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Scientific_Mantissa"), SLS_STR("1_000.5e10"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){10005000000000.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Underscore_Scientific_Exponent() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Scientific_Exponent"), SLS_STR("1.5e1_0"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){15000000000.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Underscore_Trailing() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Trailing"), SLS_STR("42.5_"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){42.5})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Underscore_Double() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Underscore_Double"), SLS_STR("4__2.5"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){42.5})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_With_Underscores() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_With_Underscores"), SLS_STR("1_234.567_89:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){1234.56789})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Max_Value() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Max_Value"), SLS_STR("3.4028235e+38:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){3.4028235e+38})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Min_Value() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Min_Value"), SLS_STR("-3.4028235e+38:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){-3.4028235e+38})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Min_Positive() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Min_Positive"), SLS_STR("1.1754944e-38:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){1.1754944e-38})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Epsilon() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Epsilon"), SLS_STR("1.1920929e-07:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){1.1920929e-07})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Near_Zero_Positive() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Near_Zero_Positive"), SLS_STR("1e-30:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){1e-30})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Near_Zero_Negative() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Near_Zero_Negative"), SLS_STR("-1e-30:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){-1e-30})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Subnormal() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Subnormal"), SLS_STR("1e-40:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){1e-40})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_Max_Value() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Max_Value"), SLS_STR("1.7976931348623157e+308:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1.7976931348623157e+308})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_Min_Value() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Min_Value"), SLS_STR("-1.7976931348623157e+308:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){-1.7976931348623157e+308})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_Min_Positive() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Min_Positive"), SLS_STR("2.2250738585072014e-308:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){2.2250738585072014e-308})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_Epsilon() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Epsilon"), SLS_STR("2.220446049250313e-16:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){2.220446049250313e-16})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_Near_Zero_Positive() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Near_Zero_Positive"), SLS_STR("1e-30:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1e-30})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_Near_Zero_Negative() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Near_Zero_Negative"), SLS_STR("-1e-30:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){-1e-30})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_Subnormal() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Subnormal"), SLS_STR("1e-320:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1e-320})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Overflow_Positive() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Overflow_Positive"), SLS_STR("1e40:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Float overflow: value exceeds range for f32."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Overflow_Negative() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Overflow_Negative"), SLS_STR("-1e40:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Float overflow: value exceeds range for f32."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_Overflow_Positive() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Overflow_Positive"), SLS_STR("1e310:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Float overflow: value exceeds range for f64."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_Overflow_Negative() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Overflow_Negative"), SLS_STR("-1e310:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Float overflow: value exceeds range for f64."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Precision_Limit() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Precision_Limit"), SLS_STR("1.2345678:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){1.2345678})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_High_Precision() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_High_Precision"), SLS_STR("3.141592653589793:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){3.141592653589793})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_Precision_Limit() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Precision_Limit"), SLS_STR("1.234567890123456:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1.234567890123456})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_High_Precision() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_High_Precision"), SLS_STR("3.141592653589793238:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){3.141592653589793})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_Close_Numbers_1() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Close_Numbers_1"), SLS_STR("1.0000000000000001:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f64_Close_Numbers_2() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f64_Close_Numbers_2"), SLS_STR("1.0000000000000002:f64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1.0000000000000002})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Invalid_No_Decimal_Point() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_No_Decimal_Point"), SLS_STR("42"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Not a valid float literal: missing decimal point."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Invalid_Multiple_Decimal_Points() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Multiple_Decimal_Points"), SLS_STR("3.14.159"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: multiple decimal points."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Invalid_Only_Decimal_Point() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Only_Decimal_Point"), SLS_STR("."));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: no digits before or after decimal point."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Invalid_Characters() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Characters"), SLS_STR("3.1a4"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: unexpected 'a' in float."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Invalid_Scientific_No_Exponent() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Scientific_No_Exponent"), SLS_STR("3.14e"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: missing exponent value."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Invalid_Scientific_Double_E() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Scientific_Double_E"), SLS_STR("3.14e10e5"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: multiple exponent markers."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Invalid_Scientific_Invalid_Exponent() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Scientific_Invalid_Exponent"), SLS_STR("3.14eX"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: invalid exponent 'X'."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Invalid_Leading_Underscore() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Leading_Underscore"), SLS_STR("_3.14"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: leading underscore."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Invalid_Underscore_Before_Decimal() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Underscore_Before_Decimal"), SLS_STR("3_.14"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: underscore before decimal point."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Invalid_Underscore_After_Decimal() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Underscore_After_Decimal"), SLS_STR("3._14"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: underscore after decimal point."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Invalid_Type_Annotation() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Type_Annotation"), SLS_STR("3.14:i32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Type mismatch: float literal cannot be annotated as integer type."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Invalid_Type_Name() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Type_Name"), SLS_STR("3.14:f16"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid type annotation: unknown type 'f16'."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Invalid_Comma_Separator() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Invalid_Comma_Separator"), SLS_STR("1,234.56"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: unexpected ',' in float."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Leading_Whitespace() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Leading_Whitespace"), SLS_STR("  3.14"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){3.14})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Trailing_Whitespace() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Trailing_Whitespace"), SLS_STR("3.14  "));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){3.14})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Both_Whitespace() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Both_Whitespace"), SLS_STR("  3.14  "));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){3.14})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_With_Whitespace() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_With_Whitespace"), SLS_STR("  2.718:f32  "));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){2.718})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Pi_Approximate() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Pi_Approximate"), SLS_STR("3.141592653589793"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){3.141592653589793})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Pi_Approximate() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Pi_Approximate"), SLS_STR("3.1415927:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){3.1415927})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Euler_Approximate() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Euler_Approximate"), SLS_STR("2.718281828459045"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){2.718281828459045})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Euler_Approximate() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Euler_Approximate"), SLS_STR("2.7182817:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){2.7182817})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Golden_Ratio() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Golden_Ratio"), SLS_STR("1.618033988749895"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1.618033988749895})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Sqrt2() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Sqrt2"), SLS_STR("1.4142135623730951"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){1.4142135623730951})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Positive_Zero() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Positive_Zero"), SLS_STR("0.0"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){0.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_Default_Negative_Zero() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_Default_Negative_Zero"), SLS_STR("-0.0"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_double_value(&test, result, i++, &(double){-0.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Positive_Zero() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Positive_Zero"), SLS_STR("0.0:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){0.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Float_f32_Negative_Zero() {
+    LexerTest test = start_up_test(SLS_STR("test_Float_f32_Negative_Zero"), SLS_STR("-0.0:f32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_float_value(&test, result, i++, &(float){-0.0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Simple_Letter_A() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Simple_Letter_A"), SLS_STR("'A'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Simple_Letter_a() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Simple_Letter_a"), SLS_STR("'a'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){97})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Simple_Letter_Z() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Simple_Letter_Z"), SLS_STR("'Z'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){90})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Simple_Letter_z() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Simple_Letter_z"), SLS_STR("'z'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){122})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Digit_0() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Digit_0"), SLS_STR("'0'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){48})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Digit_5() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Digit_5"), SLS_STR("'5'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){53})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Digit_9() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Digit_9"), SLS_STR("'9'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){57})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Space() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Space"), SLS_STR("' '"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){32})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Exclamation() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Exclamation"), SLS_STR("'!'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){33})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Question_Mark() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Question_Mark"), SLS_STR("'?'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){63})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Period() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Period"), SLS_STR("'.'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){46})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Comma() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Comma"), SLS_STR("','"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){44})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Semicolon() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Semicolon"), SLS_STR("';'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){59})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Colon() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Colon"), SLS_STR("':'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){58})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Plus() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Plus"), SLS_STR("'+'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){43})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Minus() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Minus"), SLS_STR("'-'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){45})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Asterisk() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Asterisk"), SLS_STR("'*'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){42})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Slash() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Slash"), SLS_STR("'/'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){47})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Equals() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Equals"), SLS_STR("'='"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){61})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Less_Than() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Less_Than"), SLS_STR("'<'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){60})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Greater_Than() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Greater_Than"), SLS_STR("'>'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){62})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Left_Paren() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Left_Paren"), SLS_STR("'('"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){40})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Right_Paren() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Right_Paren"), SLS_STR("')'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){41})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Left_Bracket() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Left_Bracket"), SLS_STR("'['"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){91})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Right_Bracket() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Right_Bracket"), SLS_STR("']'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){93})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Left_Brace() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Left_Brace"), SLS_STR("'{'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){123})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Right_Brace() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Right_Brace"), SLS_STR("'}'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){125})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Escape_Newline() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Newline"), SLS_STR("'\n'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){10})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Escape_Null_character() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Null_character"), SLS_STR("'\0'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Escape_Double_quote() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Double_quote"), SLS_STR("'\\\"'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){34})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Escape_Single_quote() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Single_quote"), SLS_STR("'\''"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){39})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Escape_Tab() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Tab"), SLS_STR("'\t'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){9})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Escape_Backslash() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Backslash"), SLS_STR("'\\'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){92})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Escape_Carriage_return() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Escape_Carriage_return"), SLS_STR("'\r'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){13})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Newline() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Newline"), SLS_STR("'\n'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){10})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Carriage_Return() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Carriage_Return"), SLS_STR("'\r'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){13})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Tab() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Tab"), SLS_STR("'\t'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){9})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Backslash() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Backslash"), SLS_STR("'\\'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){92})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Double_Quote() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Double_Quote"), SLS_STR("'\\\"'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){34})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Single_Quote() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Single_Quote"), SLS_STR("'\''"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){39})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Null() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Null"), SLS_STR("'\0'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Escape_x41() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_x41"), SLS_STR("'\x41'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Escape_x61() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_x61"), SLS_STR("'\x61'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){97})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Escape_x20() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_x20"), SLS_STR("'\x20'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){32})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Escape_x00() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_x00"), SLS_STR("'\x00'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){0})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Escape_xFF() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_xFF"), SLS_STR("'\xFF'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){255})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Lowercase_A() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Lowercase_A"), SLS_STR("'\x61'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){97})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Uppercase_A() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Uppercase_A"), SLS_STR("'\x41'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Space() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Space"), SLS_STR("'\x20'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){32})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Tab() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Tab"), SLS_STR("'\x09'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){9})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Newline() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Newline"), SLS_STR("'\x0A'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){10})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Max_ASCII() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Max_ASCII"), SLS_STR("'\x7F'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){127})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_With_Leading_Whitespace() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_With_Leading_Whitespace"), SLS_STR("  'A'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_With_Trailing_Whitespace() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_With_Trailing_Whitespace"), SLS_STR("'A'  "));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_With_Both_Whitespace() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_With_Both_Whitespace"), SLS_STR("  'A'  "));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Tab_Before() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Tab_Before"), SLS_STR("\t'B'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){66})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Newline_Before() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Newline_Before"), SLS_STR("\n'C'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){67})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Empty_Literal() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Empty_Literal"), SLS_STR("''"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: empty character literal."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Multiple_Characters() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Multiple_Characters"), SLS_STR("'AB'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: multiple characters without escape sequence."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Unclosed_Quote() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Unclosed_Quote"), SLS_STR("'A"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: unclosed character literal."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Unescaped_Newline() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Unescaped_Newline"), SLS_STR("'\n'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: unescaped newline in character literal."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Invalid_Escape() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Invalid_Escape"), SLS_STR("'\q'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: unknown escape sequence '\q'."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Escape_Too_Short() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_Too_Short"), SLS_STR("'\x4'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: hexadecimal escape must have exactly 2 digits."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Escape_Too_Long() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Escape_Too_Long"), SLS_STR("'\x414'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: hexadecimal escape must have exactly 2 digits."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Invalid_Digit() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Invalid_Digit"), SLS_STR("'\\xGG'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: invalid hexadecimal digit 'G'."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Double_Quotes() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Double_Quotes"), SLS_STR("\"A\""));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: character literals must use single quotes."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_No_Quotes() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_No_Quotes"), SLS_STR("A"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_for_error(&test, result, i++, SLS_STR("Not a character literal: missing quotes."))) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_ASCII_Control_SOH() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_ASCII_Control_SOH"), SLS_STR("'\x01'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){1})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_ASCII_Control_BEL() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_ASCII_Control_BEL"), SLS_STR("'\x07'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){7})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_ASCII_Control_ESC() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_ASCII_Control_ESC"), SLS_STR("'\x1B'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){27})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_ASCII_Control_DEL() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_ASCII_Control_DEL"), SLS_STR("'\x7F'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){127})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Extended_ASCII_Lower() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Extended_ASCII_Lower"), SLS_STR("'\x80'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){128})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Extended_ASCII_Upper() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Extended_ASCII_Upper"), SLS_STR("'\xFF'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){255})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Backslash_Literal() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Backslash_Literal"), SLS_STR("'\\'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){92})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Single_Quote_Escaped() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Single_Quote_Escaped"), SLS_STR("'\''"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){39})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Lowercase_x() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Lowercase_x"), SLS_STR("'\x41'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Digits_Uppercase() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Digits_Uppercase"), SLS_STR("'\xFF'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){255})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Digits_Lowercase() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Digits_Lowercase"), SLS_STR("'\xff'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){255})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Char_Hex_Digits_Mixed() {
+    LexerTest test = start_up_test(SLS_STR("test_Char_Hex_Digits_Mixed"), SLS_STR("'\xAb'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){171})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
 TestsReport run_lexer_tests() {
     TestsReport test_report = (TestsReport) {
         .section = SLS_STR("lexer_tests"),
@@ -1492,6 +3055,165 @@ TestsReport run_lexer_tests() {
     test_report.tests[i++] = test_Integer_Hex_With_Underscores();
     test_report.tests[i++] = test_Integer_Binary_With_Underscores();
     test_report.tests[i++] = test_Integer_Octal_With_Underscores();
+    test_report.tests[i++] = test_Float_Default_Simple();
+    test_report.tests[i++] = test_Float_Default_Zero();
+    test_report.tests[i++] = test_Float_Default_Negative();
+    test_report.tests[i++] = test_Float_Default_One();
+    test_report.tests[i++] = test_Float_f32_Simple();
+    test_report.tests[i++] = test_Float_f64_Simple();
+    test_report.tests[i++] = test_Float_Default_Leading_Zeros();
+    test_report.tests[i++] = test_Float_Default_Leading_Zero_Decimal();
+    test_report.tests[i++] = test_Float_Default_Trailing_Zeros();
+    test_report.tests[i++] = test_Float_Default_No_Leading_Digit();
+    test_report.tests[i++] = test_Float_Default_No_Leading_Digit_Negative();
+    test_report.tests[i++] = test_Float_Default_No_Trailing_Digits();
+    test_report.tests[i++] = test_Float_Default_No_Trailing_Digits_Negative();
+    test_report.tests[i++] = test_Float_Default_Scientific_Positive_Exp();
+    test_report.tests[i++] = test_Float_Default_Scientific_Negative_Exp();
+    test_report.tests[i++] = test_Float_Default_Scientific_Capital_E();
+    test_report.tests[i++] = test_Float_Default_Scientific_Plus_Sign();
+    test_report.tests[i++] = test_Float_Default_Very_Small();
+    test_report.tests[i++] = test_Float_Default_Scientific_Very_Small();
+    test_report.tests[i++] = test_Float_Default_Very_Large();
+    test_report.tests[i++] = test_Float_Default_Scientific_Very_Large();
+    test_report.tests[i++] = test_Float_Default_Underscore_Integer_Part();
+    test_report.tests[i++] = test_Float_Default_Underscore_Decimal_Part();
+    test_report.tests[i++] = test_Float_Default_Underscore_Both_Parts();
+    test_report.tests[i++] = test_Float_Default_Underscore_Scientific_Mantissa();
+    test_report.tests[i++] = test_Float_Default_Underscore_Scientific_Exponent();
+    test_report.tests[i++] = test_Float_Default_Underscore_Trailing();
+    test_report.tests[i++] = test_Float_Default_Underscore_Double();
+    test_report.tests[i++] = test_Float_f32_With_Underscores();
+    test_report.tests[i++] = test_Float_f32_Max_Value();
+    test_report.tests[i++] = test_Float_f32_Min_Value();
+    test_report.tests[i++] = test_Float_f32_Min_Positive();
+    test_report.tests[i++] = test_Float_f32_Epsilon();
+    test_report.tests[i++] = test_Float_f32_Near_Zero_Positive();
+    test_report.tests[i++] = test_Float_f32_Near_Zero_Negative();
+    test_report.tests[i++] = test_Float_f32_Subnormal();
+    test_report.tests[i++] = test_Float_f64_Max_Value();
+    test_report.tests[i++] = test_Float_f64_Min_Value();
+    test_report.tests[i++] = test_Float_f64_Min_Positive();
+    test_report.tests[i++] = test_Float_f64_Epsilon();
+    test_report.tests[i++] = test_Float_f64_Near_Zero_Positive();
+    test_report.tests[i++] = test_Float_f64_Near_Zero_Negative();
+    test_report.tests[i++] = test_Float_f64_Subnormal();
+    test_report.tests[i++] = test_Float_f32_Overflow_Positive();
+    test_report.tests[i++] = test_Float_f32_Overflow_Negative();
+    test_report.tests[i++] = test_Float_f64_Overflow_Positive();
+    test_report.tests[i++] = test_Float_f64_Overflow_Negative();
+    test_report.tests[i++] = test_Float_f32_Precision_Limit();
+    test_report.tests[i++] = test_Float_f32_High_Precision();
+    test_report.tests[i++] = test_Float_f64_Precision_Limit();
+    test_report.tests[i++] = test_Float_f64_High_Precision();
+    test_report.tests[i++] = test_Float_f64_Close_Numbers_1();
+    test_report.tests[i++] = test_Float_f64_Close_Numbers_2();
+    test_report.tests[i++] = test_Float_Invalid_No_Decimal_Point();
+    test_report.tests[i++] = test_Float_Invalid_Multiple_Decimal_Points();
+    test_report.tests[i++] = test_Float_Invalid_Only_Decimal_Point();
+    test_report.tests[i++] = test_Float_Invalid_Characters();
+    test_report.tests[i++] = test_Float_Invalid_Scientific_No_Exponent();
+    test_report.tests[i++] = test_Float_Invalid_Scientific_Double_E();
+    test_report.tests[i++] = test_Float_Invalid_Scientific_Invalid_Exponent();
+    test_report.tests[i++] = test_Float_Invalid_Leading_Underscore();
+    test_report.tests[i++] = test_Float_Invalid_Underscore_Before_Decimal();
+    test_report.tests[i++] = test_Float_Invalid_Underscore_After_Decimal();
+    test_report.tests[i++] = test_Float_Invalid_Type_Annotation();
+    test_report.tests[i++] = test_Float_Invalid_Type_Name();
+    test_report.tests[i++] = test_Float_Invalid_Comma_Separator();
+    test_report.tests[i++] = test_Float_Default_Leading_Whitespace();
+    test_report.tests[i++] = test_Float_Default_Trailing_Whitespace();
+    test_report.tests[i++] = test_Float_Default_Both_Whitespace();
+    test_report.tests[i++] = test_Float_f32_With_Whitespace();
+    test_report.tests[i++] = test_Float_Default_Pi_Approximate();
+    test_report.tests[i++] = test_Float_f32_Pi_Approximate();
+    test_report.tests[i++] = test_Float_Default_Euler_Approximate();
+    test_report.tests[i++] = test_Float_f32_Euler_Approximate();
+    test_report.tests[i++] = test_Float_Default_Golden_Ratio();
+    test_report.tests[i++] = test_Float_Default_Sqrt2();
+    test_report.tests[i++] = test_Float_Default_Positive_Zero();
+    test_report.tests[i++] = test_Float_Default_Negative_Zero();
+    test_report.tests[i++] = test_Float_f32_Positive_Zero();
+    test_report.tests[i++] = test_Float_f32_Negative_Zero();
+    test_report.tests[i++] = test_Char_Simple_Letter_A();
+    test_report.tests[i++] = test_Char_Simple_Letter_a();
+    test_report.tests[i++] = test_Char_Simple_Letter_Z();
+    test_report.tests[i++] = test_Char_Simple_Letter_z();
+    test_report.tests[i++] = test_Char_Digit_0();
+    test_report.tests[i++] = test_Char_Digit_5();
+    test_report.tests[i++] = test_Char_Digit_9();
+    test_report.tests[i++] = test_Char_Space();
+    test_report.tests[i++] = test_Char_Exclamation();
+    test_report.tests[i++] = test_Char_Question_Mark();
+    test_report.tests[i++] = test_Char_Period();
+    test_report.tests[i++] = test_Char_Comma();
+    test_report.tests[i++] = test_Char_Semicolon();
+    test_report.tests[i++] = test_Char_Colon();
+    test_report.tests[i++] = test_Char_Plus();
+    test_report.tests[i++] = test_Char_Minus();
+    test_report.tests[i++] = test_Char_Asterisk();
+    test_report.tests[i++] = test_Char_Slash();
+    test_report.tests[i++] = test_Char_Equals();
+    test_report.tests[i++] = test_Char_Less_Than();
+    test_report.tests[i++] = test_Char_Greater_Than();
+    test_report.tests[i++] = test_Char_Left_Paren();
+    test_report.tests[i++] = test_Char_Right_Paren();
+    test_report.tests[i++] = test_Char_Left_Bracket();
+    test_report.tests[i++] = test_Char_Right_Bracket();
+    test_report.tests[i++] = test_Char_Left_Brace();
+    test_report.tests[i++] = test_Char_Right_Brace();
+    test_report.tests[i++] = test_Char_Escape_Newline();
+    test_report.tests[i++] = test_Char_Escape_Null_character();
+    test_report.tests[i++] = test_Char_Escape_Double_quote();
+    test_report.tests[i++] = test_Char_Escape_Single_quote();
+    test_report.tests[i++] = test_Char_Escape_Tab();
+    test_report.tests[i++] = test_Char_Escape_Backslash();
+    test_report.tests[i++] = test_Char_Escape_Carriage_return();
+    test_report.tests[i++] = test_Char_Newline();
+    test_report.tests[i++] = test_Char_Carriage_Return();
+    test_report.tests[i++] = test_Char_Tab();
+    test_report.tests[i++] = test_Char_Backslash();
+    test_report.tests[i++] = test_Char_Double_Quote();
+    test_report.tests[i++] = test_Char_Single_Quote();
+    test_report.tests[i++] = test_Char_Null();
+    test_report.tests[i++] = test_Char_Hex_Escape_x41();
+    test_report.tests[i++] = test_Char_Hex_Escape_x61();
+    test_report.tests[i++] = test_Char_Hex_Escape_x20();
+    test_report.tests[i++] = test_Char_Hex_Escape_x00();
+    test_report.tests[i++] = test_Char_Hex_Escape_xFF();
+    test_report.tests[i++] = test_Char_Hex_Lowercase_A();
+    test_report.tests[i++] = test_Char_Hex_Uppercase_A();
+    test_report.tests[i++] = test_Char_Hex_Space();
+    test_report.tests[i++] = test_Char_Hex_Tab();
+    test_report.tests[i++] = test_Char_Hex_Newline();
+    test_report.tests[i++] = test_Char_Hex_Max_ASCII();
+    test_report.tests[i++] = test_Char_With_Leading_Whitespace();
+    test_report.tests[i++] = test_Char_With_Trailing_Whitespace();
+    test_report.tests[i++] = test_Char_With_Both_Whitespace();
+    test_report.tests[i++] = test_Char_Tab_Before();
+    test_report.tests[i++] = test_Char_Newline_Before();
+    test_report.tests[i++] = test_Char_Empty_Literal();
+    test_report.tests[i++] = test_Char_Multiple_Characters();
+    test_report.tests[i++] = test_Char_Unclosed_Quote();
+    test_report.tests[i++] = test_Char_Unescaped_Newline();
+    test_report.tests[i++] = test_Char_Invalid_Escape();
+    test_report.tests[i++] = test_Char_Hex_Escape_Too_Short();
+    test_report.tests[i++] = test_Char_Hex_Escape_Too_Long();
+    test_report.tests[i++] = test_Char_Hex_Invalid_Digit();
+    test_report.tests[i++] = test_Char_Double_Quotes();
+    test_report.tests[i++] = test_Char_No_Quotes();
+    test_report.tests[i++] = test_Char_ASCII_Control_SOH();
+    test_report.tests[i++] = test_Char_ASCII_Control_BEL();
+    test_report.tests[i++] = test_Char_ASCII_Control_ESC();
+    test_report.tests[i++] = test_Char_ASCII_Control_DEL();
+    test_report.tests[i++] = test_Char_Extended_ASCII_Lower();
+    test_report.tests[i++] = test_Char_Extended_ASCII_Upper();
+    test_report.tests[i++] = test_Char_Backslash_Literal();
+    test_report.tests[i++] = test_Char_Single_Quote_Escaped();
+    test_report.tests[i++] = test_Char_Hex_Lowercase_x();
+    test_report.tests[i++] = test_Char_Hex_Digits_Uppercase();
+    test_report.tests[i++] = test_Char_Hex_Digits_Lowercase();
+    test_report.tests[i++] = test_Char_Hex_Digits_Mixed();
 
     return test_report;
 }
diff --git a/SLS_Tests/cases.yaml b/SLS_Tests/cases.yaml
index f303ece..f2ee725 100644
--- a/SLS_Tests/cases.yaml
+++ b/SLS_Tests/cases.yaml
@@ -1476,3 +1476,1740 @@
   stack_final:
   - type: i16
     value: 511
+- name: Float Default Simple
+  code: '3.14'
+  tokens:
+  - type: f64
+    value: 3.14
+  operations:
+  - function: push
+    type: f64
+    value: 3.14
+  stack_final:
+  - type: f64
+    value: 3.14
+- name: Float Default Zero
+  code: '0.0'
+  tokens:
+  - type: f64
+    value: 0.0
+  operations:
+  - function: push
+    type: f64
+    value: 0.0
+  stack_final:
+  - type: f64
+    value: 0.0
+- name: Float Default Negative
+  code: '-2.5'
+  tokens:
+  - type: f64
+    value: -2.5
+  operations:
+  - function: push
+    type: f64
+    value: -2.5
+  stack_final:
+  - type: f64
+    value: -2.5
+- name: Float Default One
+  code: '1.0'
+  tokens:
+  - type: f64
+    value: 1.0
+  operations:
+  - function: push
+    type: f64
+    value: 1.0
+  stack_final:
+  - type: f64
+    value: 1.0
+- name: Float f32 Simple
+  code: 3.14:f32
+  tokens:
+  - type: f32
+    value: 3.14
+  operations:
+  - function: push
+    type: f32
+    value: 3.14
+  stack_final:
+  - type: f32
+    value: 3.14
+- name: Float f64 Simple
+  code: 2.718:f64
+  tokens:
+  - type: f64
+    value: 2.718
+  operations:
+  - function: push
+    type: f64
+    value: 2.718
+  stack_final:
+  - type: f64
+    value: 2.718
+- name: Float Default Leading Zeros
+  code: '00042.5'
+  tokens:
+  - type: f64
+    value: 42.5
+  operations:
+  - function: push
+    type: f64
+    value: 42.5
+  stack_final:
+  - type: f64
+    value: 42.5
+- name: Float Default Leading Zero Decimal
+  code: '0.5'
+  tokens:
+  - type: f64
+    value: 0.5
+  operations:
+  - function: push
+    type: f64
+    value: 0.5
+  stack_final:
+  - type: f64
+    value: 0.5
+- name: Float Default Trailing Zeros
+  code: '3.1400'
+  tokens:
+  - type: f64
+    value: 3.14
+  operations:
+  - function: push
+    type: f64
+    value: 3.14
+  stack_final:
+  - type: f64
+    value: 3.14
+- name: Float Default No Leading Digit
+  code: '.5'
+  tokens:
+  - type: f64
+    value: 0.5
+  operations:
+  - function: push
+    type: f64
+    value: 0.5
+  stack_final:
+  - type: f64
+    value: 0.5
+- name: Float Default No Leading Digit Negative
+  code: -.25
+  tokens:
+  - type: f64
+    value: -0.25
+  operations:
+  - function: push
+    type: f64
+    value: -0.25
+  stack_final:
+  - type: f64
+    value: -0.25
+- name: Float Default No Trailing Digits
+  code: '42.'
+  tokens:
+  - type: f64
+    value: 42.0
+  operations:
+  - function: push
+    type: f64
+    value: 42.0
+  stack_final:
+  - type: f64
+    value: 42.0
+- name: Float Default No Trailing Digits Negative
+  code: '-7.'
+  tokens:
+  - type: f64
+    value: -7.0
+  operations:
+  - function: push
+    type: f64
+    value: -7.0
+  stack_final:
+  - type: f64
+    value: -7.0
+- name: Float Default Scientific Positive Exp
+  code: 1.5e10
+  tokens:
+  - type: f64
+    value: 15000000000.0
+  operations:
+  - function: push
+    type: f64
+    value: 15000000000.0
+  stack_final:
+  - type: f64
+    value: 15000000000.0
+- name: Float Default Scientific Negative Exp
+  code: '2.5e-5'
+  tokens:
+  - type: f64
+    value: 2.5e-05
+  operations:
+  - function: push
+    type: f64
+    value: 2.5e-05
+  stack_final:
+  - type: f64
+    value: 2.5e-05
+- name: Float Default Scientific Capital E
+  code: 3.14E8
+  tokens:
+  - type: f64
+    value: 314000000.0
+  operations:
+  - function: push
+    type: f64
+    value: 314000000.0
+  stack_final:
+  - type: f64
+    value: 314000000.0
+- name: Float Default Scientific Plus Sign
+  code: '1.0e+3'
+  tokens:
+  - type: f64
+    value: 1000.0
+  operations:
+  - function: push
+    type: f64
+    value: 1000.0
+  stack_final:
+  - type: f64
+    value: 1000.0
+- name: Float Default Very Small
+  code: '0.000001'
+  tokens:
+  - type: f64
+    value: 1.0e-06
+  operations:
+  - function: push
+    type: f64
+    value: 1.0e-06
+  stack_final:
+  - type: f64
+    value: 1.0e-06
+- name: Float Default Scientific Very Small
+  code: '1.0e-20'
+  tokens:
+  - type: f64
+    value: 1.0e-20
+  operations:
+  - function: push
+    type: f64
+    value: 1.0e-20
+  stack_final:
+  - type: f64
+    value: 1.0e-20
+- name: Float Default Very Large
+  code: '1000000.0'
+  tokens:
+  - type: f64
+    value: 1000000.0
+  operations:
+  - function: push
+    type: f64
+    value: 1000000.0
+  stack_final:
+  - type: f64
+    value: 1000000.0
+- name: Float Default Scientific Very Large
+  code: 1.0e20
+  tokens:
+  - type: f64
+    value: 1.0e+20
+  operations:
+  - function: push
+    type: f64
+    value: 1.0e+20
+  stack_final:
+  - type: f64
+    value: 1.0e+20
+- name: Float Default Underscore Integer Part
+  code: '1_000_000.5'
+  tokens:
+  - type: f64
+    value: 1000000.5
+  operations:
+  - function: push
+    type: f64
+    value: 1000000.5
+  stack_final:
+  - type: f64
+    value: 1000000.5
+- name: Float Default Underscore Decimal Part
+  code: '3.141_592_653'
+  tokens:
+  - type: f64
+    value: 3.141592653
+  operations:
+  - function: push
+    type: f64
+    value: 3.141592653
+  stack_final:
+  - type: f64
+    value: 3.141592653
+- name: Float Default Underscore Both Parts
+  code: '1_234.567_89'
+  tokens:
+  - type: f64
+    value: 1234.56789
+  operations:
+  - function: push
+    type: f64
+    value: 1234.56789
+  stack_final:
+  - type: f64
+    value: 1234.56789
+- name: Float Default Underscore Scientific Mantissa
+  code: 1_000.5e10
+  tokens:
+  - type: f64
+    value: 10005000000000.0
+  operations:
+  - function: push
+    type: f64
+    value: 10005000000000.0
+  stack_final:
+  - type: f64
+    value: 10005000000000.0
+- name: Float Default Underscore Scientific Exponent
+  code: 1.5e1_0
+  tokens:
+  - type: f64
+    value: 15000000000.0
+  operations:
+  - function: push
+    type: f64
+    value: 15000000000.0
+  stack_final:
+  - type: f64
+    value: 15000000000.0
+- name: Float Default Underscore Trailing
+  code: '42.5_'
+  tokens:
+  - type: f64
+    value: 42.5
+  operations:
+  - function: push
+    type: f64
+    value: 42.5
+  stack_final:
+  - type: f64
+    value: 42.5
+- name: Float Default Underscore Double
+  code: '4__2.5'
+  tokens:
+  - type: f64
+    value: 42.5
+  operations:
+  - function: push
+    type: f64
+    value: 42.5
+  stack_final:
+  - type: f64
+    value: 42.5
+- name: Float f32 With Underscores
+  code: 1_234.567_89:f32
+  tokens:
+  - type: f32
+    value: 1234.56789
+  operations:
+  - function: push
+    type: f32
+    value: 1234.56789
+  stack_final:
+  - type: f32
+    value: 1234.56789
+- name: Float f32 Max Value
+  code: 3.4028235e+38:f32
+  tokens:
+  - type: f32
+    value: 3.4028235e+38
+  operations:
+  - function: push
+    type: f32
+    value: 3.4028235e+38
+  stack_final:
+  - type: f32
+    value: 3.4028235e+38
+- name: Float f32 Min Value
+  code: -3.4028235e+38:f32
+  tokens:
+  - type: f32
+    value: -3.4028235e+38
+  operations:
+  - function: push
+    type: f32
+    value: -3.4028235e+38
+  stack_final:
+  - type: f32
+    value: -3.4028235e+38
+- name: Float f32 Min Positive
+  code: 1.1754944e-38:f32
+  tokens:
+  - type: f32
+    value: 1.1754944e-38
+  operations:
+  - function: push
+    type: f32
+    value: 1.1754944e-38
+  stack_final:
+  - type: f32
+    value: 1.1754944e-38
+- name: Float f32 Epsilon
+  code: 1.1920929e-07:f32
+  tokens:
+  - type: f32
+    value: 1.1920929e-07
+  operations:
+  - function: push
+    type: f32
+    value: 1.1920929e-07
+  stack_final:
+  - type: f32
+    value: 1.1920929e-07
+- name: Float f32 Near Zero Positive
+  code: 1e-30:f32
+  tokens:
+  - type: f32
+    value: 1.0e-30
+  operations:
+  - function: push
+    type: f32
+    value: 1.0e-30
+  stack_final:
+  - type: f32
+    value: 1.0e-30
+- name: Float f32 Near Zero Negative
+  code: -1e-30:f32
+  tokens:
+  - type: f32
+    value: -1.0e-30
+  operations:
+  - function: push
+    type: f32
+    value: -1.0e-30
+  stack_final:
+  - type: f32
+    value: -1.0e-30
+- name: Float f32 Subnormal
+  code: 1e-40:f32
+  tokens:
+  - type: f32
+    value: 1.0e-40
+  operations:
+  - function: push
+    type: f32
+    value: 1.0e-40
+  stack_final:
+  - type: f32
+    value: 1.0e-40
+- name: Float f64 Max Value
+  code: 1.7976931348623157e+308:f64
+  tokens:
+  - type: f64
+    value: 1.7976931348623157e+308
+  operations:
+  - function: push
+    type: f64
+    value: 1.7976931348623157e+308
+  stack_final:
+  - type: f64
+    value: 1.7976931348623157e+308
+- name: Float f64 Min Value
+  code: -1.7976931348623157e+308:f64
+  tokens:
+  - type: f64
+    value: -1.7976931348623157e+308
+  operations:
+  - function: push
+    type: f64
+    value: -1.7976931348623157e+308
+  stack_final:
+  - type: f64
+    value: -1.7976931348623157e+308
+- name: Float f64 Min Positive
+  code: 2.2250738585072014e-308:f64
+  tokens:
+  - type: f64
+    value: 2.2250738585072014e-308
+  operations:
+  - function: push
+    type: f64
+    value: 2.2250738585072014e-308
+  stack_final:
+  - type: f64
+    value: 2.2250738585072014e-308
+- name: Float f64 Epsilon
+  code: 2.220446049250313e-16:f64
+  tokens:
+  - type: f64
+    value: 2.220446049250313e-16
+  operations:
+  - function: push
+    type: f64
+    value: 2.220446049250313e-16
+  stack_final:
+  - type: f64
+    value: 2.220446049250313e-16
+- name: Float f64 Near Zero Positive
+  code: 1e-30:f64
+  tokens:
+  - type: f64
+    value: 1.0e-30
+  operations:
+  - function: push
+    type: f64
+    value: 1.0e-30
+  stack_final:
+  - type: f64
+    value: 1.0e-30
+- name: Float f64 Near Zero Negative
+  code: -1e-30:f64
+  tokens:
+  - type: f64
+    value: -1.0e-30
+  operations:
+  - function: push
+    type: f64
+    value: -1.0e-30
+  stack_final:
+  - type: f64
+    value: -1.0e-30
+- name: Float f64 Subnormal
+  code: 1e-320:f64
+  tokens:
+  - type: f64
+    value: 1.0e-320
+  operations:
+  - function: push
+    type: f64
+    value: 1.0e-320
+  stack_final:
+  - type: f64
+    value: 1.0e-320
+- name: Float f32 Overflow Positive
+  code: 1e40:f32
+  tokens:
+  - type: error
+    value: 'Float overflow: value exceeds range for f32.'
+- name: Float f32 Overflow Negative
+  code: -1e40:f32
+  tokens:
+  - type: error
+    value: 'Float overflow: value exceeds range for f32.'
+- name: Float f64 Overflow Positive
+  code: 1e310:f64
+  tokens:
+  - type: error
+    value: 'Float overflow: value exceeds range for f64.'
+- name: Float f64 Overflow Negative
+  code: -1e310:f64
+  tokens:
+  - type: error
+    value: 'Float overflow: value exceeds range for f64.'
+- name: Float f32 Precision Limit
+  code: 1.2345678:f32
+  tokens:
+  - type: f32
+    value: 1.2345678
+  operations:
+  - function: push
+    type: f32
+    value: 1.2345678
+  stack_final:
+  - type: f32
+    value: 1.2345678
+- name: Float f32 High Precision
+  code: 3.141592653589793:f32
+  tokens:
+  - type: f32
+    value: 3.141592653589793
+  operations:
+  - function: push
+    type: f32
+    value: 3.141592653589793
+  stack_final:
+  - type: f32
+    value: 3.141592653589793
+- name: Float f64 Precision Limit
+  code: 1.234567890123456:f64
+  tokens:
+  - type: f64
+    value: 1.234567890123456
+  operations:
+  - function: push
+    type: f64
+    value: 1.234567890123456
+  stack_final:
+  - type: f64
+    value: 1.234567890123456
+- name: Float f64 High Precision
+  code: 3.141592653589793238:f64
+  tokens:
+  - type: f64
+    value: 3.141592653589793
+  operations:
+  - function: push
+    type: f64
+    value: 3.141592653589793
+  stack_final:
+  - type: f64
+    value: 3.141592653589793
+- name: Float f64 Close Numbers 1
+  code: 1.0000000000000001:f64
+  tokens:
+  - type: f64
+    value: 1.0
+  operations:
+  - function: push
+    type: f64
+    value: 1.0
+  stack_final:
+  - type: f64
+    value: 1.0
+- name: Float f64 Close Numbers 2
+  code: 1.0000000000000002:f64
+  tokens:
+  - type: f64
+    value: 1.0000000000000002
+  operations:
+  - function: push
+    type: f64
+    value: 1.0000000000000002
+  stack_final:
+  - type: f64
+    value: 1.0000000000000002
+- name: Float Invalid No Decimal Point
+  code: '42'
+  tokens:
+  - type: error
+    value: 'Not a valid float literal: missing decimal point.'
+- name: Float Invalid Multiple Decimal Points
+  code: 3.14.159
+  tokens:
+  - type: error
+    value: 'Invalid float literal: multiple decimal points.'
+- name: Float Invalid Only Decimal Point
+  code: .
+  tokens:
+  - type: error
+    value: 'Invalid float literal: no digits before or after decimal point.'
+- name: Float Invalid Characters
+  code: 3.1a4
+  tokens:
+  - type: error
+    value: 'Invalid float literal: unexpected ''a'' in float.'
+- name: Float Invalid Scientific No Exponent
+  code: 3.14e
+  tokens:
+  - type: error
+    value: 'Invalid float literal: missing exponent value.'
+- name: Float Invalid Scientific Double E
+  code: 3.14e10e5
+  tokens:
+  - type: error
+    value: 'Invalid float literal: multiple exponent markers.'
+- name: Float Invalid Scientific Invalid Exponent
+  code: 3.14eX
+  tokens:
+  - type: error
+    value: 'Invalid float literal: invalid exponent ''X''.'
+- name: Float Invalid Leading Underscore
+  code: _3.14
+  tokens:
+  - type: error
+    value: 'Invalid float literal: leading underscore.'
+- name: Float Invalid Underscore Before Decimal
+  code: '3_.14'
+  tokens:
+  - type: error
+    value: 'Invalid float literal: underscore before decimal point.'
+- name: Float Invalid Underscore After Decimal
+  code: '3._14'
+  tokens:
+  - type: error
+    value: 'Invalid float literal: underscore after decimal point.'
+- name: Float Invalid Type Annotation
+  code: 3.14:i32
+  tokens:
+  - type: error
+    value: 'Type mismatch: float literal cannot be annotated as integer type.'
+- name: Float Invalid Type Name
+  code: 3.14:f16
+  tokens:
+  - type: error
+    value: 'Invalid type annotation: unknown type ''f16''.'
+- name: Float Invalid Comma Separator
+  code: 1,234.56
+  tokens:
+  - type: error
+    value: 'Invalid float literal: unexpected '','' in float.'
+- name: Float Default Leading Whitespace
+  code: '  3.14'
+  tokens:
+  - type: f64
+    value: 3.14
+  operations:
+  - function: push
+    type: f64
+    value: 3.14
+  stack_final:
+  - type: f64
+    value: 3.14
+- name: Float Default Trailing Whitespace
+  code: '3.14  '
+  tokens:
+  - type: f64
+    value: 3.14
+  operations:
+  - function: push
+    type: f64
+    value: 3.14
+  stack_final:
+  - type: f64
+    value: 3.14
+- name: Float Default Both Whitespace
+  code: '  3.14  '
+  tokens:
+  - type: f64
+    value: 3.14
+  operations:
+  - function: push
+    type: f64
+    value: 3.14
+  stack_final:
+  - type: f64
+    value: 3.14
+- name: Float f32 With Whitespace
+  code: '  2.718:f32  '
+  tokens:
+  - type: f32
+    value: 2.718
+  operations:
+  - function: push
+    type: f32
+    value: 2.718
+  stack_final:
+  - type: f32
+    value: 2.718
+- name: Float Default Pi Approximate
+  code: '3.141592653589793'
+  tokens:
+  - type: f64
+    value: 3.141592653589793
+  operations:
+  - function: push
+    type: f64
+    value: 3.141592653589793
+  stack_final:
+  - type: f64
+    value: 3.141592653589793
+- name: Float f32 Pi Approximate
+  code: 3.1415927:f32
+  tokens:
+  - type: f32
+    value: 3.1415927
+  operations:
+  - function: push
+    type: f32
+    value: 3.1415927
+  stack_final:
+  - type: f32
+    value: 3.1415927
+- name: Float Default Euler Approximate
+  code: '2.718281828459045'
+  tokens:
+  - type: f64
+    value: 2.718281828459045
+  operations:
+  - function: push
+    type: f64
+    value: 2.718281828459045
+  stack_final:
+  - type: f64
+    value: 2.718281828459045
+- name: Float f32 Euler Approximate
+  code: 2.7182817:f32
+  tokens:
+  - type: f32
+    value: 2.7182817
+  operations:
+  - function: push
+    type: f32
+    value: 2.7182817
+  stack_final:
+  - type: f32
+    value: 2.7182817
+- name: Float Default Golden Ratio
+  code: '1.618033988749895'
+  tokens:
+  - type: f64
+    value: 1.618033988749895
+  operations:
+  - function: push
+    type: f64
+    value: 1.618033988749895
+  stack_final:
+  - type: f64
+    value: 1.618033988749895
+- name: Float Default Sqrt2
+  code: '1.4142135623730951'
+  tokens:
+  - type: f64
+    value: 1.4142135623730951
+  operations:
+  - function: push
+    type: f64
+    value: 1.4142135623730951
+  stack_final:
+  - type: f64
+    value: 1.4142135623730951
+- name: Float Default Positive Zero
+  code: '0.0'
+  tokens:
+  - type: f64
+    value: 0.0
+  operations:
+  - function: push
+    type: f64
+    value: 0.0
+  stack_final:
+  - type: f64
+    value: 0.0
+- name: Float Default Negative Zero
+  code: '-0.0'
+  tokens:
+  - type: f64
+    value: -0.0
+  operations:
+  - function: push
+    type: f64
+    value: -0.0
+  stack_final:
+  - type: f64
+    value: -0.0
+- name: Float f32 Positive Zero
+  code: 0.0:f32
+  tokens:
+  - type: f32
+    value: 0.0
+  operations:
+  - function: push
+    type: f32
+    value: 0.0
+  stack_final:
+  - type: f32
+    value: 0.0
+- name: Float f32 Negative Zero
+  code: -0.0:f32
+  tokens:
+  - type: f32
+    value: -0.0
+  operations:
+  - function: push
+    type: f32
+    value: -0.0
+  stack_final:
+  - type: f32
+    value: -0.0
+- name: Char Simple Letter A
+  code: '''A'''
+  tokens:
+  - type: char
+    value: A
+  operations:
+  - function: push
+    type: char
+    value: A
+  stack_final:
+  - type: char
+    value: A
+- name: Char Simple Letter a
+  code: '''a'''
+  tokens:
+  - type: char
+    value: a
+  operations:
+  - function: push
+    type: char
+    value: a
+  stack_final:
+  - type: char
+    value: a
+- name: Char Simple Letter Z
+  code: '''Z'''
+  tokens:
+  - type: char
+    value: Z
+  operations:
+  - function: push
+    type: char
+    value: Z
+  stack_final:
+  - type: char
+    value: Z
+- name: Char Simple Letter z
+  code: '''z'''
+  tokens:
+  - type: char
+    value: z
+  operations:
+  - function: push
+    type: char
+    value: z
+  stack_final:
+  - type: char
+    value: z
+- name: Char Digit 0
+  code: '''0'''
+  tokens:
+  - type: char
+    value: '0'
+  operations:
+  - function: push
+    type: char
+    value: '0'
+  stack_final:
+  - type: char
+    value: '0'
+- name: Char Digit 5
+  code: '''5'''
+  tokens:
+  - type: char
+    value: '5'
+  operations:
+  - function: push
+    type: char
+    value: '5'
+  stack_final:
+  - type: char
+    value: '5'
+- name: Char Digit 9
+  code: '''9'''
+  tokens:
+  - type: char
+    value: '9'
+  operations:
+  - function: push
+    type: char
+    value: '9'
+  stack_final:
+  - type: char
+    value: '9'
+- name: Char Space
+  code: ''' '''
+  tokens:
+  - type: char
+    value: ' '
+  operations:
+  - function: push
+    type: char
+    value: ' '
+  stack_final:
+  - type: char
+    value: ' '
+- name: Char Exclamation
+  code: '''!'''
+  tokens:
+  - type: char
+    value: '!'
+  operations:
+  - function: push
+    type: char
+    value: '!'
+  stack_final:
+  - type: char
+    value: '!'
+- name: Char Question Mark
+  code: '''?'''
+  tokens:
+  - type: char
+    value: '?'
+  operations:
+  - function: push
+    type: char
+    value: '?'
+  stack_final:
+  - type: char
+    value: '?'
+- name: Char Period
+  code: '''.'''
+  tokens:
+  - type: char
+    value: .
+  operations:
+  - function: push
+    type: char
+    value: .
+  stack_final:
+  - type: char
+    value: .
+- name: Char Comma
+  code: ''','''
+  tokens:
+  - type: char
+    value: ','
+  operations:
+  - function: push
+    type: char
+    value: ','
+  stack_final:
+  - type: char
+    value: ','
+- name: Char Semicolon
+  code: ''';'''
+  tokens:
+  - type: char
+    value: ;
+  operations:
+  - function: push
+    type: char
+    value: ;
+  stack_final:
+  - type: char
+    value: ;
+- name: Char Colon
+  code: ''':'''
+  tokens:
+  - type: char
+    value: ':'
+  operations:
+  - function: push
+    type: char
+    value: ':'
+  stack_final:
+  - type: char
+    value: ':'
+- name: Char Plus
+  code: '''+'''
+  tokens:
+  - type: char
+    value: +
+  operations:
+  - function: push
+    type: char
+    value: +
+  stack_final:
+  - type: char
+    value: +
+- name: Char Minus
+  code: '''-'''
+  tokens:
+  - type: char
+    value: '-'
+  operations:
+  - function: push
+    type: char
+    value: '-'
+  stack_final:
+  - type: char
+    value: '-'
+- name: Char Asterisk
+  code: '''*'''
+  tokens:
+  - type: char
+    value: '*'
+  operations:
+  - function: push
+    type: char
+    value: '*'
+  stack_final:
+  - type: char
+    value: '*'
+- name: Char Slash
+  code: '''/'''
+  tokens:
+  - type: char
+    value: /
+  operations:
+  - function: push
+    type: char
+    value: /
+  stack_final:
+  - type: char
+    value: /
+- name: Char Equals
+  code: '''='''
+  tokens:
+  - type: char
+    value: '='
+  operations:
+  - function: push
+    type: char
+    value: '='
+  stack_final:
+  - type: char
+    value: '='
+- name: Char Less Than
+  code: '''<'''
+  tokens:
+  - type: char
+    value: <
+  operations:
+  - function: push
+    type: char
+    value: <
+  stack_final:
+  - type: char
+    value: <
+- name: Char Greater Than
+  code: '''>'''
+  tokens:
+  - type: char
+    value: '>'
+  operations:
+  - function: push
+    type: char
+    value: '>'
+  stack_final:
+  - type: char
+    value: '>'
+- name: Char Left Paren
+  code: '''('''
+  tokens:
+  - type: char
+    value: (
+  operations:
+  - function: push
+    type: char
+    value: (
+  stack_final:
+  - type: char
+    value: (
+- name: Char Right Paren
+  code: ''')'''
+  tokens:
+  - type: char
+    value: )
+  operations:
+  - function: push
+    type: char
+    value: )
+  stack_final:
+  - type: char
+    value: )
+- name: Char Left Bracket
+  code: '''['''
+  tokens:
+  - type: char
+    value: '['
+  operations:
+  - function: push
+    type: char
+    value: '['
+  stack_final:
+  - type: char
+    value: '['
+- name: Char Right Bracket
+  code: ''']'''
+  tokens:
+  - type: char
+    value: ']'
+  operations:
+  - function: push
+    type: char
+    value: ']'
+  stack_final:
+  - type: char
+    value: ']'
+- name: Char Left Brace
+  code: '''{'''
+  tokens:
+  - type: char
+    value: '{'
+  operations:
+  - function: push
+    type: char
+    value: '{'
+  stack_final:
+  - type: char
+    value: '{'
+- name: Char Right Brace
+  code: '''}'''
+  tokens:
+  - type: char
+    value: '}'
+  operations:
+  - function: push
+    type: char
+    value: '}'
+  stack_final:
+  - type: char
+    value: '}'
+- name: Char Escape Newline
+  code: '''\n'''
+  tokens:
+  - type: char
+    value: '
+
+      '
+  operations:
+  - function: push
+    type: char
+    value: '
+
+      '
+  stack_final:
+  - type: char
+    value: '
+
+      '
+- name: Char Escape Null character
+  code: '''\0'''
+  tokens:
+  - type: char
+    value: "\0"
+  operations:
+  - function: push
+    type: char
+    value: "\0"
+  stack_final:
+  - type: char
+    value: "\0"
+- name: Char Escape Double quote
+  code: '''\\"'''
+  tokens:
+  - type: char
+    value: '"'
+  operations:
+  - function: push
+    type: char
+    value: '"'
+  stack_final:
+  - type: char
+    value: '"'
+- name: Char Escape Single quote
+  code: '''\'''''
+  tokens:
+  - type: char
+    value: ''''
+  operations:
+  - function: push
+    type: char
+    value: ''''
+  stack_final:
+  - type: char
+    value: ''''
+- name: Char Escape Tab
+  code: '''\t'''
+  tokens:
+  - type: char
+    value: "\t"
+  operations:
+  - function: push
+    type: char
+    value: "\t"
+  stack_final:
+  - type: char
+    value: "\t"
+- name: Char Escape Backslash
+  code: '''\\'''
+  tokens:
+  - type: char
+    value: \
+  operations:
+  - function: push
+    type: char
+    value: \
+  stack_final:
+  - type: char
+    value: \
+- name: Char Escape Carriage return
+  code: '''\r'''
+  tokens:
+  - type: char
+    value: "\r"
+  operations:
+  - function: push
+    type: char
+    value: "\r"
+  stack_final:
+  - type: char
+    value: "\r"
+- name: Char Newline
+  code: '''\n'''
+  tokens:
+  - type: char
+    value: '
+
+      '
+  operations:
+  - function: push
+    type: char
+    value: '
+
+      '
+  stack_final:
+  - type: char
+    value: '
+
+      '
+- name: Char Carriage Return
+  code: '''\r'''
+  tokens:
+  - type: char
+    value: "\r"
+  operations:
+  - function: push
+    type: char
+    value: "\r"
+  stack_final:
+  - type: char
+    value: "\r"
+- name: Char Tab
+  code: '''\t'''
+  tokens:
+  - type: char
+    value: "\t"
+  operations:
+  - function: push
+    type: char
+    value: "\t"
+  stack_final:
+  - type: char
+    value: "\t"
+- name: Char Backslash
+  code: '''\\'''
+  tokens:
+  - type: char
+    value: \
+  operations:
+  - function: push
+    type: char
+    value: \
+  stack_final:
+  - type: char
+    value: \
+- name: Char Double Quote
+  code: '''\\"'''
+  tokens:
+  - type: char
+    value: '"'
+  operations:
+  - function: push
+    type: char
+    value: '"'
+  stack_final:
+  - type: char
+    value: '"'
+- name: Char Single Quote
+  code: '''\'''''
+  tokens:
+  - type: char
+    value: ''''
+  operations:
+  - function: push
+    type: char
+    value: ''''
+  stack_final:
+  - type: char
+    value: ''''
+- name: Char Null
+  code: '''\0'''
+  tokens:
+  - type: char
+    value: "\0"
+  operations:
+  - function: push
+    type: char
+    value: "\0"
+  stack_final:
+  - type: char
+    value: "\0"
+- name: Char Hex Escape \x41
+  code: '''\x41'''
+  tokens:
+  - type: char
+    value: A
+  operations:
+  - function: push
+    type: char
+    value: A
+  stack_final:
+  - type: char
+    value: A
+- name: Char Hex Escape \x61
+  code: '''\x61'''
+  tokens:
+  - type: char
+    value: a
+  operations:
+  - function: push
+    type: char
+    value: a
+  stack_final:
+  - type: char
+    value: a
+- name: Char Hex Escape \x20
+  code: '''\x20'''
+  tokens:
+  - type: char
+    value: ' '
+  operations:
+  - function: push
+    type: char
+    value: ' '
+  stack_final:
+  - type: char
+    value: ' '
+- name: Char Hex Escape \x00
+  code: '''\x00'''
+  tokens:
+  - type: char
+    value: "\0"
+  operations:
+  - function: push
+    type: char
+    value: "\0"
+  stack_final:
+  - type: char
+    value: "\0"
+- name: Char Hex Escape \xFF
+  code: '''\xFF'''
+  tokens:
+  - type: char
+    value: "\xFF"
+  operations:
+  - function: push
+    type: char
+    value: "\xFF"
+  stack_final:
+  - type: char
+    value: "\xFF"
+- name: Char Hex Lowercase A
+  code: '''\x61'''
+  tokens:
+  - type: char
+    value: a
+  operations:
+  - function: push
+    type: char
+    value: a
+  stack_final:
+  - type: char
+    value: a
+- name: Char Hex Uppercase A
+  code: '''\x41'''
+  tokens:
+  - type: char
+    value: A
+  operations:
+  - function: push
+    type: char
+    value: A
+  stack_final:
+  - type: char
+    value: A
+- name: Char Hex Space
+  code: '''\x20'''
+  tokens:
+  - type: char
+    value: ' '
+  operations:
+  - function: push
+    type: char
+    value: ' '
+  stack_final:
+  - type: char
+    value: ' '
+- name: Char Hex Tab
+  code: '''\x09'''
+  tokens:
+  - type: char
+    value: "\t"
+  operations:
+  - function: push
+    type: char
+    value: "\t"
+  stack_final:
+  - type: char
+    value: "\t"
+- name: Char Hex Newline
+  code: '''\x0A'''
+  tokens:
+  - type: char
+    value: '
+
+      '
+  operations:
+  - function: push
+    type: char
+    value: '
+
+      '
+  stack_final:
+  - type: char
+    value: '
+
+      '
+- name: Char Hex Max ASCII
+  code: '''\x7F'''
+  tokens:
+  - type: char
+    value: "\x7F"
+  operations:
+  - function: push
+    type: char
+    value: "\x7F"
+  stack_final:
+  - type: char
+    value: "\x7F"
+- name: Char With Leading Whitespace
+  code: '  ''A'''
+  tokens:
+  - type: char
+    value: A
+  operations:
+  - function: push
+    type: char
+    value: A
+  stack_final:
+  - type: char
+    value: A
+- name: Char With Trailing Whitespace
+  code: '''A''  '
+  tokens:
+  - type: char
+    value: A
+  operations:
+  - function: push
+    type: char
+    value: A
+  stack_final:
+  - type: char
+    value: A
+- name: Char With Both Whitespace
+  code: '  ''A''  '
+  tokens:
+  - type: char
+    value: A
+  operations:
+  - function: push
+    type: char
+    value: A
+  stack_final:
+  - type: char
+    value: A
+- name: Char Tab Before
+  code: \t'B'
+  tokens:
+  - type: char
+    value: B
+  operations:
+  - function: push
+    type: char
+    value: B
+  stack_final:
+  - type: char
+    value: B
+- name: Char Newline Before
+  code: \n'C'
+  tokens:
+  - type: char
+    value: C
+  operations:
+  - function: push
+    type: char
+    value: C
+  stack_final:
+  - type: char
+    value: C
+- name: Char Empty Literal
+  code: ''''''
+  tokens:
+  - type: error
+    value: 'Invalid character literal: empty character literal.'
+- name: Char Multiple Characters
+  code: '''AB'''
+  tokens:
+  - type: error
+    value: 'Invalid character literal: multiple characters without escape sequence.'
+- name: Char Unclosed Quote
+  code: '''A'
+  tokens:
+  - type: error
+    value: 'Invalid character literal: unclosed character literal.'
+- name: Char Unescaped Newline
+  code: '''\n'''
+  tokens:
+  - type: error
+    value: 'Invalid character literal: unescaped newline in character literal.'
+- name: Char Invalid Escape
+  code: '''\q'''
+  tokens:
+  - type: error
+    value: 'Invalid character literal: unknown escape sequence ''\q''.'
+- name: Char Hex Escape Too Short
+  code: '''\x4'''
+  tokens:
+  - type: error
+    value: 'Invalid character literal: hexadecimal escape must have exactly 2 digits.'
+- name: Char Hex Escape Too Long
+  code: '''\x414'''
+  tokens:
+  - type: error
+    value: 'Invalid character literal: hexadecimal escape must have exactly 2 digits.'
+- name: Char Hex Invalid Digit
+  code: '''\\xGG'''
+  tokens:
+  - type: error
+    value: 'Invalid character literal: invalid hexadecimal digit ''G''.'
+- name: Char Double Quotes
+  code: '"A"'
+  tokens:
+  - type: error
+    value: 'Invalid character literal: character literals must use single quotes.'
+- name: Char No Quotes
+  code: A
+  tokens:
+  - type: error
+    value: 'Not a character literal: missing quotes.'
+- name: Char ASCII Control SOH
+  code: '''\x01'''
+  tokens:
+  - type: char
+    value: "\x01"
+  operations:
+  - function: push
+    type: char
+    value: "\x01"
+  stack_final:
+  - type: char
+    value: "\x01"
+- name: Char ASCII Control BEL
+  code: '''\x07'''
+  tokens:
+  - type: char
+    value: "\a"
+  operations:
+  - function: push
+    type: char
+    value: "\a"
+  stack_final:
+  - type: char
+    value: "\a"
+- name: Char ASCII Control ESC
+  code: '''\x1B'''
+  tokens:
+  - type: char
+    value: "\e"
+  operations:
+  - function: push
+    type: char
+    value: "\e"
+  stack_final:
+  - type: char
+    value: "\e"
+- name: Char ASCII Control DEL
+  code: '''\x7F'''
+  tokens:
+  - type: char
+    value: "\x7F"
+  operations:
+  - function: push
+    type: char
+    value: "\x7F"
+  stack_final:
+  - type: char
+    value: "\x7F"
+- name: Char Extended ASCII Lower
+  code: '''\x80'''
+  tokens:
+  - type: char
+    value: "\x80"
+  operations:
+  - function: push
+    type: char
+    value: "\x80"
+  stack_final:
+  - type: char
+    value: "\x80"
+- name: Char Extended ASCII Upper
+  code: '''\xFF'''
+  tokens:
+  - type: char
+    value: "\xFF"
+  operations:
+  - function: push
+    type: char
+    value: "\xFF"
+  stack_final:
+  - type: char
+    value: "\xFF"
+- name: Char Backslash Literal
+  code: '''\\'''
+  tokens:
+  - type: char
+    value: \
+  operations:
+  - function: push
+    type: char
+    value: \
+  stack_final:
+  - type: char
+    value: \
+- name: Char Single Quote Escaped
+  code: '''\'''''
+  tokens:
+  - type: char
+    value: ''''
+  operations:
+  - function: push
+    type: char
+    value: ''''
+  stack_final:
+  - type: char
+    value: ''''
+- name: Char Hex Lowercase x
+  code: '''\x41'''
+  tokens:
+  - type: char
+    value: A
+  operations:
+  - function: push
+    type: char
+    value: A
+  stack_final:
+  - type: char
+    value: A
+- name: Char Hex Digits Uppercase
+  code: '''\xFF'''
+  tokens:
+  - type: char
+    value: "\xFF"
+  operations:
+  - function: push
+    type: char
+    value: "\xFF"
+  stack_final:
+  - type: char
+    value: "\xFF"
+- name: Char Hex Digits Lowercase
+  code: '''\xff'''
+  tokens:
+  - type: char
+    value: "\xFF"
+  operations:
+  - function: push
+    type: char
+    value: "\xFF"
+  stack_final:
+  - type: char
+    value: "\xFF"
+- name: Char Hex Digits Mixed
+  code: '''\xAb'''
+  tokens:
+  - type: char
+    value: "\xAB"
+  operations:
+  - function: push
+    type: char
+    value: "\xAB"
+  stack_final:
+  - type: char
+    value: "\xAB"