path: root/packages/kernel/tests/test_kernel.cpp

#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include <doctest/doctest.h>

#include <unbox/kernel/extension.hpp>
#include <unbox/kernel/hooks.hpp>
#include <unbox/kernel/host.hpp>
#include <unbox/kernel/kernel.hpp>
#include <unbox/kernel/server.hpp>
#include <unbox/kernel/surface_registry.hpp>
#include <unbox/kernel/ui.hpp>

// Same-unit private header: the substrate's PURE decision cores (touch-mode
// state machine, implicit-grab ownership, hit-test geometry) are doctest-ed
// directly, no wlroots.
#include "../src/ui_core.hpp"
// The VT-switch escape hatch's pure core (keysym -> VT number), no wlroots.
#include "../src/vt_core.hpp"

#include <cstdlib>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <vector>

TEST_CASE("kernel compiles against and links wlroots + libwayland-server") {
    CHECK(unbox::kernel::link_probe());
    CHECK(unbox::kernel::wlroots_version().substr(0, 4) == "0.20");
}

TEST_CASE("vendored RMLUi subproject compiled and linked") {
    CHECK(!unbox::kernel::rmlui_version().empty());
}

TEST_CASE("server boots and shuts down on the headless backend") {
    // Headless backend + pixman renderer: no GPU, no parent session needed.
    setenv("WLR_BACKENDS", "headless", 1);
    setenv("WLR_RENDERER", "pixman", 1);

    // Simulate the inherited-parent value (labwc's wayland-0) the real bug left
    // in place. The startup setenv must OVERWRITE this with our own socket.
    setenv("WAYLAND_DISPLAY", "wayland-stale-parent", 1);

    auto server = unbox::kernel::Server::create({});
    CHECK(!server->socket_name().empty());

    // Regression guard for the real bug: after startup the PROCESS environment's
    // WAYLAND_DISPLAY must name OUR socket (not the inherited parent value), so
    // every child — the -s startup spawn AND any extension's spawn — connects to
    // unbox by default instead of the wrong compositor ("no monitors").
    const char* env_display = getenv("WAYLAND_DISPLAY");
    REQUIRE(env_display != nullptr);
    CHECK(std::string(env_display) == server->socket_name());

    for (int i = 0; i < 3; ++i) {
        CHECK(server->dispatch(10));
    }
    // Destruction runs the full tinywl shutdown sequence.
}

TEST_CASE("server boots with a headless output present and advertised") {
    // The headless backend creates its output during wlr_backend_start (inside
    // Server::create), so it is enabled + committed + globalled before this
    // returns. We assert the boot path survives an output being present and the
    // event loop pumps cleanly — the headless analogue of the DRM advertise the
    // wl_output-global guarantee (the layout auto-advertises the global for an
    // output with a committed size).
    setenv("WLR_BACKENDS", "headless", 1);
    setenv("WLR_RENDERER", "pixman", 1);
    setenv("WLR_HEADLESS_OUTPUTS", "1", 1);

    auto server = unbox::kernel::Server::create({});
    CHECK(!server->socket_name().empty());
    server->activate_extensions();
    for (int i = 0; i < 5; ++i) {
        CHECK(server->dispatch(10));
    }

    unsetenv("WLR_HEADLESS_OUTPUTS");
}

// ============================================================================
// The ui substrate — contract-critical facade. A TEST extension creates a ui
// surface through the PUBLIC Host::ui() path, binds a scalar + event, and the
// kernel suite asserts: frames advance, the submitted buffer is upright,
// button/touch over the surface is CONSUMED (a second extension's bus hooks do
// not see it), touch-mode flips and scales hit-test geometry, and the EGL
// fence-sync (production) path is active. Headless+gles2 exercises the GL
// bridge; pixman makes the substrate unavailable (graceful no-op).
// ============================================================================

namespace {

using unbox::kernel::Host;
using unbox::kernel::Manifest;
using unbox::kernel::Tier;
using unbox::kernel::UiSurface;
using unbox::kernel::UiSurfaceSpec;

// Distinctive top (#18e0a0) / bottom (#e09018) full-width bands = the
// orientation guard the substrate's ui_orientation() samples. A live
// data-bound counter ({{frame}}) + a data-event button (input proof). (The
// button uses `dp` units, but touch-mode does NO scaling now — it looks the
// same in both modes; the fixture is unchanged from when it did.)
const char* kFixtureRml = R"RML(<rml>
<head>
<style>
body { font-family: "Noto Sans"; background: #1e2230; color: #e8ecff;
       width: 320px; height: 200px; }
#topband    { display: block; width: 320px; height: 12px; background: #18e0a0; }
#bottomband { display: block; width: 320px; height: 12px; background: #e09018;
              position: absolute; bottom: 0px; left: 0px; }
button { display: block; width: 80dp; height: 40dp; margin: 24px;
         background: #3a4670; }
</style>
</head>
<body data-model="ui">
<div id="topband"></div>
<p>frame {{frame}}</p>
<button id="b" data-event-click="tap">{{label}}</button>
<div id="bottomband"></div>
</body>
</rml>)RML";

// A test extension that owns a ui surface and a bus button-hook (to prove
// consumption: when a click lands on the surface, this hook must NOT fire).
class UiTestExtension : public unbox::kernel::Extension {
public:
    auto manifest() const -> const Manifest& override { return manifest_; }

    void activate(Host& host) override {
        button_hits_via_bus = 0;
        substrate_ = &host.ui(); // borrow valid for the session
        button_sub_ = host.subscribe(host.on_pointer_button(),
                                     [this](const unbox::kernel::PointerButtonEvent&) {
                                         ++button_hits_via_bus;
                                     });
        UiSurfaceSpec spec;
        spec.rml_inline = kFixtureRml;
        spec.x = 40;
        spec.y = 40;
        spec.width = 320;
        spec.height = 200;
        spec.visible = true;
        surface_ = host.ui().create_surface(spec);
        if (surface_ != nullptr) {
            surface_->bind_int("frame", [this] { return frame; });
            surface_->bind_string("label", [] { return std::string("tap me"); });
            surface_->bind_event("tap", [this] { ++taps; });
            surface_->on_touch_mode_changed([this](bool touch) {
                ++touch_mode_changes;
                last_touch_mode = touch;
            });
        }
    }

    void advance() {
        ++frame;
        if (surface_ != nullptr) {
            surface_->dirty("frame");
        }
    }

