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)