From a9697e6b79debc801916643da777b015092380cc Mon Sep 17 00:00:00 2001
From: Noppadet Vivatchotikul <osnoppadetv@dtac.co.th>
Date: Thu, 25 Oct 2018 22:07:16 +0700
Subject: [PATCH 1/3] remove warning

---
 src/bin/{main.rs => mos6502.rs} |  0
 src/cpu.rs                      | 60 ++++++++++++++++-----------------
 2 files changed, 30 insertions(+), 30 deletions(-)
 rename src/bin/{main.rs => mos6502.rs} (100%)

diff --git a/src/bin/main.rs b/src/bin/mos6502.rs
similarity index 100%
rename from src/bin/main.rs
rename to src/bin/mos6502.rs
diff --git a/src/cpu.rs b/src/cpu.rs
index 2bdca43..b1e1469 100644
--- a/src/cpu.rs
+++ b/src/cpu.rs
@@ -776,7 +776,7 @@ mod tests {
 
     #[test]
     fn add_with_carry_test() {
-        let mut CPU = CPU::new();
+        let mut cpu = CPU::new();
 
         CPU.add_with_carry(1);
         assert_eq!(CPU.registers.accumulator, 1);
@@ -799,7 +799,7 @@ mod tests {
         assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), 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);
         assert_eq!(CPU.registers.accumulator, 127);
@@ -830,7 +830,7 @@ mod tests {
         assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true);
         assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
 
-        let mut CPU = CPU::new();
+        let mut cpu = CPU::new();
 
         CPU.add_with_carry(127);
         assert_eq!(CPU.registers.accumulator, 127);
@@ -849,7 +849,7 @@ mod tests {
 
     #[test]
     fn and_test() {
-        let mut CPU = CPU::new();
+        let mut cpu = CPU::new();
 
         CPU.registers.accumulator = 0;
         CPU.and(-1);
@@ -878,7 +878,7 @@ mod tests {
 
     #[test]
     fn subtract_with_carry_test() {
-        let mut CPU = CPU::new();
+        let mut cpu = CPU::new();
 
         CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied));
         CPU.registers.accumulator = 0;
@@ -938,7 +938,7 @@ mod tests {
 
     #[test]
     fn decrement_memory_test() {
-        let mut CPU = CPU::new();
+        let mut cpu = CPU::new();
         let addr = Address(0xA1B2);
 
         CPU.memory.set_byte(addr, 5);
@@ -970,7 +970,7 @@ mod tests {
     fn logical_shift_right_test() {
         // 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::LSR, OpInput::UseImplied));
         assert_eq!(CPU.registers.accumulator, 0);
@@ -1006,7 +1006,7 @@ mod tests {
 
     #[test]
     fn dec_x_test() {
-        let mut CPU = CPU::new();
+        let mut cpu = CPU::new();
 
         CPU.dec_x();
         assert_eq!(CPU.registers.index_x, -1);
@@ -1051,7 +1051,7 @@ mod tests {
 
     #[test]
     fn jump_test() {
-        let mut CPU = CPU::new();
+        let mut cpu = CPU::new();
         let addr = Address(0xA1B1);
 
         CPU.jump(addr);
@@ -1060,7 +1060,7 @@ mod tests {
 
     #[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.branch_if_carry_clear(Address(0xABCD));
@@ -1073,7 +1073,7 @@ mod tests {
 
     #[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.branch_if_carry_set(Address(0xABCD));
@@ -1086,7 +1086,7 @@ mod tests {
 
     #[test]
     fn branch_if_equal_test() {
-        let mut CPU = CPU::new();
+        let mut cpu = CPU::new();
 
         CPU.branch_if_equal(Address(0xABCD));
         assert_eq!(CPU.registers.program_counter, Address(0));
@@ -1099,7 +1099,7 @@ mod tests {
     #[test]
     fn branch_if_minus_test() {
         {
-            let mut CPU = CPU::new();
+            let mut cpu = CPU::new();
             let registers_before = CPU.registers;
 
             CPU.branch_if_minus(Address(0xABCD));
@@ -1108,7 +1108,7 @@ mod tests {
         }
 
         {
-            let mut CPU = CPU::new();
+            let mut cpu = CPU::new();
 
             CPU.registers.status.or(PS_NEGATIVE);
             let registers_before = CPU.registers;
@@ -1121,7 +1121,7 @@ mod tests {
 
     #[test]
     fn branch_if_positive_test() {
-        let mut CPU = CPU::new();
+        let mut cpu = CPU::new();
 
         CPU.registers.status.insert(PS_NEGATIVE);
         CPU.branch_if_positive(Address(0xABCD));
@@ -1134,7 +1134,7 @@ mod tests {
 
     #[test]
     fn branch_if_overflow_clear_test() {
-        let mut CPU = CPU::new();
+        let mut cpu = CPU::new();
 
         CPU.registers.status.insert(PS_OVERFLOW);
         CPU.branch_if_overflow_clear(Address(0xABCD));
@@ -1147,7 +1147,7 @@ mod tests {
 
     #[test]
     fn branch_if_overflow_set_test() {
-        let mut CPU = CPU::new();
+        let mut cpu = CPU::new();
 
         CPU.branch_if_overflow_set(Address(0xABCD));
         assert_eq!(CPU.registers.program_counter, Address(0));
@@ -1160,13 +1160,13 @@ mod tests {
     #[cfg(test)]
     fn compare_test_helper<F>(compare: &mut F, load_instruction: Instruction)
     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)));
 
-        compare(&mut CPU, 127);
+        compare(&mut cpu, 127);
         assert!(CPU.registers.status.contains(PS_ZERO));
         assert!(CPU.registers.status.contains(PS_CARRY));
         assert!(!CPU.registers.status.contains(PS_NEGATIVE));
@@ -1174,7 +1174,7 @@ mod tests {
 
         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_CARRY));
         assert!(!CPU.registers.status.contains(PS_NEGATIVE));
@@ -1182,7 +1182,7 @@ mod tests {
 
         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_CARRY));
         assert!(CPU.registers.status.contains(PS_NEGATIVE));
@@ -1190,7 +1190,7 @@ mod tests {
 
         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_CARRY));
         assert!(!CPU.registers.status.contains(PS_NEGATIVE));
@@ -1198,7 +1198,7 @@ mod tests {
 
         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_CARRY));
         assert!(!CPU.registers.status.contains(PS_NEGATIVE));
@@ -1206,7 +1206,7 @@ mod tests {
 
         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_CARRY));
         assert!(CPU.registers.status.contains(PS_NEGATIVE));
@@ -1215,7 +1215,7 @@ mod tests {
     #[test]
     fn compare_with_a_register_test() {
         compare_test_helper(
-            &mut |CPU: &mut CPU, val: u8| {
+            &mut |CPU: &mut cpu, val: u8| {
                 CPU.compare_with_a_register(val);
             },
             Instruction::LDA,
@@ -1225,7 +1225,7 @@ mod tests {
     #[test]
     fn compare_with_x_register_test() {
         compare_test_helper(
-            &mut |CPU: &mut CPU, val: u8| {
+            &mut |CPU: &mut cpu, val: u8| {
                 CPU.compare_with_x_register(val);
             },
             Instruction::LDX,
@@ -1235,7 +1235,7 @@ mod tests {
     #[test]
     fn compare_with_y_register_test() {
         compare_test_helper(
-            &mut |CPU: &mut CPU, val: u8| {
+            &mut |CPU: &mut cpu, val: u8| {
                 CPU.compare_with_y_register(val);
             },
             Instruction::LDY,
@@ -1244,7 +1244,7 @@ mod tests {
 
     #[test]
     fn exclusive_or_test() {
-        let mut CPU = CPU::new();
+        let mut cpu = CPU::new();
 
         for a_before in range_inclusive(0u8, 255u8) {
             for val in range_inclusive(0u8, 255u8) {
@@ -1272,7 +1272,7 @@ mod tests {
 
     #[test]
     fn inclusive_or_test() {
-        let mut CPU = CPU::new();
+        let mut cpu = CPU::new();
 
         for a_before in range_inclusive(0u8, 255u8) {
             for val in range_inclusive(0u8, 255u8) {

From c440637adb9ac41e52052071c7221fb269253ac7 Mon Sep 17 00:00:00 2001
From: Noppadet Vivatchotikul <osnoppadetv@dtac.co.th>
Date: Thu, 25 Oct 2018 22:35:00 +0700
Subject: [PATCH 2/3] fix variable

---
 src/cpu.rs | 580 ++++++++++++++++++++++++++---------------------------
 1 file changed, 290 insertions(+), 290 deletions(-)

diff --git a/src/cpu.rs b/src/cpu.rs
index b1e1469..c2e38e4 100644
--- a/src/cpu.rs
+++ b/src/cpu.rs
@@ -778,162 +778,162 @@ mod tests {
     fn add_with_carry_test() {
         let mut cpu = CPU::new();
 
-        CPU.add_with_carry(1);
-        assert_eq!(CPU.registers.accumulator, 1);
-        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_NEGATIVE), false);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.add_with_carry(1);
+        assert_eq!(cpu.registers.accumulator, 1);
+        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_NEGATIVE), false);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
-        CPU.add_with_carry(-1);
-        assert_eq!(CPU.registers.accumulator, 0);
-        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_NEGATIVE), false);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.add_with_carry(-1);
+        assert_eq!(cpu.registers.accumulator, 0);
+        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_NEGATIVE), false);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
-        CPU.add_with_carry(1);
-        assert_eq!(CPU.registers.accumulator, 2);
-        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_NEGATIVE), false);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.add_with_carry(1);
+        assert_eq!(cpu.registers.accumulator, 2);
+        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_NEGATIVE), false);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
         let mut cpu = CPU::new();
 
-        CPU.add_with_carry(127);
-        assert_eq!(CPU.registers.accumulator, 127);
-        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_NEGATIVE), false);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.add_with_carry(127);
+        assert_eq!(cpu.registers.accumulator, 127);
+        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_NEGATIVE), false);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
-        CPU.add_with_carry(-127);
-        assert_eq!(CPU.registers.accumulator, 0);
-        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_NEGATIVE), false);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.add_with_carry(-127);
+        assert_eq!(cpu.registers.accumulator, 0);
+        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_NEGATIVE), false);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
-        CPU.registers.status.remove(PS_CARRY);
-        CPU.add_with_carry(-128);
-        assert_eq!(CPU.registers.accumulator, -128);
-        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_NEGATIVE), true);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.registers.status.remove(PS_CARRY);
+        cpu.add_with_carry(-128);
+        assert_eq!(cpu.registers.accumulator, -128);
+        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_NEGATIVE), true);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
-        CPU.add_with_carry(127);
-        assert_eq!(CPU.registers.accumulator, -1);
-        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_NEGATIVE), true);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.add_with_carry(127);
+        assert_eq!(cpu.registers.accumulator, -1);
+        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_NEGATIVE), true);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
         let mut cpu = CPU::new();
 
-        CPU.add_with_carry(127);
-        assert_eq!(CPU.registers.accumulator, 127);
-        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_NEGATIVE), false);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.add_with_carry(127);
+        assert_eq!(cpu.registers.accumulator, 127);
+        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_NEGATIVE), false);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
-        CPU.add_with_carry(1);
-        assert_eq!(CPU.registers.accumulator, -128);
-        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_NEGATIVE), true);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true);
+        cpu.add_with_carry(1);
+        assert_eq!(cpu.registers.accumulator, -128);
+        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_NEGATIVE), true);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true);
     }
 
     #[test]
     fn and_test() {
         let mut cpu = CPU::new();
 
-        CPU.registers.accumulator = 0;
-        CPU.and(-1);
-        assert_eq!(CPU.registers.accumulator, 0);
-        assert_eq!(CPU.registers.status.contains(PS_ZERO), true);
-        assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false);
+        cpu.registers.accumulator = 0;
+        cpu.and(-1);
+        assert_eq!(cpu.registers.accumulator, 0);
+        assert_eq!(cpu.registers.status.contains(PS_ZERO), true);
+        assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
 
-        CPU.registers.accumulator = -1;
-        CPU.and(0);
-        assert_eq!(CPU.registers.accumulator, 0);
-        assert_eq!(CPU.registers.status.contains(PS_ZERO), true);
-        assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false);
+        cpu.registers.accumulator = -1;
+        cpu.and(0);
+        assert_eq!(cpu.registers.accumulator, 0);
+        assert_eq!(cpu.registers.status.contains(PS_ZERO), true);
+        assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
 
