Fixed some tests

SLS_C/src/lexer.c

@@ -440,6 +440,8 @@ static LexerResult parse_numeric_type(LexerInfo *lexer_info, char c, size_t star
             return lexer_error(lexer_info, SLS_STR("Invalid numeric literal: float type not allowed."), start, start_line);
         }
     } else if (c == 'i' || c == 'u') {
+        if (numeric_literal_type == NUMERIC_FLOAT || numeric_literal_type == NUMERIC_EXPONENTIAL)
+            return lexer_error(lexer_info, SLS_STR("Invalid float type: must be of type 'f64' or 'f32'."), start, start_line);
         if (c == 'u') numeric_type |= NUMERIC_UNSIGNED;
         c = advance(lexer_info);
         if (c == '6' && far_peek(lexer_info, 1) == '4') {
@@ -539,7 +541,7 @@ static LexerResult parse_float(LexerInfo *lexer_info, char c, size_t start, size
     if (c == ':') return parse_numeric_type(lexer_info, c, start, start_line, NUMERIC_FLOAT);
     if (isspace(c) || c == '/' || c == '\0')
         return create_float_token(lexer_info, NUMERIC_F64, start, start_line);
-    SlsStr error_msg = sls_format(SLS_STR("Invalid float literal: unexpected '%c' in float literal."), c);
+    SlsStr error_msg = sls_format(SLS_STR("Invalid float literal: unexpected '%c' in float."), c);
     if (error_msg.str == NULL) return (LexerResult){SLS_ERROR, .error = (SlsError){SLS_STR("Out Of Memory Error."), 1}};
     return lexer_error(lexer_info, error_msg, start, start_line);
 }

SLS_C/tests/lexer_tests.c

@@ -16,7 +16,7 @@
 #include "tests/tests.h"
 
 
-static const size_t NUM_OF_TESTS = 482;
+static const size_t NUM_OF_TESTS = 448;
 
 static TestResult test_Empty_Statement() {
     LexerTest test = start_up_test(SLS_STR("Empty_Statement"), SLS_STR(""));
@@ -1478,46 +1478,6 @@ static TestResult test_Float_Default_No_Trailing_Digits_Negative() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Float_Default_Scientific_Positive_Exp() {
-    LexerTest test = start_up_test(SLS_STR("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("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("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("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("Float Default Very Small"), SLS_STR("0.000001"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -1528,16 +1488,6 @@ static TestResult test_Float_Default_Very_Small() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Float_Default_Scientific_Very_Small() {
-    LexerTest test = start_up_test(SLS_STR("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("Float Default Very Large"), SLS_STR("1000000.0"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -1548,16 +1498,6 @@ static TestResult test_Float_Default_Very_Large() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Float_Default_Scientific_Very_Large() {
-    LexerTest test = start_up_test(SLS_STR("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("Float Default Underscore Integer Part"), SLS_STR("1_000_000.5"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -1588,26 +1528,6 @@ static TestResult test_Float_Default_Underscore_Both_Parts() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Float_Default_Underscore_Scientific_Mantissa() {
-    LexerTest test = start_up_test(SLS_STR("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("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("Float Default Underscore Trailing"), SLS_STR("42.5_"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -1638,182 +1558,6 @@ static TestResult test_Float_f32_With_Underscores() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Float_f32_Max_Value() {
-    LexerTest test = start_up_test(SLS_STR("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("Float f32 Precision Limit"), SLS_STR("1.2345678:f32"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -1874,30 +1618,12 @@ static TestResult test_Float_f64_Close_Numbers_2() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Float_Invalid_No_Decimal_Point() {
-    LexerTest test = start_up_test(SLS_STR("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("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;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: unexpected '.' in float."))) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Float_Invalid_Only_Decimal_Point() {
-    LexerTest test = start_up_test(SLS_STR("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);
 }
 
@@ -1910,66 +1636,12 @@ static TestResult test_Float_Invalid_Characters() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Float_Invalid_Scientific_No_Exponent() {
-    LexerTest test = start_up_test(SLS_STR("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("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("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("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("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("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("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;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid float type: must be of type 'f64' or 'f32'."))) return test.result;
     return pass_test(&test, result);
 }
 
@@ -1978,7 +1650,7 @@ static TestResult test_Float_Invalid_Type_Name() {
     LexerResult result = lexical_analysis(&test.lexer_info);
     if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_for_error(&test, result, i++, SLS_STR("Invalid type annotation: unknown type 'f16'."))) return test.result;
+    if (test_for_error(&test, result, i++, SLS_STR("Invalid float type: must be of type 'f64' or 'f32'."))) return test.result;
     return pass_test(&test, result);
 }
 
@@ -2401,42 +2073,12 @@ static TestResult test_Char_Right_Brace() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Char_Escape_Backslash() {
+static TestResult test_Char_Escape_Null_character() {
-    LexerTest test = start_up_test(SLS_STR("Char Escape Backslash"), SLS_STR("'\\'"));
+    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){92})) 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_Escape_Double_quote() {
-    LexerTest test = start_up_test(SLS_STR("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_Newline() {
-    LexerTest test = start_up_test(SLS_STR("Char Escape Newline"), SLS_STR("'\n'"));
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_character_value(&test, result, i++, &(uint8_t){10})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Char_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);
 }
@@ -2451,12 +2093,12 @@ static TestResult test_Char_Escape_Tab() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Char_Escape_Null_character() {
+static TestResult test_Char_Escape_Double_quote() {
-    LexerTest test = start_up_test(SLS_STR("Char Escape Null character"), SLS_STR("'\0'"));
+    LexerTest test = start_up_test(SLS_STR("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){0})) return test.result;
+    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);
 }
@@ -2471,6 +2113,36 @@ static TestResult test_Char_Escape_Carriage_return() {
     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_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_Newline() {
+    LexerTest test = start_up_test(SLS_STR("Char Escape Newline"), SLS_STR("'\n'"));
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_character_value(&test, result, i++, &(uint8_t){10})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
 static TestResult test_Char_Newline() {
     LexerTest test = start_up_test(SLS_STR("Char Newline"), SLS_STR("'\n'"));
     LexerResult result = lexical_analysis(&test.lexer_info);
@@ -4913,56 +4585,22 @@ TestsReport run_lexer_tests() {
     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();
@@ -5007,13 +4645,13 @@ 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_Backslash();
-    test_report.tests[i++] = test_Char_Escape_Double_quote();
-    test_report.tests[i++] = test_Char_Escape_Newline();
-    test_report.tests[i++] = test_Char_Escape_Single_quote();
-    test_report.tests[i++] = test_Char_Escape_Tab();
     test_report.tests[i++] = test_Char_Escape_Null_character();
+    test_report.tests[i++] = test_Char_Escape_Tab();
+    test_report.tests[i++] = test_Char_Escape_Double_quote();
     test_report.tests[i++] = test_Char_Escape_Carriage_return();
+    test_report.tests[i++] = test_Char_Escape_Backslash();
+    test_report.tests[i++] = test_Char_Escape_Single_quote();
+    test_report.tests[i++] = test_Char_Escape_Newline();
     test_report.tests[i++] = test_Char_Newline();
     test_report.tests[i++] = test_Char_Carriage_Return();
     test_report.tests[i++] = test_Char_Tab();

SLS_Tests/cases.yaml

@@ -1632,54 +1632,6 @@
   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:
@@ -1692,18 +1644,6 @@
   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:
@@ -1716,18 +1656,6 @@
   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:
@@ -1764,30 +1692,6 @@
   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:
@@ -1824,194 +1728,6 @@
   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:
@@ -2084,66 +1800,26 @@
   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.'
+    value: 'Invalid float literal: unexpected ''.'' in float.'
-- 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.'
+    value: 'Invalid float type: must be of type ''f64'' or ''f32''.'
 - name: Float Invalid Type Name
   code: 3.14:f16
   tokens:
   - type: error
-    value: 'Invalid type annotation: unknown type ''f16''.'
+    value: 'Invalid float type: must be of type ''f64'' or ''f32''.'
 - name: Float Invalid Comma Separator
   code: 1,234.56
   tokens:
@@ -2641,18 +2317,30 @@
   stack_final:
   - type: char
     value: '}'
-- name: Char Escape Backslash
+- name: Char Escape Null character
-  code: '''\\'''
+  code: '''\0'''
   tokens:
   - type: char
-    value: \
+    value: "\0"
   operations:
   - function: push
     type: char
-    value: \
+    value: "\0"
   stack_final:
   - type: char
-    value: \
+    value: "\0"
+- 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 Double quote
   code: '''\\"'''
   tokens:
@@ -2665,6 +2353,42 @@
   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 Escape Backslash
+  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 Newline
   code: '''\n'''
   tokens:
@@ -2683,54 +2407,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 Tab
-  code: '''\t'''
-  tokens:
-  - type: char
-    value: "\t"
-  operations:
-  - function: push
-    type: char
-    value: "\t"
-  stack_final:
-  - type: char
-    value: "\t"
-- 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 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:

SLS_Tests/generate_tests/base_tests.py

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

SLS_Tests/generate_tests/float_tests.py

@@ -49,19 +49,22 @@ class FloatTestGenerator(BaseTestGenerator):
         self.make_success_test("Float Default No Trailing Digits", "42.", "f64", 42.0)
         self.make_success_test("Float Default No Trailing Digits Negative", "-7.", "f64", -7.0)
 
-        # Scientific notation
+        if self.ENABLE_EXPONENTIAL_LITERALS:
-        self.make_success_test("Float Default Scientific Positive Exp", "1.5e10", "f64", 1.5e10)
+            # Scientific notation
-        self.make_success_test("Float Default Scientific Negative Exp", "2.5e-5", "f64", 2.5e-5)
+            self.make_success_test("Float Default Scientific Positive Exp", "1.5e10", "f64", 1.5e10)
-        self.make_success_test("Float Default Scientific Capital E", "3.14E8", "f64", 3.14e8)
+            self.make_success_test("Float Default Scientific Negative Exp", "2.5e-5", "f64", 2.5e-5)
-        self.make_success_test("Float Default Scientific Plus Sign", "1.0e+3", "f64", 1000.0)
+            self.make_success_test("Float Default Scientific Capital E", "3.14E8", "f64", 3.14e8)
+            self.make_success_test("Float Default Scientific Plus Sign", "1.0e+3", "f64", 1000.0)
 
         # Very small numbers
         self.make_success_test("Float Default Very Small", "0.000001", "f64", 0.000001)
-        self.make_success_test("Float Default Scientific Very Small", "1.0e-20", "f64", 1.0e-20)
+        if self.ENABLE_EXPONENTIAL_LITERALS:
+            self.make_success_test("Float Default Scientific Very Small", "1.0e-20", "f64", 1.0e-20)
 
         # Very large numbers
         self.make_success_test("Float Default Very Large", "1000000.0", "f64", 1000000.0)
-        self.make_success_test("Float Default Scientific Very Large", "1.0e20", "f64", 1.0e20)
+        if self.ENABLE_EXPONENTIAL_LITERALS:
+            self.make_success_test("Float Default Scientific Very Large", "1.0e20", "f64", 1.0e20)
 
     def generate_underscore_tests(self):
         """Generate tests for underscores in floats."""
@@ -77,11 +80,12 @@ class FloatTestGenerator(BaseTestGenerator):
         self.make_success_test("Float Default Underscore Both Parts",
                               "1_234.567_89", "f64", 1234.56789)
 
-        # Underscores in scientific notation
+        if self.ENABLE_EXPONENTIAL_LITERALS:
-        self.make_success_test("Float Default Underscore Scientific Mantissa",
+            # Underscores in scientific notation
-                              "1_000.5e10", "f64", 1000.5e10)
+            self.make_success_test("Float Default Underscore Scientific Mantissa",
-        self.make_success_test("Float Default Underscore Scientific Exponent",
+                                "1_000.5e10", "f64", 1000.5e10)
-                              "1.5e1_0", "f64", 1.5e10)
+            self.make_success_test("Float Default Underscore Scientific Exponent",
+                                "1.5e1_0", "f64", 1.5e10)
 
         # Trailing underscore
         self.make_success_test("Float Default Underscore Trailing", "42.5_", "f64", 42.5)
@@ -112,55 +116,57 @@ class FloatTestGenerator(BaseTestGenerator):
         """Generate edge case tests for a specific float type."""
         values = self.SPECIAL_VALUES[type_name]
 
-        # Maximum value
+        if self.ENABLE_EXPONENTIAL_LITERALS:
-        self.make_success_test(f"Float {type_name} Max Value",
+            # Maximum value
-                              f"{values['max']}:{type_name}", type_name, values['max'])
+            self.make_success_test(f"Float {type_name} Max Value",
+                                f"{values['max']}:{type_name}", type_name, values['max'])
 
-        # Minimum value (most negative)
+            # Minimum value (most negative)
-        self.make_success_test(f"Float {type_name} Min Value",
+            self.make_success_test(f"Float {type_name} Min Value",
-                              f"{values['min']}:{type_name}", type_name, values['min'])
+                                f"{values['min']}:{type_name}", type_name, values['min'])
 
-        # Smallest positive normalized value
+            # Smallest positive normalized value
-        self.make_success_test(f"Float {type_name} Min Positive",
+            self.make_success_test(f"Float {type_name} Min Positive",
-                              f"{values['min_positive']}:{type_name}",
+                                f"{values['min_positive']}:{type_name}",
-                              type_name, values['min_positive'])
+                                type_name, values['min_positive'])
 
-        # Machine epsilon
+            # Machine epsilon
-        self.make_success_test(f"Float {type_name} Epsilon",
+            self.make_success_test(f"Float {type_name} Epsilon",
-                              f"{values['epsilon']}:{type_name}",
+                                f"{values['epsilon']}:{type_name}",
-                              type_name, values['epsilon'])
+                                type_name, values['epsilon'])
 
-        # Near zero
+            # Near zero
-        self.make_success_test(f"Float {type_name} Near Zero Positive",
+            self.make_success_test(f"Float {type_name} Near Zero Positive",
-                              f"1e-30:{type_name}", type_name, 1e-30)
+                                f"1e-30:{type_name}", type_name, 1e-30)
-        self.make_success_test(f"Float {type_name} Near Zero Negative",
+            self.make_success_test(f"Float {type_name} Near Zero Negative",
-                              f"-1e-30:{type_name}", type_name, -1e-30)
+                                f"-1e-30:{type_name}", type_name, -1e-30)
 
-        # Subnormal numbers
+            # Subnormal numbers
-        if type_name == 'f64':
+            if type_name == 'f64':
-            self.make_success_test("Float f64 Subnormal",
+                self.make_success_test("Float f64 Subnormal",
-                                  "1e-320:f64", "f64", 1e-320)
+                                    "1e-320:f64", "f64", 1e-320)
-        elif type_name == 'f32':
+            elif type_name == 'f32':
-            self.make_success_test("Float f32 Subnormal",
+                self.make_success_test("Float f32 Subnormal",
-                                  "1e-40:f32", "f32", 1e-40)
+                                    "1e-40:f32", "f32", 1e-40)
 
     def generate_overflow_tests(self):
         """Generate overflow tests."""
-        # f32 overflow
+        if self.ENABLE_EXPONENTIAL_LITERALS:
-        self.make_error_test("Float f32 Overflow Positive",
+            # f32 overflow
-                           "1e40:f32",
+            self.make_error_test("Float f32 Overflow Positive",
-                           "Float overflow: value exceeds range for f32.")
+                            "1e40:f32",
-        self.make_error_test("Float f32 Overflow Negative",
+                            "Float overflow: value exceeds range for f32.")
-                           "-1e40:f32",
+            self.make_error_test("Float f32 Overflow Negative",
-                           "Float overflow: value exceeds range for f32.")
+                            "-1e40:f32",
+                            "Float overflow: value exceeds range for f32.")
 
-        # f64 overflow (extremely large values)
+            # f64 overflow (extremely large values)
-        self.make_error_test("Float f64 Overflow Positive",
+            self.make_error_test("Float f64 Overflow Positive",
-                           "1e310:f64",
+                            "1e310:f64",
-                           "Float overflow: value exceeds range for f64.")
+                            "Float overflow: value exceeds range for f64.")
-        self.make_error_test("Float f64 Overflow Negative",
+            self.make_error_test("Float f64 Overflow Negative",
-                           "-1e310:f64",
+                            "-1e310:f64",
-                           "Float overflow: value exceeds range for f64.")
+                            "Float overflow: value exceeds range for f64.")
 
     def generate_precision_tests(self):
         """Generate tests for precision limits."""
@@ -185,48 +191,32 @@ class FloatTestGenerator(BaseTestGenerator):
     def generate_error_tests(self):
         """Generate error tests."""
         # Invalid formats
-        self.make_error_test("Float Invalid No Decimal Point",
-                           "42",
-                           "Not a valid float literal: missing decimal point.")
         self.make_error_test("Float Invalid Multiple Decimal Points",
                            "3.14.159",
-                           "Invalid float literal: multiple decimal points.")
+                           "Invalid float literal: unexpected '.' in float.")
-        self.make_error_test("Float Invalid Only Decimal Point",
-                           ".",
-                           "Invalid float literal: no digits before or after decimal point.")
         self.make_error_test("Float Invalid Characters",
                            "3.1a4",
                            "Invalid float literal: unexpected 'a' in float.")
 
-        # Invalid scientific notation
+        if self.ENABLE_EXPONENTIAL_LITERALS:
-        self.make_error_test("Float Invalid Scientific No Exponent",
+            # Invalid scientific notation
-                           "3.14e",
+            self.make_error_test("Float Invalid Scientific No Exponent",
-                           "Invalid float literal: missing exponent value.")
+                            "3.14e",
-        self.make_error_test("Float Invalid Scientific Double E",
+                            "Invalid float literal: missing exponent value.")
-                           "3.14e10e5",
+            self.make_error_test("Float Invalid Scientific Double E",
-                           "Invalid float literal: multiple exponent markers.")
+                            "3.14e10e5",
-        self.make_error_test("Float Invalid Scientific Invalid Exponent",
+                            "Invalid float literal: unexpected 'e' in float.")
-                           "3.14eX",
+            self.make_error_test("Float Invalid Scientific Invalid Exponent",
-                           "Invalid float literal: invalid exponent 'X'.")
+                            "3.14eX",
-
+                            "Invalid float literal: unexpected 'X' in float.")
-        # Invalid underscores
-        self.make_error_test("Float Invalid Leading Underscore",
-                           "_3.14",
-                           "Invalid float literal: leading underscore.")
-        self.make_error_test("Float Invalid Underscore Before Decimal",
-                           "3_.14",
-                           "Invalid float literal: underscore before decimal point.")
-        self.make_error_test("Float Invalid Underscore After Decimal",
-                           "3._14",
-                           "Invalid float literal: underscore after decimal point.")
 
         # Invalid type annotations
         self.make_error_test("Float Invalid Type Annotation",
                            "3.14:i32",
-                           "Type mismatch: float literal cannot be annotated as integer type.")
+                           "Invalid float type: must be of type 'f64' or 'f32'.")
         self.make_error_test("Float Invalid Type Name",
                            "3.14:f16",
-                           "Invalid type annotation: unknown type 'f16'.")
+                           "Invalid float type: must be of type 'f64' or 'f32'.")
 
         # Comma separators not allowed
         self.make_error_test("Float Invalid Comma Separator",