//! Tests for RIL formatting and source register iteration.

use std::testing;

use std::lang::sexpr;

use std::lang::il::printer;

use std::lang::alloc;

/// Qualified names preserve empty segments and exact separator placement.

@test unsafe fn testQualifiedNames() throws (testing::TestError) {

    static STORAGE: [u8; 2048] = [0; 2048];

    let mut arena = alloc::new(&mut STORAGE[..]);

    try testing::expectBytesEq(super::formatQualifiedName(&mut arena, &[], ""), "");

    try testing::expectBytesEq(super::formatQualifiedName(&mut arena, &[], "method"), "method");

    let path = ["package", "module", "Type"];

    try testing::expectBytesEq(super::formatQualifiedName(&mut arena, &path[..], "method"), "package::module::Type::method");

    let empty = ["", "Type", ""];

    try testing::expectBytesEq(super::formatQualifiedName(&mut arena, &empty[..], ""), "::Type::::");

    let table = ["vtable", "Widget"];

    try testing::expectBytesEq(super::formatQualifiedName(&mut arena, &table[..], "Printable"), "vtable::Widget::Printable");

}

/// Check one instruction between the function header and closing delimiter.

unsafe fn checkPrintedInstruction(instr: super::Instr, expected: &[u8]) throws (testing::TestError) {

    let mut instructions = [instr];

    let blocks = [super::Block {

        label: "entry", params: &[], instrs: &mut instructions[..],

        locs: &[], preds: &[], loopDepth: 0,

    }, super::Block {

        label: "exit", params: &[], instrs: &mut [],

        locs: &[], preds: &[], loopDepth: 0,

    }];

    let function = super::Fn {

        name: "sample", params: &[], returnType: super::Type::W64,

        isExtern: false, isLeaf: true, blocks: &blocks[..],

    };

    let functions: [*unsafe super::Fn; 1] = [&function];

    let program = super::Program { data: &[], fns: &functions[..] };

    let mut storage: [u8; 512] = [0; 512];

    let bytes: 'output = &mut storage[..] in {

        let mut out = sexpr::Buffer 'output { buf: bytes, pos: 0 };

        printer::printProgram(&mut out, &program);

        let prefix = "fn w64 $sample() {\n  @entry\n    ";

        let suffix = ";\n}\n";

        try testing::expect(out.pos == prefix.len + expected.len + suffix.len);

        try testing::expectBytesEq(&out.buf[..prefix.len], prefix);

        try testing::expectBytesEq(&out.buf[prefix.len..prefix.len + expected.len], expected);

        try testing::expectBytesEq(&out.buf[prefix.len + expected.len..out.pos], suffix);

    }

}

/// Fixed instruction formatting preserves operands, widths, and optional returns.

@test unsafe fn testFixedInstructionPrinting() throws (testing::TestError) {

    let dst = super::Reg { n: 4294967295 };

    let reg = super::Reg { n: 2 };

    let value = super::Val::Imm(-9223372036854775808);

    let source = super::Val::Reg(reg);

    try checkPrintedInstruction(super::Instr::Reserve { dst, size: value, alignment: 8 }, "reserve %4294967295 -9223372036854775808 8");

    try checkPrintedInstruction(super::Instr::Load { typ: super::Type::W8, dst, src: reg, offset: -2147483648 }, "load w8 %4294967295 %2 -2147483648");

    try checkPrintedInstruction(super::Instr::Sload { typ: super::Type::W16, dst, src: reg, offset: 2147483647 }, "sload w16 %4294967295 %2 2147483647");

    try checkPrintedInstruction(super::Instr::Store { typ: super::Type::W32, src: source, dst: reg, offset: 0 }, "store w32 %2 %2 0");

    try checkPrintedInstruction(super::Instr::Blit { dst, src: reg, size: value }, "blit %4294967295 %2 -9223372036854775808");

    try checkPrintedInstruction(super::Instr::Copy { dst, val: super::Val::Undef }, "copy %4294967295 undefined");

    try checkPrintedInstruction(super::Instr::BinOp { op: super::BinOp::Add, typ: super::Type::W64, dst, a: source, b: value }, "add w64 %4294967295 %2 -9223372036854775808");

    try checkPrintedInstruction(super::Instr::UnOp { op: super::UnOp::Not, typ: super::Type::W64, dst, a: source }, "not w64 %4294967295 %2");

    try checkPrintedInstruction(super::Instr::Zext { typ: super::Type::W8, dst, val: source }, "zext w8 %4294967295 %2");

    try checkPrintedInstruction(super::Instr::Sext { typ: super::Type::W32, dst, val: value }, "sext w32 %4294967295 -9223372036854775808");

    try checkPrintedInstruction(super::Instr::Ret { val: nil }, "ret");

    try checkPrintedInstruction(super::Instr::Ret { val: value }, "ret -9223372036854775808");

    try checkPrintedInstruction(super::Instr::Unreachable, "unreachable");

    try checkPrintedInstruction(super::Instr::Ecall { dst, num: value, a0: source, a1: value, a2: source, a3: value }, "ecall %4294967295 -9223372036854775808 %2 -9223372036854775808 %2 -9223372036854775808");

    try checkPrintedInstruction(super::Instr::DeviceRead { typ: super::Type::W8, dst, handle: source, offset: value }, "device-read w8 %4294967295 %2 -9223372036854775808");

    try checkPrintedInstruction(super::Instr::DeviceWrite { typ: super::Type::W64, handle: source, offset: value, value: source }, "device-write w64 %2 -9223372036854775808 %2");

    try checkPrintedInstruction(super::Instr::Ebreak, "ebreak");

    try checkPrintedInstruction(super::Instr::MemoryFence, "memory-fence");

}

