Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.3

0.19.3 / tests / ownership / main.lucb

from luce_gpu import gpu
from luce_window import input
import interop
from luce_std import math
import memory
import ownership
import thread
from luce_std import crash
from luce_window import window
from luce_ui import ui
import layout_cycles
from luce_ui.ui import Widget, Button, Spacer, VStack, HStack, Layout, Size, Application, Painter, Rect, Event, Font, Panel, DStack

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 restore(previous: memory.Allocator):
    memory.heap = previous

func new_button(text: str) -> interop.Reference[Button]!:
    return try interop.Reference[Button].adopt(new Button(text) in memory.heap, ui.button_type, memory.heap)

func expect(outcome: interop.Outcome[unit]) -> !:
    defer outcome.release()
    outcome.get() catch failure:
        print(f"unexpected UI failure: {failure.message}")
        assert(false)

func allocations(tracker: Tracker*) -> !:
    var succeeded = false
    var failures: usize = 0
    for stage in 0..<20:
        tracker.remaining = (usize)stage
        let control: interop.Reference[Button]? = new_button("owned label") catch failure:
            assert(failure.code == memory.exhausted)
            failures += 1
            recover none
        if let value = control:
            value.release()
            succeeded = true
        tracker.remaining = none
        ownership.collect()
        assert(tracker.live == 0)
    assert(succeeded and failures >= 4)

func new_stack() -> interop.Reference[DStack]!:
    let button = try new_button("content")
    defer button.release()
    let widget = button.as_interface[Widget](button.value())
    defer widget.release()
    let panel = try interop.Reference[Panel].adopt(new Panel("Example", widget) in memory.heap, ui.panel_type, memory.heap)
    defer panel.release()
    return try interop.Reference[DStack].adopt(new DStack([panel]) in memory.heap, ui.dstack_type, memory.heap)

func docking_allocations(tracker: Tracker*) -> !:
    # Runtime candidate buffers grow infallibly. Reserve their normal capacity
    # before testing fallible package allocations, then account for that cache.
    let warmup = try new_stack()
    warmup.release()
    ownership.collect()
    let baseline = tracker.live
    var succeeded = false
    var failures: usize = 0
    for stage in 0..<160:
        tracker.remaining = (usize)stage
        let stack: interop.Reference[DStack]? = new_stack() catch failure:
            assert(failure.code == memory.exhausted)
            failures += 1
            recover none
        if let retained = stack:
            assert(retained.value().panel_count() == 1)
            retained.release()
            succeeded = true
        tracker.remaining = none
        ownership.collect()
        assert(tracker.live == baseline)
    assert(succeeded and failures > 20)
    assert(ownership.finish_run(0) == 0)
    assert(tracker.live == 0)

func ownership_and_layout(tracker: Tracker*) -> !:
    let control = try new_button("pause")
    defer control.release()
    let widget = control.as_interface[Widget](control.value())
    defer widget.release()
    let flexible = try interop.Reference[Spacer].adopt(new Spacer(1.0) in memory.heap, ui.spacer_type, memory.heap)
    defer flexible.release()
    let space = flexible.as_interface[Widget](flexible.value())
    defer space.release()
    let row = try interop.Reference[HStack].adopt(new HStack([widget, space], 10.0, 20.0) in memory.heap, ui.hstack_type, memory.heap)
    defer row.release()
    let root = row.as_interface[Widget](row.value())
    defer root.release()
    let app = try interop.Reference[Application].adopt(new Application(root) in memory.heap, ui.application_type, memory.heap)
    defer app.release()
    try expect(app.value().layout(300.0, 100.0))
    let box = control.value().layout()
    defer box.release()
    let bounds = box.value().bounds()
    assert(bounds.x == 20.0 and bounds.y == 20.0 and bounds.width > 45.0 and bounds.width < 75.0 and bounds.height == 60.0)
    let spacer_box = flexible.value().layout()
    defer spacer_box.release()
    let spare = spacer_box.value().bounds()
    assert(spare.x == bounds.x + bounds.width + 10.0 and spare.width == 280.0 - spare.x)
    try spacer_box.value().set_limits(Size(), Size(50.0, 16384.0))
    try expect(app.value().layout(300.0, 100.0))
    assert(spacer_box.value().bounds().width == 50.0)
    try box.value().set_limits(Size(40.0, 20.0), Size(16384.0, 16384.0))
    try expect(app.value().layout(60.0, 20.0))
    assert(box.value().bounds().width == 40.0 and spacer_box.value().bounds().width == 0.0)
    var duplicate = false
    row.value().set_children([widget, widget]) catch failure:
        assert(failure.code == ui.invalid)
        duplicate = true
    assert(duplicate)
    var cyclic = false
    row.value().set_children([root]) catch failure:
        assert(failure.code == ui.busy or failure.code == ui.invalid)
        cyclic = true
    assert(cyclic)
    let row_box = row.value().layout()
    defer row_box.release()
    assert(row_box.value().child_count() == 2)
    let baseline = tracker.live
    tracker.remaining = 0
    var refused = false
    row.value().set_children([space, widget]) catch failure:
        assert(failure.code == memory.exhausted)
        refused = true
    tracker.remaining = none
    assert(refused and tracker.live == baseline)
    assert(row_box.value().child_count() == 2)
    let first = try row_box.value().child(0)
    defer first.release()
    assert(first.owner == widget.owner)
    let other = try interop.Reference[Application].adopt(new Application(root) in memory.heap, ui.application_type, memory.heap)
    defer other.release()
    let shared = other.value().layout(300.0, 100.0)
    defer shared.release()
    assert(not shared.is_success())
    var empty: interop.Interface[Widget][]
    try row.value().set_children(empty)
    try expect(app.value().layout(300.0, 100.0))
    assert(row_box.value().child_count() == 0)
    try row.value().set_children([widget])
    try expect(app.value().layout(300.0, 100.0))

