//! Package reconstruction, malformed input, and arena rollback tests.

use std::testing;

use std::lang::alloc;

use std::lang::il;

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

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

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

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

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

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

/// Structural limits for small test programs.

constant LIMITS: binary::Limits = binary::Limits { registers: 16, blocks: 4 };

/// Check a package round trip and failure at every truncated byte length.

unsafe fn roundTrip(package: &binary::Package) throws (testing::TestError) {

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

    let length = try program::encode(&mut buffer[..], package) catch {

        throw testing::TestError::Failed;

    };

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

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

    set arena.offset = 8;

    let decoded = try program::decode(&buffer[..length], &mut arena, LIMITS) catch {

        throw testing::TestError::Failed;

    };

    try testing::expectBytesEq(decoded.name, package.name);

    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);

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

    let repeated = try program::encode(&mut encoded[..], &decoded) catch {

        throw testing::TestError::Failed;

    };

    try testing::expectBytesEq(&buffer[..length], &encoded[..repeated]);

    // Decoded names and string initializers retain arena ownership.

    for i in 0..length {

        set buffer[i] = 0;

    }

    let copied = try program::encode(&mut buffer[..], &decoded) catch {

        throw testing::TestError::Failed;

    };

    try testing::expectBytesEq(&buffer[..copied], &encoded[..repeated]);

    for end in 0..length {

        set arena.offset = 8;

        let mut failed = false;

        try program::decode(&buffer[..end], &mut arena, LIMITS) catch err {

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

            set failed = true;

        };

        try testing::expect(failed);

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

    }

    set arena.offset = 8;

    let mut input = reader::new(&[], &mut arena, &[]);

    let mut exhausted = false;

    try reader::storage(&mut input, 0xffffffff, 8, 0xffffffff) catch err {

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

        set exhausted = true;

    };

    try testing::expect(exhausted);

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

    // Exercise every smaller arena extent, including alignment boundaries.

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

    let _ = try program::decode(&buffer[..length], &mut usedArena, LIMITS) catch {

        throw testing::TestError::Failed;

    };

    let required = usedArena.offset;

    for capacity in 0..required {

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

        let mut failed = false;

        try program::decode(&buffer[..length], &mut short, LIMITS) catch err {

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

            set failed = true;

        };

        try testing::expect(failed);

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

    }

}

/// Check an empty program with a package identity.

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

    let package = binary::Package {

        symbols: &["p"], name: "p", dependencies: &[], exports: &[], entry: nil,

        program: il::Program { data: &[], fns: &[] },

    };

    try roundTrip(&package);

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

    let length = try program::encode(&mut buffer[..], &package) catch {

        throw testing::TestError::Failed;

    };

    try testing::expectBytesEq(&buffer[..length], &[

        82, 73, 76, 0, 1, 0, 0, 0, 1, 0, 0, 0,

        1, 0, 0, 0, 112, 0, 0, 0, 0,

        0, 0, 0, 0, 0, 0, 0, 0, 0,

        0, 0, 0, 0, 0, 0, 0, 0,

    ]);

}

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

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

    let params: *unsafe [il::Param] = &[il::Param { value: il::Reg { n: 1 }, type: il::Type::W64 }];

    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 })],

        },

        il::Instr::Ret { val: il::Val::Reg(il::Reg { n: 2 }) },

    ];

    let func = il::Fn {

        name: "p::main", params, returnType: il::Type::W64, isExtern: false, isLeaf: false,

        blocks: &[il::Block {

            label: "entry", params: &[], instrs: &mut instrs[..], locs: &[], preds: &[0], loopDepth: 2,

        }],

    };

    let external = il::Fn {

        name: "dep::fn", params, returnType: il::Type::W64, isExtern: true, isLeaf: true, blocks: &[],

    };

    let data = il::Data {

        name: "p::data", size: 64, alignment: 8, readOnly: false, isZeroInit: false,

        values: &[

            il::DataValue { item: il::DataItem::Val { typ: il::Type::W8, val: -1 }, count: 2 },

            il::DataValue { item: il::DataItem::Val { typ: il::Type::W16, val: -2 }, count: 1 },

            il::DataValue { item: il::DataItem::Val { typ: il::Type::W32, val: -3 }, count: 1 },

            il::DataValue { item: il::DataItem::Val { typ: il::Type::W64, val: -4 }, count: 1 },

            il::DataValue { item: il::DataItem::Sym("p::data"), count: 1 },

            il::DataValue { item: il::DataItem::Fn("dep::fn"), count: 1 },

            il::DataValue { item: il::DataItem::Str("bytes"), count: 2 },

            il::DataValue { item: il::DataItem::Str(""), count: 0 },

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

        ],

    };

    let zero = il::Data {

        name: "p::zero", size: 4096, alignment: 4096, readOnly: false, isZeroInit: true, values: &[],

    };

    let package = binary::Package {

        symbols: &["p", "dep", "p::main", "dep::fn", "p::data", "p::zero"], name: "p",

        dependencies: &["dep"],

        exports: &[

            binary::Export { name: "p::main", kind: binary::ExportKind::Function },

            binary::Export { name: "p::data", kind: binary::ExportKind::Data },

        ],

        entry: "p::main", program: il::Program { data: retainData(&[data, zero]), fns: &[&func, &external] },

    };

    try roundTrip(&package);

}

