finished branch testing

Author: derzz

src/cpu.rs

@@ -3,6 +3,7 @@ use bitflags::bitflags;
 use std::fmt;
 use std::time::Duration;
 
+mod branch_test;
 mod group1_test;
 mod group2_test;
 mod group3_test;
@@ -87,7 +88,7 @@ impl CPU {
             x: 0,
             y: 0,
             sp: STACK_RESET,
-            flags: CpuFlags::from_bits_truncate(0b00100100),
+            flags: CpuFlags::from_bits_truncate(0b0010_0100),
             memory: [0; 0xFFFF],
             clock_time: Duration::from_millis(1), // Example value
         }
@@ -239,7 +240,6 @@ impl CPU {
                 break;
             }
             // NOTE: Before this runs, PC must be at the instruction before the next command
-            // BUG: This may affect branching and needs to be adjusted
             self.pc = self.pc.wrapping_add(1);
         }
         // CLeaning program ROM
@@ -849,8 +849,15 @@ impl CPU {
 
     // This code will read the next item in the pc and set the pc to jump there with + 1 to go to the next instruction
     fn branch(&mut self) {
+        println!(
+            "branch: Initalized, starting to branch from pc {:#x}!",
+            self.pc
+        );
         let jump = self.mem_read(self.pc) as i8;
-        self.pc = self.pc.wrapping_add(1).wrapping_add(jump as u16);
+        println!("branch: jump is {:x}", jump);
+        // NOTE We do not need to add 2 as at then end of every run cycle will add 1, the other 1 is added since the pc is on the address instead of the instruction
+        self.pc = self.pc.wrapping_add(jump as u16);
+        println!("Finished branch, pc is now on {:#x}", self.pc);
     }
 
     fn if_contain_flag_branch(&mut self, flag: CpuFlags) {
@@ -860,7 +867,7 @@ impl CPU {
     }
 
     fn if_clear_flag_branch(&mut self, flag: CpuFlags) {
-        if self.flags.contains(flag) {
+        if !self.flags.contains(flag) {
             self.branch();
         }
     }
@@ -899,6 +906,8 @@ impl CPU {
                 bbb
             )
         } else if bbb == 0b100 {
+            // Add pc by 1 to go to reading address
+            self.pc = self.pc.wrapping_add(1);
             // Checking for branches
             match aaa {
                 // BPL

src/cpu/branch_test.rs

@@ -0,0 +1,88 @@
+#[cfg(test)]
+// Similar to JMP testing, and just branch further into the code
+// Eg. Set [BRANCH 0x02 0x00 INX]
+// And just test for x and see if branch has been or hasn't been done
+mod branch_test {
+    use crate::cpu::op::*;
+    use crate::cpu::CpuFlags;
+    use crate::cpu::CPU;
+
+    // All this will do is run [op 0x01 0x00 INX]
+    // Specify clear if the flag should be clear(This will enable all flags except the chosen flag)
+    // It will initalize all flags as empty, specify in flags to enable flags
+    // If x == 1, branch is successful, if not, branch is unsuccessful
+    fn jump(cpu: &mut CPU, op: u8, clear: bool, flag: CpuFlags) {
+        cpu.load_and_reset(vec![op, 0x01, 0x00, op::INX]);
+        if clear {
+            println!("branch_test: Allocating flags to clear!");
+            cpu.flags = CpuFlags::from_bits_truncate(0b1111_1111);
+            cpu.flags.remove(flag);
+        } else {
+            cpu.flags.insert(flag);
+        }
+        cpu.run();
+    }
+
+    // Each test will test when branch should occur and branch should not occur
+    // Clear tests if flag is clear
+    fn helper_test(op: u8, clear: bool, flag: CpuFlags) {
+        let mut cpu = CPU::new();
+        // First test should succeed
+        jump(&mut cpu, op, clear, flag);
+        assert!(
+            cpu.x == 1,
+            "Helper_test positive failed on {:#x}, cpu.x is {}",
+            op,
+            cpu.x
+        );
+
+        // Second test should fail
+        jump(&mut cpu, op, !clear, flag);
+        assert!(
+            cpu.x == 0,
+            "Helper_test negative failed on {:#x}, cpu.x is {}",
+            op,
+            cpu.x
+        );
+    }
+
+    #[test]
+    fn bpl_test() {
+        helper_test(branch_op::BPL, true, CpuFlags::NEGATIVE);
+    }
+
+    #[test]
+    fn bmi_test() {
+        helper_test(branch_op::BMI, false, CpuFlags::NEGATIVE);
+    }
+
+    #[test]
+    fn bvc_test() {
+        helper_test(branch_op::BVC, true, CpuFlags::OVERFLOW);
+    }
+
+    #[test]
+    fn bvs_test() {
+        helper_test(branch_op::BVS, false, CpuFlags::OVERFLOW);
+    }
+
+    #[test]
+    fn bcc_test() {
+        helper_test(branch_op::BCC, true, CpuFlags::CARRY);
+    }
+
+    #[test]
+    fn bcs_test() {
+        helper_test(branch_op::BCS, false, CpuFlags::CARRY);
+    }
+
+    #[test]
+    fn bne_test() {
+        helper_test(branch_op::BNE, true, CpuFlags::ZERO);
+    }
+
+    #[test]
+    fn beq_test() {
+        helper_test(branch_op::BEQ, false, CpuFlags::ZERO);
+    }
+}

src/cpu/group2_test.rs

@@ -10,7 +10,6 @@ mod group2_test {
     use crate::cpu::op::*;
     use crate::cpu::CpuFlags;
     use crate::cpu::CPU;
-    use crate::print_title;
 
     fn g2_flag_test(cpu: &CPU, carry: bool, zero: bool, negative: bool) {
         if carry {

src/cpu/op.rs

@@ -102,3 +102,15 @@ pub mod g3_op {
 
     pub const BIT: u8 = 0x20;
 }
+
+#[cfg(test)]
+pub mod branch_op {
+    pub const BPL: u8 = 0x10; // Branch on Plus (N=0)
+    pub const BMI: u8 = 0x30; // Branch on Minus (N=1)
+    pub const BVC: u8 = 0x50; // Branch on Overflow Clear (V=0)
+    pub const BVS: u8 = 0x70; // Branch on Overflow Set (V=1)
+    pub const BCC: u8 = 0x90; // Branch on Carry Clear (C=0)
+    pub const BCS: u8 = 0xB0; // Branch on Carry Set (C=1)
+    pub const BNE: u8 = 0xD0; // Branch on Not Equal (Z=0)
+    pub const BEQ: u8 = 0xF0; // Branch on Equal (Z=1)
+}