//! Binary RIL encoding fixtures.

use std::testing;

use std::lang::il;

use std::lang::il::binary::writer;

use std::lang::il::binary;

use std::lang::il::binary::reader;

use std::lang::alloc;

/// Decode arena backing storage. Tests reset it before each use.

static MEMORY: [u8; 512] = [0; 512];

/// Marker for bytes beyond a writer's borrowed output extent.

constant OUTPUT_CANARY: u8 = 0xa5;

/// Fixed data items decode with no arena storage at every count boundary.

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

    for item in [

        il::DataItem::Val { typ: il::Type::W8, val: 0x12 },

        il::DataItem::Val { typ: il::Type::W16, val: 0x1234 },

        il::DataItem::Val { typ: il::Type::W32, val: 0x12345678 },

        il::DataItem::Val { typ: il::Type::W64, val: -1 },

        il::DataItem::Sym("data"), il::DataItem::Fn("fn"), il::DataItem::Undef,

    ] {

        for count in [0 as u32, 1, 0xffffffff] {

            try checkFixedDataItem(il::DataValue { item, count });

        }

    }

}

/// Check a fixed initializer and every truncated prefix without allocation.

unsafe fn checkFixedDataItem(item: il::DataValue) throws (testing::TestError) {

    let mut buffer: [u8; 32] = [0; 32];

    let symbols: [*[u8]; 2] = ["data", "fn"];

    let mut length: u32 = 0;

    let output: 'output = &mut buffer[..], names = &symbols[..] in {

        let mut out = writer::new(output, names);

        try writer::dataValue(&mut out, item) catch { throw testing::TestError::Failed; };

        set length = out.offset;

    }

    for end in 0..length + 1 {

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

        let source: 'input = &buffer[..end], names = &symbols[..] in {

            let mut input = reader::new(source, &mut arena, names);

            let mut failed = false;

            let decoded = try reader::dataValue(&mut input) catch err {

                assert err == binary::Error::Truncated;

                set failed = true;

                il::DataValue { item: il::DataItem::Undef, count: 0 }

            };

            assert failed == (end < length);

            assert input.offset <= end;

            if not failed {

                assert decoded == item;

                assert input.offset == length;

            }

        }

        assert arena.offset == 0;

    }

}

/// Scalar decoding uses only checked input bytes and numeric cursor bounds.

fn checkScalarReader 'input (input: &mut reader::Reader 'input) throws (testing::TestError) {

    set input.registers = 2;

    set input.blocks = 3;

    let reg = try reader::reg(input) catch { throw testing::TestError::Failed; };

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

    let target = try reader::target(input) catch { throw testing::TestError::Failed; };

    try testing::expect(target == 2);

    let mut truncated = false;

    try reader::integer(input, 1) catch err {

        try testing::expect(err == binary::Error::Truncated);

        set truncated = true;

    };

    try testing::expect(truncated);

    set input.offset = 0;

    let flag = try reader::flag(input) catch { throw testing::TestError::Failed; };

    try testing::expect(flag);

    set input.offset = 0;

    let typ = try reader::typ(input) catch { throw testing::TestError::Failed; };

    try testing::expect(typ == il::Type::W8);

    set input.offset = 0;

    let count = try reader::count(input, 4) catch { throw testing::TestError::Failed; };

    try testing::expect(count == 1);

    set input.offset = 0;

    let wide = try reader::integer(input, 8) catch { throw testing::TestError::Failed; };

    try testing::expect(wide == 0x0000000200000001);

}

/// A regional input buffer supports safe scalar decoding.

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

    let memory = &mut MEMORY[..];

    let mut arena = alloc::new(memory);

    let bytes: [u8; 8] = [1, 0, 0, 0, 2, 0, 0, 0];

    let namesTable: [*[u8]; 0] = [];

    let source: 'input = &bytes[..], names = &namesTable[..] in {

        let mut input = reader::new(source, &mut arena, names);

        try checkScalarReader(&mut input);

    }

}

