ai-app/iris/src/layout_tests.rs

//! Pass conditions for LAYOUT.md section 8, exercised as plain unit tests
//! rather than through `run-headless.sh`: `UiRenderState` and `Widgets` do
//! not touch a GPU or a window, so a tree can be built and driven directly.
//! No GPU-backed rendering (`UiRenderNode`) is exercised here -- only the
//! CPU-side layout/move machinery LAYOUT.md is about.

use crate::prelude::*;

/// The minimal `UiRsc` a test needs: just the shared `UiData`, none of the
/// event/window/state plumbing `DefaultRsc` carries. `pub(crate)` so
/// `access_tests.rs` (I4, RUST.md) can reuse it rather than keeping a
/// second copy of the same harness.
pub(crate) struct TestRsc {
    pub(crate) ui: UiData,
}

impl UiRsc for TestRsc {
    fn ui(&self) -> &UiData {
        &self.ui
    }
    fn ui_mut(&mut self) -> &mut UiData {
        &mut self.ui
    }
}

/// A `Scroll` over a `Span` of `n` fixed-height rects -- N primitives large
/// enough that an O(N) regression in the move path would show up as a
/// non-trivial counter rather than being lost in noise (LAYOUT.md section
/// 8, condition 3, using rects rather than glyphs to avoid pulling the font
/// stack into a plain unit test). Returns the scroll widget (weak, for
/// mutating it later), the erased root to draw, and the rows (weak, for
/// hit-testing one of them).
fn scrolled_rects(
    rsc: &mut TestRsc,
    n: usize,
) -> (WeakWidget<Scroll>, StrongWidget, Vec<WeakWidget<Rect>>) {
    let mut span = Span::empty(Dir::DOWN);
    let mut rects = Vec::with_capacity(n);
    for _ in 0..n {
        let rect = rsc.ui.widgets.add_strong(Rect::new(UiColor::WHITE));
        rects.push(rect.weak());
        // Each row gets a fixed height so the span's total content is
        // genuinely taller than the viewport -- rest-sized rows would just
        // divide whatever space is offered and never need scrolling.
        let row = rsc.ui.widgets.add_strong(Sized {
            inner: rect.any(),
            x: None,
            y: Some(Len::abs(10.0)),
        });
        span.push(row.any());
    }
    let span = rsc.ui.widgets.add_strong(span);
    let scroll = rsc.ui.widgets.add_strong(Scroll::new(span.any(), Axis::Y));
    let weak = scroll.weak();
    (weak, scroll.any(), rects)
}

#[test]
fn an_unchanged_frame_draws_and_rewrites_nothing() {
    let mut rsc = TestRsc {
        ui: UiData::default(),
    };
    let (_scroll, root, _rects) = scrolled_rects(&mut rsc, 500);
    let mut render = UiRenderState::new();
    render.resize((800.0, 20000.0));

    render.update(&root, &mut rsc);
    render.take_counters(); // discard the first, real draw

    render.update(&root, &mut rsc);
    let (draws, rewrites, moves, _shapes) = render.take_counters();
    assert_eq!((draws, rewrites, moves), (0, 0, 0));
}

