Worked on making test cases

SLS_C/tests/lexer_tests.c

@@ -26,119 +26,68 @@ static TestResult test_Empty_Statement() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Identifier_Hello() {
+static TestResult test_Integer_Default_Decimal_0() {
-    LexerTest test = start_up_test("test_Identifier_Hello", "Hello");
+    LexerTest test = start_up_test("test_Integer_Default_Decimal_0", "0");
     LexerResult result = lexical_analysis(&test.lexer_info);
     if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, 5, "Hello"})) return test.result;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 0})) return test.result;
     if (test_eof_value(&test, result, i++, 0)) return test.result;
     return pass_test(&test, result);
 }
 
-static TestResult test_Identifier_Plus() {
+static TestResult test_Integer_Default_Decimal_1_neg() {
-    LexerTest test = start_up_test("test_Identifier_Plus", "+");
+    LexerTest test = start_up_test("test_Integer_Default_Decimal_1_neg", "-1");
     LexerResult result = lexical_analysis(&test.lexer_info);
     if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, 1, "+"})) return test.result;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, -1})) return test.result;
     if (test_eof_value(&test, result, i++, 0)) return test.result;
     return pass_test(&test, result);
 }
 
-static TestResult test_Identifier_Rotate() {
+static TestResult test_Integer_Default_Decimal_1_pos() {
-    LexerTest test = start_up_test("test_Identifier_Rotate", "rot");
+    LexerTest test = start_up_test("test_Integer_Default_Decimal_1_pos", "+1");
     LexerResult result = lexical_analysis(&test.lexer_info);
     if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, 3, "rot"})) return test.result;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 1})) return test.result;
     if (test_eof_value(&test, result, i++, 0)) return test.result;
     return pass_test(&test, result);
 }
 
-static TestResult test_Identifier_Swap_and_Duplicate() {
+static TestResult test_Integer_Default_Decimal_Leading_Zeros() {
-    LexerTest test = start_up_test("test_Identifier_Swap_and_Duplicate", "swap dup");
+    LexerTest test = start_up_test("test_Integer_Default_Decimal_Leading_Zeros", "00042");
     LexerResult result = lexical_analysis(&test.lexer_info);
     if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, 4, "swap"})) return test.result;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 42})) return test.result;
-    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, 3, "dup"})) return test.result;
     if (test_eof_value(&test, result, i++, 0)) return test.result;
     return pass_test(&test, result);
 }
 
-static TestResult test_Identifier_Depth() {
+static TestResult test_Integer_Default_Hex_0xFF() {
-    LexerTest test = start_up_test("test_Identifier_Depth", "depth");
+    LexerTest test = start_up_test("test_Integer_Default_Hex_0xFF", "0xFF");
     LexerResult result = lexical_analysis(&test.lexer_info);
     if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, 5, "depth"})) return test.result;
+    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_Identifier_Literal_Point() {
+static TestResult test_Integer_Default_Hex_0xdeadbeef() {
-    LexerTest test = start_up_test("test_Identifier_Literal_Point", "::Point");
+    LexerTest test = start_up_test("test_Integer_Default_Hex_0xdeadbeef", "0xdeadbeef");
     LexerResult result = lexical_analysis(&test.lexer_info);
     if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, 5, "Point"})) return test.result;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 3735928559})) return test.result;
     if (test_eof_value(&test, result, i++, 0)) return test.result;
     return pass_test(&test, result);
 }
 
