Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.1

0.6.1 / tests / compatibility / store.lucb

## RAM Store plus durable open/reopen through Prism's journal.
from luce_prism import prism, persist
from luce_std import files
import c
import strings
import memory
import interop

var scratch_root: str
var persist_path: str
var database_path: str
var dump_path: str
var persist_buffer: u8[2048]
var database_buffer: u8[2048]
var dump_buffer: u8[2048]
var case_number: usize

pub func run(scratch: str) -> !:
    scratch_root = scratch
    try snapshot_does_not_see_later_commits()
    try snapshot_is_read_only()
    try begin_reads_own_writes()
    try children_include_unbaked_adds()
    try delete_then_add_child_misses()
    try disjoint_commits_succeed()
    try alice_bob_conflict_after_bake()
    try bake_leaves_snapshot_unchanged()
    try memory_limit_refuses_large_set()
    try set_limit_refuses_below_resident()
    try view_cap_is_1024()
    try mount_is_a_separate_identity()
    try mount_rejects_bad_identity()
    try document_facade_sees_unbaked()
    try session_query_reads_tables_in_place()
    try each_child_reads_rows_in_place()
    try persist_budget_counts_chunked_keys()
    try persist_reopen_sees_unbaked_commit()
    try persist_schema_only_root_then_commit()
    try persist_bake_reclaim_survives_reopen()
    try fs_entries_follow_links_and_host_names()
    try fs_make_directory_creates_parents()
    try fs_delete_and_remove_directory_split()
    try fs_remove_all_does_not_follow_links()
    try fs_write_and_dump_per_identity()
    try large_value_lives_in_an_extent()
    try replaced_extents_are_swept_on_open()
    try vm_evicts_baked_payloads_and_faults()
    try vm_pin_holds_subtree_and_set_refuses()
    try vm_reopen_pages_under_limit()
    try vm_query_pages_selected_rows_in()
    print("PASS store: isolation, overlap after bake, children, memory limit, view cap, persist, fs helpers, payload VM")

## A snapshot's query reads the store's tables, baked and unbaked, without a document.
func session_query_reads_tables_in_place() -> !:
    var store = try prism.Store()
    defer store.close()
    let tx = try store.begin()
    defer tx.release()
    try tx.value().add("/box", "folder")
    for uid in 1..<(usize)6:
        var name: u8[32]
        let path = try strings.format(name, f"/box/m{uid}")
        try tx.value().add(path, "message")
        let date = try prism.Value.integer(10 - (i64)uid)
        defer date.release()
        try tx.value().set(path, "date", date)
        let subject = try prism.Value.text("unique" if uid == 3 else "hello")
        defer subject.release()
        try tx.value().set(path, "subject", subject)
    _ = try tx.value().commit()
    _ = try store.bake()
    # A later commit stays unbaked; the query sees it as well.
    let late = try store.begin()
    defer late.release()
    try late.value().add("/box/m6", "message")
    let early = try prism.Value.integer(1)
    defer early.release()
    try late.value().set("/box/m6", "date", early)
    _ = try late.value().commit()
    let snap = try store.snapshot()
    defer snap.release()
    var query = try snap.value().query("/box/*")
    defer query.close()
    assert(try query.count() == 6)
    let ordered = try query.order_by("date")
    defer ordered.release()
    let oldest = try ordered.value().limit(2)
    defer oldest.release()
    let rows = try oldest.value().select()
    defer rows.release()
    assert(rows.value().count() == 2)
    assert(try rows.value().path_at(0) == "/box/m6" and try rows.value().path_at(1) == "/box/m5")
    let newest = try ordered.value().reverse()
    defer newest.release()
    assert(try newest.value().first() == "/box/m1")
    let wanted = try prism.Value.text("unique")
    defer wanted.release()
    let rule = try prism.Predicate.field("subject", prism.Comparison.equal, wanted)
    defer rule.release()
    let unique = try query.filter(rule)
    defer unique.release()
    assert(try unique.value().one() == "/box/m3")
    assert(try query.aggregate("date", prism.Aggregate.sum) == 36.0)
    var everything = try snap.value().query()
    defer everything.close()
    assert(try everything.count() == 7)

## What each_child saw: paths, then each row's fields joined.
struct Seen:
    var paths: u8[512]
    var used: usize

