use crate::a11y::A11yTree;
use crate::input::driver::CoordinatorDriver;
use crate::input::{InputCoordinator, WidgetResponse};
use crate::types::WidgetId;
use super::events::EventSynthesizer;
pub struct TestHarness {
pub coordinator: InputCoordinator,
pub events: EventSynthesizer,
frame_a11y: A11yTree,
}
pub struct FrameOutcome {
pub responses: Vec<(WidgetId, WidgetResponse)>,
pub a11y: A11yTree,
}
impl Default for TestHarness {
fn default() -> Self {
Self::new()
}
}
impl TestHarness {
pub fn new() -> Self {
Self {
coordinator: InputCoordinator::new(),
events: EventSynthesizer::new(),
frame_a11y: A11yTree::new(),
}
}
pub fn frame<R>(
&mut self,
build: impl FnOnce(&mut InputCoordinator, &mut A11yTree) -> R,
) -> (R, FrameOutcome) {
self.coordinator.begin_frame(self.events.input_state());
self.frame_a11y.clear();
let result = build(&mut self.coordinator, &mut self.frame_a11y);
let responses = self.coordinator.end_frame();
self.events.end_frame();
(
result,
FrameOutcome {
responses,
a11y: self.frame_a11y.clone(),
},
)
}
pub fn settle<R>(
&mut self,
build: impl FnOnce(&mut InputCoordinator, &mut A11yTree) -> R,
) -> (R, FrameOutcome) {
self.frame(build)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::input::driver::CoordinatorDriver;
use crate::input::pointer::state::{InputState, MouseButton};
use crate::input::Sense;
use crate::types::{Rect, WidgetState};
fn register(coord: &mut InputCoordinator, id: WidgetId, rect: Rect) {
coord.register(id, rect, Sense::CLICK);
}
#[test]
fn click_through_a_trivial_widget_reports_clicked() {
let id = WidgetId::from("trivial-click");
let rect = Rect::new(0.0, 0.0, 40.0, 20.0);
let mut harness = TestHarness::new();
harness.frame(|coord, _| register(coord, id.clone(), rect));
harness.events.pointer_down(10.0, 10.0, MouseButton::Left);
harness.frame(|coord, _| register(coord, id.clone(), rect));
assert_eq!(harness.coordinator.widget_state(&id), WidgetState::Pressed);
harness.events.pointer_up(10.0, 10.0, MouseButton::Left);
let (_, outcome) = harness.frame(|coord, _| register(coord, id.clone(), rect));
let (_, response) = outcome
.responses
.iter()
.find(|(wid, _)| wid == &id)
.expect("clicked response must exist");
assert!(response.clicked);
}
#[test]
fn drag_in_while_held_does_not_press_the_widget_dragged_onto() {
let widget_a = WidgetId::from("drag-a");
let widget_b = WidgetId::from("drag-b");
let rect_a = Rect::new(0.0, 0.0, 50.0, 50.0);
let rect_b = Rect::new(100.0, 0.0, 50.0, 50.0);
let mut harness = TestHarness::new();
let build = |coord: &mut InputCoordinator, _: &mut A11yTree| {
register(coord, widget_a.clone(), rect_a);
register(coord, widget_b.clone(), rect_b);
};
harness.frame(build);
harness.events.pointer_down(25.0, 25.0, MouseButton::Left);
harness.frame(build);
assert_eq!(harness.coordinator.widget_state(&widget_a), WidgetState::Pressed);
harness.events.pointer_move(125.0, 25.0);
harness.frame(build);
assert_eq!(
harness.coordinator.widget_state(&widget_b),
WidgetState::Hovered,
"press-origin widget A must not transfer Pressed onto B on drag-in"
);
assert_eq!(harness.coordinator.widget_state(&widget_a), WidgetState::Normal);
assert!(
harness.coordinator.cook_state().drag_armed,
"a held press that travelled past DRAG_THRESHOLD_PX is armed as a drag"
);
}
fn response_for<'a>(outcome: &'a FrameOutcome, id: &WidgetId) -> Option<&'a WidgetResponse> {
outcome.responses.iter().find(|(wid, _)| wid == id).map(|(_, r)| r)
}
#[test]
fn quick_clicks_report_double_then_triple_and_a_slow_one_resets() {
let id = WidgetId::from("multi-click");
let rect = Rect::new(0.0, 0.0, 40.0, 20.0);
let mut harness = TestHarness::new();
let build = |coord: &mut InputCoordinator, _: &mut A11yTree| register(coord, id.clone(), rect);
harness.frame(build);
let click_at = |harness: &mut TestHarness, dt: f64, x: f64| {
harness.events.tick(dt);
harness.events.click(x, 10.0);
let (_, outcome) = harness.frame(build);
let r = response_for(&outcome, &id).expect("clicked response").clone();
assert!(r.clicked);
(r.double_clicked, r.triple_clicked, harness.coordinator.cook_state().click_count)
};
assert_eq!(click_at(&mut harness, 1.0, 10.0), (false, false, 1));
assert_eq!(click_at(&mut harness, 0.1, 11.0), (true, false, 2));
assert_eq!(click_at(&mut harness, 0.1, 11.0), (false, true, 3));
assert_eq!(click_at(&mut harness, 1.0, 11.0), (false, false, 1));
assert_eq!(click_at(&mut harness, 0.1, 30.0), (false, false, 1));
}
#[test]
fn a_host_that_stamps_no_time_never_reports_a_double_click() {
let id = WidgetId::from("unstamped");
let rect = Rect::new(0.0, 0.0, 40.0, 20.0);
let mut coord = InputCoordinator::new();
let mut input = InputState::new();
input.pointer.pos = Some((10.0, 10.0));
for _ in 0..3 {
input.pointer.clicked = Some(MouseButton::Left);
coord.begin_frame(input.clone());
register(&mut coord, id.clone(), rect);
let responses = coord.end_frame();
let (_, r) = responses.iter().find(|(wid, _)| wid == &id).expect("response");
assert!(r.clicked && !r.double_clicked && !r.triple_clicked);
assert_eq!(coord.cook_state().click_count, 1);
}
}
#[test]
fn a_pointer_grab_keeps_input_on_the_grabbing_widget_until_release() {
let handle = WidgetId::from("splitter");
let other = WidgetId::from("other");
let rect_h = Rect::new(0.0, 0.0, 10.0, 100.0);
let rect_o = Rect::new(50.0, 0.0, 100.0, 100.0);
let mut harness = TestHarness::new();
let build = |coord: &mut InputCoordinator, _: &mut A11yTree| {
register(coord, handle.clone(), rect_h);
register(coord, other.clone(), rect_o);
};
harness.frame(build);
harness.events.tick(0.5).pointer_down(5.0, 50.0, MouseButton::Left);
harness.frame(build);
harness.coordinator.grab_pointer(handle.clone());
harness.events.pointer_move(100.0, 50.0);
let (_, outcome) = harness.frame(build);
assert!(response_for(&outcome, &handle).is_some_and(|r| r.hovered), "grab keeps the handle hovered");
assert!(response_for(&outcome, &other).is_none_or(|r| !r.hovered), "the widget under the cursor is not hovered");
harness.events.pointer_up(100.0, 50.0, MouseButton::Left);
let (_, outcome) = harness.frame(build);
assert!(response_for(&outcome, &handle).is_some_and(|r| r.clicked));
assert!(response_for(&outcome, &other).is_none_or(|r| !r.clicked));
assert_eq!(harness.coordinator.cook_state().grabbed, None);
harness.events.pointer_move(101.0, 50.0);
let (_, outcome) = harness.frame(build);
assert!(response_for(&outcome, &other).is_some_and(|r| r.hovered));
}
#[test]
fn release_pointer_ends_a_grab_early() {
let mut coord = InputCoordinator::new();
coord.grab_pointer("h");
assert_eq!(coord.cook_state().grabbed, Some(WidgetId::from("h")));
coord.release_pointer();
assert_eq!(coord.cook_state().grabbed, None);
}
#[test]
fn settle_makes_a_first_time_registration_hoverable() {
let id = WidgetId::from("first-timer");
let rect = Rect::new(0.0, 0.0, 40.0, 20.0);
let mut harness = TestHarness::new();
harness.events.pointer_move(10.0, 10.0);
harness.frame(|coord, _| register(coord, id.clone(), rect));
assert_eq!(harness.coordinator.widget_state(&id), WidgetState::Normal);
harness.settle(|coord, _| register(coord, id.clone(), rect));
assert_eq!(harness.coordinator.widget_state(&id), WidgetState::Hovered);
}
}