dymokomi/luce-compress
Source of release 0.9.0
0.9.0 / 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