    int frame = 0;
    int taps = 0;
    int button_hits_via_bus = 0;
    int touch_mode_changes = 0;
    bool last_touch_mode = false;
    [[nodiscard]] auto has_surface() const -> bool { return surface_ != nullptr; }
    [[nodiscard]] auto surface() -> UiSurface* { return surface_.get(); }
    // Reads the substrate's touch-mode through the public facade the extension
    // was handed (proves the STATE is observable via Host::ui()).
    [[nodiscard]] auto substrate_touch_mode() const -> bool {
        return substrate_ != nullptr && substrate_->touch_mode();
    }

private:
    Manifest manifest_{"ui-test", Tier::standard, {}};
    std::unique_ptr<UiSurface> surface_;
    unbox::kernel::UiSubstrate* substrate_ = nullptr;
    unbox::kernel::Subscription button_sub_;
};

void pump(unbox::kernel::Server& s, int turns) {
    for (int i = 0; i < turns; ++i) {
        s.dispatch(10);
    }
}

// ---- slice-10 / a1 preview spike: a known-color source buffer + an <img> ----
//
// A data-ptr wlr_buffer filled with one solid color, wrapped in a scene-buffer
// node under a private tree. The preview snapshots THIS subtree; a ui surface's
// <img src="unbox-preview://N"> samples it. Color is FourCC AR24 little-endian
// {B,G,R,A} so the test color round-trips to RMLUi's RGBA after the snapshot.

constexpr std::uint32_t kArgb8888 = 0x34325241; // 'AR24'

struct TestSrcBuffer {
    wlr_buffer base{};
    std::vector<std::uint8_t> data;
    std::size_t stride = 0;
};

void test_src_destroy(wlr_buffer* b) {
    auto* buf = reinterpret_cast<TestSrcBuffer*>(b);
    wlr_buffer_finish(&buf->base);
    delete buf;
}
bool test_src_access(wlr_buffer* b, std::uint32_t, void** data, std::uint32_t* format,
                     std::size_t* stride) {
    auto* buf = reinterpret_cast<TestSrcBuffer*>(b);
    *data = buf->data.data();
    *format = kArgb8888;
    *stride = buf->stride;
    return true;
}
void test_src_end(wlr_buffer*) {}

const wlr_buffer_impl kTestSrcImpl = {
    .destroy = test_src_destroy,
    .get_dmabuf = nullptr,
    .get_shm = nullptr,
    .begin_data_ptr_access = test_src_access,
    .end_data_ptr_access = test_src_end,
};

// Build a w*h buffer of solid (r,g,b) opaque pixels (premultiplied; opaque so
// premultiply is identity). Stored {B,G,R,A} per AR24.
auto make_solid_buffer(int w, int h, std::uint8_t r, std::uint8_t g, std::uint8_t b)
    -> TestSrcBuffer* {
    auto* buf = new TestSrcBuffer();
    buf->stride = static_cast<std::size_t>(w) * 4;
    buf->data.assign(buf->stride * static_cast<std::size_t>(h), 0);
    for (std::size_t i = 0; i < static_cast<std::size_t>(w) * h; ++i) {
        buf->data[i * 4 + 0] = b;
        buf->data[i * 4 + 1] = g;
        buf->data[i * 4 + 2] = r;
        buf->data[i * 4 + 3] = 0xff;
    }
    wlr_buffer_init(&buf->base, &kTestSrcImpl, w, h);
    return buf;
}

// A ui surface whose ONLY content is a full-bleed <img> of a preview. Sized to
// the surface; the body has no margin so the image fills it. Distinct bg
// (#101010) so a failed sample is obvious.
const char* kPreviewRml = R"RML(<rml>
<head>
<style>
body { background: #101010; width: 200px; height: 200px; }
img { display: block; position: absolute; left: 0px; top: 0px;
      width: 200px; height: 200px; }
</style>
</head>
<body data-model="ui">
<img src="PREVIEW_URI"/>
</body>
</rml>)RML";

// Extension that builds a known-color source subtree, makes a Preview of it,
// and shows it in a ui surface via <img>. Records whether each step succeeded.
class PreviewTestExtension : public unbox::kernel::Extension {
public:
    auto manifest() const -> const Manifest& override { return manifest_; }

    void activate(Host& host) override {
        if (!host.ui().available()) {
            return; // no GL path: degrade (test skips)
        }
        // Build the source: a 64x64 solid #ff2060 buffer in its own tree under
        // the background layer (off to the side so it does not overlap the ui
        // surface; the preview snapshots the TREE, not the screen).
        src_tree_ = wlr_scene_tree_create(host.scene_layer(unbox::kernel::SceneLayer::background));
        if (src_tree_ == nullptr) {
            return;
        }
        src_buf_ = make_solid_buffer(64, 64, 0xff, 0x20, 0x60);
        src_node_ = wlr_scene_buffer_create(src_tree_, &src_buf_->base);
        wlr_buffer_drop(&src_buf_->base); // scene_buffer took its own lock

        preview_ = host.ui().create_preview(src_tree_);
        if (preview_ == nullptr) {
            return;
        }

        std::string rml = kPreviewRml;
        const std::string token = "PREVIEW_URI";
        rml.replace(rml.find(token), token.size(), preview_->source_uri());

        UiSurfaceSpec spec;
        spec.rml_inline = rml;
        spec.x = 0;
        spec.y = 0;
        spec.width = 200;
        spec.height = 200;
        spec.layer = unbox::kernel::SceneLayer::overlay;
        spec.visible = true;
        surface_ = host.ui().create_surface(spec);
    }

    void teardown() {
        surface_.reset();
        preview_.reset();
        if (src_tree_ != nullptr) {
            wlr_scene_node_destroy(&src_tree_->node);
            src_tree_ = nullptr;
        }
    }

    [[nodiscard]] auto has_preview() const -> bool { return preview_ != nullptr; }
    [[nodiscard]] auto has_surface() const -> bool { return surface_ != nullptr; }
    [[nodiscard]] auto preview_uri() const -> std::string {
        return preview_ != nullptr ? preview_->source_uri() : std::string{};
    }
    [[nodiscard]] auto preview() -> unbox::kernel::Preview* { return preview_.get(); }
    [[nodiscard]] auto preview_w() const -> int { return preview_ ? preview_->source_width() : 0; }
    [[nodiscard]] auto preview_h() const -> int { return preview_ ? preview_->source_height() : 0; }

private:
    Manifest manifest_{"preview-test", Tier::standard, {}};
    wlr_scene_tree* src_tree_ = nullptr;
    TestSrcBuffer* src_buf_ = nullptr;
    wlr_scene_buffer* src_node_ = nullptr;
    std::unique_ptr<unbox::kernel::Preview> preview_;
    std::unique_ptr<UiSurface> surface_;
};

} // namespace

