unbreak tests

X86DisassemblerTests/InstructionTests/JumpInstructionTests.cs

@@ -1,4 +1,5 @@
 using X86Disassembler.X86;
+using X86Disassembler.X86.Operands;
 
 namespace X86DisassemblerTests.InstructionTests;
 
@@ -16,15 +17,25 @@ public class JumpInstructionTests
         // Arrange
         // JMP +5 (EB 05) - Jump 5 bytes forward
         byte[] codeBuffer = new byte[] { 0xEB, 0x05 };
-        var decoder = new InstructionDecoder(codeBuffer, codeBuffer.Length);
+        var disassembler = new Disassembler(codeBuffer, 0);
         
         // Act
-        var instruction = decoder.DecodeInstruction();
+        var instruction = disassembler.Disassemble().First();
         
         // Assert
         Assert.NotNull(instruction);
-        Assert.Equal("jmp", instruction.Mnemonic);
-        Assert.Equal("0x00000007", instruction.Operands); // Current position (2) + offset (5) = 7
+        Assert.Equal(InstructionType.Jmp, instruction.Type);
+        
+        // Check that we have one operand
+        Assert.Single(instruction.StructuredOperands);
+        
+        // Check that the operand is a relative offset operand
+        var operand = instruction.StructuredOperands[0];
+        Assert.IsType<RelativeOffsetOperand>(operand);
+        
+        // Check the target address
+        var relativeOffsetOperand = (RelativeOffsetOperand)operand;
+        Assert.Equal(0x00000007UL, relativeOffsetOperand.TargetAddress); // Current position (2) + offset (5) = 7
     }
     
     /// <summary>
@@ -36,15 +47,25 @@ public class JumpInstructionTests
         // Arrange
         // JMP +0x12345678 (E9 78 56 34 12) - Jump 0x12345678 bytes forward
         byte[] codeBuffer = new byte[] { 0xE9, 0x78, 0x56, 0x34, 0x12 };
-        var decoder = new InstructionDecoder(codeBuffer, codeBuffer.Length);
+        var disassembler = new Disassembler(codeBuffer, 0);
         
         // Act
-        var instruction = decoder.DecodeInstruction();
+        var instruction = disassembler.Disassemble().First();
         
         // Assert
         Assert.NotNull(instruction);
-        Assert.Equal("jmp", instruction.Mnemonic);
-        Assert.Equal("0x1234567D", instruction.Operands); // Current position (5) + offset (0x12345678) = 0x1234567D
+        Assert.Equal(InstructionType.Jmp, instruction.Type);
+        
+        // Check that we have one operand
+        Assert.Single(instruction.StructuredOperands);
+        
+        // Check that the operand is a relative offset operand
+        var operand = instruction.StructuredOperands[0];
+        Assert.IsType<RelativeOffsetOperand>(operand);
+        
+        // Check the target address
+        var relativeOffsetOperand = (RelativeOffsetOperand)operand;
+        Assert.Equal(0x1234567DUL, relativeOffsetOperand.TargetAddress); // Current position (5) + offset (0x12345678) = 0x1234567D
     }
     
     /// <summary>
@@ -54,18 +75,27 @@ public class JumpInstructionTests
     public void ConditionalJumpHandler_DecodesJzRel8_Correctly()
     {
         // Arrange
-        // JZ +10 (74 0A) - Jump 10 bytes forward if zero/equal
-        // Note: JZ and JE are equivalent in x86
+        // JZ +10 (74 0A) - Jump 10 bytes forward if zero flag is set
         byte[] codeBuffer = new byte[] { 0x74, 0x0A };
-        var decoder = new InstructionDecoder(codeBuffer, codeBuffer.Length);
+        var disassembler = new Disassembler(codeBuffer, 0);
         
         // Act
-        var instruction = decoder.DecodeInstruction();
+        var instruction = disassembler.Disassemble().First();
         
         // Assert
         Assert.NotNull(instruction);
-        Assert.Equal("jz", instruction.Mnemonic);
-        Assert.Equal("0x0000000C", instruction.Operands); // Current position (2) + offset (10) = 12 (0x0C)
+        Assert.Equal(InstructionType.Jz, instruction.Type);
+        
+        // Check that we have one operand
+        Assert.Single(instruction.StructuredOperands);
+        
+        // Check that the operand is a relative offset operand
+        var operand = instruction.StructuredOperands[0];
+        Assert.IsType<RelativeOffsetOperand>(operand);
+        
+        // Check the target address
+        var relativeOffsetOperand = (RelativeOffsetOperand)operand;
+        Assert.Equal(0x0000000CUL, relativeOffsetOperand.TargetAddress); // Current position (2) + offset (10) = 12 (0x0C)
     }
     
     /// <summary>
