dymokomi/luce-prism
Source of release 0.6.1
0.6.1 / tests / compatibility / state.lucb
from luce_prism import prism
import interop
import memory
import strings
from compatibility.serialization import roundtrip
func seed() -> interop.Reference[prism.Document]!:
return try prism.Document.parse("#prisma 4.0\ndef group \"s\" { def object \"a\" { float3 c = (1,0,0) string note = \"hi\" } def material \"m\" { float3 out = (1,1,1) } } connect </s/a.c> = </s/m.out>")
func copy_is_isolated_across_every_mutator() -> !:
let doc = try seed()
defer doc.release()
let snapshot = try doc.value().copy()
defer snapshot.release()
let expected = try seed()
defer expected.release()
let before = try snapshot.value().encode()
defer before.release()
try doc.value().add("/s/b", "object")
_ = try doc.value().add_child("/s", "anon")
let value = try prism.Value.number(9.0)
defer value.release()
try doc.value().set("/s/a", "c", value)
try doc.value().set_metadata("/s/a", "note", "changed")
try doc.value().connect("/s/m.out", "/s/b.in")
try doc.value().disconnect("/s/a.c")
try doc.value().rename("/s/a", "/s/a2")
try doc.value().remove("/s/m")
try doc.value().mark_deleted("/ghost")
var empty: str[]
try doc.value().reorder("/s", empty)
let fragment = try prism.Document.parse("#prisma 4.0\ndef thing \"p\" {}")
defer fragment.release()
let roots = try doc.value().instantiate(fragment, "/s")
defer roots.release()
let after = try snapshot.value().encode()
defer after.release()
assert(before.value().bytes() == after.value().bytes())
assert(try snapshot.value().equals(expected) and not try doc.value().equals(snapshot))
func mutating_a_copy_leaves_the_original_intact() -> !:
let original = try seed()
defer original.release()
let copy = try original.value().copy()
defer copy.release()
let before = try original.value().encode()
defer before.release()
try copy.value().add("/s/extra", "object")
let value = try prism.Value.number(2.0)
defer value.release()
try copy.value().set("/s/a", "c", value)
let after = try original.value().encode()
defer after.release()
assert(before.value().bytes() == after.value().bytes())
assert(not try copy.value().equals(original))
func equality_and_ids_hold_across_copy() -> !:
let original = try seed()
defer original.release()
let copy = try original.value().copy()
defer copy.release()
assert(try copy.value().equals(original))
assert(copy.value().element_id("/s/a") == original.value().element_id("/s/a"))
func snapshot_chain_stays_independent() -> !:
let doc = try seed()
defer doc.release()
let first = try doc.value().copy()
defer first.release()
let before = try first.value().encode()
defer before.release()
try doc.value().add("/s/x", "object")
let one = try prism.Value.number(1.0)
defer one.release()
try doc.value().set("/s/x", "v", one)
let second = try doc.value().copy()
defer second.release()
let middle = try second.value().encode()
defer middle.release()
let two = try prism.Value.number(2.0)
defer two.release()
try doc.value().set("/s/x", "v", two)
try doc.value().remove("/s/m")
let first_after = try first.value().encode()
defer first_after.release()
let second_after = try second.value().encode()
defer second_after.release()
assert(before.value().bytes() == first_after.value().bytes())
assert(middle.value().bytes() == second_after.value().bytes())
assert(not try first.value().equals(second) and first.value().contains("/s/m") and second.value().contains("/s/x"))
func referenced(asset: str, target: str) -> !:
let doc = try prism.Document.parse("#prisma 4.0\ndef object \"x\" { float3 color = (0,0,1) }")
defer doc.release()
try doc.value().set_metadata("/x", "reference", asset)
if target.length > 0:
try doc.value().set_metadata("/x", "referencePath", target)
let encoded = try doc.value().encode(prism.Encoding.text)
defer encoded.release()
let text = try encoded.value().text()
assert(strings.contains(text, "reference \"") and not strings.contains(text, "string reference"))
assert(strings.contains(text, "float3 color"))
for mode in 0..<(usize)5:
let back = try roundtrip(doc, mode)
defer back.release()
assert(try back.value().metadata("/x", "reference") == asset)
if target.length > 0:
assert(try back.value().metadata("/x", "referencePath") == target)
# A referenced filename is data; decoding never attempts to open it.
assert(back.value().element_count() == 1)
func reference_directive_round_trips() -> !:
try referenced("car.prisma", "")
func reference_with_inner_element_path() -> !:
try referenced("parts.prisma", "/parts/bolt")
func reference_authored_programmatically() -> !:
try referenced("parts.prism", "/parts/bolt")
func reference_wildcard_round_trips_in_text() -> !:
try referenced("parts.prisma", "/parts/*")
func legacy_string_reference_still_parses() -> !:
let doc = try prism.Document.parse("#prisma 3.0\ndef object \"a\" { string reference = \"car.prisma\" }")
defer doc.release()
assert(try doc.value().metadata("/a", "reference") == "car.prisma")
let back = try roundtrip(doc, 0)
defer back.release()
func wired(reverse: bool) -> interop.Reference[prism.Document]!:
let doc = try prism.Document.parse("#prisma 4.0\ndef \"m1\" { float out = 1 } def \"m2\" { float out = 2 } def \"a\" {} def \"b\" {} def \"c\" {}")
errdefer doc.release()
let slots: str[3] = ["/a.v","/b.v","/c.v"]
for i in 0..<slots.length:
try doc.value().connect("/m1.out", slots[2 - i] if reverse else slots[i])
return doc
func identical(a: interop.Reference[prism.Document], b: interop.Reference[prism.Document]) -> !:
assert(try a.value().equals(b))
for compressed in [false, true]:
let first = try a.value().encode(prism.Encoding.binary, compressed)
defer first.release()
let second = try b.value().encode(prism.Encoding.binary, compressed)
defer second.release()
assert(first.value().bytes() == second.value().bytes())
func binary_is_deterministic_across_connection_order() -> !:
let forward = try wired(false)
defer forward.release()
let reverse = try wired(true)
defer reverse.release()
try identical(forward, reverse)
func binary_is_deterministic_after_resourcing() -> !:
let churned = try wired(false)
defer churned.release()
let direct = try wired(false)
defer direct.release()
try churned.value().connect("/m2.out", "/a.v")
try churned.value().connect("/m1.out", "/a.v")
try identical(churned, direct)
func binary_round_trip_is_idempotent_and_stable() -> !:
let original = try wired(true)
defer original.release()
let back = try roundtrip(original, 1)
defer back.release()
try identical(original, back)
func layer() -> interop.Reference[prism.Document]!:
let doc = try prism.Document.parse("#prisma 4.0\ndef group \"world\" { def object \"sphere\" { float radius = 2 float3 albedo = (1,0,0) string label = \"the sphere\" float radius.timeSamples = { 0: 2, 24: 5 } } over material \"mat\" { float gain = 0.5 string note = \"tweaked\" unset oldParam unset string oldNote } } connect </world/sphere.albedo> = </world/mat.out> delete \"/world/junk\" disconnect \"/world/sphere.radius\"")
return doc
func text_and_binary_round_trip_identically() -> !:
let doc = try layer()
defer doc.release()
for mode in 0..<(usize)5:
let back = try roundtrip(doc, mode)
defer back.release()
func overlay_tombstones_survive_each_codec_specifically() -> !:
let doc = try layer()
defer doc.release()
let base = try prism.Document.parse("#prisma 4.0\ndef group \"world\" { def object \"sphere\" {} def \"junk\" {} def material \"mat\" { float oldParam = 1 float retained = 4 string oldNote = \"old\" } } connect </world/sphere.radius> = </world/mat.out>")
defer base.release()
for mode in 0..<(usize)5:
let back = try roundtrip(doc, mode)
defer back.release()
let composed = try base.value().overlay(back)
defer composed.release()
assert(not composed.value().contains("/world/junk"))
assert(not composed.value().has_property("/world/mat", "oldParam"))
assert(not composed.value().has_metadata("/world/mat", "oldNote"))
assert(composed.value().has_property("/world/mat", "retained"))
assert(composed.value().connection_count() == 1)
func query() -> interop.Reference[prism.Query]!:
let doc = try prism.Document.parse("#prisma 4.0\ndef table \"t\" { def row \"a\" { float v = 10 } def row \"b\" { float v = 20 } def row \"c\" {} }")
defer doc.release()
return try interop.Reference[prism.Query].adopt(try new prism.Query(doc, "/t/*") in memory.heap, prism.query_type, memory.heap)
func is_null_and_not_null() -> !:
let all = try query()
defer all.release()
let absent = try prism.Predicate.is_null("v")
defer absent.release()
let present = try prism.Predicate.exists("v")
defer present.release()
let nulls = try all.value().filter(absent)
defer nulls.release()
let nonnulls = try all.value().filter(present)
defer nonnulls.release()
assert(try nulls.value().one() == "/t/c" and try nonnulls.value().count() == 2)
func three_valued_comparison() -> !:
let all = try query()
defer all.release()
let ten = try prism.Value.number(10.0)
defer ten.release()
let neq = try prism.Predicate.field("v", prism.Comparison.not_equal, ten)
defer neq.release()
let eq = try prism.Predicate.field("v", prism.Comparison.equal, ten)
defer eq.release()
let negated = try eq.value().negate()
defer negated.release()
let present_unequal = try all.value().filter(neq)
defer present_unequal.release()
let complement = try all.value().filter(negated)
defer complement.release()
assert(try present_unequal.value().one() == "/t/b" and try complement.value().count() == 2)
func aggregates_skip_null() -> !:
let all = try query()
defer all.release()
assert(try all.value().count() == 3)
assert(try all.value().aggregate("v", prism.Aggregate.sum) == 30.0)
assert(try all.value().aggregate("v", prism.Aggregate.average) == 15.0)
func wildcard_priority_and_root_assets() -> !:
let doc = try wired(false)
defer doc.release()
try doc.value().connect_pattern("/m2.out", "/*.other")
try doc.value().connect_pattern("/m1.out", "/a*.other")
assert(try doc.value().source("/a.other") == "/m2.out")
for mode in 0..<(usize)5:
let back = try roundtrip(doc, mode)
defer back.release()
assert(try back.value().source("/a.other") == "/m2.out")
try doc.value().set_asset("/", b"root\0bytes")
let package = try roundtrip(doc, 3)
defer package.release()
let root = try package.value().asset("/")
defer root.release()
assert(root.value().bytes() == b"root\0bytes")
pub func run() -> !:
try asset_diffs_do_not_silently_drop_changes()
try copy_is_isolated_across_every_mutator()
try mutating_a_copy_leaves_the_original_intact()
try equality_and_ids_hold_across_copy()
try snapshot_chain_stays_independent()
try reference_directive_round_trips()
try reference_with_inner_element_path()
try reference_authored_programmatically()
try reference_wildcard_round_trips_in_text()
try legacy_string_reference_still_parses()
try binary_is_deterministic_across_connection_order()
try binary_is_deterministic_after_resourcing()
try binary_round_trip_is_idempotent_and_stable()
try text_and_binary_round_trip_identically()
try overlay_tombstones_survive_each_codec_specifically()
try is_null_and_not_null()
try three_valued_comparison()
try aggregates_skip_null()
try wildcard_priority_and_root_assets()
print("PASS 18 copy, reference, deterministic serialization, codec parity and null cases")
func asset_diffs_do_not_silently_drop_changes() -> !:
let base = try prism.Document.parse("#prisma 4.0\ndef image \"image\" { uint8[2] pixels = [0,255] }")
defer base.release()
try base.value().set_asset("/image", b"attachment")
let target = try base.value().copy()
defer target.release()
let pixels = try prism.Value.array(prism.DType.uint8, [2], b"a\0")
defer pixels.release()
try target.value().set("/image", "pixels", pixels)
let delta = try base.value().diff(target)
defer delta.release()
let replayed = try base.value().overlay(delta)
defer replayed.release()
assert(try replayed.value().equals(target))
var log = try prism.EventLog(base)
defer log.close()
for operation in 0..<3:
let changed = try base.value().copy()
defer changed.release()
if operation == 0:
try changed.value().set_asset("/image", b"changed")
elif operation == 1:
try changed.value().remove_asset("/image")
else:
try changed.value().set_asset("/other", b"added")
var failed = false
_ = log.commit(changed) catch failure:
assert(failure.code == prism.unsupported)
failed = true
recover 0
assert(failed and log.head_offset() == 0 and log.layer_count() == 0)
let head = try log.head()
defer head.release()
assert(try head.value().equals(base))