-        CPU.registers.accumulator = -1;
-        CPU.and(0x0f);
-        assert_eq!(CPU.registers.accumulator, 0x0f);
-        assert_eq!(CPU.registers.status.contains(PS_ZERO), false);
-        assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false);
+        cpu.registers.accumulator = -1;
+        cpu.and(0x0f);
+        assert_eq!(cpu.registers.accumulator, 0x0f);
+        assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
+        assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
 
-        CPU.registers.accumulator = -1;
-        CPU.and(-128);
-        assert_eq!(CPU.registers.accumulator, -128);
-        assert_eq!(CPU.registers.status.contains(PS_ZERO), false);
-        assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), true);
+        cpu.registers.accumulator = -1;
+        cpu.and(-128);
+        assert_eq!(cpu.registers.accumulator, -128);
+        assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
+        assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), true);
     }
 
     #[test]
     fn subtract_with_carry_test() {
         let mut cpu = CPU::new();
 
-        CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied));
-        CPU.registers.accumulator = 0;
+        cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
+        cpu.registers.accumulator = 0;
 
-        CPU.subtract_with_carry(1);
-        assert_eq!(CPU.registers.accumulator, -1);
-        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_NEGATIVE), true);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.subtract_with_carry(1);
+        assert_eq!(cpu.registers.accumulator, -1);
+        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_NEGATIVE), true);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
-        CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied));
-        CPU.registers.accumulator = -128;
-        CPU.subtract_with_carry(1);
-        assert_eq!(CPU.registers.accumulator, 127);
-        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_NEGATIVE), false);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true);
+        cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
+        cpu.registers.accumulator = -128;
+        cpu.subtract_with_carry(1);
+        assert_eq!(cpu.registers.accumulator, 127);
+        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_NEGATIVE), false);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true);
 
