libmwemu 0.24.5

//! Tests for the FCOM, FCOMP, and FCOMPP instructions.
//!
//! FCOM/FCOMP/FCOMPP - Compare Floating-Point Values
//!
//! FCOM compares ST(0) with a source value and sets condition code flags
//! C0, C2, and C3 in the FPU status word according to the results.
//!
//! FCOMP performs the same comparison and then pops the register stack.
//! FCOMPP compares ST(0) with ST(1) and pops the stack twice.
//!
//! Comparison Results:
//! - ST(0) > SRC: C3=0, C2=0, C0=0
//! - ST(0) < SRC: C3=0, C2=0, C0=1
//! - ST(0) = SRC: C3=1, C2=0, C0=0
//! - Unordered:   C3=1, C2=1, C0=1 (NaN operand)
//!
//! Opcodes:
//! - FCOM: D8 /2 (mem), D8 D0+i (reg)
//! - FCOMP: D8 /3 (mem), D8 D8+i (reg)
//! - FCOMPP: DE D9
//!
//! Flags affected:
//! - C1: Set to 0
//! - C0, C2, C3: Set according to comparison result
//!
//! Reference: /Users/int/dev/rax/docs/fcom:fcomp:fcompp.txt

use crate::*;
const DATA_ADDR: u64 = 0x7000;

// Helper function to write f64 to memory
fn write_f64(mem: u64, addr: u64, val: f64) {
    let mut emu = emu64();
    emu.maps.write_bytes_slice(addr, &val.to_le_bytes());
}

// Helper function to read f64 from memory
fn read_f64(mem: u64, addr: u64) -> f64 {
    let emu = emu64();
    let mut buf = [0u8; 8];
    emu.maps.read_bytes_buff(&mut buf, addr);
    f64::from_le_bytes(buf)
}

// FPU status word bit positions for condition codes
const C0_BIT: u16 = 0x0100; // bit 8
const C2_BIT: u16 = 0x0400; // bit 10
const C3_BIT: u16 = 0x4000; // bit 14

// Helper to extract FPU status word
// Note: This is a simplified test - actual implementation would need to
// read the FPU status word through FSTSW instruction

// ============================================================================
// FCOM - Compare ST(0) with ST(1)
// ============================================================================

#[test]
fn test_fcom_equal() {
    let mut emu = emu64(); // FLD qword [0x2000]  ; Load 5.0 into ST(0)
                           // FLD qword [0x2008]  ; Load 5.0 into ST(0), previous ST(0) becomes ST(1)
                           // FCOM ST(1)          ; D8 D1 - Compare ST(0) with ST(1)
                           // FSTP qword [0x3000] ; Store result flag test helper
                           // FSTP qword [0x3008] ; Clean stack
                           // HLT
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xD8, 0xD1, // FCOM ST(1)
        // For testing, we'll store both values to verify they're still on stack
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 5.0);
    emu.maps.write_f64(0x2008, 5.0);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, 5.0, "ST(0) should be unchanged");
    assert_eq!(val2, 5.0, "ST(1) should be unchanged");
}

#[test]
fn test_fcom_greater_than() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (5.0)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (10.0)
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 5.0);
    emu.maps.write_f64(0x2008, 10.0);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, 10.0, "ST(0) should be 10.0");
    assert_eq!(val2, 5.0, "ST(1) should be 5.0");
}

#[test]
fn test_fcom_less_than() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (7.0)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (3.0)
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 7.0);
    emu.maps.write_f64(0x2008, 3.0);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, 3.0, "ST(0) should be 3.0");
    assert_eq!(val2, 7.0, "ST(1) should be 7.0");
}

#[test]
fn test_fcom_zero_equal() {
    let mut emu = emu64();
    let code = [
        0xD9, 0xEE, // FLDZ
        0xD9, 0xEE, // FLDZ
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, 0.0);
    assert_eq!(val2, 0.0);
}

#[test]
fn test_fcom_positive_negative_zero() {
    let mut emu = emu64(); // +0.0 should equal -0.0
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (-0.0)
        0xD9, 0xEE, // FLDZ (+0.0)
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, -0.0);

    emu.run(None).unwrap();
}

// ============================================================================
// FCOMP - Compare and Pop Once
// ============================================================================

#[test]
fn test_fcomp_equal() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xD8, 0xD9, // FCOMP ST(1) - compare and pop
        // After FCOMP, only one value should be on stack
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 5.0);
    emu.maps.write_f64(0x2008, 5.0);

    emu.run(None).unwrap();

    let val = emu.maps.read_f64(0x3000).unwrap();
    assert_eq!(
        val, 5.0,
        "After FCOMP, ST(0) should contain the remaining value"
    );
}