func note_row(context: void*?, row: const prism.RowView*) -> !:
    let seen = (Seen*)(context else error(prism.invalid, "no context"))
    var line: u8[128]
    let date = row.integer("date") else -1
    let read = row.boolean("read") else false
    let subject = row.text("subject") else "-"
    let text = try strings.format(line, f"{row.path()}:{date}:{read}:{subject};")
    for i in 0..<text.length:
        seen.paths[seen.used + i] = text.bytes[i]
    seen.used += text.length

## each_child visits the children of a parent in order, baked and unbaked alike, with
## typed getters and no Value per property.
func each_child_reads_rows_in_place() -> !:
    var store = try prism.Store()
    defer store.close()
    let tx = try store.begin()
    defer tx.release()
    try tx.value().add("/box", "folder")
    for uid in 1..<(usize)3:
        var name: u8[32]
        let path = try strings.format(name, f"/box/m{uid}")
        try tx.value().add(path, "message")
        let date = try prism.Value.integer(100 + (i64)uid)
        defer date.release()
        try tx.value().set(path, "date", date)
        var label: u8[32]
        let subject = try prism.Value.text(try strings.format(label, f"hello {uid}"))
        defer subject.release()
        try tx.value().set(path, "subject", subject)
    let read = try prism.Value.boolean(true)
    defer read.release()
    try tx.value().set("/box/m2", "read", read)
    _ = try tx.value().commit()
    _ = try store.bake()
    let late = try store.begin()
    defer late.release()
    try late.value().add("/box/m3", "message")
    _ = try late.value().commit()
    let snap = try store.snapshot()
    defer snap.release()
    var seen = Seen()
    try snap.value().each_child("/box", note_row, &seen)
    assert((str)seen.paths[..<seen.used] == "/box/m1:101:false:hello 1;/box/m2:102:true:hello 2;/box/m3:-1:false:-;")
    # has: through baked and unbaked commits, without reading the value.
    assert(try snap.value().has("/box/m2", "read") and not try snap.value().has("/box/m1", "read"))
    assert(not try snap.value().has("/box/m3", "date") and not try snap.value().has("/missing", "date"))
    # A write session with changes of its own reads its document instead.
    try late.value().add("/box/m4", "message")
    var refused = false
    late.value().each_child("/box", note_row, &seen) catch failure:
        assert(failure.code == prism.unsupported)
        refused = true
    assert(refused)

func snapshot_does_not_see_later_commits() -> !:
    var store = try prism.Store()
    defer store.close()
    let snap = try store.snapshot()
    defer snap.release()
    let tx = try store.begin()
    defer tx.release()
    try tx.value().add("/users", "directory")
    _ = try tx.value().commit()
    assert(not try snap.value().contains("/users"))
    let after = try store.snapshot()
    defer after.release()
    assert(try after.value().contains("/users"))
    assert(try after.value().type_at("/users") == "directory")

func snapshot_is_read_only() -> !:
    var store = try prism.Store()
    defer store.close()
    let snap = try store.snapshot()
    defer snap.release()
    var refused = false
    snap.value().add("/x", "file") catch failure:
        assert(failure.code == prism.invalid)
        refused = true
    assert(refused)

func begin_reads_own_writes() -> !:
    var store = try prism.Store()
    defer store.close()
    let tx = try store.begin()
    defer tx.release()
    try tx.value().add("/notes", "file")
    let text = try prism.Value.text("hello")
    defer text.release()
    try tx.value().set("/notes", "text", text)
    assert(try tx.value().contains("/notes"))
    let got = try tx.value().get("/notes", "text")
    defer got.release()
    assert(try got.value().text_at() == "hello")
    _ = try tx.value().commit()
    assert(try tx.value().contains("/notes"))

func children_include_unbaked_adds() -> !:
    var store = try prism.Store()
    defer store.close()
    let tx = try store.begin()
    defer tx.release()
    try tx.value().add("/users", "directory")
    try tx.value().add("/users/alice", "directory")
    _ = try tx.value().commit()
    let snap = try store.snapshot()
    defer snap.release()
    let kids = try snap.value().children("/users")
    defer kids.release()
    assert(kids.value().count() == 1)
    assert(try kids.value().at(0) == "/users/alice")

