langatator/tests/test_evaluation.c

#include <stdio.h>
#include <assert.h>
#include <string.h>
#include "../src/types.h"
#include "../src/number_parsing.h"
#include "../src/utils.h"
#include "../src/evaluator.h"
#include "../src/state.h"

void test_evaluation()
{
    printf_wrap("== test evaluation == \n");

    struct StateContainer* state = state_init();

    // test int parsing
    int resVal = 0;
    unsigned char resType = 0;

    evaluate(state, "-4", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(-4 == resVal);

    evaluate(state, "  -    6   ", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(-6 == resVal);

    evaluate(state, " 1+ (-    45  ) ", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(-44 == resVal);

    evaluate(state, "-(4+9)+1", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(-12 == resVal);

    evaluate(state, "(-(8-9+5))+8", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(4 == resVal);

    evaluate(state, "2^6", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(64 == resVal);

    evaluate(state, "3 + 4", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(7 == resVal);

    evaluate(state, "(2*4)+0+0", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(8 == resVal);

    evaluate(state, "2.5-(2+0.1)", &resVal, &resType);
    assert(resType == TYPE_FLOAT);
    assert(float_almost_equal(0.4, get_float_from_int_rep(resVal)));

    evaluate(state, "1^0 +  (7*(5 +2))", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(50 == resVal);

    evaluate(state, "- ( 0.1+ 0.3 )", &resVal, &resType);
    assert(resType == TYPE_FLOAT);
    assert(float_almost_equal(-0.4, get_float_from_int_rep(resVal)));

    /* FUNCTIONS */

    evaluate(state, "sqrt(2)-1", &resVal, &resType);
    assert(resType == TYPE_FLOAT);
    assert(float_almost_equal(0.41421, get_float_from_int_rep(resVal)));

    evaluate(state, "(abs((0-1)*2)) + abs(2)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(4 == resVal);

    evaluate(state, "exp(2)-1", &resVal, &resType);
    assert(resType == TYPE_FLOAT);
    assert(float_almost_equal(6.389, get_float_from_int_rep(resVal)));
    
    evaluate(state, "(cos(2)^2)+(sin(2)^2)", &resVal, &resType);
    assert(resType == TYPE_FLOAT);
    assert(float_almost_equal(1, get_float_from_int_rep(resVal)));

    evaluate(state, "ceil(1.5)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(2 == resVal);

    evaluate(state, "floor(1.5)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(1 == resVal);

    evaluate(state, "floor(1.001)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(1 == resVal);
    
    evaluate(state, "random_int(1, 100)", &resVal, &resType);
    assert(resType == TYPE_INT);
    printf_wrap(" - random int: %d \n", resVal);

    evaluate(state, "abs(2)+abs(-2)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(4 == resVal);

    evaluate(state, "max(25, 4)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(25 == resVal);

    evaluate(state, "max(-25, 42)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(42 == resVal);

    evaluate(state, "max( (1+1)^(6+1-1) , 4+2)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(64 == resVal);

    evaluate(state, "max(floor(exp(1))^(4+1) , -2)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(32 == resVal);

    // testing function composition is important
    evaluate(state, "abs(abs(-2))", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(2 == resVal);

    /* COMPARAISON OPERATORS */
    evaluate(state, "2 = 2", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(1 == resVal);

    evaluate(state, "2 = 3", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(0 == resVal);

    evaluate(state, "2 = 3.2", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(0 == resVal);

    evaluate(state, "!(2 = 3)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(1 == resVal);

    evaluate(state, "!! 0", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(0 == resVal);

    evaluate(state, "(! (! 1)) + 0", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(1 == resVal);

    evaluate(state, "!!2", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(1 == resVal);

    evaluate(state, "1 & 1", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(1 == resVal);

    evaluate(state, "1 & ((1+0)-1)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(0 == resVal);

    evaluate(state, "1 & (1 | 0)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(1 == resVal);

    evaluate(state, "0 > 0", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(0 == resVal);

    evaluate(state, "-45 < 1", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(1 == resVal);

    evaluate(state, "5 > 0", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(1 == resVal);

    evaluate(state, "5 % 10", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(5 == resVal);

    evaluate(state, "5.3 % 10", &resVal, &resType);
    assert(resType == TYPE_FLOAT);
    assert(float_almost_equal(5.3, get_float_from_int_rep(resVal)));

    /* VARIABLES */
    int ex = 43;
    var_store_set(state->varStore, "var", TYPE_INT, (void*) &ex);
    evaluate(state, "var", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(43 == resVal);

    evaluate(state, "var < 52", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(1 == resVal);

    evaluate(state, "var < (52-2)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(1 == resVal);

    int ex2 = 3;
    var_store_set(state->varStore, "var2", TYPE_INT, (void*) &ex2);

    evaluate(state, "abs((var2^2)-((var-41)^2))+2", &resVal, &resType);
    assert(resType == TYPE_INT);
    printf_wrap("actually got: %d \n", resVal);
    assert(7 == resVal);

    /* TYPE FUNCS */
    evaluate(state, "is_number(123)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(resVal);

    evaluate(state, "is_number(-25.5)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(resVal);

    evaluate(state, "is_number(NULL)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(!resVal);

    evaluate(state, "is_null(NULL)", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(resVal);

    evaluate(state, "(is_null(NULL) & is_number(42)) | 0", &resVal, &resType);
    assert(resType == TYPE_INT);
    assert(resVal);
}