use crate::backend::mock::{self, widget};
use crate::*;
use std::cell::{Cell, RefCell};
use std::rc::Rc;
fn init() {
let _ = App::new("test");
}
fn setup() -> (Window, Table) {
init();
let win = Window::new("w");
let t = Table::new(win);
t.set_columns(&[
Column::new("Name").width(120),
Column::new("Size").align(ColumnAlign::Right).sortable(true),
]);
(win, t)
}
#[test]
fn table_mirrors_columns_rows_and_cells() {
let (_win, t) = setup();
assert!(t.is_alive());
t.push_row(&["a", "1"]);
t.push_row(&["b", "2"]);
t.set_cell(1, 1, "22");
t.set_cell(5, 0, "ignored");
let w = widget(t.id()).unwrap();
assert_eq!(w.kind, Some(Kind::Table));
assert_eq!(w.columns.len(), 2);
assert_eq!(w.columns[0].width, 120);
assert_eq!(w.columns[1].align, ColumnAlign::Right);
assert!(w.columns[1].sortable);
assert_eq!(w.rows, vec![vec!["a", "1"], vec!["b", "22"]]);
assert_eq!(t.cell(1, 1), "22");
assert_eq!(t.row_count(), 2);
t.push_row(&["c"]);
t.set_cell(2, 3, "x");
assert_eq!(t.row(2), vec!["c", "", "", "x"]);
t.set_rows(&[vec!["z", "9"]]);
assert_eq!(widget(t.id()).unwrap().rows, vec![vec!["z", "9"]]);
t.clear();
assert!(widget(t.id()).unwrap().rows.is_empty());
}
#[test]
fn table_columns_set_before_and_after_rows_and_initial_sync() {
init();
let win = Window::new("w");
let t = Table::new(win);
t.push_row(&["a"]);
t.add_column(Column::new("A"));
let w = widget(t.id()).unwrap();
assert_eq!(w.columns.len(), 1);
assert_eq!(w.rows.len(), 1, "rows are re-sent after columns");
assert_eq!(t.columns()[0].title, "A");
}
#[test]
fn table_selection_follows_row_edits() {
let (_win, t) = setup();
t.set_rows(&[vec!["a"], vec!["b"], vec!["c"]]);
t.set_selected(Some(2));
assert_eq!(widget(t.id()).unwrap().selected, Some(2));
t.remove_row(0);
assert_eq!(t.selected(), Some(1));
assert_eq!(widget(t.id()).unwrap().selected, Some(1));
t.insert_row(0, &["n"]);
assert_eq!(t.selected(), Some(2));
t.remove_row(2);
assert_eq!(t.selected(), None);
assert_eq!(widget(t.id()).unwrap().selected, None);
t.set_selected(Some(99));
assert_eq!(t.selected(), None);
t.set_selected(Some(1));
t.set_rows(&[vec!["only"]]);
assert_eq!(t.selected(), None, "selection cleared when out of range");
assert_eq!(widget(t.id()).unwrap().selected, None);
t.set_selected(Some(0));
assert_eq!(t.selected_row(), Some(vec!["only".to_string()]));
t.clear();
assert_eq!(t.selected(), None);
}
#[test]
fn table_events_and_callbacks() {
let (_win, t) = setup();
t.set_rows(&[vec!["a", "1"], vec!["b", "2"]]);
let log = Rc::new(RefCell::new(vec![]));
let l = log.clone();
t.on_select(move |s| l.borrow_mut().push(format!("sel {s:?}")));
let l = log.clone();
t.on_activate(move |r| l.borrow_mut().push(format!("act {r}")));
let l = log.clone();
t.on_column_click(move |c| l.borrow_mut().push(format!("col {c}")));
mock::user_select_row(t.id(), Some(1));
assert_eq!(t.selected(), Some(1));
mock::user_activate_row(t.id(), 1);
mock::user_click_column(t.id(), 1);
mock::user_activate_row(t.id(), 7);
mock::user_click_column(t.id(), 9);
mock::user_select_row(t.id(), Some(7));
assert_eq!(t.selected(), Some(1));
mock::user_select_row(t.id(), None);
assert_eq!(t.selected(), None);
assert_eq!(*log.borrow(), ["sel Some(1)", "act 1", "col 1", "sel None"]);
}
#[test]
fn table_sort_indicator_and_app_side_sorting() {
let (_win, t) = setup();
t.set_rows(&[vec!["b", "2"], vec!["a", "1"]]);
t.on_column_click(move |c| {
let mut rows = t.rows();
rows.sort_by(|x, y| x[c].cmp(&y[c]));
t.set_rows(&rows);
t.set_sort_indicator(Some((c, true)));
});
mock::user_click_column(t.id(), 0);
let w = widget(t.id()).unwrap();
assert_eq!(w.rows[0][0], "a");
assert_eq!(w.sort, Some((0, true)));
assert_eq!(t.sort_indicator(), Some((0, true)));
t.set_sort_indicator(Some((9, true)));
assert_eq!(t.sort_indicator(), None);
assert_eq!(widget(t.id()).unwrap().sort, None);
}
#[test]
fn table_batch_sends_once() {
let (_win, t) = setup();
t.batch(|t| {
for i in 0..50 {
t.push_row(&[i.to_string(), "x".to_string()]);
}
assert!(
widget(t.id()).unwrap().rows.is_empty(),
"deferred inside the batch"
);
t.set_selected(Some(3));
});
let w = widget(t.id()).unwrap();
assert_eq!(w.rows.len(), 50);
assert_eq!(w.selected, Some(3));
}
#[test]
fn table_dead_and_stale_handles_are_inert() {
let (_win, t) = setup();
t.destroy();
t.push_row(&["a"]);
t.set_cell(0, 0, "x");
t.set_selected(Some(0));
t.on_select(|_| {});
assert_eq!(t.row_count(), 0);
assert_eq!(t.selected(), None);
t.batch(|t| t.push_row(&["a"]));
let bad = Table::new(Widget(WidgetId::DEAD));
assert!(!bad.is_alive());
let _ = last_error();
let (win, _) = setup();
let b = Button::new(win, "b");
let fake = Table::from_id(b.id());
fake.push_row(&["a"]);
fake.set_columns(&[Column::new("x")]);
assert_eq!(fake.row_count(), 0);
assert_eq!(widget(b.id()).unwrap().rows.len(), 0);
}
#[test]
fn table_in_layout_gets_bounds() {
let (win, t) = setup();
t.set_expand(1.0);
win.set_size(400, 300);
win.show();
App::update();
let b = widget(t.id()).unwrap().bounds;
assert!(b.w >= 300 && b.h >= 150, "{b:?}");
}
fn tree_setup() -> (Window, Tree, TreeNodeId, TreeNodeId, TreeNodeId) {
init();
let win = Window::new("w");
let t = Tree::new(win);
let root = t.add(None, "root");
let a = t.add(Some(root), "a");
let b = t.add(Some(root), "b");
(win, t, root, a, b)
}
fn rows(t: Tree) -> Vec<(u64, u32, String, bool, bool)> {
widget(t.id())
.unwrap()
.tree_rows
.into_iter()
.map(|r| (r.node, r.depth, r.text, r.expanded, r.has_children))
.collect()
}
#[test]
fn tree_flattens_preorder_with_depth_and_flags() {
let (_w, t, root, a, b) = tree_setup();
let a1 = t.add(Some(a), "a1");
let c = t.add(None, "c");
t.set_expanded(root, true);
let r = rows(t);
let names: Vec<_> = r.iter().map(|x| (x.2.as_str(), x.1)).collect();
assert_eq!(
names,
[("root", 0), ("a", 1), ("a1", 2), ("b", 1), ("c", 0)]
);
assert_eq!(r[0].0, root.0);
assert!(r[0].3 && !r[1].3);
assert!(r[0].4 && r[1].4 && !r[2].4 && !r[3].4 && !r[4].4);
assert_eq!(t.children(Some(root)), vec![a, b]);
assert_eq!(t.children(None), vec![root, c]);
assert_eq!(t.parent(a1), Some(a));
assert_eq!(t.parent(root), None);
assert_eq!(t.len(), 5);
assert_eq!(t.text(a1), "a1");
t.set_text(a1, "renamed");
assert_eq!(rows(t)[2].2, "renamed");
}
#[test]
fn tree_insert_remove_and_dead_ids() {
let (_w, t, root, a, b) = tree_setup();
let mid = t.insert(Some(root), 1, "mid");
assert_eq!(t.children(Some(root)), vec![a, mid, b]);
let bogus = t.add(Some(TreeNodeId(999_999_999)), "x");
assert_eq!(bogus, TreeNodeId(0));
assert!(!t.contains(bogus));
let a1 = t.add(Some(a), "a1");
t.set_selected(Some(a1));
t.remove(a);
assert!(!t.contains(a) && !t.contains(a1));
assert_eq!(t.selected(), None);
assert_eq!(widget(t.id()).unwrap().tree_selected, None);
assert_eq!(rows(t).len(), 3);
t.remove(a); t.set_expanded(a, true);
t.set_text(a, "x");
assert_eq!(t.text(a), "");
t.clear();
assert!(t.is_empty());
assert!(widget(t.id()).unwrap().tree_rows.is_empty());
}
#[test]
fn tree_selection_reveals_ancestors_and_is_silent() {
let (_w, t, root, a, _b) = tree_setup();
let a1 = t.add(Some(a), "a1");
let fired = Rc::new(Cell::new(0));
let f = fired.clone();
t.on_select(move |_| f.set(f.get() + 1));
let f = fired.clone();
t.on_expand(move |_, _| f.set(f.get() + 10));
t.set_selected(Some(a1));
assert_eq!(fired.get(), 0);
assert!(t.expanded(root) && t.expanded(a));
assert_eq!(t.selected(), Some(a1));
let w = widget(t.id()).unwrap();
assert_eq!(w.tree_selected, Some(a1.0));
assert!(w.tree_rows.iter().find(|r| r.node == a.0).unwrap().expanded);
t.set_selected(Some(TreeNodeId(424242)));
assert_eq!(t.selected(), None);
t.expand_all(false);
assert!(!t.expanded(root));
t.expand_all(true);
assert!(t.expanded(a));
}
#[test]
fn tree_user_events_update_state_and_call_back() {
let (_w, t, root, a, _b) = tree_setup();
let log = Rc::new(RefCell::new(vec![]));
let l = log.clone();
t.on_select(move |s| l.borrow_mut().push(format!("sel {:?}", s.map(|n| n.0))));
let l = log.clone();
t.on_activate(move |n| l.borrow_mut().push(format!("act {}", n.0)));
let l = log.clone();
t.on_expand(move |n, e| l.borrow_mut().push(format!("exp {} {e}", n.0)));
mock::user_tree_expand(t.id(), root.0, true);
assert!(t.expanded(root));
mock::user_tree_select(t.id(), Some(a.0));
assert_eq!(t.selected(), Some(a));
mock::user_tree_activate(t.id(), a.0);
mock::user_tree_expand(t.id(), root.0, false);
assert!(!t.expanded(root));
mock::user_tree_select(t.id(), Some(7777));
mock::user_tree_activate(t.id(), 7777);
mock::user_tree_expand(t.id(), 7777, true);
mock::user_tree_select(t.id(), None);
assert_eq!(
*log.borrow(),
[
format!("exp {} true", root.0),
format!("sel Some({})", a.0),
format!("act {}", a.0),
format!("exp {} false", root.0),
"sel None".to_string()
]
);
}
#[test]
fn tree_lazy_loading_in_expand_callback() {
init();
let win = Window::new("w");
let t = Tree::new(win);
let dir = t.add(None, "dir");
t.set_has_children(dir, true);
assert!(rows(t)[0].4, "expander shown without children");
t.on_expand(move |n, open| {
if open && t.children(Some(n)).is_empty() {
t.add(Some(n), "file1");
t.add(Some(n), "file2");
}
});
mock::user_tree_expand(t.id(), dir.0, true);
let r = rows(t);
assert_eq!(r.len(), 3);
assert!(r[0].3, "stays expanded after the core re-sent the rows");
assert_eq!(r[1].2, "file1");
assert_eq!(r[1].1, 1);
}
#[test]
fn tree_batch_and_nested_batches() {
init();
let win = Window::new("w");
let t = Tree::new(win);
t.batch(|t| {
let r = t.add(None, "r");
t.batch(|t| {
for i in 0..20 {
t.add(Some(r), &i.to_string());
}
});
assert!(widget(t.id()).unwrap().tree_rows.is_empty());
t.set_selected(Some(r));
});
let w = widget(t.id()).unwrap();
assert_eq!(w.tree_rows.len(), 21);
assert!(w.tree_selected.is_some());
}
#[test]
fn tree_destroyed_in_callback_is_safe() {
let (_w, t, root, ..) = tree_setup();
t.on_expand(move |_, _| t.destroy());
mock::user_tree_expand(t.id(), root.0, true);
assert!(!t.is_alive());
}
fn menu_setup() -> (Window, PopupMenu, MenuItem, CheckMenuItem, MenuItem) {
init();
let win = Window::new("w");
let pm = PopupMenu::new();
let cut = MenuItem::new(pm, "Cut");
MenuSeparator::new(pm);
let chk = CheckMenuItem::new(pm, "Wrap");
let sub = Menu::new(pm, "More");
let deep = MenuItem::new(sub, "Deep");
(win, pm, cut, chk, deep)
}
#[test]
fn popup_menu_builds_natively_and_is_parentless() {
let (_win, pm, cut, chk, deep) = menu_setup();
assert!(pm.is_alive() && cut.is_alive() && chk.is_alive() && deep.is_alive());
assert_eq!(widget(pm.id()).unwrap().kind, Some(Kind::PopupMenu));
assert_eq!(widget(pm.id()).unwrap().parent, None);
assert_eq!(widget(cut.id()).unwrap().parent, Some(pm.id()));
let bad = core::create(Kind::PopupMenu, Some(_win.id()), |_| {});
assert_eq!(bad, WidgetId::DEAD);
let _ = last_error();
let bar = core::create(Kind::MenuBar, Some(pm.id()), |_| {});
assert_eq!(bar, WidgetId::DEAD);
let _ = last_error();
assert!(!Kind::PopupMenu.in_layout());
}
#[test]
fn right_click_runs_callback_then_popup_and_item_fires() {
let (win, pm, cut, chk, _deep) = menu_setup();
let lst = ListBox::new(win);
lst.set_context_menu(pm);
let order = Rc::new(RefCell::new(vec![]));
let o = order.clone();
lst.on_context_menu(move |x, y| {
o.borrow_mut()
.push(format!("cb {x},{y} popups={}", mock::popup_log().len()));
cut.set_enabled(false); });
let o = order.clone();
chk.on_toggle(move |b| o.borrow_mut().push(format!("toggle {b}")));
mock::queue_popup_choice(Some(chk.id()));
mock::user_context_menu(lst.id(), 30, 40);
let rec = mock::last_popup().unwrap();
assert_eq!(rec.menu, pm.id());
assert_eq!(rec.window, Some(win.id()));
assert_eq!(rec.at, Some((30, 40)));
assert_eq!(
rec.items,
vec![
(Kind::MenuItem, "Cut".into(), false),
(Kind::MenuSeparator, "".into(), true),
(Kind::CheckMenuItem, "Wrap".into(), true),
(Kind::Menu, "More".into(), true),
]
);
assert_eq!(*order.borrow(), ["cb 30,40 popups=0", "toggle true"]);
assert!(chk.checked());
}
#[test]
fn popup_item_click_and_disabled_item_and_dismiss() {
let (win, pm, cut, _chk, deep) = menu_setup();
win.set_context_menu(pm);
let clicks = Rc::new(Cell::new(0));
let c = clicks.clone();
cut.on_click(move || c.set(c.get() + 1));
let c = clicks.clone();
deep.on_click(move || c.set(c.get() + 100));
mock::queue_popup_choice(Some(cut.id()));
mock::user_context_menu(win.id(), 1, 2);
assert_eq!(clicks.get(), 1);
mock::queue_popup_choice(Some(deep.id())); mock::user_context_menu(win.id(), 1, 2);
assert_eq!(clicks.get(), 101);
cut.set_enabled(false);
mock::queue_popup_choice(Some(cut.id()));
mock::user_context_menu(win.id(), 1, 2);
assert_eq!(clicks.get(), 101, "disabled items cannot fire");
mock::queue_popup_choice(None); mock::user_context_menu(win.id(), 1, 2);
assert_eq!(clicks.get(), 101);
assert_eq!(mock::popup_log().len(), 4);
}
#[test]
fn context_menu_bubbles_to_ancestor_and_ignores_unwanted() {
let (win, pm, ..) = menu_setup();
mock::clear_popup_log();
let col = VBox::new(win);
let lbl = Label::new(col, "x");
mock::user_context_menu(lbl.id(), 5, 6);
assert!(mock::popup_log().is_empty(), "nobody wants it");
win.set_context_menu(pm);
mock::user_context_menu(lbl.id(), 5, 6);
assert_eq!(mock::popup_log().len(), 1);
assert_eq!(mock::last_popup().unwrap().at, Some((5, 6)));
let other = PopupMenu::new();
lbl.set_context_menu(other);
mock::user_context_menu(lbl.id(), 1, 1);
assert_eq!(mock::last_popup().unwrap().menu, other.id());
lbl.clear_context_menu();
mock::user_context_menu(lbl.id(), 1, 1);
assert_eq!(mock::last_popup().unwrap().menu, pm.id());
lbl.set_context_menu(other);
lbl.set_enabled(false);
let n = mock::popup_log().len();
mock::user_context_menu(lbl.id(), 1, 1);
assert_eq!(mock::popup_log().len(), n);
}
#[test]
fn callback_only_context_menu_and_menu_attached_in_callback() {
let (win, pm, ..) = menu_setup();
mock::clear_popup_log();
let b = Button::new(win, "b");
let got = Rc::new(Cell::new((0, 0)));
let g = got.clone();
b.on_context_menu(move |x, y| {
g.set((x, y));
b.set_context_menu(pm);
});
mock::user_context_menu(b.id(), 9, 8);
assert_eq!(got.get(), (9, 8));
assert_eq!(
mock::popup_log().len(),
1,
"menu attached by the callback is shown"
);
}
#[test]
fn programmatic_show_at_and_stale_menus() {
let (win, pm, ..) = menu_setup();
mock::clear_popup_log();
pm.show_at(win, 10, 20);
assert_eq!(mock::last_popup().unwrap().at, Some((10, 20)));
assert_eq!(mock::last_popup().unwrap().window, Some(win.id()));
pm.show(win);
assert_eq!(mock::last_popup().unwrap().at, None);
let b = Button::new(win, "b");
PopupMenu::from_id(b.id()).show_at(win, 1, 1);
let n = mock::popup_log().len();
win.set_context_menu(pm);
pm.destroy();
mock::user_context_menu(win.id(), 1, 1);
pm.show_at(win, 1, 1);
assert_eq!(mock::popup_log().len(), n);
let w2 = Window::new("w2");
let pm2 = PopupMenu::new();
w2.destroy();
pm2.show_at(w2, 1, 1);
assert_eq!(mock::last_popup().unwrap().window, None);
}
#[test]
fn popup_menu_destroy_removes_native_children() {
let (_win, pm, cut, ..) = menu_setup();
let before = mock::widget_count();
pm.destroy();
assert!(!cut.is_alive());
assert!(widget(cut.id()).is_none());
assert_eq!(mock::widget_count(), before - 6);
}
#[test]
fn a11y_table_and_tree_roles_and_labels() {
let (win, t) = setup();
win.show();
App::update();
let n = a11y::resolve(win.id())
.unwrap()
.into_iter()
.find(|n| n.id == t.id())
.unwrap();
assert_eq!(n.role, A11yRole::Table);
assert_eq!(
a11y::resolve(win.id())
.unwrap()
.iter()
.filter(|n| n.kind == Kind::Table)
.count(),
1
);
t.set_a11y_name("Files");
t.set_a11y_description("All the files");
let n = a11y::resolve(win.id())
.unwrap()
.into_iter()
.find(|n| n.id == t.id())
.unwrap();
assert_eq!(
(n.name.as_deref(), n.description.as_deref()),
(Some("Files"), Some("All the files"))
);
let (win, t, ..) = tree_setup();
win.show();
App::update();
let n = a11y::resolve(win.id())
.unwrap()
.into_iter()
.find(|n| n.id == t.id())
.unwrap();
assert_eq!(n.role, A11yRole::Tree);
}
#[test]
fn a11y_popup_menu_role() {
let (_win, pm, ..) = menu_setup();
assert_eq!(pm.a11y().role, None);
assert!(a11y::resolve(pm.id()).is_none());
}
#[test]
fn set_cell_sends_only_the_cell() {
init();
let win = Window::new("w");
let t = Table::new(win);
t.set_columns(&[Column::new("a"), Column::new("b")]);
let rows: Vec<Vec<String>> = (0..50).map(|i| vec![i.to_string(), "x".into()]).collect();
t.set_rows(&rows);
t.set_selected(Some(7));
App::update();
let before = widget(t.id()).unwrap().rows_pushes;
t.set_cell(3, 1, "changed");
t.set_cell(4, 1, "also");
t.set_cell(999, 0, "ignored");
App::update();
let w = widget(t.id()).unwrap();
assert_eq!(w.rows_pushes, before, "the rows were not sent again");
assert_eq!(w.rows[3][1], "changed");
assert_eq!(w.rows[4][1], "also");
assert_eq!(w.selected, Some(7));
assert_eq!(t.cell(3, 1), "changed");
for i in 0..400 {
t.set_cell(i % 50, 0, &format!("v{i}"));
}
t.push_row(&["new", "row"]);
t.set_cell(0, 1, "after");
App::update();
let w = widget(t.id()).unwrap();
assert_eq!(w.rows, t.rows());
assert_eq!(w.rows[0][1], "after");
assert_eq!(w.selected, Some(7));
win.destroy();
}