#[test]
fn test_fcomp_greater() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (3.0)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (8.0)
        0xD8, 0xD9, // FCOMP ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 3.0);
    emu.maps.write_f64(0x2008, 8.0);

    emu.run(None).unwrap();

    let val = emu.maps.read_f64(0x3000).unwrap();
    assert_eq!(val, 3.0);
}

#[test]
fn test_fcomp_less() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (9.0)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (2.0)
        0xD8, 0xD9, // FCOMP ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 9.0);
    emu.maps.write_f64(0x2008, 2.0);

    emu.run(None).unwrap();

    let val = emu.maps.read_f64(0x3000).unwrap();
    assert_eq!(val, 9.0);
}

#[test]
fn test_fcomp_with_constant() {
    let mut emu = emu64();
    let code = [
        0xD9, 0xE8, // FLD1
        0xD9, 0xE8, // FLD1
        0xD8, 0xD9, // FCOMP ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);

    emu.run(None).unwrap();

    let val = emu.maps.read_f64(0x3000).unwrap();
    assert_eq!(val, 1.0);
}

// ============================================================================
// FCOMPP - Compare and Pop Twice
// ============================================================================

#[test]
fn test_fcompp_equal() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xDE, 0xD9, // FCOMPP - compare and pop twice
        // Stack should now be empty, push a marker value to verify
        0xD9, 0xE8, // FLD1
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 4.0);
    emu.maps.write_f64(0x2008, 4.0);

    emu.run(None).unwrap();

    let marker = emu.maps.read_f64(0x3000).unwrap();
    assert_eq!(
        marker, 1.0,
        "Stack should be empty after FCOMPP, FLD1 should work"
    );
}

#[test]
fn test_fcompp_greater() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (2.0)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (6.0)
        0xDE, 0xD9, // FCOMPP
        0xD9, 0xE8, // FLD1 (marker)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 2.0);
    emu.maps.write_f64(0x2008, 6.0);

    emu.run(None).unwrap();

    let marker = emu.maps.read_f64(0x3000).unwrap();
    assert_eq!(marker, 1.0);
}

#[test]
fn test_fcompp_less() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (8.0)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (3.0)
        0xDE, 0xD9, // FCOMPP
        0xD9, 0xEE, // FLDZ (marker)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 8.0);
    emu.maps.write_f64(0x2008, 3.0);

    emu.run(None).unwrap();

    let marker = emu.maps.read_f64(0x3000).unwrap();
    assert_eq!(marker, 0.0);
}

#[test]
fn test_fcompp_with_constants() {
    let mut emu = emu64();
    let code = [
        0xD9, 0xEE, // FLDZ
        0xD9, 0xE8, // FLD1
        0xDE, 0xD9, // FCOMPP
        0xD9, 0xEB, // FLDPI (marker)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);

    emu.run(None).unwrap();

    let marker = emu.maps.read_f64(0x3000).unwrap();
    assert!((marker - std::f64::consts::PI).abs() < 1e-15);
}

// ============================================================================
// FCOM - Special Values
// ============================================================================

#[test]
fn test_fcom_infinity_greater() {
    let mut emu = emu64(); // +infinity > finite
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (100.0)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (+inf)
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 100.0);
    emu.maps.write_f64(0x2008, f64::INFINITY);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, f64::INFINITY);
    assert_eq!(val2, 100.0);
}

#[test]
fn test_fcom_negative_infinity_less() {
    let mut emu = emu64(); // -infinity < finite
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (0.0)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (-inf)
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 0.0);
    emu.maps.write_f64(0x2008, f64::NEG_INFINITY);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, f64::NEG_INFINITY);
    assert_eq!(val2, 0.0);
}

#[test]
fn test_fcom_infinities_equal() {
    let mut emu = emu64(); // +inf == +inf
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (+inf)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (+inf)
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, f64::INFINITY);
    emu.maps.write_f64(0x2008, f64::INFINITY);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, f64::INFINITY);
    assert_eq!(val2, f64::INFINITY);
}

#[test]
fn test_fcom_infinities_different() {
    let mut emu = emu64(); // +inf > -inf
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (-inf)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (+inf)
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, f64::NEG_INFINITY);
    emu.maps.write_f64(0x2008, f64::INFINITY);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, f64::INFINITY);
    assert_eq!(val2, f64::NEG_INFINITY);
}

// ============================================================================
// FCOM - NaN Comparisons (Unordered)
// ============================================================================

