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 = 22;

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_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_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_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_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", "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;
    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", "-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;
    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", "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;
    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){52, "Invalid numeric literal: unexpected ',' in integer."})) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Integer_i8_Overflow() {
    LexerTest test = start_up_test("test_Integer_i8_Overflow", "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;
    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", "-129i8");
    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){51, "Invalid numeric literal: unexpected character 'a'."})) 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){47, "Invalid binary literal: digit '2' not allowed."})) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Integer_Default_Invalid_Underscore_Start() {
    LexerTest test = start_up_test("test_Integer_Default_Invalid_Underscore_Start", "_42");
    LexerResult result = lexical_analysis(&test.lexer_info);
    if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
    size_t i = 0;
    if (test_for_error(&test, result, i++, &(TestErrorMessage){55, "Invalid numeric literal: cannot start with underscore."})) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Integer_Default_Invalid_Underscore_End() {
    LexerTest test = start_up_test("test_Integer_Default_Invalid_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_for_error(&test, result, i++, &(TestErrorMessage){53, "Invalid numeric literal: cannot end with underscore."})) return test.result;
    return pass_test(&test, result);
}

static TestResult test_Integer_Default_Invalid_Underscore_Double() {
    LexerTest test = start_up_test("test_Integer_Default_Invalid_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_for_error(&test, result, i++, &(TestErrorMessage){62, "Invalid numeric literal: consecutive underscores not allowed."})) 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_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_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_Invalid_Underscore_Start();
    test_report.tests[i++] = test_Integer_Default_Invalid_Underscore_End();
    test_report.tests[i++] = test_Integer_Default_Invalid_Underscore_Double();

    return test_report;
}