try testing::expect(decoded.dependencies.len == package.dependencies.len);

    try testing::expect(decoded.exports.len == package.exports.len);

    try testing::expect(decoded.program.fns.len == package.program.fns.len);

    for original, i in package.program.fns {

        let restored = decoded.program.fns[i];

        assert restored.blocks.len == original.blocks.len;

        for block, j in original.blocks {

            let rebuilt = &restored.blocks[j];

            try testing::expectBytesEq(rebuilt.label, block.label);

            assert rebuilt.loopDepth == block.loopDepth;

    ]);

}

/// Check functions, dependencies, exports, initializers, and block metadata.

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

    let mut instrs = [

        il::Instr::Call {

            retTy: il::Type::W64, dst: il::Reg { n: 2 }, func: il::Val::FnAddr("dep::fn"),

            args: &[il::Val::Reg(il::Reg { n: 1 })],

        },

    try rejected(&package, LIMITS);

    set func.isExtern = false;

    set func.params = &[il::Param { value: il::Reg { n: 16 }, type: il::Type::W64 }];

    try rejected(&package, LIMITS);

    set func.params = &[];

    set block.preds = &[1];

    set func.blocks = &[block];

    try rejected(&package, LIMITS);

}

/// Read typed SSA parameters with checked register indices.

unsafe fn readParams 'input (input: &mut reader::Reader 'input) -> *unsafe [il::Param] throws (binary::Error) {

    let n = try reader::count(input, 5);

    let params = try reader::storage(input, @sizeOf(il::Param), @alignOf(il::Param), n)

        as *mut [il::Param];

        let value = try reader::reg(input);

        let t = try reader::typ(input);

        set params[i] = il::Param { value, type: t };

    }

}

/// Extend an initializer extent without exceeding its declared storage.

fn extendDataExtent(extent: u64, value: il::DataValue, size: u32) -> u64 throws (binary::Error) {

    let mut width: u32 = 0;