#[test]
fn test_fcom_nan_vs_number() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (5.0)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (NaN)
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 5.0);
    emu.maps.write_f64(0x2008, f64::NAN);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert!(val1.is_nan());
    assert_eq!(val2, 5.0);
}

#[test]
fn test_fcom_number_vs_nan() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (NaN)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (10.0)
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, f64::NAN);
    emu.maps.write_f64(0x2008, 10.0);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, 10.0);
    assert!(val2.is_nan());
}

#[test]
fn test_fcom_nan_vs_nan() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (NaN)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (NaN)
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, f64::NAN);
    emu.maps.write_f64(0x2008, f64::NAN);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert!(val1.is_nan());
    assert!(val2.is_nan());
}

// ============================================================================
// FCOM - Various Numeric Comparisons
// ============================================================================

#[test]
fn test_fcom_very_close_numbers() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 1.0);
    emu.maps.write_f64(0x2008, 1.0 + 1e-15);

    emu.run(None).unwrap();
}

#[test]
fn test_fcom_negative_numbers() {
    let mut emu = emu64(); // -5.0 > -10.0
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (-10.0)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (-5.0)
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, -10.0);
    emu.maps.write_f64(0x2008, -5.0);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, -5.0);
    assert_eq!(val2, -10.0);
    // -5.0 > -10.0, so C3=0, C2=0, C0=0
}

#[test]
fn test_fcom_mixed_signs() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (-3.0)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (3.0)
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, -3.0);
    emu.maps.write_f64(0x2008, 3.0);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, 3.0);
    assert_eq!(val2, -3.0);
}

#[test]
fn test_fcom_tiny_numbers() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 1e-100);
    emu.maps.write_f64(0x2008, 2e-100);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, 2e-100);
    assert_eq!(val2, 1e-100);
}

#[test]
fn test_fcom_huge_numbers() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 1e100);
    emu.maps.write_f64(0x2008, 2e100);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, 2e100);
    assert_eq!(val2, 1e100);
}

// ============================================================================
// FCOM - Sequence of Comparisons
// ============================================================================

#[test]
fn test_fcom_sequence() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (1.0)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (2.0)
        0xD8, 0xD1, // FCOM ST(1) - compare 2.0 vs 1.0
        0xDD, 0x04, 0x25, 0x10, 0x20, 0x00, 0x00, // FLD qword [0x2010] (3.0)
        0xD8, 0xD1, // FCOM ST(1) - compare 3.0 vs 2.0
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xDD, 0x1C, 0x25, 0x10, 0x30, 0x00, 0x00, // FSTP qword [0x3010]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 1.0);
    emu.maps.write_f64(0x2008, 2.0);
    emu.maps.write_f64(0x2010, 3.0);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    let val3 = emu.maps.read_f64(0x3010).unwrap();
    assert_eq!(val1, 3.0);
    assert_eq!(val2, 2.0);
    assert_eq!(val3, 1.0);
}

#[test]
fn test_mixed_compare_operations() {
    let mut emu = emu64();
    let code = [
        0xD9, 0xE8, // FLD1 (1.0)
        0xD9, 0xE8, // FLD1 (1.0)
        0xD8, 0xD1, // FCOM ST(1)
        0xD9, 0xE8, // FLD1 (1.0)
        0xD8, 0xD9, // FCOMP ST(1) - pop once
        0xDE, 0xD9, // FCOMPP - pop twice
        0xD9, 0xEE, // FLDZ (marker - stack should be empty)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);

    emu.run(None).unwrap();

    let marker = emu.maps.read_f64(0x3000).unwrap();
    assert_eq!(marker, 0.0);
}

#[test]
fn test_fcom_with_arithmetic() {
    let mut emu = emu64();
    let code = [
        0xD9, 0xE8, // FLD1
        0xD9, 0xE8, // FLD1
        0xDE, 0xC1, // FADDP (1 + 1 = 2)
        0xD9, 0xE8, // FLD1
        0xD9, 0xE8, // FLD1
        0xDE, 0xC1, // FADDP (1 + 1 = 2)
        0xD8, 0xD1, // FCOM ST(1) - compare 2 vs 2
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, 2.0);
    assert_eq!(val2, 2.0);
}

#[test]
fn test_fcom_fractions() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 0.25);
    emu.maps.write_f64(0x2008, 0.5);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, 0.5);
    assert_eq!(val2, 0.25);
}

#[test]
fn test_fcomp_negative_values() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xD8, 0xD9, // FCOMP ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, -10.0);
    emu.maps.write_f64(0x2008, -5.0);

    emu.run(None).unwrap();

    let val = emu.maps.read_f64(0x3000).unwrap();
    assert_eq!(val, -10.0);
}