/// Call printing preserves destinations, callee forms, and argument order.

@test unsafe fn testCallPrinting() throws (testing::TestError) {

    let dst = super::Reg { n: 7 };

    let direct = super::Val::FnAddr("callee");

    let indirect = super::Val::Reg(super::Reg { n: 2 });

    let args = [super::Val::Imm(-1), super::Val::Reg(dst), super::Val::FnAddr("pkg::callback")];

    try checkPrintedInstruction(super::Instr::Call {

        retTy: super::Type::W8, dst: nil, func: direct, args: &[],

    }, "call w8 $callee()");

    try checkPrintedInstruction(super::Instr::Call {

        retTy: super::Type::W16, dst, func: direct, args: &[],

    }, "call w16 %7 $callee()");

    try checkPrintedInstruction(super::Instr::Call {

        retTy: super::Type::W32, dst: nil, func: indirect, args: &args[..1],

    }, "call w32 %2(-1)");

    try checkPrintedInstruction(super::Instr::Call {

        retTy: super::Type::W64, dst, func: indirect, args: &args[..],

    }, "call w64 %7 %2(-1, %7, $\"pkg::callback\")");

    try checkPrintedInstruction(super::Instr::Call {

        retTy: super::Type::W64, dst, func: super::Val::FnAddr("pkg::callee"), args: &args[..],

    }, "call w64 %7 $\"pkg::callee\"(-1, %7, $\"pkg::callback\")");

}

/// Control-flow printing preserves target labels and empty or populated arguments.

@test unsafe fn testControlFlowPrinting() throws (testing::TestError) {

    let value = super::Val::Reg(super::Reg { n: 3 });

    let other = super::Val::Imm(-7);

    let mut args = [value, other];

    try checkPrintedInstruction(super::Instr::Jmp { target: 0, args: &mut [] }, "jmp @entry");

    try checkPrintedInstruction(super::Instr::Jmp { target: 0, args: &mut args[..] }, "jmp @entry(%3, -7)");

    try checkPrintedInstruction(super::Instr::Br {

        op: super::CmpOp::Eq, typ: super::Type::W8, a: value, b: other,

        thenTarget: 0, thenArgs: &mut [], elseTarget: 1, elseArgs: &mut [],

    }, "br.eq w8 %3 -7 @entry @exit");

    try checkPrintedInstruction(super::Instr::Br {

        op: super::CmpOp::Ne, typ: super::Type::W16, a: value, b: other,

        thenTarget: 1, thenArgs: &mut args[..], elseTarget: 0, elseArgs: &mut [],

    }, "br.ne w16 %3 -7 @exit(%3, -7) @entry");

    try checkPrintedInstruction(super::Instr::Br {

        op: super::CmpOp::Slt, typ: super::Type::W32, a: value, b: other,

        thenTarget: 0, thenArgs: &mut [], elseTarget: 1, elseArgs: &mut args[..],

    }, "br.slt w32 %3 -7 @entry @exit(%3, -7)");

    try checkPrintedInstruction(super::Instr::Br {

        op: super::CmpOp::Ult, typ: super::Type::W64, a: value, b: other,

        thenTarget: 0, thenArgs: &mut args[..], elseTarget: 0, elseArgs: &mut args[..],

    }, "br.ult w64 %3 -7 @entry(%3, -7) @entry(%3, -7)");

    let mut cases = [

        super::SwitchCase { value: -9223372036854775808, target: 0, args: &mut [] },

        super::SwitchCase { value: 9223372036854775807, target: 0, args: &mut args[..] },

    ];

    try checkPrintedInstruction(super::Instr::Switch {

        val: value, defaultTarget: 0, defaultArgs: &mut [], cases: &mut [],

    }, "switch %3 @entry");

    try checkPrintedInstruction(super::Instr::Switch {

        val: value, defaultTarget: 0, defaultArgs: &mut args[..], cases: &mut cases[..],

    }, "switch %3 (-9223372036854775808 @entry) (9223372036854775807 @entry(%3, -7)) @entry(%3, -7)");

}

