Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-compress

Source of release 0.9.1

0.9.1 / src / stream_tests.lucb

import compress
import decoder as codec
import thread
import interop
import memory

func worker(raw: void*?):
    _ = raw
    for iteration in 0..<16:
        let encoded = compress.encode(b"separate stream streams") catch failure: trap(failure.message)
        defer encoded.release()
        let packed = encoded.value().bytes() catch failure: trap(failure.message)
        var decoder = codec.make_decoder() catch failure: trap(failure.message)
        var input: usize
        var output: usize
        var scratch: u8[1]
        let expected = b"separate stream streams"
        while true:
            let size: usize = 1 if input < packed.length else 0
            let step = decoder.step(packed[input..<input + size], scratch, input + size == packed.length) catch failure: trap(failure.message)
            input += (usize)step.consumed
            if step.produced == 1:
                assert(scratch[0] == expected[output])
                output += 1
                scratch[0] = 0
            if step.status == codec.finished: break
        assert(output == expected.length and input == packed.length)

pub func main(arguments: str[]) -> i32!:
    _ = arguments
    assert(memory.size_of(codec.Decoder) > 32768 and memory.size_of(codec.Decoder) <= 49152)
    for framing in ["gzip", "auto"]:
        var failed = false
        _ = codec.make_decoder(framing) catch failure:
            assert(failure.code == compress.invalid)
            failed = true
            recover codec.Decoder()
        assert(failed)
    for budgets in 0..<2:
        var failed = false
        _ = codec.make_decoder("zlib", -1 if budgets == 0 else 100, -1 if budgets == 1 else 100) catch failure:
            assert(failure.code == compress.invalid)
            failed = true
            recover codec.Decoder()
        assert(failed)
    let large_budget = try codec.make_decoder("raw", 9223372036854775807, 9223372036854775807)
    assert(large_budget.statistics().input_bytes == 0)
    var uninitialized: codec.Decoder
    var scratch: u8[64]
    var empty: u8[]
    var rejected = false
    _ = uninitialized.step(b"", empty) catch failure:
        assert(failure.code == compress.closed)
        rejected = true
        recover codec.Step()
    assert(rejected)
    var decoder = try codec.make_decoder()
    assert((try decoder.step(b"", empty)).status == codec.need_input)
    let encoded = try compress.encode(b"ABCABCABCABC")
    defer encoded.release()
    let packed = try encoded.value().bytes()
    ## Exhausted budgets must not ask for input/output that can never be accepted.
    var no_input = try codec.make_decoder(max_input = 0)
    rejected = false
    _ = no_input.step(b"", empty) catch failure:
        assert(failure.code == compress.limit_exceeded)
        rejected = true
        recover codec.Step()
    assert(rejected and no_input.statistics().input_bytes == 0)
    var no_output = try codec.make_decoder(max_output = 0)
    rejected = false
    _ = no_output.step(packed, empty) catch failure:
        assert(failure.code == compress.limit_exceeded)
        rejected = true
        recover codec.Step()
    assert(rejected and no_output.statistics().output_bytes == 0)
    let first = try decoder.step(packed, empty, true)
    assert(first.status == codec.need_output and first.produced == 0)
    ## The end marker survives output backpressure, without resupplying the flag.
    let rest = try decoder.step(packed[(usize)first.consumed..], scratch)
    assert(rest.status == codec.finished and rest.produced == 12)
    assert((str)scratch[..<12] == "ABCABCABCABC")
    try decoder.reset()
    assert(decoder.statistics().input_bytes == 0 and decoder.statistics().output_bytes == 0)
    rejected = false
    _ = decoder.step(packed[..<packed.length - 1], scratch, true) catch failure:
        assert(failure.code == compress.corrupt)
        rejected = true
        recover codec.Step()
    assert(rejected and decoder.statistics().failed)
    try decoder.reset()
    assert(not decoder.statistics().failed)
    assert((try decoder.step(packed, scratch, true)).status == codec.finished)
    try decoder.reset()
    _ = try decoder.step(packed, empty, true)
    rejected = false
    _ = decoder.step(b"", scratch, true) catch failure:
        assert(failure.code == compress.invalid)
        rejected = true
        recover codec.Step()
    assert(rejected and decoder.statistics().failed)
    decoder.close()
    decoder.close()
    rejected = false
    decoder.reset() catch failure:
        assert(failure.code == compress.closed)
        rejected = true
    assert(rejected)
    var raw_decoder = try codec.make_decoder("raw", (i64)packed.length - 6, 12)
    assert((try raw_decoder.step(packed[2..<packed.length - 4], scratch, true)).status == codec.finished)
    var facade = try compress.Inflater()
    defer facade.close()
    for capacity in [-1, 1048577]:
        var failed = false
        let unavailable: interop.Reference[compress.Data]? = facade.feed(packed, capacity) catch failure:
            assert(failure.code == compress.invalid)
            failed = true
            recover none
        assert(failed and unavailable == none)
    assert((try facade.statistics()).input_bytes == 0)
    let chunk = try facade.feed(packed, 64, true)
    defer chunk.release()
    assert(try chunk.value().status() == compress.finished)
    facade.close()
    assert((str)(try chunk.value().bytes()) == "ABCABCABCABC")
    var workers: thread.Handle[8]
    for i in 0..<8: workers[i] = try thread.spawn(worker, none)
    for handle in workers: try handle.join()
    print(f"PASS incremental lifecycle, end markers, poison/reset, raw framing, ownership, 8 workers; state={memory.size_of(codec.Decoder)} bytes")
    return 0