Added comprehensive test coverage for arithmetic and logical instructions. Implemented AND instruction handlers and added tests for ADC, SBB, and arithmetic unary operations.

X86Disassembler/X86/Handlers/And/AndAlImmHandler.cs

@@ -0,0 +1,57 @@
+namespace X86Disassembler.X86.Handlers.And;
+
+/// <summary>
+/// Handler for AND AL, imm8 instruction (0x24)
+/// </summary>
+public class AndAlImmHandler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the AndAlImmHandler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public AndAlImmHandler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        return opcode == 0x24;
+    }
+    
+    /// <summary>
+    /// Decodes an AND AL, imm8 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "and";
+        
+        int position = Decoder.GetPosition();
+        
+        // Read immediate value
+        if (position >= Length)
+        {
+            instruction.Operands = "al, ??";
+            return true;
+        }
+        
+        // Read immediate value
+        byte imm8 = Decoder.ReadByte();
+        
+        // Set operands
+        instruction.Operands = $"al, 0x{imm8:X2}";
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/And/AndEaxImmHandler.cs

@@ -0,0 +1,57 @@
+namespace X86Disassembler.X86.Handlers.And;
+
+/// <summary>
+/// Handler for AND EAX, imm32 instruction (0x25)
+/// </summary>
+public class AndEaxImmHandler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the AndEaxImmHandler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public AndEaxImmHandler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        return opcode == 0x25;
+    }
+    
+    /// <summary>
+    /// Decodes an AND EAX, imm32 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "and";
+        
+        int position = Decoder.GetPosition();
+        
+        // Read immediate value
+        if (position + 3 >= Length)
+        {
+            instruction.Operands = "eax, ??";
+            return true;
+        }
+        
+        // Read immediate value
+        uint imm32 = Decoder.ReadUInt32();
+        
+        // Set operands
+        instruction.Operands = $"eax, 0x{imm32:X8}";
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/And/AndImmToRm32Handler.cs

@@ -0,0 +1,94 @@
+namespace X86Disassembler.X86.Handlers.And;
+
+/// <summary>
+/// Handler for AND r/m32, imm32 instruction (0x81 /4)
+/// </summary>
+public class AndImmToRm32Handler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the AndImmToRm32Handler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public AndImmToRm32Handler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        if (opcode != 0x81)
+        {
+            return false;
+        }
+        
+        // Check if we have enough bytes to read the ModR/M byte
+        int position = Decoder.GetPosition();
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte to check the reg field (bits 5-3)
+        byte modRM = CodeBuffer[position];
+        int reg = (modRM >> 3) & 0x7;
+        
+        // reg = 4 means AND operation
+        return reg == 4;
+    }
+    
+    /// <summary>
+    /// Decodes an AND r/m32, imm32 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "and";
+        
+        int position = Decoder.GetPosition();
+        
+        // Read the ModR/M byte
+        var (mod, reg, rm, memOperand) = ModRMDecoder.ReadModRM();
+        
+        // Read immediate value
+        if (position + 3 >= Length)
+        {
+            // Incomplete instruction
+            if (mod == 3)
+            {
+                string rmRegName = ModRMDecoder.GetRegisterName(rm, 32);
+                instruction.Operands = $"{rmRegName}, ??";
+            }
+            else
+            {
+                instruction.Operands = $"{memOperand}, ??";
+            }
+            return true;
+        }
+        
+        // Read immediate value
+        uint imm32 = Decoder.ReadUInt32();
+        
+        // Set operands
+        if (mod == 3)
+        {
+            string rmRegName = ModRMDecoder.GetRegisterName(rm, 32);
+            instruction.Operands = $"{rmRegName}, 0x{imm32:X8}";
+        }
+        else
+        {
+            instruction.Operands = $"{memOperand}, 0x{imm32:X8}";
+        }
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/And/AndImmToRm32SignExtendedHandler.cs

