use super::harness::*;
use cagire::model::forth::Value;

fn int(n: i64) -> Value {
    Value::Int(n, None)
}

#[test]
fn dup() {
    expect_stack("3 dup", &[int(3), int(3)]);
}

#[test]
fn dup_underflow() {
    expect_error("dup", "stack underflow");
}

#[test]
fn dupn() {
    expect_stack("2 4 dupn", &[int(2), int(2), int(2), int(2)]);
}

#[test]
fn dupn_one() {
    expect_stack("5 1 dupn", &[int(5)]);
}

#[test]
fn dupn_zero() {
    expect_stack("5 0 dupn", &[]);
}

#[test]
fn dupn_underflow() {
    expect_error("3 dupn", "stack underflow");
}

#[test]
fn bang_alias() {
    expect_stack("c4 3 !", &[int(60), int(60), int(60)]);
}

#[test]
fn drop() {
    expect_stack("1 2 drop", &[int(1)]);
}

#[test]
fn drop_underflow() {
    expect_error("drop", "stack underflow");
}

#[test]
fn swap() {
    expect_stack("1 2 swap", &[int(2), int(1)]);
}

#[test]
fn swap_underflow() {
    expect_error("1 swap", "stack underflow");
}

#[test]
fn over() {
    expect_stack("1 2 over", &[int(1), int(2), int(1)]);
}

#[test]
fn over_underflow() {
    expect_error("1 over", "stack underflow");
}

#[test]
fn rot() {
    expect_stack("1 2 3 rot", &[int(2), int(3), int(1)]);
}

#[test]
fn rot_underflow() {
    expect_error("1 2 rot", "stack underflow");
}

#[test]
fn nip() {
    expect_stack("1 2 nip", &[int(2)]);
}

#[test]
fn nip_underflow() {
    expect_error("1 nip", "stack underflow");
}

#[test]
fn tuck() {
    expect_stack("1 2 tuck", &[int(2), int(1), int(2)]);
}

#[test]
fn tuck_underflow() {
    expect_error("1 tuck", "stack underflow");
}

#[test]
fn stack_persists() {
    let f = forth();
    let ctx = default_ctx();
    f.evaluate("1 2 3", &ctx).unwrap();
    assert_eq!(f.stack(), vec![int(1), int(2), int(3)]);
    f.evaluate("4 5", &ctx).unwrap();
    assert_eq!(f.stack(), vec![int(1), int(2), int(3), int(4), int(5)]);
}

#[test]
fn clear_stack() {
    let f = forth();
    f.evaluate("1 2 3", &default_ctx()).unwrap();
    f.clear_stack();
    assert!(f.stack().is_empty());
}