func delete_then_add_child_misses() -> !:
    var store = try prism.Store()
    defer store.close()
    let seed = try store.begin()
    defer seed.release()
    try seed.value().add("/a", "directory")
    try seed.value().add("/a/b", "file")
    _ = try seed.value().commit()
    let del = try store.begin()
    defer del.release()
    try del.value().remove("/a")
    _ = try del.value().commit()
    let add = try store.begin()
    defer add.release()
    try add.value().add("/a/b", "file")
    _ = try add.value().commit()
    let snap = try store.snapshot()
    defer snap.release()
    assert(not try snap.value().contains("/a"))
    assert(not try snap.value().contains("/a/b"))
    let kids = try snap.value().children("/a")
    defer kids.release()
    assert(kids.value().count() == 0)

func disjoint_commits_succeed() -> !:
    var store = try prism.Store()
    defer store.close()
    let alice = try store.begin()
    defer alice.release()
    let bob = try store.begin()
    defer bob.release()
    try alice.value().add("/a", "file")
    try bob.value().add("/b", "file")
    _ = try alice.value().commit()
    _ = try bob.value().commit()
    let snap = try store.snapshot()
    defer snap.release()
    assert(try snap.value().contains("/a") and try snap.value().contains("/b"))

func alice_bob_conflict_after_bake() -> !:
    var store = try prism.Store()
    defer store.close()
    let alice = try store.begin()
    defer alice.release()
    let bob = try store.begin()
    defer bob.release()
    try alice.value().add("/a", "file")
    try bob.value().add("/a", "file")
    _ = try alice.value().commit()
    _ = try store.bake()
    var collided = false
    _ = bob.value().commit() catch failure:
        assert(failure.code == prism.conflict)
        collided = true
        recover -1
    assert(collided)
    let stats = try store.statistics()
    assert(stats.conflicted_commits >= 1)
    let snap = try store.snapshot()
    defer snap.release()
    assert(try snap.value().contains("/a"))

func bake_leaves_snapshot_unchanged() -> !:
    var store = try prism.Store()
    defer store.close()
    let tx = try store.begin()
    defer tx.release()
    try tx.value().add("/keep", "file")
    let value = try prism.Value.number(1.0)
    defer value.release()
    try tx.value().set("/keep", "x", value)
    _ = try tx.value().commit()
    let snap = try store.snapshot()
    defer snap.release()
    let later = try store.begin()
    defer later.release()
    let nine = try prism.Value.number(9.0)
    defer nine.release()
    try later.value().set("/keep", "x", nine)
    _ = try later.value().commit()
    _ = try store.bake()
    let old = try snap.value().get("/keep", "x")
    defer old.release()
    assert(try old.value().number_at() == 1.0)
    let baked = try store.snapshot()
    defer baked.release()
    let now = try baked.value().get("/keep", "x")
    defer now.release()
    assert(try now.value().number_at() == 9.0)

func memory_limit_refuses_large_set() -> !:
    var store = try prism.Store(4096)
    defer store.close()
    let tx = try store.begin()
    defer tx.release()
    try tx.value().add("/blob", "file")
    var payload: u8[5000]
    for i in 0..<payload.length:
        payload[i] = 1
    let shape: i64[1] = [5000]
    let value = try prism.Value.array(prism.DType.uint8, shape, payload)
    defer value.release()
    var refused = false
    tx.value().set("/blob", "bytes", value) catch failure:
        assert(failure.code == prism.limit_exceeded)
        refused = true
    assert(refused)

func set_limit_refuses_below_resident() -> !:
    var store = try prism.Store()
    defer store.close()
    let tx = try store.begin()
    defer tx.release()
    try tx.value().add("/a", "file")
    _ = try tx.value().commit()
    let stats = try store.statistics()
    assert(stats.resident > 0)
    var refused = false
    store.set_limit(1) catch failure:
        assert(failure.code == prism.limit_exceeded)
        refused = true
    assert(refused)

func release_sessions(held: (interop.Reference[prism.Session]?)[], count: usize):
    var i: usize = 0
    while i < count:
        if let session = held[i]:
            session.release()
        i += 1

