slime/src/testing.cpp

#define epsilon 2.2204460492503131E-16

#define testresult int
#define pass 1
#define fail 0

#define print_assert_equal_fail(variable, value, type, format)          \
    printf("\n%s:%d: Assertion failed\n\tfor '" #variable "'"           \
        "\n\texpected: " format                                         \
        "\n\tgot:      " format "\n",                                   \
        __FILE__, __LINE__, (type)value, (type)variable)

#define print_assert_not_equal_fail(variable, value, type, format)      \
    printf("\n%s:%d: Assertion failed\n\tfor '" #variable "'"           \
           "\n\texpected not: " format                                  \
           "\n\tgot anyways:  " format "\n",                            \
           __FILE__, __LINE__, (type)value, (type)variable)

#define assert_no_error(error)                                          \
    if (error) {                                                        \
        printf("\nExpected no error to occur,"                          \
               " but an error occured anyways:\n");                     \
        log_error();                                                    \
        return fail;                                                    \
    }                                                                   \

#define assert_equal_int(variable, value)                               \
    if (variable != value) {                                            \
        print_assert_equal_fail(variable, value, size_t, "%zd");        \
        return fail;                                                    \
    }

#define assert_not_equal_int(variable, value)                           \
    if (variable == value) {                                            \
        print_assert_not_equal_fail(variable, value, size_t, "%zd");    \
        return fail;                                                    \
    }

#define assert_equal_double(variable, value)                            \
    if (fabs((double)variable - (double)value) > epsilon) {             \
        print_assert_equal_fail(variable, value, double, "%f");         \
        return fail;                                                    \
    }

#define assert_not_equal_double(variable, value)                        \
    if (fabs((double)variable - (double)value) <= epsilon) {            \
        print_assert_not_equal_fail(variable, value, double, "%f");     \
        return fail;                                                    \
    }

#define assert_equal_string(variable, value)                            \
    if (!string_equal(variable, value)) {                               \
        print_assert_equal_fail(&variable->data, value, char*, "%s");    \
        return fail;                                                    \
    }

#define assert_equal_type(node, _type)                          \
    if (node->type != _type) {                                  \
        print_assert_equal_fail(                                \
            Lisp_Object_Type_to_string(node->type),                \
            Lisp_Object_Type_to_string(_type), char*, "%s");       \
        return fail;                                            \
    }                                                           \

#define assert_null(variable)                   \
    assert_equal_int(variable, nullptr)

#define assert_not_null(variable)               \
    assert_not_equal_int(variable, nullptr)