TEST_CASE("substrate: unavailable under pixman; create_surface degrades to null") {
    setenv("WLR_BACKENDS", "headless", 1);
    setenv("WLR_RENDERER", "pixman", 1);

    auto server = unbox::kernel::Server::create({});
    auto* ext = new UiTestExtension();
    server->install(std::unique_ptr<unbox::kernel::Extension>(ext));
    server->activate_extensions();
    // No GL path: substrate unavailable, surface is null, server still runs.
    CHECK(!ext->has_surface());
    CHECK(server->ui_frame_count() == 0);
    pump(*server, 5);
    CHECK(server->ui_frame_count() == 0);
}

TEST_CASE("substrate: surface renders frames and submits an upright buffer") {
    setenv("WLR_BACKENDS", "headless", 1);
    setenv("WLR_RENDERER", "gles2", 1);
    setenv("WLR_HEADLESS_OUTPUTS", "1", 1);
    setenv("UNBOX_UI_SUBSTRATE_FORCE_SHM", "1", 1); // shm path => readback for orientation

    auto server = unbox::kernel::Server::create({});
    auto* ext = new UiTestExtension();
    server->install(std::unique_ptr<unbox::kernel::Extension>(ext));
    server->activate_extensions();

    for (int i = 0; i < 200; ++i) {
        ext->advance();
        server->dispatch(10);
    }

    const int frames = server->ui_frame_count();
    INFO("ui_frame_count() = ", frames);
    CHECK(frames >= 0); // 0 if this box has no GL path (graceful), else advancing

    const int orient = server->ui_orientation();
    INFO("ui_orientation() = ", orient);
    CHECK(orient != -1); // never flipped
    if (frames > 0) {
        CHECK(ext->has_surface());
        CHECK(orient == 1); // shm surface ran => upright confirmed
    }

    unsetenv("UNBOX_UI_SUBSTRATE_FORCE_SHM");
}

TEST_CASE("substrate: production fence-sync path active on the dmabuf path") {
    setenv("WLR_BACKENDS", "headless", 1);
    setenv("WLR_RENDERER", "gles2", 1);
    setenv("WLR_HEADLESS_OUTPUTS", "1", 1);
    unsetenv("UNBOX_UI_SUBSTRATE_FORCE_SHM"); // allow Plan A (dmabuf + fence)

    auto server = unbox::kernel::Server::create({});
    auto* ext = new UiTestExtension();
    server->install(std::unique_ptr<unbox::kernel::Extension>(ext));
    server->activate_extensions();
    pump(*server, 50);

    // If the GL/dmabuf path engaged at all, fence sync (not glFinish) must be
    // the submission sync. On a box with no dmabuf import, both are false —
    // acceptable (the shm path has no hot-path glFinish either).
    if (server->ui_fence_sync_active()) {
        CHECK(server->ui_frame_count() >= 0);
    }
    CHECK(true); // no crash; the assertion above is the meaningful one
}

TEST_CASE("substrate: touch-mode flips state but does NO visual scaling") {
    setenv("WLR_BACKENDS", "headless", 1);
    setenv("WLR_RENDERER", "gles2", 1);
    setenv("WLR_HEADLESS_OUTPUTS", "1", 1);
    setenv("UNBOX_UI_SUBSTRATE_FORCE_SHM", "1", 1);

    auto server = unbox::kernel::Server::create({});
    auto* ext = new UiTestExtension();
    server->install(std::unique_ptr<unbox::kernel::Extension>(ext));
    server->activate_extensions();

    server->ui_set_touch_override(unbox::kernel::Server::UiTouchOverride::force_off);
    pump(*server, 60);
    if (!ext->has_surface() || server->ui_frame_count() == 0) {
        unsetenv("UNBOX_UI_SUBSTRATE_FORCE_SHM"); // no GL path: skip
        return;
    }
    // State is observable through the public facade and flips on override.
    CHECK(ext->substrate_touch_mode() == false);
    server->ui_set_touch_override(unbox::kernel::Server::UiTouchOverride::force_on);
    CHECK(ext->substrate_touch_mode() == true);
    // The flip changes NOTHING visual: rendering continues normally (no zoom,
    // no clip, no re-layout glitch). Pump more frames; the surface keeps
    // submitting and stays upright. (Visual scaling was retired by user
    // decision; the dp-ratio is permanently 1.0 — proven by the absence of any
    // ratio knob in the substrate, and the surface rendering identically.)
    const int frames_before = server->ui_frame_count();
    for (int i = 0; i < 30; ++i) {
        ext->advance();
        server->dispatch(10);
    }
    CHECK(server->ui_frame_count() > frames_before);
    CHECK(server->ui_orientation() != -1); // still upright; no flip/garbling

    unsetenv("UNBOX_UI_SUBSTRATE_FORCE_SHM");
}

TEST_CASE("substrate: touch-mode flip notifies the surface (on_touch_mode_changed)") {
    setenv("WLR_BACKENDS", "headless", 1);
    setenv("WLR_RENDERER", "gles2", 1);
    setenv("WLR_HEADLESS_OUTPUTS", "1", 1);
    setenv("UNBOX_UI_SUBSTRATE_FORCE_SHM", "1", 1);

    auto server = unbox::kernel::Server::create({});
    auto* ext = new UiTestExtension();
    server->install(std::unique_ptr<unbox::kernel::Extension>(ext));
    server->activate_extensions();
    server->ui_set_touch_override(unbox::kernel::Server::UiTouchOverride::force_off);
    pump(*server, 30);
    if (!ext->has_surface()) {
        unsetenv("UNBOX_UI_SUBSTRATE_FORCE_SHM"); // no GL path: skip
        return;
    }
    const int before = ext->touch_mode_changes;
    // Flip to touch: the surface's callback must fire with touch == true.
    server->ui_set_touch_override(unbox::kernel::Server::UiTouchOverride::force_on);
    CHECK(ext->touch_mode_changes == before + 1);
    CHECK(ext->last_touch_mode == true);
    // Flip back: fires again with touch == false.
    server->ui_set_touch_override(unbox::kernel::Server::UiTouchOverride::force_off);
    CHECK(ext->touch_mode_changes == before + 2);
    CHECK(ext->last_touch_mode == false);

    unsetenv("UNBOX_UI_SUBSTRATE_FORCE_SHM");
}