/// Read valid symbol values and reject invalid or truncated wire indices.

fn checkSymbolReader 'input (input: &mut reader::Reader 'input) throws (testing::TestError) {

    let name = try reader::symbol(input) catch { throw testing::TestError::Failed; };

    try testing::expectBytesEq(name, "data");

    let data = try reader::val(input) catch { throw testing::TestError::Failed; };

    let case il::Val::DataSym(dataName) = data else throw testing::TestError::Failed;

    try testing::expectBytesEq(dataName, "data");

    let function = try reader::val(input) catch { throw testing::TestError::Failed; };

    let case il::Val::FnAddr(functionName) = function else throw testing::TestError::Failed;

    try testing::expectBytesEq(functionName, "fn");

    let mut invalid = false;

    try reader::symbol(input) catch err {

        assert err == binary::Error::Symbol;

        set invalid = true;

    };

    assert invalid;

    let mut truncated = false;

    try reader::val(input) catch err {

        assert err == binary::Error::Truncated;

        set truncated = true;

    };

    assert truncated;

}

/// Symbol and value decoding use checked table storage from a safe function.

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

    let memory = &mut MEMORY[..];

    let mut arena = alloc::new(memory);

    let bytes: [u8; 18] = [0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 1, 0, 0, 0, 2, 0, 0, 0];

    let namesTable: [*[u8]; 2] = ["data", "fn"];

    let source: 'input = &bytes[..], names = &namesTable[..] in {

        let mut input = reader::new(source, &mut arena, names);

        try checkSymbolReader(&mut input);

    }

}

/// Check little-endian encoding for every integer width.

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

    let mut buffer: [u8; 15] = [0; 15];

    let namesTable: [*[u8]; 0] = [];

    let storage: 'buffer = &mut buffer[..], names = &namesTable[..] in {

        let mut out = writer::new(storage, names);

        try writer::integer(&mut out, 0x12, 1) catch {

            throw testing::TestError::Failed;

        };

        try writer::integer(&mut out, 0x3456, 2) catch {

            throw testing::TestError::Failed;

        };

        try writer::integer(&mut out, 0x789abcde, 4) catch {

            throw testing::TestError::Failed;

        };

        try writer::integer(&mut out, 0x0123456789abcdef, 8) catch {

            throw testing::TestError::Failed;

        };

        try testing::expectBytesEq(&out.bytes[..], &[0x12, 0x56, 0x34, 0xde, 0xbc, 0x9a, 0x78, 0xef, 0xcd,

            0xab, 0x89, 0x67, 0x45, 0x23, 0x01]);

    }

}

/// Compare one instruction with its fixed wire representation.

unsafe fn instruction(item: il::Instr, expected: &[u8]) throws (testing::TestError) {

    let mut buffer: [u8; 256] = [0; 256];

    let namesTable: [*[u8]; 2] = ["data", "fn"];

    let storage: 'buffer = &mut buffer[..], names = &namesTable[..] in {

        let mut out = writer::new(storage, names);

        try writer::instr(&mut out, item) catch {

            throw testing::TestError::Failed;

        };

        try testing::expectBytesEq(&out.bytes[..out.offset], expected);

        for capacity in 0..(expected.len + 1) {

            for i in 0..out.bytes.len {

                set out.bytes[i] = OUTPUT_CANARY;

            }

            let shortStorage: 'short = &mut out.bytes[..capacity], shortNames = &out.symbols[..] in {

                let mut short = writer::new(shortStorage, shortNames);

                let mut failed = false;

                try writer::instr(&mut short, item) catch err {

                    try testing::expect(err == binary::Error::Capacity);

                    set failed = true;

                };

                assert failed == (capacity < expected.len);

                try testing::expect(short.offset <= capacity);

                try testing::expectBytesEq(&short.bytes[..short.offset], &expected[..short.offset]);

            }

            for i in capacity..out.bytes.len {

                assert out.bytes[i] == OUTPUT_CANARY;

            }

        }

        // Inline operands use only the input bytes and symbol table.

        let mut arenaSize: u32 = 0;

        match item {

            case il::Instr::Call { .. }, il::Instr::Jmp { .. },

                 il::Instr::Br { .. }, il::Instr::Switch { .. } => set arenaSize = 512,

            else => {}

        }

        let memory = &mut MEMORY[..arenaSize];

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

        let source: 'input = &expected[..], inputNames = &namesTable[..] in {

            let mut input = reader::new(source, &mut arena, inputNames);

            set input.registers = 16;

            set input.blocks = 4;

            let decoded = try reader::instr(&mut input) catch {

                throw testing::TestError::Failed;

            };

            try testing::expect(input.offset == expected.len);

            set out.offset = 0;

            try writer::instr(&mut out, decoded) catch {

                throw testing::TestError::Failed;

            };

            try testing::expectBytesEq(&out.bytes[..out.offset], expected);

            for length in 0..expected.len {

                alloc::reset(&mut arena);

                set input = reader::new(&source[..length], &mut arena, inputNames);

                set input.registers = 16;

                set input.blocks = 4;

                let mut failed = false;

                try reader::instr(&mut input) catch err {

                    try testing::expect(err == binary::Error::Truncated);

                    set failed = true;

                };

                try testing::expect(failed);

            }

        }

    }

}