-        CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied));
-        CPU.registers.accumulator = 127;
-        CPU.subtract_with_carry(-1);
-        assert_eq!(CPU.registers.accumulator, -128);
-        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_NEGATIVE), true);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true);
+        cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
+        cpu.registers.accumulator = 127;
+        cpu.subtract_with_carry(-1);
+        assert_eq!(cpu.registers.accumulator, -128);
+        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_NEGATIVE), true);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true);
 
-        CPU.execute_instruction((Instruction::CLC, OpInput::UseImplied));
-        CPU.registers.accumulator = -64;
-        CPU.subtract_with_carry(64);
-        assert_eq!(CPU.registers.accumulator, 127);
-        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_NEGATIVE), false);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true);
+        cpu.execute_instruction((Instruction::CLC, OpInput::UseImplied));
+        cpu.registers.accumulator = -64;
+        cpu.subtract_with_carry(64);
+        assert_eq!(cpu.registers.accumulator, 127);
+        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_NEGATIVE), false);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true);
 
-        CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied));
-        CPU.registers.accumulator = 0;
-        CPU.subtract_with_carry(-128);
-        assert_eq!(CPU.registers.accumulator, -128);
-        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_NEGATIVE), true);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), true);
+        cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
+        cpu.registers.accumulator = 0;
+        cpu.subtract_with_carry(-128);
+        assert_eq!(cpu.registers.accumulator, -128);
+        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_NEGATIVE), true);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), true);
 