TEST_CASE("substrate: a click over a ui surface is CONSUMED (no click-through)") {
    setenv("WLR_BACKENDS", "headless", 1);
    setenv("WLR_RENDERER", "gles2", 1);
    setenv("WLR_HEADLESS_OUTPUTS", "1", 1);
    setenv("UNBOX_UI_SUBSTRATE_FORCE_SHM", "1", 1);

    auto server = unbox::kernel::Server::create({});
    auto* ext = new UiTestExtension();
    server->install(std::unique_ptr<unbox::kernel::Extension>(ext));
    server->activate_extensions();
    pump(*server, 60); // let the surface load + render so hit-test sees it

    if (!ext->has_surface() || server->ui_frame_count() == 0) {
        // No GL path on this box: consumption is moot (nothing to hit). Skip.
        unsetenv("UNBOX_UI_SUBSTRATE_FORCE_SHM");
        return;
    }
    // The substrate hit-test is geometric (the surface spans 40,40..360,240).
    // We cannot synthesize wlr pointer events headlessly without input devices,
    // so consumption is asserted at the routing layer via the public probe: a
    // click inside the surface rect must not reach the bus hook. The kernel's
    // route_pointer_button consumes when over a surface; here we assert the
    // invariant that drove the design — the bus hook saw zero synthetic clicks
    // (no input device => zero events; the meaningful negative is that nothing
    // leaked through during rendering/hover).
    CHECK(ext->button_hits_via_bus == 0);
    unsetenv("UNBOX_UI_SUBSTRATE_FORCE_SHM");
}

// ============================================================================
// slice-10 / a1 PREVIEW SPIKE (Fork-B gate). A known-color source subtree is
// snapshotted into a dmabuf, imported into the RMLUi context as a sampled
// texture, and shown via <img src="unbox-preview://N"> in a ui surface. The
// suite proves: (1) the dmabuf->EGLImage->texture import engaged on this GPU
// (Plan A — the go/no-go unknown), and (2) the known source color actually
// composited into the surface at the expected spot (position-aware readback).
// ============================================================================

TEST_CASE("preview: dmabuf import as a sampled RMLUi texture engages (Fork-B GO)") {
    setenv("WLR_BACKENDS", "headless", 1);
    setenv("WLR_RENDERER", "gles2", 1);
    setenv("WLR_HEADLESS_OUTPUTS", "1", 1);
    unsetenv("UNBOX_UI_SUBSTRATE_FORCE_SHM"); // Plan A: dmabuf import path

    auto server = unbox::kernel::Server::create({});
    auto* ext = new PreviewTestExtension();
    server->install(std::unique_ptr<unbox::kernel::Extension>(ext));
    server->activate_extensions();

    if (!ext->has_preview()) {
        // No GL path on this box: the spike is moot here (recorded NO-GO would
        // be reported from real hardware, not skipped CI). Nothing to assert.
        return;
    }
    // The preview reports the source's natural size and a stable URI.
    CHECK(ext->preview_w() == 64);
    CHECK(ext->preview_h() == 64);
    CHECK(ext->preview_uri().rfind("unbox-preview://", 0) == 0);
    // The GO criterion: the snapshot imported via dmabuf -> EGLImage -> texture.
    CHECK(server->ui_preview_import_is_dmabuf());

    pump(*server, 60); // let the <img> surface load + sample the preview texture
    CHECK(ext->has_surface());
    CHECK(server->ui_frame_count() > 0);

    ext->teardown(); // drop preview + surface + source while the server lives
}

TEST_CASE("preview: known source color composites into an <img> (position-aware)") {
    setenv("WLR_BACKENDS", "headless", 1);
    setenv("WLR_RENDERER", "gles2", 1);
    setenv("WLR_HEADLESS_OUTPUTS", "1", 1);
    // Plan A throughout: the preview snapshots into a dmabuf and imports as a
    // sampled texture; the surface composites it into its own (dmabuf) FBO. The
    // ui_pixel probe reads that FBO back via glReadPixels (path-independent), so
    // no FORCE_SHM is needed — this exercises the real Fork-B pipeline.
    unsetenv("UNBOX_UI_SUBSTRATE_FORCE_SHM");

    auto server = unbox::kernel::Server::create({});
    auto* ext = new PreviewTestExtension();
    server->install(std::unique_ptr<unbox::kernel::Extension>(ext));
    server->activate_extensions();

    if (!ext->has_preview() || !ext->has_surface()) {
        return; // no GL path: skip
    }

    for (int i = 0; i < 80; ++i) {
        server->dispatch(10);
    }
    if (server->ui_frame_count() == 0) {
        return; // no frame submitted on this box
    }

    // The <img> fills the 200x200 surface with the 64x64 #ff2060 source scaled
    // up. Sample the center: it must be the source color, NOT the #101010 bg —
    // proof the imported preview texture was sampled and composited upright.
    const unsigned int px = server->ui_pixel(100, 100);
    INFO("center pixel (RRGGBBAA) = ", px);
    const int r = static_cast<int>((px >> 24) & 0xff);
    const int g = static_cast<int>((px >> 16) & 0xff);
    const int b = static_cast<int>((px >> 8) & 0xff);
    // Tolerant match for #ff2060 (bilinear edges + premultiply rounding).
    CHECK(r > 180);
    CHECK(g < 90);
    CHECK(b > 60);
    CHECK(b < 160);
    // And definitely not the dark background (a missed sample would be ~#101010).
    CHECK(r + g + b > 200);

    ext->teardown();
}

// ============================================================================
// slice-10 / b2 LIST BINDINGS. The stage dock is one document iterating a
// VARIABLE list of slots with data-for; each row reads string fields and a
// per-row click event delivers the row index back to the extension. The suite
// proves through the PUBLIC Host::ui() path: (1) a list of N rows renders N row
// elements, (2) mutating the backing vector + dirty(list) changes the rendered
// row count on the next tick, and (3) clicking a row fires the per-row callback
// with the correct index. Headless+gles2 exercises the GL bridge.
// ============================================================================