-static TestResult test_Identifier_Literal_Multiply() {
+static TestResult test_Integer_Default_Binary_0b1010() {
-    LexerTest test = start_up_test("test_Identifier_Literal_Multiply", "::*");
+    LexerTest test = start_up_test("test_Integer_Default_Binary_0b1010", "0b1010");
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, 1, "*"})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Identifier_Literal_Name() {
-    LexerTest test = start_up_test("test_Identifier_Literal_Name", "::name");
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_identifier_value(&test, result, i++, &(TestIdentifierValue){TRUE, 4, "name"})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_Default_Decimal_15() {
-    LexerTest test = start_up_test("test_Integer_Default_Decimal_15", "15");
-    LexerResult result = lexical_analysis(&test.lexer_info);
-    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
-    size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 15})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_Default_Hex_E1() {
-    LexerTest test = start_up_test("test_Integer_Default_Hex_E1", "0xE1");
-    LexerResult result = 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, 225})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_Default_Hex_b2() {
-    LexerTest test = start_up_test("test_Integer_Default_Hex_b2", "0xb2");
-    LexerResult result = 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, 178})) return test.result;
-    if (test_eof_value(&test, result, i++, 0)) return test.result;
-    return pass_test(&test, result);
-}
-
-static TestResult test_Integer_Default_Binary_1010() {
-    LexerTest test = start_up_test("test_Integer_Default_Binary_1010", "0b1010");
     LexerResult result = lexical_analysis(&test.lexer_info);
     if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
@@ -147,12 +96,62 @@ static TestResult test_Integer_Default_Binary_1010() {
     return pass_test(&test, result);
 }
 
-static TestResult test_Integer_Default_Decimal_2_001_650() {
+static TestResult test_Integer_Default_Octal_0o755() {
-    LexerTest test = start_up_test("test_Integer_Default_Decimal_2_001_650", "2_001_650");
+    LexerTest test = start_up_test("test_Integer_Default_Octal_0o755", "0o755");
     LexerResult result = lexical_analysis(&test.lexer_info);
     if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
     size_t i = 0;
-    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 2001650})) return test.result;
+    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_i8_Decimal_127() {
+    LexerTest test = start_up_test("test_Integer_i8_Decimal_127", "127i8");
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    // Unhandled token type: i8
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_i8_Decimal_128() {
+    LexerTest test = start_up_test("test_Integer_i8_Decimal_128", "-128i8");
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    // Unhandled token type: i8
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_u8_Decimal_255() {
+    LexerTest test = start_up_test("test_Integer_u8_Decimal_255", "255u8");
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    // Unhandled token type: u8
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_Default_Decimal_with_Underscore() {
+    LexerTest test = start_up_test("test_Integer_Default_Decimal_with_Underscore", "1_000_000");
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 1000000})) return test.result;
+    if (test_eof_value(&test, result, i++, 0)) return test.result;
+    return pass_test(&test, result);
+}
+
+static TestResult test_Integer_Default_Whitespace() {
+    LexerTest test = start_up_test("test_Integer_Default_Whitespace", "  42  ");
+    LexerResult result = lexical_analysis(&test.lexer_info);
+    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
+    size_t i = 0;
+    if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 42})) return test.result;
     if (test_eof_value(&test, result, i++, 0)) return test.result;
     return pass_test(&test, result);
 }
@@ -167,19 +166,19 @@ TestsReport run_lexer_tests() {
     size_t i = 0;
 
     test_report.tests[i++] = test_Empty_Statement();
-    test_report.tests[i++] = test_Identifier_Hello();
+    test_report.tests[i++] = test_Integer_Default_Decimal_0();
-    test_report.tests[i++] = test_Identifier_Plus();
+    test_report.tests[i++] = test_Integer_Default_Decimal_1_neg();
-    test_report.tests[i++] = test_Identifier_Rotate();
+    test_report.tests[i++] = test_Integer_Default_Decimal_1_pos();
-    test_report.tests[i++] = test_Identifier_Swap_and_Duplicate();
+    test_report.tests[i++] = test_Integer_Default_Decimal_Leading_Zeros();
-    test_report.tests[i++] = test_Identifier_Depth();
+    test_report.tests[i++] = test_Integer_Default_Hex_0xFF();
-    test_report.tests[i++] = test_Identifier_Literal_Point();
+    test_report.tests[i++] = test_Integer_Default_Hex_0xdeadbeef();
-    test_report.tests[i++] = test_Identifier_Literal_Multiply();
+    test_report.tests[i++] = test_Integer_Default_Binary_0b1010();
-    test_report.tests[i++] = test_Identifier_Literal_Name();
+    test_report.tests[i++] = test_Integer_Default_Octal_0o755();
-    test_report.tests[i++] = test_Integer_Default_Decimal_15();
+    test_report.tests[i++] = test_Integer_i8_Decimal_127();
-    test_report.tests[i++] = test_Integer_Default_Hex_E1();
+    test_report.tests[i++] = test_Integer_i8_Decimal_128();
-    test_report.tests[i++] = test_Integer_Default_Hex_b2();
+    test_report.tests[i++] = test_Integer_u8_Decimal_255();
-    test_report.tests[i++] = test_Integer_Default_Binary_1010();
+    test_report.tests[i++] = test_Integer_Default_Decimal_with_Underscore();
-    test_report.tests[i++] = test_Integer_Default_Decimal_2_001_650();
+    test_report.tests[i++] = test_Integer_Default_Whitespace();
 
     return test_report;
 }

