427 lines
11 KiB
Rust
427 lines
11 KiB
Rust
//! Testing methods on Chirp's public API
|
|
use chirp::prelude::*;
|
|
use std::{collections::hash_map::DefaultHasher, hash::Hash};
|
|
|
|
#[test]
|
|
fn chip8() {
|
|
let ch8 = Chip8::default(); // Default
|
|
let ch82 = ch8.clone(); // Clone
|
|
assert_eq!(ch8, ch82); // PartialEq
|
|
println!("{ch8:?}"); // Debug
|
|
}
|
|
|
|
mod bus {
|
|
use super::*;
|
|
mod region {
|
|
use super::*;
|
|
// #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[test]
|
|
fn copy() {
|
|
let r1 = Screen;
|
|
let r2 = r1;
|
|
assert_eq!(r1, r2);
|
|
}
|
|
#[test]
|
|
#[allow(clippy::clone_on_copy)]
|
|
fn clone() {
|
|
let r1 = Screen;
|
|
let r2 = r1.clone();
|
|
assert_eq!(r1, r2);
|
|
}
|
|
#[test]
|
|
fn display() {
|
|
println!("{Charset}{Program}{Screen}{Stack}{Count}");
|
|
}
|
|
#[test]
|
|
fn debug() {
|
|
println!("{Charset:?}{Program:?}{Screen:?}{Stack:?}{Count:?}");
|
|
}
|
|
// lmao the things you do for test coverage
|
|
#[test]
|
|
fn eq() {
|
|
assert_eq!(Screen, Screen);
|
|
assert_ne!(Charset, Program);
|
|
}
|
|
#[test]
|
|
fn ord() {
|
|
assert_eq!(Stack, Charset.max(Program).max(Screen).max(Stack));
|
|
assert!(Charset < Program && Program < Screen && Screen < Stack);
|
|
}
|
|
#[test]
|
|
fn hash() {
|
|
let mut hasher = DefaultHasher::new();
|
|
Stack.hash(&mut hasher);
|
|
println!("{hasher:?}");
|
|
}
|
|
}
|
|
#[test]
|
|
#[should_panic]
|
|
fn bus_missing_region() {
|
|
// Print the screen of a bus with no screen
|
|
bus! {}.print_screen().unwrap()
|
|
}
|
|
}
|
|
|
|
mod cpu {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn set_break() {
|
|
let mut cpu = CPU::default();
|
|
let point = 0x234;
|
|
assert_eq!(cpu.breakpoints(), &[]);
|
|
// Attempt to set the same breakpoint 100 times
|
|
for _ in 0..100 {
|
|
cpu.set_break(point);
|
|
}
|
|
assert_eq!(cpu.breakpoints(), &[point]);
|
|
}
|
|
#[test]
|
|
fn unset_break() {
|
|
let mut cpu = CPU::default();
|
|
let point = 0x234;
|
|
// set TWO breakpoints
|
|
cpu.set_break(point + 1);
|
|
cpu.set_break(point);
|
|
assert_eq!(cpu.breakpoints(), &[point + 1, point]);
|
|
// Attempt to unset the same breakpoint 100 times
|
|
for _ in 0..100 {
|
|
cpu.unset_break(point);
|
|
}
|
|
// Only unset the matching point
|
|
assert_eq!(cpu.breakpoints(), &[point + 1]);
|
|
}
|
|
|
|
#[test]
|
|
fn press_invalid_key() {
|
|
let mut cpu = CPU::default();
|
|
let cpu2 = cpu.clone();
|
|
cpu.press(0x21345134);
|
|
// no change has been made
|
|
assert_eq!(cpu, cpu2);
|
|
}
|
|
#[test]
|
|
fn release_invalid_key() {
|
|
let mut cpu = CPU::default();
|
|
let cpu2 = cpu.clone();
|
|
cpu.release(0x21345134);
|
|
// no change has been made
|
|
assert_eq!(cpu, cpu2);
|
|
}
|
|
#[test]
|
|
fn set_invalid_gpr() {
|
|
let mut cpu = CPU::default();
|
|
let cpu2 = cpu.clone();
|
|
cpu.set_v(0x21345134, 0xff);
|
|
// no change has been made
|
|
assert_eq!(cpu, cpu2);
|
|
}
|
|
mod controlflags {
|
|
use super::*;
|
|
//#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[test]
|
|
fn clone() {
|
|
let cf1 = ControlFlags {
|
|
debug: false,
|
|
pause: false,
|
|
keypause: false,
|
|
vbi_wait: false,
|
|
lastkey: None,
|
|
quirks: Default::default(),
|
|
monotonic: None,
|
|
};
|
|
let cf2 = cf1.clone();
|
|
assert_eq!(cf1, cf2)
|
|
}
|
|
#[test]
|
|
fn debug() {
|
|
println!("{:?}", ControlFlags::default());
|
|
}
|
|
#[test]
|
|
fn default() {
|
|
assert_eq!(
|
|
ControlFlags::default(),
|
|
ControlFlags {
|
|
debug: false,
|
|
pause: false,
|
|
keypause: false,
|
|
vbi_wait: false,
|
|
lastkey: Default::default(),
|
|
quirks: Default::default(),
|
|
monotonic: Default::default()
|
|
}
|
|
)
|
|
}
|
|
#[test]
|
|
fn eq() {
|
|
let cf1 = ControlFlags::default();
|
|
let cf2 = ControlFlags {
|
|
debug: true,
|
|
pause: true,
|
|
keypause: true,
|
|
vbi_wait: true,
|
|
lastkey: Default::default(),
|
|
quirks: Default::default(),
|
|
monotonic: Default::default(),
|
|
};
|
|
assert_ne!(cf1, cf2);
|
|
}
|
|
#[test]
|
|
fn ord() {
|
|
let cf1 = ControlFlags::default();
|
|
let cf2 = ControlFlags {
|
|
debug: true,
|
|
pause: true,
|
|
keypause: true,
|
|
vbi_wait: true,
|
|
lastkey: Default::default(),
|
|
quirks: Default::default(),
|
|
monotonic: Default::default(),
|
|
};
|
|
assert!(cf1 < cf2);
|
|
assert_eq!(ControlFlags::default(), cf1.min(cf2));
|
|
}
|
|
#[test]
|
|
fn hash() {
|
|
let mut hasher = DefaultHasher::new();
|
|
ControlFlags::default().hash(&mut hasher);
|
|
println!("{:?}", hasher);
|
|
}
|
|
}
|
|
}
|
|
|
|
mod dis {
|
|
use chirp::cpu::disassembler::Insn;
|
|
use imperative_rs::InstructionSet;
|
|
|
|
#[test]
|
|
#[allow(clippy::clone_on_copy)]
|
|
fn clone() {
|
|
let opcode = Insn::decode(&[0xef, 0xa1]).unwrap().1; // random valid opcode
|
|
let clone = opcode.clone();
|
|
assert_eq!(opcode, clone);
|
|
}
|
|
#[test]
|
|
fn debug() {
|
|
println!("{:?}", Insn::decode(b"AA")) // "sne #41, v1"
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn error() {
|
|
let error = chirp::error::Error::MissingRegion { region: Screen };
|
|
// Print it with Display and Debug
|
|
println!("{error} {error:?}");
|
|
}
|
|
|
|
mod ui_builder {
|
|
use super::*;
|
|
#[test]
|
|
fn ui_builder() -> Result<()> {
|
|
let builder = UIBuilder::new(32, 64).rom("dummy.ch8").build()?;
|
|
println!("{builder:?}");
|
|
Ok(())
|
|
}
|
|
#[test]
|
|
fn default() {
|
|
let ui_builder = UIBuilder::default();
|
|
println!("{ui_builder:?}");
|
|
}
|
|
#[test]
|
|
#[allow(clippy::redundant_clone)]
|
|
fn clone_debug() {
|
|
let ui_builder_clone = UIBuilder::default().clone();
|
|
println!("{ui_builder_clone:?}");
|
|
}
|
|
}
|
|
mod ui {
|
|
use super::*;
|
|
fn new_chip8() -> Chip8 {
|
|
Chip8 {
|
|
cpu: CPU::default(),
|
|
bus: bus! {},
|
|
}
|
|
}
|
|
#[test]
|
|
fn frame() -> Result<()> {
|
|
let mut ui = UIBuilder::new(32, 64).build()?;
|
|
let mut ch8 = new_chip8();
|
|
ui.frame(&mut ch8).unwrap();
|
|
Ok(())
|
|
}
|
|
#[test]
|
|
fn keys() -> Result<()> {
|
|
let mut ui = UIBuilder::new(32, 64).build()?;
|
|
let mut ch8 = new_chip8();
|
|
let ch8 = &mut ch8;
|
|
ui.frame(ch8).unwrap();
|
|
ui.keys(ch8).unwrap();
|
|
Ok(())
|
|
}
|
|
#[test]
|
|
fn debug() -> Result<()> {
|
|
println!("{:?}", UIBuilder::new(32, 64).build()?);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
mod framebuffer_format {
|
|
use super::*;
|
|
#[test]
|
|
fn default() {
|
|
let _fbf = FrameBufferFormat::default();
|
|
}
|
|
#[test]
|
|
fn clone() {
|
|
let fbf = FrameBufferFormat {
|
|
fg: 0x12345678,
|
|
bg: 0x90abcdef,
|
|
};
|
|
let fbf2 = fbf.clone();
|
|
assert_eq!(fbf, fbf2);
|
|
}
|
|
#[test]
|
|
fn debug() {
|
|
println!("{:?}", FrameBufferFormat::default());
|
|
}
|
|
#[test]
|
|
fn eq() {
|
|
assert_eq!(FrameBufferFormat::default(), FrameBufferFormat::default());
|
|
assert_ne!(
|
|
FrameBufferFormat {
|
|
fg: 0xff00ff,
|
|
bg: 0x00ff00
|
|
},
|
|
FrameBufferFormat {
|
|
fg: 0x00ff00,
|
|
bg: 0xff00ff
|
|
},
|
|
);
|
|
}
|
|
#[test]
|
|
fn ord() {
|
|
assert!(
|
|
FrameBufferFormat::default()
|
|
== FrameBufferFormat {
|
|
fg: 0xffffff,
|
|
bg: 0xffffff,
|
|
}
|
|
.min(FrameBufferFormat::default())
|
|
);
|
|
}
|
|
#[test]
|
|
fn hash() {
|
|
let mut hasher = DefaultHasher::new();
|
|
FrameBufferFormat::default().hash(&mut hasher);
|
|
println!("{hasher:?}");
|
|
}
|
|
}
|
|
|
|
mod framebuffer {
|
|
use super::*;
|
|
// [derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[test]
|
|
fn new() {
|
|
assert_eq!(FrameBuffer::new(64, 32), FrameBuffer::default());
|
|
}
|
|
#[test]
|
|
fn clone() {
|
|
let fb1 = FrameBuffer::default();
|
|
let fb2 = fb1.clone();
|
|
assert_eq!(fb1, fb2);
|
|
}
|
|
|
|
#[test]
|
|
fn debug() {
|
|
println!("{:?}", FrameBuffer::default());
|
|
}
|
|
|
|
#[test]
|
|
fn eq() {
|
|
assert_eq!(FrameBuffer::new(64, 32), FrameBuffer::default());
|
|
}
|
|
|
|
#[test]
|
|
fn ord() {
|
|
assert!(FrameBuffer::new(21, 12) == FrameBuffer::new(21, 12).min(FrameBuffer::new(34, 46)));
|
|
}
|
|
|
|
#[test]
|
|
fn hash() {
|
|
let mut hasher = DefaultHasher::new();
|
|
FrameBuffer::default().hash(&mut hasher);
|
|
println!("{hasher:?}");
|
|
}
|
|
}
|
|
|
|
mod quirks {
|
|
use super::*;
|
|
use chirp::cpu::Quirks;
|
|
|
|
#[test]
|
|
fn from_true() {
|
|
let quirks_true = Quirks::from(true);
|
|
assert_eq!(
|
|
quirks_true,
|
|
Quirks {
|
|
bin_ops: true,
|
|
shift: true,
|
|
draw_wait: true,
|
|
dma_inc: true,
|
|
stupid_jumps: false,
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn from_false() {
|
|
let quirks_true = Quirks::from(false);
|
|
assert_eq!(
|
|
quirks_true,
|
|
Quirks {
|
|
bin_ops: false,
|
|
shift: false,
|
|
draw_wait: false,
|
|
dma_inc: false,
|
|
stupid_jumps: false,
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn clone() {
|
|
let q1 = Quirks {
|
|
bin_ops: false,
|
|
shift: true,
|
|
draw_wait: false,
|
|
dma_inc: true,
|
|
stupid_jumps: false,
|
|
};
|
|
let q2 = q1.clone();
|
|
assert_eq!(q1, q2);
|
|
}
|
|
|
|
#[test]
|
|
fn debug() {
|
|
println!("{:?}", Quirks::from(true));
|
|
}
|
|
|
|
#[test]
|
|
fn eq() {
|
|
assert_ne!(Quirks::from(false), Quirks::from(true));
|
|
}
|
|
|
|
#[test]
|
|
fn ord() {
|
|
assert!(Quirks::from(false) < Quirks::from(true));
|
|
assert!(Quirks::from(true) == Quirks::from(false).max(Quirks::from(true)));
|
|
}
|
|
|
|
#[test]
|
|
fn hash() {
|
|
let mut hasher = DefaultHasher::new();
|
|
Quirks::from(true).hash(&mut hasher);
|
|
println!("{hasher:?}");
|
|
}
|
|
}
|