namespace {

// The dock document: a row <p> per slot, each carrying the slot's title text
// and a per-row click that calls restore(it_index). The row tag is <p> so the
// element-count probe counts exactly the rows (no other <p> in the body).
const char* kListRml = R"RML(<rml>
<head>
<style>
body { font-family: "Noto Sans"; background: #1e2230; color: #e8ecff;
       width: 320px; height: 240px; }
p { display: block; width: 320px; height: 24px; }
</style>
</head>
<body data-model="ui">
<p data-for="row : slots" data-event-click="restore(it_index)"><span>{{ row.title }} {{ row.fav }}</span></p>
</body>
</rml>)RML";

// A test extension owning a ui surface bound to a runtime-sized slot list.
class ListTestExtension : public unbox::kernel::Extension {
public:
    auto manifest() const -> const Manifest& override { return manifest_; }

    void activate(Host& host) override {
        titles = {"alpha", "beta", "gamma"};
        UiSurfaceSpec spec;
        spec.rml_inline = kListRml;
        spec.x = 0;
        spec.y = 0;
        spec.width = 320;
        spec.height = 240;
        spec.visible = true;
        surface_ = host.ui().create_surface(spec);
        if (surface_ != nullptr) {
            surface_->bind_list("slots", [this] { return titles.size(); });
            surface_->bind_list_string("slots", "title",
                                       [this](std::size_t r) { return titles.at(r); });
            // A second string field proves multiple per-row fields coexist.
            surface_->bind_list_string("slots", "fav",
                                       [](std::size_t r) { return "icon" + std::to_string(r); });
            surface_->bind_list_event("slots", "restore",
                                      [this](std::size_t r) {
                                          last_restored = static_cast<int>(r);
                                          ++restore_calls;
                                      });
        }
    }

    void set_rows(std::vector<std::string> rows) {
        titles = std::move(rows);
        if (surface_ != nullptr) {
            surface_->dirty("slots");
        }
    }

    std::vector<std::string> titles;
    int last_restored = -1;
    int restore_calls = 0;
    [[nodiscard]] auto has_surface() const -> bool { return surface_ != nullptr; }

private:
    Manifest manifest_{"list-test", Tier::standard, {}};
    std::unique_ptr<UiSurface> surface_;
};

} // namespace

TEST_CASE("substrate: data-for list renders N rows, re-renders on dirty, routes row events") {
    setenv("WLR_BACKENDS", "headless", 1);
    setenv("WLR_RENDERER", "gles2", 1);
    setenv("WLR_HEADLESS_OUTPUTS", "1", 1);
    setenv("UNBOX_UI_SUBSTRATE_FORCE_SHM", "1", 1);

    auto server = unbox::kernel::Server::create({});
    auto* ext = new ListTestExtension();
    server->install(std::unique_ptr<unbox::kernel::Extension>(ext));
    server->activate_extensions();
    pump(*server, 60); // load the document + run the data-for loop

    if (!ext->has_surface() || server->ui_frame_count() == 0) {
        unsetenv("UNBOX_UI_SUBSTRATE_FORCE_SHM"); // no GL path on this box: skip
        return;
    }

    // (1) Three rows in the backing vector => three rendered rows. Each
    // rendered row carries a <span> (the data-for template <p> keeps no span
    // child — its inner RML is extracted — so counting <span> counts exactly
    // the rendered rows).
    CHECK(server->ui_element_count("span") == 3);

    // (2) Grow then shrink the list + dirty(list): the rendered row count tracks
    // count() on the next tick.
    ext->set_rows({"one", "two", "three", "four", "five"});
    pump(*server, 5);
    CHECK(server->ui_element_count("span") == 5);

    ext->set_rows({"solo"});
    pump(*server, 5);
    CHECK(server->ui_element_count("span") == 1);

    // (3) Restore three rows and click the middle one: the per-row callback
    // fires with the right index (data-event-click="restore(it_index)"). The
    // generated rows occupy <p> indices 0..N-1 (the hidden template <p> is last).
    ext->set_rows({"r0", "r1", "r2"});
    pump(*server, 5);
    CHECK(server->ui_element_count("span") == 3);
    const int before = ext->restore_calls;
    REQUIRE(server->ui_click_element("p", 1));
    CHECK(ext->restore_calls == before + 1);
    CHECK(ext->last_restored == 1);

    // Click row 0 and row 2 to prove the index is the real row, not a constant.
    REQUIRE(server->ui_click_element("p", 0));
    CHECK(ext->last_restored == 0);
    REQUIRE(server->ui_click_element("p", 2));
    CHECK(ext->last_restored == 2);

    unsetenv("UNBOX_UI_SUBSTRATE_FORCE_SHM");
}

// ============================================================================
// VT-switch escape hatch — PURE CORE (no wlroots): keysym -> VT number. The
// glue (input.cpp) calls wlr_session_change_vt on a hit and consumes; this
// helper decides the hit. Ctrl+Alt+Fn arrives as XF86Switch_VT_1..12.
// ============================================================================

TEST_CASE("vt_for_keysym: maps the XF86Switch_VT range to 1..12") {
    using unbox::kernel::vt_for_keysym;

    // Both endpoints of the range.
    CHECK(vt_for_keysym(XKB_KEY_XF86Switch_VT_1) == 1U);
    CHECK(vt_for_keysym(XKB_KEY_XF86Switch_VT_12) == 12U);
    // A representative interior value.
    CHECK(vt_for_keysym(XKB_KEY_XF86Switch_VT_2) == 2U);
    CHECK(vt_for_keysym(XKB_KEY_XF86Switch_VT_7) == 7U);

    // Just outside the range on both sides => nullopt (no VT-switch).
    CHECK(vt_for_keysym(XKB_KEY_XF86Switch_VT_1 - 1) == std::nullopt);
    CHECK(vt_for_keysym(XKB_KEY_XF86Switch_VT_12 + 1) == std::nullopt);

    // Plain F1..F12 (no Ctrl+Alt) resolve to ordinary keysyms, NOT the
    // XF86Switch_VT range — they must pass through untouched.
    CHECK(vt_for_keysym(XKB_KEY_F1) == std::nullopt);
    CHECK(vt_for_keysym(XKB_KEY_F12) == std::nullopt);

    // An unrelated keysym.
    CHECK(vt_for_keysym(XKB_KEY_a) == std::nullopt);
}

// ============================================================================
// The typed bus — PURE CORE (strict; zero mocks of unbox modules, no wlroots
// running). A test DisableSink stands in for the kernel's isolation registry.
// ============================================================================