SLS_Tests/cases.yaml

@@ -30,145 +30,87 @@
   operations: []
   stack_final: []
 
-# Basic Identifiers
+# Basic Integers
 
-- name: Identifier Hello
+- name: Integer Default Decimal 0
-  code: "Hello"
+  code: "0"
   tokens:
-  - type: identifier
+  - type: i64
-    value: Hello
+    value: 0
   operations:
-  - function: Hello
+  - function: push
-  runtime_error:
+    type: i64
-    message: Function "Hello" not found.
+    value: 0
-
-- name: Identifier Plus
-  code: "+"
-  tokens:
-  - type: identifier
-    value: "+"
-  operations:
-  - function: "+"
-  runtime_error:
-    message: Function "+" requires 2 "Addable" on the stack.
-
-- name: Identifier Rotate
-  code: "rot"
-  tokens:
-  - type: identifier
-    value: rot
-  operations:
-  - function: rot
-  runtime_error:
-    message: Function "rot" requires 3 "Stackable" on the stack.
-
-- name: Identifier Swap and Duplicate
-  code: "swap dup"
-  tokens:
-  - type: identifier
-    value: swap
-  - type: identifier
-    value: dup
-  operations:
-  - function: swap
-  - function: dup
-  runtime_error:
-    message: Function "swap" requires 2 "Stackable" on the stack.
-
-- name: Identifier Depth
-  code: "depth"
-  tokens:
-  - type: identifier
-    value: depth
-  operations:
-  - function: depth
   stack_final:
   - type: i64
     value: 0
 
-# Basic Identifier Literals
+- name: Integer Default Decimal -1 neg
-
+  code: "-1"
-- name: Identifier Literal Point
-  code: "::Point"
-  tokens:
-  - type: identifier_literal
-    value: Point
-  operations:
-  - function: push
-    type: identifier_literal
-    value: Point
-  stack_final:
-  - type: identifier_literal
-    value: Point
-
-- name: Identifier Literal Multiply
-  code: "::*"
-  tokens:
-  - type: identifier_literal
-    value: "*"
-  operations:
-  - function: push
-    type: identifier_literal
-    value: "*"
-  stack_final:
-  - type: identifier_literal
-    value: "*"
-
-- name: Identifier Literal Name
-  code: "::name"
-  tokens:
-  - type: identifier_literal
-    value: name
-  operations:
-  - function: push
-    type: identifier_literal
-    value: name
-  stack_final:
-  - type: identifier_literal
-    value: name
-
-# Basic Integers
-
-- name: Integer Default Decimal 15
-  code: "15"
   tokens:
   - type: i64
-    value: 15
+    value: -1
   operations:
   - function: push
     type: i64
-    value: 15
+    value: -1
   stack_final:
   - type: i64
-    value: 15
+    value: -1
 
-- name: Integer Default Hex E1
+- name: Integer Default Decimal +1 pos
-  code: "0xE1"
+  code: "+1"
   tokens:
   - type: i64
-    value: 225
+    value: 1
   operations:
   - function: push
     type: i64
-    value: 225
+    value: 1
   stack_final:
   - type: i64
-    value: 225
+    value: 1
 
-- name: Integer Default Hex b2
+- name: Integer Default Decimal Leading Zeros
-  code: "0xb2"
+  code: "00042"
   tokens:
   - type: i64
-    value: 178
+    value: 42
   operations:
   - function: push
     type: i64
-    value: 178
+    value: 42
   stack_final:
   - type: i64
-    value: 178
+    value: 42
 
