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")