mist/mist-test/src/common/expr_test.mist

pub module expr_test;

pub void test_literals()
{
    assert_eq!(42, 42);
    assert_eq!(3.14, 3.14);
    assert_eq!(true, true);
    assert_eq!(false, false);
    assert_eq!("hello", "hello");
}

pub void test_tuples()
{
    let t = (1, true, "three");
    assert_eq!(t.0, 1);
    assert_eq!(t.1, true);
    assert_eq!(t.2, "three");
}

pub void test_arrays()
{
    let arr = [1, 2, 3];
    assert_eq!(arr[0], 1);
    assert_eq!(arr[1], 2);
    assert_eq!(arr[2], 3);
}

pub void test_array_repeat()
{
    let arr = [0; 5];
    assert_eq!(arr[0], 0);
    assert_eq!(arr[4], 0);
    assert_eq!(arr.len(), 5);
}

pub void test_binary_arith()
{
    assert_eq!(10 + 5, 15);
    assert_eq!(10 - 5, 5);
    assert_eq!(10 * 5, 50);
    assert_eq!(10 / 5, 2);
    assert_eq!(10 % 3, 1);
}

pub void test_binary_cmp()
{
    assert_eq!(5 < 10, true);
    assert_eq!(10 <= 10, true);
    assert_eq!(10 > 5, true);
    assert_eq!(10 >= 10, true);
    assert_eq!(5 == 5, true);
    assert_eq!(5 != 10, true);
}

pub void test_binary_logic()
{
    assert_eq!(true && true, true);
    assert_eq!(true && false, false);
    assert_eq!(true || false, true);
    assert_eq!(false || false, false);
}

pub void test_binary_bit()
{
    assert_eq!(5 & 3, 1);
    assert_eq!(5 | 3, 7);
    assert_eq!(5 ^ 3, 6);
    assert_eq!(1 << 2, 4);
    assert_eq!(4 >> 1, 2);
}

pub void test_prefix()
{
    let x = 42;
    assert_eq!(-x, -42);
    assert_eq!(!true, false);
    assert_eq!(!false, true);
}

pub void test_ref_deref()
{
    let x = 42;
    let r = &x;
    assert_eq!(*r, 42);
}

pub void test_postfix_inc_dec()
{
    let mut x = 5;
    x++;
    assert_eq!(x, 6);
    x--;
    assert_eq!(x, 5);
}

pub void test_as_cast()
{
    let x = 42;
    assert_eq!(x as f64, 42.0);
}

pub void test_closure()
{
    let add = (a, b) => a + b;
    assert_eq!(add(2, 3), 5);
}

pub void test_block_expr()
{
    let x = {
        let y = 10;
        y + 5
    };
    assert_eq!(x, 15);
}

pub void test_if_expr()
{
    let x = if true {
        1
    } else {
        2
    };
    assert_eq!(x, 1);
    let y = if false {
        1
    } else {
        2
    };
    assert_eq!(y, 2);
}

pub void test_range_expr()
{
    let r = 0 .. 5;
    let mut count = 0;
    for i in r {
        count++;
    }
    assert_eq!(count, 5);
}

pub void test_binary_assign()
{
    let mut x = 10;
    x += 5;
    assert_eq!(x, 15);
    x -= 3;
    assert_eq!(x, 12);
    x *= 2;
    assert_eq!(x, 24);
    x /= 4;
    assert_eq!(x, 6);
    x %= 4;
    assert_eq!(x, 2);
}

pub void run_tests()
{
    test_literals();
    test_tuples();
    test_arrays();
    test_array_repeat();
    test_binary_arith();
    test_binary_cmp();
    test_binary_logic();
    test_binary_bit();
    test_prefix();
    test_ref_deref();
    test_postfix_inc_dec();
    test_as_cast();
    test_closure();
    test_block_expr();
    test_if_expr();
    test_range_expr();
    test_binary_assign();
}