/// Malformed inline operands retain bounded cursors and empty arena storage.

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

    let packets: [*[u8]; 6] = [

        &[255],

        &[6, 255],

        &[1, 3],

        &[5, 16, 0, 0, 0, 4],

        &[11, 2],

        &[5, 0, 0, 0, 0, 2, 0, 0, 0, 0],

    ];

    let namesTable: [*[u8]; 0] = [];

    for packet, index in packets {

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

        let source: 'input = &packet[..], names = &namesTable[..] in {

            let mut input = reader::new(source, &mut arena, names);

            set input.registers = 16;

            let mut failed = false;

            try reader::instr(&mut input) catch err {

                let expected = binary::Error::Symbol if index == 5 else binary::Error::Invalid;

                assert err == expected;

                set failed = true;

            };

            assert failed;

            assert input.offset <= source.len;

            assert arena.offset == 0;

        }

    }

}

/// Check all instruction tags and their field order.

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

    let mut args: [il::Val; 1] = [il::Val::Undef];

    let mut cases: [il::SwitchCase; 1] = [il::SwitchCase {

        value: -1, target: 2, args: &mut args[..],

    }];

    try instruction(il::Instr::Reserve {

        dst: il::Reg { n: 1 }, size: il::Val::Undef, alignment: 16,

    }, &[0, 1, 0, 0, 0, 4, 16, 0, 0, 0]);

    try instruction(il::Instr::Load {

        typ: il::Type::W8, dst: il::Reg { n: 1 }, src: il::Reg { n: 2 }, offset: -1,

    }, &[1, 1, 1, 0, 0, 0, 2, 0, 0, 0, 255, 255, 255, 255]);

    try instruction(il::Instr::Sload {

        typ: il::Type::W16, dst: il::Reg { n: 1 }, src: il::Reg { n: 2 }, offset: 3,

    }, &[2, 2, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0]);

    try instruction(il::Instr::Store {

        typ: il::Type::W32, src: il::Val::Undef, dst: il::Reg { n: 2 }, offset: 3,

    }, &[3, 4, 4, 2, 0, 0, 0, 3, 0, 0, 0]);

    try instruction(il::Instr::Blit {

        dst: il::Reg { n: 1 }, src: il::Reg { n: 2 }, size: il::Val::Undef,

    }, &[4, 1, 0, 0, 0, 2, 0, 0, 0, 4]);

    try instruction(il::Instr::Copy {

        dst: il::Reg { n: 1 }, val: il::Val::Undef,

    }, &[5, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::BinOp {

        op: il::BinOp::Add, typ: il::Type::W64, dst: il::Reg { n: 1 }, a: il::Val::Undef,

        b: il::Val::Undef,

    }, &[6, 0, 8, 1, 0, 0, 0, 4, 4]);

    try instruction(il::Instr::UnOp {

        op: il::UnOp::Neg, typ: il::Type::W64, dst: il::Reg { n: 1 }, a: il::Val::Undef,

    }, &[7, 0, 8, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::Zext {

        typ: il::Type::W8, dst: il::Reg { n: 1 }, val: il::Val::Undef,

    }, &[8, 1, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::Sext {

        typ: il::Type::W16, dst: il::Reg { n: 1 }, val: il::Val::Undef,

    }, &[9, 2, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::Call {

        retTy: il::Type::W64, dst: nil, func: il::Val::FnAddr("fn"), args: &[],

    }, &[10, 8, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0]);

    try instruction(il::Instr::Call {

        retTy: il::Type::W64, dst: il::Reg { n: 2 }, func: il::Val::FnAddr("fn"), args: &args[..],

    }, &[10, 8, 1, 2, 0, 0, 0, 3, 1, 0, 0, 0, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::Ret {

        val: nil,

    }, &[11, 0]);

    try instruction(il::Instr::Ret {

        val: il::Val::Undef,

    }, &[11, 1, 4]);

    try instruction(il::Instr::Jmp {

        target: 2, args: &mut args[..],

    }, &[12, 2, 0, 0, 0, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::Br {

        op: il::CmpOp::Eq, typ: il::Type::W32, a: il::Val::Undef, b: il::Val::Undef, thenTarget: 1,

        thenArgs: &mut args[..], elseTarget: 2, elseArgs: &mut args[..],

    }, &[13, 0, 4, 4, 4, 1, 0, 0, 0, 1, 0, 0, 0, 4, 2, 0, 0, 0, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::Switch {

        val: il::Val::Undef, defaultTarget: 1, defaultArgs: &mut args[..], cases: &mut cases[..],

    }, &[

        14, 4, 1, 0, 0, 0, 1, 0, 0, 0, 4, 1,

        0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 2,

        0, 0, 0, 1, 0, 0, 0, 4,

    ]);

    try instruction(il::Instr::Switch {

        val: il::Val::Undef, defaultTarget: 1, defaultArgs: &mut [], cases: &mut [],

    }, &[14, 4, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);

    let mut mixedCases = [

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

        il::SwitchCase { value: 9223372036854775807, target: 2, args: &mut args[..] },

    ];

    try instruction(il::Instr::Switch {

        val: il::Val::Undef, defaultTarget: 1, defaultArgs: &mut [], cases: &mut mixedCases[..],

    }, &[

        14, 4, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,

        0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0,

        255, 255, 255, 255, 255, 255, 255, 127, 2, 0, 0, 0, 1, 0, 0, 0, 4,

    ]);

    try instruction(il::Instr::Unreachable, &[15]);

    try instruction(il::Instr::Ecall {

        dst: il::Reg { n: 1 }, num: il::Val::Undef, a0: il::Val::Undef, a1: il::Val::Undef,

        a2: il::Val::Undef, a3: il::Val::Undef,

    }, &[16, 1, 0, 0, 0, 4, 4, 4, 4, 4]);

    try instruction(il::Instr::Ebreak, &[17]);

    try instruction(il::Instr::MemoryFence, &[18]);

    for typ in [il::Type::W8, il::Type::W16, il::Type::W32, il::Type::W64] {

        let mut read: [u8; 8] = [19, 0, 1, 0, 0, 0, 4, 4];

        let mut write: [u8; 5] = [20, 0, 4, 4, 4];

        set read[1] = il::typeSize(typ) as u8;

        set write[1] = il::typeSize(typ) as u8;

        try instruction(il::Instr::DeviceRead {

            typ, dst: il::Reg { n: 1 }, handle: il::Val::Undef, offset: il::Val::Undef,

        }, &read[..]);

        try instruction(il::Instr::DeviceWrite {

            typ, handle: il::Val::Undef, offset: il::Val::Undef, value: il::Val::Undef,

        }, &write[..]);

    }

}

/// Switch decoding stops at an invalid target or argument in either case.

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

    let namesTable: [*[u8]; 0] = [];

    let mut encoded: [u8; 48] = [0; 48];

    set encoded[0] = binary::INSTR_SWITCH;

    set encoded[1] = 4;

    set encoded[10] = 2;

    set encoded[26] = 1;

    set encoded[30] = 4;

    set encoded[43] = 1;

    set encoded[47] = 4;

    for offset in [22, 39, 30, 47] {

        let original = encoded[offset];

        set encoded[offset] = 255;

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

        let source: 'input = &encoded[..], names = &namesTable[..] in {

            let mut input = reader::new(source, &mut arena, names);

            set input.blocks = 1;

            let mut failed = false;

            try reader::instr(&mut input) catch err {

                assert err == binary::Error::Invalid;

                set failed = true;

            };

            assert failed;

            assert input.offset == offset + (4 if offset == 22 or offset == 39 else 1);

        }

        set encoded[offset] = original;

    }

}

/// Byte decoding retains exact allocation and cursor state on storage failure.

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

    let encoded: [u8; 11] = [0, 0, 0, 0, 3, 0, 0, 0, 65, 0, 255];

    let namesTable: [*[u8]; 0] = [];

    for capacity in 0..4 {

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

        let source: 'input = &encoded[..], names = &namesTable[..] in {

            let mut input = reader::new(source, &mut arena, names);

            let empty = try! reader::bytes(&mut input);

            assert empty.len == 0;

            assert input.offset == 4;

            let mut failed = false;

            let result = try reader::bytes(&mut input) catch err {

                assert err == binary::Error::Storage;

                set failed = true;

                &[] as *[u8]

            };

            assert failed == (capacity < 3);

            assert input.offset == (8 if failed else 11);

            if not failed { try testing::expectBytesEq(result, &[65, 0, 255]); }

        }

        assert arena.offset == (3 if capacity == 3 else 0);

    }

}

/// Exact operand tables use one allocation and publish only complete prefixes.

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

    let namesTable: [*[u8]; 0] = [];

    let alignment = @alignOf(il::Val);

    let remainder = ((&MEMORY[0]) as u64) & (alignment as u64 - 1);

    let padding = ((alignment as u64 - remainder) & (alignment as u64 - 1)) as u32;

    for count in 0..4 {

        let required = 0 if count == 0 else padding + count * @sizeOf(il::Val);

        let mut encoded: [u8; 7] = [0, 0, 0, 0, 4, 4, 4];

        set encoded[0] = count as u8;

        for capacity in 0..required + 1 {

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

            let source: 'input = &encoded[..4 + count], names = &namesTable[..] in {

                let mut input = reader::new(source, &mut arena, names);

                let mut failed = false;

                let result = try reader::values(&mut input) catch error {

                    assert error == binary::Error::Storage;

                    set failed = true;

                    &mut [] as *unsafe mut [il::Val]

                };

                assert failed == (capacity < required);

                assert input.offset == (4 if failed else 4 + count);

                if not failed {

                    assert result.len == count;

                    for value in result { assert value == il::Val::Undef; }

                }

            }

            assert arena.offset == (0 if capacity < required else required);

        }

    }

}

/// Invalid values stop counted decoding at the failing tag or register index.

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

    let namesTable: [*[u8]; 0] = [];

    for position in 0..2 {

        for invalidTag in [false, true] {

            let mut encoded: [u8; 14] = [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];

            if invalidTag {

                set encoded[4 + position * 5] = 255;

            } else {

                set encoded[5 + position * 5] = 1;

            }

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

            let source: 'input = &encoded[..], names = &namesTable[..] in {

                let mut input = reader::new(source, &mut arena, names);

                set input.registers = 1;

                let mut failed = false;

                try reader::values(&mut input) catch err {

                    assert err == binary::Error::Invalid;

                    set failed = true;

                };

                assert failed;

                assert input.offset == position * 5 + (5 if invalidTag else 9);

            }

        }

    }

}

