Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.0

0.6.0 / tests / main.lucb

from luce_prism import prism
import memory
import ownership
import interop
from luce_std import files
import compatibility.tables as table_tests

func rejected(bytes: const u8[]) -> !:
    let result: interop.Reference[prism.Document]? = prism.Document.decode(bytes) catch failure:
        assert(failure.code == prism.invalid or failure.code == prism.limit_exceeded or failure.code == prism.unsupported)
        recover none
    if let document = result:
        document.release()
        assert(false)

func paths():
    assert(prism.valid_path("/world/[2]/node.value"))
    assert(prism.valid_path("/"))
    assert(not prism.valid_path("/world/"))
    assert(not prism.valid_path("/world.foo/bar"))
    assert(not prism.valid_path("/world..foo"))
    assert(not prism.valid_path("/../world"))
    assert(not prism.valid_path("/world/[x]"))
    assert(prism.is_descendant("/world/a.value", "/world"))
    assert(not prism.is_descendant("/worldwide/a", "/world"))
    assert(prism.parent_path("/world/node.value") == "/world")

func values() -> !:
    let integer = try prism.Value.integer(-9223372036854775807 - 1)
    defer integer.release()
    assert(try integer.value().integer_at() == -9223372036854775807 - 1)
    let unsigned = try prism.Value.unsigned(18446744073709551615)
    defer unsigned.release()
    assert(try unsigned.value().unsigned_at() == 18446744073709551615)
    let grid = try prism.Value.numbers([2, 2], [1.0, 2.0, 3.0, 4.0], prism.DType.float16)
    defer grid.release()
    assert(grid.value().rank() == 2 and try grid.value().dimension(1) == 2)
    assert(try grid.value().number_at(3) == 4.0)
    let names = try prism.Value.strings([2], ["alpha", "beta"])
    defer names.release()
    assert(try names.value().text_at(1) == "beta")
    let empty = try prism.Value.array(prism.DType.uint8, [0, 3], b"")
    defer empty.release()
    assert(empty.value().count() == 0 and empty.value().rank() == 2)
    let invalid_value: interop.Reference[prism.Value]? = prism.Value.numbers([3], [1.0]) catch failure:
        assert(failure.code == prism.invalid)
        recover none
    if let unexpected = invalid_value:
        unexpected.release()
        assert(false)

func roundtrips() -> !:
    let text = try prism.Document.load("tests/fixtures/core.prisma")
    defer text.release()
    let expected = try text.value().encode()
    defer expected.release()
    let fixture_file = try files.read("tests/fixtures/core.prism")
    defer fixture_file.release()
    let fixture = fixture_file.value
    assert(expected.value().bytes() == fixture)
    for path in ["tests/fixtures/core.prism", "tests/fixtures/core-compressed.prism"]:
        let parsed = try prism.Document.load(path)
        defer parsed.release()
        let actual = try parsed.value().encode()
        defer actual.release()
        assert(actual.value().bytes() == fixture)
        let source = try parsed.value().encode(prism.Encoding.text)
        defer source.release()
        let again = try prism.Document.parse(try source.value().text())
        defer again.release()
        let binary = try again.value().encode()
        defer binary.release()
        assert(binary.value().bytes() == fixture)
    let packed = try text.value().encode(prism.Encoding.binary, true)
    defer packed.release()
    assert(packed.value().size() < expected.value().size())
    let inflated = try prism.Document.decode(packed.value().bytes())
    defer inflated.release()
    let same = try inflated.value().encode()
    defer same.release()
    assert(same.value().bytes() == fixture)
    let resolved = try text.value().eval("/world/target.input", 5.0)
    defer resolved.release()
    assert(try resolved.value().number_at() == 10.0)
    let archive = try prism.Document.load("tests/fixtures/core-package.prism")
    defer archive.release()
    assert(archive.value().asset_count() == 1)
    let asset = try archive.value().asset("/world/source")
    defer asset.release()
    assert(asset.value().bytes() == b"\0\xff\x01")
    let encoded_archive = try archive.value().encode(prism.Encoding.package)
    defer encoded_archive.release()
    let original_archive_file = try files.read("tests/fixtures/core-package.prism")
    defer original_archive_file.release()
    let original_archive = original_archive_file.value
    assert(encoded_archive.value().bytes() == original_archive)
    # A plain document encode cannot silently discard package assets.
    let lost_assets: interop.Reference[prism.Blob]? = archive.value().encode() catch failure:
        assert(failure.code == prism.invalid)
        recover none
    if let unexpected = lost_assets:
        unexpected.release()
        assert(false)

func mutations() -> !:
    var document = try prism.Document()
    defer document.close()
    try document.add("/a", "group")
    try document.add("/a/node", "node")
    try document.add("/b", "group")
    try document.add("/out", "node")
    let value = try prism.Value.integer(4)
    try document.set("/a/node", "value", value)
    value.release()
    try document.connect("/a/node.value", "/out.input")
    try document.set_asset("/a/node", b"asset")
    try document.rename("/a/node", "/b/node")
    assert(document.contains("/b/node") and not document.contains("/a/node"))
    assert(try document.source("/out.input") == "/b/node.value")
    let asset = try document.asset("/b/node")
    defer asset.release()
    assert(try asset.value().text() == "asset")
    let retained = try document.get("/b/node", "value")
    defer retained.release()
    let encoded = try document.encode(prism.Encoding.package)
    defer encoded.release()
    let decoded = try prism.Document.decode(encoded.value().bytes())
    defer decoded.release()
    assert(decoded.value().contains("/b/node"))
    try document.remove("/b")
    assert(not document.contains("/b/node") and document.connection_count() == 0 and document.asset_count() == 0)
    assert(try retained.value().integer_at() == 4)
    let one = try prism.Value.number(0.0)
    defer one.release()
    let two = try prism.Value.number(10.0)
    defer two.release()
    try document.set("/out", "x", one)
    try document.set_sample("/out", "x", 0.0, one)
    try document.set_sample("/out", "x", 10.0, two)
    let middle = try document.resolve("/out", "x", 2.5)
    defer middle.release()
    assert(try middle.value().number_at() == 2.5)
    try document.connect("/out.y", "/out.x")
    try document.connect("/out.x", "/out.y")
    let cycle = try document.eval("/out.x")
    defer cycle.release()
    assert(try cycle.value().number_at() == 0.0)
    assert(cycle.value().dtype() == prism.DType.float32)

