j/Chirp
1
1
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity

cpu/tests.rs: Modularize and add new tests

Browse Source
This commit is contained in:
John 2023-03-26 18:33:12 -05:00
parent a2a44dfd4f
commit 185712aeb6
1 changed files with 726 additions and 599 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

387
src/cpu/tests.rs
View File

@ -1,5 +1,9 @@
//! Tests for cpu.rs
//!
//! These run instructions, and ensure their output is consistent with previous builds
use super::*;
use crate::{
pub(self) use crate::{
bus,
bus::{Bus, Region::*},
};
@ -26,6 +30,8 @@ fn setup_environment() -> (CPU, Bus) {
}
/// Unused instructions
///
/// TODO: Exhaustively test unused instructions
#[test]
#[should_panic]
fn unimplemented() {
@ -35,12 +41,14 @@ fn unimplemented() {
cpu.unimplemented(0xffff);
}
mod sys {
use super::*;
/// 0aaa: Handles a "machine language function call" (lmao)
#[test]
#[should_panic]
fn sys() {
let (mut cpu, mut bus) = setup_environment();
bus.write(0x200u16, 0x0200u16); // 0x0200 is not one of the defined ML routines
bus.write(0x200u16, 0x0200u16); // 0x0200 is not one of the allowed routines
cpu.tick(&mut bus);
cpu.sys(0x200);
}
@ -73,17 +81,24 @@ fn ret() {
assert!(dbg!(cpu.sp.wrapping_sub(sp_orig)) == 0x2);
// Verify the stack pointer has moved
}
}
/// Tests control-flow instructions
///
/// Basically anything that touches the program counter
mod cf {
use super::*;
/// 1aaa: Sets the program counter to an absolute address
#[test]
fn jump() {
// Generate a random test address that's not 0x200
let test_addr = random::<u16>() & !0x200;
let (mut cpu, _) = setup_environment();
// Test all valid addresses
for addr in 0x000..0xffe {
// Call an address
cpu.jump(test_addr);
cpu.jump(addr);
// Verify the current address is the called address
assert_eq!(test_addr, cpu.pc);
assert_eq!(addr, cpu.pc);
}
}
/// 2aaa: Pushes pc onto the stack, then jumps to a
@ -104,7 +119,7 @@ fn call() {
/// 3xbb: Skips the next instruction if register X == b
#[test]
fn skip_if_x_equal_byte() {
fn skip_equals_immediate() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xffff {
let (a, b, addr) = (word as u8, (word >> 4) as u8, random::<u16>() & 0x7fe);
@ -114,7 +129,7 @@ fn skip_if_x_equal_byte() {
// set the register under test to a
cpu.v[x] = a;
// do the thing
cpu.skip_if_x_equal_byte(x, b);
cpu.skip_equals_immediate(x, b);
// validate the result
assert_eq!(cpu.pc, addr.wrapping_add(if dbg!(a == b) { 2 } else { 0 }));
}
@ -123,7 +138,7 @@ fn skip_if_x_equal_byte() {
/// 4xbb: Skips the next instruction if register X != b
#[test]
fn skip_if_x_not_equal_byte() {
fn skip_not_equals_immediate() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xffff {
let (a, b, addr) = (word as u8, (word >> 4) as u8, random::<u16>() & 0x7fe);
@ -133,7 +148,7 @@ fn skip_if_x_not_equal_byte() {
// set the register under test to a
cpu.v[x] = a;
// do the thing
cpu.skip_if_x_not_equal_byte(x, b);
cpu.skip_not_equals_immediate(x, b);
// validate the result
assert_eq!(cpu.pc, addr.wrapping_add(if a != b { 2 } else { 0 }));
}
@ -142,7 +157,7 @@ fn skip_if_x_not_equal_byte() {
/// 5xy0: Skips the next instruction if register X != register Y
#[test]
fn skip_if_x_equal_y() {
fn skip_equals() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xffff {
let (a, b, addr) = (word as u8, (word >> 4) as u8, random::<u16>() & 0x7fe);
@ -156,12 +171,57 @@ fn skip_if_x_equal_y() {
// set the registers under test to a, b
(cpu.v[x], cpu.v[y]) = (a, b);
// do the thing
cpu.skip_if_x_equal_y(x, y);
cpu.skip_equals(x, y);
// validate the result
assert_eq!(cpu.pc, addr.wrapping_add(if a == b { 2 } else { 0 }));
}
}
}
/// 9xy0: Skip next instruction if X != y
#[test]
fn skip_not_equals() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xffff {
let (a, b, addr) = (word as u8, (word >> 4) as u8, random::<u16>() & 0x7fe);
for reg in 0..=0xff {
let (x, y) = (reg & 0xf, reg >> 4);
if x == y {
continue;
}
// set the PC to a random address
cpu.pc = addr;
// set the registers under test to a, b
(cpu.v[x], cpu.v[y]) = (a, b);
// do the thing
cpu.skip_not_equals(x, y);
// validate the result
assert_eq!(cpu.pc, addr.wrapping_add(if a != b { 2 } else { 0 }));
}
}
}
/// Badr: Jump to &adr + v0
#[test]
fn jump_indexed() {
let (mut cpu, _) = setup_environment();
// For every valid address
for addr in 0..0x1000 {
// For every valid offset
for v0 in 0..=0xff {
// set v[0] = v0
cpu.v[0] = v0;
// jump indexed
cpu.jump_indexed(addr);
// Validate register set
assert_eq!(cpu.pc, addr.wrapping_add(v0.into()));
}
}
}
}
mod math {
use super::*;
/// 6xbb: Loads immediate byte b into register vX
#[test]
fn load_immediate() {
@ -192,8 +252,9 @@ fn add_immediate() {
}
/// 8xy0: Loads the value of y into x
// TODO: Test with authentic flag set
#[test]
fn load_y_into_x() {
fn load() {
let (mut cpu, _) = setup_environment();
// We use zero as a sentinel value for this test, so loop from 1 to 255
for test_value in 1..=0xff {
@ -206,7 +267,7 @@ fn load_y_into_x() {
cpu.v[y] = test_value;
// zero X
cpu.v[x] = 0;
cpu.load_y_into_x(x, y);
cpu.load(x, y);
// verify results
assert_eq!(cpu.v[x], test_value);
assert_eq!(cpu.v[y], test_value);
@ -215,8 +276,9 @@ fn load_y_into_x() {
}
/// 8xy1: Performs bitwise or of vX and vY, and stores the result in vX
// TODO: Test with authentic flag set
#[test]
fn x_orequals_y() {
fn or() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xffff {
let (a, b) = (word as u8, (word >> 4) as u8);
@ -227,7 +289,7 @@ fn x_orequals_y() {
(cpu.v[x], cpu.v[y]) = (a, b);
// do the thing
cpu.x_orequals_y(x, y);
cpu.or(x, y);
// validate the result
assert_eq!(cpu.v[x], if x == y { b } else { expected_result });
@ -236,8 +298,9 @@ fn x_orequals_y() {
}
/// 8xy2: Performs bitwise and of vX and vY, and stores the result in vX
// TODO: Test with authentic flag set
#[test]
fn x_andequals_y() {
fn and() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xffff {
let (a, b) = (word as u8, (word >> 4) as u8);
@ -248,7 +311,7 @@ fn x_andequals_y() {
(cpu.v[x], cpu.v[y]) = (a, b);
// do the thing
cpu.x_andequals_y(x, y);
cpu.and(x, y);
// validate the result
assert_eq!(cpu.v[x], if x == y { b } else { expected_result });
@ -257,8 +320,9 @@ fn x_andequals_y() {
}
/// 8xy3: Performs bitwise xor of vX and vY, and stores the result in vX
// TODO: Test with authentic flag set
#[test]
fn x_xorequals_y() {
fn xor() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xffff {
let (a, b) = (word as u8, (word >> 4) as u8);
@ -269,7 +333,7 @@ fn x_xorequals_y() {
(cpu.v[x], cpu.v[y]) = (a, b);
// do the thing
cpu.x_xorequals_y(x, y);
cpu.xor(x, y);
// validate the result
assert_eq!(cpu.v[x], if x == y { 0 } else { expected_result });
@ -280,7 +344,7 @@ fn x_xorequals_y() {
/// 8xy4: Performs addition of vX and vY, and stores the result in vX, carry in vF
/// If X is F, *only* stores borrow
#[test]
fn x_addequals_y() {
fn add() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xffff {
let (a, b) = (word as u8, (word >> 4) as u8);
@ -293,7 +357,7 @@ fn x_addequals_y() {
(cpu.v[x], cpu.v[y]) = (a, b);
// do the thing
cpu.x_addequals_y(x, y);
cpu.add(x, y);
// validate the result
// if the destination is vF, the result was discarded, and only the carry was kept
@ -307,7 +371,7 @@ fn x_addequals_y() {
/// 8xy5: Performs subtraction of vX and vY, and stores the result in vX, borrow in vF
#[test]
fn x_subequals_y() {
fn sub() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xffff {
let (a, b) = (word as u8, (word >> 4) as u8);
@ -319,7 +383,7 @@ fn x_subequals_y() {
(cpu.v[x], cpu.v[y]) = (a, b);
// do the thing
cpu.x_subequals_y(x, y);
cpu.sub(x, y);
// validate the result
// if the destination is vF, the result was discarded, and only the carry was kept
@ -333,22 +397,21 @@ fn x_subequals_y() {
}
/// 8xy6: Performs bitwise right shift of vX, stores carry-out in vF
// TODO: Test with authentic flag set
#[test]
fn shift_right_x() {
fn shift_right() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xff {
for x in 0..=0xf {
// set the register under test to `word`
cpu.v[x] = word;
// calculate the expected result
let expected = word >> 1;
// do the thing
cpu.shift_right_x(x);
cpu.shift_right(x, x);
// validate the result
// if the destination is vF, the result was discarded, and only the carry was kept
if x != 0xf {
assert_eq!(cpu.v[x], expected);
assert_eq!(cpu.v[x], word >> 1);
}
// The borrow flag for subtraction is inverted
assert_eq!(cpu.v[0xf], word & 1);
@ -358,7 +421,7 @@ fn shift_right_x() {
/// 8xy7: Performs subtraction of vY and vX, and stores the result in vX and ~carry in vF
#[test]
fn backwards_subtract() {
fn backwards_sub() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xffff {
let (a, b) = (word as u8, (word >> 4) as u8);
@ -370,7 +433,7 @@ fn backwards_subtract() {
(cpu.v[x], cpu.v[y]) = (a, b);
// do the thing
cpu.backwards_subtract(x, y);
cpu.backwards_sub(x, y);
// validate the result
// if the destination is vF, the result was discarded, and only the carry was kept
@ -384,83 +447,72 @@ fn backwards_subtract() {
}
/// 8X_E: Performs bitwise left shift of vX
// TODO: Test with authentic flag set
#[test]
fn shift_left_x() {
fn shift_left() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xff {
for x in 0..=0xf {
// set the register under test to `word`
cpu.v[x] = word;
// calculate the expected result
let expected = word << 1;
// do the thing
cpu.shift_left_x(x);
cpu.shift_left(x, x);
// validate the result
// if the destination is vF, the result was discarded, and only the carry was kept
if x != 0xf {
assert_eq!(cpu.v[x], expected);
assert_eq!(cpu.v[x], word << 1);
}
// The borrow flag for subtraction is inverted
assert_eq!(cpu.v[0xf], word >> 7);
}
}
}
/// 9xy0: Skip next instruction if X != y
#[test]
fn skip_if_x_not_equal_y() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xffff {
let (a, b, addr) = (word as u8, (word >> 4) as u8, random::<u16>() & 0x7fe);
for reg in 0..=0xff {
let (x, y) = (reg & 0xf, reg >> 4);
if x == y {
continue;
}
// set the PC to a random address
cpu.pc = addr;
// set the registers under test to a, b
(cpu.v[x], cpu.v[y]) = (a, b);
// do the thing
cpu.skip_if_x_not_equal_y(x, y);
// validate the result
assert_eq!(cpu.pc, addr.wrapping_add(if a != b { 2 } else { 0 }));
}
}
}
/// Test operations on the index/indirect register, I
mod i {
use super::*;
/// Aadr: Load address #adr into register I
#[test]
fn load_indirect_register() {
fn load_i_immediate() {
let (mut cpu, _) = setup_environment();
// For every valid address
for addr in 0..0x1000 {
// Load indirect register
cpu.load_indirect_register(addr);
// Validate register set
cpu.load_i_immediate(addr);
// Validate register set to addr
assert_eq!(cpu.i, addr);
}
}
/// Badr: Jump to &adr + v0
/// Fx1e: Add vX to I
#[test]
fn jump_indexed() {
fn add_i() {
let (mut cpu, _) = setup_environment();
// For every valid address
for addr in 0..0x1000 {
// For every valid offset
for v0 in 0..=0xff {
// set v[0] = v0
cpu.v[0] = v0;
// jump indexed
cpu.jump_indexed(addr);
for x in 0..=0xfff {
let (x, byte) = (x >> 8, x as u8);
// set v[x] = byte
(cpu.i, cpu.v[x]) = (addr as u16, byte);
// add vX to indirect register
cpu.add_i(x);
// Validate register set
assert_eq!(cpu.pc, addr.wrapping_add(v0.into()));
assert_eq!(cpu.i, (addr + byte as usize) as u16)
}
}
}
}
/// Screen, buttons, other things that would be peripherals on a real architecture
/// # Includes:
/// - Random number generation
/// - Drawing to the display
mod io {
use std::io::Write;
use super::*;
/// Cxbb: Stores a random number & the provided byte into vX
//#[test]
#[allow(dead_code)]
@ -468,6 +520,8 @@ fn rand() {
todo!()
}
mod display {
use super::*;
struct ScreenTest {
program: &'static [u8],
screen: &'static [u8],
@ -519,51 +573,49 @@ fn draw() {
assert_eq!(bus.get_region(Screen).unwrap(), test.screen);
}
}
}
mod cf {
//use super::*;
/// Ex9E: Skip next instruction if key == #X
//#[test]
#[allow(dead_code)]
fn skip_if_key_equals_x() {
fn skip_key_equals() {
todo!()
}
/// ExaE: Skip next instruction if key != #X
//#[test]
#[allow(dead_code)]
fn skip_if_key_not_x() {
fn skip_key_not_equals() {
todo!()
}
/// Fx07: Get the current DT, and put it in vX
/// ```py
/// vX = DT
/// ```
#[test]
fn get_delay_timer() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xff {
for x in 0..=0xf {
// set the register under test to `word`
cpu.delay = word;
// do the thing
cpu.get_delay_timer(x);
// validate the result
assert_eq!(cpu.v[x], word);
}
}
}
/// Fx0A: Wait for key, then vX = K
//#[test]
#[allow(dead_code)]
fn wait_for_key() {
todo!()
}
}
/// Fx07: Get the current DT, and put it in vX
#[test]
fn get_delay_timer() {
let (mut cpu, _) = setup_environment();
for word in 0..=0xff {
for x in 0..=0xf {
// set the register under test to `word`
cpu.delay = word;
// do the thing
cpu.load_delay_timer(x);
// validate the result
assert_eq!(cpu.v[x], word);
}
}
}
/// Fx15: Load vX into DT
/// ```py
/// DT = vX
/// ```
#[test]
fn load_delay_timer() {
let (mut cpu, _) = setup_environment();
@ -572,7 +624,7 @@ fn load_delay_timer() {
// set the register under test to `word`
cpu.v[x] = word;
// do the thing
cpu.load_delay_timer(x);
cpu.store_delay_timer(x);
// validate the result
assert_eq!(cpu.delay, word);
}
@ -580,9 +632,6 @@ fn load_delay_timer() {
}
/// Fx18: Load vX into ST
/// ```py
/// ST = vX;
/// ```
#[test]
fn load_sound_timer() {
let (mut cpu, _) = setup_environment();
@ -591,53 +640,113 @@ fn load_sound_timer() {
// set the register under test to `word`
cpu.v[x] = word;
// do the thing
cpu.load_sound_timer(x);
cpu.store_sound_timer(x);
// validate the result
assert_eq!(cpu.sound, word);
}
}
}
/// Fx1e: Add vX to I,
/// ```py
/// I += vX;
/// ```
#[test]
fn add_to_indirect() {
let (mut cpu, _) = setup_environment();
// For every valid address
for addr in 0..0x1000 {
// For every valid offset
for x in 0..=0xfff {
let (x, byte) = (x >> 8, x as u8);
// set v[x] = byte
(cpu.i, cpu.v[x]) = (addr as u16, byte);
// add vX to indirect register
cpu.add_to_indirect(x);
// Validate register set
assert_eq!(cpu.i, (addr + byte as usize) as u16)
}
}
mod sprite {
use super::*;
struct SpriteTest {
input: u8,
output: &'static [u8],
}
#[rustfmt::skip]
const TESTS: [SpriteTest; 16] = [
SpriteTest { input: 0x0, output: &[0xf0, 0x90, 0x90, 0x90, 0xf0] },
SpriteTest { input: 0x1, output: &[0x20, 0x60, 0x20, 0x20, 0x70] },
SpriteTest { input: 0x2, output: &[0xf0, 0x10, 0xf0, 0x80, 0xf0] },
SpriteTest { input: 0x3, output: &[0xf0, 0x10, 0xf0, 0x10, 0xf0] },
SpriteTest { input: 0x4, output: &[0x90, 0x90, 0xf0, 0x10, 0x10] },
SpriteTest { input: 0x5, output: &[0xf0, 0x80, 0xf0, 0x10, 0xf0] },
SpriteTest { input: 0x6, output: &[0xf0, 0x80, 0xf0, 0x90, 0xf0] },
SpriteTest { input: 0x7, output: &[0xf0, 0x10, 0x20, 0x40, 0x40] },
SpriteTest { input: 0x8, output: &[0xf0, 0x90, 0xf0, 0x90, 0xf0] },
SpriteTest { input: 0x9, output: &[0xf0, 0x90, 0xf0, 0x10, 0xf0] },
SpriteTest { input: 0xa, output: &[0xf0, 0x90, 0xf0, 0x90, 0x90] },
SpriteTest { input: 0xb, output: &[0xe0, 0x90, 0xe0, 0x90, 0xe0] },
SpriteTest { input: 0xc, output: &[0xf0, 0x80, 0x80, 0x80, 0xf0] },
SpriteTest { input: 0xd, output: &[0xe0, 0x90, 0x90, 0x90, 0xe0] },
SpriteTest { input: 0xe, output: &[0xf0, 0x80, 0xf0, 0x80, 0xf0] },
SpriteTest { input: 0xf, output: &[0xf0, 0x80, 0xf0, 0x80, 0x80] },
];
/// Fx29: Load sprite for character vX into I
/// ```py
/// I = sprite(vX);
/// ```
//#[test]
#[test]
#[allow(dead_code)]
fn load_sprite_x() {
todo!()
fn load_sprite() {
let (mut cpu, bus) = setup_environment();
for test in TESTS {
let reg = 0xf & random::<usize>();
// load number into CPU register
cpu.v[reg] = test.input;
cpu.load_sprite(reg);
let addr = cpu.i as usize;
assert_eq!(
bus.get(addr..addr.wrapping_add(5)).unwrap(),
test.output,
"\nTesting load_sprite({:x}) -> {:04x} {{\n\tout:{:02x?}\n\texp:{:02x?}\n}}",
test.input,
cpu.i,
bus.get(addr..addr.wrapping_add(5)).unwrap(),
test.output,
);
}
}
}
mod bcdtest {
pub(self) use super::*;
struct BCDTest {
// value to test
input: u8,
// result
output: &'static [u8],
}
const BCD_TESTS: [BCDTest; 3] = [
BCDTest {
input: 000,
output: &[0, 0, 0],
},
BCDTest {
input: 255,
output: &[2, 5, 5],
},
BCDTest {
input: 127,
output: &[1, 2, 7],
},
];
/// Fx33: BCD convert X into I`[0..3]`
//#[test]
#[test]
#[allow(dead_code)]
fn bcd_convert_i() {
todo!()
fn bcd_convert() {
for test in BCD_TESTS {
let (mut cpu, mut bus) = setup_environment();
let addr = 0xff0 & random::<u16>() as usize;
// load CPU registers
cpu.i = addr as u16;
cpu.v[5] = test.input;
// run instruction
cpu.bcd_convert(5, &mut bus);
// validate the results
assert_eq!(bus.get(addr..addr.saturating_add(3)), Some(test.output))
}
}
}
/// Fx55: DMA Stor from I to registers 0..X
// TODO: Test with authentic flag unset
// TODO: Test with authentic flag set
//#[test]
#[allow(dead_code)]
fn dma_store() {
@ -648,10 +757,28 @@ fn dma_store() {
}
/// Fx65: DMA Load from I to registers 0..X
//#[test]
// TODO: Test with authentic flag unset
// TODO: Test with authentic flag set
#[test]
#[allow(dead_code)]
fn dma_load() {
todo!()
let (mut cpu, mut bus) = setup_environment();
const DATA: &[u8] = b"ABCDEFGHIJKLMNOP";
// Load some test data into memory
let addr = 0x456;
bus.get_mut(addr..addr + DATA.len())
.unwrap()
.write(DATA)
.unwrap();
for len in 0..16 {
// Perform DMA load
cpu.i = addr as u16;
cpu.load_dma(len, &mut bus);
// Check that registers grabbed the correct data
assert_eq!(cpu.v[0..=len], DATA[0..=len]);
assert_eq!(cpu.v[len + 1..], [0; 16][len + 1..]);
// clear
cpu.v = [0; 16];
}
}
}