Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-compress

Source of release 0.9.1

0.9.1 / src / fuzz_tests.lucb

## Test-only bounded batch format; Python/zlib supplies independent expectations.
import native as codec
import compress
import binary
from luce_std import files
import c

func check(reader: binary.Reader*) -> !:
    let identity = try reader.uint(4)
    let wrapped = try reader.uint(4)
    let valid = try reader.uint(4)
    let size = try reader.uint(4)
    let expected_size = try reader.uint(4)
    let expected_consumed = try reader.uint(4)
    let max_input = try reader.uint(4)
    let max_output = try reader.uint(4)
    var seed = (u32)(try reader.uint(4))
    assert(wrapped <= 1 and valid <= 1 and seed != 0)
    assert(size <= 262144 and expected_size <= 65536 and max_input <= 262144 and max_output <= 65536)
    assert(expected_consumed <= size)
    let packed = try reader.take((usize)size)
    let expected = try reader.take((usize)expected_size)
    print(f"CASE {identity}")
    var decoder = try codec.make_decoder("zlib" if wrapped == 1 else "raw", (i64)max_input, (i64)max_output)
    defer decoder.close()
    var input: u8[257]
    var output: u8[258]
    var consumed: usize
    var produced: usize
    var calls: u64
    var units: u64
    let late = seed % 2 == 1
    while true:
        assert(calls <= 64 * (size + max_output + 1024))
        seed ^= seed << 13
        seed ^= seed >> 17
        seed ^= seed << 5
        var count: usize = 0 if calls % 7 == 0 else 1 + (usize)(seed % 257)
        if count > packed.length - consumed: count = packed.length - consumed
        let capacity: usize = 0 if calls % 5 == 0 else 1 + (usize)((seed >> 8) % 257)
        let allowance: i64 = 4096 if calls % 11 == 0 else 1 + (i64)((seed >> 16) % 31)
        for index in 0..<count: input[index] = packed[consumed + index]
        output[capacity] = 173
        let last = consumed == packed.length if late else consumed + count == packed.length
        var rejected = false
        let step = decoder.step(input[..<count], output[..<capacity], last, allowance) catch failure:
            assert(failure.code == compress.corrupt or failure.code == compress.unsupported or failure.code == compress.limit_exceeded)
            if valid == 1: print(f"UNEXPECTED_REJECT {identity} {failure.message}")
            assert(valid == 0 and decoder.statistics().failed)
            rejected = true
            recover codec.Step()
        let stats = decoder.statistics()
        assert(stats.input_bytes <= (i64)max_input and stats.output_bytes <= (i64)max_output)
        assert(output[capacity] == 173)
        if rejected:
            var poisoned = false
            _ = decoder.step(b"", output) catch failure:
                assert(failure.code == compress.corrupt)
                poisoned = true
                recover codec.Step()
            assert(poisoned)
            try decoder.reset()
            assert(not decoder.statistics().failed and decoder.statistics().input_bytes == 0 and decoder.statistics().output_bytes == 0)
            return
        assert(step.work_units > 0 and step.work_units <= allowance)
        assert(step.consumed >= 0 and (usize)step.consumed <= count and step.consumed <= 8 * step.work_units)
        assert(step.produced >= 0 and (usize)step.produced <= capacity and step.produced <= 258 * step.work_units)
        units += (u64)step.work_units
        assert(units <= 64 * (size + max_output + 1024))
        if valid == 1:
            assert(produced <= expected.length and (usize)step.produced <= expected.length - produced)
            for index in 0..<(usize)step.produced: assert(output[index] == expected[produced + index])
        for index in 0..<count: input[index] = 221
        for index in 0..<(usize)step.produced: output[index] = 222
        consumed += (usize)step.consumed
        produced += (usize)step.produced
        assert(stats.input_bytes == (i64)consumed and stats.output_bytes == (i64)produced and not stats.failed)
        calls += 1
        if step.status == codec.finished:
            assert(valid == 1 and stats.finished and consumed == (usize)expected_consumed and produced == expected.length)
            return
        if step.status == codec.need_input: assert((usize)step.consumed == count)
        elif step.status == codec.need_output: assert((usize)step.produced == capacity)
        else: assert(step.status == codec.yielded and step.work_units == allowance)

pub func main(arguments: str[]) -> i32!:
    assert(arguments.length == 2)
    let file = try files.read((c.str)arguments[1], limit = 16777216)
    defer file.release()
    let data = file.value
    var reader = binary.Reader(data = data)
    assert((str)(try reader.take(8)) == "LCFZ01\0\0")
    let count = try reader.uint(4)
    assert(count > 0 and count <= 128)
    for index in 0..<(usize)count: try check(&reader)
    assert(reader.position == data.length)
    print(f"PASS batch {count}")
    return 0