-        CPU.execute_instruction((Instruction::CLC, OpInput::UseImplied));
-        CPU.registers.accumulator = 0;
-        CPU.subtract_with_carry(127);
-        assert_eq!(CPU.registers.accumulator, -128);
-        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_NEGATIVE), true);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.execute_instruction((Instruction::CLC, OpInput::UseImplied));
+        cpu.registers.accumulator = 0;
+        cpu.subtract_with_carry(127);
+        assert_eq!(cpu.registers.accumulator, -128);
+        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_NEGATIVE), true);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
     }
 
     #[test]
@@ -941,29 +941,29 @@ mod tests {
         let mut cpu = CPU::new();
         let addr = Address(0xA1B2);
 
-        CPU.memory.set_byte(addr, 5);
+        cpu.memory.set_byte(addr, 5);
 
-        CPU.decrement_memory(addr);
-        assert_eq!(CPU.memory.get_byte(addr), 4);
-        assert_eq!(CPU.registers.status.contains(PS_ZERO), false);
-        assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false);
+        cpu.decrement_memory(addr);
+        assert_eq!(cpu.memory.get_byte(addr), 4);
+        assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
+        assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
 
-        CPU.decrement_memory(addr);
-        assert_eq!(CPU.memory.get_byte(addr), 3);
-        assert_eq!(CPU.registers.status.contains(PS_ZERO), false);
-        assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false);
+        cpu.decrement_memory(addr);
+        assert_eq!(cpu.memory.get_byte(addr), 3);
+        assert_eq!(cpu.registers.status.contains(PS_ZERO), false);
+        assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
 
-        CPU.decrement_memory(addr);
-        CPU.decrement_memory(addr);
-        CPU.decrement_memory(addr);
-        assert_eq!(CPU.memory.get_byte(addr), 0);
-        assert_eq!(CPU.registers.status.contains(PS_ZERO), true);
-        assert_eq!(CPU.registers.status.contains(PS_NEGATIVE), false);
+        cpu.decrement_memory(addr);
+        cpu.decrement_memory(addr);
+        cpu.decrement_memory(addr);
+        assert_eq!(cpu.memory.get_byte(addr), 0);
+        assert_eq!(cpu.registers.status.contains(PS_ZERO), true);
+        assert_eq!(cpu.registers.status.contains(PS_NEGATIVE), false);
 
