refactor 2 electric boogaloo

2025-06-15 21:40:43 +01:00
parent 277f210b3e
commit 2b8281157e
30 changed files with 125 additions and 71 deletions
@@ -0,0 +1,211 @@
+#![allow(clippy::unwrap_used)]
+use crate::prelude::*;
+
+#[test]
+fn test_opcode_nop() {
+    let instr = Instruction::Nop;
+    assert_eq!(instr.opcode(), 0x0);
+}
+
+#[test]
+fn test_opcode_data_transfer() {
+    let args = RTypeArgs::new(None, None, None, None);
+    assert_eq!(Instruction::Mov(args).opcode(), 0x1);
+    assert_eq!(Instruction::MovSigned(args).opcode(), 0x2);
+
+    let iargs = ITypeArgs::new(0, None, None);
+    assert_eq!(Instruction::LoadByte(iargs).opcode(), 0x3);
+    assert_eq!(Instruction::LoadByteSigned(iargs).opcode(), 0x4);
+    assert_eq!(Instruction::LoadHalfword(iargs).opcode(), 0x5);
+    assert_eq!(Instruction::LoadHalfwordSigned(iargs).opcode(), 0x6);
+    assert_eq!(Instruction::LoadWord(iargs).opcode(), 0x7);
+    assert_eq!(Instruction::StoreByte(iargs).opcode(), 0x8);
+    assert_eq!(Instruction::StoreHalfword(iargs).opcode(), 0x9);
+    assert_eq!(Instruction::StoreWord(iargs).opcode(), 0xA);
+    assert_eq!(Instruction::LoadLowerImmediate(iargs).opcode(), 0xB);
+    assert_eq!(Instruction::LoadUpperImmediate(iargs).opcode(), 0xC);
+}
+
+#[test]
+fn test_opcode_jump_instructions() {
+    let args = ITypeArgs::new(0, None, None);
+    assert_eq!(Instruction::Jump(args).opcode(), 0xD);
+    assert_eq!(Instruction::JumpEq(args).opcode(), 0xE);
+    assert_eq!(Instruction::JumpNeq(args).opcode(), 0xF);
+    assert_eq!(Instruction::JumpGt(args).opcode(), 0x10);
+    assert_eq!(Instruction::JumpGe(args).opcode(), 0x11);
+    assert_eq!(Instruction::JumpLt(args).opcode(), 0x12);
+    assert_eq!(Instruction::JumpLe(args).opcode(), 0x13);
+}
+
+#[test]
+fn test_opcode_arithmetic() {
+    let args = RTypeArgs::new(None, None, None, None);
+    assert_eq!(Instruction::Compare(args).opcode(), 0x14);
+    assert_eq!(Instruction::Increment(args).opcode(), 0x15);
+    assert_eq!(Instruction::Decrement(args).opcode(), 0x16);
+    assert_eq!(Instruction::ShiftLeft(args).opcode(), 0x17);
+    assert_eq!(Instruction::ShiftRight(args).opcode(), 0x18);
+    assert_eq!(Instruction::Add(args).opcode(), 0x19);
+    assert_eq!(Instruction::Sub(args).opcode(), 0x1A);
+}
+
+#[test]
+fn test_opcode_logical() {
+    let args = RTypeArgs::new(None, None, None, None);
+    assert_eq!(Instruction::And(args).opcode(), 0x1B);
+    assert_eq!(Instruction::Or(args).opcode(), 0x1C);
+    assert_eq!(Instruction::Not(args).opcode(), 0x1D);
+    assert_eq!(Instruction::Xor(args).opcode(), 0x1E);
+    assert_eq!(Instruction::Nand(args).opcode(), 0x1F);
+    assert_eq!(Instruction::Nor(args).opcode(), 0x20);
+    assert_eq!(Instruction::Xnor(args).opcode(), 0x21);
+}
+
+#[test]
+fn test_opcode_misc() {
+    let interrupt = Interrupt::Software(5);
+    assert_eq!(Instruction::Interrupt(interrupt).opcode(), 0x22);
+    assert_eq!(Instruction::IntReturn.opcode(), 0x23);
+    assert_eq!(Instruction::Halt.opcode(), 0x24);
+}
+
+#[test]
+fn test_opcode_with_different_args() {
+    let args1 = RTypeArgs::new(
+        Some(Register::Rg0),
+        Some(Register::Rg1),
+        Some(Register::Rg2),
+        Some(5),
+    );
+    let args2 = RTypeArgs::new(
+        Some(Register::Acc),
+        Some(Register::Spr),
+        Some(Register::Bpr),
+        Some(31),
+    );
+
+    // Opcode should be the same regardless of arguments
+    assert_eq!(
+        Instruction::Add(args1).opcode(),
+        Instruction::Add(args2).opcode()
+    );
+    assert_eq!(
+        Instruction::Sub(args1).opcode(),
+        Instruction::Sub(args2).opcode()
+    );
+}
+
+#[test]
+fn test_opcode_boundary_values() {
+    // Test highest opcode value
+    assert_eq!(Instruction::Halt.opcode(), 0x24);
+
+    // Test lowest opcode value
+    assert_eq!(Instruction::Nop.opcode(), 0x0);
+}
+
+#[test]
+fn test_instruction_decode_nop() {
+    let instr = Instruction::Nop;
+    let encoded = instr.encode();
+    let decoded = Instruction::decode(encoded).unwrap();
+    assert_eq!(instr, decoded);
+}
+
+#[test]
+fn test_instruction_decode_data_transfer() {
+    let args = RTypeArgs::new(
+        Some(Register::Rg0),
+        Some(Register::Rg1),
+        Some(Register::Rg2),
+        Some(5),
+    );
+    let instr = Instruction::Mov(args);
+    let encoded = instr.encode();
+    let decoded = Instruction::decode(encoded).unwrap();
+    assert_eq!(instr, decoded);
+
+    let iargs = ITypeArgs::new(100, Some(Register::Rg3), Some(Register::Rg4));
+    let instr = Instruction::LoadWord(iargs);
+    let encoded = instr.encode();
+    let decoded = Instruction::decode(encoded).unwrap();
+    assert_eq!(instr, decoded);
+}
+
+#[test]
+fn test_instruction_decode_jump() {
+    let args = ITypeArgs::new(200, Some(Register::Acc), Some(Register::Spr));
+    let instr = Instruction::Jump(args);
+    let encoded = instr.encode();
+    let decoded = Instruction::decode(encoded).unwrap();
+    assert_eq!(instr, decoded);
+
+    let instr = Instruction::JumpEq(args);
+    let encoded = instr.encode();
+    let decoded = Instruction::decode(encoded).unwrap();
+    assert_eq!(instr, decoded);
+}
+
+#[test]
+fn test_instruction_decode_arithmetic() {
+    let args = RTypeArgs::new(
+        Some(Register::Bpr),
+        Some(Register::Rg7),
+        Some(Register::Rgf),
+        Some(31),
+    );
+    let instr = Instruction::Add(args);
+    let encoded = instr.encode();
+    let decoded = Instruction::decode(encoded).unwrap();
+    assert_eq!(instr, decoded);
+
+    let instr = Instruction::Compare(args);
+    let encoded = instr.encode();
+    let decoded = Instruction::decode(encoded).unwrap();
+    assert_eq!(instr, decoded);
+}
+
+#[test]
+fn test_instruction_decode_logical() {
+    let args = RTypeArgs::new(
+        Some(Register::Rg8),
+        Some(Register::Rg9),
+        Some(Register::Rga),
+        Some(15),
+    );
+    let instr = Instruction::And(args);
+    let encoded = instr.encode();
+    let decoded = Instruction::decode(encoded).unwrap();
+    assert_eq!(instr, decoded);
+
+    let instr = Instruction::Xor(args);
+    let encoded = instr.encode();
+    let decoded = Instruction::decode(encoded).unwrap();
+    assert_eq!(instr, decoded);
+}
+
+#[test]
+fn test_instruction_decode_misc() {
+    let instr = Instruction::Halt;
+    let encoded = instr.encode();
+    let decoded = Instruction::decode(encoded).unwrap();
+    assert_eq!(instr, decoded);
+}
+
+#[test]
+fn test_instruction_decode_invalid() {
+    // Test with invalid opcode.
+    let invalid_encoded = 0xFF00_0000;
+    assert!(Instruction::decode(invalid_encoded).is_err());
+}
+
+// TODO: Get interrupts working.
+// #[test]
+// fn test_instruction_decode_interrupt() {
+//     let interrupt = Interrupt::Software(10);
+//     let instr = Instruction::Interrupt(interrupt);
+//     let encoded = instr.encode();
+//     let decoded = Instruction::decode(encoded).unwrap();
+//     assert_eq!(instr, decoded);
+// }