func view_cap_is_1024() -> !:
    var store = try prism.Store()
    defer store.close()
    var held: (interop.Reference[prism.Session]?)[1024]
    var n: usize = 0
    defer release_sessions(held[..<n], n)
    while n < 1024:
        held[n] = try store.snapshot()
        n += 1
    var refused = false
    let blocked: interop.Reference[prism.Session]? = store.snapshot() catch failure:
        assert(failure.code == prism.limit_exceeded)
        refused = true
        recover none
    assert(refused and blocked == none)
    if let first = held[0]:
        first.release()
        held[0] = none
    let extra = try store.snapshot()
    defer extra.release()
    release_sessions(held[..<n], n)
    n = 0

func mount_is_a_separate_identity() -> !:
    var store = try prism.Store()
    defer store.close()
    assert(not try store.mounted("media.prism"))
    try store.mount("media.prism")
    assert(try store.mounted("media.prism"))
    let root = try store.begin()
    defer root.release()
    try root.value().add("/users", "directory")
    _ = try root.value().commit()
    let media = try store.begin_identity("media.prism")
    defer media.release()
    try media.value().add("/photos", "directory")
    _ = try media.value().commit()
    let root_snap = try store.snapshot()
    defer root_snap.release()
    assert(try root_snap.value().contains("/users"))
    assert(not try root_snap.value().contains("/photos"))
    let media_snap = try store.open_document("media.prism")
    defer media_snap.release()
    assert(try media_snap.value().contains("/photos"))
    assert(not try media_snap.value().contains("/users"))

func mount_rejects_bad_identity() -> !:
    var store = try prism.Store()
    defer store.close()
    var dots = false
    store.mount("..") catch failure:
        assert(failure.code == prism.invalid)
        dots = true
    assert(dots)
    var slash = false
    store.mount("media/prism") catch failure:
        assert(failure.code == prism.invalid)
        slash = true
    assert(slash)

func document_facade_sees_unbaked() -> !:
    var store = try prism.Store()
    defer store.close()
    let tx = try store.begin()
    defer tx.release()
    try tx.value().add("/row", "object")
    let value = try prism.Value.integer(2)
    defer value.release()
    try tx.value().set("/row", "x", value)
    _ = try tx.value().commit()
    let snap = try store.snapshot()
    defer snap.release()
    let doc = try snap.value().document()
    defer doc.release()
    assert(doc.value().contains("/row"))
    let got = try doc.value().get("/row", "x")
    defer got.release()
    assert(try got.value().integer_at() == 2)
    var query = try snap.value().query()
    defer query.close()
    assert(try query.count() == 1)

func persist_dir() -> str:
    return persist_path

func persist_db() -> str:
    return database_path

func reset_persist() -> !:
    case_number += 1
    persist_path = try strings.format(persist_buffer, f"{scratch_root}/persist-{case_number}")
    database_path = try strings.format(database_buffer, f"{persist_path}/root.db")
    try files.ensure_directory(persist_dir())

func persist_budget_counts_chunked_keys() -> !:
    let small = try persist.journal_bytes_for_layer("root", 1, 16)
    assert(small == persist.encoded_put(2 + 4 + 1 + 20, 16))
    let huge = try persist.journal_bytes_for_layer("root", 1, persist.payload_budget)
    assert(huge > persist.payload_budget)

func persist_reopen_sees_unbaked_commit() -> !:
    try reset_persist()
    let first = try prism.Store.open(persist_db())
    let tx = try first.value().begin()
    try tx.value().add("/notes", "file")
    let text = try prism.Value.text("hello")
    defer text.release()
    try tx.value().set("/notes", "text", text)
    _ = try tx.value().commit()
    tx.release()
    try first.value().mount("mail")
    let mail = try first.value().begin_identity("mail")
    try mail.value().add("/inbox", "folder")
    _ = try mail.value().commit()
    mail.release()
    first.release()
    let second = try prism.Store.open(persist_db())
    defer second.release()
    # The catalog survives the reopen with the identities that hold commits.
    assert(try second.value().mounted("mail") and not try second.value().mounted("other"))
    let snap = try second.value().snapshot()
    defer snap.release()
    assert(try snap.value().contains("/notes"))
    let got = try snap.value().get("/notes", "text")
    defer got.release()
    assert(try got.value().text_at() == "hello")

