dymokomi/luce-compress
Source of release 0.9.0
0.9.0 / src / gzip / tests.lucb
#==============================================================================================
#
# gzip/tests - The module's tests
#
#==============================================================================================
# mark: Helpers ===============================================================================
## Words to compress.
func sample(output: u8[]):
let words = ["gzip ", "member ", "deflate ", "header ", "crc ", "\n"]
var at: usize = 0
var state: u32 = 1
while at < output.length:
state = state *% 1103515245 +% 12345
let word = words[(usize)((state >> 16) % 6)]
for byte in word.bytes:
if at < output.length:
output[at] = byte
at += 1
## A member of `data` with every header flag set: FTEXT, FHCRC, FEXTRA, FNAME and
## FCOMMENT; `out` must hold it. Its length.
func flagged(data: const u8[], out: u8[]) -> usize!:
let head = b"\x1f\x8b\x08\x1f\x00\x00\x00\x00\x00\x03\x06\x00AB\x02\x00hi"
var at: usize = 0
memory.copy(out, head, head.length)
at += head.length
memory.copy(out[at..], b"name.txt\x00a comment\x00", 19)
at += 19
let crc = flate.crc32(out[..<at])
out[at] = (u8)crc
out[at + 1] = (u8)(crc >> 8)
at += 2
at += try flate.deflate_raw(data, 6, out[at..], true)
let check = flate.crc32(data)
for i in 0..<(usize)4:
out[at + i] = (u8)(check >> (u32)(8 * i))
out[at + 4 + i] = (u8)((u32)data.length >> (u32)(8 * i))
return at + 8
## Decode `packed` a `piece` and `room` at a time; the output's length (into `output`).
func decode_pieces(packed: const u8[], output: u8[], piece: usize, room: usize, multiple: bool = true) -> (usize, usize)!:
var state = Decoder.open(multiple = multiple)
defer state.close()
var at: usize = 0
var made: usize = 0
var offered: usize = 0
while true:
if offered <= at:
offered = at + piece if at + piece < packed.length else packed.length
let end = made + room if made + room < output.length else output.length
let step = try state.step(packed[at..<offered], output[made..<end], offered == packed.length)
at += (usize)step.consumed
made += (usize)step.produced
if step.status == decoder.finished:
return (at, made)
if step.status == decoder.need_input:
assert(at == offered)
## The failure code of decoding `packed` whole, or `closed` when it decodes.
func failure_of(packed: const u8[], max_output: usize = default_limit) -> ErrorCode:
let output = decode(packed, max_output) catch failure:
return failure.code
free(output) in memory.heap
return closed
# mark: Tests =================================================================================
test "members round-trip at every level":
var data: u8[30000]
sample(data)
for level: i32 in 0..<10:
let packed = try encode(data, level)
defer free(packed) in memory.heap
let plain = try decode(packed)
defer free(plain) in memory.heap
assert(plain == data)
let header = try read_header(packed)
assert(header.length == 10 and header.flags == 0 and header.system == 255)
test "every header field is read and checked":
var data: u8[5000]
sample(data)
var packed: u8[8000]
let used = try flagged(data, packed)
let header = try read_header(packed[..<used])
assert(header.flags == 0x1F and header.system == 3 and header.length == 39)
assert(header.extra == b"AB\x02\x00hi" and (str)header.name == "name.txt" and (str)header.comment == "a comment")
let plain = try decode(packed[..<used])
assert(plain == data)
free(plain) in memory.heap
var out: u8[5000]
for piece in [(usize)1, 2, 5, 64, 100000]:
let (consumed, made) = try decode_pieces(packed[..<used], out, piece, piece + 3)
assert(consumed == used and made == data.length and out[..<made] == data)
# Damage to the header CRC, a reserved flag, the method, the data CRC and the size.
for place in [(usize)37, 3, 2, used - 8, used - 4]:
var damaged = packed
damaged[place] ^= 0x40
assert(failure_of(damaged[..<used]) == corrupt)
for cut in 0..<used:
assert(failure_of(packed[..<cut]) == corrupt)
test "members join, zero padding ends a file, other bytes do not":
var data: u8[9000]
sample(data)
let first = try encode(data[..<4000], 1)
defer free(first) in memory.heap
let empty = try encode(b"", 6)
defer free(empty) in memory.heap
let second = try encode(data[4000..], 9)
defer free(second) in memory.heap
var file: u8[12000]
var at: usize = 0
for part in [(const u8[])first, empty, second]:
memory.copy(file[at..], part, part.length)
at += part.length
let plain = try decode(file[..<at + 16])
assert(plain == data)
free(plain) in memory.heap
var out: u8[9000]
let (consumed, made) = try decode_pieces(file[..<at + 16], out, 7, 11)
assert(consumed == at + 16 and made == data.length and out[..<made] == data)
# One member only: consumed ends at its end.
let (one, made_one) = try decode_pieces(file[..<at], out, 3, 100, multiple = false)
assert(one == first.length and made_one == 4000)
file[at + 5] = 1
assert(failure_of(file[..<at + 16]) == corrupt)
let allowed = try decode(file[..<at], allow_trailing = true)
free(allowed) in memory.heap
assert(failure_of(file[..<at], 8999) == limit)
assert(failure_of(b"") == corrupt)
test "a closed or failed decoder behaves":
var state = Decoder.open()
var out: u8[16]
var code = invalid
_ = state.step(b"\x1f\x8c", out, true) catch failure:
code = failure.code
recover decoder.Step(0, 0, 0, 0)
assert(code == corrupt and state.statistics().failed)
try state.reset()
let packed = try encode(b"abc")
defer free(packed) in memory.heap
let step = try state.step(packed, out, true)
assert(step.status == decoder.finished and (str)out[..<3] == "abc")
state.close()
code = invalid
_ = state.step(packed, out, true) catch failure:
code = failure.code
recover decoder.Step(0, 0, 0, 0)
assert(code == closed)