Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-compress

Source of release 0.9.1

0.9.1 / src / flate / tests.lucb

#==============================================================================================
#
#   flate/tests - The module's tests
#
#==============================================================================================

test "checksums match their definitions":
    assert(crc32(b"123456789") == 0xCBF43926)
    assert(adler32(b"Wikipedia") == 0x11E60398)
    assert(crc32(b"56789", crc32(b"1234")) == 0xCBF43926)
    assert(adler32_combine(adler32(b"Wiki"), adler32(b"pedia"), 5) == 0x11E60398)

test "every level round-trips, alone and in segments":
    var input: u8[20000]
    for i in 0..<input.length:
        input[i] = (u8)((i * 7 + i // 300) % 251) if i % 1000 < 600 else (u8)(i % 3)
    for level: i32 in 0..<10:
        var out: u8[21000]
        let used = try deflate_zlib(input, level, out)
        var back: u8[20000]
        assert(try inflate_zlib(out[..<used], back) == used)
        for i in 0..<input.length:
            assert(back[i] == input[i])
        # Three independent segments make one stream.
        var joined: u8[21000]
        var at = try deflate_raw(input[..<5000], level, joined, false)
        at += try deflate_raw(input[5000..<5000], level, joined[at..], false)
        at += try deflate_raw(input[5000..], level, joined[at..], true)
        var again: u8[20000]
        assert(try inflate_raw(joined[..<at], again) == at)
        for i in 0..<input.length:
            assert(again[i] == input[i])

test "damaged streams fail":
    var input: u8[4000]
    for i in 0..<input.length:
        input[i] = (u8)(i * 13 % 256)
    var out: u8[4200]
    let used = try deflate_zlib(input, 6, out)
    var back: u8[4000]
    var failed = false
    inflate_zlib(out[..<used - 9], back) catch:
        failed = true
        recover 0
    assert(failed)
    failed = false
    out[used - 1] ^= 1
    inflate_zlib(out[..<used], back) catch:
        failed = true
        recover 0
    assert(failed)
    failed = false
    var short: u8[3999]
    out[used - 1] ^= 1
    inflate_zlib(out[..<used], short) catch:
        failed = true
        recover 0
    assert(failed)

## What a windowed inflate handed on, checked against the input as it comes.
struct Received:
    var expected: const u8[]
    var at: usize
    var calls: usize
    var wrong: bool

func receive(context: void*?, bytes: const u8[]) -> !:
    let received = (Received*)(context else return)
    for byte in bytes:
        if received.at >= received.expected.length or received.expected[received.at] != byte:
            received.wrong = true
        received.at += 1
    received.calls += 1

test "a windowed inflate hands on the same bytes a window at a time":
    let size: usize = 400000
    let input = try new u8[size] --- in memory.heap
    defer free(input) in memory.heap
    for i in 0..<size:
        input[i] = (u8)((i * 7 + i // 300) % 251) if i % 1000 < 600 else (u8)(i % 3)
    let packed = try new u8[size + 1000] --- in memory.heap
    defer free(packed) in memory.heap
    let through = try new u8[70000] --- in memory.heap
    defer free(through) in memory.heap
    # Level 0 is stored blocks; 1 and 6 matches reaching back across slides.
    for level in [(i32)0, 1, 6]:
        let used = try deflate_raw(input, level, packed, true)
        var received = Received(expected = input, at = 0, calls = 0, wrong = false)
        assert(try inflate_raw_windowed(packed[..<used], through, size, receive, (void*)&received) == used)
        assert(received.at == size and not received.wrong and received.calls > 5)
        # A stream longer or shorter than promised fails.
        var failed = false
        received = Received(expected = input, at = 0, calls = 0, wrong = false)
        inflate_raw_windowed(packed[..<used], through, size - 1, receive, (void*)&received) catch:
            failed = true
            recover 0
        assert(failed)
        failed = false
        received = Received(expected = input, at = 0, calls = 0, wrong = false)
        inflate_raw_windowed(packed[..<used], through, size + 1, receive, (void*)&received) catch:
            failed = true
            recover 0
        assert(failed)

## Input handed over in pieces of `size` bytes.
struct Pieces:
    var data: const u8[]
    var at: usize
    var size: usize
    var received: Received

func next_piece(context: void*?) -> const u8[]:
    let pieces = (Pieces*)(context else trap("pieces"))
    let end = pieces.at + pieces.size if pieces.at + pieces.size < pieces.data.length else pieces.data.length
    let piece = pieces.data[pieces.at..<end]
    pieces.at = end
    return piece

func receive_pieces(context: void*?, bytes: const u8[]) -> !:
    let pieces = (Pieces*)(context else return)
    try receive((void*)&pieces.received, bytes)

test "a windowed inflate takes its input in pieces of any size":
    let size: usize = 300000
    let input = try new u8[size] --- in memory.heap
    defer free(input) in memory.heap
    for i in 0..<size:
        input[i] = (u8)((i * 7 + i // 300) % 251) if i % 1000 < 600 else (u8)(i % 3)
    let packed = try new u8[size + 1000] --- in memory.heap
    defer free(packed) in memory.heap
    let through = try new u8[70000] --- in memory.heap
    defer free(through) in memory.heap
    for level in [(i32)0, 1, 6]:
        let used = try deflate_raw(input, level, packed, true)
        for piece in [(usize)1, 7, 4096, 100000]:
            var pieces = Pieces(data = packed[..<used], at = piece, size = piece, received = Received(expected = input, at = 0, calls = 0, wrong = false))
            let consumed = try inflate_raw_windowed(packed[..<piece], through, size, receive_pieces, (void*)&pieces, next_piece)
            assert(consumed == used and pieces.received.at == size and not pieces.received.wrong)
        # Cut short, it fails.
        var short = Pieces(data = packed[..<used - 5], at = 100, size = 100, received = Received(expected = input, at = 0, calls = 0, wrong = false))
        var failed = false
        inflate_raw_windowed(packed[..<100], through, size, receive_pieces, (void*)&short, next_piece) catch:
            failed = true
            recover 0
        assert(failed)