/// Buffered output truncates at capacity and preserves adjacent storage.

@test fn testSafePrintBuffer() throws (testing::TestError) {

    let mut storage: [u8; 7] = [42; 7];

    let bytes: 'output = &mut storage[1..6] in {

        let mut out = sexpr::Buffer 'output { buf: bytes, pos: 0 };

        sexpr::write(&mut out, "ab");

        sexpr::write(&mut out, "cdef");

        sexpr::write(&mut out, "ignored");

        try testing::expect(out.pos == 5);

        try testing::expectBytesEq(out.buf, "abcde");

    }

    try testing::expect(storage[0] == 42);

    try testing::expect(storage[6] == 42);

    let bytes: 'empty = &mut storage[0..0] in {

        let mut out = sexpr::Buffer 'empty { buf: bytes, pos: 0 };

        sexpr::write(&mut out, "ignored");

        try testing::expect(out.pos == 0);

    }

}

/// S-expression formatting uses checked output storage.

@test fn testSafeExpressionPrinter() throws (testing::TestError) {

    let mut storage: [u8; 64] = [0; 64];

    let bytes: 'output = &mut storage[..] in {

        let mut out = sexpr::Buffer 'output { buf: bytes, pos: 0 };

        sexpr::printTo(sexpr::Expr::Str("a\n\t\\"), 0, &mut out);

        sexpr::printTo(sexpr::Expr::Char('\n'), 0, &mut out);

        try testing::expectBytesEq(&out.buf[..out.pos], "\"a\\n\\t\\\\\"'\\n'");

    }

}

/// Fixed register cursors can be initialized in safe code.

@test fn testSafeRegisterCursor() throws (testing::TestError) {

    let instr = super::Instr::Ecall {

        dst: super::Reg { n: 0 },

        num: super::Val::Reg(super::Reg { n: 1 }),

        a0: super::Val::Reg(super::Reg { n: 2 }),

        a1: super::Val::Reg(super::Reg { n: 3 }),

        a2: super::Val::Reg(super::Reg { n: 4 }),

        a3: super::Val::Reg(super::Reg { n: 5 }),

    };

    let cursor = super::registers(&instr);

    try testing::expect(cursor.count == 5);

    for reg, i in &cursor.fixed[..] {

        try testing::expect(reg.n == i + 1);

    }

    let emptyInstr = super::Instr::Unreachable;

    let empty = super::registers(&emptyInstr);

    try testing::expect(empty.count == 0);

    for reg in &empty.fixed[..] {

        try testing::expect(reg.n == 0);

    }

}

/// Require exact source-register order and stable exhaustion.

unsafe fn check(instr: super::Instr, expected: &[u32]) throws (testing::TestError) {

    let mut cursor = super::registers(&instr);

    for value in expected {

        let reg = super::nextReg(&mut cursor, &instr) else panic;

        try testing::expect(reg.n == value);

    }

    try testing::expect(super::nextReg(&mut cursor, &instr) == nil);

    try testing::expect(super::nextReg(&mut cursor, &instr) == nil);

}

