uxn/tests/vm_tests.rs

994 lines
26 KiB
Rust

use uxn::isa::Icode;
use uxn::vm::*;
#[test]
fn test_brk() {
let mut vm = Uxn::of1(&[Icode::BRK]);
assert_eq!(vm.step(), Err(UxnError::Break));
}
#[test]
fn test_lit() {
let mut vm = Uxn::of1(&[Icode::LIT, 0x01, Icode::BRK]);
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().peek1(), Ok(0x01));
}
#[test]
fn test_lit2() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xFF, 0xAA,
Icode::BRK, // BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().peek2(), Ok(0xFFAA));
}
#[test]
fn test_litr() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::RETURN, 0xAA,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.rst.borrow().peek1(), Ok(0xAA));
}
#[test]
fn test_inc() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xFF, 0xAA,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().peek2(), Ok(0xFFAA));
}
#[test]
fn test_pop1() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xFF,
Icode::LIT, 0xAA,
Icode::POP,
Icode::LIT, 0xBB,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().peek2(), Ok(0xFFBB));
}
#[test]
fn test_pop2() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xFF,
Icode::LIT, 0xAA,
Icode::LIT, 0xBB,
Icode::POP | Icode::SHORT,
Icode::LIT, 0xCC,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().peek2(), Ok(0xFFCC));
}
#[test]
fn test_popk() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xFF,
Icode::POP | Icode::KEEP,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xFF));
}
#[test]
fn test_nip() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xAA,
Icode::LIT, 0xBB,
Icode::NIP,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xBB));
}
#[test]
fn test_nip2() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xAA, 0x00,
Icode::LIT | Icode::SHORT, 0xBB, 0x00,
Icode::NIP | Icode::SHORT,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().peek2(), Ok(0xBB00));
}
#[test]
fn test_nipk() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xAA,
Icode::LIT, 0xBB,
Icode::NIP | Icode::KEEP,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xAA));
assert_eq!(vm.wst.borrow().get1(1), Ok(0xBB));
assert_eq!(vm.wst.borrow().get1(2), Ok(0xBB));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xBB));
}
#[test]
fn test_swp() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xAA,
Icode::LIT, 0xBB,
Icode::SWP,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xBB));
assert_eq!(vm.wst.borrow().get1(1), Ok(0xAA));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xAA));
}
#[test]
fn test_swp2() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xAA, 0x00,
Icode::LIT | Icode::SHORT, 0xBB, 0x00,
Icode::SWP | Icode::SHORT,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get2(0), Ok(0xBB00));
assert_eq!(vm.wst.borrow().get2(2), Ok(0xAA00));
assert_eq!(vm.wst.borrow().peek2(), Ok(0xAA00));
}
#[test]
fn test_swpk() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xAA,
Icode::LIT, 0xBB,
Icode::SWP | Icode::KEEP,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xAA));
assert_eq!(vm.wst.borrow().get1(1), Ok(0xBB));
assert_eq!(vm.wst.borrow().get1(2), Ok(0xBB));
assert_eq!(vm.wst.borrow().get1(3), Ok(0xAA));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xAA));
}
#[test]
fn test_rot() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xAA,
Icode::LIT, 0xBB,
Icode::LIT, 0xCC,
Icode::ROT,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xBB));
assert_eq!(vm.wst.borrow().get1(1), Ok(0xCC));
assert_eq!(vm.wst.borrow().get1(2), Ok(0xAA));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xAA));
}
#[test]
fn test_rot_cycle() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xAA,
Icode::LIT, 0xBB,
Icode::LIT, 0xCC,
Icode::ROT,
Icode::ROT,
Icode::ROT,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xAA));
assert_eq!(vm.wst.borrow().get1(1), Ok(0xBB));
assert_eq!(vm.wst.borrow().get1(2), Ok(0xCC));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xCC));
}
#[test]
fn test_dup() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xAA,
Icode::LIT, 0xBB,
Icode::DUP,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xAA));
assert_eq!(vm.wst.borrow().get1(1), Ok(0xBB));
assert_eq!(vm.wst.borrow().get1(2), Ok(0xBB));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xBB));
}
#[test]
fn test_ovr() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xAA,
Icode::LIT, 0xBB,
Icode::OVR,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xAA));
assert_eq!(vm.wst.borrow().get1(1), Ok(0xBB));
assert_eq!(vm.wst.borrow().get1(2), Ok(0xAA));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xAA));
}
#[test]
fn test_eql_neg() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xAA,
Icode::LIT, 0xBB,
Icode::EQL,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0x00));
assert_eq!(vm.wst.borrow().peek1(), Ok(0x00));
}
#[test]
fn test_eql_pos() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xAA,
Icode::LIT, 0xAA,
Icode::EQL,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0x01));
assert_eq!(vm.wst.borrow().peek1(), Ok(0x01));
}
#[test]
fn test_neq_neg() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xAA,
Icode::LIT, 0xAA,
Icode::NEQ,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0x00));
assert_eq!(vm.wst.borrow().peek1(), Ok(0x00));
}
#[test]
fn test_neq_pos() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xAA,
Icode::LIT, 0xBB,
Icode::NEQ,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0x01));
assert_eq!(vm.wst.borrow().peek1(), Ok(0x01));
}
#[test]
fn test_gth_neg() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0x00,
Icode::LIT, 0x01,
Icode::GTH,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0x00));
assert_eq!(vm.wst.borrow().peek1(), Ok(0x00));
}
#[test]
fn test_gth_pos() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0x01,
Icode::LIT, 0x00,
Icode::GTH,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0x01));
assert_eq!(vm.wst.borrow().peek1(), Ok(0x01));
}
#[test]
fn test_lth_neg() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0x01,
Icode::LIT, 0x00,
Icode::LTH,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0x00));
assert_eq!(vm.wst.borrow().peek1(), Ok(0x00));
}
#[test]
fn test_lth_pos() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0x00,
Icode::LIT, 0x01,
Icode::LTH,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0x01));
assert_eq!(vm.wst.borrow().peek1(), Ok(0x01));
}
#[test]
fn test_jmprp() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xAA,
Icode::LIT, 0x03,
Icode::JMP,
Icode::POP,
Icode::LIT, 0xFF,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xAA));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xAA));
}
#[test]
fn test_jmpa() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x01, 0x10, Icode::JMP | Icode::SHORT,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
Icode::LIT, 0xAA,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xAA));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xAA));
}
#[test]
fn test_jmprn() {
// Negative relative jup
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x01, 0x10, Icode::JMP | Icode::SHORT,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
// Negative relative jump target
Icode::LIT, 0xAA, Icode::BRK, 0x00,
// Absolute jump target
Icode::LIT, -7i8 as u8, Icode::JMP,
// Wrong arm
Icode::LIT, 0xFF,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xAA));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xAA));
}
#[test]
fn test_jmpc_true() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0x01,
Icode::LIT, 0x03,
Icode::JCN,
// Fall through
Icode::LIT, 0xFF, Icode::BRK,
// Target
Icode::LIT, 0xAA, Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xAA));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xAA));
}
#[test]
fn test_jmpc_false() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0x00,
Icode::LIT, 0x03,
Icode::JCN,
// Fall through
Icode::LIT, 0xFF, Icode::BRK,
// Target
Icode::LIT, 0xAA, Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xFF));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xFF));
}
#[test]
fn test_jsr() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0x05, Icode::JSR, 0x00,
// Fall through
0x00, 0x00, 0x00, 0x00,
// Target
Icode::LIT, 0xAA, Icode::BRK, 0x00,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xAA));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xAA));
assert_eq!(vm.rst.borrow().get2(0), Ok(0x0103));
assert_eq!(vm.rst.borrow().peek2(), Ok(0x0103));
}
#[test]
fn test_jsra() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x01, 0x08, Icode::JSR | Icode::SHORT,
// Fall through
0x00, 0x00, 0x00, 0x00,
// Target
Icode::LIT, 0xAA, Icode::BRK, 0x00,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0xAA));
assert_eq!(vm.wst.borrow().peek1(), Ok(0xAA));
assert_eq!(vm.rst.borrow().get2(0), Ok(0x0104));
assert_eq!(vm.rst.borrow().peek2(), Ok(0x0104));
}
#[test]
fn test_sth() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x01, 0x08, Icode::STH,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().get1(0), Ok(0x01));
assert_eq!(vm.wst.borrow().peek1(), Ok(0x01));
assert_eq!(vm.rst.borrow().get1(0), Ok(0x08));
assert_eq!(vm.rst.borrow().peek1(), Ok(0x08));
}
#[test]
fn test_sth2() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x01, 0x08, Icode::STH | Icode::SHORT,
Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.rst.borrow().get2(0), Ok(0x0108));
assert_eq!(vm.rst.borrow().peek2(), Ok(0x0108));
}
#[test]
fn test_ldz() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0x0b, Icode::LDZ, Icode::BRK,
]);
vm.sta1(0x000b, 0xFF).unwrap();
}
// Make sure the write took
assert_eq!(vm.lda1(0x00b).unwrap(), 0xFF);
// Run the example
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 1);
assert_eq!(vm.wst.borrow().peek1(), Ok(0xFF));
}
#[test]
fn test_ldz2() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0x0b, Icode::LDZ | Icode::SHORT, Icode::BRK,
]);
vm.sta2(0x000b, 0xFFEE).unwrap();
}
// Make sure the write took
assert_eq!(vm.lda1(0x00b).unwrap(), 0xFF);
// Run the example
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 2);
assert_eq!(vm.wst.borrow().peek2(), Ok(0xFFEE));
}
#[test]
fn test_stz() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xFF, Icode::LIT, 0x0b,
Icode::STZ, Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 0);
assert_eq!(vm.lda1(0x000b), Ok(0xFF));
}
#[test]
fn test_stz2() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xFF, Icode::LIT, 0x0b,
Icode::STZ, Icode::BRK,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 0);
assert_eq!(vm.lda1(0x000b), Ok(0xFF));
}
#[test]
fn test_ldr() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0x01, Icode::LDR, Icode::BRK,
0xFF,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 1);
assert_eq!(vm.wst.borrow().peek1(), Ok(0xFF));
}
#[test]
fn test_ldr2() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0x01, Icode::LDR | Icode::SHORT, Icode::BRK,
0xFF, 0xEE
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 2);
assert_eq!(vm.wst.borrow().peek2(), Ok(0xFFEE));
}
#[test]
fn test_str() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xEE, Icode::LIT, 0x03,
Icode::STR, Icode::BRK, 0x00, 0x00,
0xFF, // Will be overwritten
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 0);
assert_eq!(vm.lda1(0x0108), Ok(0xEE));
}
#[test]
fn test_str2() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xEE, 0xDD, Icode::LIT,
0x02, Icode::STR | Icode::SHORT, Icode::BRK, 0x00,
0xFF, 0xFF // Will be overwritten
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 0);
assert_eq!(vm.lda2(0x0108), Ok(0xEEDD));
}
#[test]
fn test_lda() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x01, 0x08, Icode::LDA,
Icode::BRK, 0x00, 0x00, 0x00,
0xEE,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 1);
assert_eq!(vm.wst.borrow().peek1(), Ok(0xEE));
}
#[test]
fn test_lda2() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x01, 0x08, Icode::LDA | Icode::SHORT,
Icode::BRK, 0x00, 0x00, 0x00,
0xEE, 0xDD,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 2);
assert_eq!(vm.wst.borrow().peek2(), Ok(0xEEDD));
}
#[test]
fn test_sta() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT, 0xFF, Icode::NOP, Icode::NOP,
Icode::LIT | Icode::SHORT, 0x01, 0x0c, Icode::NOP,
Icode::STA, Icode::BRK, 0x00, 0x00,
0x00,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 0);
assert_eq!(vm.lda1(0x010c), Ok(0xFF));
}
#[test]
fn test_sta2() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xFF, 0xEE, Icode::NOP,
Icode::LIT | Icode::SHORT, 0x01, 0x0c, Icode::NOP,
Icode::STA | Icode::SHORT, Icode::BRK, Icode::NOP,
0x00, 0x00,
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 0);
assert_eq!(vm.lda2(0x010c), Ok(0xFFEE));
}
#[test]
fn test_add() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xFF, 0x01, Icode::ADD, Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 1);
assert_eq!(vm.wst.borrow().peek1(), Ok(0x00));
}
#[test]
fn test_add2() {
// The incantation for adding a u8 to a u16 is probably something involving using [ LIT #00 SWP ] but yeesh.
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xFF, 0x00,
Icode::LIT, 0x01,
// Promote u8 to u16 by stuffing an #00 in there. Yes coulda used a bigger lit but playing with the upcast.
Icode::LIT, 0x0,
Icode::SWP,
// u16 + u16
Icode::ADD | Icode::SHORT,
Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 2);
assert_eq!(vm.wst.borrow().peek2(), Ok(0xFF01));
}
#[test]
fn test_sub() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xFF, 0x01, Icode::SUB, Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 1);
assert_eq!(vm.wst.borrow().peek1(), Ok(0xFE));
}
#[test]
fn test_sub2() {
// The incantation for adding a u8 to a u16 is probably something involving using [ LIT #00 SWP ] but yeesh.
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xFF, 0xFF,
Icode::LIT, 0x01,
// Promote u8 to u16 by stuffing an #00 in there. Yes coulda used a bigger lit but playing with the upcast.
Icode::LIT, 0x0,
Icode::SWP,
Icode::SUB | Icode::SHORT,
Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 2);
assert_eq!(vm.wst.borrow().peek2(), Ok(0xFFFE));
}
#[test]
fn test_mul() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x4, 0x4, Icode::MUL, Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 1);
assert_eq!(vm.wst.borrow().peek1(), Ok(0x10));
}
#[test]
fn test_mul2() {
// The incantation for adding a u8 to a u16 is probably something involving using [ LIT #00 SWP ] but yeesh.
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xFF, 0xFF,
Icode::LIT, 0x01,
// Promote u8 to u16 by stuffing an #00 in there. Yes coulda used a bigger lit but playing with the upcast.
Icode::LIT, 0x0,
Icode::SWP,
Icode::MUL | Icode::SHORT,
Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 2);
assert_eq!(vm.wst.borrow().peek2(), Ok(0xFFFF));
}
#[test]
fn test_div() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x10, 0x4, Icode::DIV, Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 1);
assert_eq!(vm.wst.borrow().peek1(), Ok(0x4));
}
#[test]
fn test_div2() {
// The incantation for adding a u8 to a u16 is probably something involving using [ LIT #00 SWP ] but yeesh.
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x10, 0x00,
Icode::LIT, 0x2,
// Promote u8 to u16 by stuffing an #00 in there. Yes coulda used a bigger lit but playing with the upcast.
Icode::LIT, 0x0,
Icode::SWP,
Icode::DIV | Icode::SHORT,
Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 2);
assert_eq!(vm.wst.borrow().peek2(), Ok(0x0800));
}
#[test]
fn test_and() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xF, 0x1, Icode::AND, Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 1);
assert_eq!(vm.wst.borrow().peek1(), Ok(0x1));
}
#[test]
fn test_and2() {
// The incantation for adding a u8 to a u16 is probably something involving using [ LIT #00 SWP ] but yeesh.
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x10, 0x03,
Icode::LIT, 0x2,
// Promote u8 to u16 by stuffing an #00 in there. Yes coulda used a bigger lit but playing with the upcast.
Icode::LIT, 0x0,
Icode::SWP,
Icode::AND | Icode::SHORT,
Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 2);
assert_eq!(vm.wst.borrow().peek2(), Ok(0x0002));
}
#[test]
fn test_or() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xF, 0x1,
Icode::OR,
Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 1);
assert_eq!(vm.wst.borrow().peek1(), Ok(0xF));
}
#[test]
fn test_or2() {
// The incantation for adding a u8 to a u16 is probably something involving using [ LIT #00 SWP ] but yeesh.
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x10, 0x03,
Icode::LIT, 0x2,
// Promote u8 to u16 by stuffing an #00 in there. Yes coulda used a bigger lit but playing with the upcast.
Icode::LIT, 0x0,
Icode::SWP,
Icode::OR | Icode::SHORT,
Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 2);
assert_eq!(vm.wst.borrow().peek2(), Ok(0x1003));
}
#[test]
fn test_xor() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0xF, 0x1,
Icode::XOR,
Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 1);
assert_eq!(vm.wst.borrow().peek1(), Ok(0xE));
}
#[test]
fn test_xor2() {
// The incantation for adding a u8 to a u16 is probably something involving using [ LIT #00 SWP ] but yeesh.
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x10, 0x03,
Icode::LIT, 0x2,
// Promote u8 to u16 by stuffing an #00 in there. Yes coulda used a bigger lit but playing with the upcast.
Icode::LIT, 0x0,
Icode::SWP,
Icode::XOR | Icode::SHORT,
Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 2);
assert_eq!(vm.wst.borrow().peek2(), Ok(0x1001));
}
#[test]
fn test_sft_l() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x0F, 0x10,
Icode::SFT,
Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 1);
assert_eq!(vm.wst.borrow().peek1(), Ok(0x1E));
}
#[test]
fn test_sft_r() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x0F, 0x01,
Icode::SFT,
Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 1);
assert_eq!(vm.wst.borrow().peek1(), Ok(0x07));
}
#[test]
fn test_sft_rl2() {
nofmt::pls! {
let mut vm = Uxn::of1(&[
Icode::LIT | Icode::SHORT, 0x80, 0x01,
Icode::LIT, 0x21, // Shift truncates, so this will unset all the bits
Icode::SFT | Icode::SHORT,
Icode::BRK
]);
}
assert_eq!(vm.run(64), Err(UxnError::Break));
assert_eq!(vm.wst.borrow().idx(), 2);
assert_eq!(vm.wst.borrow().peek2(), Ok(0x0000));
}