func persist_schema_only_root_then_commit() -> !:
    try reset_persist()
    let first = try prism.Store.open(persist_db())
    first.value().close()
    first.release()
    let second = try prism.Store.open(persist_db())
    defer second.release()
    let tx = try second.value().begin()
    defer tx.release()
    try tx.value().add("/users", "directory")
    _ = try tx.value().commit()
    let snap = try second.value().snapshot()
    defer snap.release()
    assert(try snap.value().contains("/users"))

func persist_bake_reclaim_survives_reopen() -> !:
    try reset_persist()
    let first = try prism.Store.open(persist_db())
    let tx = try first.value().begin()
    try tx.value().add("/keep", "file")
    let value = try prism.Value.number(3.0)
    defer value.release()
    try tx.value().set("/keep", "x", value)
    _ = try tx.value().commit()
    tx.release()
    _ = try first.value().bake()
    first.release()
    let second = try prism.Store.open(persist_db())
    defer second.release()
    let snap = try second.value().snapshot()
    defer snap.release()
    let got = try snap.value().get("/keep", "x")
    defer got.release()
    assert(try got.value().number_at() == 3.0)

func dump_dir() -> str:
    return dump_path

func reset_dump() -> !:
    case_number += 1
    dump_path = try strings.format(dump_buffer, f"{scratch_root}/dump-{case_number}")
    try files.ensure_directory(dump_dir())

func seed_photos(store: prism.Store*) -> !:
    try store.mount("media.prism")
    let root = try store.begin()
    defer root.release()
    try root.value().add("/users", "directory")
    try root.value().add("/users/alice", "directory")
    try root.value().add("/users/alice/photos", "link")
    try root.value().set_metadata("/users/alice/photos", "reference", "media.prism")
    try root.value().add("/users/alice/[0]", "file")
    try root.value().set_metadata("/users/alice/[0]", "name", "notes.txt")
    let note = try prism.Value.text("hi")
    defer note.release()
    try root.value().set("/users/alice/[0]", "text", note)
    _ = try root.value().commit()
    let media = try store.begin_identity("media.prism")
    defer media.release()
    try media.value().add("/vacation", "file")
    let payload = try prism.Value.array(prism.DType.uint8, [4], b"JPEG")
    defer payload.release()
    try media.value().set("/vacation", "bytes", payload)
    _ = try media.value().commit()

func find_entry(listing: interop.Reference[prism.Entries], name: str) -> usize!:
    var i: usize = 0
    while i < listing.value().count():
        if try listing.value().name_at(i) == name:
            return i
        i += 1
    error(prism.missing, "missing directory entry")

func fs_entries_follow_links_and_host_names() -> !:
    var store = try prism.Store()
    defer store.close()
    try seed_photos(&store)
    assert(try store.exists("/users/alice/photos"))
    assert(try store.is_dir("/users/alice/photos"))
    assert(try store.is_file("/users/alice/photos/vacation"))
    assert(not try store.is_file("/users/alice/photos"))
    let listing = try store.entries("/users/alice")
    defer listing.release()
    assert(listing.value().count() == 2)
    let photos = try find_entry(listing, "photos")
    assert(try listing.value().path_at(photos) == "/users/alice/photos")
    assert(try listing.value().kind_at(photos) == prism.LookKind.directory)
    let notes = try find_entry(listing, "notes.txt")
    assert(try listing.value().path_at(notes) == "/users/alice/notes.txt")
    assert(try listing.value().kind_at(notes) == prism.LookKind.file)
    let names = try store.list("/users/alice")
    defer names.release()
    assert(names.value().count() == 2)
    assert(try names.value().at(0) == "notes.txt")
    assert(try names.value().at(1) == "photos")
    let nested = try store.entries("/users/alice/photos")
    defer nested.release()
    assert(nested.value().count() == 1)
    assert(try nested.value().name_at(0) == "vacation")
    assert(try nested.value().kind_at(0) == prism.LookKind.file)