@test unsafe fn testRegisterIteration() throws (testing::TestError) {

    let dst = super::Reg { n: 99 };

    let r1 = super::Reg { n: 1 };

    let r2 = super::Reg { n: 2 };

    let a = super::Val::Reg(r1);

    let b = super::Val::Reg(r2);

    let imm = super::Val::Imm(7);

    try check(super::Instr::Reserve { dst, size: a, alignment: 8 }, &[1]);

    try check(super::Instr::Reserve { dst, size: imm, alignment: 8 }, &[]);

    try check(super::Instr::Load { typ: super::Type::W64, dst, src: r1, offset: 0 }, &[1]);

    try check(super::Instr::Sload { typ: super::Type::W32, dst, src: r2, offset: 0 }, &[2]);

    try check(super::Instr::Store { typ: super::Type::W64, src: a, dst: r2, offset: 0 }, &[1, 2]);

    try check(super::Instr::Store { typ: super::Type::W64, src: imm, dst: r2, offset: 0 }, &[2]);

    try check(super::Instr::Blit { dst: r1, src: r2, size: a }, &[1, 2, 1]);

    try check(super::Instr::Blit { dst: r1, src: r2, size: imm }, &[1, 2]);

    try check(super::Instr::Copy { dst, val: a }, &[1]);

    try check(super::Instr::Copy { dst, val: imm }, &[]);

    try check(super::Instr::Copy { dst, val: super::Val::DataSym("data") }, &[]);

    try check(super::Instr::Copy { dst, val: super::Val::Undef }, &[]);

    try check(super::Instr::BinOp { op: super::BinOp::Add, typ: super::Type::W64, dst, a: imm, b }, &[2]);

    try check(super::Instr::BinOp { op: super::BinOp::Add, typ: super::Type::W64, dst, a, b: a }, &[1, 1]);

    try check(super::Instr::UnOp { op: super::UnOp::Neg, typ: super::Type::W64, dst, a }, &[1]);

    try check(super::Instr::Zext { typ: super::Type::W8, dst, val: a }, &[1]);

    try check(super::Instr::Sext { typ: super::Type::W8, dst, val: b }, &[2]);

    let mut args = [imm, a, b, a];

    try check(super::Instr::Call { retTy: super::Type::W64, dst, func: b, args: &args[..] }, &[2, 1, 2, 1]);

    try check(super::Instr::Call { retTy: super::Type::W64, dst: nil, func: super::Val::FnAddr("callee"), args: &[] }, &[]);

    try check(super::Instr::Ret { val: a }, &[1]);

    try check(super::Instr::Ret { val: nil }, &[]);

    try check(super::Instr::Jmp { target: 0, args: &mut args[..] }, &[1, 2, 1]);

    let mut other = [b, imm];

    try check(super::Instr::Br { op: super::CmpOp::Eq, typ: super::Type::W64, a, b,

        thenTarget: 0, thenArgs: &mut args[..], elseTarget: 1, elseArgs: &mut other[..] }, &[1, 2, 1, 2, 1, 2]);

    try check(super::Instr::Br { op: super::CmpOp::Eq, typ: super::Type::W64, a: imm, b: imm,

        thenTarget: 0, thenArgs: &mut [], elseTarget: 1, elseArgs: &mut other[..] }, &[2]);

    try check(super::Instr::Br { op: super::CmpOp::Eq, typ: super::Type::W64, a, b,

        thenTarget: 0, thenArgs: &mut other[..], elseTarget: 1, elseArgs: &mut [] }, &[1, 2, 2]);

    let mut cases = [

        super::SwitchCase { value: 0, target: 0, args: &mut [] },

        super::SwitchCase { value: 1, target: 1, args: &mut args[..] },

        super::SwitchCase { value: 2, target: 2, args: &mut [] },

        super::SwitchCase { value: 3, target: 3, args: &mut other[..] },

    ];

    try check(super::Instr::Switch { val: b, defaultTarget: 0, defaultArgs: &mut [], cases: &mut cases[..] }, &[2, 1, 2, 1, 2]);

    try check(super::Instr::Switch { val: a, defaultTarget: 0, defaultArgs: &mut other[..], cases: &mut cases[..] }, &[1, 2, 1, 2, 1, 2]);

    try check(super::Instr::Switch { val: imm, defaultTarget: 0, defaultArgs: &mut args[..], cases: &mut [] }, &[1, 2, 1]);

    try check(super::Instr::Switch { val: imm, defaultTarget: 0, defaultArgs: &mut [], cases: &mut [] }, &[]);

    try check(super::Instr::Ecall { dst, num: a, a0: imm, a1: b, a2: a, a3: imm }, &[1, 2, 1]);

    try check(super::Instr::Ecall { dst, num: a, a0: b, a1: a, a2: b, a3: a }, &[1, 2, 1, 2, 1]);

    try check(super::Instr::Unreachable, &[]);

    try check(super::Instr::Ebreak, &[]);

    try check(super::Instr::MemoryFence, &[]);

}