/// Reject an invalid encoded instruction without a panic.

unsafe fn badInstruction(bytes: *[u8], expected: binary::Error) throws (testing::TestError) {

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

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

    let mut input = reader::new(bytes, &mut arena, &["p"]);

    set input.registers = 2;

    set input.blocks = 1;

    let mut failed = false;

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

        try testing::expect(err == expected);

        set failed = true;

    };

    try testing::expect(failed);

}

/// Check instruction tags, operand tags, types, optional flags, and indices.

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

    try badInstruction(&[255], binary::Error::Invalid);

    try badInstruction(&[5, 0, 0, 0, 0, 255], binary::Error::Invalid);

    try badInstruction(&[1, 3], binary::Error::Invalid);

    try badInstruction(&[6, 255], binary::Error::Invalid);

    try badInstruction(&[7, 255], binary::Error::Invalid);

    try badInstruction(&[13, 255], binary::Error::Invalid);

    try badInstruction(&[11, 2], binary::Error::Invalid);

    try badInstruction(&[10, 8, 2], binary::Error::Invalid);

    try badInstruction(&[5, 2, 0, 0, 0], binary::Error::Invalid);

    try badInstruction(&[5, 0, 0, 0, 0, 0, 2, 0, 0, 0], binary::Error::Invalid);

    try badInstruction(&[12, 1, 0, 0, 0], binary::Error::Invalid);

    try badInstruction(&[5, 0, 0, 0, 0, 2, 1, 0, 0, 0], binary::Error::Symbol);

    try badInstruction(&[12, 0, 0, 0, 0, 255, 255, 255, 255], binary::Error::Truncated);

}

/// Check header validation and package symbol indices with arena rollback.

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

    let package = binary::Package {

        symbols: &["p"], name: "p", dependencies: &[], exports: &[], entry: nil,

        program: il::Program { data: &[], fns: &[] },

    };

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

    let length = try program::encode(&mut buffer[..], &package) catch {

        throw testing::TestError::Failed;

    };

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

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

    for offset in &[0, 4, 17, 29] {

        let original = buffer[offset];

        set buffer[offset] = 255;

        set arena.offset = 8;

        let mut failed = false;

        try program::decode(&buffer[..length], &mut arena, LIMITS) catch {

            set failed = true;

        };

        try testing::expect(failed);

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

        set buffer[offset] = original;

    }

    let mut trailing = false;

    try program::decode(&buffer[..length + 1], &mut arena, LIMITS) catch err {

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

        set trailing = true;

    };

    try testing::expect(trailing);

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

}

/// Encode a malformed package and check rejection with arena rollback.

unsafe fn rejected(package: &binary::Package, limits: binary::Limits) throws (testing::TestError) {

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

    let length = try program::encode(&mut buffer[..], package) catch {

        throw testing::TestError::Failed;

    };

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

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

    set arena.offset = 8;

    let mut failed = false;

    try program::decode(&buffer[..length], &mut arena, limits) catch err {

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

        set failed = true;

    };

    try testing::expect(failed);

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

}