/// Check every value tag and empty and nonempty sequences.

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

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

    let namesTable: [*[u8]; 2] = ["data", "fn"];

    let storage: 'buffer = &mut buffer[..], names = &namesTable[..] in {

        let mut out = writer::new(storage, names);

        try writer::values(&mut out, &[]) catch {

            throw testing::TestError::Failed;

        };

        try writer::values(&mut out, &[

            il::Val::Reg(il::Reg { n: 0x12345678 }),

            il::Val::Imm(-2), il::Val::DataSym("data"),

            il::Val::FnAddr("fn"), il::Val::Undef,

        ]) catch {

            throw testing::TestError::Failed;

        };

        try testing::expectBytesEq(&out.bytes[..out.offset], &[

            0, 0, 0, 0, 5, 0, 0, 0,

            0, 0x78, 0x56, 0x34, 0x12,

            1, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

            2, 0, 0, 0, 0, 3, 1, 0, 0, 0, 4,

        ]);

        let memory = &mut MEMORY[..256];

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

        let mut input = reader::new(&out.bytes[..out.offset], &mut arena, &out.symbols[..]);

        set input.registers = 0x12345679;

        let empty = try reader::values(&mut input) catch {

            throw testing::TestError::Failed;

        };

        let decoded = try reader::values(&mut input) catch {

            throw testing::TestError::Failed;

        };

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

        try testing::expect(decoded.len == 5);

        try testing::expect(input.offset == out.offset);

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

        let copyNamesTable: [*[u8]; 2] = ["data", "fn"];

        let copyStorage: 'copy = &mut repeated[..], copyNames = &copyNamesTable[..] in {

            let mut copy = writer::new(copyStorage, copyNames);

            try writer::values(&mut copy, empty) catch {

                throw testing::TestError::Failed;

            };

            try writer::values(&mut copy, decoded) catch {

                throw testing::TestError::Failed;

            };

            try testing::expectBytesEq(&out.bytes[..out.offset], &copy.bytes[..copy.offset]);

        }

    }

}