#[test]
fn scrolling_moves_in_o1_without_a_redraw() {
    let mut rsc = TestRsc {
        ui: UiData::default(),
    };
    let (scroll, root, _rects) = scrolled_rects(&mut rsc, 500);
    let mut render = UiRenderState::new();
    render.resize((800.0, 600.0));

    // The first draw offers `Scroll`'s content a zero-height region
    // (nothing has been measured yet) and learns the real content length
    // from what comes back; `update()` only redraws widgets actually
    // marked dirty, so that corrected length is not reflected in the
    // content's own *active* region until something -- here a no-op
    // scroll tick -- actually asks `Scroll` to redraw again. Only after
    // that warm-up does the content's offered size stop changing between
    // draws, which is what makes a further, real scroll tick a same-size
    // move instead of a resize. See scroll.rs.
    render.update(&root, &mut rsc);
    rsc.ui.widgets.get_mut(&scroll).unwrap().scroll(0.0);
    render.update(&root, &mut rsc);
    render.take_counters();

    // Negative: `scroll`'s sign convention subtracts from `amt`, and
    // `amt` starts at (and is clamped to) 0 at the top of the content, so
    // a *positive* argument here would be scrolling further up (a no-op,
    // already clamped) rather than actually moving anything.
    rsc.ui.widgets.get_mut(&scroll).unwrap().scroll(-40.0);
    render.update(&root, &mut rsc);
    let (draws, _rewrites, moves, _shapes) = render.take_counters();

    // The pass condition (LAYOUT.md section 8, condition 3) is 0 draws and
    // 1 move_offsets write, independent of how many rects are in the
    // scrolled subtree. `draws` here is exactly 1: `Scroll` itself is
    // marked dirty by `scroll()` and its own body is cheap arithmetic with
    // no primitives of its own, so it is the one real `Widget::draw` this
    // counts -- the 500 rects underneath move via the O(1) chain and are
    // never revisited.
    assert_eq!(draws, 1, "only Scroll itself should redraw");
    assert_eq!(moves, 1, "the scrolled subtree should move in one write");
}

#[test]
fn hit_testing_follows_a_scrolled_widget() {
    let mut rsc = TestRsc {
        ui: UiData::default(),
    };
    let (scroll, root, rects) = scrolled_rects(&mut rsc, 500);
    let mut render = UiRenderState::new();
    render.resize((800.0, 600.0));
    render.update(&root, &mut rsc);
    rsc.ui.widgets.get_mut(&scroll).unwrap().scroll(0.0);
    render.update(&root, &mut rsc);

    let target = &rects[2];
    let before = render.resolved_region(target, &rsc).unwrap();

    rsc.ui.widgets.get_mut(&scroll).unwrap().scroll(-37.0);
    render.update(&root, &mut rsc);

    let after = render.resolved_region(target, &rsc).unwrap();
    let before_px = before.to_px((800.0, 600.0).into());
    let after_px = after.to_px((800.0, 600.0).into());

    // Scrolling by -37 moves `amt` from 0 to 37, sliding the content's
    // top-left up by 37px -- `resolved_region` (the CPU twin of the vertex
    // shader's chain walk) must reflect that immediately, not the
    // pre-scroll position, or a tap routed through it would land on
    // whatever is now at the old coordinates instead of this widget.
    assert!(
        (after_px.top_left.y - (before_px.top_left.y - 37.0)).abs() < 0.01,
        "before={before_px:?} after={after_px:?}"
    );
}

/// `ActiveData::mask` is the mask a widget was drawn **under**, not the one
/// it set for itself -- `redraw` feeds it straight back in as the inherited
/// mask, so storing the set one hands a `Masked` its own mask the second
/// time round -- which `Painter::set_mask` asserts against, since a mask
/// that chains to itself is a clip loop. That was an abort the first time
/// the composer's new scroll area was redrawn on the emulator; a targeted
/// redraw of a `Masked` is what any real screen does whenever anything
/// inside it changes.
#[test]
fn redrawing_a_masked_widget_does_not_nest_its_own_mask() {
    let mut rsc = TestRsc {
        ui: UiData::default(),
    };
    let (_scroll, inner_root, _rects) = scrolled_rects(&mut rsc, 8);
    let masked = rsc.ui.widgets.add_strong(Masked { inner: inner_root });
    let masked_id = masked.id();
    let root = masked.any();
    let mut render = UiRenderState::new();
    render.resize((800.0, 600.0));
    render.update(&root, &mut rsc);

    render.redraw(masked_id, &mut rsc);
    render.redraw(masked_id, &mut rsc);

    assert_eq!(
        render.active.get(&masked_id).unwrap().mask,
        MaskIdx::NONE,
        "a `Masked` at the root is drawn under no mask of its own"
    );
}

