Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-compress

Source of release 0.9.0

0.9.0 / src / zip / tests.lucb

#==============================================================================================
#
#   zip/tests - The module's tests, over archives built in memory
#
#   DESCRIPTION:
#       A small writer lays out local headers, data and a central directory the way
#       zip tools do, so each test can build an archive, then damage one field of it.
#
#==============================================================================================

## One entry for `build`: its name, its bytes, and whether to deflate them.
struct Item:
    var name: str
    var data: const u8[]
    var deflate: bool

## Appends little-endian fields to a caller's buffer.
struct Writer:
    var out: u8[]
    var at: usize

    func put16(value: u32):
        self.out[self.at] = (u8)value
        self.out[self.at + 1] = (u8)(value >> 8)
        self.at += 2

    func put32(value: u32):
        self.put16(value & 65535)
        self.put16(value >> 16)

    func put(data: const u8[]):
        if data.length > 0:
            memory.copy(self.out[self.at..], data, data.length)
        self.at += data.length

## The archive of `items` written into `out`, with `comment` after its end record;
## returns its length.
func build(out: u8[], items: const Item[], comment: str = "") -> usize!:
    var w = Writer(out = out, at = 0)
    var offsets: usize[8]
    var packed_sizes: usize[8]
    var packed: u8[4096]
    for index in 0..<items.length:
        let item = items[index]
        offsets[index] = w.at
        var size = item.data.length
        if item.deflate:
            size = try flate.deflate_raw(item.data, 6, packed, true)
        packed_sizes[index] = size
        w.put32(0x04034b50)
        w.put16(20)
        w.put16(0)
        w.put16(8 if item.deflate else 0)
        w.put32(0)
        w.put32(flate.crc32(item.data))
        w.put32((u32)size)
        w.put32((u32)item.data.length)
        w.put16((u32)item.name.length)
        w.put16(0)
        w.put(item.name.bytes)
        w.put(packed[..<size] if item.deflate else item.data)
    let directory = w.at
    for index in 0..<items.length:
        let item = items[index]
        w.put32(0x02014b50)
        w.put16(20)
        w.put16(20)
        w.put16(0)
        w.put16(8 if item.deflate else 0)
        w.put32(0)
        w.put32(flate.crc32(item.data))
        w.put32((u32)packed_sizes[index])
        w.put32((u32)item.data.length)
        w.put16((u32)item.name.length)
        w.put16(0)
        w.put16(0)
        w.put16(0)
        w.put16(0)
        w.put32(0)
        w.put32((u32)offsets[index])
        w.put(item.name.bytes)
    let directory_size = w.at - directory
    w.put32(0x06054b50)
    w.put16(0)
    w.put16(0)
    w.put16((u32)items.length)
    w.put16((u32)items.length)
    w.put32((u32)directory_size)
    w.put32((u32)directory)
    w.put16((u32)comment.length)
    w.put(comment.bytes)
    return w.at

let text: str = "brush settings, brush settings, brush settings and a shape and a grain"

## Whether opening `data` fails with `code`.
func open_fails(data: const u8[], code: ErrorCode) -> bool:
    var archive = open(data) catch failure:
        return failure.code == code
    archive.close()
    return false

## Whether reading `name` from `data` fails with `code`.
func read_fails(data: const u8[], name: str, code: ErrorCode, max_size: usize = default_entry_limit) -> bool:
    var archive = open(data) catch failure:
        return false
    defer archive.close()
    let bytes = archive.read(name, max_size) catch failure:
        return failure.code == code
    free(bytes) in memory.heap
    return false

## The central directory's offset in the archive `data`.
func directory_of(data: const u8[]) -> usize:
    return (usize)read32(data, data.length - 22 + 16)

test "stored and deflated entries list and read back, with a comment after the end":
    let items: Item[3] = [Item(name = "Brush.archive", data = text.bytes, deflate = true),
                          Item(name = "QuickLook/", data = b"", deflate = false),
                          Item(name = "Shape.png", data = b"PNG stored bytes", deflate = false)]
    var buffer: u8[4096]
    let length = try build(buffer, items, "a comment")
    var archive = try open(buffer[..<length])
    defer archive.close()
    assert(archive.count == 3)
    assert(archive.entries[0].name == "Brush.archive" and archive.entries[0].method == method_deflated)
    assert(archive.entries[0].size == text.length and archive.entries[0].compressed_size < text.length)
    assert(archive.entries[1].is_directory() and not archive.entries[2].is_directory())
    assert(archive.has("Shape.png") and not archive.has("shape.png"))
    let settings = try archive.read("Brush.archive")
    defer free(settings) in memory.heap
    assert((str)settings == text)
    let shape = try archive.read("Shape.png")
    defer free(shape) in memory.heap
    assert((str)shape == "PNG stored bytes")
    let folder = try archive.read("QuickLook/")
    defer free(folder) in memory.heap
    assert(folder.length == 0)