#define invoke_test(name)                                       \
    printf("" #name ":");                                       \
    if (name() == pass) {                                       \
        for(size_t i = strlen(#name); i < 70; ++i)              \
            printf((i%3==1)? "." : " ");                        \
        printf("%spassed%s\n", console_green, console_normal);  \
    }                                                           \
    else {                                                      \
        for(int i = -1; i < 70; ++i)                            \
        printf((i%3==1)? "." : " ");                            \
        printf("%sfailed%s\n", console_red, console_normal);    \
        if(error) {                                             \
            free(error);                                        \
            error = nullptr;                                    \
        }                                                       \
    }                                                           \

proc test_eval_operands() -> testresult {
    char operands_string[] = "((eval 1) (+ 1 2) \"okay\" (eval :haha))";
    Lisp_Object* operands = Parser::parse_single_expression(operands_string);
    int operands_length;
    operands = eval_arguments(operands, Memory::create_built_ins_environment(), &operands_length);

    assert_no_error(error);
    assert_equal_int(list_length(operands), 4);

    assert_equal_type(operands, Lisp_Object_Type::Pair);
    assert_equal_type(operands->value.pair->first, Lisp_Object_Type::Number);
    assert_equal_double(operands->value.pair->first->value.number->value, 1);

    operands = operands->value.pair->rest;

    assert_equal_type(operands, Lisp_Object_Type::Pair);
    assert_equal_type(operands->value.pair->first, Lisp_Object_Type::Number);
    assert_equal_double(operands->value.pair->first->value.number->value, 3);

    operands = operands->value.pair->rest;

    assert_equal_type(operands, Lisp_Object_Type::Pair);
    assert_equal_type(operands->value.pair->first, Lisp_Object_Type::String);
    assert_equal_string(operands->value.pair->first->value.string, "okay");

    operands = operands->value.pair->rest;

    assert_equal_type(operands, Lisp_Object_Type::Pair);
    assert_equal_type(operands->value.pair->first, Lisp_Object_Type::Keyword);
    assert_equal_string(operands->value.pair->first->value.keyword->identifier, "haha");

    return pass;
}

proc test_parse_atom() -> testresult {
    int index_in_text = 0;
    char string[] =
        "123 -1.23e-2 " // numbers
        "\"asd\" "      // strings
        ":key1 :key:2 " // keywords
        "sym +";        // symbols

    // test numbers
    Lisp_Object* result = Parser::parse_atom(string, &index_in_text);

    assert_equal_type(result, Lisp_Object_Type::Number);
    assert_equal_double(result->value.number->value, 123);

    ++index_in_text;

    result = Parser::parse_atom(string, &index_in_text);
    assert_equal_type(result, Lisp_Object_Type::Number);
    assert_equal_double(result->value.number->value, -1.23e-2);

    // test strings
    ++index_in_text;

    result = Parser::parse_atom(string, &index_in_text);
    assert_equal_type(result, Lisp_Object_Type::String);
    assert_equal_string(result->value.string, "asd");

    // test keywords
    ++index_in_text;

    result = Parser::parse_atom(string, &index_in_text);
    assert_equal_type(result, Lisp_Object_Type::Keyword);
    assert_equal_string(result->value.keyword->identifier, "key1");

    ++index_in_text;

    result = Parser::parse_atom(string, &index_in_text);
    assert_equal_type(result, Lisp_Object_Type::Keyword);
    assert_equal_string(result->value.keyword->identifier, "key:2");

    // test symbols
    ++index_in_text;

    result = Parser::parse_atom(string, &index_in_text);
    assert_equal_type(result, Lisp_Object_Type::Symbol);
    assert_equal_string(result->value.symbol->identifier, "sym");

    ++index_in_text;

    result = Parser::parse_atom(string, &index_in_text);
    assert_equal_type(result, Lisp_Object_Type::Symbol);
    assert_equal_string(result->value.symbol->identifier, "+");

    return pass;
}

proc test_parse_expression() -> testresult {
    int index_in_text = 0;
    char string[] = "(fun + 12)";

    Lisp_Object* result = Parser::parse_expression(string, &index_in_text);
    assert_no_error(error);

    assert_equal_type(result, Lisp_Object_Type::Pair);
    assert_equal_type(result->value.pair->first, Lisp_Object_Type::Symbol);
    assert_equal_string(result->value.pair->first->value.symbol->identifier, "fun");

    result = result->value.pair->rest;

    assert_equal_type(result, Lisp_Object_Type::Pair);
    assert_equal_type(result->value.pair->first, Lisp_Object_Type::Symbol);
    assert_equal_string(result->value.pair->first->value.symbol->identifier, "+");

    result = result->value.pair->rest;

    assert_equal_type(result, Lisp_Object_Type::Pair);
    assert_equal_type(result->value.pair->first, Lisp_Object_Type::Number);
    assert_equal_double(result->value.pair->first->value.number->value, 12);

    result = result->value.pair->rest;

    assert_equal_type(result, Lisp_Object_Type::Nil);

    char string2[] = "(define fun (lambda (x) (+ 5 (* x x ))))";
    index_in_text = 0;

    result = Parser::parse_expression(string2, &index_in_text);
    assert_no_error(error);

    assert_equal_type(result, Lisp_Object_Type::Pair);
    assert_equal_type(result->value.pair->first, Lisp_Object_Type::Symbol);
    assert_equal_string(result->value.pair->first->value.symbol->identifier, "define");

    result = result->value.pair->rest;

    assert_equal_type(result, Lisp_Object_Type::Pair);
    assert_equal_type(result->value.pair->first, Lisp_Object_Type::Symbol);
    assert_equal_string(result->value.pair->first->value.symbol->identifier, "fun");

    result = result->value.pair->rest;

    assert_equal_type(result, Lisp_Object_Type::Pair);
    assert_equal_type(result->value.pair->first, Lisp_Object_Type::Pair);
    assert_equal_type(result->value.pair->first->value.pair->first, Lisp_Object_Type::Symbol);
    assert_equal_string(result->value.pair->first->value.pair->first->value.symbol->identifier, "lambda");

    result = result->value.pair->rest;

    return pass;
}

proc test_built_in_add() -> testresult {
    char exp_string[] = "(+ 10 4)";
    Lisp_Object* expression = Parser::parse_single_expression(exp_string);
    Lisp_Object* result = eval_expr(expression, Memory::create_built_ins_environment());

    assert_no_error(error);
    assert_not_null(result);
    assert_equal_type(result, Lisp_Object_Type::Number);
    assert_equal_double(result->value.number->value, 14);

    return pass;
}

proc test_built_in_substract() -> testresult {
    char exp_string[] = "(- 10 4)";
    Lisp_Object* expression = Parser::parse_single_expression(exp_string);
    Lisp_Object* result = eval_expr(expression, Memory::create_built_ins_environment());

    assert_no_error(error);
    assert_not_null(result);
    assert_equal_type(result, Lisp_Object_Type::Number);
    assert_equal_double(result->value.number->value, 6);

    return pass;
}


proc test_built_in_multiply() -> testresult {
    char exp_string[] = "(* 10 4)";
    Lisp_Object* expression = Parser::parse_single_expression(exp_string);
    Lisp_Object* result = eval_expr(expression, Memory::create_built_ins_environment());

    assert_no_error(error);
    assert_not_null(result);
    assert_equal_type(result, Lisp_Object_Type::Number);
    assert_equal_double(result->value.number->value, 40);

    return pass;
}


proc test_built_in_divide() -> testresult {
    char exp_string[] = "(/ 20 4)";
    Lisp_Object* expression = Parser::parse_single_expression(exp_string);
    Lisp_Object* result = eval_expr(expression, Memory::create_built_ins_environment());

    assert_null(error);
    assert_not_null(result);
    assert_equal_type(result, Lisp_Object_Type::Number);
    assert_equal_double(result->value.number->value, 5);

    return pass;
}


proc test_built_in_if() -> testresult {
    char exp_string1[] = "(if 1 4 5)";
    Lisp_Object* expression = Parser::parse_single_expression(exp_string1);
    Lisp_Object* result = eval_expr(expression, Memory::create_built_ins_environment());

    assert_no_error(error);
    assert_not_null(result);
    assert_equal_type(result, Lisp_Object_Type::Number);
    assert_equal_double(result->value.number->value, 4);

    char exp_string2[] = "(if () 4 5)";
    expression = Parser::parse_single_expression(exp_string2);
    result = eval_expr(expression, Memory::create_built_ins_environment());

    assert_no_error(error);
    assert_not_null(result);
    assert_equal_type(result, Lisp_Object_Type::Number);
    assert_equal_double(result->value.number->value, 5);

    return pass;
}

proc test_built_in_and() -> testresult {
    char exp_string1[] = "(and 1 \"asd\" 4)";
    Lisp_Object* expression = Parser::parse_single_expression(exp_string1);
    Lisp_Object* result = eval_expr(expression, Memory::create_built_ins_environment());

    assert_no_error(error);
    assert_not_null(result);
    assert_equal_type(result, Lisp_Object_Type::T);

    // a false case
    char exp_string2[] = "(and () \"asd\" 4)";
    expression = Parser::parse_single_expression(exp_string2);
    result = eval_expr(expression, Memory::create_built_ins_environment());

    assert_no_error(error);
    assert_not_null(result);
    assert_equal_type(result, Lisp_Object_Type::Nil);

    return pass;
}

proc test_built_in_or() -> testresult {
    char exp_string1[] = "(or \"asd\" nil)";
    Lisp_Object* expression = Parser::parse_single_expression(exp_string1);
    Lisp_Object* result = eval_expr(expression, Memory::create_built_ins_environment());

    assert_no_error(error);
    assert_not_null(result);
    assert_equal_type(result, Lisp_Object_Type::T);

    // a false case
    char exp_string2[] = "(or () ())";
    expression = Parser::parse_single_expression(exp_string2);
    result = eval_expr(expression, Memory::create_built_ins_environment());

    assert_no_error(error);
    assert_not_null(result);
    assert_equal_type(result, Lisp_Object_Type::Nil);

    return pass;
}


proc test_built_in_not() -> testresult {
    char exp_string1[] = "(not ())";
    Lisp_Object* expression = Parser::parse_single_expression(exp_string1);
    Lisp_Object* result = eval_expr(expression, Memory::create_built_ins_environment());

    // a true case
    assert_no_error(error);
    assert_not_null(result);
    assert_equal_type(result, Lisp_Object_Type::T);

    // a false case
    char exp_string2[] = "(not \"asd xD\")";
    expression = Parser::parse_single_expression(exp_string2);
    result = eval_expr(expression, Memory::create_built_ins_environment());

    assert_no_error(error);
    assert_not_null(result);
    assert_equal_type(result, Lisp_Object_Type::Nil);

    return pass;
}

proc run_all_tests() -> void {
    log_level = Log_Level::None;
    Memory::init();
    Parser::init(Memory::create_built_ins_environment());

    printf("-- Parsing --\n");
    invoke_test(test_parse_atom);
    invoke_test(test_parse_expression);

    printf("\n-- Basic evaluating --\n");
    invoke_test(test_eval_operands);

    printf("\n-- Built ins --\n");
    invoke_test(test_built_in_add);
    invoke_test(test_built_in_substract);
    invoke_test(test_built_in_multiply);
    invoke_test(test_built_in_divide);
    invoke_test(test_built_in_if);
    invoke_test(test_built_in_and);
    invoke_test(test_built_in_or);
    invoke_test(test_built_in_not);
}

#undef epsilon
#undef testresult
#undef pass
#undef fail

#undef print_assert_equal_fail
#undef print_assert_not_equal_fail
#undef assert_no_error
#undef assert_equal_int
#undef assert_not_equal_int
#undef assert_equal_double
#undef assert_not_equal_double
#undef assert_equal_string
#undef assert_equal_type
#undef assert_null
#undef assert_not_null
#undef invoke_test