func game_mode() -> !:
    let flexible = try interop.Reference[Spacer].adopt(new Spacer(1.0) in memory.heap, ui.spacer_type, memory.heap)
    defer flexible.release()
    let space = flexible.as_interface[Widget](flexible.value())
    defer space.release()
    let app = try interop.Reference[Application].adopt(new Application(space, game = true, fps = 70.0) in memory.heap, ui.application_type, memory.heap)
    defer app.release()
    assert(app.value().is_game() and app.value().fps() == 70.0)
    assert(not app.value().is_fullscreen())
    app.value().set_game(false)
    assert(not app.value().is_game())
    try app.value().set_fps(0.0)
    assert(app.value().fps() == 0.0)
    var rejected = false
    app.value().set_fps(-1.0) catch failure:
        assert(failure.code == ui.invalid)
        rejected = true
    assert(rejected)
    rejected = false
    let invalid: interop.Reference[Application]? = interop.Reference[Application].adopt(new Application(space, fps = 1001.0) in memory.heap, ui.application_type, memory.heap) catch failure:
        assert(failure.code == ui.invalid)
        rejected = true
        recover none
    assert(rejected and invalid == none)

func shared_font() -> !:
    let font = try interop.Reference[Font].adopt(new Font(size = 18.0) in memory.heap, ui.font_type, memory.heap)
    let expected_width = try font.value().measure("Save") + ui.Theme().inset(font) * 2.0
    var control = Button("Save", font = font) catch failure:
        font.release()
        error(failure.code, failure.message)
    defer control.close()
    font.release()
    let measured = control.measure(ui.Constraints())
    defer measured.release()
    assert((try measured.get()).width == expected_width)

func drawing() -> !:
    var font = try Font()
    defer font.close()
    assert(try font.measure("iii") == try font.measure("WWW"))
    assert(try font.measure("aAĆ©") == 3.0 * font.advance())
    var frame = try gpu.Frame(window.Size(100.0, 80.0, 200.0, 160.0, 2.0))
    let target = try frame.target()
    defer target.release()
    var painter = try Painter(target)
    defer painter.close()
    try painter.text("Case preserved")
    frame.close()
    var expired = false
    painter.rectangle(Rect(width = 20.0, height = 20.0), gpu.Color()) catch failure:
        assert(failure.code == interop.expired)
        expired = true
    assert(expired)

## Holds an application, as a crash hook that saves its document would.
struct Saver:
    var app: interop.Reference[Application]?

    func save(argument: unit) -> interop.Outcome[unit]:
        _ = argument
        return interop.Outcome[unit].success(interop.Owned[unit](()))

    func close():
        if let app = self.app:
            self.app = none
            app.release()

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        if let app = self.app:
            app.trace(visit, context)

let saver_type: interop.Type[Saver] = interop.Type[Saver]("crash hook saver", Saver.close, Saver.trace)

## A crash hook that captures the application is removed by `close`: nothing it held
## outlives the application, and the handle the caller dropped early did not remove it.
func crash_hooks() -> !:
    let button = try new_button("save")
    defer button.release()
    let widget = button.as_interface[Widget](button.value())
    defer widget.release()
    let app = try interop.Reference[Application].adopt(new Application(widget) in memory.heap, ui.application_type, memory.heap)
    defer app.release()
    let saver = try interop.Reference[Saver].adopt(new Saver(app = app.clone()) in memory.heap, saver_type, memory.heap)
    defer saver.release()
    let callback = try interop.Callback[unit, unit].bind_mutating(saver, Saver.save)
    defer callback.release()
    let kept = try app.value().on_crash(callback)
    let dropped = try app.value().on_crash(callback)
    dropped.release()
    assert(kept.value().is_active())
    app.value().close()
    assert(not kept.value().is_active())
    kept.release()

func construct_on_worker(context: void*?):
    let rejected = (bool*)(context else trap("missing thread result"))
    let layout: Layout? = Layout() catch failure:
        assert(failure.code == interop.wrong_thread)
        *rejected = true
        recover none
    assert(layout == none)

pub func main(arguments: str[]) -> i32!:
    var rejected = false
    let worker = try thread.spawn(construct_on_worker, (void*)&rejected)
    try worker.join()
    assert(rejected)
    # crash reports keep a signal stack for the process: made before allocations are counted
    try crash.enable()
    var tracker = Tracker(upstream = memory.heap)
    let previous = memory.heap
    memory.heap = &tracker
    defer restore(previous)
    with tracker:
        try allocations(&tracker)
        try docking_allocations(&tracker)
        try layout_cycles.collect()
        assert(ownership.finish_run(0) == 0)
        try layout_cycles.relayout_during_collection()
        assert(ownership.finish_run(0) == 0)
        assert(tracker.live == 0)
        try ownership_and_layout(&tracker)
        assert(ownership.finish_run(0) == 0)
        assert(tracker.live == 0)
        try shared_font()
        try game_mode()
        try drawing()
        assert(ownership.finish_run(0) == 0)
        assert(tracker.live == 0)
        try crash_hooks()
        ownership.collect()
        assert(ownership.finish_run(0) == 0)
        assert(tracker.live == 0)
    print("ok UI ownership, allocation, layout and drawing scopes")
    return 0