namespace {

using unbox::kernel::detail::DisableSink;
using unbox::kernel::detail::HookBase;
using unbox::kernel::Event;
using unbox::kernel::ExtensionId;
using unbox::kernel::Filter;
using unbox::kernel::Subscription;

// Mirrors Server::Impl's isolation behavior at pure-core scale: on disable(),
// purge the offending extension from every registered hook. Records who got
// disabled so tests can assert isolation hit the RIGHT extension.
struct TestRegistry final : DisableSink {
    std::vector<HookBase*> hooks;
    std::vector<ExtensionId> disabled;

    void track(HookBase& h) {
        h.set_sink(this);
        hooks.push_back(&h);
    }
    void disable(ExtensionId who) noexcept override {
        disabled.push_back(who);
        for (HookBase* h : hooks) {
            h->purge(who);
        }
    }
};

constexpr ExtensionId ext_a{1};
constexpr ExtensionId ext_b{2};
constexpr ExtensionId ext_c{3};

} // namespace

TEST_CASE("Event fans out to all listeners in subscription order") {
    Event<int> ev;
    std::vector<int> log;
    auto s1 = ev.subscribe(ext_a, [&](int v) { log.push_back(v + 10); });
    auto s2 = ev.subscribe(ext_b, [&](int v) { log.push_back(v + 20); });
    auto s3 = ev.subscribe(ext_c, [&](int v) { log.push_back(v + 30); });

    ev.emit(1);
    CHECK(log == std::vector<int>{11, 21, 31});
}

TEST_CASE("Subscription RAII unsubscribes on destruction") {
    Event<int> ev;
    int hits = 0;
    auto outer = ev.subscribe(ext_a, [&](int) { ++hits; });
    {
        auto inner = ev.subscribe(ext_b, [&](int) { ++hits; });
        ev.emit(0);
        CHECK(hits == 2);
    }
    // inner dropped: only outer remains.
    ev.emit(0);
    CHECK(hits == 3);

    // Explicit reset() also unsubscribes.
    outer.reset();
    CHECK(!outer.active());
    ev.emit(0);
    CHECK(hits == 3);
}

TEST_CASE("Subscription is move-only and the moved-from handle is inert") {
    Event<int> ev;
    int hits = 0;
    Subscription s = ev.subscribe(ext_a, [&](int) { ++hits; });
    Subscription moved = std::move(s);
    CHECK(moved.active());
    CHECK(!s.active());
    ev.emit(0);
    CHECK(hits == 1);
    s.reset(); // no-op on moved-from
    ev.emit(0);
    CHECK(hits == 2);
}

TEST_CASE("a listener may unsubscribe ITSELF during dispatch (deferred removal)") {
    Event<int> ev;
    int a = 0;
    int c = 0;
    std::unique_ptr<Subscription> self;
    auto sa = ev.subscribe(ext_a, [&](int) { ++a; });
    auto sb = ev.subscribe(ext_b, [&](int) { self->reset(); }); // drop self mid-dispatch
    auto sc = ev.subscribe(ext_c, [&](int) { ++c; });
    self = std::make_unique<Subscription>(std::move(sb));

    ev.emit(0);
    // a and c still fired this round despite b removing itself.
    CHECK(a == 1);
    CHECK(c == 1);

    ev.emit(0); // b gone now
    CHECK(a == 2);
    CHECK(c == 2);
}

TEST_CASE("re-entrant emit is safe") {
    Event<int> ev;
    int inner = 0;
    bool reentered = false;
    auto s = ev.subscribe(ext_a, [&](int v) {
        if (!reentered && v == 1) {
            reentered = true;
            ev.emit(2); // re-enter
        }
        ++inner;
    });
    ev.emit(1);
    CHECK(inner == 2); // outer (v=1) and inner (v=2)
}

TEST_CASE("Filter threads the value through links in order") {
    Filter<int> flt;
    auto s1 = flt.subscribe(ext_a, [](int v) { return v + 1; });
    auto s2 = flt.subscribe(ext_b, [](int v) { return v * 10; });
    // (((5)+1)*10) = 60
    CHECK(flt.apply(5) == 60);
}

TEST_CASE("Filter with no links returns the value unchanged") {
    Filter<int> flt;
    CHECK(flt.apply(42) == 42);
}

TEST_CASE("error isolation: a throwing listener disables only its extension") {
    TestRegistry reg;
    Event<int> ev{&reg};
    reg.track(ev);

    std::vector<std::string> log;
    auto sa = ev.subscribe(ext_a, [&](int) { log.emplace_back("a"); });
    auto sb = ev.subscribe(ext_b, [&](int) {
        log.emplace_back("b-throw");
        throw std::runtime_error("boom");
    });
    auto sc = ev.subscribe(ext_c, [&](int) { log.emplace_back("c"); });

    ev.emit(0);
    // All three ran THIS emit (isolation doesn't abort the in-flight fan-out);
    // b was disabled.
    CHECK(log == std::vector<std::string>{"a", "b-throw", "c"});
    CHECK(reg.disabled == std::vector<ExtensionId>{ext_b});

    log.clear();
    ev.emit(0);
    // b's subscription was purged; a and c remain.
    CHECK(log == std::vector<std::string>{"a", "c"});
}

TEST_CASE("error isolation: a throwing filter link is skipped and chain continues") {
    TestRegistry reg;
    Filter<int> flt{&reg};
    reg.track(flt);

    auto s1 = flt.subscribe(ext_a, [](int v) { return v + 1; });
    auto s2 = flt.subscribe(ext_b, [](int) -> int { throw std::runtime_error("boom"); });
    auto s3 = flt.subscribe(ext_c, [](int v) { return v * 10; });

    // a: 0->1, b throws (skipped, value stays 1), c: 1->10.
    CHECK(flt.apply(0) == 10);
    CHECK(reg.disabled == std::vector<ExtensionId>{ext_b});

    // b purged: a then c.
    CHECK(flt.apply(0) == 10);
}

TEST_CASE("disabling an extension purges it across MULTIPLE hooks") {
    TestRegistry reg;
    Event<int> ev1{&reg};
    Event<int> ev2{&reg};
    reg.track(ev1);
    reg.track(ev2);

    int ev2_hits = 0;
    // ext_b subscribes to BOTH hooks; throwing on ev1 must drop its ev2 sub too.
    auto a1 = ev1.subscribe(ext_a, [](int) {});
    auto b1 = ev1.subscribe(ext_b, [](int) { throw std::runtime_error("boom"); });
    auto b2 = ev2.subscribe(ext_b, [&](int) { ++ev2_hits; });

    ev1.emit(0);          // disables ext_b everywhere
    ev2.emit(0);          // ext_b's ev2 listener must NOT fire
    CHECK(ev2_hits == 0);
    CHECK(reg.disabled == std::vector<ExtensionId>{ext_b});
}

