Rava/tests/test_nanbox.c

#include "test_utils.h"
#include <math.h>
#include "../runtime/nanbox.h"

UnittestTestResult_t* test_int_basic(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_int_basic");

    RavaNanboxValue_t val = rava_nanbox_int(42);
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_is_int(val), "should be int");
    UNITTEST_ASSERT_FALSE(_unittest_result, rava_nanbox_is_bool(val), "should not be bool");
    UNITTEST_ASSERT_FALSE(_unittest_result, rava_nanbox_is_null(val), "should not be null");
    UNITTEST_ASSERT_EQUAL(_unittest_result, 42, rava_nanbox_as_int(val), "should equal 42");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_int_negative(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_int_negative");

    RavaNanboxValue_t val = rava_nanbox_int(-100);
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_is_int(val), "should be int");
    UNITTEST_ASSERT_EQUAL(_unittest_result, -100, rava_nanbox_as_int(val), "should equal -100");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_int_zero(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_int_zero");

    RavaNanboxValue_t val = rava_nanbox_int(0);
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_is_int(val), "should be int");
    UNITTEST_ASSERT_EQUAL(_unittest_result, 0, rava_nanbox_as_int(val), "should equal 0");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_long_basic(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_long_basic");

    RavaNanboxValue_t val = rava_nanbox_long(1000000000000LL);
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_is_long(val), "should be long");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_bool_true(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_bool_true");

    RavaNanboxValue_t val = rava_nanbox_bool(true);
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_is_bool(val), "should be bool");
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_as_bool(val), "should be true");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_bool_false(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_bool_false");

    RavaNanboxValue_t val = rava_nanbox_bool(false);
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_is_bool(val), "should be bool");
    UNITTEST_ASSERT_FALSE(_unittest_result, rava_nanbox_as_bool(val), "should be false");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_null(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_null");

    RavaNanboxValue_t val = rava_nanbox_null();
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_is_null(val), "should be null");
    UNITTEST_ASSERT_FALSE(_unittest_result, rava_nanbox_is_int(val), "should not be int");
    UNITTEST_ASSERT_FALSE(_unittest_result, rava_nanbox_is_bool(val), "should not be bool");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_double_basic(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_double_basic");

    RavaNanboxValue_t val = rava_nanbox_double(3.14159);
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_is_double(val), "should be double");
    double d = rava_nanbox_as_double(val);
    UNITTEST_ASSERT_TRUE(_unittest_result, fabs(d - 3.14159) < 0.0001, "should equal 3.14159");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_double_negative(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_double_negative");

    RavaNanboxValue_t val = rava_nanbox_double(-123.456);
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_is_double(val), "should be double");
    double d = rava_nanbox_as_double(val);
    UNITTEST_ASSERT_TRUE(_unittest_result, fabs(d - (-123.456)) < 0.0001, "should equal -123.456");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_conversion_int_to_long(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_conversion_int_to_long");

    RavaNanboxValue_t val = rava_nanbox_int(42);
    UNITTEST_ASSERT_EQUAL(_unittest_result, 42, (int)rava_nanbox_to_long(val), "int to long should equal 42");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_conversion_int_to_double(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_conversion_int_to_double");

    RavaNanboxValue_t val = rava_nanbox_int(10);
    UNITTEST_ASSERT_TRUE(_unittest_result, fabs(rava_nanbox_to_double(val) - 10.0) < 0.0001, "int to double should equal 10.0");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_conversion_bool_to_int(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_conversion_bool_to_int");

    RavaNanboxValue_t t = rava_nanbox_bool(true);
    RavaNanboxValue_t f = rava_nanbox_bool(false);
    UNITTEST_ASSERT_EQUAL(_unittest_result, 1, rava_nanbox_to_int(t), "true to int should equal 1");
    UNITTEST_ASSERT_EQUAL(_unittest_result, 0, rava_nanbox_to_int(f), "false to int should equal 0");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_to_bool(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_to_bool");

    UNITTEST_ASSERT_FALSE(_unittest_result, rava_nanbox_to_bool(rava_nanbox_null()), "null to bool should be false");
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_to_bool(rava_nanbox_bool(true)), "true to bool should be true");
    UNITTEST_ASSERT_FALSE(_unittest_result, rava_nanbox_to_bool(rava_nanbox_bool(false)), "false to bool should be false");
    UNITTEST_ASSERT_FALSE(_unittest_result, rava_nanbox_to_bool(rava_nanbox_int(0)), "0 to bool should be false");
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_to_bool(rava_nanbox_int(1)), "1 to bool should be true");
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_to_bool(rava_nanbox_int(-1)), "-1 to bool should be true");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_object_pointer(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_object_pointer");

    int dummy = 42;
    RavaNanboxValue_t val = rava_nanbox_object(&dummy);
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_is_object(val), "should be object");
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_as_object(val) == &dummy, "pointer should match");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_string_pointer(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_string_pointer");

    const char* str = "hello";
    RavaNanboxValue_t val = rava_nanbox_string(str);
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_is_string(val), "should be string");
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_as_string(val) == str, "pointer should match");

    UNITTEST_END_TEST();
}

UnittestTestResult_t* test_array_pointer(void) {
    UNITTEST_BEGIN_TEST("TestNanbox", "test_array_pointer");

    int arr[10];
    RavaNanboxValue_t val = rava_nanbox_array(arr);
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_is_array(val), "should be array");
    UNITTEST_ASSERT_TRUE(_unittest_result, rava_nanbox_as_array(val) == arr, "pointer should match");

    UNITTEST_END_TEST();
}

int main(int argc, char **argv) {
    UnittestConfig_t *config = unittest_config_create();
    config->verbosity = 2;

    if (argc > 1 && strcmp(argv[1], "--json") == 0) {
        config->output_format = UNITTEST_FORMAT_JSON;
        config->use_colors = false;
    }

    UnittestTestSuite_t *suite = unittest_test_suite_create("NaN Boxing Tests");

    UnittestTestCase_t *tc = unittest_test_case_create("TestNanbox");
    unittest_test_case_add_result(tc, test_int_basic());
    unittest_test_case_add_result(tc, test_int_negative());
    unittest_test_case_add_result(tc, test_int_zero());
    unittest_test_case_add_result(tc, test_long_basic());
    unittest_test_case_add_result(tc, test_bool_true());
    unittest_test_case_add_result(tc, test_bool_false());
    unittest_test_case_add_result(tc, test_null());
    unittest_test_case_add_result(tc, test_double_basic());
    unittest_test_case_add_result(tc, test_double_negative());
    unittest_test_case_add_result(tc, test_conversion_int_to_long());
    unittest_test_case_add_result(tc, test_conversion_int_to_double());
    unittest_test_case_add_result(tc, test_conversion_bool_to_int());
    unittest_test_case_add_result(tc, test_to_bool());
    unittest_test_case_add_result(tc, test_object_pointer());
    unittest_test_case_add_result(tc, test_string_pointer());
    unittest_test_case_add_result(tc, test_array_pointer());
    unittest_test_suite_add_test_case(suite, tc);

    unittest_generate_report(suite, config);

    int failures = suite->total_failed + suite->total_errors;
    unittest_test_suite_destroy(suite);
    unittest_config_destroy(config);

    return failures > 0 ? 1 : 0;
}