-        CPU.decrement_memory(addr);
-        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_NEGATIVE), true);
+        cpu.decrement_memory(addr);
+        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_NEGATIVE), true);
     }
 
     #[test]
@@ -971,82 +971,82 @@ mod tests {
         // Testing UseImplied version (which targets the accumulator) only, for now
 
         let mut cpu = CPU::new();
-        CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(0)));
-        CPU.execute_instruction((Instruction::LSR, OpInput::UseImplied));
-        assert_eq!(CPU.registers.accumulator, 0);
-        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_NEGATIVE), false);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(0)));
+        cpu.execute_instruction((Instruction::LSR, OpInput::UseImplied));
+        assert_eq!(cpu.registers.accumulator, 0);
+        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_NEGATIVE), false);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
-        CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(1)));
-        CPU.execute_instruction((Instruction::LSR, OpInput::UseImplied));
-        assert_eq!(CPU.registers.accumulator, 0);
-        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_NEGATIVE), false);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(1)));
+        cpu.execute_instruction((Instruction::LSR, OpInput::UseImplied));
+        assert_eq!(cpu.registers.accumulator, 0);
+        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_NEGATIVE), false);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
-        CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(255)));
-        CPU.execute_instruction((Instruction::LSR, OpInput::UseImplied));
-        assert_eq!(CPU.registers.accumulator, 0x7F);
-        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_NEGATIVE), false);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(255)));
+        cpu.execute_instruction((Instruction::LSR, OpInput::UseImplied));
+        assert_eq!(cpu.registers.accumulator, 0x7F);
+        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_NEGATIVE), false);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
-        CPU.execute_instruction((Instruction::LDA, OpInput::UseImmediate(254)));
-        CPU.execute_instruction((Instruction::LSR, OpInput::UseImplied));
-        assert_eq!(CPU.registers.accumulator, 0x7F);
-        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_NEGATIVE), false);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(254)));
+        cpu.execute_instruction((Instruction::LSR, OpInput::UseImplied));
+        assert_eq!(cpu.registers.accumulator, 0x7F);
+        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_NEGATIVE), false);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
     }
 
     #[test]
     fn dec_x_test() {
         let mut cpu = CPU::new();
 
-        CPU.dec_x();
-        assert_eq!(CPU.registers.index_x, -1);
-        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_NEGATIVE), true);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.dec_x();
+        assert_eq!(cpu.registers.index_x, -1);
+        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_NEGATIVE), true);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
-        CPU.dec_x();
-        assert_eq!(CPU.registers.index_x, -2);
-        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_NEGATIVE), true);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.dec_x();
+        assert_eq!(cpu.registers.index_x, -2);
+        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_NEGATIVE), true);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
-        CPU.load_x_register(5);
-        CPU.dec_x();
-        assert_eq!(CPU.registers.index_x, 4);
-        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_NEGATIVE), false);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.load_x_register(5);
+        cpu.dec_x();
+        assert_eq!(cpu.registers.index_x, 4);
+        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_NEGATIVE), 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.status.contains(PS_CARRY), false);
-        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_OVERFLOW), false);
+        assert_eq!(cpu.registers.index_x, 0);
+        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_NEGATIVE), false);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
 
-        CPU.dec_x();
-        assert_eq!(CPU.registers.index_x, -1);
-        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_NEGATIVE), true);
-        assert_eq!(CPU.registers.status.contains(PS_OVERFLOW), false);
+        cpu.dec_x();
+        assert_eq!(cpu.registers.index_x, -1);
+        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_NEGATIVE), true);
+        assert_eq!(cpu.registers.status.contains(PS_OVERFLOW), false);
     }
 
     #[test]
@@ -1054,68 +1054,68 @@ mod tests {
         let mut cpu = CPU::new();
         let addr = Address(0xA1B1);
 
-        CPU.jump(addr);
-        assert_eq!(CPU.registers.program_counter, addr);
+        cpu.jump(addr);
+        assert_eq!(cpu.registers.program_counter, addr);
     }
 
     #[test]
     fn branch_if_carry_clear_test() {
         let mut cpu = CPU::new();
 
-        CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied));
-        CPU.branch_if_carry_clear(Address(0xABCD));
-        assert_eq!(CPU.registers.program_counter, Address(0));
+        cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
+        cpu.branch_if_carry_clear(Address(0xABCD));
+        assert_eq!(cpu.registers.program_counter, Address(0));
 