func fs_make_directory_creates_parents() -> !:
    var store = try prism.Store()
    defer store.close()
    try store.make_directory("/users/bob/docs")
    assert(try store.is_dir("/users"))
    assert(try store.is_dir("/users/bob"))
    assert(try store.is_dir("/users/bob/docs"))
    try store.make_directory("/users/bob/docs")
    var refused = false
    let tx = try store.begin()
    defer tx.release()
    try tx.value().add("/tmp", "file")
    _ = try tx.value().commit()
    store.make_directory("/tmp") catch failure:
        assert(failure.code == prism.invalid)
        refused = true
    assert(refused)

func fs_delete_and_remove_directory_split() -> !:
    var store = try prism.Store()
    defer store.close()
    try seed_photos(&store)
    var dir = false
    store.delete("/users/alice") catch failure:
        assert(failure.code == prism.invalid)
        dir = true
    assert(dir)
    try store.delete("/users/alice/notes.txt")
    assert(not try store.exists("/users/alice/notes.txt"))
    try store.make_directory("/empty")
    try store.remove_directory("/empty")
    assert(not try store.exists("/empty"))
    var full = false
    store.remove_directory("/users") catch failure:
        assert(failure.code == prism.invalid)
        full = true
    assert(full)
    var link = false
    store.remove_directory("/users/alice/photos") catch failure:
        assert(failure.code == prism.invalid)
        link = true
    assert(link)
    try store.delete("/users/alice/photos")
    assert(not try store.exists("/users/alice/photos"))
    let media = try store.open_document("media.prism")
    defer media.release()
    assert(try media.value().contains("/vacation"))

func fs_remove_all_does_not_follow_links() -> !:
    var store = try prism.Store()
    defer store.close()
    try seed_photos(&store)
    try store.remove_all("/users/alice")
    assert(not try store.exists("/users/alice"))
    assert(not try store.exists("/users/alice/photos"))
    let media = try store.open_document("media.prism")
    defer media.release()
    assert(try media.value().contains("/vacation"))
    try store.remove_all("/missing")
    var other = try prism.Store()
    defer other.close()
    try seed_photos(&other)
    try other.remove_all("/users/alice/photos")
    assert(not try other.exists("/users/alice/photos"))
    let again = try other.open_document("media.prism")
    defer again.release()
    assert(try again.value().contains("/vacation"))

func fs_write_and_dump_per_identity() -> !:
    var store = try prism.Store()
    defer store.close()
    try seed_photos(&store)
    try store.make_directory("/users/bob")
    let hello = try prism.Value.text("hello")
    defer hello.release()
    try store.write("/users/bob/readme", hello)
    let got = try store.read("/users/bob/readme")
    defer got.release()
    assert(try got.value().text_at() == "hello")
    try reset_dump()
    try store.dump(dump_dir())
    var restored = try prism.Store()
    defer restored.close()
    try restored.load(dump_dir())
    assert(try restored.is_dir("/users/alice/photos"))
    let vacation = try restored.read("/users/alice/photos/vacation")
    defer vacation.release()
    let expected = try prism.Value.array(prism.DType.uint8, [4], b"JPEG")
    defer expected.release()
    assert(try vacation.value().equals(expected))
    let root = try restored.snapshot()
    defer root.release()
    assert(not try root.value().contains("/vacation"))
    let media = try restored.open_document("media.prism")
    defer media.release()
    assert(try media.value().contains("/vacation"))

## A value larger than a journal frame commits: its payload goes to an extent once,
## the journal and the snapshot carry a reference, and it reads back before and after
## a bake and a reopen.
func large_value_lives_in_an_extent() -> !:
    try reset_persist()
    let size = persist.payload_budget + 1
    let first = try prism.Store.open(persist_db())
    let tx = try first.value().begin()
    try tx.value().add("/blob", "file")
    let value = try marked_blob(size, 7)
    defer value.release()
    try tx.value().set("/blob", "bytes", value)
    _ = try tx.value().commit()
    tx.release()
    let unbaked = try first.value().snapshot()
    let early = try unbaked.value().get("/blob", "bytes")
    assert(early.value().bytes().length == size and early.value().bytes()[size - 1] == 7)
    early.release()
    unbaked.release()
    first.release()
    # Reopened unbaked: the journal held only a reference.
    let second = try prism.Store.open(persist_db())
    let reopened = try second.value().snapshot()
    let again = try reopened.value().get("/blob", "bytes")
    assert(again.value().bytes().length == size and again.value().bytes()[0] == 7)
    again.release()
    reopened.release()
    _ = try second.value().bake(wait_ms = 1000)
    second.release()
    let third = try prism.Store.open(persist_db())
    defer third.release()
    let baked = try third.value().snapshot()
    defer baked.release()
    let last = try baked.value().get("/blob", "bytes")
    defer last.release()
    assert(last.value().bytes().length == size and last.value().bytes()[size - 1] == 7)
    # Neither the journal nor the snapshot copied the payload.
    assert(try file_size(persist_db()) < 1048576)