#[test]
fn a_mask_stays_put_while_its_scrolled_content_moves() {
    let mut rsc = TestRsc {
        ui: UiData::default(),
    };
    let (scroll, inner_root, _rects) = scrolled_rects(&mut rsc, 500);
    let masked = rsc.ui.widgets.add_strong(Masked { inner: inner_root });
    let masked_id = masked.id();
    let root = masked.any();
    let mut render = UiRenderState::new();
    render.resize((800.0, 600.0));

    render.update(&root, &mut rsc);
    rsc.ui.widgets.get_mut(&scroll).unwrap().scroll(0.0);
    render.update(&root, &mut rsc);

    let masked_slot_before = render.active.get(&masked_id).unwrap().move_slot;
    let mask_delta_before = rsc.ui.move_offsets[masked_slot_before.idx()].delta;

    rsc.ui.widgets.get_mut(&scroll).unwrap().scroll(-40.0);
    render.update(&root, &mut rsc);

    let masked_slot_after = render.active.get(&masked_id).unwrap().move_slot;
    let mask_delta_after = rsc.ui.move_offsets[masked_slot_after.idx()].delta;

    // `Masked` itself is never the target of a `mov`/`reposition` here --
    // only its scrolled child is -- so the slot its own mask references
    // (`Painter::set_mask` bakes in `self.move_slot`, i.e. this one) must
    // still read zero after the scroll. The visible counterpart of this
    // (the clipped edge follows the scroll while the viewport border does
    // not) is `iris/run-headless.sh`'s job to catch in a real frame; this
    // is the numeric half, on the same data the fragment shader's
    // `resolve_move` reads. See LAYOUT.md section 2b.
    assert_eq!(mask_delta_before, [0.0, 0.0]);
    assert_eq!(mask_delta_after, [0.0, 0.0]);
}

/// Reproduces `transcript_ui::composer::build_composer`'s exact tree shape
/// (a `Rect` background stacked behind a `Span::RIGHT`-wrapped, padded,
/// `rest`-width `TextEdit`, itself the second child of an outer
/// `Span::DOWN` beside a `rest(1)`-height sibling) without the event/
/// resource plumbing `composer.rs`'s builders need, to isolate whether the
/// bug Iris reported on 2026-09-06 ("text seems to not appear in box")
/// is this crate's layout engine or something specific to the real
/// composer/screen. `TextEditable::edit` only needs `UiRsc`, so a plain
/// insert exercises the exact redraw path a keystroke does.
fn composer_like_tree(rsc: &mut TestRsc) -> (WeakWidget<TextEdit>, StrongWidget) {
    let field = wtext("")
        .editable(EditMode::MultiLine)
        .text_align(Align::LEFT)
        .wrap(true)
        .size(18)
        .color(UiColor::WHITE)
        .add(rsc);
    let bar = (field.pad(dp(12)).width(rest(1)),)
        .span(Dir::RIGHT)
        .background(rect(UiColor::new(40, 40, 46, 255)))
        .add(rsc);
    let list_stand_in = rect(UiColor::BLACK).height(rest(1)).add(rsc);
    let tree = (list_stand_in, bar).span(Dir::DOWN).add_strong(rsc).any();
    (field, tree)
}

