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