//! Test sub-word arithmetic normalization.

//! Verifies that W8/W16 arithmetic results are properly sign/zero-extended,

//! and that W32 operations use the correct *w instruction variants.

fn testI8Overflow() -> bool {

    let a: i8 = 120;

    let b: i8 = 10;

    let result: i8 = a + b;

    // 120 + 10 = 130, which wraps to -126 in i8

    if result != -126 {

        return false;

    }

    return true;

}

fn testU8Overflow() -> bool {

    let a: u8 = 250;

    let b: u8 = 10;

    let result: u8 = a + b;

    // 250 + 10 = 260, which wraps to 4 in u8

    if result != 4 {

        return false;

    }

    return true;

}

fn testI8Subtraction() -> bool {

    let a: i8 = -100;

    let b: i8 = 50;

    let result: i8 = a - b;

    // -100 - 50 = -150, which wraps to 106 in i8

    if result != 106 {

        return false;

    }

    return true;

}

fn testU8Subtraction() -> bool {

    let a: u8 = 5;

    let b: u8 = 10;

    let result: u8 = a - b;

    // 5 - 10 = -5, which wraps to 251 in u8

    if result != 251 {

        return false;

    }

    return true;

}

fn testI16Overflow() -> bool {

    let a: i16 = 32000;

    let b: i16 = 1000;

    let result: i16 = a + b;

    // 32000 + 1000 = 33000, which wraps to -32536 in i16

    if result != -32536 {

        return false;

    }

    return true;

}

fn testU16Overflow() -> bool {

    let a: u16 = 65530;

    let b: u16 = 10;

    let result: u16 = a + b;

    // 65530 + 10 = 65540, which wraps to 4 in u16

    if result != 4 {

        return false;

    }

    return true;

}

fn testI8Multiply() -> bool {

    let a: i8 = 15;

    let b: i8 = 10;

    let result: i8 = a * b;

    // 15 * 10 = 150, which wraps to -106 in i8

    if result != -106 {

        return false;

    }

    return true;

}

fn testU8Multiply() -> bool {

    let a: u8 = 20;

    let b: u8 = 15;

    let result: u8 = a * b;

    // 20 * 15 = 300, which wraps to 44 in u8

    if result != 44 {

        return false;

    }

    return true;

}

fn testI8Comparison() -> bool {

    let a: i8 = 127;

    let b: i8 = a + 1;

    // b should be -128 after overflow

    if b >= 0 {

        return false;

    }

    if b != -128 {

        return false;

    }

    return true;

}

fn testU8Comparison() -> bool {

    let a: u8 = 255;

    let b: u8 = a + 1 as u8;

    // b should be 0 after overflow

    if b != 0 {

        return false;

    }

    return true;

}

fn testNarrowingCast() -> bool {

    let x: i32 = 1000;

    let narrow: u8 = x as u8;

    // 1000 = 0x3E8, lower byte = 0xE8 = 232

    if narrow != 232 {

        return false;

    }

    return true;

}

fn testW32ShiftRight() -> bool {

    let max: u32 = 0xFFFFFFFF;

    let shifted: u32 = max >> 16;

    // Should be 0xFFFF = 65535

    if shifted != 65535 {

        return false;

    }

    return true;

}

fn testI8NegOverflow() -> bool {

    let min: i8 = -128;

    let negated: i8 = -min;

    // RV64 should preserve i8 wrap behavior: -(-128) == -128

    if negated != -128 {

        return false;

    }

    return true;

}

fn testU8BitNot() -> bool {

    let x: u8 = 0;

    let inverted: u8 = ~x;

    // 8-bit not of 0 is 0xFF.

    if inverted != 255 {

        return false;

    }

    return true;

}

fn testW32ShiftLargeImmediate() -> bool {

    let x: u32 = 1;

    let shifted: u32 = x << 40;

    // Shift amount should be masked to 5 bits for 32-bit shifts: 40 % 32 = 8.

    if shifted != 256 {

        return false;

    }

    return true;

}

@default fn main() -> i32 {

    assert testI8Overflow();

    assert testU8Overflow();

    assert testI8Subtraction();

    assert testU8Subtraction();

    assert testI16Overflow();

    assert testU16Overflow();

    assert testI8Multiply();

    assert testU8Multiply();

    assert testI8Comparison();

    assert testU8Comparison();

    assert testNarrowingCast();

    assert testW32ShiftRight();

    assert testI8NegOverflow();

    assert testU8BitNot();

    assert testW32ShiftLargeImmediate();

    return 0;

}