pub void test_var_decl() {
    let x = 42;
    assert_eq!(x, 42);

    i32 y = 10;
    assert_eq!(y, 10);

    str* name = "mist";
    assert_eq!(name, "mist");
}

pub void test_var_decl_with_init() {
    let mut x = 0;
    x = 5;
    assert_eq!(x, 5);
}

pub void test_if_statement() {
    let mut x = 0;

    if (true) {
        x = 1;
    }
    assert_eq!(x, 1);

    if (false) {
        x = 2;
    } else {
        x = 3;
    }
    assert_eq!(x, 3);
}

pub void test_if_else_if() {
    let mut x = 0;

    if (x == 1) {
        x = 10;
    } else if (x == 0) {
        x = 20;
    } else {
        x = 30;
    }
    assert_eq!(x, 20);
}

pub void test_while_loop() {
    let mut count = 0;

    while (count < 5) {
        count++;
    }
    assert_eq!(count, 5);
}

pub void test_for_loop() {
    let mut sum = 0;

    for (i : 0..4) {
        sum += i;
    }
    assert_eq!(sum, 6);
}

pub void test_loop_stmt() {
    let mut count = 0;

    loop {
        count++;
        if (count >= 3) {
            break;
        }
    }
    assert_eq!(count, 3);
}

pub void test_break_continue() {
    let mut sum = 0;

    for (i : 0..10) {
        if (i % 2 == 0) {
            continue;
        }
        if (i >= 7) {
            break;
        }
        sum += i;
    }
    assert_eq!(sum, 1 + 3 + 5);
}

pub i32 test_return_from_fn() {
    return 42;
}

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

pub void test_match_literal() {
    let x = 2;
    let mut result = 0;

    match (x) {
        1 => { result = 10; }
        2 => { result = 20; }
        3 => { result = 30; }
        _ => panic!();
    }
    assert_eq!(result, 20);
}

pub void test_match_or_pattern() {
    let x = 1;
    let mut result = 0;

    match (x) {
        1 | 2 => { result = 100; }
        3 => { result = 200; }
        _ => panic!();
    }
    assert_eq!(result, 100);
}

pub void test_match_default() {
    let x = 99;
    let mut result = 0;

    match (x) {
        1 => { result = 10; }
        y => { result = y; }
    }
    assert_eq!(result, 99);
}

pub void test_for_with_pattern_destructure() {
    let pairs = [(1, "a"), (2, "b")];
    let mut keys = 0;

    for ([k, _] : pairs) {
        keys += k;
    }
    assert_eq!(keys, 3);
}

pub void run_tests() {
    test_var_decl();
    test_var_decl_with_init();
    test_if_statement();
    test_if_else_if();
    test_while_loop();
    test_for_loop();
    test_loop_stmt();
    test_break_continue();
    assert_eq!(test_return_from_fn(), 42);
    test_block_scope();
    test_match_literal();
    test_match_or_pattern();
    test_match_default();
    test_for_with_pattern_destructure();
}