KylerOlsen/YREA-SLS
KylerOlsen
/
YREA-SLS
1
0
Fork 0
Code Releases 3 Wiki Activity

Updated test cases

This commit is contained in:
Kyler Olsen 2025-11-23 21:41:58 -07:00
parent 1566c7bf60
commit d166eb5289
7 changed files with 674 additions and 1143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

786
SLS_C/tests/lexer_tests.c
View File

@ -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() {
LexerTest test = start_up_test(SLS_STR("Char Escape Null character"), SLS_STR("'\\0'"));
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){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() {
LexerTest test = start_up_test(SLS_STR("Char Hex Lowercase A"), SLS_STR("'\\x61'"));
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){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() {
LexerTest test = start_up_test(SLS_STR("Char Hex Uppercase A"), SLS_STR("'\\x41'"));
static TestResult test_Char_Escape_Null_character() {
LexerTest test = start_up_test(SLS_STR("Char Escape Null character"), SLS_STR("'\\0'"));
LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0;
if (test_character_value(&test, result, i++, &(uint8_t){65})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result);
}
static TestResult test_Char_Hex_Space() {
LexerTest test = start_up_test(SLS_STR("Char Hex Space"), SLS_STR("'\\x20'"));
LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0;
if (test_character_value(&test, result, i++, &(uint8_t){32})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result);
}
static TestResult test_Char_Hex_Tab() {
LexerTest test = start_up_test(SLS_STR("Char Hex Tab"), SLS_STR("'\\x09'"));
LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0;
if (test_character_value(&test, result, i++, &(uint8_t){9})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result);
}
static TestResult test_Char_Hex_Newline() {
LexerTest test = start_up_test(SLS_STR("Char Hex Newline"), SLS_STR("'\\x0A'"));
LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0;
if (test_character_value(&test, result, i++, &(uint8_t){10})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result);
}
static TestResult test_Char_Hex_Max_ASCII() {
LexerTest test = start_up_test(SLS_STR("Char Hex Max ASCII"), SLS_STR("'\\x7F'"));
LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0;
if (test_character_value(&test, result, i++, &(uint8_t){127})) return test.result;
if (test_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);
}
@ -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_Hex_Uppercase_A();
test_report.tests[i++] = test_Char_Hex_Space();
test_report.tests[i++] = test_Char_Hex_Tab();
test_report.tests[i++] = test_Char_Hex_Newline();
test_report.tests[i++] = test_Char_Hex_Max_ASCII();
test_report.tests[i++] = test_Char_Escape_Single_quote();
test_report.tests[i++] = test_Char_Escape_Null_character();
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();

847
SLS_Tests/cases.yaml
View File

@ -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
code: '''\\0'''
- name: Char Escape Backslash
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
code: '''\\x61'''
- name: Char Escape Single quote
code: '''\\'''''
tokens:
- type: char
value: a
value: ''''
operations:
- function: push
type: char
value: a
value: ''''
stack_final:
- type: char
value: a
- name: Char Hex Uppercase A
code: '''\\x41'''
value: ''''
- name: Char Escape Null character
code: '''\\0'''
tokens:
- type: char
value: A
value: "\0"
operations:
- function: push
type: char
value: A
value: "\0"
stack_final:
- type: char
value: A
- name: Char Hex Space
code: '''\\x20'''
tokens:
- type: char
value: ' '
operations:
- function: push
type: char
value: ' '
stack_final:
- type: char
value: ' '
- name: Char Hex Tab
code: '''\\x09'''
tokens:
- type: char
value: "\t"
operations:
- function: push
type: char
value: "\t"
stack_final:
- type: char
value: "\t"
- name: Char Hex Newline
code: '''\\x0A'''
tokens:
- type: char
value: '
'
operations:
- function: push
type: char
value: '
'
stack_final:
- type: char
value: '
'
- name: Char Hex Max ASCII
code: '''\\x7F'''
tokens:
- type: char
value: "\x7F"
operations:
- function: push
type: char
value: "\x7F"
stack_final:
- type: char
value: "\x7F"
value: "\0"
- 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:

1
SLS_Tests/generate_tests/base_tests.py
View File

@ -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]]]" = []

74
SLS_Tests/generate_tests/char_tests.py
View File

@ -74,13 +74,14 @@ class CharTestGenerator(BaseTestGenerator):
def generate_hexadecimal_escape_tests(self):
"""Generate tests for hexadecimal escape sequences."""
# Additional specific hex escapes
self.make_success_test("Char Hex Lowercase A", "'\\\\x61'", "char", 'a')
self.make_success_test("Char Hex Uppercase A", "'\\\\x41'", "char", 'A')
self.make_success_test("Char Hex Space", "'\\\\x20'", "char", ' ')
self.make_success_test("Char Hex Tab", "'\\\\x09'", "char", '\t')
self.make_success_test("Char Hex Newline", "'\\\\x0A'", "char", '\n')
self.make_success_test("Char Hex Max ASCII", "'\\\\x7F'", "char", '\x7F')
if self.ENABLE_CHAR_HEX_ESCAPE:
# Additional specific hex escapes
self.make_success_test("Char Hex Lowercase A", "'\\\\x61'", "char", 'a')
self.make_success_test("Char Hex Uppercase A", "'\\\\x41'", "char", 'A')
self.make_success_test("Char Hex Space", "'\\\\x20'", "char", ' ')
self.make_success_test("Char Hex Tab", "'\\\\x09'", "char", '\t')
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",
"'\\\\x4'",
"Invalid character literal: hexadecimal escape must have exactly 2 digits.")
self.make_error_test("Char Hex Escape Too Long",
"'\\\\x414'",
"Invalid character literal: hexadecimal escape must have exactly 2 digits.")
# Invalid hex digits
self.make_error_test("Char Hex Invalid Digit",
"'\\\\xGG'",
"Invalid character literal: invalid hexadecimal digit 'G'.")
if self.ENABLE_CHAR_HEX_ESCAPE:
self.make_error_test("Char Hex Escape Too Short",
"'\\\\x4'",
"Invalid character literal: hexadecimal escape must have exactly 2 digits.")
self.make_error_test("Char Hex Escape Too Long",
"'\\\\x414'",
"Invalid character literal: hexadecimal escape must have exactly 2 digits.")
# Invalid hex digits
self.make_error_test("Char Hex Invalid Digit",
"'\\\\xGG'",
"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
self.make_success_test("Char ASCII Control SOH", "'\\\\x01'", "char", '\x01')
self.make_success_test("Char ASCII Control BEL", "'\\\\x07'", "char", '\x07')
self.make_success_test("Char ASCII Control ESC", "'\\\\x1B'", "char", '\x1B')
self.make_success_test("Char ASCII Control DEL", "'\\\\x7F'", "char", '\x7F')
# Extended ASCII
self.make_success_test("Char Extended ASCII Lower", "'\\\\x80'", "char", '\x80')
self.make_success_test("Char Extended ASCII Upper", "'\\\\xFF'", "char", '\xFF')
if self.ENABLE_CHAR_HEX_ESCAPE:
# ASCII control characters
self.make_success_test("Char ASCII Control SOH", "'\\\\x01'", "char", '\x01')
self.make_success_test("Char ASCII Control BEL", "'\\\\x07'", "char", '\x07')
self.make_success_test("Char ASCII Control ESC", "'\\\\x1B'", "char", '\x1B')
self.make_success_test("Char ASCII Control DEL", "'\\\\x7F'", "char", '\x7F')
# Extended ASCII
self.make_success_test("Char Extended ASCII Lower", "'\\\\x80'", "char", '\x80')
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
self.make_success_test("Char Hex Lowercase x", "'\\\\x41'", "char", 'A')
# Hex digits - both cases
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 Mixed", "'\\\\xAb'", "char", '\xAB')
if self.ENABLE_CHAR_HEX_ESCAPE:
# Hex escapes - lowercase x
self.make_success_test("Char Hex Lowercase x", "'\\\\x41'", "char", 'A')
# Hex digits - both cases
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 Mixed", "'\\\\xAb'", "char", '\xAB')
if self.ENABLE_UNICODE:
# Unicode escapes - lowercase u

2
SLS_Tests/generate_tests/float_tests.py
View File

@ -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."""

13
SLS_Tests/generate_tests/idents_and_bools_tests.py
View File

@ -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"',
"string", "true")
self.make_success_test("Bool String False", '"false"',
"string", "false")
if self.ENABLE_STRINGS:
self.make_success_test("Bool String True", '"true"',
"string", "true")
self.make_success_test("Bool String False", '"false"',
"string", "false")
# Other languages
self.make_success_test("Bool Yes", "yes",

94
SLS_Tests/generate_tests/integer_tests.py
View File

@ -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 Binary Max", "0b01111111: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 Hex Max", "0x7F: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 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 Binary Max", "0b11111111:u8", "u8", 255)
self.make_success_test("Integer u8 Octal Max", "0o377: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 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 Binary Sample",
"0b1111111100000000:i16", "i16", 65280)
self.make_success_test("Integer i16 Octal Sample", "0o1234:i16", "i16", 668)
self.make_success_test("Integer i16 Hex Sample", "0x1234:i16", "i16", 4660)
self.make_success_test("Integer i16 Binary Sample",
"0b1111111100000000:i16", "i16", -256)
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 Binary Max",
"0b1111111111111111: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 Hex Max", "0xFFFF:u16", "u16", 65535)
self.make_success_test("Integer u16 Binary Max",
"0b1111111111111111: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)
elif type_name == 'i32':
self.make_success_test("Integer i32 Hex Sample", "0xABCD:i32", "i32", 43981)
self.make_success_test("Integer i32 Binary Sample",
"0b11110000:i32", "i32", 240)
self.make_success_test("Integer i32 Hex Sample", "0xABCD:i32", "i32", 43981)
self.make_success_test("Integer i32 Binary Sample",
"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 Binary Sample",
"0b11111111000000001111111100000000:u32",
"u32", 4278255360)
self.make_success_test("Integer u32 Octal Max",
"0o37777777777:u32", "u32", 4294967295)
self.make_success_test("Integer u32 Decimal Mid", "1000000:u32", "u32", 1000000)
self.make_success_test("Integer u32 Hex Max", "0xFFFFFFFF:u32", "u32", 4294967295)
self.make_success_test("Integer u32 Binary Sample",
"0b11111111000000001111111100000000:u32",
"u32", 4278255360)
self.make_success_test("Integer u32 Octal Max",
"0o37777777777:u32", "u32", 4294967295)
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 Hex 0xFF", "0xFF:i64", "i64", 255)
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 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 Binary 0b1010", "0b1010:i64", "i64", 10)
self.make_success_test("Integer i64 Octal 0o755", "0o755:i64", "i64", 493)
elif type_name == 'u64':
self.make_success_test("Integer u64 Hex Max",
"0xFFFFFFFFFFFFFFFF:u64",
"u64", "UINT64_MAX")
self.make_success_test("Integer u64 Binary Sample",
"0b1010101010101010:u64", "u64", 43690)
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 Hex Max",
"0xFFFFFFFFFFFFFFFF:u64",
"u64", "UINT64_MAX")
self.make_success_test("Integer u64 Binary Sample",
"0b1010101010101010:u64", "u64", 43690)
self.make_success_test("Integer u64 Octal Sample", "0o7777:u64", "u64", 4095)
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()