/// Check initializer extent arithmetic, alignments, and duplicate symbols.

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

    let mut item = il::Data {

        name: "p", size: 0xffffffff, alignment: 8, readOnly: false, isZeroInit: false,

        values: &[

            il::DataValue { item: il::DataItem::Val { typ: il::Type::W64, val: 0 }, count: 0xffffffff },

        ],

    };

    let mut package = binary::Package {

        symbols: &["p"], name: "p", dependencies: &[], exports: &[], entry: nil,

        program: il::Program { data: retainData(&[item]), fns: &[] },

    };

    try rejected(&package, LIMITS);

    set item.size = 1;

    set item.values = &[

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

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

    ];

    set package.program = il::Program { data: retainData(&[item]), fns: &[] };

    try rejected(&package, LIMITS);

    set item.values = &[];

    for alignment in &[0, 3] {

        set item.alignment = alignment;

        set package.program = il::Program { data: retainData(&[item]), fns: &[] };

        try rejected(&package, LIMITS);

    }

    set package.program = il::Program { data: &[], fns: &[] };

    set package.symbols = &["p", "p"];

    try rejected(&package, LIMITS);

    set package.symbols = &["p", ""];

    try rejected(&package, LIMITS);

}

/// Check function block limits, parameter indices, and predecessor indices.

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

    let mut instrs = [il::Instr::Ret { val: nil }];

    let mut block = il::Block {

        label: "entry", params: &[], instrs: &mut instrs[..], locs: &[], preds: &[], loopDepth: 0,

    };

    let mut func = il::Fn {

        name: "p", params: &[], returnType: il::Type::W64,

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

    };

    let package = binary::Package {

        symbols: &["p"], name: "p", dependencies: &[], exports: &[], entry: nil,

        program: il::Program { data: &[], fns: &[&func] },

    };

    try rejected(&package, binary::Limits { registers: 16, blocks: 0 });

    set func.isExtern = true;

    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);

}

/// Reject unknown initializer tags and widths before reading their payloads.

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

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

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

    let fixtures: [*[u8]; 2] = [&[255], &[0, 3]];

    for bytes in &fixtures[..] {

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

        let mut failed = false;

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

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

            set failed = true;

        };

        try testing::expect(failed);

    }

}

/// Check symbol collection capacity and package ownership failures.

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

    let mut symbols: [*[u8]; 8] = undefined;

    let mut dependencies: [*[u8]; 1] = undefined;

    let empty = il::Program { data: &[], fns: &[] };

    let mut names = collect::new(&mut symbols[..0], &mut dependencies[..]);

    let mut failed = false;

    try collect::package(&mut names, "p", empty, &[], nil) catch err {

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

        set failed = true;

    };

    try testing::expect(failed);

    let item = il::Data {

        name: "p::data", size: 8, alignment: 8, readOnly: false, isZeroInit: false,

        values: &[il::DataValue { item: il::DataItem::Fn("dep::fn"), count: 1 }],

    };

    let local = il::Program { data: retainData(&[item]), fns: &[] };

    set names = collect::new(&mut symbols[..], &mut dependencies[..0]);

    set failed = false;

    try collect::package(&mut names, "p", local, &[], nil) catch err {

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

        set failed = true;

    };

    try testing::expect(failed);

    set names = collect::new(&mut symbols[..], &mut dependencies[..]);

    set failed = false;

    try collect::package(&mut names, "other", local, &[], nil) catch err {

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

        set failed = true;

    };

    try testing::expect(failed);

    set names = collect::new(&mut symbols[..], &mut dependencies[..]);

    let package = try collect::package(&mut names, "p", local, &[], nil) catch {

        throw testing::TestError::Failed;

    };

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

    try testing::expectBytesEq(package.dependencies[0], "dep");

    try testing::expect(package.symbols.len == 4);

}

/// Copy data fixtures into stable storage for the package descriptor.

unsafe fn retainData(items: &[il::Data]) -> *[il::Data] {

    unsafe static DATA: [il::Data; 2] = undefined;

    assert items.len <= DATA.len;

    for item, i in items {

        set DATA[i] = item;

    }

    return &DATA[..items.len];

}