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)); }