use uzor::app_context::StateRegistry;
use uzor::input::{InputCoordinator, LayerId};
use uzor::layout::docking::{DockPanel, LeafId};
use uzor::testing::NullRenderContext;
use uzor::tokens::{BuiltinSet, Tokens};
use uzor::{Rect, WidgetId};
use super::*;
use crate::handle::{FrameTime, HookOps, PanelCx, VisualView, Widgets};
use crate::types::ids::WindowId;
use crate::types::spec::{PanelHome, Spec};
#[derive(Clone, Debug)]
struct P;
impl DockPanel for P {
fn title(&self) -> &str {
"kit"
}
fn type_id(&self) -> &'static str {
"kit"
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum Never {}
struct K;
impl Spec for K {
type Panel = P;
type Overlay = Never;
type Action = Never;
fn decode_panel(_home: PanelHome, _type_id: &str) -> Option<P> {
Some(P)
}
}
#[derive(Default)]
struct Harness {
states: StateRegistry,
coord: InputCoordinator,
keep_coord: bool,
record: Option<uzor::testing::RecordingRenderContext>,
}
impl Harness {
fn frame<R>(&mut self, visual: &VisualView<K>, body: impl FnOnce(&mut PanelCx<'_, K>) -> R) -> R {
let tokens = Tokens::builtin(BuiltinSet::Dark);
if self.keep_coord {
self.coord.begin_frame_widgets_only();
} else {
self.coord = InputCoordinator::new();
}
let mut null = NullRenderContext::default();
let render: &mut dyn uzor::render::RenderContext = match self.record.as_mut() {
Some(r) => r,
None => &mut null,
};
let mut hooks = HookOps::<K>::default();
let mut cx = PanelCx {
window: WindowId(1),
leaf: LeafId(0),
panel: &P,
index: 0,
rect: Rect::new(0.0, 0.0, 800.0, 600.0),
dpr: 1.0,
tokens: tokens.as_ref(),
render,
widgets: Widgets {
coord: &mut self.coord,
states: &mut self.states,
selectables: &mut Default::default(),
layer: LayerId::main(),
},
view: visual,
time: FrameTime::default(),
out: &mut hooks,
};
body(&mut cx)
}
}
fn click(id: &str) -> VisualView<K> {
let mut v = VisualView::<K>::default();
v.clicked = vec![(WidgetId::from(id), 1)];
v
}
fn idle() -> VisualView<K> {
VisualView::<K>::default()
}
#[test]
fn tabs_lay_out_parts_and_bind_a_click() {
let mut h = Harness::default();
let mut tab = 0usize;
let r = h.frame(&click("t:tab:2"), |cx| {
tabs("t", Rect::new(0.0, 0.0, 300.0, 30.0), &["A", "B", "C"]).bind(&mut tab).build(cx)
});
assert_eq!((r.index, r.changed, tab), (Some(2), true, 2));
assert_eq!(h.coord.widget_rect(&WidgetId::from("t:tab:1")), Some(Rect::new(100.0, 0.0, 100.0, 30.0)));
let tabbable = h.coord.focusable_ids(None);
assert!(["t:tab:0", "t:tab:1", "t:tab:2"].iter().all(|t| tabbable.contains(&WidgetId::from(*t))));
let r = h.frame(&click("t:tab:2"), |cx| tabs("t", Rect::new(0.0, 0.0, 300.0, 30.0), &["A", "B", "C"]).bind(&mut tab).build(cx));
assert!(!r.changed, "clicking the active tab is not a change");
}
#[test]
fn list_hits_only_visible_rows() {
let mut h = Harness::default();
let mut sel = None;
let rows = ["a", "b", "c", "d", "e"];
let r = h.frame(&click("l:row:3"), |cx| {
list("l", Rect::new(0.0, 0.0, 200.0, 60.0), &rows).row_height(20.0).scroll(40.0).bind(&mut sel).build(cx)
});
assert_eq!((r.index, sel), (Some(3), Some(3)));
assert!(h.coord.widget_rect(&WidgetId::from("l:row:1")).is_none(), "scrolled out");
assert_eq!(h.coord.widget_rect(&WidgetId::from("l:row:2")), Some(Rect::new(0.0, 0.0, 200.0, 20.0)));
assert!(h.coord.widget_rect(&WidgetId::from("l:row:4")).is_some());
}
#[test]
fn select_opens_picks_and_closes() {
let mut h = Harness::default();
let mut choice = 0usize;
let opts = ["Low", "Mid", "High"];
let rect = Rect::new(10.0, 10.0, 120.0, 28.0);
h.frame(&click("s"), |cx| select("s", rect, &opts).bind(&mut choice).build(cx));
h.frame(&idle(), |cx| select("s", rect, &opts).bind(&mut choice).build(cx));
assert!(h.coord.widget_rect(&WidgetId::from("s:list:item:2")).is_some(), "open list registers its options");
let r = h.frame(&click("s:list:item:2"), |cx| select("s", rect, &opts).bind(&mut choice).build(cx));
assert_eq!((r.index, r.changed, choice), (Some(2), true, 2));
h.frame(&idle(), |cx| select("s", rect, &opts).bind(&mut choice).build(cx));
assert!(h.coord.widget_rect(&WidgetId::from("s:list:item:2")).is_none(), "closed after the pick");
h.frame(&click("s"), |cx| select("s", rect, &opts).build(cx));
h.frame(&click("elsewhere"), |cx| select("s", rect, &opts).build(cx));
h.frame(&idle(), |cx| select("s", rect, &opts).build(cx));
assert!(h.coord.widget_rect(&WidgetId::from("s:list:item:0")).is_none());
}
#[test]
fn menu_reports_pick_and_closes() {
let mut h = Harness::default();
let mut open = true;
let items = ["Copy", "Delete"];
h.frame(&idle(), |cx| menu("m", (50.0, 50.0), &items, &mut open).danger(1).build(cx));
assert!(open && h.coord.widget_rect(&WidgetId::from("m:item:1")).is_some());
let r = h.frame(&click("m:item:1"), |cx| menu("m", (50.0, 50.0), &items, &mut open).build(cx));
assert_eq!((r.index, open), (Some(1), false));
let mut open = true;
h.frame(&click("other"), |cx| menu("m", (50.0, 50.0), &items, &mut open).build(cx));
assert!(!open, "a click outside dismisses");
}
#[test]
fn dialog_reports_footer_and_close() {
let mut h = Harness::default();
let rect = Rect::new(100.0, 100.0, 400.0, 240.0);
let r = h.frame(&click("d:footer:1"), |cx| dialog("d", rect).title("Rename").footer(&["Save", "Cancel"]).build(cx));
assert_eq!((r.index, r.clicked), (Some(1), false));
let r = h.frame(&click("d:close"), |cx| dialog("d", rect).title("Rename").build(cx));
assert!(r.clicked && r.changed);
}
#[test]
fn splitter_drags_within_range() {
let mut h = Harness::default();
let span = Rect::new(0.0, 0.0, 800.0, 600.0);
let mut pos = 200.0;
let mut press = VisualView::<K>::default();
press.pressed = Some(WidgetId::from("sp"));
press.button_down = true;
press.pointer = Some((900.0, 10.0));
let r = h.frame(&press, |cx| splitter("sp", Axis::X, span, &mut pos).range(100.0, 600.0).build(cx));
assert!(r.pressed && r.changed);
assert_eq!(pos, 600.0);
let r = h.frame(&idle(), |cx| splitter("sp", Axis::X, span, &mut pos).build(cx));
assert!(!r.pressed, "release ends the drag");
}
#[test]
fn toasts_keep_frames_coming_until_they_expire() {
let mut h = Harness::default();
let mut stack = ToastStackState::new();
stack.push(ToastType { title: None, message: "Saved".into(), timestamp_ms: 0, duration_ms: 1000, severity: ToastSeverity::Info }, 0);
let area = Rect::new(0.0, 0.0, 800.0, 600.0);
assert!(h.frame(&idle(), |cx| toasts("toasts", area, &mut stack, 500).build(cx)).changed);
assert!(!h.frame(&idle(), |cx| toasts("toasts", area, &mut stack, 60_000).build(cx)).changed);
}
#[test]
fn input_is_focusable_and_reports_focus() {
let mut h = Harness::default();
let mut v = VisualView::<K>::default();
v.focused = Some(WidgetId::from("name"));
let mut name = String::from("Ann");
let r = h.frame(&v, |cx| input("name", Rect::new(0.0, 0.0, 200.0, 28.0), &mut name).placeholder("Name").build(cx));
assert!(r.focused);
assert!(h.coord.focusable_ids(None).contains(&WidgetId::from("name")));
}
#[test]
fn input_edits_itself_with_undo_and_syncs_both_ways() {
let mut h = Harness { keep_coord: true, ..Default::default() };
let rect = Rect::new(0.0, 0.0, 200.0, 28.0);
let mut name = String::from("Ann");
let id = WidgetId::from("name");
h.frame(&idle(), |cx| input("name", rect, &mut name).build(cx));
assert_eq!(h.coord.text_fields().text(&id), "Ann", "the app's value seeds the field");
let f = h.coord.text_fields_mut();
f.focus(id.clone());
for c in "a b".chars() {
f.on_char(c);
}
let r = h.frame(&idle(), |cx| input("name", rect, &mut name).build(cx));
assert!(r.changed && r.focused);
assert_eq!(name, "Anna b");
h.coord.text_fields_mut().on_key(uzor::KeyPress::Undo);
let r = h.frame(&idle(), |cx| input("name", rect, &mut name).build(cx));
assert!(r.changed);
assert_eq!(name, "Anna ");
name = "Bob".into();
let r = h.frame(&idle(), |cx| input("name", rect, &mut name).build(cx));
assert!(!r.changed, "an app write is not a user change");
assert_eq!(h.coord.text_fields().text(&id), "Bob");
assert_eq!(h.coord.text_fields_mut().on_key(uzor::KeyPress::Undo), uzor::TextAction::None);
}
#[test]
fn disabled_input_is_not_a_text_field() {
let mut h = Harness::default();
let mut name = String::new();
h.frame(&idle(), |cx| input("name", Rect::new(0.0, 0.0, 200.0, 28.0), &mut name).disabled(true).build(cx));
assert!(!h.coord.text_fields().has_field(&WidgetId::from("name")));
assert!(!h.coord.focusable_ids(None).contains(&WidgetId::from("name")));
}
#[test]
fn button_reports_like_the_rest() {
let mut h = Harness::default();
let r = h.frame(&click("ok"), |cx| button("ok", Rect::new(0.0, 0.0, 80.0, 28.0)).text("OK").build_response(cx));
assert!(r.clicked);
}
#[test]
fn checkbox_and_switch_report_the_new_state_and_are_named() {
let mut h = Harness::default();
let mut on = false;
let r = h.frame(&click("cb"), |cx| checkbox("cb", Rect::new(0.0, 0.0, 120.0, 20.0)).label("Notify").bind(&mut on).build_response(cx));
assert!(on && r.checked && r.changed);
let mut sw = true;
let r = h.frame(&click("sw"), |cx| switch("sw", Rect::new(0.0, 0.0, 40.0, 20.0)).label("Dark").disabled(true).bind(&mut sw).build_response(cx));
assert!(sw && r.checked && !r.changed, "a disabled switch does not flip");
}
#[test]
fn table_reports_rows_and_header_columns() {
let mut h = Harness::default();
let rows = vec![vec!["a".to_string(), "1".into()], vec!["b".into(), "2".into()]];
let rect = Rect::new(0.0, 0.0, 300.0, 200.0);
let mut sel = None;
let r = h.frame(&click("t:row:1"), |cx| table("t", rect, &["Name", "N"], &rows).columns("2fr 80px").bind(&mut sel).build(cx));
assert_eq!((r.index, r.changed, sel), (Some(1), true, Some(1)));
let r = h.frame(&click("t:col:0"), |cx| table("t", rect, &["Name", "N"], &rows).build(cx));
assert_eq!(r.column, Some(0));
let ids = h.coord.focusable_ids(None);
assert!(ids.contains(&WidgetId::from("t:col:1")) && ids.contains(&WidgetId::from("t:row:0")));
}
#[test]
fn drawer_closes_on_scrim_and_slides_with_progress() {
let mut h = Harness::default();
let area = Rect::new(0.0, 0.0, 800.0, 600.0);
let mut open = true;
let d = drawer("d", area, &mut open).width(300.0).progress(0.5);
assert_eq!(d.body_rect().x, 650.0);
assert_eq!(drawer("d", area, &mut true).side(Side::Left).body_rect().x, 0.0);
let r = h.frame(&click("d"), |cx| drawer("d", area, &mut open).build(cx));
assert!(open && !r.changed, "a click inside the panel keeps it open");
let r = h.frame(&click("d:scrim"), |cx| drawer("d", area, &mut open).build(cx));
assert!(!open && r.changed);
}
#[test]
fn field_registers_names_masks_and_feeds_the_store() {
let mut h = Harness { keep_coord: true, ..Default::default() };
let rect = Rect::new(10.0, 0.0, 200.0, 28.0);
let id = WidgetId::from("pw");
let pw = || field("pw", rect).config(uzor::TextFieldConfig::password()).placeholder("Password").masked(true).clip(true).colors("white", "gray");
let r = h.frame(&idle(), |cx| pw().build(cx));
assert_eq!(r, FieldResponse::default());
assert!(h.coord.focusable_ids(None).contains(&id));
assert!(h.coord.a11y_tree().nodes().iter().any(|n| n.name == "Password"));
let f = h.coord.text_fields_mut();
f.focus(id.clone());
for c in "abc".chars() {
f.on_char(c);
}
let mut v = idle();
v.focused = Some(id.clone());
let r = h.frame(&v, |cx| pw().build(cx));
assert_eq!(r, FieldResponse { text: "abc".into(), focused: true });
let st = h.coord.text_fields().field_state(&id).unwrap();
assert_eq!(st.text, "abc");
let r = h.frame(&v, |cx| pw().set(Some("xy")).build(cx));
assert_eq!(r.text, "xy");
let r = h.frame(&v, |cx| pw().set(Some("")).build(cx));
assert_eq!(r.text, "");
}
fn painted_with_clips(ops: &[uzor::testing::DrawOp]) -> Vec<(String, f64, Option<Rect>)> {
use uzor::testing::DrawOp as D;
let (mut stack, mut cur, mut path, mut out) = (Vec::new(), None::<Rect>, None::<Rect>, Vec::new());
for op in ops {
match op {
D::Save => stack.push(cur),
D::Restore => cur = stack.pop().flatten(),
D::BeginPath => path = None,
D::Rect { x, y, w, h } => path = Some(Rect::new(*x, *y, *w, *h)),
D::Clip => cur = path.map(|p| cur.map_or(p, |c: Rect| c.intersect(p))),
D::FillText { text, x, .. } => out.push((text.clone(), *x, cur)),
D::FillRect { x, .. } => out.push(("<rect>".into(), *x, cur)),
_ => {}
}
}
out
}
#[test]
fn field_clips_scrolls_with_the_caret_and_stays_inside_its_viewport() {
let rect = Rect::new(10.0, 100.0, 200.0, 28.0);
let id = WidgetId::from("tok");
let long = format!("hsreq1.{}", "x".repeat(53));
let mut h = Harness { keep_coord: true, record: Some(uzor::testing::RecordingRenderContext::with_char_width(10.0)), ..Default::default() };
let mut v = idle();
v.focused = Some(id.clone());
h.frame(&idle(), |cx| field("tok", rect).placeholder("hsreq1.…").set(Some(&long)).build(cx));
h.coord.text_fields_mut().focus(id.clone());
let viewport = Rect::new(0.0, 0.0, 400.0, 300.0);
let frame = |h: &mut Harness, v: &VisualView<K>, r: Rect, vp: Rect| {
h.record.as_mut().unwrap().ops.clear();
h.frame(v, |cx| field("tok", r).placeholder("hsreq1.…").clip_to(vp).build(cx));
painted_with_clips(&h.record.as_ref().unwrap().ops)
};
let p = frame(&mut h, &v, rect, viewport);
let (t, x, clip) = p.iter().find(|(t, ..)| t == &long).cloned().expect("text painted");
assert_eq!(clip, Some(rect), "text clipped to the field: {t}");
assert_eq!(x, rect.x - (600.0 - 199.0), "scrolled so the end shows");
let caret = p.iter().find(|(t, ..)| t == "<rect>").map(|c| (c.1, c.2));
if let Some((cx, Some(c))) = caret {
assert!(cx >= c.x && cx < c.x + c.width, "caret {cx} inside {c:?}");
}
h.coord.text_fields_mut().field_state_mut(&id).unwrap().cursor = 0;
let p = frame(&mut h, &v, rect, viewport);
assert_eq!(p.iter().find(|(t, ..)| t == &long).unwrap().1, rect.x);
let p = frame(&mut h, &idle(), rect, viewport);
assert_eq!(p.iter().find(|(t, ..)| t == &long).map(|e| (e.1, e.2)), Some((rect.x, Some(rect))));
let half = Rect::new(0.0, 0.0, 400.0, 114.0);
let p = frame(&mut h, &idle(), rect, half);
assert_eq!(p.iter().find(|(t, ..)| t == &long).unwrap().2, Some(Rect::new(10.0, 100.0, 200.0, 14.0)));
assert_eq!(h.coord.widget_rect(&id), Some(Rect::new(10.0, 100.0, 200.0, 14.0)));
h.coord.text_fields_mut().clear(&id);
let p = frame(&mut h, &idle(), rect, Rect::new(0.0, 0.0, 400.0, 90.0));
assert!(p.is_empty(), "{p:?}");
let p = frame(&mut h, &idle(), rect, viewport);
assert_eq!(p.iter().find(|(t, ..)| t == "hsreq1.…").unwrap().2, Some(rect), "placeholder clipped too");
}
#[test]
fn field_scroll_keeps_the_caret_in_view() {
assert_eq!(field_scroll(0.0, 50.0, 100.0, 200.0), 0.0);
assert_eq!(field_scroll(0.0, 600.0, 600.0, 200.0), 401.0);
assert_eq!(field_scroll(401.0, 500.0, 600.0, 200.0), 401.0, "caret still in view: no jump");
assert_eq!(field_scroll(401.0, 300.0, 600.0, 200.0), 300.0);
assert_eq!(field_scroll(401.0, 100.0, 100.0, 200.0), 0.0, "text shrank: back to the start");
}
fn key(code: uzor::input::keyboard::KeyCode, text: Option<&str>) -> crate::KeyInput {
crate::KeyInput { code, text: text.map(str::to_string), state: crate::KeyState::Down, mods: Default::default() }
}
#[test]
fn select_keyboard_search_escape_and_stays_inside_its_container() {
use uzor::input::keyboard::KeyCode as K;
let mut h = Harness::default();
let zones: Vec<String> = (0..30).map(|i| format!("Zone/City_{i:02}")).collect();
let opts: Vec<&str> = zones.iter().map(String::as_str).collect();
let mut choice = 3usize;
let dlg = Rect::new(0.0, 0.0, 400.0, 300.0);
let rect = Rect::new(300.0, 240.0, 90.0, 28.0);
let none: Option<&crate::KeyInput> = None;
let frame = |h: &mut Harness, ev: &_, k: Option<&crate::KeyInput>, c: &mut usize| h.frame(ev, |cx| select("tz", rect, &opts).within(dlg).key(k).bind(c).build(cx));
let r = frame(&mut h, &click("tz"), none, &mut choice);
assert!(r.checked, "a click opens it");
frame(&mut h, &idle(), none, &mut choice);
let list = h.coord.widget_rect(&WidgetId::from("tz:list")).expect("list registered");
assert!(list.x >= 0.0 && list.x + list.width <= 400.0 && list.y >= 0.0 && list.y + list.height <= 300.0, "{list:?}");
assert!(list.y + list.height <= 240.0, "opens above the trigger: {list:?}");
let down = key(K::ArrowDown, None);
let r = frame(&mut h, &idle(), Some(&down), &mut choice);
assert!(r.pressed && r.checked);
let enter = key(K::Enter, None);
let r = frame(&mut h, &idle(), Some(&enter), &mut choice);
assert_eq!((r.index, r.changed, choice, r.checked), (Some(4), true, 4, false));
frame(&mut h, &click("tz"), none, &mut choice);
for t in ["2", "7"] {
let k = key(K::Num2, Some(t));
frame(&mut h, &idle(), Some(&k), &mut choice);
}
frame(&mut h, &idle(), none, &mut choice);
assert!(h.coord.widget_rect(&WidgetId::from("tz:list:item:27")).is_some());
assert!(h.coord.widget_rect(&WidgetId::from("tz:list:item:26")).is_none(), "filtered out");
let r = frame(&mut h, &idle(), Some(&enter), &mut choice);
assert_eq!((r.index, choice), (Some(27), 27));
frame(&mut h, &click("tz"), none, &mut choice);
let esc = key(K::Escape, None);
let r = frame(&mut h, &idle(), Some(&esc), &mut choice);
assert!(r.pressed && !r.checked && r.index.is_none());
frame(&mut h, &idle(), none, &mut choice);
assert!(h.coord.widget_rect(&WidgetId::from("tz:list")).is_none());
}
#[test]
fn pointer_over_answers_only_for_the_topmost_target() {
let term = WidgetId::from("term");
let mut v = VisualView::<K>::default();
v.pointer = Some((300.0, 100.0));
v.scroll = (0.0, -2.0);
v.hovered = Some(WidgetId::from("bd-card"));
v.hover_path = vec![WidgetId::from("bd-card")];
assert_eq!(v.pointer_over(&term), None);
assert_eq!(v.scroll_over(&term), (0.0, 0.0));
assert_eq!(v.raw_pointer(), Some((300.0, 100.0)), "the raw position stays available, opt-in");
v.hovered = Some(term.clone());
v.hover_path = vec![term.clone()];
assert_eq!(v.pointer_over(&term), Some((300.0, 100.0)));
assert_eq!(v.scroll_over(&term), (0.0, -2.0));
v.hovered = Some(WidgetId::from("bd-card"));
v.hover_path = vec![WidgetId::from("bd-card")];
v.pressed = Some(term.clone());
assert_eq!(v.pointer_over(&term), Some((300.0, 100.0)));
}
#[test]
fn press_origin_is_reported_only_for_a_held_press() {
let mut v = VisualView::<K>::default();
v.press_origin = Some((12.0, 3.0));
assert_eq!(v.press_origin(), None, "no button held");
v.button_down = true;
assert_eq!(v.press_origin(), None, "held over nothing pressable");
v.pressed = Some(WidgetId::from("bar"));
v.pointer = Some((40.0, 9.0));
assert_eq!(v.press_origin(), Some((12.0, 3.0)));
assert_eq!(v.pressed_at(&WidgetId::from("bar")), Some((12.0, 3.0)));
assert_eq!(v.pressed_at(&WidgetId::from("other")), None);
}
#[test]
fn dom_tree_registers_controls_inputs_and_reports_clicks() {
use domkit::{self, SelectOpt};
let sheet = domkit::sheet();
let tree = |open: bool| {
let opts = [SelectOpt::new("Low"), SelectOpt::new("Mid").sub("default"), SelectOpt::new("High").disabled(true)];
let mut root = uzor::ui::dom::El::new("div.k-col")
.child(domkit::switch("notify", true, "Notifications"))
.child(domkit::input("nick", uzor::ui::dom::Edit::new("ann").placeholder("Nick")))
.child(domkit::select_trigger("lvl", "Mid", open, "Level"));
if open {
root = root.child(domkit::select_popover("lvl", &opts, Some(1), domkit::popover_at(Rect::new(0.0, 80.0, 160.0, 30.0), Rect::new(0.0, 0.0, 800.0, 600.0), 160.0, 120.0)));
}
root
};
let mut h = Harness { keep_coord: true, ..Default::default() };
let area = Rect::new(0.0, 0.0, 400.0, 600.0);
let r = h.frame(&click("lvl"), |cx| dom(area, &sheet, tree(false)).build(cx));
assert_eq!(r.clicked.as_deref(), Some("lvl"));
assert!(h.coord.focusable_ids(None).contains(&WidgetId::from("notify")));
let r = h.frame(&click("lvl:opt:0"), |cx| dom(area, &sheet, tree(true)).build(cx));
assert_eq!(domkit::picked_opt("lvl", r.clicked.as_deref().unwrap_or("")), Some(0));
assert!(h.coord.widget_rect(&WidgetId::from("lvl:opt:2")).is_none(), "disabled rows are not targets");
let st = h.coord.text_fields().field_state(&WidgetId::from("nick")).expect("field");
assert_eq!(st.text, "ann");
let a11y = r.dom.a11y();
assert!(a11y.iter().any(|n| n.id == "notify" && n.name == "Notifications" && n.checked == Some(true)));
}
#[test]
fn area_lines_wrap_at_spaces_and_hard_breaks() {
let mut r = uzor::testing::RecordingRenderContext::with_char_width(10.0);
let l = area_lines(&mut r, "hello world\nab", 60.0);
assert_eq!(l, vec![AreaLine { start: 0, end: 6, hard: false }, AreaLine { start: 6, end: 11, hard: true }, AreaLine { start: 12, end: 14, hard: false }]);
assert_eq!(area_lines(&mut r, "abcdefghij", 40.0).len(), 3);
assert_eq!(area_lines(&mut r, "", 40.0), vec![AreaLine::default()]);
assert_eq!(area_lines(&mut r, "a\n", 40.0).len(), 2);
}
#[test]
fn area_paints_lines_and_moves_by_them() {
use uzor::input::keyboard::keyboard::KeyPress;
let rect = Rect::new(10.0, 100.0, 60.0, 80.0);
let id = WidgetId::from("msg");
let mut h = Harness { keep_coord: true, record: Some(uzor::testing::RecordingRenderContext::with_char_width(10.0)), ..Default::default() };
let a = || area("msg", rect).placeholder("Message").line_height(20.0).font(13.0, "Inter");
let r = h.frame(&idle(), |cx| a().set(Some("hello world\nab")).build(cx));
assert_eq!((r.lines, r.content_h), (3, 60.0));
let texts: Vec<String> = painted_with_clips(&h.record.as_ref().unwrap().ops).into_iter().map(|t| t.0).filter(|t| t != "<rect>").collect();
assert_eq!(texts, ["hello ", "world", "ab"]);
let f = h.coord.text_fields_mut();
assert!(f.has_lines(&id));
f.begin_drag_at_xy(id.clone(), 10.0 + 11.0, 100.0 + 45.0);
f.on_drag_end();
assert_eq!(f.cursor(&id), 13);
f.on_key(KeyPress::ArrowUp);
assert_eq!(f.cursor(&id), 7);
f.on_key(KeyPress::ArrowUp);
assert_eq!(f.cursor(&id), 1);
f.on_key(KeyPress::End);
assert_eq!(f.cursor(&id), 5, "End stops at the soft wrap");
f.on_key(KeyPress::ArrowDown);
f.on_key(KeyPress::Home);
assert_eq!(f.cursor(&id), 6);
f.on_key(KeyPress::ArrowDown);
f.on_key(KeyPress::ArrowDown);
assert_eq!(f.cursor(&id), 14, "past the last line: the end");
let mut v = idle();
v.focused = Some(id.clone());
let r = h.frame(&v, |cx| a().build(cx));
assert!(r.focused && r.caret_top == 40.0);
}