/// The reproduction itself. A window this tall stands in for the keyboard
/// closed; the second, shorter `resize` stands in for `adjustResize`
/// shrinking the surface when the IME opens -- exactly the sequence
/// `IrisViewPeer::surface_changed` drives on a real keyboard open. Typing
/// happens both before and after, since Iris's report was specifically
/// that text typed *after* the keyboard was already up did not appear.
#[test]
fn composing_text_after_a_keyboard_resize_lands_in_the_bars_own_region() {
    let mut rsc = TestRsc {
        ui: UiData::default(),
    };
    let (field, root) = composer_like_tree(&mut rsc);
    let mut render = UiRenderState::new();

    render.resize((1080.0, 2298.0));
    render.update(&root, &mut rsc);
    // Focusing a field is what places its caret on a real tap
    // (`attr.rs`'s `on_press` -> `TextEditCtx::select`), and an insert
    // with no caret is a routing bug rather than a state to simulate --
    // `insert_str`'s own `debug_assert!` says so, and caught this test
    // typing into an unfocused field when it was added.
    field
        .edit(&mut rsc)
        .select(vec2(40.0, 2250.0), vec2(1080.0, 2298.0), false, false);
    field.edit(&mut rsc).insert("a");
    render.update(&root, &mut rsc);

    let before_px = render.window_region(&field, &rsc).unwrap();
    // The field is one line plus 12dp of padding on a 2298-tall window --
    // nowhere near the whole window's height, and anchored at the bottom.
    assert!(
        before_px.bot_right.y - before_px.top_left.y < 200.0,
        "before a resize: {before_px:?}"
    );
    assert!(
        before_px.top_left.y > 1800.0,
        "expected the bar near the bottom before a resize: {before_px:?}"
    );

    // The keyboard opens: a real `surface_changed`/`resize` to a shorter
    // window, then a further keystroke -- the redraw that must land in the
    // bar's new (also short) region, not whatever region a provisional
    // measurement pass used along the way.
    render.resize((1080.0, 1478.0));
    render.update(&root, &mut rsc);
    field.edit(&mut rsc).insert("b");
    render.update(&root, &mut rsc);

    let after_px = render.window_region(&field, &rsc).unwrap();
    assert!(
        after_px.bot_right.y - after_px.top_left.y < 200.0,
        "after a resize + keystroke: {after_px:?}"
    );
    assert!(
        after_px.top_left.y > 1200.0,
        "expected the bar near the bottom of the shorter window: {after_px:?}"
    );
}

/// `Scroll` used to be documented as resolving its own lengths against
/// `Painter::output_size` -- the window -- which read as if a scroll area
/// smaller than the screen could not work, and cost a session's
/// investigation before the composer was wired up (docs/RUST.md,
/// 2026-09-06). It measures `painter.px_size()` now, so this pins the
/// three numbers that follow from the offered box: what it reports
/// upward, what its capping parent reports, and how far it can pan.
#[test]
fn a_scroll_measures_the_box_it_was_offered_not_the_window() {
    let mut rsc = TestRsc {
        ui: UiData::default(),
    };
    let rect = rsc.ui.widgets.add_strong(Rect::new(UiColor::WHITE));
    let tall = rsc.ui.widgets.add_strong(Sized {
        inner: rect.any(),
        x: None,
        y: Some(Len::abs(1000.0)),
    });
    let scroll = rsc.ui.widgets.add_strong(Scroll::new(tall.any(), Axis::Y));
    let scroll_w = scroll.weak();
    let scroll_id = scroll.id();
    let capped = rsc.ui.widgets.add_strong(MaxSize {
        inner: scroll.any(),
        x: None,
        y: Some(Len::abs(100.0)),
    });
    let capped_id = capped.id();
    let root = capped.any();

    let mut render = UiRenderState::new();
    render.resize((800.0, 600.0));
    // Two passes: the first offers the content a zero-length region
    // (nothing measured yet) and learns the real content length from what
    // comes back -- see `scrolling_moves_in_o1_without_a_redraw` for why
    // that warm-up is deliberate rather than a bug.
    render.update(&root, &mut rsc);
    rsc.ui.widgets.get_mut(&scroll_w).unwrap().scroll(0.0);
    render.update(&root, &mut rsc);

    // Reports the *content*, so the cap above it has something to cap;
    // reporting the container instead would make the answer a function of
    // itself, since the container is sized from this very number.
    assert_eq!(
        render.active.get(&scroll_id).unwrap().size.y,
        Len::abs(1000.0)
    );
    assert_eq!(
        render.active.get(&capped_id).unwrap().size.y,
        Len::abs(100.0),
        "the cap, not the content and not the window"
    );

    // Panning is bounded by content minus *container*: 900, not the 400
    // a 600px window would give.
    rsc.ui.widgets.get_mut(&scroll_w).unwrap().scroll(-10_000.0);
    assert!(
        (rsc.ui.widgets.get_mut(&scroll_w).unwrap().amt() - 900.0).abs() < 0.01,
        "amt={}",
        rsc.ui.widgets.get_mut(&scroll_w).unwrap().amt()
    );
}