## An extent nothing references any more goes on the next open.
func replaced_extents_are_swept_on_open() -> !:
    try reset_persist()
    let first = try prism.Store.open(persist_db())
    for round in 0..<(usize)2:
        let tx = try first.value().begin()
        if round == 0:
            try tx.value().add("/blob", "file")
        let value = try marked_blob(8192, (u8)(round + 1))
        try tx.value().set("/blob", "bytes", value)
        value.release()
        _ = try tx.value().commit()
        tx.release()
        _ = try first.value().bake(wait_ms = 1000)
    first.release()
    var name_buffer: u8[2048]
    let old_extent = try strings.format(name_buffer, f"{persist_db()}.ext/root.1.0")
    assert(try file_exists(old_extent))
    let second = try prism.Store.open(persist_db())
    defer second.release()
    var again_buffer: u8[2048]
    assert(not try file_exists(try strings.format(again_buffer, f"{persist_db()}.ext/root.1.0")))
    var kept_buffer: u8[2048]
    assert(try file_exists(try strings.format(kept_buffer, f"{persist_db()}.ext/root.2.0")))
    let snap = try second.value().snapshot()
    defer snap.release()
    let value = try snap.value().get("/blob", "bytes")
    defer value.release()
    assert(value.value().bytes()[0] == 2)

## Whether a file is at `path`, through luce-std's public API (tests are a separate
## package and cannot use prism's file_access).
func file_exists(path: str) -> bool!:
    let name = try strings.copy(path)
    defer strings.release(name)
    return files.exists((c.str)name)

func file_size(path: str) -> i64!:
    let name = try strings.copy(path)
    defer strings.release(name)
    return (try files.metadata((c.str)name)).size

func marked_blob(count: usize, mark: u8) -> interop.Reference[prism.Value]!:
    let payload = try new u8[count] --- in memory.heap
    defer free(payload) in memory.heap
    payload[0] = mark
    payload[count - 1] = mark
    let shape: i64[1] = [(i64)count]
    return try prism.Value.array(prism.DType.uint8, shape, payload)

func write_baked_file(store: prism.Store*, path: str, mark: u8, bytes: usize) -> !:
    let tx = try store.begin()
    try tx.value().add(path, "file")
    let value = try marked_blob(bytes, mark)
    tx.value().set(path, "bytes", value) catch failure:
        value.release()
        tx.release()
        error(failure.code, failure.message)
    value.release()
    _ = tx.value().commit() catch failure:
        tx.release()
        error(failure.code, failure.message)
    tx.release()
    _ = try store.bake()

func vm_evicts_baked_payloads_and_faults() -> !:
    try reset_persist()
    let limit: usize = 33554432
    let chunk: usize = 6291456
    let store = try prism.Store.open(persist_db(), limit)
    defer store.release()
    try write_baked_file(try store.get(), "/a", 11, chunk)
    try write_baked_file(try store.get(), "/b", 22, chunk)
    try write_baked_file(try store.get(), "/c", 33, chunk)
    try write_baked_file(try store.get(), "/d", 44, chunk)
    try write_baked_file(try store.get(), "/e", 55, chunk)
    try write_baked_file(try store.get(), "/f", 66, chunk)
    let after_writes = try store.value().statistics()
    assert(after_writes.resident <= (i64)limit)
    assert(after_writes.evictions >= 1)
    let faults_before = after_writes.faults
    let snap = try store.value().snapshot()
    defer snap.release()
    let kids = try snap.value().children("/")
    defer kids.release()
    assert(kids.value().count() == 6)
    assert(try store.value().kind("/a") == prism.LookKind.file)
    let after_list = try store.value().statistics()
    assert(after_list.faults == faults_before)
    let cold = try store.value().read("/a")
    defer cold.release()
    assert(cold.value().bytes()[0] == 11)
    assert(cold.value().bytes()[chunk - 1] == 11)
    let stats = try store.value().statistics()
    assert(stats.evictions >= 1)
    assert(stats.faults >= faults_before + 1)
    assert(stats.resident <= (i64)limit)

