Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-compress

Source of release 0.9.1

0.9.1 / src / native_tests.lucb

import compress
import thread
import interop
import memory
import binary
import flate
import segments

## Over 2 MiB, `compress` deflates 1 MiB segments on several threads into one
## stream: flate's one-thread inflate reads it, `inflate` and `decode` read
## it back in parallel, and a damaged segment fails as corrupt.
func segmented() -> !:
    let size: usize = 11 * 1048576 + 12345
    let plain = try new u8[size] --- in memory.heap
    defer free(plain) in memory.heap
    var seed: u32 = 2463534242
    for at in 0..<size:
        seed ^= seed << 13
        seed ^= seed >> 17
        seed ^= seed << 5
        plain[at] = (u8)(seed & 7) if (at // 4096) % 2 == 0 else (u8)(at & 255)
    let packed = try compress.compress(plain, 1)
    defer free(packed) in memory.heap
    assert(segments.markers(packed) == 11)
    let back = try new u8[size] --- in memory.heap
    defer free(back) in memory.heap
    _ = try flate.inflate_zlib(packed, back)
    assert((str)back == (str)plain)
    for at in 0..<size: back[at] = 0
    try compress.inflate(packed, back)
    assert((str)back == (str)plain)
    let decoded = try compress.decode(packed, (i64)size)
    defer decoded.release()
    assert((str)(try decoded.value().bytes()) == (str)plain)
    var small = false
    _ = compress.decode(packed, (i64)size - 1) catch failure:
        assert(failure.code == compress.limit_exceeded)
        small = true
        recover decoded
    assert(small)
    packed[packed.length // 2] ^= 85
    var damaged = false
    compress.inflate(packed, back) catch failure:
        assert(failure.code == compress.corrupt)
        damaged = true
    assert(damaged)

func worker(raw: void*?):
    _ = raw
    for iteration in 0..<32:
        let encoded = compress.encode(b"parallel codec test test test") catch failure: trap(failure.message)
        defer encoded.release()
        let bytes = encoded.value().bytes() catch failure: trap(failure.message)
        let decoded = compress.decode(bytes, 29) catch failure: trap(failure.message)
        defer decoded.release()
        let plain = decoded.value().bytes() catch failure: trap(failure.message)
        assert((str)plain == "parallel codec test test test")

pub func main(arguments: str[]) -> i32!:
    _ = arguments
    assert(compress.adler32(b"") == 1 and compress.crc32(b"") == 0)
    assert(compress.adler32(b"Wikipedia") == 300286872)
    assert(compress.crc32(b"123456789") == 3421780262)
    var buffer = binary.Buffer()
    defer buffer.close()
    try buffer.put(b"")
    assert(buffer.view().length == 0)
    let empty = try compress.encode(b"")
    defer empty.release()
    let decoded = try compress.decode(try empty.value().bytes(), 0)
    defer decoded.release()
    assert((try decoded.value().bytes()).length == 0)
    decoded.value().close()
    decoded.value().close()
    var refused = false
    _ = decoded.value().bytes() catch failure:
        assert(failure.code == compress.closed)
        refused = true
        recover b""
    assert(refused)
    for maximum in [-1, 1073741825]:
        var rejected = false
        let bad: interop.Reference[compress.Data]? = compress.encode(b"", maximum) catch failure:
            assert(failure.code == compress.invalid)
            rejected = true
            recover none
        assert(rejected and bad == none)
    try segmented()
    var workers: thread.Handle[8]
    for index in 0..<8: workers[index] = try thread.spawn(worker, none)
    for handle in workers: try handle.join()
    print("PASS checksums, empty buffers, ownership, invalid limits, segmented parallel streams, 8 independent worker contexts")
    return 0