-        CPU.execute_instruction((Instruction::CLC, OpInput::UseImplied));
-        CPU.branch_if_carry_clear(Address(0xABCD));
-        assert_eq!(CPU.registers.program_counter, Address(0xABCD));
+        cpu.execute_instruction((Instruction::CLC, OpInput::UseImplied));
+        cpu.branch_if_carry_clear(Address(0xABCD));
+        assert_eq!(cpu.registers.program_counter, Address(0xABCD));
     }
 
     #[test]
     fn branch_if_carry_set_test() {
         let mut cpu = CPU::new();
 
-        CPU.execute_instruction((Instruction::CLC, OpInput::UseImplied));
-        CPU.branch_if_carry_set(Address(0xABCD));
-        assert_eq!(CPU.registers.program_counter, Address(0));
+        cpu.execute_instruction((Instruction::CLC, OpInput::UseImplied));
+        cpu.branch_if_carry_set(Address(0xABCD));
+        assert_eq!(cpu.registers.program_counter, Address(0));
 
-        CPU.execute_instruction((Instruction::SEC, OpInput::UseImplied));
-        CPU.branch_if_carry_set(Address(0xABCD));
-        assert_eq!(CPU.registers.program_counter, Address(0xABCD));
+        cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
+        cpu.branch_if_carry_set(Address(0xABCD));
+        assert_eq!(cpu.registers.program_counter, Address(0xABCD));
     }
 
     #[test]
     fn branch_if_equal_test() {
         let mut cpu = CPU::new();
 
-        CPU.branch_if_equal(Address(0xABCD));
-        assert_eq!(CPU.registers.program_counter, Address(0));
+        cpu.branch_if_equal(Address(0xABCD));
+        assert_eq!(cpu.registers.program_counter, Address(0));
 
-        CPU.registers.status.or(PS_ZERO);
-        CPU.branch_if_equal(Address(0xABCD));
-        assert_eq!(CPU.registers.program_counter, Address(0xABCD));
+        cpu.registers.status.or(PS_ZERO);
+        cpu.branch_if_equal(Address(0xABCD));
+        assert_eq!(cpu.registers.program_counter, Address(0xABCD));
     }
 
     #[test]
     fn branch_if_minus_test() {
         {
             let mut cpu = CPU::new();
-            let registers_before = CPU.registers;
+            let registers_before = cpu.registers;
 
-            CPU.branch_if_minus(Address(0xABCD));
-            assert_eq!(CPU.registers, registers_before);
-            assert_eq!(CPU.registers.program_counter, Address(0));
+            cpu.branch_if_minus(Address(0xABCD));
+            assert_eq!(cpu.registers, registers_before);
+            assert_eq!(cpu.registers.program_counter, Address(0));
         }
 
         {
             let mut cpu = CPU::new();
 
-            CPU.registers.status.or(PS_NEGATIVE);
-            let registers_before = CPU.registers;
+            cpu.registers.status.or(PS_NEGATIVE);
+            let registers_before = cpu.registers;
 
-            CPU.branch_if_minus(Address(0xABCD));
-            assert_eq!(CPU.registers.status, registers_before.status);
-            assert_eq!(CPU.registers.program_counter, Address(0xABCD));
+            cpu.branch_if_minus(Address(0xABCD));
+            assert_eq!(cpu.registers.status, registers_before.status);
+            assert_eq!(cpu.registers.program_counter, Address(0xABCD));
         }
     }
 
