Updated test cases

SLS_C/tests/lexer_tests.c

@@ -16,7 +16,7 @@
 #include "tests/tests.h"
 
 
-static const size_t NUM_OF_TESTS = 389;
+static const size_t NUM_OF_TESTS = 368;
 
 static TestResult test_Empty_Statement() {
     LexerTest test = start_up_test(SLS_STR("Empty_Statement"), SLS_STR(""));
@@ -352,46 +352,6 @@ static TestResult test_Integer_i8_Underflow() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Integer_i8_Hex_Max() {
-    LexerTest test = start_up_test(SLS_STR("Integer i8 Hex Max"), SLS_STR("0x7F:i8"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_i8_Binary_Max() {
-    LexerTest test = start_up_test(SLS_STR("Integer i8 Binary Max"), SLS_STR("0b01111111:i8"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_i8_Octal_Max() {
-    LexerTest test = start_up_test(SLS_STR("Integer i8 Octal Max"), SLS_STR("0o177:i8"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_i8_Negative_Hex() {
-    LexerTest test = start_up_test(SLS_STR("Integer i8 Negative Hex"), SLS_STR("-0x80:i8"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, -128})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
 static TestResult test_Integer_i16_Decimal_Positive() {
     LexerTest test = start_up_test(SLS_STR("Integer i16 Decimal Positive"), SLS_STR("42:i16"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -490,36 +450,6 @@ static TestResult test_Integer_i16_Underflow() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Integer_i16_Hex_Sample() {
-    LexerTest test = start_up_test(SLS_STR("Integer i16 Hex Sample"), SLS_STR("0x1234:i16"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 4660})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_i16_Binary_Sample() {
-    LexerTest test = start_up_test(SLS_STR("Integer i16 Binary Sample"), SLS_STR("0b1111111100000000:i16"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 65280})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_i16_Octal_Sample() {
-    LexerTest test = start_up_test(SLS_STR("Integer i16 Octal Sample"), SLS_STR("0o1234:i16"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 668})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
 static TestResult test_Integer_i32_Decimal_Positive() {
     LexerTest test = start_up_test(SLS_STR("Integer i32 Decimal Positive"), SLS_STR("42:i32"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -628,26 +558,6 @@ static TestResult test_Integer_i32_With_Underscores() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Integer_i32_Hex_Sample() {
-    LexerTest test = start_up_test(SLS_STR("Integer i32 Hex Sample"), SLS_STR("0xABCD:i32"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 43981})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_i32_Binary_Sample() {
-    LexerTest test = start_up_test(SLS_STR("Integer i32 Binary Sample"), SLS_STR("0b11110000:i32"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 240})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
 static TestResult test_Integer_i64_Decimal_Positive() {
     LexerTest test = start_up_test(SLS_STR("Integer i64 Decimal Positive"), SLS_STR("42:i64"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -756,46 +666,6 @@ static TestResult test_Integer_i64_With_Underscores() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Integer_i64_Decimal_Positive_42() {
-    LexerTest test = start_up_test(SLS_STR("Integer i64 Decimal Positive 42"), SLS_STR("42:i64"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 42})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_i64_Hex_0xFF() {
-    LexerTest test = start_up_test(SLS_STR("Integer i64 Hex 0xFF"), SLS_STR("0xFF:i64"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 255})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_i64_Binary_0b1010() {
-    LexerTest test = start_up_test(SLS_STR("Integer i64 Binary 0b1010"), SLS_STR("0b1010:i64"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 10})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_i64_Octal_0o755() {
-    LexerTest test = start_up_test(SLS_STR("Integer i64 Octal 0o755"), SLS_STR("0o755:i64"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 493})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
 static TestResult test_Integer_u8_Decimal_Positive() {
     LexerTest test = start_up_test(SLS_STR("Integer u8 Decimal Positive"), SLS_STR("42:u8"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -884,36 +754,6 @@ static TestResult test_Integer_u8_Underflow() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Integer_u8_Hex_Max() {
-    LexerTest test = start_up_test(SLS_STR("Integer u8 Hex Max"), SLS_STR("0xFF:u8"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_u8_Binary_Max() {
-    LexerTest test = start_up_test(SLS_STR("Integer u8 Binary Max"), SLS_STR("0b11111111:u8"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_u8_Octal_Max() {
-    LexerTest test = start_up_test(SLS_STR("Integer u8 Octal Max"), SLS_STR("0o377:u8"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
 static TestResult test_Integer_u16_Decimal_Positive() {
     LexerTest test = start_up_test(SLS_STR("Integer u16 Decimal Positive"), SLS_STR("42:u16"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -1002,46 +842,6 @@ static TestResult test_Integer_u16_Underflow() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Integer_u16_Hex_Max() {
-    LexerTest test = start_up_test(SLS_STR("Integer u16 Hex Max"), SLS_STR("0xFFFF:u16"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_u16_Binary_Max() {
-    LexerTest test = start_up_test(SLS_STR("Integer u16 Binary Max"), SLS_STR("0b1111111111111111:u16"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_u16_Octal_Max() {
-    LexerTest test = start_up_test(SLS_STR("Integer u16 Octal Max"), SLS_STR("0o177777:u16"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_u16_Decimal_Mid() {
-    LexerTest test = start_up_test(SLS_STR("Integer u16 Decimal Mid"), SLS_STR("50000:u16"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 50000})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
 static TestResult test_Integer_u32_Decimal_Positive() {
     LexerTest test = start_up_test(SLS_STR("Integer u32 Decimal Positive"), SLS_STR("42:u32"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -1140,46 +940,6 @@ static TestResult test_Integer_u32_With_Underscores() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Integer_u32_Hex_Max() {
-    LexerTest test = start_up_test(SLS_STR("Integer u32 Hex Max"), SLS_STR("0xFFFFFFFF:u32"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4294967295})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_u32_Binary_Sample() {
-    LexerTest test = start_up_test(SLS_STR("Integer u32 Binary Sample"), SLS_STR("0b11111111000000001111111100000000:u32"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4278255360})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_u32_Octal_Max() {
-    LexerTest test = start_up_test(SLS_STR("Integer u32 Octal Max"), SLS_STR("0o37777777777:u32"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4294967295})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_u32_Decimal_Mid() {
-    LexerTest test = start_up_test(SLS_STR("Integer u32 Decimal Mid"), SLS_STR("1000000:u32"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 1000000})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
 static TestResult test_Integer_u64_Decimal_Positive() {
     LexerTest test = start_up_test(SLS_STR("Integer u64 Decimal Positive"), SLS_STR("42:u64"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -1278,6 +1038,246 @@ static TestResult test_Integer_u64_With_Underscores() {
     return pass_test(&test, result);
 }
 
+static TestResult test_Integer_i8_Hex_Max() {
+    LexerTest test = start_up_test(SLS_STR("Integer i8 Hex Max"), SLS_STR("0x7F:i8"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_i8_Binary_Max() {
+    LexerTest test = start_up_test(SLS_STR("Integer i8 Binary Max"), SLS_STR("0b01111111:i8"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_i8_Octal_Max() {
+    LexerTest test = start_up_test(SLS_STR("Integer i8 Octal Max"), SLS_STR("0o177:i8"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_i8_Negative_Hex() {
+    LexerTest test = start_up_test(SLS_STR("Integer i8 Negative Hex"), SLS_STR("-0x80:i8"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, -128})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_u8_Hex_Max() {
+    LexerTest test = start_up_test(SLS_STR("Integer u8 Hex Max"), SLS_STR("0xFF:u8"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_u8_Binary_Max() {
+    LexerTest test = start_up_test(SLS_STR("Integer u8 Binary Max"), SLS_STR("0b11111111:u8"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_u8_Octal_Max() {
+    LexerTest test = start_up_test(SLS_STR("Integer u8 Octal Max"), SLS_STR("0o377:u8"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_i16_Hex_Sample() {
+    LexerTest test = start_up_test(SLS_STR("Integer i16 Hex Sample"), SLS_STR("0x1234:i16"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 4660})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_i16_Binary_Sample() {
+    LexerTest test = start_up_test(SLS_STR("Integer i16 Binary Sample"), SLS_STR("0b1111111100000000:i16"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, -256})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_i16_Octal_Sample() {
+    LexerTest test = start_up_test(SLS_STR("Integer i16 Octal Sample"), SLS_STR("0o1234:i16"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 668})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_u16_Hex_Max() {
+    LexerTest test = start_up_test(SLS_STR("Integer u16 Hex Max"), SLS_STR("0xFFFF:u16"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_u16_Binary_Max() {
+    LexerTest test = start_up_test(SLS_STR("Integer u16 Binary Max"), SLS_STR("0b1111111111111111:u16"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_u16_Octal_Max() {
+    LexerTest test = start_up_test(SLS_STR("Integer u16 Octal Max"), SLS_STR("0o177777:u16"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_u16_Decimal_Mid() {
+    LexerTest test = start_up_test(SLS_STR("Integer u16 Decimal Mid"), SLS_STR("50000:u16"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 50000})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_i32_Hex_Sample() {
+    LexerTest test = start_up_test(SLS_STR("Integer i32 Hex Sample"), SLS_STR("0xABCD:i32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 43981})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_i32_Binary_Sample() {
+    LexerTest test = start_up_test(SLS_STR("Integer i32 Binary Sample"), SLS_STR("0b11110000:i32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 240})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_u32_Hex_Max() {
+    LexerTest test = start_up_test(SLS_STR("Integer u32 Hex Max"), SLS_STR("0xFFFFFFFF:u32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4294967295})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_u32_Binary_Sample() {
+    LexerTest test = start_up_test(SLS_STR("Integer u32 Binary Sample"), SLS_STR("0b11111111000000001111111100000000:u32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4278255360})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_u32_Octal_Max() {
+    LexerTest test = start_up_test(SLS_STR("Integer u32 Octal Max"), SLS_STR("0o37777777777:u32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4294967295})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_u32_Decimal_Mid() {
+    LexerTest test = start_up_test(SLS_STR("Integer u32 Decimal Mid"), SLS_STR("1000000:u32"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 1000000})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_i64_Decimal_Positive_42() {
+    LexerTest test = start_up_test(SLS_STR("Integer i64 Decimal Positive 42"), SLS_STR("42:i64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 42})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_i64_Hex_0xFF() {
+    LexerTest test = start_up_test(SLS_STR("Integer i64 Hex 0xFF"), SLS_STR("0xFF:i64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 255})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_i64_Binary_0b1010() {
+    LexerTest test = start_up_test(SLS_STR("Integer i64 Binary 0b1010"), SLS_STR("0b1010:i64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 10})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_i64_Octal_0o755() {
+    LexerTest test = start_up_test(SLS_STR("Integer i64 Octal 0o755"), SLS_STR("0o755:i64"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 493})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
 static TestResult test_Integer_u64_Hex_Max() {
     LexerTest test = start_up_test(SLS_STR("Integer u64 Hex Max"), SLS_STR("0xFFFFFFFFFFFFFFFF:u64"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -1659,7 +1659,7 @@ static TestResult test_Float_Invalid_Comma_Separator() {
     LexerResult result = 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;
+    if (test_for_error(&test, result, i++, &SLS_STR("Invalid decimal literal: unexpected ',' in decimal integer."))) return test.result;
     return pass_test(&test, result);
 }
 
@@ -2073,12 +2073,12 @@ static TestResult test_Char_Right_Brace() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Char_Escape_Null_character() {
+static TestResult test_Char_Escape_Backslash() {
-    LexerTest test = start_up_test(SLS_STR("Char Escape Null character"), SLS_STR("'\\0'"));
+    LexerTest test = start_up_test(SLS_STR("Char Escape Backslash"), SLS_STR("'\\\\'"));
     LexerResult result = lexical_analysis(&test.lexer_info);
     if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){0})) return test.result;
+    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);
 }
@@ -2103,26 +2103,6 @@ static TestResult test_Char_Escape_Newline() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Char_Escape_Single_quote() {
-    LexerTest test = start_up_test(SLS_STR("Char Escape Single quote"), SLS_STR("'\\''"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){39})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_Escape_Backslash() {
-    LexerTest test = start_up_test(SLS_STR("Char Escape Backslash"), SLS_STR("'\\\\'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){92})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
 static TestResult test_Char_Escape_Tab() {
     LexerTest test = start_up_test(SLS_STR("Char Escape Tab"), SLS_STR("'\\t'"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -2133,62 +2113,22 @@ static TestResult test_Char_Escape_Tab() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Char_Hex_Lowercase_A() {
+static TestResult test_Char_Escape_Single_quote() {
-    LexerTest test = start_up_test(SLS_STR("Char Hex Lowercase A"), SLS_STR("'\\x61'"));
+    LexerTest test = start_up_test(SLS_STR("Char Escape Single quote"), SLS_STR("'\\''"));
     LexerResult result = lexical_analysis(&test.lexer_info);
     if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){97})) return test.result;
+    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_Uppercase_A() {
+static TestResult test_Char_Escape_Null_character() {
-    LexerTest test = start_up_test(SLS_STR("Char Hex Uppercase A"), SLS_STR("'\\x41'"));
+    LexerTest test = start_up_test(SLS_STR("Char Escape Null character"), SLS_STR("'\\0'"));
     LexerResult result = lexical_analysis(&test.lexer_info);
     if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
+    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_Space() {
-    LexerTest test = start_up_test(SLS_STR("Char Hex Space"), SLS_STR("'\\x20'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){32})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_Hex_Tab() {
-    LexerTest test = start_up_test(SLS_STR("Char Hex Tab"), SLS_STR("'\\x09'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){9})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_Hex_Newline() {
-    LexerTest test = start_up_test(SLS_STR("Char Hex Newline"), SLS_STR("'\\x0A'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){10})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_Hex_Max_ASCII() {
-    LexerTest test = start_up_test(SLS_STR("Char Hex Max ASCII"), SLS_STR("'\\x7F'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){127})) return test.result;
     if (test_eof_value(&test, result, i++, 0)) return test.result;
     return pass_test(&test, result);
 }
@@ -2288,133 +2228,6 @@ static TestResult test_Char_Invalid_Escape() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Char_Hex_Escape_Too_Short() {
-    LexerTest test = start_up_test(SLS_STR("Char Hex Escape Too Short"), SLS_STR("'\\x4'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: hexadecimal escape must have exactly 2 digits."))) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_Hex_Escape_Too_Long() {
-    LexerTest test = start_up_test(SLS_STR("Char Hex Escape Too Long"), SLS_STR("'\\x414'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: hexadecimal escape must have exactly 2 digits."))) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_Hex_Invalid_Digit() {
-    LexerTest test = start_up_test(SLS_STR("Char Hex Invalid Digit"), SLS_STR("'\\xGG'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: invalid hexadecimal digit 'G'."))) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_ASCII_Control_SOH() {
-    LexerTest test = start_up_test(SLS_STR("Char ASCII Control SOH"), SLS_STR("'\\x01'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){1})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_ASCII_Control_BEL() {
-    LexerTest test = start_up_test(SLS_STR("Char ASCII Control BEL"), SLS_STR("'\\x07'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){7})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_ASCII_Control_ESC() {
-    LexerTest test = start_up_test(SLS_STR("Char ASCII Control ESC"), SLS_STR("'\\x1B'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){27})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_ASCII_Control_DEL() {
-    LexerTest test = start_up_test(SLS_STR("Char ASCII Control DEL"), SLS_STR("'\\x7F'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){127})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_Extended_ASCII_Lower() {
-    LexerTest test = start_up_test(SLS_STR("Char Extended ASCII Lower"), SLS_STR("'\\x80'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){128})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_Extended_ASCII_Upper() {
-    LexerTest test = start_up_test(SLS_STR("Char Extended ASCII Upper"), SLS_STR("'\\xFF'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){255})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_Hex_Lowercase_x() {
-    LexerTest test = start_up_test(SLS_STR("Char Hex Lowercase x"), SLS_STR("'\\x41'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_Hex_Digits_Uppercase() {
-    LexerTest test = start_up_test(SLS_STR("Char Hex Digits Uppercase"), SLS_STR("'\\xFF'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){255})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_Hex_Digits_Lowercase() {
-    LexerTest test = start_up_test(SLS_STR("Char Hex Digits Lowercase"), SLS_STR("'\\xff'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){255})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_Hex_Digits_Mixed() {
-    LexerTest test = start_up_test(SLS_STR("Char Hex Digits Mixed"), SLS_STR("'\\xAb'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){171})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
 static TestResult test_Identifier_Simple_Lowercase() {
     LexerTest test = start_up_test(SLS_STR("Identifier Simple Lowercase"), SLS_STR("hello"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -2887,7 +2700,7 @@ static TestResult test_Identifier_Literal_Empty() {
     LexerResult result = 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("Unexpected character: unexpected ':' during parsing."))) return test.result;
+    if (test_for_error(&test, result, i++, &SLS_STR("Invalid identifier literal: empty identifier after '::'."))) return test.result;
     return pass_test(&test, result);
 }
 
@@ -3331,26 +3144,6 @@ static TestResult test_Bool_Numeric_0() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Bool_String_True() {
-    LexerTest test = start_up_test(SLS_STR("Bool String True"), SLS_STR("\"true\""));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_string_value(&test, result, i++, &SLS_STR("true"))) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Bool_String_False() {
-    LexerTest test = start_up_test(SLS_STR("Bool String False"), SLS_STR("\"false\""));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_string_value(&test, result, i++, &SLS_STR("false"))) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
 static TestResult test_Bool_Yes() {
     LexerTest test = start_up_test(SLS_STR("Bool Yes"), SLS_STR("yes"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -3915,10 +3708,6 @@ TestsReport run_lexer_tests() {
     test_report.tests[i++] = test_Integer_i8_Min_Value();
     test_report.tests[i++] = test_Integer_i8_Overflow();
     test_report.tests[i++] = test_Integer_i8_Underflow();
-    test_report.tests[i++] = test_Integer_i8_Hex_Max();
-    test_report.tests[i++] = test_Integer_i8_Binary_Max();
-    test_report.tests[i++] = test_Integer_i8_Octal_Max();
-    test_report.tests[i++] = test_Integer_i8_Negative_Hex();
     test_report.tests[i++] = test_Integer_i16_Decimal_Positive();
     test_report.tests[i++] = test_Integer_i16_Zero();
     test_report.tests[i++] = test_Integer_i16_Decimal_Negative();
@@ -3929,9 +3718,6 @@ TestsReport run_lexer_tests() {
     test_report.tests[i++] = test_Integer_i16_Min_Value();
     test_report.tests[i++] = test_Integer_i16_Overflow();
     test_report.tests[i++] = test_Integer_i16_Underflow();
-    test_report.tests[i++] = test_Integer_i16_Hex_Sample();
-    test_report.tests[i++] = test_Integer_i16_Binary_Sample();
-    test_report.tests[i++] = test_Integer_i16_Octal_Sample();
     test_report.tests[i++] = test_Integer_i32_Decimal_Positive();
     test_report.tests[i++] = test_Integer_i32_Zero();
     test_report.tests[i++] = test_Integer_i32_Decimal_Negative();
@@ -3943,8 +3729,6 @@ TestsReport run_lexer_tests() {
     test_report.tests[i++] = test_Integer_i32_Overflow();
     test_report.tests[i++] = test_Integer_i32_Underflow();
     test_report.tests[i++] = test_Integer_i32_With_Underscores();
-    test_report.tests[i++] = test_Integer_i32_Hex_Sample();
-    test_report.tests[i++] = test_Integer_i32_Binary_Sample();
     test_report.tests[i++] = test_Integer_i64_Decimal_Positive();
     test_report.tests[i++] = test_Integer_i64_Zero();
     test_report.tests[i++] = test_Integer_i64_Decimal_Negative();
@@ -3956,10 +3740,6 @@ TestsReport run_lexer_tests() {
     test_report.tests[i++] = test_Integer_i64_Overflow();
     test_report.tests[i++] = test_Integer_i64_Underflow();
     test_report.tests[i++] = test_Integer_i64_With_Underscores();
-    test_report.tests[i++] = test_Integer_i64_Decimal_Positive_42();
-    test_report.tests[i++] = test_Integer_i64_Hex_0xFF();
-    test_report.tests[i++] = test_Integer_i64_Binary_0b1010();
-    test_report.tests[i++] = test_Integer_i64_Octal_0o755();
     test_report.tests[i++] = test_Integer_u8_Decimal_Positive();
     test_report.tests[i++] = test_Integer_u8_Zero();
     test_report.tests[i++] = test_Integer_u8_Hex();
@@ -3969,9 +3749,6 @@ TestsReport run_lexer_tests() {
     test_report.tests[i++] = test_Integer_u8_Min_Value();
     test_report.tests[i++] = test_Integer_u8_Overflow();
     test_report.tests[i++] = test_Integer_u8_Underflow();
-    test_report.tests[i++] = test_Integer_u8_Hex_Max();
-    test_report.tests[i++] = test_Integer_u8_Binary_Max();
-    test_report.tests[i++] = test_Integer_u8_Octal_Max();
     test_report.tests[i++] = test_Integer_u16_Decimal_Positive();
     test_report.tests[i++] = test_Integer_u16_Zero();
     test_report.tests[i++] = test_Integer_u16_Hex();
@@ -3981,10 +3758,6 @@ TestsReport run_lexer_tests() {
     test_report.tests[i++] = test_Integer_u16_Min_Value();
     test_report.tests[i++] = test_Integer_u16_Overflow();
     test_report.tests[i++] = test_Integer_u16_Underflow();
-    test_report.tests[i++] = test_Integer_u16_Hex_Max();
-    test_report.tests[i++] = test_Integer_u16_Binary_Max();
-    test_report.tests[i++] = test_Integer_u16_Octal_Max();
-    test_report.tests[i++] = test_Integer_u16_Decimal_Mid();
     test_report.tests[i++] = test_Integer_u32_Decimal_Positive();
     test_report.tests[i++] = test_Integer_u32_Zero();
     test_report.tests[i++] = test_Integer_u32_Hex();
@@ -3995,10 +3768,6 @@ TestsReport run_lexer_tests() {
     test_report.tests[i++] = test_Integer_u32_Overflow();
     test_report.tests[i++] = test_Integer_u32_Underflow();
     test_report.tests[i++] = test_Integer_u32_With_Underscores();
-    test_report.tests[i++] = test_Integer_u32_Hex_Max();
-    test_report.tests[i++] = test_Integer_u32_Binary_Sample();
-    test_report.tests[i++] = test_Integer_u32_Octal_Max();
-    test_report.tests[i++] = test_Integer_u32_Decimal_Mid();
     test_report.tests[i++] = test_Integer_u64_Decimal_Positive();
     test_report.tests[i++] = test_Integer_u64_Zero();
     test_report.tests[i++] = test_Integer_u64_Hex();
@@ -4009,6 +3778,30 @@ TestsReport run_lexer_tests() {
     test_report.tests[i++] = test_Integer_u64_Overflow();
     test_report.tests[i++] = test_Integer_u64_Underflow();
     test_report.tests[i++] = test_Integer_u64_With_Underscores();
+    test_report.tests[i++] = test_Integer_i8_Hex_Max();
+    test_report.tests[i++] = test_Integer_i8_Binary_Max();
+    test_report.tests[i++] = test_Integer_i8_Octal_Max();
+    test_report.tests[i++] = test_Integer_i8_Negative_Hex();
+    test_report.tests[i++] = test_Integer_u8_Hex_Max();
+    test_report.tests[i++] = test_Integer_u8_Binary_Max();
+    test_report.tests[i++] = test_Integer_u8_Octal_Max();
+    test_report.tests[i++] = test_Integer_i16_Hex_Sample();
+    test_report.tests[i++] = test_Integer_i16_Binary_Sample();
+    test_report.tests[i++] = test_Integer_i16_Octal_Sample();
+    test_report.tests[i++] = test_Integer_u16_Hex_Max();
+    test_report.tests[i++] = test_Integer_u16_Binary_Max();
+    test_report.tests[i++] = test_Integer_u16_Octal_Max();
+    test_report.tests[i++] = test_Integer_u16_Decimal_Mid();
+    test_report.tests[i++] = test_Integer_i32_Hex_Sample();
+    test_report.tests[i++] = test_Integer_i32_Binary_Sample();
+    test_report.tests[i++] = test_Integer_u32_Hex_Max();
+    test_report.tests[i++] = test_Integer_u32_Binary_Sample();
+    test_report.tests[i++] = test_Integer_u32_Octal_Max();
+    test_report.tests[i++] = test_Integer_u32_Decimal_Mid();
+    test_report.tests[i++] = test_Integer_i64_Decimal_Positive_42();
+    test_report.tests[i++] = test_Integer_i64_Hex_0xFF();
+    test_report.tests[i++] = test_Integer_i64_Binary_0b1010();
+    test_report.tests[i++] = test_Integer_i64_Octal_0o755();
     test_report.tests[i++] = test_Integer_u64_Hex_Max();
     test_report.tests[i++] = test_Integer_u64_Binary_Sample();
     test_report.tests[i++] = test_Integer_u64_Octal_Sample();
@@ -4089,18 +3882,12 @@ TestsReport run_lexer_tests() {
     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_Null_character();
+    test_report.tests[i++] = test_Char_Escape_Backslash();
     test_report.tests[i++] = test_Char_Escape_Carriage_return();
     test_report.tests[i++] = test_Char_Escape_Newline();
-    test_report.tests[i++] = test_Char_Escape_Single_quote();
-    test_report.tests[i++] = test_Char_Escape_Backslash();
     test_report.tests[i++] = test_Char_Escape_Tab();
-    test_report.tests[i++] = test_Char_Hex_Lowercase_A();
+    test_report.tests[i++] = test_Char_Escape_Single_quote();
-    test_report.tests[i++] = test_Char_Hex_Uppercase_A();
+    test_report.tests[i++] = test_Char_Escape_Null_character();
-    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();
@@ -4111,19 +3898,6 @@ TestsReport run_lexer_tests() {
     test_report.tests[i++] = test_Char_Unclosed_Quote();
     test_report.tests[i++] = test_Char_Unescaped_Newline();
     test_report.tests[i++] = test_Char_Invalid_Escape();
-    test_report.tests[i++] = test_Char_Hex_Escape_Too_Short();
-    test_report.tests[i++] = test_Char_Hex_Escape_Too_Long();
-    test_report.tests[i++] = test_Char_Hex_Invalid_Digit();
-    test_report.tests[i++] = test_Char_ASCII_Control_SOH();
-    test_report.tests[i++] = test_Char_ASCII_Control_BEL();
-    test_report.tests[i++] = test_Char_ASCII_Control_ESC();
-    test_report.tests[i++] = test_Char_ASCII_Control_DEL();
-    test_report.tests[i++] = test_Char_Extended_ASCII_Lower();
-    test_report.tests[i++] = test_Char_Extended_ASCII_Upper();
-    test_report.tests[i++] = test_Char_Hex_Lowercase_x();
-    test_report.tests[i++] = test_Char_Hex_Digits_Uppercase();
-    test_report.tests[i++] = test_Char_Hex_Digits_Lowercase();
-    test_report.tests[i++] = test_Char_Hex_Digits_Mixed();
     test_report.tests[i++] = test_Identifier_Simple_Lowercase();
     test_report.tests[i++] = test_Identifier_Simple_Uppercase();
     test_report.tests[i++] = test_Identifier_Mixed_Case();
@@ -4216,8 +3990,6 @@ TestsReport run_lexer_tests() {
     test_report.tests[i++] = test_Bool_False_Mixed_Case();
     test_report.tests[i++] = test_Bool_Numeric_1();
     test_report.tests[i++] = test_Bool_Numeric_0();
-    test_report.tests[i++] = test_Bool_String_True();
-    test_report.tests[i++] = test_Bool_String_False();
     test_report.tests[i++] = test_Bool_Yes();
     test_report.tests[i++] = test_Bool_No();
     test_report.tests[i++] = test_Bool_Typo_Ture();

SLS_Tests/cases.yaml

@@ -362,54 +362,6 @@
   tokens:
   - type: error
     value: 'Integer overflow: value exceeds range for i8.'
-- name: Integer i8 Hex Max
-  code: 0x7F:i8
-  tokens:
-  - type: i8
-    value: 127
-  operations:
-  - function: push
-    type: i8
-    value: 127
-  stack_final:
-  - type: i8
-    value: 127
-- name: Integer i8 Binary Max
-  code: 0b01111111:i8
-  tokens:
-  - type: i8
-    value: 127
-  operations:
-  - function: push
-    type: i8
-    value: 127
-  stack_final:
-  - type: i8
-    value: 127
-- name: Integer i8 Octal Max
-  code: 0o177:i8
-  tokens:
-  - type: i8
-    value: 127
-  operations:
-  - function: push
-    type: i8
-    value: 127
-  stack_final:
-  - type: i8
-    value: 127
-- name: Integer i8 Negative Hex
-  code: -0x80:i8
-  tokens:
-  - type: i8
-    value: -128
-  operations:
-  - function: push
-    type: i8
-    value: -128
-  stack_final:
-  - type: i8
-    value: -128
 - name: Integer i16 Decimal Positive
   code: 42:i16
   tokens:
@@ -516,42 +468,6 @@
   tokens:
   - type: error
     value: 'Integer overflow: value exceeds range for i16.'
-- name: Integer i16 Hex Sample
-  code: 0x1234:i16
-  tokens:
-  - type: i16
-    value: 4660
-  operations:
-  - function: push
-    type: i16
-    value: 4660
-  stack_final:
-  - type: i16
-    value: 4660
-- name: Integer i16 Binary Sample
-  code: 0b1111111100000000:i16
-  tokens:
-  - type: i16
-    value: 65280
-  operations:
-  - function: push
-    type: i16
-    value: 65280
-  stack_final:
-  - type: i16
-    value: 65280
-- name: Integer i16 Octal Sample
-  code: 0o1234:i16
-  tokens:
-  - type: i16
-    value: 668
-  operations:
-  - function: push
-    type: i16
-    value: 668
-  stack_final:
-  - type: i16
-    value: 668
 - name: Integer i32 Decimal Positive
   code: 42:i32
   tokens:
@@ -670,30 +586,6 @@
   stack_final:
   - type: i32
     value: 1000000
-- name: Integer i32 Hex Sample
-  code: 0xABCD:i32
-  tokens:
-  - type: i32
-    value: 43981
-  operations:
-  - function: push
-    type: i32
-    value: 43981
-  stack_final:
-  - type: i32
-    value: 43981
-- name: Integer i32 Binary Sample
-  code: 0b11110000:i32
-  tokens:
-  - type: i32
-    value: 240
-  operations:
-  - function: push
-    type: i32
-    value: 240
-  stack_final:
-  - type: i32
-    value: 240
 - name: Integer i64 Decimal Positive
   code: 42:i64
   tokens:
@@ -812,54 +704,6 @@
   stack_final:
   - type: i64
     value: 1000000
-- name: Integer i64 Decimal Positive 42
-  code: 42:i64
-  tokens:
-  - type: i64
-    value: 42
-  operations:
-  - function: push
-    type: i64
-    value: 42
-  stack_final:
-  - type: i64
-    value: 42
-- name: Integer i64 Hex 0xFF
-  code: 0xFF:i64
-  tokens:
-  - type: i64
-    value: 255
-  operations:
-  - function: push
-    type: i64
-    value: 255
-  stack_final:
-  - type: i64
-    value: 255
-- name: Integer i64 Binary 0b1010
-  code: 0b1010:i64
-  tokens:
-  - type: i64
-    value: 10
-  operations:
-  - function: push
-    type: i64
-    value: 10
-  stack_final:
-  - type: i64
-    value: 10
-- name: Integer i64 Octal 0o755
-  code: 0o755:i64
-  tokens:
-  - type: i64
-    value: 493
-  operations:
-  - function: push
-    type: i64
-    value: 493
-  stack_final:
-  - type: i64
-    value: 493
 - name: Integer u8 Decimal Positive
   code: 42:u8
   tokens:
@@ -954,42 +798,6 @@
   tokens:
   - type: error
     value: 'Integer overflow: value exceeds range for u8.'
-- name: Integer u8 Hex Max
-  code: 0xFF:u8
-  tokens:
-  - type: u8
-    value: 255
-  operations:
-  - function: push
-    type: u8
-    value: 255
-  stack_final:
-  - type: u8
-    value: 255
-- name: Integer u8 Binary Max
-  code: 0b11111111:u8
-  tokens:
-  - type: u8
-    value: 255
-  operations:
-  - function: push
-    type: u8
-    value: 255
-  stack_final:
-  - type: u8
-    value: 255
-- name: Integer u8 Octal Max
-  code: 0o377:u8
-  tokens:
-  - type: u8
-    value: 255
-  operations:
-  - function: push
-    type: u8
-    value: 255
-  stack_final:
-  - type: u8
-    value: 255
 - name: Integer u16 Decimal Positive
   code: 42:u16
   tokens:
@@ -1084,54 +892,6 @@
   tokens:
   - type: error
     value: 'Integer overflow: value exceeds range for u16.'
-- name: Integer u16 Hex Max
-  code: 0xFFFF:u16
-  tokens:
-  - type: u16
-    value: 65535
-  operations:
-  - function: push
-    type: u16
-    value: 65535
-  stack_final:
-  - type: u16
-    value: 65535
-- name: Integer u16 Binary Max
-  code: 0b1111111111111111:u16
-  tokens:
-  - type: u16
-    value: 65535
-  operations:
-  - function: push
-    type: u16
-    value: 65535
-  stack_final:
-  - type: u16
-    value: 65535
-- name: Integer u16 Octal Max
-  code: 0o177777:u16
-  tokens:
-  - type: u16
-    value: 65535
-  operations:
-  - function: push
-    type: u16
-    value: 65535
-  stack_final:
-  - type: u16
-    value: 65535
-- name: Integer u16 Decimal Mid
-  code: 50000:u16
-  tokens:
-  - type: u16
-    value: 50000
-  operations:
-  - function: push
-    type: u16
-    value: 50000
-  stack_final:
-  - type: u16
-    value: 50000
 - name: Integer u32 Decimal Positive
   code: 42:u32
   tokens:
@@ -1238,54 +998,6 @@
   stack_final:
   - type: u32
     value: 1000000
-- name: Integer u32 Hex Max
-  code: 0xFFFFFFFF:u32
-  tokens:
-  - type: u32
-    value: 4294967295
-  operations:
-  - function: push
-    type: u32
-    value: 4294967295
-  stack_final:
-  - type: u32
-    value: 4294967295
-- name: Integer u32 Binary Sample
-  code: 0b11111111000000001111111100000000:u32
-  tokens:
-  - type: u32
-    value: 4278255360
-  operations:
-  - function: push
-    type: u32
-    value: 4278255360
-  stack_final:
-  - type: u32
-    value: 4278255360
-- name: Integer u32 Octal Max
-  code: 0o37777777777:u32
-  tokens:
-  - type: u32
-    value: 4294967295
-  operations:
-  - function: push
-    type: u32
-    value: 4294967295
-  stack_final:
-  - type: u32
-    value: 4294967295
-- name: Integer u32 Decimal Mid
-  code: 1000000:u32
-  tokens:
-  - type: u32
-    value: 1000000
-  operations:
-  - function: push
-    type: u32
-    value: 1000000
-  stack_final:
-  - type: u32
-    value: 1000000
 - name: Integer u64 Decimal Positive
   code: 42:u64
   tokens:
@@ -1392,6 +1104,294 @@
   stack_final:
   - type: u64
     value: 1000000
+- name: Integer i8 Hex Max
+  code: 0x7F:i8
+  tokens:
+  - type: i8
+    value: 127
+  operations:
+  - function: push
+    type: i8
+    value: 127
+  stack_final:
+  - type: i8
+    value: 127
+- name: Integer i8 Binary Max
+  code: 0b01111111:i8
+  tokens:
+  - type: i8
+    value: 127
+  operations:
+  - function: push
+    type: i8
+    value: 127
+  stack_final:
+  - type: i8
+    value: 127
+- name: Integer i8 Octal Max
+  code: 0o177:i8
+  tokens:
+  - type: i8
+    value: 127
+  operations:
+  - function: push
+    type: i8
+    value: 127
+  stack_final:
+  - type: i8
+    value: 127
+- name: Integer i8 Negative Hex
+  code: -0x80:i8
+  tokens:
+  - type: i8
+    value: -128
+  operations:
+  - function: push
+    type: i8
+    value: -128
+  stack_final:
+  - type: i8
+    value: -128
+- name: Integer u8 Hex Max
+  code: 0xFF:u8
+  tokens:
+  - type: u8
+    value: 255
+  operations:
+  - function: push
+    type: u8
+    value: 255
+  stack_final:
+  - type: u8
+    value: 255
+- name: Integer u8 Binary Max
+  code: 0b11111111:u8
+  tokens:
+  - type: u8
+    value: 255
+  operations:
+  - function: push
+    type: u8
+    value: 255
+  stack_final:
+  - type: u8
+    value: 255
+- name: Integer u8 Octal Max
+  code: 0o377:u8
+  tokens:
+  - type: u8
+    value: 255
+  operations:
+  - function: push
+    type: u8
+    value: 255
+  stack_final:
+  - type: u8
+    value: 255
+- name: Integer i16 Hex Sample
+  code: 0x1234:i16
+  tokens:
+  - type: i16
+    value: 4660
+  operations:
+  - function: push
+    type: i16
+    value: 4660
+  stack_final:
+  - type: i16
+    value: 4660
+- name: Integer i16 Binary Sample
+  code: 0b1111111100000000:i16
+  tokens:
+  - type: i16
+    value: -256
+  operations:
+  - function: push
+    type: i16
+    value: -256
+  stack_final:
+  - type: i16
+    value: -256
+- name: Integer i16 Octal Sample
+  code: 0o1234:i16
+  tokens:
+  - type: i16
+    value: 668
+  operations:
+  - function: push
+    type: i16
+    value: 668
+  stack_final:
+  - type: i16
+    value: 668
+- name: Integer u16 Hex Max
+  code: 0xFFFF:u16
+  tokens:
+  - type: u16
+    value: 65535
+  operations:
+  - function: push
+    type: u16
+    value: 65535
+  stack_final:
+  - type: u16
+    value: 65535
+- name: Integer u16 Binary Max
+  code: 0b1111111111111111:u16
+  tokens:
+  - type: u16
+    value: 65535
+  operations:
+  - function: push
+    type: u16
+    value: 65535
+  stack_final:
+  - type: u16
+    value: 65535
+- name: Integer u16 Octal Max
+  code: 0o177777:u16
+  tokens:
+  - type: u16
+    value: 65535
+  operations:
+  - function: push
+    type: u16
+    value: 65535
+  stack_final:
+  - type: u16
+    value: 65535
+- name: Integer u16 Decimal Mid
+  code: 50000:u16
+  tokens:
+  - type: u16
+    value: 50000
+  operations:
+  - function: push
+    type: u16
+    value: 50000
+  stack_final:
+  - type: u16
+    value: 50000
+- name: Integer i32 Hex Sample
+  code: 0xABCD:i32
+  tokens:
+  - type: i32
+    value: 43981
+  operations:
+  - function: push
+    type: i32
+    value: 43981
+  stack_final:
+  - type: i32
+    value: 43981
+- name: Integer i32 Binary Sample
+  code: 0b11110000:i32
+  tokens:
+  - type: i32
+    value: 240
+  operations:
+  - function: push
+    type: i32
+    value: 240
+  stack_final:
+  - type: i32
+    value: 240
+- name: Integer u32 Hex Max
+  code: 0xFFFFFFFF:u32
+  tokens:
+  - type: u32
+    value: 4294967295
+  operations:
+  - function: push
+    type: u32
+    value: 4294967295
+  stack_final:
+  - type: u32
+    value: 4294967295
+- name: Integer u32 Binary Sample
+  code: 0b11111111000000001111111100000000:u32
+  tokens:
+  - type: u32
+    value: 4278255360
+  operations:
+  - function: push
+    type: u32
+    value: 4278255360
+  stack_final:
+  - type: u32
+    value: 4278255360
+- name: Integer u32 Octal Max
+  code: 0o37777777777:u32
+  tokens:
+  - type: u32
+    value: 4294967295
+  operations:
+  - function: push
+    type: u32
+    value: 4294967295
+  stack_final:
+  - type: u32
+    value: 4294967295
+- name: Integer u32 Decimal Mid
+  code: 1000000:u32
+  tokens:
+  - type: u32
+    value: 1000000
+  operations:
+  - function: push
+    type: u32
+    value: 1000000
+  stack_final:
+  - type: u32
+    value: 1000000
+- name: Integer i64 Decimal Positive 42
+  code: 42:i64
+  tokens:
+  - type: i64
+    value: 42
+  operations:
+  - function: push
+    type: i64
+    value: 42
+  stack_final:
+  - type: i64
+    value: 42
+- name: Integer i64 Hex 0xFF
+  code: 0xFF:i64
+  tokens:
+  - type: i64
+    value: 255
+  operations:
+  - function: push
+    type: i64
+    value: 255
+  stack_final:
+  - type: i64
+    value: 255
+- name: Integer i64 Binary 0b1010
+  code: 0b1010:i64
+  tokens:
+  - type: i64
+    value: 10
+  operations:
+  - function: push
+    type: i64
+    value: 10
+  stack_final:
+  - type: i64
+    value: 10
+- name: Integer i64 Octal 0o755
+  code: 0o755:i64
+  tokens:
+  - type: i64
+    value: 493
+  operations:
+  - function: push
+    type: i64
+    value: 493
+  stack_final:
+  - type: i64
+    value: 493
 - name: Integer u64 Hex Max
   code: 0xFFFFFFFFFFFFFFFF:u64
   tokens:
@@ -1824,7 +1824,7 @@
   code: 1,234.56
   tokens:
   - type: error
-    value: 'Invalid float literal: unexpected '','' in float.'
+    value: 'Invalid decimal literal: unexpected '','' in decimal integer.'
 - name: Float Default Leading Whitespace
   code: '  3.14'
   tokens:
@@ -2317,18 +2317,18 @@
   stack_final:
   - type: char
     value: '}'
-- name: Char Escape Null character
+- name: Char Escape Backslash
-  code: '''\\0'''
+  code: '''\\\\'''
   tokens:
   - type: char
-    value: "\0"
+    value: \
   operations:
   - function: push
     type: char
-    value: "\0"
+    value: \
   stack_final:
   - type: char
-    value: "\0"
+    value: \
 - name: Char Escape Carriage return
   code: '''\\r'''
   tokens:
@@ -2359,30 +2359,6 @@
     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 Backslash
-  code: '''\\\\'''
-  tokens:
-  - type: char
-    value: \
-  operations:
-  - function: push
-    type: char
-    value: \
-  stack_final:
-  - type: char
-    value: \
 - name: Char Escape Tab
   code: '''\\t'''
   tokens:
@@ -2395,84 +2371,30 @@
   stack_final:
   - type: char
     value: "\t"
-- name: Char Hex Lowercase A
+- name: Char Escape Single quote
-  code: '''\\x61'''
+  code: '''\\'''''
   tokens:
   - type: char
-    value: a
+    value: ''''
   operations:
   - function: push
     type: char
-    value: a
+    value: ''''
   stack_final:
   - type: char
-    value: a
+    value: ''''
-- name: Char Hex Uppercase A
+- name: Char Escape Null character
-  code: '''\\x41'''
+  code: '''\\0'''
   tokens:
   - type: char
-    value: A
+    value: "\0"
   operations:
   - function: push
     type: char
-    value: A
+    value: "\0"
   stack_final:
   - type: char
-    value: A
+    value: "\0"
-- 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:
@@ -2558,141 +2480,6 @@
   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 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 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"
 - name: Identifier Simple Lowercase
   code: hello
   tokens:
@@ -3240,7 +3027,7 @@
   code: '::'
   tokens:
   - type: error
-    value: 'Unexpected character: unexpected '':'' during parsing.'
+    value: 'Invalid identifier literal: empty identifier after ''::''.'
 - name: Identifier Case Lower
   code: variable
   tokens:
@@ -3769,30 +3556,6 @@
   stack_final:
   - type: i64
     value: 0
-- name: Bool String True
-  code: '"true"'
-  tokens:
-  - type: string
-    value: 'true'
-  operations:
-  - function: push
-    type: string
-    value: 'true'
-  stack_final:
-  - type: string
-    value: 'true'
-- name: Bool String False
-  code: '"false"'
-  tokens:
-  - type: string
-    value: 'false'
-  operations:
-  - function: push
-    type: string
-    value: 'false'
-  stack_final:
-  - type: string
-    value: 'false'
 - name: Bool Yes
   code: 'yes'
   tokens:

SLS_Tests/generate_tests/base_tests.py

@@ -54,6 +54,7 @@ class BaseTestGenerator(ABC):
 
     ENABLE_UNICODE = False
     ENABLE_EXPONENTIAL_LITERALS = False
+    ENABLE_CHAR_HEX_ESCAPE = False
     ENABLE_STRINGS = False
 
     __generators: "ClassVar[List[Type[BaseTestGenerator]]]" = []

SLS_Tests/generate_tests/char_tests.py

@@ -74,13 +74,14 @@ class CharTestGenerator(BaseTestGenerator):
     
     def generate_hexadecimal_escape_tests(self):
         """Generate tests for hexadecimal escape sequences."""
-        # Additional specific hex escapes
+        if self.ENABLE_CHAR_HEX_ESCAPE:
-        self.make_success_test("Char Hex Lowercase A", "'\\\\x61'", "char", 'a')
+            # Additional specific hex escapes
-        self.make_success_test("Char Hex Uppercase A", "'\\\\x41'", "char", 'A')
+            self.make_success_test("Char Hex Lowercase A", "'\\\\x61'", "char", 'a')
-        self.make_success_test("Char Hex Space", "'\\\\x20'", "char", ' ')
+            self.make_success_test("Char Hex Uppercase A", "'\\\\x41'", "char", 'A')
-        self.make_success_test("Char Hex Tab", "'\\\\x09'", "char", '\t')
+            self.make_success_test("Char Hex Space", "'\\\\x20'", "char", ' ')
-        self.make_success_test("Char Hex Newline", "'\\\\x0A'", "char", '\n')
+            self.make_success_test("Char Hex Tab", "'\\\\x09'", "char", '\t')
-        self.make_success_test("Char Hex Max ASCII", "'\\\\x7F'", "char", '\x7F')
+            self.make_success_test("Char Hex Newline", "'\\\\x0A'", "char", '\n')
+            self.make_success_test("Char Hex Max ASCII", "'\\\\x7F'", "char", '\x7F')
     
     def generate_unicode_escape_tests(self):
         """Generate tests for Unicode escape sequences."""
@@ -165,18 +166,19 @@ class CharTestGenerator(BaseTestGenerator):
                            "Invalid character literal: unknown escape sequence '\\\\q'.")
         
         # Invalid hex escape (not 2 digits)
-        self.make_error_test("Char Hex Escape Too Short",
+        if self.ENABLE_CHAR_HEX_ESCAPE:
-                           "'\\\\x4'",
+            self.make_error_test("Char Hex Escape Too Short",
-                           "Invalid character literal: hexadecimal escape must have exactly 2 digits.")
+                            "'\\\\x4'",
+                            "Invalid character literal: hexadecimal escape must have exactly 2 digits.")
             
-        self.make_error_test("Char Hex Escape Too Long",
+            self.make_error_test("Char Hex Escape Too Long",
-                           "'\\\\x414'",
+                            "'\\\\x414'",
-                           "Invalid character literal: hexadecimal escape must have exactly 2 digits.")
+                            "Invalid character literal: hexadecimal escape must have exactly 2 digits.")
             
-        # Invalid hex digits
+            # Invalid hex digits
-        self.make_error_test("Char Hex Invalid Digit",
+            self.make_error_test("Char Hex Invalid Digit",
-                           "'\\\\xGG'",
+                            "'\\\\xGG'",
-                           "Invalid character literal: invalid hexadecimal digit 'G'.")
+                            "Invalid character literal: invalid hexadecimal digit 'G'.")
         
         if self.ENABLE_UNICODE:
             # Invalid Unicode escape (no braces)
@@ -215,15 +217,16 @@ class CharTestGenerator(BaseTestGenerator):
     
     def generate_edge_case_tests(self):
         """Generate edge case tests."""
-        # ASCII control characters
+        if self.ENABLE_CHAR_HEX_ESCAPE:
-        self.make_success_test("Char ASCII Control SOH", "'\\\\x01'", "char", '\x01')
+            # ASCII control characters
-        self.make_success_test("Char ASCII Control BEL", "'\\\\x07'", "char", '\x07')
+            self.make_success_test("Char ASCII Control SOH", "'\\\\x01'", "char", '\x01')
-        self.make_success_test("Char ASCII Control ESC", "'\\\\x1B'", "char", '\x1B')
+            self.make_success_test("Char ASCII Control BEL", "'\\\\x07'", "char", '\x07')
-        self.make_success_test("Char ASCII Control DEL", "'\\\\x7F'", "char", '\x7F')
+            self.make_success_test("Char ASCII Control ESC", "'\\\\x1B'", "char", '\x1B')
+            self.make_success_test("Char ASCII Control DEL", "'\\\\x7F'", "char", '\x7F')
             
-        # Extended ASCII
+            # Extended ASCII
-        self.make_success_test("Char Extended ASCII Lower", "'\\\\x80'", "char", '\x80')
+            self.make_success_test("Char Extended ASCII Lower", "'\\\\x80'", "char", '\x80')
-        self.make_success_test("Char Extended ASCII Upper", "'\\\\xFF'", "char", '\xFF')
+            self.make_success_test("Char Extended ASCII Upper", "'\\\\xFF'", "char", '\xFF')
         
         if self.ENABLE_UNICODE:
             # Zero-width characters
@@ -245,13 +248,14 @@ class CharTestGenerator(BaseTestGenerator):
     
     def generate_case_sensitivity_tests(self):
         """Generate tests for case sensitivity in escape sequences."""
-        # Hex escapes - lowercase x
+        if self.ENABLE_CHAR_HEX_ESCAPE:
-        self.make_success_test("Char Hex Lowercase x", "'\\\\x41'", "char", 'A')
+            # Hex escapes - lowercase x
+            self.make_success_test("Char Hex Lowercase x", "'\\\\x41'", "char", 'A')
             
-        # Hex digits - both cases
+            # Hex digits - both cases
-        self.make_success_test("Char Hex Digits Uppercase", "'\\\\xFF'", "char", '\xFF')
+            self.make_success_test("Char Hex Digits Uppercase", "'\\\\xFF'", "char", '\xFF')
-        self.make_success_test("Char Hex Digits Lowercase", "'\\\\xff'", "char", '\xff')
+            self.make_success_test("Char Hex Digits Lowercase", "'\\\\xff'", "char", '\xff')
-        self.make_success_test("Char Hex Digits Mixed", "'\\\\xAb'", "char", '\xAB')
+            self.make_success_test("Char Hex Digits Mixed", "'\\\\xAb'", "char", '\xAB')
         
         if self.ENABLE_UNICODE:
             # Unicode escapes - lowercase u

SLS_Tests/generate_tests/float_tests.py

@@ -221,7 +221,7 @@ class FloatTestGenerator(BaseTestGenerator):
         # Comma separators not allowed
         self.make_error_test("Float Invalid Comma Separator",
                            "1,234.56",
-                           "Invalid float literal: unexpected ',' in float.")
+                           "Invalid decimal literal: unexpected ',' in decimal integer.")
 
     def generate_whitespace_tests(self):
         """Generate tests with whitespace."""

SLS_Tests/generate_tests/idents_and_bools_tests.py

@@ -210,7 +210,7 @@ class IdentifierTestGenerator(BaseTestGenerator):
         # Empty identifier literal
         self.make_error_test("Identifier Literal Empty",
                            "::",
-                           "Unexpected character: unexpected ':' during parsing.")
+                           "Invalid identifier literal: empty identifier after '::'.")
     
     def generate_case_sensitivity_tests(self):
         """Generate tests showing case sensitivity."""
@@ -322,11 +322,12 @@ class BooleanTestGenerator(BaseTestGenerator):
         self.make_success_test("Bool Numeric 0", "0", "i64", 0)
         
         # String representations
-        self.make_success_test("Bool String True", '"true"',
+        if self.ENABLE_STRINGS:
-                           "string", "true")
+            self.make_success_test("Bool String True", '"true"',
+                            "string", "true")
             
-        self.make_success_test("Bool String False", '"false"',
+            self.make_success_test("Bool String False", '"false"',
-                           "string", "false")
+                            "string", "false")
         
         # Other languages
         self.make_success_test("Bool Yes", "yes",

SLS_Tests/generate_tests/integer_tests.py

@@ -141,69 +141,59 @@ class IntegerTestGenerator(BaseTestGenerator):
                            f"{underflow_val}:{type_name}",
                            f"Integer overflow: value exceeds range for {type_name}.")
 
-    def generate_special_typed_tests(self, type_name: str):
-        """Generate special tests for specific types."""
-        min_val, max_val = self.TYPE_RANGES[type_name]
-        is_unsigned = type_name.startswith('u')
-
         # Underscores with type annotation
-        if max_val >= 1000000:
+        if max_range >= 1000000:
             self.make_success_test(f"Integer {type_name} With Underscores",
                                   f"1_000_000:{type_name}", type_name, 1000000)
 
+    def generate_special_typed_tests(self):
+        """Generate special tests for specific types."""
+
         # Special values for specific types
-        if type_name == 'i8':
+        self.make_success_test("Integer i8 Hex Max", "0x7F:i8", "i8", 127)
-            self.make_success_test("Integer i8 Hex Max", "0x7F:i8", "i8", 127)
+        self.make_success_test("Integer i8 Binary Max", "0b01111111:i8", "i8", 127)
-            self.make_success_test("Integer i8 Binary Max", "0b01111111:i8", "i8", 127)
+        self.make_success_test("Integer i8 Octal Max", "0o177:i8", "i8", 127)
-            self.make_success_test("Integer i8 Octal Max", "0o177:i8", "i8", 127)
+        self.make_success_test("Integer i8 Negative Hex", "-0x80:i8", "i8", -128)
-            self.make_success_test("Integer i8 Negative Hex", "-0x80:i8", "i8", -128)
 
-        elif type_name == 'u8':
+        self.make_success_test("Integer u8 Hex Max", "0xFF:u8", "u8", 255)
-            self.make_success_test("Integer u8 Hex Max", "0xFF:u8", "u8", 255)
+        self.make_success_test("Integer u8 Binary Max", "0b11111111:u8", "u8", 255)
-            self.make_success_test("Integer u8 Binary Max", "0b11111111:u8", "u8", 255)
+        self.make_success_test("Integer u8 Octal Max", "0o377:u8", "u8", 255)
-            self.make_success_test("Integer u8 Octal Max", "0o377:u8", "u8", 255)
 
-        elif type_name == 'i16':
+        self.make_success_test("Integer i16 Hex Sample", "0x1234:i16", "i16", 4660)
-            self.make_success_test("Integer i16 Hex Sample", "0x1234:i16", "i16", 4660)
+        self.make_success_test("Integer i16 Binary Sample",
-            self.make_success_test("Integer i16 Binary Sample",
+                                "0b1111111100000000:i16", "i16", -256)
-                                  "0b1111111100000000:i16", "i16", 65280)
+        self.make_success_test("Integer i16 Octal Sample", "0o1234:i16", "i16", 668)
-            self.make_success_test("Integer i16 Octal Sample", "0o1234:i16", "i16", 668)
 
-        elif type_name == 'u16':
+        self.make_success_test("Integer u16 Hex Max", "0xFFFF:u16", "u16", 65535)
-            self.make_success_test("Integer u16 Hex Max", "0xFFFF:u16", "u16", 65535)
+        self.make_success_test("Integer u16 Binary Max",
-            self.make_success_test("Integer u16 Binary Max",
+                                "0b1111111111111111:u16", "u16", 65535)
-                                  "0b1111111111111111:u16", "u16", 65535)
+        self.make_success_test("Integer u16 Octal Max", "0o177777:u16", "u16", 65535)
-            self.make_success_test("Integer u16 Octal Max", "0o177777:u16", "u16", 65535)
+        self.make_success_test("Integer u16 Decimal Mid", "50000:u16", "u16", 50000)
-            self.make_success_test("Integer u16 Decimal Mid", "50000:u16", "u16", 50000)
 
-        elif type_name == 'i32':
+        self.make_success_test("Integer i32 Hex Sample", "0xABCD:i32", "i32", 43981)
-            self.make_success_test("Integer i32 Hex Sample", "0xABCD:i32", "i32", 43981)
+        self.make_success_test("Integer i32 Binary Sample",
-            self.make_success_test("Integer i32 Binary Sample",
+                                "0b11110000:i32", "i32", 240)
-                                  "0b11110000:i32", "i32", 240)
 
-        elif type_name == 'u32':
+        self.make_success_test("Integer u32 Hex Max", "0xFFFFFFFF:u32", "u32", 4294967295)
-            self.make_success_test("Integer u32 Hex Max", "0xFFFFFFFF:u32", "u32", 4294967295)
+        self.make_success_test("Integer u32 Binary Sample",
-            self.make_success_test("Integer u32 Binary Sample",
+                                "0b11111111000000001111111100000000:u32",
-                                  "0b11111111000000001111111100000000:u32",
+                                "u32", 4278255360)
-                                  "u32", 4278255360)
+        self.make_success_test("Integer u32 Octal Max",
-            self.make_success_test("Integer u32 Octal Max",
+                                "0o37777777777:u32", "u32", 4294967295)
-                                  "0o37777777777:u32", "u32", 4294967295)
+        self.make_success_test("Integer u32 Decimal Mid", "1000000:u32", "u32", 1000000)
-            self.make_success_test("Integer u32 Decimal Mid", "1000000:u32", "u32", 1000000)
 
-        elif type_name == 'i64':
+        self.make_success_test("Integer i64 Decimal Positive 42", "42:i64", "i64", 42)
-            self.make_success_test("Integer i64 Decimal Positive 42", "42:i64", "i64", 42)
+        self.make_success_test("Integer i64 Hex 0xFF", "0xFF:i64", "i64", 255)
-            self.make_success_test("Integer i64 Hex 0xFF", "0xFF:i64", "i64", 255)
+        self.make_success_test("Integer i64 Binary 0b1010", "0b1010:i64", "i64", 10)
-            self.make_success_test("Integer i64 Binary 0b1010", "0b1010:i64", "i64", 10)
+        self.make_success_test("Integer i64 Octal 0o755", "0o755:i64", "i64", 493)
-            self.make_success_test("Integer i64 Octal 0o755", "0o755:i64", "i64", 493)
 
-        elif type_name == 'u64':
+        self.make_success_test("Integer u64 Hex Max",
-            self.make_success_test("Integer u64 Hex Max",
+                                "0xFFFFFFFFFFFFFFFF:u64",
-                                  "0xFFFFFFFFFFFFFFFF:u64",
+                                "u64", "UINT64_MAX")
-                                  "u64", "UINT64_MAX")
+        self.make_success_test("Integer u64 Binary Sample",
-            self.make_success_test("Integer u64 Binary Sample",
+                                "0b1010101010101010:u64", "u64", 43690)
-                                  "0b1010101010101010:u64", "u64", 43690)
+        self.make_success_test("Integer u64 Octal Sample", "0o7777:u64", "u64", 4095)
-            self.make_success_test("Integer u64 Octal Sample", "0o7777:u64", "u64", 4095)
+        self.make_success_test("Integer u64 Decimal", "42:u64", "u64", 42)
-            self.make_success_test("Integer u64 Decimal", "42:u64", "u64", 42)
 
     def generate_underscore_tests(self):
         """Generate tests for underscores in different bases."""
@@ -227,7 +217,7 @@ class IntegerTestGenerator(BaseTestGenerator):
         # Tests for each specific type
         for type_name in ['i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64']:
             self.generate_typed_tests(type_name)
-            self.generate_special_typed_tests(type_name)
+        self.generate_special_typed_tests()
 
         # Additional edge cases
         self.generate_underscore_tests()