ai-app/iris/transcript-fixture/tests/phone_screen.rs

//! Layer 1 of docs/RUST.md's "Three test layers": the real transcript
//! screen, over the real bench fixture, at the phone's size and density,
//! driven by `iris::harness` with no window, no compositor and no GPU.
//!
//! Every gesture here is a file under `touch/` -- see
//! `flick-120hz.touch` for why the *shape* of the delivery is the whole
//! point, and why the emulator cannot produce it (a `ui-trace` swipe is
//! many evenly-spaced events; a finger at 120Hz is five samples in
//! 20ms).

use iris::harness::{Harness, TouchScript};
use iris::prelude::*;
use transcript_fixture::{PHONE_FRAME_MS, PHONE_SCALE, phone_size};

/// The screen open on the fixture, framed twice: once to draw, once for
/// `List::repair_anchor` to resolve the opening `snap_end` into a real
/// anchor, which is what every assertion about scroll position reads.
fn opened() -> (Harness, transcript_ui::TranscriptScreen) {
    let mut h = Harness::new(phone_size(), PHONE_SCALE);
    let opened = transcript_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: &transcript_ui::TranscriptScreen) -> String {
    (screen.list)(&mut h.rsc).anchor_position_display()
}

/// (a) and (b) together, because the second is only meaningful if the
/// first happened: the recorded flick must release with a real velocity
/// (`GestureOutcome::Released(Some(v))`, which is the only thing that
/// puts a value in `List::fling_velocity`), and the list must then
/// actually travel and stop on the spline's own schedule.
#[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");
    // Compose's own answer for this recording's five samples, printed by
    // `iris/benches/velocity_reference.py` -- not a number read off this
    // code. Negative because the flick runs *down* the screen and
    // `Selection::drag` flings the list by `-v` (see its `Released` arm).
    // The 2026-09-07 before/after: the old average estimator read
    // -12250px/s here, which is the fling Iris reported as too slow.
    assert!(
        (velocity + 15_250.0).abs() < 20.0,
        "expected ~-15250px/s from velocity_reference.py, got {velocity}"
    );

    // `iris/benches/fling_spline_reference.py`'s own line for this exact
    // case -- `density=2.55 v=15250.0: distance=11057.424px
    // duration=2.0716s`. **Not** `FlingCalculator::new(PHONE_SCALE)`,
    // which is the calculator under test: bounding a fling with the thing
    // being measured is the "compared the code with itself" shape 73f956f
    // found in the spline's own tests, and it left this one able to fail
    // in the "ran too long" direction only -- never in the "stopped dead"
    // direction, which is what Iris actually reported
    // (docs/REVIEW-2026-09-07.md's T1).
    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();
    // Travel in pixels, measured from a row's own on-screen extent, since
    // `List` has no travel accessor and this needs none: follow whatever
    // row is under the viewport's middle until it leaves, then pick
    // another. Deliberately an *under*-count -- the frame a row leaves on
    // contributes nothing -- which is why it is only ever a lower bound.
    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() && !list.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();
    // Both directions. The lower bound is the one that fails when a fling
    // settles on its first tick; the upper is the one that was here.
    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"
    );
    // 80% of the reference, against 10527px measured today -- the 5%
    // shortfall is the frames a tracked row leaves the screen on. A fling
    // that moves one row's worth fails this; scaling `tick_fling`'s delta
    // by 0.01 reports 111px, which is how it was confirmed to fail in the
    // direction the bug goes.
    assert!(
        travelled >= REFERENCE_PX * 0.8,
        "the fling travelled {travelled:.0}px against the spline reference's {REFERENCE_PX:.0}px"
    );
}

/// The half the flick fix had no reason to touch: a tap must decide
/// `Tapped`, which means no velocity anywhere and nothing moved.
#[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"
    );
    // Frames it would have moved in, had anything been moving.
    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"
    );
}

/// A press held past `LONG_PRESS` and then dragged selects text rather
/// than panning -- the other branch of the same arbiter the flick goes
/// through.
#[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"
    );
}

/// The composer sits on whatever the platform says the bottom of usable
/// space is -- the keyboard's inset while it is open
/// (`Composer::set_bottom_inset`, the path Android's
/// `on_insets_changed` feeds). Checked here rather than on the emulator
/// because it is a layout fact, and the emulator costs minutes.
#[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.render
            .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}"
    );

    // A Gboard-sized keyboard on this surface. Any real number would do;
    // what matters is that the bar clears it.
    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
    );
}