Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-usd

Source of release 0.9.2

0.9.2 / tests / checks / usdc_checks.lucb

## The usdc reader: crates OpenUSD wrote (tests/fixtures/usdc, made by
## usdcat from our layers) read into layers that print as usdcat prints
## them; the integer coding round-trips; damaged crates fail cleanly.
import memory
from luce_usd.kernel import Names, LayerData, read_usda, read_usdc, write_usda, write_usdc, read_file, decode_integers, encode_integers, encoded_bound, invalid, unsupported
from luce_geocore.core.growing import Growing
import strings

pub func fixtures() -> !:
    try fixture("values")
    try fixture("properties")
    try fixture("composition")
    try fixture("arrays")

## Each fixture alone, so allocation failure reaches every one of them.
pub func values_fixture() -> !: try fixture("values")

pub func properties_fixture() -> !: try fixture("properties")

pub func composition_fixture() -> !: try fixture("composition")

pub func arrays_fixture() -> !: try fixture("arrays")

func fixture(name: str) -> !:
    var buffer: u8[256]
    let crate = try read_file(try strings.format(buffer, f"tests/fixtures/usdc/{name}.usdc"))
    defer free(crate) in memory.heap
    var expected_buffer: u8[256]
    let expected = try read_file(try strings.format(expected_buffer, f"tests/fixtures/usdc/{name}.expected.usda"))
    defer free(expected) in memory.heap
    var names = try Names()
    defer names.close()
    var layer = try LayerData(&names)
    defer layer.close()
    try read_usdc(crate, &layer)
    var out = Growing[u8]()
    defer out.close()
    try write_usda(&layer, &out)
    if (str)out.view() != (str)expected:
        print(f"crate fixture {name} prints differently:")
        print((str)out.view())
    assert((str)out.view() == (str)expected)

## Encode then decode integers of both widths, with every code in play.
pub func integers() -> !:
    let count: usize = 1000
    var values = try new i64[count] --- in memory.heap
    defer free(values) in memory.heap
    var state: u64 = 7
    for index in 0..<count:
        state = state *% 6364136223846793005 +% 1442695040888963407
        let pick = (state >> 60) & 3
        var step: i64 = 1
        if pick == 1: step = (i64)((state >> 20) & 0xFF) - 128
        elif pick == 2: step = (i64)((state >> 20) & 0xFFFF) - 32768
        elif pick == 3: step = (i64)((state >> 20) & 0xFFFFFFF) - 134217728
        values[index] = (values[index - 1] if index > 0 else 0) + step
    let widths: usize[2] = [4, 8]
    for width in widths:
        let raw = try new u8[count * width] --- in memory.heap
        defer free(raw) in memory.heap
        for index in 0..<count:
            if width == 4: memory.write[i32]((void*)&raw[index * 4], (i32)values[index])
            else: memory.write[i64]((void*)&raw[index * 8], values[index] * 1000003)
        let encoded = try new u8[encoded_bound(count, width)] --- in memory.heap
        defer free(encoded) in memory.heap
        let length = try encode_integers(raw, count, width, encoded)
        let back = try new u8[count * width] --- in memory.heap
        defer free(back) in memory.heap
        try decode_integers(encoded[..<length], count, width, back)
        for index in 0..<raw.length: assert(back[index] == raw[index])

## Truncated and damaged crates fail with invalid or unsupported, or read;
## they never read out of bounds.
pub func damaged() -> !:
    var buffer: u8[256]
    let crate = try read_file(try strings.format(buffer, f"tests/fixtures/usdc/arrays.usdc"))
    defer free(crate) in memory.heap
    let copy = try new u8[crate.length] --- in memory.heap
    defer free(copy) in memory.heap
    var names = try Names()
    defer names.close()
    var cut: usize = 0
    while cut < crate.length:
        try attempt(&names, crate[..<cut])
        cut += 7
    var state: u64 = 99
    for trial in 0..<400:
        memory.copy(copy, crate, crate.length)
        state = state *% 6364136223846793005 +% 1442695040888963407
        let at = (usize)((state >> 16) % (u64)crate.length)
        copy[at] = copy[at] ^ (u8)(1 << (u8)(trial % 8))
        try attempt(&names, copy)

func attempt(names: Names*, data: const u8[]) -> !:
    var layer = try LayerData(names)
    defer layer.close()
    read_usdc(data, &layer) catch failure:
        if failure.code != invalid and failure.code != unsupported:
            print(f"a damaged crate failed with an unexpected code: {failure.message}")
            assert(false)

## Layers written as crates read back to the same text: every usda and
## usdc fixture through write_usdc and read_usdc.
pub func writes() -> !:
    try rewrite("usda", "values", false)
    try rewrite("usda", "properties", false)
    try rewrite("usdc", "arrays", true)
    try rewrite("usdc", "composition", true)
    try rewrite("usdc", "values", true)

func rewrite(folder: str, name: str, crate: bool) -> !:
    var buffer: u8[256]
    let path = try strings.format(buffer, f"tests/fixtures/{folder}/{name}.{folder}")
    let input = try read_file(path)
    defer free(input) in memory.heap
    var expected_buffer: u8[256]
    let expected = try read_file(try strings.format(expected_buffer, f"tests/fixtures/{folder}/{name}.expected.usda"))
    defer free(expected) in memory.heap
    var names = try Names()
    defer names.close()
    var layer = try LayerData(&names)
    defer layer.close()
    if crate: try read_usdc(input, &layer)
    else: try read_usda(input, &layer)
    var written = Growing[u8]()
    defer written.close()
    try write_usdc(&layer, &written)
    var again = try LayerData(&names)
    defer again.close()
    try read_usdc(written.view(), &again)
    var text = Growing[u8]()
    defer text.close()
    try write_usda(&again, &text)
    if (str)text.view() != (str)expected:
        print(f"{name} written as a crate reads back differently:")
        print((str)text.view())
    assert((str)text.view() == (str)expected)