func malformed() -> !:
    for source in ["", "#prisma 9.0\n", "#prisma 4.0\ndef x {", "#prisma 4.0\ndef x { uint8 p = 256 }", "#prisma 4.0\ndef x { int32[2,2] p = [[1,2],[3]] }", "#prisma 4.0\ndef x { str p = \"bad }", "#prisma 4.0\ndef x { float64[4294967295,4294967295,2] p = [] }", "#prisma 4.0\ndef x { str p = true }"]:
        try rejected(source.bytes)
    let bytes_file = try files.read("tests/fixtures/core.prism")
    defer bytes_file.release()
    let bytes = bytes_file.value
    # Every truncated prefix before required sections must fail (trailing sections
    # are optional, so test only up to half of this crate).
    for end in 0..<bytes.length // 2:
        try rejected(bytes[..<end])
    try rejected(b"PRSMC\0\x04\0\x02\0")
    try rejected(b"PRSMC\0\x04\0\x01\0\xff\xff\xff\xff\xff\xff\xff\xff")
    try rejected(b"PRSMC\0\x04\0\0\0\xff\xff\xff\xff")
    try rejected(b"PRSMZ\0\x04\0\0\0\0\0\0\0")

struct Tracker: memory.Allocator:
    var upstream: memory.Allocator
    var live: usize
    var remaining: usize?

    pub func allocate(size: usize, alignment: usize) -> u8[]?:
        if let remaining = self.remaining:
            if remaining == 0:
                return none
            self.remaining = remaining - 1
        let block = self.upstream.allocate(size, alignment) else return none
        self.live += 1
        return block

    pub func resize(block: u8[], size: usize) -> bool:
        return self.upstream.resize(block, size)

    pub func release(block: u8[]):
        assert(self.live > 0)
        self.live -= 1
        self.upstream.release(block)

func allocations(tracker: Tracker*) -> !:
    let input = "#prisma 4.0\ndef node \"a\" { float64 x = 1 float64 x.timeSamples = {0: 1, 2: 3} str \"escaped\\tname\" = \"owned\\nvalue\" }\n"
    var successes: usize = 0
    for stage in 0..<(usize)240:
        tracker.remaining = stage
        let document: interop.Reference[prism.Document]? = prism.Document.parse(input) catch failure:
            assert(failure.code == memory.exhausted)
            recover none
        if let value = document:
            value.release()
            successes += 1
        tracker.remaining = none
        ownership.collect()
        assert(tracker.live == 0)
    assert(successes > 0 and successes < 240)

func restore(allocator: memory.Allocator):
    memory.heap = allocator

pub func main(arguments: str[]) -> i32!:
    paths()
    try text_edges()
    try values()
    try roundtrips()
    try mutations()
    try malformed()
    try table_tests.run()
    ownership.collect()
    var tracker = Tracker(upstream = memory.heap)
    defer restore(tracker.upstream)
    memory.heap = &tracker
    try allocations(&tracker)
    print("PASS Prism values, C++ fixtures, encodings, animation, mutation, malformed input and allocation failures")
    return 0

func text_edges() -> !:
    assert(not prism.valid_path("/a\0b"))
    assert(prism.detect(b"\xff\xfe\xff\xff\xff\xff") == prism.Encoding.unknown)
    let doc = try prism.Document.parse("#prisma 4.0\ndef x { str[] tokens = [\"]\", \"}\", \"(\"] bool[2] flags = [true, false] }")
    defer doc.release()
    let tokens = try doc.value().get("/[0]", "tokens")
    defer tokens.release()
    assert(tokens.value().count() == 3)
    assert(try tokens.value().text_at(0) == "]")
    let encoded = try doc.value().encode(prism.Encoding.text)
    defer encoded.release()
    let decoded = try prism.Document.parse(try encoded.value().text())
    defer decoded.release()
    let binary = try doc.value().encode()
    defer binary.release()
    let other = try decoded.value().encode()
    defer other.release()
    assert(binary.value().bytes() == other.value().bytes())
    try rejected("#prisma 4.0\ndef x { int32[1] a = \"[\" 1 \"]\" }".bytes)
    # Names must stay valid across lookahead and later escaped-string allocations.
    let escaped = try prism.Document.parse("#prisma 4.0\ndef \"node\\ttype\" \"a\" { str \"key\\tname\" = \"first\\nvalue\" str other = \"next\\tvalue\" }")
    defer escaped.release()
    assert(try escaped.value().type_at("/a") == "node\ttype")
    let named = try escaped.value().get("/a", "key\tname")
    defer named.release()
    assert(try named.value().text_at() == "first\nvalue")
    try rejected("#prisma 4.0\ndef x { str p = \"value\" > }".bytes)
    try rejected("#prisma 4.0\ndef x { str p = \"value\" } \"unterminated".bytes)