func vm_pin_holds_subtree_and_set_refuses() -> !:
    try reset_persist()
    let limit: usize = 33554432
    let chunk: usize = 6291456
    let store = try prism.Store.open(persist_db(), limit)
    defer store.release()
    try write_baked_file(try store.get(), "/keep", 9, chunk)
    try write_baked_file(try store.get(), "/x", 1, chunk)
    try write_baked_file(try store.get(), "/y", 2, chunk)
    try write_baked_file(try store.get(), "/z", 3, chunk)
    try write_baked_file(try store.get(), "/w", 4, chunk)
    try write_baked_file(try store.get(), "/v", 5, chunk)
    let snap = try store.value().snapshot()
    defer snap.release()
    try snap.value().pin("/keep")
    try store.value().set_limit(8388608)
    let kept = try snap.value().get("/keep", "bytes")
    defer kept.release()
    assert(kept.value().bytes()[0] == 9)
    let tx = try store.value().begin()
    defer tx.release()
    try tx.value().add("/overflow", "file")
    let extra = try marked_blob(chunk, 8)
    defer extra.release()
    var refused = false
    tx.value().set("/overflow", "bytes", extra) catch failure:
        assert(failure.code == prism.limit_exceeded)
        refused = true
    assert(refused)

func vm_reopen_pages_under_limit() -> !:
    try reset_persist()
    let limit: usize = 33554432
    let chunk: usize = 6291456
    let first = try prism.Store.open(persist_db(), limit)
    try write_baked_file(try first.get(), "/a", 11, chunk)
    try write_baked_file(try first.get(), "/b", 22, chunk)
    try write_baked_file(try first.get(), "/c", 33, chunk)
    try write_baked_file(try first.get(), "/d", 44, chunk)
    try write_baked_file(try first.get(), "/e", 55, chunk)
    try write_baked_file(try first.get(), "/f", 66, chunk)
    first.release()
    let store = try prism.Store.open(persist_db(), limit)
    defer store.release()
    let stats = try store.value().statistics()
    assert(stats.resident <= (i64)limit)
    assert(try store.value().kind("/a") == prism.LookKind.file)
    let cold = try store.value().read("/a")
    defer cold.release()
    assert(cold.value().bytes()[0] == 11)
    assert(cold.value().bytes()[chunk - 1] == 11)

## A query over evicted payloads pages in only what it reads, and what it selects.
func vm_query_pages_selected_rows_in() -> !:
    try reset_persist()
    let limit: usize = 33554432
    let chunk: usize = 6291456
    let store = try prism.Store.open(persist_db(), limit)
    defer store.release()
    try write_baked_file(try store.get(), "/a", 11, chunk)
    try write_baked_file(try store.get(), "/b", 22, chunk)
    try write_baked_file(try store.get(), "/c", 33, chunk)
    try write_baked_file(try store.get(), "/d", 44, chunk)
    try write_baked_file(try store.get(), "/e", 55, chunk)
    try write_baked_file(try store.get(), "/f", 66, chunk)
    let snap = try store.value().snapshot()
    defer snap.release()
    let before = try store.value().statistics()
    assert(before.evictions >= 1)
    var query = try snap.value().query("/*")
    defer query.close()
    let present = try prism.Predicate.exists("bytes")
    defer present.release()
    let with_bytes = try query.filter(present)
    defer with_bytes.release()
    assert(try with_bytes.value().count() == 6)
    assert((try store.value().statistics()).faults == before.faults)
    let first = try with_bytes.value().limit(1)
    defer first.release()
    let rows = try first.value().select()
    defer rows.release()
    let bytes = try rows.value().get(0, "bytes")
    defer bytes.release()
    assert(try rows.value().path_at(0) == "/a" and bytes.value().bytes()[0] == 11 and bytes.value().bytes()[chunk - 1] == 11)