@@ -1123,38 +1123,38 @@ mod tests {
     fn branch_if_positive_test() {
         let mut cpu = CPU::new();
 
-        CPU.registers.status.insert(PS_NEGATIVE);
-        CPU.branch_if_positive(Address(0xABCD));
-        assert_eq!(CPU.registers.program_counter, Address(0));
+        cpu.registers.status.insert(PS_NEGATIVE);
+        cpu.branch_if_positive(Address(0xABCD));
+        assert_eq!(cpu.registers.program_counter, Address(0));
 
-        CPU.registers.status.remove(PS_NEGATIVE);
-        CPU.branch_if_positive(Address(0xABCD));
-        assert_eq!(CPU.registers.program_counter, Address(0xABCD));
+        cpu.registers.status.remove(PS_NEGATIVE);
+        cpu.branch_if_positive(Address(0xABCD));
+        assert_eq!(cpu.registers.program_counter, Address(0xABCD));
     }
 
     #[test]
     fn branch_if_overflow_clear_test() {
         let mut cpu = CPU::new();
 
-        CPU.registers.status.insert(PS_OVERFLOW);
-        CPU.branch_if_overflow_clear(Address(0xABCD));
-        assert_eq!(CPU.registers.program_counter, Address(0));
+        cpu.registers.status.insert(PS_OVERFLOW);
+        cpu.branch_if_overflow_clear(Address(0xABCD));
+        assert_eq!(cpu.registers.program_counter, Address(0));
 
-        CPU.registers.status.remove(PS_OVERFLOW);
-        CPU.branch_if_overflow_clear(Address(0xABCD));
-        assert_eq!(CPU.registers.program_counter, Address(0xABCD));
+        cpu.registers.status.remove(PS_OVERFLOW);
+        cpu.branch_if_overflow_clear(Address(0xABCD));
+        assert_eq!(cpu.registers.program_counter, Address(0xABCD));
     }
 
     #[test]
     fn branch_if_overflow_set_test() {
         let mut cpu = CPU::new();
 
-        CPU.branch_if_overflow_set(Address(0xABCD));
-        assert_eq!(CPU.registers.program_counter, Address(0));
+        cpu.branch_if_overflow_set(Address(0xABCD));
+        assert_eq!(cpu.registers.program_counter, Address(0));
 
-        CPU.registers.status.insert(PS_OVERFLOW);
-        CPU.branch_if_overflow_set(Address(0xABCD));
-        assert_eq!(CPU.registers.program_counter, Address(0xABCD));
+        cpu.registers.status.insert(PS_OVERFLOW);
+        cpu.branch_if_overflow_set(Address(0xABCD));
+        assert_eq!(cpu.registers.program_counter, Address(0xABCD));
     }
 
     #[cfg(test)]
@@ -1164,59 +1164,59 @@ mod tests {
     {
         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);
-        assert!(CPU.registers.status.contains(PS_ZERO));
-        assert!(CPU.registers.status.contains(PS_CARRY));
-        assert!(!CPU.registers.status.contains(PS_NEGATIVE));
+        assert!(cpu.registers.status.contains(PS_ZERO));
+        assert!(cpu.registers.status.contains(PS_CARRY));
+        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);
-        assert!(!CPU.registers.status.contains(PS_ZERO));
-        assert!(CPU.registers.status.contains(PS_CARRY));
-        assert!(!CPU.registers.status.contains(PS_NEGATIVE));
+        assert!(!cpu.registers.status.contains(PS_ZERO));
+        assert!(cpu.registers.status.contains(PS_CARRY));
+        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);
-        assert!(!CPU.registers.status.contains(PS_ZERO));
-        assert!(!CPU.registers.status.contains(PS_CARRY));
-        assert!(CPU.registers.status.contains(PS_NEGATIVE));
+        assert!(!cpu.registers.status.contains(PS_ZERO));
+        assert!(!cpu.registers.status.contains(PS_CARRY));
+        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);
-        assert!(!CPU.registers.status.contains(PS_ZERO));
-        assert!(!CPU.registers.status.contains(PS_CARRY));
-        assert!(!CPU.registers.status.contains(PS_NEGATIVE));
+        assert!(!cpu.registers.status.contains(PS_ZERO));
+        assert!(!cpu.registers.status.contains(PS_CARRY));
+        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);
-        assert!(!CPU.registers.status.contains(PS_ZERO));
-        assert!(!CPU.registers.status.contains(PS_CARRY));
-        assert!(!CPU.registers.status.contains(PS_NEGATIVE));
+        assert!(!cpu.registers.status.contains(PS_ZERO));
+        assert!(!cpu.registers.status.contains(PS_CARRY));
+        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);
-        assert!(!CPU.registers.status.contains(PS_ZERO));
-        assert!(!CPU.registers.status.contains(PS_CARRY));
-        assert!(CPU.registers.status.contains(PS_NEGATIVE));
+        assert!(!cpu.registers.status.contains(PS_ZERO));
+        assert!(!cpu.registers.status.contains(PS_CARRY));
+        assert!(cpu.registers.status.contains(PS_NEGATIVE));
     }
 
     #[test]
     fn compare_with_a_register_test() {
         compare_test_helper(
             &mut |CPU: &mut cpu, val: u8| {
-                CPU.compare_with_a_register(val);
+                cpu.compare_with_a_register(val);
             },
             Instruction::LDA,
         );
@@ -1226,7 +1226,7 @@ mod tests {
     fn compare_with_x_register_test() {
         compare_test_helper(
             &mut |CPU: &mut cpu, val: u8| {
-                CPU.compare_with_x_register(val);
+                cpu.compare_with_x_register(val);
             },
             Instruction::LDX,
         );
@@ -1236,7 +1236,7 @@ mod tests {
     fn compare_with_y_register_test() {
         compare_test_helper(
             &mut |CPU: &mut cpu, val: u8| {
-                CPU.compare_with_y_register(val);
+                cpu.compare_with_y_register(val);
             },
             Instruction::LDY,
         );
@@ -1248,23 +1248,23 @@ mod tests {
 
         for a_before 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;
-                assert_eq!(CPU.registers.accumulator, a_after as i8);
+                assert_eq!(cpu.registers.accumulator, a_after as i8);
 
                 if a_after == 0 {
-                    assert!(CPU.registers.status.contains(PS_ZERO));
+                    assert!(cpu.registers.status.contains(PS_ZERO));
                 } else {
-                    assert!(!CPU.registers.status.contains(PS_ZERO));
+                    assert!(!cpu.registers.status.contains(PS_ZERO));
                 }
 
                 if (a_after as i8) < 0 {
-                    assert!(CPU.registers.status.contains(PS_NEGATIVE));
+                    assert!(cpu.registers.status.contains(PS_NEGATIVE));
                 } else {
-                    assert!(!CPU.registers.status.contains(PS_NEGATIVE));
+                    assert!(!cpu.registers.status.contains(PS_NEGATIVE));
                 }
             }
         }
@@ -1276,23 +1276,23 @@ mod tests {
 
         for a_before 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;
-                assert_eq!(CPU.registers.accumulator, a_after as i8);
+                assert_eq!(cpu.registers.accumulator, a_after as i8);
 
                 if a_after == 0 {
-                    assert!(CPU.registers.status.contains(PS_ZERO));
+                    assert!(cpu.registers.status.contains(PS_ZERO));
                 } else {
-                    assert!(!CPU.registers.status.contains(PS_ZERO));
+                    assert!(!cpu.registers.status.contains(PS_ZERO));
                 }
 
                 if (a_after as i8) < 0 {
-                    assert!(CPU.registers.status.contains(PS_NEGATIVE));
+                    assert!(cpu.registers.status.contains(PS_NEGATIVE));
                 } else {
-                    assert!(!CPU.registers.status.contains(PS_NEGATIVE));
+                    assert!(!cpu.registers.status.contains(PS_NEGATIVE));
                 }
             }
         }

From 7e8171487e2b222847dd138c0e8dfc1c8f53da65 Mon Sep 17 00:00:00 2001
From: Noppadet Vivatchotikul <osnoppadetv@dtac.co.th>
Date: Fri, 26 Oct 2018 09:50:43 +0700
Subject: [PATCH 3/3] fix syntax error

---
 src/cpu.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cpu.rs b/src/cpu.rs
index c2e38e4..3e9191b 100644
--- a/src/cpu.rs
+++ b/src/cpu.rs
@@ -1160,7 +1160,7 @@ mod tests {
     #[cfg(test)]
     fn compare_test_helper<F>(compare: &mut F, load_instruction: Instruction)
     where
-        F: FnMut(&mut cpu, u8),
+        F: FnMut(&mut CPU, u8),
     {
         let mut cpu = CPU::new();
 
@@ -1215,7 +1215,7 @@ mod tests {
     #[test]
     fn compare_with_a_register_test() {
         compare_test_helper(
-            &mut |CPU: &mut cpu, val: u8| {
+            &mut |cpu: &mut CPU, val: u8| {
                 cpu.compare_with_a_register(val);
             },
             Instruction::LDA,
@@ -1225,7 +1225,7 @@ mod tests {
     #[test]
     fn compare_with_x_register_test() {
         compare_test_helper(
-            &mut |CPU: &mut cpu, val: u8| {
+            &mut |cpu: &mut CPU, val: u8| {
                 cpu.compare_with_x_register(val);
             },
             Instruction::LDX,
@@ -1235,7 +1235,7 @@ mod tests {
     #[test]
     fn compare_with_y_register_test() {
         compare_test_helper(
-            &mut |CPU: &mut cpu, val: u8| {
+            &mut |cpu: &mut CPU, val: u8| {
                 cpu.compare_with_y_register(val);
             },
             Instruction::LDY,