/// Check initializer bytes and repetition counts.

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

    let mut buffer: [u8; 128] = [0; 128];

    let namesTable: [*[u8]; 2] = ["data", "fn"];

    let storage: 'buffer = &mut buffer[..], names = &namesTable[..] in {

        let mut out = writer::new(storage, names);

        try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Val { typ: il::Type::W8,

            val: -1 }, count: 0 }) catch {

                throw testing::TestError::Failed;

            };

        try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Val { typ: il::Type::W16,

            val: -2 }, count: 1 }) catch {

                throw testing::TestError::Failed;

            };

        try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Val { typ: il::Type::W32,

            val: -3 }, count: 2 }) catch {

                throw testing::TestError::Failed;

            };

        try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Val { typ: il::Type::W64,

            val: -4 }, count: 3 }) catch {

                throw testing::TestError::Failed;

            };

        try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Sym("data"), count: 4 })

            catch {

                throw testing::TestError::Failed;

            };

        try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Fn("fn"), count: 5 }) catch

            {

                throw testing::TestError::Failed;

            };

        try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Str("ab"), count: 6 }) catch

            {

                throw testing::TestError::Failed;

            };

        try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Str(""), count: 7 }) catch {

            throw testing::TestError::Failed; };

        try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Undef, count: 8 }) catch {

            throw testing::TestError::Failed; };

        try testing::expectBytesEq(&out.bytes[..out.offset], &[0, 1, 255, 0, 0, 0, 0, 0, 2, 254, 255, 1, 0,

            0, 0, 0, 4, 253, 255, 255, 255, 2, 0, 0, 0, 0, 8, 252, 255, 255, 255, 255, 255, 255, 255, 3,

            0, 0, 0, 1, 0, 0, 0, 0, 4, 0, 0, 0, 2, 1, 0, 0, 0, 5, 0, 0, 0, 3, 2, 0, 0, 0, 97, 98, 6, 0,

            0, 0, 3, 0, 0, 0, 0, 7, 0, 0, 0, 4, 8, 0, 0, 0]);

    }

}