@@ -75,18 +105,27 @@ public class JumpInstructionTests
     public void TwoByteConditionalJumpHandler_DecodesJnzRel32_Correctly()
     {
         // Arrange
-        // JNZ +0x12345678 (0F 85 78 56 34 12) - Jump 0x12345678 bytes forward if not zero/not equal
-        // Note: JNZ and JNE are equivalent in x86
+        // JNZ +0x12345678 (0F 85 78 56 34 12) - Jump 0x12345678 bytes forward if zero flag is not set
         byte[] codeBuffer = new byte[] { 0x0F, 0x85, 0x78, 0x56, 0x34, 0x12 };
-        var decoder = new InstructionDecoder(codeBuffer, codeBuffer.Length);
+        var disassembler = new Disassembler(codeBuffer, 0);
         
         // Act
-        var instruction = decoder.DecodeInstruction();
+        var instruction = disassembler.Disassemble().First();
         
         // Assert
         Assert.NotNull(instruction);
-        Assert.Equal("jnz", instruction.Mnemonic);
-        Assert.Equal("0x1234567E", instruction.Operands); // Current position (6) + offset (0x12345678) = 0x1234567E
+        Assert.Equal(InstructionType.Jnz, instruction.Type);
+        
+        // Check that we have one operand
+        Assert.Single(instruction.StructuredOperands);
+        
+        // Check that the operand is a relative offset operand
+        var operand = instruction.StructuredOperands[0];
+        Assert.IsType<RelativeOffsetOperand>(operand);
+        
+        // Check the target address
+        var relativeOffsetOperand = (RelativeOffsetOperand)operand;
+        Assert.Equal(0x1234567EUL, relativeOffsetOperand.TargetAddress); // Current position (6) + offset (0x12345678) = 0x1234567E
     }
     
     /// <summary>
@@ -98,15 +137,25 @@ public class JumpInstructionTests
         // Arrange
         // JGE +5 (7D 05) - Jump 5 bytes forward if greater than or equal
         byte[] codeBuffer = new byte[] { 0x7D, 0x05 };
-        var decoder = new InstructionDecoder(codeBuffer, codeBuffer.Length);
+        var disassembler = new Disassembler(codeBuffer, 0);
         
         // Act
-        var instruction = decoder.DecodeInstruction();
+        var instruction = disassembler.Disassemble().First();
         
         // Assert
         Assert.NotNull(instruction);
-        Assert.Equal("jge", instruction.Mnemonic);
-        Assert.Equal("0x00000007", instruction.Operands); // Current position (2) + offset (5) = 7
+        Assert.Equal(InstructionType.Jge, instruction.Type);
+        
+        // Check that we have one operand
+        Assert.Single(instruction.StructuredOperands);
+        
+        // Check that the operand is a relative offset operand
+        var operand = instruction.StructuredOperands[0];
+        Assert.IsType<RelativeOffsetOperand>(operand);
+        
+        // Check the target address
+        var relativeOffsetOperand = (RelativeOffsetOperand)operand;
+        Assert.Equal(0x00000007UL, relativeOffsetOperand.TargetAddress); // Current position (2) + offset (5) = 7
     }
     
     /// <summary>
@@ -117,16 +166,27 @@ public class JumpInstructionTests
     {
         // Arrange
         // JGE -5 (7D FB) - Jump 5 bytes backward if greater than or equal
+        // 0xFB is -5 in two's complement
         byte[] codeBuffer = new byte[] { 0x7D, 0xFB };
-        var disassembler = new Disassembler(codeBuffer, 0x1000); // Set a base address for easier verification
+        var disassembler = new Disassembler(codeBuffer, 0);
         
         // Act
         var instructions = disassembler.Disassemble();
         
         // Assert
         Assert.Single(instructions);
-        Assert.Equal("jge", instructions[0].Mnemonic);
-        Assert.Equal("0xFFFFFFFD", instructions[0].Operands); // 0x1000 + 2 - 5 = 0xFFFFFFFD (sign-extended)
+        Assert.Equal(InstructionType.Jge, instructions[0].Type);
+        
+        // Check that we have one operand
+        Assert.Single(instructions[0].StructuredOperands);
+        
+        // Check that the operand is a relative offset operand
+        var operand = instructions[0].StructuredOperands[0];
+        Assert.IsType<RelativeOffsetOperand>(operand);
+        
+        // Check the target address
+        var relativeOffsetOperand = (RelativeOffsetOperand)operand;
+        Assert.Equal(0xFFFFFFFDUL, relativeOffsetOperand.TargetAddress); // 0 + 2 - 5 = 0xFFFFFFFD (sign-extended)
     }
     
     /// <summary>
