switch (event->state) {

    case WL_POINTER_BUTTON_STATE_PRESSED:

        if (cursor_mode != CURSOR_NORMAL && cursor_mode != CURSOR_PRESSED)

            break;

        pressed_button = event->button;

        if (locked)

            break;

        /* Focus a window when a button is pressed over it. */

            tiled_resize_boundary(

                selmon, (int)round(cursor->x), (int)round(cursor->y), &grab_horizontal

            )) {

            grabws      = selmon->ws;

            cursor_mode = CURSOR_TILE_RESIZE;

            tiled_resize_cursor(true, grab_horizontal);

            return;

        }

        tiled_resize_cursor(false, false);

    if (!locked && event->state == WL_KEYBOARD_KEY_STATE_PRESSED) {

        for (i = 0; i < nsyms; i++)

            handled |= key_binding(mods, syms[i], 0);

    }

    if ((handled & 2) && group->wlr_group->keyboard.repeat_info.delay > 0) {

        wl_event_source_timer_update(

            group->key_repeat_source, group->wlr_group->keyboard.repeat_info.delay

        );

    } else {

        group->nsyms = 0;

    restore_max_stack(grabc->mon);

    /* Float the window and let pointer motion move or resize it. */

    grabc->persist_float = 1;

    set_floating(grabc, 1);

    switch (cursor_mode = arg->u) {

    case CURSOR_MOVE:

        grabcx = (int)round(cursor->x) - grabc->geom.x;

            client_assign_monitor(c, m);

            if (!c->is_fullscreen)

                c->prev = c->geom;

            resize(c, c->geom, 0);

        if (c->is_fullscreen)

            resize(c, m->m, 0);

    }

}

static void test_workspace_scale(void) {

    client_t                client;

    struct wlr_surface      surface = {};

    struct wlr_xdg_surface  xdg;

    struct wlr_xdg_toplevel toplevel;

    workspace_t             workspace = {};

    init_xdg_client(&client, &xdg, &toplevel, "app", "Window");

    fractional_scale = 0;

    wl_list_init(&clients);

    wl_list_insert(&clients, &client.link);

    assign_workspace(&workspace, &monitor);

    assert(client.mon == &monitor);

    assert(scaled_surface == &surface);

    assert(fractional_scale == 2.0f);

    assert(buffer_scale == 2);

    wl_list_remove(&client.link);

}

/* Verify matching rules update client state and workspace assignment. */

static void test_rule_application(void) {

    client_t                client;

    struct wlr_xdg_surface  surface;

    struct wlr_xdg_toplevel toplevel;

    struct wlr_pointer_swipe_end_event    swipe_end    = { .time_msec = 3, .cancelled = false };

    struct wlr_pointer_pinch_begin_event  pinch_begin  = { .time_msec = 4, .fingers = 2 };

    struct wlr_pointer_pinch_update_event pinch_update = {

        .time_msec = 5,

        .dx        = 1,

        .dy        = 2,

        .scale     = 1.1,

        .rotation  = 3,

    };

    struct wlr_pointer_pinch_end_event  pinch_end  = { .time_msec = 6, .cancelled = true };

        .state  = WL_POINTER_BUTTON_STATE_RELEASED,

    };

    struct wlr_cursor fake_cursor = {};

    client_t          client      = {};

    client.persist_float = 0;

    button_press(nullptr, &event);

    assert(cursor_mode == CURSOR_MOVE);

    assert(grabc == &client);

}

/* Verify an implicit-output panel keeps its assigned output when it unmaps. */

static void test_layer_unmap_monitor(void) {

    monitor_t                   monitor = {};

    layer_surface_t             wrapper = {

    };

    assert(layer_surface_output_monitor(&wrapper) == &monitor);

}

        { "workspaces", test_workspace_queries },

        { "paths-and-borders", test_paths_and_border_policy },

        { "rules", test_rule_application },

        { "focus", test_focus_queries },

        { "workspace-scale", test_workspace_scale },

        { "window-state", test_window_state_storage },

        { "child-reaping", test_child_reaping },

        { "spawn-tracking", test_spawn_tracking },

        { "layer-unmap-monitor", test_layer_unmap_monitor },

        { "command-failure-notification", test_command_failure_notification },