/// Reject invalid widths, insufficient storage, and absent symbols.

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

    let mut buffer: [u8; 8] = [0; 8];

    let namesTable: [*[u8]; 0] = [];

    let storage: 'buffer = &mut buffer[..], names = &namesTable[..] in {

        let mut out = writer::new(storage, names);

        let mut failures: u32 = 0;

        try writer::integer(&mut out, 1, 3) catch err {

            try testing::expect(err == binary::Error::Invalid);

            set failures += 1;

        };

        try writer::symbol(&mut out, "absent") catch err {

            try testing::expect(err == binary::Error::Symbol);

            set failures += 1;

        };

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

        try writer::integer(&mut out, 0, 8) catch {

            throw testing::TestError::Failed;

        };

        try writer::integer(&mut out, 1, 1) catch err {

            try testing::expect(err == binary::Error::Capacity);

            set failures += 1;

        };

        try testing::expect(failures == 3);

        try testing::expect(out.offset == 8);

    }

}

/// Check operation tags independently of the native union representation.

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

    let binaryOps = &[

        il::BinOp::Add, il::BinOp::Sub, il::BinOp::Mul,

        il::BinOp::Sdiv, il::BinOp::Udiv, il::BinOp::Srem,

        il::BinOp::Urem, il::BinOp::Eq, il::BinOp::Ne,

        il::BinOp::Slt, il::BinOp::Sge, il::BinOp::Ult,

        il::BinOp::Uge, il::BinOp::And, il::BinOp::Or,

        il::BinOp::Xor, il::BinOp::Shl, il::BinOp::Sshr,

        il::BinOp::Ushr,

    ];

    for op, tag in binaryOps {

        try instruction(il::Instr::BinOp {

            op, typ: il::Type::W64, dst: il::Reg { n: 1 },

            a: il::Val::Undef, b: il::Val::Undef,

        }, &[6, tag as u8, 8, 1, 0, 0, 0, 4, 4]);

    }

    for op, tag in &[il::UnOp::Neg, il::UnOp::Not] {

        try instruction(il::Instr::UnOp {

            op, typ: il::Type::W64, dst: il::Reg { n: 1 },

            a: il::Val::Undef,

        }, &[7, tag as u8, 8, 1, 0, 0, 0, 4]);

    }

    let mut empty: [il::Val; 0] = [];

    for op, tag in &[il::CmpOp::Eq, il::CmpOp::Ne, il::CmpOp::Slt, il::CmpOp::Ult] {

        try instruction(il::Instr::Br {

            op, typ: il::Type::W8, a: il::Val::Undef, b: il::Val::Undef,

            thenTarget: 1, thenArgs: &mut empty[..],

            elseTarget: 2, elseArgs: &mut empty[..],

        }, &[13, tag as u8, 1, 4, 4, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0]);

    }

}

/// Check byte-sequence bounds at every output size.

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

    let mut buffer: [u8; 7] = [0; 7];

    for capacity in 0..7 {

        let namesTable: [*[u8]; 0] = [];

        let storage: 'short = &mut buffer[..capacity], names = &namesTable[..] in {

            let mut out = writer::new(storage, names);

            let mut failed = false;

            try writer::bytes(&mut out, "abc") catch err {

                try testing::expect(err == binary::Error::Capacity);

                set failed = true;

            };

            try testing::expect(failed);

            try testing::expect(out.offset <= capacity);

        }

    }

    let namesTable: [*[u8]; 0] = [];

    let storage: 'buffer = &mut buffer[..], names = &namesTable[..] in {

        let mut out = writer::new(storage, names);

        try writer::bytes(&mut out, "abc") catch {

            throw testing::TestError::Failed;

        };

        try testing::expectBytesEq(&out.bytes[..], &[3, 0, 0, 0, 97, 98, 99]);

    }

}