#[test]
fn test_fcompp_pi_comparison() {
    let mut emu = emu64();
    let code = [
        0xD9, 0xEB, // FLDPI
        0xD9, 0xEB, // FLDPI
        0xDE, 0xD9, // FCOMPP
        0xD9, 0xE8, // FLD1 (marker)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);

    emu.run(None).unwrap();

    let marker = emu.maps.read_f64(0x3000).unwrap();
    assert_eq!(marker, 1.0);
}

#[test]
fn test_fcom_denormal_numbers() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    let denormal1 = f64::MIN_POSITIVE / 2.0;
    let denormal2 = f64::MIN_POSITIVE / 4.0;
    emu.maps.write_f64(0x2000, denormal2);
    emu.maps.write_f64(0x2008, denormal1);

    emu.run(None).unwrap();

    // denormal1 > denormal2
}

#[test]
fn test_fcom_max_values() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, f64::MAX);
    emu.maps.write_f64(0x2008, f64::MAX);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, f64::MAX);
    assert_eq!(val2, f64::MAX);
}

#[test]
fn test_fcomp_sequential() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000] (1.0)
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008] (2.0)
        0xD8, 0xD9, // FCOMP ST(1)
        0xDD, 0x04, 0x25, 0x10, 0x20, 0x00, 0x00, // FLD qword [0x2010] (3.0)
        0xD8, 0xD9, // FCOMP ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 1.0);
    emu.maps.write_f64(0x2008, 2.0);
    emu.maps.write_f64(0x2010, 3.0);

    emu.run(None).unwrap();
}

#[test]
fn test_fcom_powers_of_ten() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 1e10);
    emu.maps.write_f64(0x2008, 1e20);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, 1e20);
    assert_eq!(val2, 1e10);
}

#[test]
fn test_fcompp_negative_infinity() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xDE, 0xD9, // FCOMPP
        0xD9, 0xEB, // FLDPI (marker)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, f64::NEG_INFINITY);
    emu.maps.write_f64(0x2008, f64::NEG_INFINITY);

    emu.run(None).unwrap();

    let marker = emu.maps.read_f64(0x3000).unwrap();
    assert!((marker - std::f64::consts::PI).abs() < 1e-15);
}

#[test]
fn test_fcom_epsilon() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, 1.0);
    emu.maps.write_f64(0x2008, 1.0 + f64::EPSILON);

    emu.run(None).unwrap();
}

#[test]
fn test_fcom_mixed_sign_small() {
    let mut emu = emu64();
    let code = [
        0xDD, 0x04, 0x25, 0x00, 0x20, 0x00, 0x00, // FLD qword [0x2000]
        0xDD, 0x04, 0x25, 0x08, 0x20, 0x00, 0x00, // FLD qword [0x2008]
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);
    emu.maps.write_f64(0x2000, -0.001);
    emu.maps.write_f64(0x2008, 0.001);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert_eq!(val1, 0.001);
    assert_eq!(val2, -0.001);
}

#[test]
fn test_fcompp_after_arithmetic() {
    let mut emu = emu64();
    let code = [
        0xD9, 0xE8, // FLD1
        0xD9, 0xE8, // FLD1
        0xDE, 0xC1, // FADDP (2)
        0xD9, 0xE8, // FLD1
        0xD9, 0xE8, // FLD1
        0xDE, 0xC9, // FMULP (1)
        0xDE, 0xD9, // FCOMPP (compare 2 vs 1)
        0xD9, 0xEE, // FLDZ (marker)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);

    emu.run(None).unwrap();

    let marker = emu.maps.read_f64(0x3000).unwrap();
    assert_eq!(marker, 0.0);
}
#[test]
fn test_fcom_constants_comparison() {
    let mut emu = emu64();
    let code = [
        0xD9, 0xEB, // FLDPI
        0xD9, 0xEA, // FLDL2E
        0xD8, 0xD1, // FCOM ST(1)
        0xDD, 0x1C, 0x25, 0x00, 0x30, 0x00, 0x00, // FSTP qword [0x3000]
        0xDD, 0x1C, 0x25, 0x08, 0x30, 0x00, 0x00, // FSTP qword [0x3008]
        0xF4, // HLT
    ];

    emu.load_code_bytes(&code);

    emu.run(None).unwrap();

    let val1 = emu.maps.read_f64(0x3000).unwrap();
    let val2 = emu.maps.read_f64(0x3008).unwrap();
    assert!((val1 - std::f64::consts::LOG2_E).abs() < 1e-15);
    assert!((val2 - std::f64::consts::PI).abs() < 1e-15);
}