YREA-SLS/SLS_C/tests/lexer_tests.c

// Kyler Olsen
// YREA SLS
// Lexer Tests
// October 2025

#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <math.h>

#include "sls/sls_errors.h"
#include "sls/lexer.h"
#include "sls/string.h"
#include "tests/lexer_test_helpers.h"
#include "tests/tests.h"


static const size_t NUM_OF_TESTS = 20;

static TestResult test_Empty_Statement() {
    LexerTest test = start_up_test("test_Empty_Statement", "");
    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_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

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_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_Integer_Default_Decimal_1() {
    LexerTest test = start_up_test("test_Integer_Default_Decimal_1", "-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_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_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_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_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_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_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_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_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;
    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_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, 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", "127: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_Decimal_128() {
    LexerTest test = start_up_test("test_Integer_i8_Decimal_128", "-128: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_Decimal_255() {
    LexerTest test = start_up_test("test_Integer_u8_Decimal_255", "255: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_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_Decimal_with_Commas_Invalid() {
    LexerTest test = start_up_test("test_Integer_Default_Decimal_with_Commas_Invalid", "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_for_error(&test, result, i++, &(TestErrorMessage){60, "Invalid decimal literal: unexpected ',' in decimal integer."})) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Integer_i8_Overflow() {
    LexerTest test = start_up_test("test_Integer_i8_Overflow", "128: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_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Integer_i8_Underflow() {
    LexerTest test = start_up_test("test_Integer_i8_Underflow", "-129: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_eof_value(&test, result, i++, 0)) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Integer_Default_Invalid_Characters() {
    LexerTest test = start_up_test("test_Integer_Default_Invalid_Characters", "12a3");
    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++, &(TestErrorMessage){60, "Invalid decimal literal: unexpected 'a' in decimal integer."})) 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);
}

static TestResult test_Integer_Default_Invalid_Prefix() {
    LexerTest test = start_up_test("test_Integer_Default_Invalid_Prefix", "0b2");
    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++, &(TestErrorMessage){58, "Invalid binary literal: unexpected '2' in binary integer."})) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Integer_Default_Underscore_End() {
    LexerTest test = start_up_test("test_Integer_Default_Underscore_End", "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);
}

static TestResult test_Integer_Default_Underscore_Double() {
    LexerTest test = start_up_test("test_Integer_Default_Underscore_Double", "4__2");
    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);
}

TestsReport run_lexer_tests() {
    TestsReport test_report = (TestsReport) {
        .section = "lexer_tests",
        .count = NUM_OF_TESTS,
        .tests = (TestResult *)malloc(sizeof(TestResult) * NUM_OF_TESTS),
    };

    size_t i = 0;

    test_report.tests[i++] = test_Empty_Statement();
    test_report.tests[i++] = test_Integer_Default_Decimal_0();
    test_report.tests[i++] = test_Integer_Default_Decimal_1();
    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_Decimal_with_Commas_Invalid();
    test_report.tests[i++] = test_Integer_i8_Overflow();
    test_report.tests[i++] = test_Integer_i8_Underflow();
    test_report.tests[i++] = test_Integer_Default_Invalid_Characters();
    test_report.tests[i++] = test_Integer_Default_Whitespace();
    test_report.tests[i++] = test_Integer_Default_Invalid_Prefix();
    test_report.tests[i++] = test_Integer_Default_Underscore_End();
    test_report.tests[i++] = test_Integer_Default_Underscore_Double();

    return test_report;
}