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 = 14;
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;
    // 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);
}

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_Whitespace();

    return test_report;
}