6502/mre-mos6502
1
0
Fork 0
mirror of https://github.com/mre/mos6502.git synced 2025-02-21 00:29:26 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #7 from whitemalt/master

Browse Source 
remove warning
This commit is contained in:
Matthias Endler 2018-10-27 14:56:35 +02:00 committed by GitHub
commit 1301218e37
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 320 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/bin/mos6502.rs
View File

@ -39,6 +39,7 @@ fn main() {
// "Load" a program // "Load" a program
let zero_page_data = [ let zero_page_data = [
// ZeroPage data start // ZeroPage data start
0x00, 0x00,

638
src/cpu.rs
View File

@ -773,385 +773,385 @@ mod tests {
#[test] #[test]
fn add_with_carry_test() { fn add_with_carry_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.add_with_carry(1); cpu.add_with_carry(1);
assert_eq!(CPU.registers.accumulator, 1); assert_eq!(cpu.registers.accumulator, 1);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.add_with_carry(-1); cpu.add_with_carry(-1);
assert_eq!(CPU.registers.accumulator, 0); assert_eq!(cpu.registers.accumulator, 0);
assert_eq!(CPU.registers.status.contains(PS_CARRY), true); assert_eq!(cpu.registers.status.contains(PS_CARRY), true);
assert_eq!(CPU.registers.status.contains(PS_ZERO), true); assert_eq!(cpu.registers.status.contains(PS_ZERO), true);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.add_with_carry(1); cpu.add_with_carry(1);
assert_eq!(CPU.registers.accumulator, 2); assert_eq!(cpu.registers.accumulator, 2);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.add_with_carry(127); cpu.add_with_carry(127);
assert_eq!(CPU.registers.accumulator, 127); assert_eq!(cpu.registers.accumulator, 127);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.add_with_carry(-127); cpu.add_with_carry(-127);
assert_eq!(CPU.registers.accumulator, 0); assert_eq!(cpu.registers.accumulator, 0);
assert_eq!(CPU.registers.status.contains(PS_CARRY), true); assert_eq!(cpu.registers.status.contains(PS_CARRY), true);
assert_eq!(CPU.registers.status.contains(PS_ZERO), true); assert_eq!(cpu.registers.status.contains(PS_ZERO), true);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.registers.status.remove(PS_CARRY); cpu.registers.status.remove(PS_CARRY);
CPU.add_with_carry(-128); cpu.add_with_carry(-128);
assert_eq!(CPU.registers.accumulator, -128); assert_eq!(cpu.registers.accumulator, -128);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.add_with_carry(127); cpu.add_with_carry(127);
assert_eq!(CPU.registers.accumulator, -1); assert_eq!(cpu.registers.accumulator, -1);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.add_with_carry(127); cpu.add_with_carry(127);
assert_eq!(CPU.registers.accumulator, 127); assert_eq!(cpu.registers.accumulator, 127);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.add_with_carry(1); cpu.add_with_carry(1);
assert_eq!(CPU.registers.accumulator, -128); assert_eq!(cpu.registers.accumulator, -128);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true);
} }
#[test] #[test]
fn and_test() { fn and_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.registers.accumulator = 0; cpu.registers.accumulator = 0;
CPU.and(-1); cpu.and(-1);
assert_eq!(CPU.registers.accumulator, 0); assert_eq!(cpu.registers.accumulator, 0);
assert_eq!(CPU.registers.status.contains(PS_ZERO), true); assert_eq!(cpu.registers.status.contains(PS_ZERO), true);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
CPU.registers.accumulator = -1; cpu.registers.accumulator = -1;
CPU.and(0); cpu.and(0);
assert_eq!(CPU.registers.accumulator, 0); assert_eq!(cpu.registers.accumulator, 0);
assert_eq!(CPU.registers.status.contains(PS_ZERO), true); assert_eq!(cpu.registers.status.contains(PS_ZERO), true);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
CPU.registers.accumulator = -1; cpu.registers.accumulator = -1;
CPU.and(0x0f); cpu.and(0x0f);
assert_eq!(CPU.registers.accumulator, 0x0f); assert_eq!(cpu.registers.accumulator, 0x0f);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
CPU.registers.accumulator = -1; cpu.registers.accumulator = -1;
CPU.and(-128); cpu.and(-128);
assert_eq!(CPU.registers.accumulator, -128); assert_eq!(cpu.registers.accumulator, -128);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true);
} }
#[test] #[test]
fn subtract_with_carry_test() { fn subtract_with_carry_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
CPU.registers.accumulator = 0; cpu.registers.accumulator = 0;
CPU.subtract_with_carry(1); cpu.subtract_with_carry(1);
assert_eq!(CPU.registers.accumulator, -1); assert_eq!(cpu.registers.accumulator, -1);
assert_eq!(CPU.registers.status.contains(PS_CARRY), true); assert_eq!(cpu.registers.status.contains(PS_CARRY), true);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
CPU.registers.accumulator = -128; cpu.registers.accumulator = -128;
CPU.subtract_with_carry(1); cpu.subtract_with_carry(1);
assert_eq!(CPU.registers.accumulator, 127); assert_eq!(cpu.registers.accumulator, 127);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true);
CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
CPU.registers.accumulator = 127; cpu.registers.accumulator = 127;
CPU.subtract_with_carry(-1); cpu.subtract_with_carry(-1);
assert_eq!(CPU.registers.accumulator, -128); assert_eq!(cpu.registers.accumulator, -128);
assert_eq!(CPU.registers.status.contains(PS_CARRY), true); assert_eq!(cpu.registers.status.contains(PS_CARRY), true);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true);
CPU.execute_instruction((Instruction::CLC, OpInput::UseImplied)); cpu.execute_instruction((Instruction::CLC, OpInput::UseImplied));
CPU.registers.accumulator = -64; cpu.registers.accumulator = -64;
CPU.subtract_with_carry(64); cpu.subtract_with_carry(64);
assert_eq!(CPU.registers.accumulator, 127); assert_eq!(cpu.registers.accumulator, 127);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true);
CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
CPU.registers.accumulator = 0; cpu.registers.accumulator = 0;
CPU.subtract_with_carry(-128); cpu.subtract_with_carry(-128);
assert_eq!(CPU.registers.accumulator, -128); assert_eq!(cpu.registers.accumulator, -128);
assert_eq!(CPU.registers.status.contains(PS_CARRY), true); assert_eq!(cpu.registers.status.contains(PS_CARRY), true);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true);
CPU.execute_instruction((Instruction::CLC, OpInput::UseImplied)); cpu.execute_instruction((Instruction::CLC, OpInput::UseImplied));
CPU.registers.accumulator = 0; cpu.registers.accumulator = 0;
CPU.subtract_with_carry(127); cpu.subtract_with_carry(127);
assert_eq!(CPU.registers.accumulator, -128); assert_eq!(cpu.registers.accumulator, -128);
assert_eq!(CPU.registers.status.contains(PS_CARRY), true); assert_eq!(cpu.registers.status.contains(PS_CARRY), true);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
} }
#[test] #[test]
fn decrement_memory_test() { fn decrement_memory_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
let addr = Address(0xA1B2); let addr = Address(0xA1B2);
CPU.memory.set_byte(addr, 5); cpu.memory.set_byte(addr, 5);
CPU.decrement_memory(addr); cpu.decrement_memory(addr);
assert_eq!(CPU.memory.get_byte(addr), 4); assert_eq!(cpu.memory.get_byte(addr), 4);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
CPU.decrement_memory(addr); cpu.decrement_memory(addr);
assert_eq!(CPU.memory.get_byte(addr), 3); assert_eq!(cpu.memory.get_byte(addr), 3);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
CPU.decrement_memory(addr); cpu.decrement_memory(addr);
CPU.decrement_memory(addr); cpu.decrement_memory(addr);
CPU.decrement_memory(addr); cpu.decrement_memory(addr);
assert_eq!(CPU.memory.get_byte(addr), 0); assert_eq!(cpu.memory.get_byte(addr), 0);
assert_eq!(CPU.registers.status.contains(PS_ZERO), true); assert_eq!(cpu.registers.status.contains(PS_ZERO), true);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
CPU.decrement_memory(addr); cpu.decrement_memory(addr);
assert_eq!(CPU.memory.get_byte(addr) as i8, -1); assert_eq!(cpu.memory.get_byte(addr) as i8, -1);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true);
} }
#[test] #[test]
fn logical_shift_right_test() { fn logical_shift_right_test() {
// Testing UseImplied version (which targets the accumulator) only, for now // Testing UseImplied version (which targets the accumulator) only, for now
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(0))); cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(0)));
CPU.execute_instruction((Instruction::LSR, OpInput::UseImplied)); cpu.execute_instruction((Instruction::LSR, OpInput::UseImplied));
assert_eq!(CPU.registers.accumulator, 0); assert_eq!(cpu.registers.accumulator, 0);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), true); assert_eq!(cpu.registers.status.contains(PS_ZERO), true);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(1))); cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(1)));
CPU.execute_instruction((Instruction::LSR, OpInput::UseImplied)); cpu.execute_instruction((Instruction::LSR, OpInput::UseImplied));
assert_eq!(CPU.registers.accumulator, 0); assert_eq!(cpu.registers.accumulator, 0);
assert_eq!(CPU.registers.status.contains(PS_CARRY), true); assert_eq!(cpu.registers.status.contains(PS_CARRY), true);
assert_eq!(CPU.registers.status.contains(PS_ZERO), true); assert_eq!(cpu.registers.status.contains(PS_ZERO), true);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(255))); cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(255)));
CPU.execute_instruction((Instruction::LSR, OpInput::UseImplied)); cpu.execute_instruction((Instruction::LSR, OpInput::UseImplied));
assert_eq!(CPU.registers.accumulator, 0x7F); assert_eq!(cpu.registers.accumulator, 0x7F);
assert_eq!(CPU.registers.status.contains(PS_CARRY), true); assert_eq!(cpu.registers.status.contains(PS_CARRY), true);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(254))); cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(254)));
CPU.execute_instruction((Instruction::LSR, OpInput::UseImplied)); cpu.execute_instruction((Instruction::LSR, OpInput::UseImplied));
assert_eq!(CPU.registers.accumulator, 0x7F); assert_eq!(cpu.registers.accumulator, 0x7F);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
} }
#[test] #[test]
fn dec_x_test() { fn dec_x_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.dec_x(); cpu.dec_x();
assert_eq!(CPU.registers.index_x, -1); assert_eq!(cpu.registers.index_x, -1);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.dec_x(); cpu.dec_x();
assert_eq!(CPU.registers.index_x, -2); assert_eq!(cpu.registers.index_x, -2);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.load_x_register(5); cpu.load_x_register(5);
CPU.dec_x(); cpu.dec_x();
assert_eq!(CPU.registers.index_x, 4); assert_eq!(cpu.registers.index_x, 4);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.dec_x(); cpu.dec_x();
CPU.dec_x(); cpu.dec_x();
CPU.dec_x(); cpu.dec_x();
CPU.dec_x(); cpu.dec_x();
assert_eq!(CPU.registers.index_x, 0); assert_eq!(cpu.registers.index_x, 0);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), true); assert_eq!(cpu.registers.status.contains(PS_ZERO), true);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
CPU.dec_x(); cpu.dec_x();
assert_eq!(CPU.registers.index_x, -1); assert_eq!(cpu.registers.index_x, -1);
assert_eq!(CPU.registers.status.contains(PS_CARRY), false); assert_eq!(cpu.registers.status.contains(PS_CARRY), false);
assert_eq!(CPU.registers.status.contains(PS_ZERO), false); assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true); assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true);
assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false); assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
} }
#[test] #[test]
fn jump_test() { fn jump_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
let addr = Address(0xA1B1); let addr = Address(0xA1B1);
CPU.jump(addr); cpu.jump(addr);
assert_eq!(CPU.registers.program_counter, addr); assert_eq!(cpu.registers.program_counter, addr);
} }
#[test] #[test]
fn branch_if_carry_clear_test() { fn branch_if_carry_clear_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
CPU.branch_if_carry_clear(Address(0xABCD)); cpu.branch_if_carry_clear(Address(0xABCD));
assert_eq!(CPU.registers.program_counter, Address(0)); assert_eq!(cpu.registers.program_counter, Address(0));
CPU.execute_instruction((Instruction::CLC, OpInput::UseImplied)); cpu.execute_instruction((Instruction::CLC, OpInput::UseImplied));
CPU.branch_if_carry_clear(Address(0xABCD)); cpu.branch_if_carry_clear(Address(0xABCD));
assert_eq!(CPU.registers.program_counter, Address(0xABCD)); assert_eq!(cpu.registers.program_counter, Address(0xABCD));
} }
#[test] #[test]
fn branch_if_carry_set_test() { fn branch_if_carry_set_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.execute_instruction((Instruction::CLC, OpInput::UseImplied)); cpu.execute_instruction((Instruction::CLC, OpInput::UseImplied));
CPU.branch_if_carry_set(Address(0xABCD)); cpu.branch_if_carry_set(Address(0xABCD));
assert_eq!(CPU.registers.program_counter, Address(0)); assert_eq!(cpu.registers.program_counter, Address(0));
CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied)); cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
CPU.branch_if_carry_set(Address(0xABCD)); cpu.branch_if_carry_set(Address(0xABCD));
assert_eq!(CPU.registers.program_counter, Address(0xABCD)); assert_eq!(cpu.registers.program_counter, Address(0xABCD));
} }
#[test] #[test]
fn branch_if_equal_test() { fn branch_if_equal_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.branch_if_equal(Address(0xABCD)); cpu.branch_if_equal(Address(0xABCD));
assert_eq!(CPU.registers.program_counter, Address(0)); assert_eq!(cpu.registers.program_counter, Address(0));
CPU.registers.status.or(PS_ZERO); cpu.registers.status.or(PS_ZERO);
CPU.branch_if_equal(Address(0xABCD)); cpu.branch_if_equal(Address(0xABCD));
assert_eq!(CPU.registers.program_counter, Address(0xABCD)); assert_eq!(cpu.registers.program_counter, Address(0xABCD));
} }
#[test] #[test]
fn branch_if_minus_test() { fn branch_if_minus_test() {
{ {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
let registers_before = CPU.registers; let registers_before = cpu.registers;
CPU.branch_if_minus(Address(0xABCD)); cpu.branch_if_minus(Address(0xABCD));
assert_eq!(CPU.registers, registers_before); assert_eq!(cpu.registers, registers_before);
assert_eq!(CPU.registers.program_counter, Address(0)); assert_eq!(cpu.registers.program_counter, Address(0));
} }
{ {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.registers.status.or(PS_NEGATIVE); cpu.registers.status.or(PS_NEGATIVE);
let registers_before = CPU.registers; let registers_before = cpu.registers;
CPU.branch_if_minus(Address(0xABCD)); cpu.branch_if_minus(Address(0xABCD));
assert_eq!(CPU.registers.status, registers_before.status); assert_eq!(cpu.registers.status, registers_before.status);
assert_eq!(CPU.registers.program_counter, Address(0xABCD)); assert_eq!(cpu.registers.program_counter, Address(0xABCD));
} }
} }
#[test] #[test]
fn branch_if_positive_test() { fn branch_if_positive_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.registers.status.insert(PS_NEGATIVE); cpu.registers.status.insert(PS_NEGATIVE);
CPU.branch_if_positive(Address(0xABCD)); cpu.branch_if_positive(Address(0xABCD));
assert_eq!(CPU.registers.program_counter, Address(0)); assert_eq!(cpu.registers.program_counter, Address(0));
CPU.registers.status.remove(PS_NEGATIVE); cpu.registers.status.remove(PS_NEGATIVE);
CPU.branch_if_positive(Address(0xABCD)); cpu.branch_if_positive(Address(0xABCD));
assert_eq!(CPU.registers.program_counter, Address(0xABCD)); assert_eq!(cpu.registers.program_counter, Address(0xABCD));
} }
#[test] #[test]
fn branch_if_overflow_clear_test() { fn branch_if_overflow_clear_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.registers.status.insert(PS_OVERFLOW); cpu.registers.status.insert(PS_OVERFLOW);
CPU.branch_if_overflow_clear(Address(0xABCD)); cpu.branch_if_overflow_clear(Address(0xABCD));
assert_eq!(CPU.registers.program_counter, Address(0)); assert_eq!(cpu.registers.program_counter, Address(0));
CPU.registers.status.remove(PS_OVERFLOW); cpu.registers.status.remove(PS_OVERFLOW);
CPU.branch_if_overflow_clear(Address(0xABCD)); cpu.branch_if_overflow_clear(Address(0xABCD));
assert_eq!(CPU.registers.program_counter, Address(0xABCD)); assert_eq!(cpu.registers.program_counter, Address(0xABCD));
} }
#[test] #[test]
fn branch_if_overflow_set_test() { fn branch_if_overflow_set_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.branch_if_overflow_set(Address(0xABCD)); cpu.branch_if_overflow_set(Address(0xABCD));
assert_eq!(CPU.registers.program_counter, Address(0)); assert_eq!(cpu.registers.program_counter, Address(0));
CPU.registers.status.insert(PS_OVERFLOW); cpu.registers.status.insert(PS_OVERFLOW);
CPU.branch_if_overflow_set(Address(0xABCD)); cpu.branch_if_overflow_set(Address(0xABCD));
assert_eq!(CPU.registers.program_counter, Address(0xABCD)); assert_eq!(cpu.registers.program_counter, Address(0xABCD));
} }
#[cfg(test)] #[cfg(test)]
@ -1159,61 +1159,61 @@ mod tests {
where where
F: FnMut(&mut CPU, u8), F: FnMut(&mut CPU, u8),
{ {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
CPU.execute_instruction((load_instruction, OpInput::UseImmediate(127))); cpu.execute_instruction((load_instruction, OpInput::UseImmediate(127)));
compare(&mut CPU, 127); compare(&mut cpu, 127);
assert!(CPU.registers.status.contains(PS_ZERO)); assert!(cpu.registers.status.contains(PS_ZERO));
assert!(CPU.registers.status.contains(PS_CARRY)); assert!(cpu.registers.status.contains(PS_CARRY));
assert!(!CPU.registers.status.contains(PS_NEGATIVE)); assert!(!cpu.registers.status.contains(PS_NEGATIVE));
CPU.execute_instruction((load_instruction, OpInput::UseImmediate(127))); cpu.execute_instruction((load_instruction, OpInput::UseImmediate(127)));
compare(&mut CPU, 1); compare(&mut cpu, 1);
assert!(!CPU.registers.status.contains(PS_ZERO)); assert!(!cpu.registers.status.contains(PS_ZERO));
assert!(CPU.registers.status.contains(PS_CARRY)); assert!(cpu.registers.status.contains(PS_CARRY));
assert!(!CPU.registers.status.contains(PS_NEGATIVE)); assert!(!cpu.registers.status.contains(PS_NEGATIVE));
CPU.execute_instruction((load_instruction, OpInput::UseImmediate(1))); cpu.execute_instruction((load_instruction, OpInput::UseImmediate(1)));
compare(&mut CPU, 2); compare(&mut cpu, 2);
assert!(!CPU.registers.status.contains(PS_ZERO)); assert!(!cpu.registers.status.contains(PS_ZERO));
assert!(!CPU.registers.status.contains(PS_CARRY)); assert!(!cpu.registers.status.contains(PS_CARRY));
assert!(CPU.registers.status.contains(PS_NEGATIVE)); assert!(cpu.registers.status.contains(PS_NEGATIVE));
CPU.execute_instruction((load_instruction, OpInput::UseImmediate(20))); cpu.execute_instruction((load_instruction, OpInput::UseImmediate(20)));
compare(&mut CPU, -50i8 as u8); compare(&mut cpu, -50i8 as u8);
assert!(!CPU.registers.status.contains(PS_ZERO)); assert!(!cpu.registers.status.contains(PS_ZERO));
assert!(!CPU.registers.status.contains(PS_CARRY)); assert!(!cpu.registers.status.contains(PS_CARRY));
assert!(!CPU.registers.status.contains(PS_NEGATIVE)); assert!(!cpu.registers.status.contains(PS_NEGATIVE));
CPU.execute_instruction((load_instruction, OpInput::UseImmediate(1))); cpu.execute_instruction((load_instruction, OpInput::UseImmediate(1)));
compare(&mut CPU, -1i8 as u8); compare(&mut cpu, -1i8 as u8);
assert!(!CPU.registers.status.contains(PS_ZERO)); assert!(!cpu.registers.status.contains(PS_ZERO));
assert!(!CPU.registers.status.contains(PS_CARRY)); assert!(!cpu.registers.status.contains(PS_CARRY));
assert!(!CPU.registers.status.contains(PS_NEGATIVE)); assert!(!cpu.registers.status.contains(PS_NEGATIVE));
CPU.execute_instruction((load_instruction, OpInput::UseImmediate(127))); cpu.execute_instruction((load_instruction, OpInput::UseImmediate(127)));
compare(&mut CPU, -128i8 as u8); compare(&mut cpu, -128i8 as u8);
assert!(!CPU.registers.status.contains(PS_ZERO)); assert!(!cpu.registers.status.contains(PS_ZERO));
assert!(!CPU.registers.status.contains(PS_CARRY)); assert!(!cpu.registers.status.contains(PS_CARRY));
assert!(CPU.registers.status.contains(PS_NEGATIVE)); assert!(cpu.registers.status.contains(PS_NEGATIVE));
} }
#[test] #[test]
fn compare_with_a_register_test() { fn compare_with_a_register_test() {
compare_test_helper( compare_test_helper(
&mut |CPU: &mut CPU, val: u8| { &mut |cpu: &mut CPU, val: u8| {
CPU.compare_with_a_register(val); cpu.compare_with_a_register(val);
}, },
Instruction::LDA, Instruction::LDA,
); );
@ -1222,8 +1222,8 @@ mod tests {
#[test] #[test]
fn compare_with_x_register_test() { fn compare_with_x_register_test() {
compare_test_helper( compare_test_helper(
&mut |CPU: &mut CPU, val: u8| { &mut |cpu: &mut CPU, val: u8| {
CPU.compare_with_x_register(val); cpu.compare_with_x_register(val);
}, },
Instruction::LDX, Instruction::LDX,
); );
@ -1232,8 +1232,8 @@ mod tests {
#[test] #[test]
fn compare_with_y_register_test() { fn compare_with_y_register_test() {
compare_test_helper( compare_test_helper(
&mut |CPU: &mut CPU, val: u8| { &mut |cpu: &mut CPU, val: u8| {
CPU.compare_with_y_register(val); cpu.compare_with_y_register(val);
}, },
Instruction::LDY, Instruction::LDY,
); );
@ -1241,27 +1241,27 @@ mod tests {
#[test] #[test]
fn exclusive_or_test() { fn exclusive_or_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
for a_before in range_inclusive(0u8, 255u8) { for a_before in range_inclusive(0u8, 255u8) {
for val in range_inclusive(0u8, 255u8) { for val in range_inclusive(0u8, 255u8) {
CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(a_before))); cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(a_before)));
CPU.exclusive_or(val); cpu.exclusive_or(val);
let a_after = a_before ^ val; let a_after = a_before ^ val;
assert_eq!(CPU.registers.accumulator, a_after as i8); assert_eq!(cpu.registers.accumulator, a_after as i8);
if a_after == 0 { if a_after == 0 {
assert!(CPU.registers.status.contains(PS_ZERO)); assert!(cpu.registers.status.contains(PS_ZERO));
} else { } else {
assert!(!CPU.registers.status.contains(PS_ZERO)); assert!(!cpu.registers.status.contains(PS_ZERO));
} }
if (a_after as i8) < 0 { if (a_after as i8) < 0 {
assert!(CPU.registers.status.contains(PS_NEGATIVE)); assert!(cpu.registers.status.contains(PS_NEGATIVE));
} else { } else {
assert!(!CPU.registers.status.contains(PS_NEGATIVE)); assert!(!cpu.registers.status.contains(PS_NEGATIVE));
} }
} }
} }
@ -1269,27 +1269,27 @@ mod tests {
#[test] #[test]
fn inclusive_or_test() { fn inclusive_or_test() {
let mut CPU = CPU::new(); let mut cpu = CPU::new();
for a_before in range_inclusive(0u8, 255u8) { for a_before in range_inclusive(0u8, 255u8) {
for val in range_inclusive(0u8, 255u8) { for val in range_inclusive(0u8, 255u8) {
CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(a_before))); cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(a_before)));
CPU.inclusive_or(val); cpu.inclusive_or(val);
let a_after = a_before | val; let a_after = a_before | val;
assert_eq!(CPU.registers.accumulator, a_after as i8); assert_eq!(cpu.registers.accumulator, a_after as i8);
if a_after == 0 { if a_after == 0 {
assert!(CPU.registers.status.contains(PS_ZERO)); assert!(cpu.registers.status.contains(PS_ZERO));
} else { } else {
assert!(!CPU.registers.status.contains(PS_ZERO)); assert!(!cpu.registers.status.contains(PS_ZERO));
} }
if (a_after as i8) < 0 { if (a_after as i8) < 0 {
assert!(CPU.registers.status.contains(PS_NEGATIVE)); assert!(cpu.registers.status.contains(PS_NEGATIVE));
} else { } else {
assert!(!CPU.registers.status.contains(PS_NEGATIVE)); assert!(!cpu.registers.status.contains(PS_NEGATIVE));
} }
} }
} }