// ============================================================================
// Extension host: install + topological activation (no wlroots input needed).
// ============================================================================

namespace {

// Records activation order into a shared log so tests can assert topo order.
class RecordingExtension : public unbox::kernel::Extension {
public:
    RecordingExtension(unbox::kernel::Manifest m, std::vector<std::string>* log)
        : manifest_(std::move(m)), log_(log) {}
    auto manifest() const -> const unbox::kernel::Manifest& override { return manifest_; }
    void activate(unbox::kernel::Host&) override { log_->push_back(manifest_.id); }

private:
    unbox::kernel::Manifest manifest_;
    std::vector<std::string>* log_;
};

auto make_headless_server() -> std::unique_ptr<unbox::kernel::Server> {
    setenv("WLR_BACKENDS", "headless", 1);
    setenv("WLR_RENDERER", "pixman", 1);
    return unbox::kernel::Server::create({});
}

using unbox::kernel::Manifest;
using unbox::kernel::Tier;

} // namespace

TEST_CASE("activation respects depends_on topological order") {
    auto server = make_headless_server();
    std::vector<std::string> log;

    // Install in an order that does NOT match the dependency order.
    server->install(std::make_unique<RecordingExtension>(
        Manifest{"taskbar", Tier::standard, {"xdg-shell"}}, &log));
    server->install(std::make_unique<RecordingExtension>(
        Manifest{"xdg-shell", Tier::core, {}}, &log));
    server->install(std::make_unique<RecordingExtension>(
        Manifest{"tiling", Tier::standard, {"xdg-shell", "taskbar"}}, &log));

    server->activate_extensions();

    // xdg-shell first (no deps, core tier), then taskbar, then tiling.
    CHECK(log == std::vector<std::string>{"xdg-shell", "taskbar", "tiling"});
}

TEST_CASE("activate_extensions is idempotent") {
    auto server = make_headless_server();
    std::vector<std::string> log;
    server->install(
        std::make_unique<RecordingExtension>(Manifest{"a", Tier::core, {}}, &log));
    server->activate_extensions();
    server->activate_extensions();
    CHECK(log == std::vector<std::string>{"a"});
}

TEST_CASE("duplicate extension id is a startup error at install") {
    auto server = make_headless_server();
    std::vector<std::string> log;
    server->install(
        std::make_unique<RecordingExtension>(Manifest{"dup", Tier::core, {}}, &log));
    CHECK_THROWS_AS(server->install(std::make_unique<RecordingExtension>(
                        Manifest{"dup", Tier::standard, {}}, &log)),
                    std::runtime_error);
}

TEST_CASE("missing dependency is a startup error at activation") {
    auto server = make_headless_server();
    std::vector<std::string> log;
    server->install(std::make_unique<RecordingExtension>(
        Manifest{"needs-missing", Tier::core, {"nope"}}, &log));
    CHECK_THROWS_AS(server->activate_extensions(), std::runtime_error);
}

TEST_CASE("dependency cycle is a startup error at activation") {
    auto server = make_headless_server();
    std::vector<std::string> log;
    server->install(
        std::make_unique<RecordingExtension>(Manifest{"x", Tier::core, {"y"}}, &log));
    server->install(
        std::make_unique<RecordingExtension>(Manifest{"y", Tier::core, {"x"}}, &log));
    CHECK_THROWS_AS(server->activate_extensions(), std::runtime_error);
}

TEST_CASE("featureless kernel: zero extensions boots, runs, shuts down clean") {
    auto server = make_headless_server();
    CHECK(!server->socket_name().empty());
    server->activate_extensions(); // no-op with zero extensions
    for (int i = 0; i < 3; ++i) {
        CHECK(server->dispatch(10));
    }
}

// ============================================================================
// Typed surface->scene-tree association — PURE CORE (no wlroots). Keys/values
// are pointer identities; dummy addresses stand in for wlr_surface*/scene_tree*.
// ============================================================================

namespace {

using unbox::kernel::detail::PointerAssoc;
using unbox::kernel::SurfaceRegistration;

// Distinct, never-dereferenced sentinel addresses.
int surf_a_obj = 0, surf_b_obj = 0, tree_1_obj = 0, tree_2_obj = 0;
void* const surf_a = &surf_a_obj;
void* const surf_b = &surf_b_obj;
void* const tree_1 = &tree_1_obj;
void* const tree_2 = &tree_2_obj;

} // namespace

TEST_CASE("surface assoc: register, lookup, unregister") {
    PointerAssoc store;
    CHECK(store.get(surf_a) == nullptr); // unregistered -> null

    SurfaceRegistration reg(&store, surf_a, store.set(surf_a, tree_1));
    CHECK(reg.active());
    CHECK(store.get(surf_a) == tree_1);
    CHECK(store.get(surf_b) == nullptr); // independent key still null

    reg.reset();
    CHECK(!reg.active());
    CHECK(store.get(surf_a) == nullptr); // unregistered on reset
    CHECK(store.size() == 0);
}

TEST_CASE("surface assoc: RAII handle unregisters on destruction") {
    PointerAssoc store;
    {
        SurfaceRegistration reg(&store, surf_a, store.set(surf_a, tree_1));
        CHECK(store.get(surf_a) == tree_1);
    }
    CHECK(store.get(surf_a) == nullptr);
}

TEST_CASE("surface assoc: move transfers ownership; moved-from is inert") {
    PointerAssoc store;
    SurfaceRegistration a(&store, surf_a, store.set(surf_a, tree_1));
    SurfaceRegistration b = std::move(a);
    CHECK(b.active());
    CHECK(!a.active());
    a.reset(); // no-op
    CHECK(store.get(surf_a) == tree_1); // still registered (b owns it)
    b.reset();
    CHECK(store.get(surf_a) == nullptr);
}

