Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.3

0.19.3 / tests / pixels / run_loop_pixels.lucb

## The run loop sleeps until it has work: a watched socket turning readable, or a
## wake_at instant, ends its wait. Each case is timed against the loop's one-second
## safety ceiling, which is what would end the wait if neither did.
import interop
import memory
import ownership
import thread
import time
from luce_std import net
from luce_ui import ui
from luce_ui.ui import Application, Spacer, Widget

## Stops the application from a callback: when its socket is readable, or on the first
## frame at or after `due`.
struct Stopper:
    var app: Application*
    var socket: net.Datagram*
    var due: u64
    var reads: i64

    func readable(argument: unit) -> interop.Outcome[unit]:
        _ = argument
        var buffer: u8[8]
        _ = self.socket.receive_from(buffer[..<8]) catch failure:
            return interop.Outcome[unit].failure(failure.code, interop.copy_text(failure.message) catch exhausted: trap(exhausted.message))
        self.reads += 1
        self.app.stop()
        return interop.Outcome[unit].success(interop.Owned[unit](()))

    func frame(elapsed: f64) -> interop.Outcome[unit]:
        _ = elapsed
        if self.due != 0 and time.now() >= self.due:
            self.app.stop()
        return interop.Outcome[unit].success(interop.Owned[unit](()))

    func close():
        self.reads = 0

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        _ = visit
        _ = context

let stopper_type: interop.Type[Stopper] = interop.Type[Stopper]("run loop test stopper", Stopper.close, Stopper.trace)

struct Delivery:
    var socket: net.Datagram*
    var address: net.SocketAddress

## Send one datagram after 100 ms, from another thread.
func deliver(context: void*?):
    let delivery = (Delivery*)(context else trap("missing delivery"))
    thread.sleep(100)
    var payload: u8[1] = [1]
    delivery.socket.send_to(payload[..<1], delivery.address) catch failure:
        trap(failure.message)

func run_once(app: interop.Reference[Application]) -> u64!:
    let started = time.now()
    let outcome = app.value().run()
    defer outcome.release()
    try outcome.get()
    return time.since(started)

pub func wakes() -> !:
    let spacer = try interop.Reference[Spacer].adopt(new Spacer(1.0) in memory.heap, ui.spacer_type, memory.heap)
    defer spacer.release()
    let content = spacer.as_interface[Widget](spacer.value())
    defer content.release()
    let app = try interop.Reference[Application].adopt(new Application(content, title = "Run loop wakes", width = 200, height = 120) in memory.heap, ui.application_type, memory.heap)
    defer app.release()
    var receiver = try net.Datagram.bind(net.SocketAddress.loopback(0))
    defer receiver.destroy()
    var sender = try net.Datagram.bind(net.SocketAddress.loopback(0))
    defer sender.destroy()
    let stopper = try interop.Reference[Stopper].adopt(new Stopper(app = app.value(), socket = &receiver, due = 0, reads = 0) in memory.heap, stopper_type, memory.heap)
    defer stopper.release()
    let readable = try interop.Callback[unit, unit].bind_mutating(stopper, Stopper.readable)
    defer readable.release()
    let frames = try interop.Callback[f64, unit].bind_mutating(stopper, Stopper.frame)
    defer frames.release()
    let connection = try app.value().on_frame(frames)
    defer connection.release()
    # A datagram arriving ends the wait; its callback stops the loop.
    let descriptor = receiver.descriptor() else trap("the socket has no descriptor")
    let watch = try app.value().watch((i64)descriptor, readable)
    var delivery = Delivery(socket = &sender, address = try receiver.address())
    var worker = try thread.spawn(deliver, (void*)&delivery)
    let watched = try run_once(app)
    try worker.join()
    app.value().unwatch(watch)
    assert(stopper.value().reads == 1 and watched < 900000000)
    # wake_at alone ends the wait; the first frame after it stops the loop.
    try app.value().set_title("Run loop wakes — again")
    stopper.value().due = time.now() + 100000000
    app.value().wake_after(0.1)
    let woken = try run_once(app)
    assert(woken >= 90000000 and woken < 900000000)
    print("ok run loop wakes for watched sockets and wake_at")

## A frame callback that fails every frame, and the error handler that hears of it.
struct Failing:
    var reports: i64
    ## Whether every report carried the frame's message whole.
    var whole: bool

    func frame(elapsed: f64) -> interop.Outcome[unit]:
        _ = elapsed
        return interop.Outcome[unit].failure(failing_frame, interop.copy_text("the frame failed") catch exhausted: trap(exhausted.message))

    func report(message: str) -> interop.Outcome[unit]:
        self.reports += 1
        self.whole = self.whole and message == "the frame failed"
        return interop.Outcome[unit].success(interop.Owned[unit](()))

    func close():
        self.reports = 0

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        _ = visit
        _ = context

let failing_type: interop.Type[Failing] = interop.Type[Failing]("run loop test failing frame", Failing.close, Failing.trace)
let failing_frame: ErrorCode = ErrorCode.package(41)

func failing_app(title: str) -> interop.Reference[Application]!:
    let spacer = try interop.Reference[Spacer].adopt(new Spacer(1.0) in memory.heap, ui.spacer_type, memory.heap)
    defer spacer.release()
    let content = spacer.as_interface[Widget](spacer.value())
    defer content.release()
    return try interop.Reference[Application].adopt(new Application(content, title = title, width = 200, height = 120) in memory.heap, ui.application_type, memory.heap)

## A frame callback's failure goes to the error handler, once while it repeats, and the
## run goes on; without a handler it ends the run and is shown in a window first.
pub func frame_failures() -> !:
    let failing = try interop.Reference[Failing].adopt(new Failing(reports = 0, whole = true) in memory.heap, failing_type, memory.heap)
    defer failing.release()
    let frames = try interop.Callback[f64, unit].bind_mutating(failing, Failing.frame)
    defer frames.release()
    let handled = try failing_app("Frame failures")
    defer handled.release()
    let reported = try interop.Callback[str, unit].bind_mutating(failing, Failing.report)
    defer reported.release()
    try handled.value().set_error_handler(reported)
    let connection = try handled.value().on_frame(frames)
    defer connection.release()
    let ran = handled.value().run(frame_limit = 5)
    defer ran.release()
    try ran.get()
    assert(failing.value().reports == 1)
    assert(failing.value().whole)
    assert(not handled.value().failure_shown())
    let unhandled = try failing_app("Frame failure shown")
    defer unhandled.release()
    let unhandled_connection = try unhandled.value().on_frame(frames)
    defer unhandled_connection.release()
    let ended = unhandled.value().run(frame_limit = 3)
    defer ended.release()
    _ = ended.get() catch failure:
        assert(failure.code == failing_frame)
        assert(failure.message == "the frame failed")
        recover ()
    assert(not ended.is_success())
    assert(unhandled.value().failure_shown())
    print("ok a frame callback's failure reaches the error handler, and one that ends the run is shown")