@@ -136,34 +196,88 @@ public class JumpInstructionTests
     public void JgeRel8Handler_DecodesJgeRel8_InSequence_Correctly()
     {
         // Arrange
-        // This is a common pattern: JGE/JL followed by different code paths
-        // JGE +5 (7D 05) - Jump 5 bytes forward if greater than or equal
-        // ADD EBP, 0x18 (83 C5 18)
-        // JMP +3 (EB 03) - Jump past the next instruction
-        // ADD EBP, -0x48 (83 C5 B8)
+        // Sequence of instructions:
+        // 1. JGE +5 (7D 05) - Jump 5 bytes forward if greater than or equal
+        // 2. ADD EBP, 0x18 (83 C5 18) - Add 0x18 to EBP
+        // 3. JMP +3 (EB 03) - Jump 3 bytes forward
+        // 4. ADD EBP, -0x48 (83 C5 B8) - Add -0x48 to EBP (0xB8 is -0x48 in two's complement)
         byte[] codeBuffer = new byte[] { 0x7D, 0x05, 0x83, 0xC5, 0x18, 0xEB, 0x03, 0x83, 0xC5, 0xB8 };
-        var disassembler = new Disassembler(codeBuffer, 0x1000);
+        var disassembler = new Disassembler(codeBuffer, 0);
         
         // Act
         var instructions = disassembler.Disassemble();
         
         // Assert
-        Assert.True(instructions.Count >= 4, $"Expected at least 4 instructions, but got {instructions.Count}");
+        Assert.Equal(4, instructions.Count);
         
         // First instruction: JGE +5
-        Assert.Equal("jge", instructions[0].Mnemonic);
-        Assert.Equal("0x00000007", instructions[0].Operands); // Base address is ignored, only relative offset matters
+        Assert.Equal(InstructionType.Jge, instructions[0].Type);
+        
+        // Check that we have one operand
+        Assert.Single(instructions[0].StructuredOperands);
+        
+        // Check that the operand is a relative offset operand
+        var operand = instructions[0].StructuredOperands[0];
+        Assert.IsType<RelativeOffsetOperand>(operand);
+        
+        // Check the target address
+        var relativeOffsetOperand = (RelativeOffsetOperand)operand;
+        Assert.Equal(7UL, relativeOffsetOperand.TargetAddress); // Base address is ignored, only relative offset matters
         
         // Second instruction: ADD EBP, 0x18
-        Assert.Equal("add", instructions[1].Mnemonic);
-        Assert.Equal("ebp, 0x00000018", instructions[1].Operands);
+        Assert.Equal(InstructionType.Add, instructions[1].Type);
+        
+        // Check that we have two operands
+        Assert.Equal(2, instructions[1].StructuredOperands.Count);
+        
+        // Check that the first operand is a register operand
+        var firstOperand = instructions[1].StructuredOperands[0];
+        Assert.IsType<RegisterOperand>(firstOperand);
+        
+        // Check that the second operand is an immediate operand
+        var secondOperand = instructions[1].StructuredOperands[1];
+        Assert.IsType<ImmediateOperand>(secondOperand);
+        
+        // Check the values of the operands
+        var registerOperand = (RegisterOperand)firstOperand;
+        var immediateOperand = (ImmediateOperand)secondOperand;
+        Assert.Equal(RegisterIndex.Bp, registerOperand.Register);
+        Assert.Equal(32, registerOperand.Size); // Validate that it's a 32-bit register (EBP)
+        Assert.Equal(0x18U, immediateOperand.Value);
         
         // Third instruction: JMP +3
-        Assert.Equal("jmp", instructions[2].Mnemonic);
-        Assert.Equal("0x0000000A", instructions[2].Operands); // Base address is ignored, only relative offset matters
+        Assert.Equal(InstructionType.Jmp, instructions[2].Type);
+        
+        // Check that we have one operand
+        Assert.Single(instructions[2].StructuredOperands);
+        
+        // Check that the operand is a relative offset operand
+        operand = instructions[2].StructuredOperands[0];
+        Assert.IsType<RelativeOffsetOperand>(operand);
+        
+        // Check the target address
+        relativeOffsetOperand = (RelativeOffsetOperand)operand;
+        Assert.Equal(10UL, relativeOffsetOperand.TargetAddress); // Base address is ignored, only relative offset matters
         
         // Fourth instruction: ADD EBP, -0x48 (0xB8 sign-extended to 32-bit is 0xFFFFFFB8)
-        Assert.Equal("add", instructions[3].Mnemonic);
-        Assert.Equal("ebp, 0xFFFFFFB8", instructions[3].Operands);
+        Assert.Equal(InstructionType.Add, instructions[3].Type);
+        
+        // Check that we have two operands
+        Assert.Equal(2, instructions[3].StructuredOperands.Count);
+        
+        // Check that the first operand is a register operand
+        firstOperand = instructions[3].StructuredOperands[0];
+        Assert.IsType<RegisterOperand>(firstOperand);
+        
+        // Check that the second operand is an immediate operand
+        secondOperand = instructions[3].StructuredOperands[1];
+        Assert.IsType<ImmediateOperand>(secondOperand);
+        
+        // Check the values of the operands
+        registerOperand = (RegisterOperand)firstOperand;
+        immediateOperand = (ImmediateOperand)secondOperand;
+        Assert.Equal(RegisterIndex.Bp, registerOperand.Register);
+        Assert.Equal(32, registerOperand.Size); // Validate that it's a 32-bit register (EBP)
+        Assert.Equal(0xFFFFFFB8L, immediateOperand.Value);
     }
 }