@@ -0,0 +1,96 @@
+namespace X86Disassembler.X86.Handlers.And;
+
+/// <summary>
+/// Handler for AND r/m32, imm8 (sign-extended) instruction (0x83 /4)
+/// </summary>
+public class AndImmToRm32SignExtendedHandler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the AndImmToRm32SignExtendedHandler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public AndImmToRm32SignExtendedHandler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        if (opcode != 0x83)
+        {
+            return false;
+        }
+        
+        // Check if we have enough bytes to read the ModR/M byte
+        int position = Decoder.GetPosition();
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte to check the reg field (bits 5-3)
+        byte modRM = CodeBuffer[position];
+        int reg = (modRM >> 3) & 0x7;
+        
+        // reg = 4 means AND operation
+        return reg == 4;
+    }
+    
+    /// <summary>
+    /// Decodes an AND r/m32, imm8 (sign-extended) instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "and";
+        
+        int position = Decoder.GetPosition();
+        
+        // Read the ModR/M byte
+        var (mod, reg, rm, memOperand) = ModRMDecoder.ReadModRM();
+        
+        // Read immediate value
+        if (position >= Length)
+        {
+            // Incomplete instruction
+            if (mod == 3)
+            {
+                string rmRegName = ModRMDecoder.GetRegisterName(rm, 32);
+                instruction.Operands = $"{rmRegName}, ??";
+            }
+            else
+            {
+                instruction.Operands = $"{memOperand}, ??";
+            }
+            return true;
+        }
+        
+        // Read and sign-extend the immediate value
+        byte imm8 = Decoder.ReadByte();
+        int signExtended = (sbyte)imm8;
+        uint imm32 = (uint)signExtended;
+        
+        // Set operands
+        if (mod == 3)
+        {
+            string rmRegName = ModRMDecoder.GetRegisterName(rm, 32);
+            instruction.Operands = $"{rmRegName}, 0x{imm32:X8}";
+        }
+        else
+        {
+            instruction.Operands = $"{memOperand}, 0x{imm32:X8}";
+        }
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/And/AndImmToRm8Handler.cs

@@ -0,0 +1,93 @@
+namespace X86Disassembler.X86.Handlers.And;
+
+/// <summary>
+/// Handler for AND r/m8, imm8 instruction (0x80 /4)
+/// </summary>
+public class AndImmToRm8Handler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the AndImmToRm8Handler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public AndImmToRm8Handler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        if (opcode != 0x80)
+        {
+            return false;
+        }
+        
+        // Check if we have enough bytes to read the ModR/M byte
+        int position = Decoder.GetPosition();
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte to check the reg field (bits 5-3)
+        byte modRM = CodeBuffer[position];
+        int reg = (modRM >> 3) & 0x7;
+        
+        // reg = 4 means AND operation
+        return reg == 4;
+    }
+    
+    /// <summary>
+    /// Decodes an AND r/m8, imm8 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "and";
+        
+        int position = Decoder.GetPosition();
+        
+        // Read the ModR/M byte
+        var (mod, reg, rm, memOperand) = ModRMDecoder.ReadModRM();
+        
+        // Read immediate value
+        if (position >= Length)
+        {
+            // Incomplete instruction
+            if (mod == 3)
+            {
+                string rmRegName = ModRMDecoder.GetRegisterName(rm, 8);
+                instruction.Operands = $"{rmRegName}, ??";
+            }
+            else
+            {
+                instruction.Operands = $"byte ptr {memOperand}, ??";
+            }
+            return true;
+        }
+        
+        byte imm8 = Decoder.ReadByte();
+        
+        // Set operands
+        if (mod == 3)
+        {
+            string rmRegName = ModRMDecoder.GetRegisterName(rm, 8);
+            instruction.Operands = $"{rmRegName}, 0x{imm8:X2}";
+        }
+        else
+        {
+            instruction.Operands = $"byte ptr {memOperand}, 0x{imm8:X2}";
+        }
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/And/AndMemRegHandler.cs

@@ -0,0 +1,66 @@
+namespace X86Disassembler.X86.Handlers.And;
+
+/// <summary>
+/// Handler for AND r/m32, r32 instruction (0x21)
+/// </summary>
+public class AndMemRegHandler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the AndMemRegHandler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public AndMemRegHandler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        return opcode == 0x21;
+    }
+    
+    /// <summary>
+    /// Decodes an AND r/m32, r32 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "and";
+        
+        int position = Decoder.GetPosition();
+        
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte
+        var (mod, reg, rm, memOperand) = ModRMDecoder.ReadModRM();
+        
+        // Get register name
+        string regName = ModRMDecoder.GetRegisterName(reg, 32);
+        
+        // For mod == 3, both operands are registers
+        if (mod == 3)
+        {
+            string rmRegName = ModRMDecoder.GetRegisterName(rm, 32);
+            instruction.Operands = $"{rmRegName}, {regName}";
+        }
+        else // Memory operand
+        {
+            instruction.Operands = $"{memOperand}, {regName}";
+        }
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/And/AndR32Rm32Handler.cs

@@ -0,0 +1,66 @@
+namespace X86Disassembler.X86.Handlers.And;
+
+/// <summary>
+/// Handler for AND r32, r/m32 instruction (0x23)
+/// </summary>
+public class AndR32Rm32Handler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the AndR32Rm32Handler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public AndR32Rm32Handler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        return opcode == 0x23;
+    }
+    
+    /// <summary>
+    /// Decodes an AND r32, r/m32 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "and";
+        
+        int position = Decoder.GetPosition();
+        
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte
+        var (mod, reg, rm, memOperand) = ModRMDecoder.ReadModRM();
+        
+        // Get register name
+        string regName = ModRMDecoder.GetRegisterName(reg, 32);
+        
+        // For mod == 3, both operands are registers
+        if (mod == 3)
+        {
+            string rmRegName = ModRMDecoder.GetRegisterName(rm, 32);
+            instruction.Operands = $"{regName}, {rmRegName}";
+        }
+        else // Memory operand
+        {
+            instruction.Operands = $"{regName}, {memOperand}";
+        }
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/And/AndR8Rm8Handler.cs