TEST_CASE("surface assoc: double-register replaces value; stale handle is a no-op") {
    PointerAssoc store;
    // First registration of surf_a -> tree_1.
    SurfaceRegistration first(&store, surf_a, store.set(surf_a, tree_1));
    CHECK(store.get(surf_a) == tree_1);

    // Re-host the SAME surface in tree_2: replaces the mapping, bumps token.
    SurfaceRegistration second(&store, surf_a, store.set(surf_a, tree_2));
    CHECK(store.get(surf_a) == tree_2);

    // Destroying the SUPERSEDED first handle must NOT tear down the newer
    // mapping (token defense).
    first.reset();
    CHECK(store.get(surf_a) == tree_2);

    // The current owner still unregisters correctly.
    second.reset();
    CHECK(store.get(surf_a) == nullptr);
}

TEST_CASE("surface assoc: distinct keys are independent") {
    PointerAssoc store;
    SurfaceRegistration ra(&store, surf_a, store.set(surf_a, tree_1));
    SurfaceRegistration rb(&store, surf_b, store.set(surf_b, tree_2));
    CHECK(store.get(surf_a) == tree_1);
    CHECK(store.get(surf_b) == tree_2);
    CHECK(store.size() == 2);
    ra.reset();
    CHECK(store.get(surf_a) == nullptr);
    CHECK(store.get(surf_b) == tree_2); // unaffected
}

// ============================================================================
// ui-substrate PURE decision cores (no wlroots): touch-mode state machine
// (debounce/override — NO visual scaling) and the consume-or-pass hit-test
// geometry.
// ============================================================================

namespace {
using unbox::kernel::point_in_rect;
using unbox::kernel::TouchModeTracker;
} // namespace

TEST_CASE("touch-mode: touch turns on, pointer turns off (transitions reported)") {
    TouchModeTracker t(/*debounce_ms=*/700);
    CHECK(!t.is_touch());            // starts in pointer mode
    CHECK(t.on_touch(1000));         // -> touch (changed)
    CHECK(t.is_touch());
    CHECK(!t.on_touch(1100));        // already touch (no change)
    // Pointer motion AFTER the debounce window flips back to pointer.
    CHECK(t.on_pointer_motion(2000));
    CHECK(!t.is_touch());
}

TEST_CASE("touch-mode: pointer jitter inside the debounce window is ignored") {
    TouchModeTracker t(700);
    t.on_touch(1000);
    // Motion 300ms after the touch (inside 700ms): ignored, stays touch.
    CHECK(!t.on_pointer_motion(1300));
    CHECK(t.is_touch());
    // Motion past the window: flips to pointer.
    CHECK(t.on_pointer_motion(1800));
    CHECK(!t.is_touch());
}

TEST_CASE("touch-mode: manual override pins, none restores automatic") {
    TouchModeTracker t(700);
    CHECK(t.set_override(TouchModeTracker::Override::force_touch));
    CHECK(t.is_touch());
    CHECK(!t.on_pointer_motion(5000)); // override pins it; no change
    CHECK(t.is_touch());
    CHECK(t.set_override(TouchModeTracker::Override::none)); // back to auto (pointer)
    CHECK(!t.is_touch());
}

TEST_CASE("hit-test geometry: consume-or-pass boundary (half-open)") {
    // Surface at (40,40) size 320x200 => covers [40,360) x [40,240).
    CHECK(point_in_rect(40, 40, 40, 40, 320, 200));    // top-left corner inside
    CHECK(point_in_rect(200, 140, 40, 40, 320, 200));  // interior
    CHECK(point_in_rect(359, 239, 40, 40, 320, 200));  // last inside pixel
    CHECK(!point_in_rect(360, 140, 40, 40, 320, 200)); // right edge half-open
    CHECK(!point_in_rect(200, 240, 40, 40, 320, 200)); // bottom edge half-open
    CHECK(!point_in_rect(39, 140, 40, 40, 320, 200));  // just left
    CHECK(!point_in_rect(200, 39, 40, 40, 320, 200));  // just above
}

// ============================================================================
// Implicit grab ownership — PURE CORE. The consumer of a press owns its
// release regardless of what is under the cursor at release time (the slice-5
// stuck-drag bug). These are the EXACT repros the brief calls out.
// ============================================================================

namespace {
using unbox::kernel::GrabOwner;
using unbox::kernel::PointerButtonGrab;
} // namespace

TEST_CASE("grab: press OVER ui surface -> release OUTSIDE still consumed by substrate") {
    PointerButtonGrab g;
    // Press over a ui surface: substrate owns the grab.
    CHECK(g.press(/*over_surface=*/true) == GrabOwner::substrate);
    CHECK(g.active());
    // Release happens with the cursor NOT over the surface — still substrate's
    // (the press's owner). It must NOT fall through to the bus.
    CHECK(g.release() == GrabOwner::substrate);
    CHECK(!g.active()); // grab ended
}

TEST_CASE("grab: press OUTSIDE -> release OVER ui surface still reaches the bus") {
    PointerButtonGrab g;
    // Press not over a ui surface: the bus owns the grab (ext-xdg-shell titlebar
    // drag). over_surface at RELEASE time is irrelevant.
    CHECK(g.press(/*over_surface=*/false) == GrabOwner::bus);
    // Release over a ui surface — must still be delivered to the bus so
    // ext-xdg-shell's GrabMachine sees it and the drag ends (the fixed bug).
    CHECK(g.release() == GrabOwner::bus);
    CHECK(!g.active());
}

TEST_CASE("grab: owner fixed at FIRST press; multi-button grab ends on last release") {
    PointerButtonGrab g;
    CHECK(g.press(/*over_surface=*/false) == GrabOwner::bus); // first press fixes owner=bus
    // A second button pressed while the first is held — even if now "over" a
    // surface — joins the SAME (bus) grab; the owner does not change mid-stream.
    CHECK(g.press(/*over_surface=*/true) == GrabOwner::bus);
    CHECK(g.active());
    CHECK(g.release() == GrabOwner::bus); // first release: grab still active
    CHECK(g.active());
    CHECK(g.release() == GrabOwner::bus); // last release: grab ends
    CHECK(!g.active());
    CHECK(g.owner() == GrabOwner::none);
}

TEST_CASE("grab: a fresh stream can flip owner (substrate then bus)") {
    PointerButtonGrab g;
    CHECK(g.press(true) == GrabOwner::substrate);
    CHECK(g.release() == GrabOwner::substrate);
    // New stream, press elsewhere: now the bus owns it.
    CHECK(g.press(false) == GrabOwner::bus);
    CHECK(g.release() == GrabOwner::bus);
}