271 lines
8.4 KiB
Rust
271 lines
8.4 KiB
Rust
use ai_app::ui::fixture::{PHONE_FRAME_MS, PHONE_SCALE, phone_size};
|
|
use iris::harness::{Harness, TouchScript};
|
|
use iris::prelude::*;
|
|
|
|
fn opened() -> (Harness, ai_app::ui::TranscriptScreen) {
|
|
let mut h = Harness::new(phone_size(), PHONE_SCALE);
|
|
let opened = ai_app::ui::fixture::open(&mut h.rsc, &mut h.state).expect("the fixture folds");
|
|
h.frame(0);
|
|
h.frame(PHONE_FRAME_MS);
|
|
(h, opened.screen)
|
|
}
|
|
|
|
fn script(name: &str, text: &str) -> TouchScript {
|
|
TouchScript::parse(text).unwrap_or_else(|e| panic!("{name}: {e}"))
|
|
}
|
|
|
|
fn offset(h: &mut Harness, screen: &ai_app::ui::TranscriptScreen) -> String {
|
|
(screen.list)(&mut h.rsc).anchor_position_display()
|
|
}
|
|
|
|
#[test]
|
|
fn a_recorded_flick_releases_with_a_velocity_and_flings_the_list() {
|
|
let (mut h, screen) = opened();
|
|
let before = offset(&mut h, &screen);
|
|
|
|
let flick = script("flick-120hz", include_str!("../touch/flick-120hz.touch"));
|
|
h.replay(&flick);
|
|
|
|
let velocity = (screen.list)(&mut h.rsc)
|
|
.fling_velocity()
|
|
.expect("the flick must release as a pan with a velocity, not a tap");
|
|
assert!(
|
|
(velocity - 15_250.0).abs() < 20.0,
|
|
"expected ~15250px/s from velocity_reference.py, got {velocity}"
|
|
);
|
|
|
|
const REFERENCE_MS: u64 = 2071;
|
|
const REFERENCE_PX: f32 = 11057.0;
|
|
let end = flick.end_ms() + REFERENCE_MS * 2;
|
|
let mut settled_at = None;
|
|
let mut t = flick.end_ms();
|
|
let middle = phone_size().y / 2.0;
|
|
let mut travelled = 0.0f32;
|
|
let mut tracked: Option<(RowKey, f32)> = None;
|
|
while t <= end {
|
|
h.frame(t);
|
|
let list = (screen.list)(&mut h.rsc);
|
|
tracked =
|
|
match tracked.and_then(|(key, was)| list.extent(key).map(|(now, _)| (key, was, now))) {
|
|
Some((key, was, now)) => {
|
|
travelled += (now - was).abs();
|
|
Some((key, now))
|
|
}
|
|
None => list
|
|
.key_at(middle)
|
|
.and_then(|key| list.extent(key).map(|(top, _)| (key, top))),
|
|
};
|
|
if settled_at.is_none() && !(screen.list)(&mut h.rsc).is_scrolling() {
|
|
settled_at = Some(t);
|
|
}
|
|
t += PHONE_FRAME_MS;
|
|
}
|
|
|
|
let after = offset(&mut h, &screen);
|
|
assert_ne!(
|
|
before, after,
|
|
"the fling ticks must have moved the list off where the flick left it"
|
|
);
|
|
let settled_at = settled_at.expect("the fling must stop on its own, not run forever");
|
|
let ran_for = settled_at - flick.end_ms();
|
|
assert!(
|
|
ran_for >= REFERENCE_MS - PHONE_FRAME_MS * 2,
|
|
"the fling stopped after {ran_for}ms against the spline reference's {REFERENCE_MS}ms"
|
|
);
|
|
assert!(
|
|
ran_for <= REFERENCE_MS + PHONE_FRAME_MS * 2,
|
|
"the fling ran {ran_for}ms against the spline reference's {REFERENCE_MS}ms"
|
|
);
|
|
assert!(
|
|
travelled >= REFERENCE_PX * 0.8,
|
|
"the fling travelled {travelled:.0}px against the spline reference's {REFERENCE_PX:.0}px"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_tap_on_a_row_moves_nothing() {
|
|
let (mut h, screen) = opened();
|
|
let before = offset(&mut h, &screen);
|
|
|
|
h.replay(&script("tap", include_str!("../touch/tap.touch")));
|
|
|
|
assert_eq!(
|
|
(screen.list)(&mut h.rsc).fling_velocity(),
|
|
None,
|
|
"a tap must not fling"
|
|
);
|
|
h.frames_until(100, 400, PHONE_FRAME_MS);
|
|
assert_eq!(before, offset(&mut h, &screen), "a tap must scroll nothing");
|
|
assert_eq!(
|
|
h.state.opened_urls,
|
|
Vec::<String>::new(),
|
|
"no link was under this tap"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_long_press_and_drag_selects_text() {
|
|
let (mut h, screen) = opened();
|
|
let before = offset(&mut h, &screen);
|
|
|
|
h.replay(&script(
|
|
"long-press",
|
|
include_str!("../touch/long-press.touch"),
|
|
));
|
|
|
|
let selected = screen
|
|
.selected_text(&mut h.rsc)
|
|
.expect("a long-press then drag must leave text selected");
|
|
assert!(
|
|
!selected.trim().is_empty(),
|
|
"the selection covered no characters: {selected:?}"
|
|
);
|
|
assert_eq!(
|
|
before,
|
|
offset(&mut h, &screen),
|
|
"a selection must not also pan the list"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_tap_after_selection_deselects_text() {
|
|
let (mut h, screen) = opened();
|
|
h.replay(&script(
|
|
"select-then-tap",
|
|
"0 down 300 1000\n\
|
|
520 move 300 1000\n\
|
|
560 move 700 1000\n\
|
|
600 move 900 1000\n\
|
|
640 up 900 1000\n\
|
|
800 down 540 1000\n\
|
|
880 up 540 1000",
|
|
));
|
|
|
|
assert_eq!(
|
|
screen.selected_text(&mut h.rsc),
|
|
None,
|
|
"an ordinary tap after a selection must dismiss it"
|
|
);
|
|
assert_eq!(
|
|
h.state.opened_urls,
|
|
Vec::<String>::new(),
|
|
"the deselecting tap must be consumed rather than activating content"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_composer_sits_above_a_simulated_ime_inset() {
|
|
let (mut h, screen) = opened();
|
|
let height = h.size().y;
|
|
let field_bottom = |h: &mut Harness| {
|
|
h.rsc
|
|
.ui
|
|
.render_state()
|
|
.get()
|
|
.window_region(&screen.composer.field, &h.rsc)
|
|
.expect("the composer field is on screen")
|
|
.bot_right
|
|
.y
|
|
};
|
|
|
|
let closed = field_bottom(&mut h);
|
|
assert!(
|
|
closed <= height,
|
|
"the composer is off the bottom of the window even with no keyboard: {closed} > {height}"
|
|
);
|
|
|
|
let ime = 1000.0;
|
|
screen.composer.set_bottom_inset(&mut h.rsc, ime);
|
|
h.frame(PHONE_FRAME_MS * 2);
|
|
|
|
let open = field_bottom(&mut h);
|
|
assert!(
|
|
open <= height - ime,
|
|
"the keyboard covers the composer: its bottom is at {open}, the IME starts at {}",
|
|
height - ime
|
|
);
|
|
assert!(
|
|
(closed - open - ime).abs() < 1.0,
|
|
"the composer moved {} for a {ime}px inset",
|
|
closed - open
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_space_in_the_composer_finishes_layout() {
|
|
let (mut h, screen) = opened();
|
|
screen.composer.set_bottom_inset(&mut h.rsc, 1000.0);
|
|
h.frame(PHONE_FRAME_MS * 2);
|
|
h.state.set_focus(Some(screen.composer.field));
|
|
screen.composer.field.edit(&mut h.rsc).set_cursor_byte(0);
|
|
|
|
for text in ["h", "i", " "] {
|
|
screen.composer.field.edit(&mut h.rsc).insert(text);
|
|
h.frame(PHONE_FRAME_MS);
|
|
}
|
|
|
|
assert_eq!(screen.composer.field.edit(&mut h.rsc).text.text(), "hi ");
|
|
let region = h
|
|
.rsc
|
|
.ui
|
|
.render_state()
|
|
.get()
|
|
.window_region(&screen.composer.field, &h.rsc)
|
|
.expect("the composer field is drawn");
|
|
let size = region.bot_right - region.top_left;
|
|
assert!(
|
|
size.x > phone_size().x / 2.0,
|
|
"the field shrink-wrapped to the short message: {region:?}"
|
|
);
|
|
assert!(
|
|
size.y < 30.0 * PHONE_SCALE,
|
|
"the trailing space wrapped onto a second line: {region:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_newline_leaves_the_caret_inside_the_composers_padding() {
|
|
let (mut h, screen) = opened();
|
|
let height = h.size().y;
|
|
let ime = 1000.0;
|
|
screen.composer.set_bottom_inset(&mut h.rsc, ime);
|
|
h.frame(PHONE_FRAME_MS * 2);
|
|
|
|
h.state.set_focus(Some(screen.composer.field));
|
|
screen.composer.field.edit(&mut h.rsc).set_cursor_byte(0);
|
|
for _ in 0..12 {
|
|
screen.composer.field.edit(&mut h.rsc).insert("a\n");
|
|
h.frame(PHONE_FRAME_MS);
|
|
}
|
|
let render_handle = h.rsc.ui.render_state();
|
|
let render_state = render_handle.get();
|
|
let message = render_state
|
|
.debug(h.rsc.widgets(), "Message")
|
|
.find(|a| !a.primitives.is_empty())
|
|
.expect("the composer field is drawn");
|
|
let caret = render_state.primitive_corners(message.primitives.last().unwrap().slot, &h.rsc);
|
|
let bar_bottom = height - ime;
|
|
let padding = 12.0 * PHONE_SCALE;
|
|
assert!(
|
|
caret.bot_right.y < bar_bottom - padding / 2.0,
|
|
"the caret is in the bar's bottom padding: it ends at {}, the bar's edge is {bar_bottom} \
|
|
and its padding is {padding}px",
|
|
caret.bot_right.y,
|
|
);
|
|
|
|
let mask = h.rsc.ui.masks[message.mask.idx()];
|
|
let bar = render_state.primitive_corners(mask.primitive, &h.rsc);
|
|
let visible_content_top = message
|
|
.primitives
|
|
.iter()
|
|
.map(|p| render_state.primitive_corners(p.slot, &h.rsc))
|
|
.filter(|r| r.bot_right.y > bar.top_left.y)
|
|
.map(|r| r.top_left.y)
|
|
.fold(f32::INFINITY, f32::min);
|
|
assert!(
|
|
visible_content_top > bar.top_left.y,
|
|
"the composer's first visible line is clipped above its bar: content starts at {visible_content_top}, bar starts at {}",
|
|
bar.top_left.y,
|
|
);
|
|
}
|