Worked on making test cases

2025-11-05 17:03:21 -07:00 · 2025-11-05 17:03:21 -07:00 · 3aa4af6577
parent 98922385e8
commit 3aa4af6577
2 changed files with 250 additions and 203 deletions
--- a/SLS_C/tests/lexer_tests.c
+++ b/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() {
-    LexerTest test = start_up_test("test_Identifier_Hello", "Hello");
+static TestResult test_Integer_Default_Decimal_0() {
+    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() {
-    LexerTest test = start_up_test("test_Identifier_Plus", "+");
+static TestResult test_Integer_Default_Decimal_1_neg() {
+    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() {
-    LexerTest test = start_up_test("test_Identifier_Rotate", "rot");
+static TestResult test_Integer_Default_Decimal_1_pos() {
+    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() {
-    LexerTest test = start_up_test("test_Identifier_Swap_and_Duplicate", "swap dup");
+static TestResult test_Integer_Default_Decimal_Leading_Zeros() {
+    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_identifier_value(&test, result, i++, &(TestIdentifierValue){FALSE, 3, "dup"})) return test.result;
+    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_Identifier_Depth() {
-    LexerTest test = start_up_test("test_Identifier_Depth", "depth");
+static TestResult test_Integer_Default_Hex_0xFF() {
+    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() {
-    LexerTest test = start_up_test("test_Identifier_Literal_Point", "::Point");
+static TestResult test_Integer_Default_Hex_0xdeadbeef() {
+    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() {
-    LexerTest test = start_up_test("test_Identifier_Literal_Multiply", "::*");
-    LexerResult result = 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");
+static TestResult test_Integer_Default_Binary_0b1010() {
+    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;
@ -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() {
-    LexerTest test = start_up_test("test_Integer_Default_Decimal_2_001_650", "2_001_650");
+static TestResult test_Integer_Default_Octal_0o755() {
+    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_Identifier_Plus();
-    test_report.tests[i++] = test_Identifier_Rotate();
-    test_report.tests[i++] = test_Identifier_Swap_and_Duplicate();
-    test_report.tests[i++] = test_Identifier_Depth();
-    test_report.tests[i++] = test_Identifier_Literal_Point();
-    test_report.tests[i++] = test_Identifier_Literal_Multiply();
-    test_report.tests[i++] = test_Identifier_Literal_Name();
-    test_report.tests[i++] = test_Integer_Default_Decimal_15();
-    test_report.tests[i++] = test_Integer_Default_Hex_E1();
-    test_report.tests[i++] = test_Integer_Default_Hex_b2();
-    test_report.tests[i++] = test_Integer_Default_Binary_1010();
-    test_report.tests[i++] = test_Integer_Default_Decimal_2_001_650();
+    test_report.tests[i++] = test_Integer_Default_Decimal_0();
+    test_report.tests[i++] = test_Integer_Default_Decimal_1_neg();
+    test_report.tests[i++] = test_Integer_Default_Decimal_1_pos();
+    test_report.tests[i++] = test_Integer_Default_Decimal_Leading_Zeros();
+    test_report.tests[i++] = test_Integer_Default_Hex_0xFF();
+    test_report.tests[i++] = test_Integer_Default_Hex_0xdeadbeef();
+    test_report.tests[i++] = test_Integer_Default_Binary_0b1010();
+    test_report.tests[i++] = test_Integer_Default_Octal_0o755();
+    test_report.tests[i++] = test_Integer_i8_Decimal_127();
+    test_report.tests[i++] = test_Integer_i8_Decimal_128();
+    test_report.tests[i++] = test_Integer_u8_Decimal_255();
+    test_report.tests[i++] = test_Integer_Default_Decimal_with_Underscore();
+    test_report.tests[i++] = test_Integer_Default_Whitespace();

    return test_report;
 }
--- a/SLS_Tests/cases.yaml
+++ b/SLS_Tests/cases.yaml
@ -30,145 +30,87 @@
  operations: []
  stack_final: []

-# Basic Identifiers
+# Basic Integers

- name: Identifier Hello
-  code: "Hello"
+- name: Integer Default Decimal 0
+  code: "0"
  tokens:
-  - type: identifier
-    value: Hello
+  - type: i64
+    value: 0
  operations:
-  - function: Hello
-  runtime_error:
-    message: Function "Hello" not found.
-
- 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
+  - function: push
+    type: i64
+    value: 0
  stack_final:
  - type: i64
    value: 0

-# Basic Identifier Literals
-
- 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"
+- name: Integer Default Decimal -1 neg
+  code: "-1"
  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
-  code: "0xE1"
+- name: Integer Default Decimal +1 pos
+  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
-  code: "0xb2"
+- name: Integer Default Decimal Leading Zeros
+  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
-  code: "2_001_650"
+- name: Integer Default Octal 0o755
+  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 i64 Hex 5f
-# - name: Integer i64 Binary 10110
+- name: Integer i8 Decimal 127
+  code: "127i8"
+  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
+