/// The half `hit_testing_follows_a_scrolled_widget` could not see: it
/// checks a *descendant* of the widget `Scroll` actually moves, whose own
/// `region` is stale and is corrected entirely by the move chain. The
/// moved widget itself had its `region` updated *and* the chain delta
/// added on top, so its hit box sat at twice the pan -- which is why a
/// finger pan of the composer left its field untappable. See
/// `ActiveData::move_applied`.
#[test]
fn a_panned_widgets_own_hit_box_moves_exactly_once() {
    let mut rsc = TestRsc {
        ui: UiData::default(),
    };
    let rect = rsc.ui.widgets.add_strong(Rect::new(UiColor::WHITE));
    let tall = rsc.ui.widgets.add_strong(Sized {
        inner: rect.any(),
        x: None,
        y: Some(Len::abs(1000.0)),
    });
    let tall_w = tall.weak();
    let scroll = rsc.ui.widgets.add_strong(Scroll::new(tall.any(), Axis::Y));
    let scroll_w = scroll.weak();
    let root = scroll.any();

    let mut render = UiRenderState::new();
    render.resize((800.0, 600.0));
    render.update(&root, &mut rsc);
    rsc.ui.widgets.get_mut(&scroll_w).unwrap().scroll(0.0);
    render.update(&root, &mut rsc);

    let before = render.window_region(&tall_w, &rsc).unwrap();
    rsc.ui.widgets.get_mut(&scroll_w).unwrap().scroll(-37.0);
    render.update(&root, &mut rsc);
    let after = render.window_region(&tall_w, &rsc).unwrap();

    assert!(
        (after.top_left.y - (before.top_left.y - 37.0)).abs() < 0.01,
        "the pan was applied twice: before={before:?} after={after:?}"
    );
}

/// A `Masked` used to allocate a **new** mask slot on every draw, and
/// `draw_inner`'s unchanged-region fast path means its descendants are
/// mostly *not* redrawn with it -- so they went on referencing the slot
/// they were first drawn under, whose region had since stopped being the
/// widget's. Measured 2026-09-06 on the composer's tree: four live mask
/// entries, none of them the `Masked`'s current box, and the field it was
/// meant to clip drew nothing at all on the emulator. The slot is
/// allocated once and rewritten in place now (`ActiveData::own_mask`), so
/// this pins both halves: one entry, and that entry is the widget's own
/// region.
#[test]
fn a_masked_widget_keeps_one_mask_slot_that_is_always_its_own_region() {
    let mut rsc = TestRsc {
        ui: UiData::default(),
    };
    let (_scroll, inner_root, _rects) = scrolled_rects(&mut rsc, 8);
    let masked = rsc.ui.widgets.add_strong(Masked { inner: inner_root });
    let masked_id = masked.id();
    // Placed at the bottom of a `Span::DOWN` behind a `rest(1)` sibling,
    // which is what moves the bar away from the provisional slot it is
    // first drawn at -- the move that left the stale mask behind.
    let filler = rsc.ui.widgets.add_strong(Rect::new(UiColor::BLACK));
    let filler = rsc.ui.widgets.add_strong(Sized {
        inner: filler.any(),
        x: None,
        y: Some(rest(1)),
    });
    let capped = rsc.ui.widgets.add_strong(MaxSize {
        inner: masked.any(),
        x: None,
        y: Some(Len::abs(60.0)),
    });
    let mut span = Span::empty(Dir::DOWN);
    span.push(filler.any());
    span.push(capped.any());
    let root = rsc.ui.widgets.add_strong(span).any();

    let mut render = UiRenderState::new();
    render.resize((800.0, 600.0));
    for _ in 0..3 {
        render.update(&root, &mut rsc);
        render.redraw(masked_id, &mut rsc);
    }

    assert_eq!(
        rsc.ui.masks.iter().count(),
        1,
        "one `Masked` must own exactly one mask slot, however often it is redrawn"
    );
    let mask = *rsc.ui.masks.iter().next().unwrap();
    assert_eq!(
        mask.region,
        render.active.get(&masked_id).unwrap().region,
        "the mask a descendant clips against must be this widget's current box"
    );
}