test "an empty archive has no entries":
    let items: Item[1] = [Item(name = "unused", data = b"", deflate = false)]
    var buffer: u8[64]
    let length = try build(buffer, items[..<0])
    var archive = try open(buffer[..<length])
    assert(archive.count == 0 and not archive.has("x"))
    archive.close()

test "missing entries, limits and a damaged CRC fail with their codes":
    let items: Item[2] = [Item(name = "a", data = text.bytes, deflate = true), Item(name = "b", data = b"stored", deflate = false)]
    var buffer: u8[4096]
    let length = try build(buffer, items)
    let data = buffer[..<length]
    assert(read_fails(data, "c", missing))
    assert(read_fails(data, "a", limit, 10))
    var refused = false
    var limited = open(data, 1) catch failure:
        refused = failure.code == limit
        recover Archive(data = data, count = 0)
    limited.close()
    assert(refused)
    # Flip a stored byte: the CRC no longer matches.
    let stored_at = (usize)read32(data, directory_of(data) + 46 + 1 + 42) + 30 + 1
    buffer[stored_at] ^= 1
    assert(read_fails(data, "b", corrupt))
    buffer[stored_at] ^= 1
    # Damage the deflate stream's block type (reserved type 3).
    let deflated_at = (usize)read32(data, directory_of(data) + 42) + 30 + 1
    buffer[deflated_at] = 0xFF
    assert(read_fails(data, "a", corrupt))

test "encryption, other methods, ZIP64 and multi-disk archives are refused":
    let items: Item[1] = [Item(name = "a", data = b"stored", deflate = false)]
    var buffer: u8[4096]
    let length = try build(buffer, items)
    let data = buffer[..<length]
    let central = directory_of(data)
    buffer[central + 8] = 1
    assert(read_fails(data, "a", unsupported))
    buffer[central + 8] = 0
    buffer[central + 10] = 12
    assert(read_fails(data, "a", unsupported))
    buffer[central + 10] = 0
    for i in 0..<(usize)4:
        buffer[central + 24 + i] = 0xFF
    assert(open_fails(data, unsupported))
    for i in 0..<(usize)4:
        buffer[central + 24 + i] = 0
    buffer[central + 24] = 6
    let end = length - 22
    buffer[end + 8] = 0xFF
    buffer[end + 9] = 0xFF
    buffer[end + 10] = 0xFF
    buffer[end + 11] = 0xFF
    assert(open_fails(data, unsupported))
    buffer[end + 8] = 1
    buffer[end + 9] = 0
    buffer[end + 10] = 1
    buffer[end + 11] = 0
    buffer[end + 4] = 1
    assert(open_fails(data, unsupported))
    buffer[end + 4] = 0
    var archive = try open(data)
    assert(archive.count == 1)
    archive.close()

test "truncated and foreign bytes fail cleanly":
    let items: Item[1] = [Item(name = "a", data = text.bytes, deflate = true)]
    var buffer: u8[4096]
    let length = try build(buffer, items)
    assert(open_fails(b"", invalid))
    assert(open_fails(b"PK not really an archive at all", invalid))
    assert(open_fails(buffer[..<length - 1], invalid))
    # The directory claims to start past its end record.
    let end = length - 22
    buffer[end + 16] = (u8)(length & 255)
    buffer[end + 17] = (u8)(length >> 8)
    assert(open_fails(buffer[..<length], corrupt))
    # Every shorter prefix of a valid archive fails without reading past it.
    let fresh = try build(buffer, items)
    for cut in 0..<fresh:
        var archive = open(buffer[..<cut]) catch failure:
            continue
        archive.close()
        assert(false)

test "stored archives align their data and read back":
    let files: StoredFile[3] = [
        StoredFile(name = "root.usdc", data = b"PXR-USDC and some bytes"),
        StoredFile(name = "textures/a.png", data = b"\x89PNG"),
        StoredFile(name = "empty.txt", data = b""),
    ]
    let size = stored_size(files, 64)
    let output = try new u8[size] --- in memory.heap
    defer free(output) in memory.heap
    let written = try write_stored(files, 64, output)
    assert(written == size)
    var archive = try open(output[..<written])
    defer archive.close()
    assert(archive.count == 3)
    for index in 0..<3:
        let entry = archive.find(files[index].name) else trap("missing entry")
        let data = try archive.stored_bytes(entry)
        assert(data.length == files[index].data.length)
        if data.length > 0: assert(((usize)data.data - (usize)output.data) % 64 == 0)
        let copy = try archive.extract(entry)
        defer free(copy) in memory.heap
        for at in 0..<copy.length: assert(copy[at] == files[index].data[at])