Rava/tests/test_fastframe.c

#include <stdio.h>
#include <assert.h>
#include "../runtime/fastframe.h"

static int tests_passed = 0;

#define TEST(name) static void test_##name(void)
#define RUN_TEST(name) do { \
    printf("Running %s... ", #name); \
    test_##name(); \
    printf("PASSED\n"); \
    tests_passed++; \
} while(0)

TEST(init) {
    rava_fastframe_init();
    assert(rava_fastframe_get_depth() == 0);
    assert(rava_fastframe_current() == NULL);
}

TEST(push_pop) {
    rava_fastframe_init();

    FastFrame_t* frame = rava_fastframe_push(NULL, 4);
    assert(frame != NULL);
    assert(rava_fastframe_get_depth() == 1);
    assert(rava_fastframe_current() == frame);

    rava_fastframe_pop();
    assert(rava_fastframe_get_depth() == 0);
    assert(rava_fastframe_current() == NULL);
}

TEST(nested_frames) {
    rava_fastframe_init();

    FastFrame_t* f1 = rava_fastframe_push(NULL, 2);
    FastFrame_t* f2 = rava_fastframe_push(NULL, 2);
    FastFrame_t* f3 = rava_fastframe_push(NULL, 2);

    assert(rava_fastframe_get_depth() == 3);
    assert(rava_fastframe_current() == f3);

    rava_fastframe_pop();
    assert(rava_fastframe_current() == f2);

    rava_fastframe_pop();
    assert(rava_fastframe_current() == f1);

    rava_fastframe_pop();
    assert(rava_fastframe_current() == NULL);
}

TEST(stack_operations) {
    rava_fastframe_init();

    FastFrame_t* frame = rava_fastframe_push(NULL, 4);
    assert(rava_fastframe_stack_is_empty(frame));

    rava_fastframe_stack_push(frame, rava_nanbox_int(10));
    rava_fastframe_stack_push(frame, rava_nanbox_int(20));
    rava_fastframe_stack_push(frame, rava_nanbox_int(30));

    assert(!rava_fastframe_stack_is_empty(frame));
    assert(frame->stack_top == 3);

    RavaNanboxValue_t top = rava_fastframe_stack_peek(frame);
    assert(rava_nanbox_as_int(top) == 30);
    assert(frame->stack_top == 3);

    RavaNanboxValue_t v1 = rava_fastframe_stack_pop(frame);
    RavaNanboxValue_t v2 = rava_fastframe_stack_pop(frame);
    RavaNanboxValue_t v3 = rava_fastframe_stack_pop(frame);

    assert(rava_nanbox_as_int(v1) == 30);
    assert(rava_nanbox_as_int(v2) == 20);
    assert(rava_nanbox_as_int(v3) == 10);
    assert(rava_fastframe_stack_is_empty(frame));

    rava_fastframe_reset();
}

TEST(locals) {
    rava_fastframe_init();

    FastFrame_t* frame = rava_fastframe_push(NULL, 8);

    frame->locals[0] = rava_nanbox_int(100);
    frame->locals[1] = rava_nanbox_int(200);
    frame->locals[2] = rava_nanbox_bool(true);

    assert(rava_nanbox_as_int(frame->locals[0]) == 100);
    assert(rava_nanbox_as_int(frame->locals[1]) == 200);
    assert(rava_nanbox_as_bool(frame->locals[2]) == true);

    rava_fastframe_reset();
}

TEST(reset) {
    rava_fastframe_init();

    rava_fastframe_push(NULL, 2);
    rava_fastframe_push(NULL, 2);
    rava_fastframe_push(NULL, 2);

    assert(rava_fastframe_get_depth() == 3);

    rava_fastframe_reset();
    assert(rava_fastframe_get_depth() == 0);
}

TEST(stack_clear) {
    rava_fastframe_init();

    FastFrame_t* frame = rava_fastframe_push(NULL, 4);
    rava_fastframe_stack_push(frame, rava_nanbox_int(1));
    rava_fastframe_stack_push(frame, rava_nanbox_int(2));
    rava_fastframe_stack_push(frame, rava_nanbox_int(3));

    assert(frame->stack_top == 3);

    rava_fastframe_stack_clear(frame);
    assert(frame->stack_top == 0);
    assert(rava_fastframe_stack_is_empty(frame));

    rava_fastframe_reset();
}

int main(void) {
    printf("=== Fast Frame Unit Tests ===\n\n");

    RUN_TEST(init);
    RUN_TEST(push_pop);
    RUN_TEST(nested_frames);
    RUN_TEST(stack_operations);
    RUN_TEST(locals);
    RUN_TEST(reset);
    RUN_TEST(stack_clear);

    printf("\n=== Results: %d tests passed ===\n", tests_passed);
    return 0;
}