/// A `dp` cap that has done its job must be reported in pixels. `Span`
/// places a child using the `abs`/`rel` of the length it reported, so a
/// `MaxSize` handing back the caller's own `dp(168)` gave the composer's
/// bar a slot of **zero** the moment its content grew past six lines --
/// and the `Scroll` inside then measured its container at -63px (the
/// padding, subtracted from nothing) and panned the whole message out of
/// view. Measured on this checkout's emulator, 2026-09-06:
/// `container=-63 content=415.8 amt=478.8`. See `Len::fold_dp`.
#[test]
fn a_dp_cap_is_reported_in_pixels_so_a_span_can_place_it() {
    let mut rsc = TestRsc {
        ui: UiData::default(),
    };
    let rect = rsc.ui.widgets.add_strong(Rect::new(UiColor::WHITE));
    let tall = rsc.ui.widgets.add_strong(Sized {
        inner: rect.any(),
        x: None,
        y: Some(Len::abs(1000.0)),
    });
    let capped = rsc.ui.widgets.add_strong(MaxSize {
        inner: tall.any(),
        x: None,
        y: Some(Len::dp(100.0)),
    });
    let capped_w = capped.weak();
    let filler = rsc.ui.widgets.add_strong(Rect::new(UiColor::BLACK));
    let filler = rsc.ui.widgets.add_strong(Sized {
        inner: filler.any(),
        x: None,
        y: Some(rest(1)),
    });
    let mut span = Span::empty(Dir::DOWN);
    span.push(filler.any());
    span.push(capped.any());
    let root = rsc.ui.widgets.add_strong(span).any();

    let mut render = UiRenderState::new();
    render.resize((800.0, 600.0));
    render.set_density(2.5);
    render.update(&root, &mut rsc);
    render.update(&root, &mut rsc);

    let box_px = render.window_region(&capped_w, &rsc).unwrap();
    let height = box_px.bot_right.y - box_px.top_left.y;
    assert!(
        (height - 250.0).abs() < 0.01,
        "expected the 100dp cap at density 2.5 to be a 250px slot, got {height} ({box_px:?})"
    );
}

/// The sibling of `a_panned_widgets_own_hit_box_moves_exactly_once`, on
/// the branch that fix had no reason to touch: `draw_inner`'s
/// size-independent fast path rewrites a widget's primitives *in place*
/// and leaves its move slot alone, so unlike `mov` there is no slot delta
/// for `region` to have absorbed. Counting one there anyway makes
/// `resolved_region` subtract a delta the chain never held, and the
/// widget's hit box lands short of where it is drawn by exactly the
/// distance it just moved -- with nothing on screen to say so, since the
/// primitives are in the right place.
#[test]
fn a_size_independent_widget_moved_by_its_parent_has_the_hit_box_it_is_drawn_at() {
    let mut rsc = TestRsc {
        ui: UiData::default(),
    };
    let top = rsc.ui.widgets.add_strong(Rect::new(UiColor::WHITE));
    let spacer = rsc.ui.widgets.add_strong(Sized {
        inner: top.any(),
        x: None,
        y: Some(Len::abs(100.0)),
    });
    let spacer_w = spacer.weak();
    // `Rect` is `is_size_independent`, so growing the spacer above it
    // offers this one a region that changed *both* position and size --
    // the one shape that reaches the branch under test.
    let below = rsc.ui.widgets.add_strong(Rect::new(UiColor::WHITE));
    let below_w = below.weak();
    let mut span = Span::empty(Dir::DOWN);
    span.push(spacer.any());
    span.push(below.any());
    let root = rsc.ui.widgets.add_strong(span).any();

    let mut render = UiRenderState::new();
    render.resize((800.0, 600.0));
    render.update(&root, &mut rsc);
    // `Span` draws each child once at the full region to measure it and
    // then places it, so this widget has already been through the branch
    // once by the end of the very first frame.
    let first = render.window_region(&below_w, &rsc).unwrap();
    assert!(
        (first.top_left.y - 100.0).abs() < 0.01,
        "hit box at {:?}, drawn at y=100",
        first.top_left
    );

    rsc.ui.widgets.get_mut(&spacer_w).unwrap().y = Some(Len::abs(250.0));
    render.update(&root, &mut rsc);
    let after = render.window_region(&below_w, &rsc).unwrap();
    assert!(
        (after.top_left.y - 250.0).abs() < 0.01,
        "hit box at {:?}, drawn at y=250",
        after.top_left
    );
}