-- name: Integer Default Binary 1010
+- name: Integer Default Hex 0xFF
+  code: "0xFF"
+  tokens:
+  - type: i64
+    value: 255
+  operations:
+  - function: push
+    type: i64
+    value: 255
+  stack_final:
+  - type: i64
+    value: 255
+
+- name: Integer Default Hex 0xdeadbeef
+  code: "0xdeadbeef"
+  tokens:
+  - type: i64
+    value: 3735928559
+  operations:
+  - function: push
+    type: i64
+    value: 3735928559
+  stack_final:
+  - type: i64
+    value: 3735928559
+
+- name: Integer Default Binary 0b1010
   code: "0b1010"
   tokens:
   - type: i64
@@ -181,26 +123,129 @@
   - type: i64
     value: 10
 
-- name: Integer Default Decimal 2,001,650
+- name: Integer Default Octal 0o755
-  code: "2_001_650"
+  code: "0o755"
   tokens:
   - type: i64
-    value: 2001650
+    value: 493
   operations:
   - function: push
     type: i64
-    value: 2001650
+    value: 493
   stack_final:
   - type: i64
-    value: 2001650
+    value: 493
 
-# - name: Integer i64 Decimal 5
+- name: Integer i8 Decimal 127
-# - name: Integer i64 Hex 5f
+  code: "127i8"
-# - name: Integer i64 Binary 10110
+  tokens:
+  - type: i8
+    value: 127
+  operations:
+  - function: push
+    type: i8
+    value: 127
+  stack_final:
+  - type: i8
+    value: 127
+
+- name: Integer i8 Decimal -128
+  code: "-128i8"
+  tokens:
+  - type: i8
+    value: -128
+  operations:
+  - function: push
+    type: i8
+    value: -128
+  stack_final:
+  - type: i8
+    value: -128
+
+- name: Integer u8 Decimal 255
+  code: "255u8"
+  tokens:
+  - type: u8
+    value: 255
+  operations:
+  - function: push
+    type: u8
+    value: 255
+  stack_final:
+  - type: u8
+    value: 255
+
+- name: Integer Default Decimal with Underscore
+  code: "1_000_000"
+  tokens:
+  - type: i64
+    value: 1000000
+  operations:
+  - function: push
+    type: i64
+    value: 1000000
+  stack_final:
+  - type: i64
+    value: 1000000
+
+- name: Integer Default Decimal with Commas Invalid
+  code: "1,000,000"
+  lexer_error:
+    message: "Invalid numeric literal: unexpected ',' in integer."
+
+- name: Integer i8 Overflow
+  code: "128i8"
+  runtime_error:
+    message: "Integer overflow: 128 exceeds range for i8."
+
+- name: Integer i8 Underflow
+  code: "-129i8"
+  runtime_error:
+    message: "Integer underflow: -129 exceeds range for i8."
+
+- name: Integer Default Invalid Characters
+  code: "12a3"
+  lexer_error:
+    message: "Invalid numeric literal: unexpected character 'a'."
+
+- name: Integer Default Whitespace
+  code: "  42  "
+  tokens:
+  - type: i64
+    value: 42
+  operations:
+  - function: push
+    type: i64
+    value: 42
+  stack_final:
+  - type: i64
+    value: 42
+
+- name: Integer Default Invalid Prefix
+  code: "0b2"
+  lexer_error:
+    message: "Invalid binary literal: digit '2' not allowed."
+
+- name: Integer Default Invalid Underscore Start
+  code: "_42"
+  lexer_error:
+    message: "Invalid numeric literal: cannot start with underscore."
+
+- name: Integer Default Invalid Underscore End
+  code: "42_"
+  lexer_error:
+    message: "Invalid numeric literal: cannot end with underscore."
+
+- name: Integer Default Invalid Underscore Double
+  code: "4__2"
+  lexer_error:
+    message: "Invalid numeric literal: consecutive underscores not allowed."
 
 # Basic Floats
 # Basic Strings
 # Basic Booleans
+# Basic Identifiers
+# Basic Identifier Literals
 # Basic Arrays
 # Basic Token Strings
 # Stack Operations
@@ -255,3 +300,6 @@
 # Std Lib IO
 # Std Lib Strings
 # Std Lib Type conversions
+# Error Handling
+# Reflection
+