@@ -0,0 +1,66 @@
+namespace X86Disassembler.X86.Handlers.And;
+
+/// <summary>
+/// Handler for AND r8, r/m8 instruction (0x22)
+/// </summary>
+public class AndR8Rm8Handler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the AndR8Rm8Handler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public AndR8Rm8Handler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        return opcode == 0x22;
+    }
+    
+    /// <summary>
+    /// Decodes an AND r8, r/m8 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "and";
+        
+        int position = Decoder.GetPosition();
+        
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte
+        var (mod, reg, rm, memOperand) = ModRMDecoder.ReadModRM();
+        
+        // Get register name
+        string regName = ModRMDecoder.GetRegisterName(reg, 8);
+        
+        // For mod == 3, both operands are registers
+        if (mod == 3)
+        {
+            string rmRegName = ModRMDecoder.GetRegisterName(rm, 8);
+            instruction.Operands = $"{regName}, {rmRegName}";
+        }
+        else // Memory operand
+        {
+            instruction.Operands = $"{regName}, byte ptr {memOperand}";
+        }
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/And/AndRm8R8Handler.cs

@@ -0,0 +1,66 @@
+namespace X86Disassembler.X86.Handlers.And;
+
+/// <summary>
+/// Handler for AND r/m8, r8 instruction (0x20)
+/// </summary>
+public class AndRm8R8Handler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the AndRm8R8Handler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public AndRm8R8Handler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        return opcode == 0x20;
+    }
+    
+    /// <summary>
+    /// Decodes an AND r/m8, r8 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "and";
+        
+        int position = Decoder.GetPosition();
+        
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte
+        var (mod, reg, rm, memOperand) = ModRMDecoder.ReadModRM();
+        
+        // Get register name
+        string regName = ModRMDecoder.GetRegisterName(reg, 8);
+        
+        // For mod == 3, both operands are registers
+        if (mod == 3)
+        {
+            string rmRegName = ModRMDecoder.GetRegisterName(rm, 8);
+            instruction.Operands = $"{rmRegName}, {regName}";
+        }
+        else // Memory operand
+        {
+            instruction.Operands = $"byte ptr {memOperand}, {regName}";
+        }
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/InstructionHandlerFactory.cs

@@ -1,4 +1,5 @@
 using X86Disassembler.X86.Handlers.Add;
+using X86Disassembler.X86.Handlers.And;
 using X86Disassembler.X86.Handlers.ArithmeticImmediate;
 using X86Disassembler.X86.Handlers.ArithmeticUnary;
 using X86Disassembler.X86.Handlers.Call;
@@ -56,6 +57,7 @@ public class InstructionHandlerFactory
         // Register handlers in order of priority (most specific first)
         RegisterArithmeticImmediateHandlers(); // Group 1 instructions (including 0x83)
         RegisterAddHandlers();
+        RegisterAndHandlers();
         RegisterArithmeticUnaryHandlers();
         RegisterCmpHandlers();
         RegisterXorHandlers();
@@ -349,6 +351,24 @@ public class InstructionHandlerFactory
         _handlers.Add(new PopRegHandler(_codeBuffer, _decoder, _length));
     }
     
+    /// <summary>
+    /// Registers all And instruction handlers
+    /// </summary>
+    private void RegisterAndHandlers()
+    {
+        // Add AND handlers
+        _handlers.Add(new AndImmToRm8Handler(_codeBuffer, _decoder, _length));
+        _handlers.Add(new AndImmToRm32Handler(_codeBuffer, _decoder, _length));
+        _handlers.Add(new AndImmToRm32SignExtendedHandler(_codeBuffer, _decoder, _length));
+
+        _handlers.Add(new AndR8Rm8Handler(_codeBuffer, _decoder, _length));
+        _handlers.Add(new AndRm8R8Handler(_codeBuffer, _decoder, _length));
+        _handlers.Add(new AndR32Rm32Handler(_codeBuffer, _decoder, _length));
+        _handlers.Add(new AndMemRegHandler(_codeBuffer, _decoder, _length));
+        _handlers.Add(new AndAlImmHandler(_codeBuffer, _decoder, _length));
+        _handlers.Add(new AndEaxImmHandler(_codeBuffer, _decoder, _length));
+    }
+    
     /// <summary>
     /// Gets the handler that can decode the given opcode
     /// </summary>