/// A parent that both `mov`s a child (its own layout moved the box it
/// offers) and `reposition`s it inside that box in the same frame -- what
/// `List::place`'s Bottom-known branch does once a row's cached height
/// stops matching what the row reports, which is reachable as soon as a
/// transcript row's blocks wrap (docs/IRIS_TODO.md's "Found by P1a").
struct MoveThenPlace {
    inner: StrongWidget,
    /// Where the child is *offered* a (constant-size) box, moved between
    /// frames by the test.
    offer_top: f32,
    /// Where the child is then placed within this widget's own region.
    place_top: f32,
}

impl Widget for MoveThenPlace {
    fn draw(&mut self, painter: &mut Painter) -> Size {
        let offer = UiRegion::new(
            UiSpan::FULL,
            UiSpan::new(
                UiScalar::abs(self.offer_top),
                UiScalar::abs(self.offer_top + 40.0),
            ),
        );
        painter.widget_within(&self.inner, offer);
        let place = UiRegion::new(
            UiSpan::FULL,
            UiSpan::new(
                UiScalar::abs(self.place_top),
                UiScalar::abs(self.place_top + 40.0),
            ),
        );
        painter.reposition(&self.inner, place);
        Size::default()
    }
}

/// `mov` accumulates a delta onto a widget's move slot and `reposition`
/// overwrites it, and both can legitimately land on one widget in one
/// frame (see `MoveThenPlace`). `reposition` used to write its own delta
/// alone, which dropped the move and put the child back at the position
/// the offered box had *before* it moved; a `debug_assert!` that
/// `move_applied` was zero hid that behind a panic instead of fixing it.
/// The slot has one owner and one meaning now --
/// `move_applied + repositioned` -- so the child stays where it was
/// placed however its offered box moves. Fails at the offer's position
/// (200) rather than the placement's (100) without that.
#[test]
fn a_widget_moved_by_its_parent_and_then_placed_inside_it_lands_at_the_placement() {
    let mut rsc = TestRsc {
        ui: UiData::default(),
    };
    let rect = rsc.ui.widgets.add_strong(Rect::new(UiColor::WHITE));
    let child = rsc.ui.widgets.add_strong(Sized {
        inner: rect.any(),
        x: None,
        y: Some(Len::abs(40.0)),
    });
    let child_w = child.weak();
    let parent = rsc.ui.widgets.add_strong(MoveThenPlace {
        inner: child.any(),
        offer_top: 0.0,
        place_top: 100.0,
    });
    let parent_w = parent.weak();
    let root = parent.any();

    let mut render = UiRenderState::new();
    render.resize((200.0, 400.0));
    render.update(&root, &mut rsc);
    let before = render.window_region(&child_w, &rsc).unwrap();
    assert!(
        (before.top_left.y - 100.0).abs() < 0.01,
        "the child should be drawn where it was placed, not where it was offered: {before:?}"
    );

    // Move the offered box without changing its size (the `mov` fast path)
    // and place the child at the same spot as before. Marking the parent
    // dirty is what a real container's own content change does; the child
    // itself is untouched, which is the case `mov` exists for.
    {
        let parent = rsc.ui.widgets.get_mut(&parent_w).unwrap();
        parent.offer_top = 200.0;
    }
    rsc.ui.widgets.needs_redraw.insert(parent_w.id());
    render.update(&root, &mut rsc);
    let after = render.window_region(&child_w, &rsc).unwrap();
    assert!(
        (after.top_left.y - 100.0).abs() < 0.01,
        "the placement did not change, so neither should the child: before={before:?} \
         after={after:?}"
    );
}