837 lines
27 KiB
Rust
837 lines
27 KiB
Rust
use super::*;
|
|
|
|
fn tab_with_results(n: usize) -> SearchTab {
|
|
let mut tab = SearchTab::new(false);
|
|
tab.query = "alpha".into();
|
|
tab.focus_query = false;
|
|
tab.results = (0..n)
|
|
.map(|i| SearchHit {
|
|
file_id: i as i64,
|
|
name: format!("alpha_widget_{i}.txt"),
|
|
path: format!("/qs-test/alpha_widget_{i}.txt"),
|
|
size: 116,
|
|
mtime: 1_700_000_000,
|
|
rank: 3.0,
|
|
stage: 1,
|
|
snippet: None,
|
|
})
|
|
.collect();
|
|
tab.order = (0..n as u32).collect();
|
|
tab
|
|
}
|
|
|
|
fn run_frame(
|
|
ctx: &egui::Context,
|
|
tab: &mut SearchTab,
|
|
events: Vec<egui::Event>,
|
|
) -> egui::FullOutput {
|
|
let input = crate::test_ui::raw_input(egui::vec2(1000.0, 700.0), events);
|
|
ctx.run(input, |ctx| {
|
|
egui::CentralPanel::default().show(ctx, |ui| {
|
|
tab.ui(ui);
|
|
});
|
|
})
|
|
}
|
|
|
|
/// Walk the pointer down the name column until it sits on `row`'s label
|
|
/// glyphs: the text cursor proves a selectable label won the hit-test,
|
|
/// `hovered_row` proves the row still tracks hover.
|
|
fn hover_row_text(ctx: &egui::Context, tab: &mut SearchTab, row: usize) -> egui::Pos2 {
|
|
for y in 40..250 {
|
|
let pos = egui::pos2(60.0, y as f32);
|
|
let out = run_frame(ctx, tab, vec![egui::Event::PointerMoved(pos)]);
|
|
let over_text = out.platform_output.cursor_icon == egui::CursorIcon::Text;
|
|
if over_text && tab.hovered_row == Some(row) {
|
|
return pos;
|
|
}
|
|
}
|
|
panic!("never landed on row {row}'s label text");
|
|
}
|
|
|
|
use crate::test_ui::painted_text;
|
|
|
|
/// Far too long for the Path column at the test's 1000pt screen width.
|
|
fn deep_path() -> String {
|
|
concat!(
|
|
"/media/shared/QuickSearch/crates/quicksearch-gui/src/",
|
|
"deeply/nested/under/several/more/directories/alpha_widget_0.txt"
|
|
)
|
|
.to_string()
|
|
}
|
|
|
|
/// The Path column drops out of the *middle*, so the volume the file
|
|
/// sits on and the directories right above it both stay on screen.
|
|
#[test]
|
|
fn long_paths_elide_from_the_middle_of_the_path_column() {
|
|
let ctx = egui::Context::default();
|
|
let mut tab = tab_with_results(1);
|
|
let path = deep_path();
|
|
tab.results[0].path = path.clone();
|
|
|
|
let painted = painted_text(&run_frame(&ctx, &mut tab, vec![]));
|
|
let cell = painted
|
|
.iter()
|
|
.find(|t| t.starts_with("/media") && t.contains('…'))
|
|
.unwrap_or_else(|| panic!("no elided path cell among {painted:?}"));
|
|
|
|
assert!(!painted.contains(&path), "painted in full");
|
|
assert_eq!(cell.matches('…').count(), 1, "elided twice: {cell}");
|
|
let (head, tail) = cell.split_once('…').expect("one ellipsis");
|
|
assert!(path.starts_with(head), "{cell}");
|
|
assert!(path.ends_with(tail), "{cell}");
|
|
assert!(
|
|
tail.ends_with("alpha_widget_0.txt"),
|
|
"the deep end survives: {cell}"
|
|
);
|
|
}
|
|
|
|
/// The whole path stays reachable on hover: egui's free tooltip only
|
|
/// appears while *it* did the eliding, so pre-shortened text brings its own.
|
|
#[test]
|
|
fn an_elided_path_still_shows_the_whole_thing_on_hover() {
|
|
let ctx = egui::Context::default();
|
|
// Testing that the tooltip is wired up, not egui's hover timing.
|
|
ctx.style_mut(|s| {
|
|
s.interaction.tooltip_delay = 0.0;
|
|
s.interaction.show_tooltips_only_when_still = false;
|
|
});
|
|
let mut tab = tab_with_results(1);
|
|
let path = deep_path();
|
|
tab.results[0].path = path.clone();
|
|
|
|
run_frame(&ctx, &mut tab, vec![]); // settle the table's layout
|
|
for y in 40..250 {
|
|
// x lands in the Path column, past the 220pt Name column.
|
|
let pos = egui::pos2(300.0, y as f32);
|
|
let mut out = run_frame(&ctx, &mut tab, vec![egui::Event::PointerMoved(pos)]);
|
|
if tab.hovered_row != Some(0) {
|
|
continue;
|
|
}
|
|
// The tooltip is its own area, so it may land a frame behind.
|
|
for _ in 0..3 {
|
|
if painted_text(&out).contains(&path) {
|
|
return;
|
|
}
|
|
out = run_frame(&ctx, &mut tab, vec![]);
|
|
}
|
|
}
|
|
panic!("the full path never appeared on hover");
|
|
}
|
|
|
|
fn click(pos: egui::Pos2, button: egui::PointerButton) -> Vec<egui::Event> {
|
|
[true, false]
|
|
.into_iter()
|
|
.map(|pressed| egui::Event::PointerButton {
|
|
pos,
|
|
button,
|
|
pressed,
|
|
modifiers: egui::Modifiers::default(),
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn hit(id: i64, name: &str, rank: f64, size: u64) -> SearchHit {
|
|
SearchHit {
|
|
file_id: id,
|
|
name: name.to_string(),
|
|
path: format!("/d/{name}"),
|
|
size,
|
|
mtime: 1_700_000_000,
|
|
rank,
|
|
stage: rank as u8,
|
|
snippet: None,
|
|
}
|
|
}
|
|
|
|
fn batch(tab: &mut SearchTab, hits: Vec<SearchHit>) {
|
|
tab.apply_update(
|
|
SearchUpdate::Hits {
|
|
generation: tab.generation,
|
|
hits,
|
|
},
|
|
1000,
|
|
);
|
|
if tab.sort_dirty {
|
|
tab.resort();
|
|
}
|
|
}
|
|
|
|
/// A tab already past the fade, so batches land straight in `results`.
|
|
fn streaming_tab() -> SearchTab {
|
|
let mut tab = SearchTab::new(false);
|
|
tab.focus_query = false;
|
|
tab.query = "zebra".into();
|
|
tab.swap_pending = false;
|
|
tab
|
|
}
|
|
|
|
fn displayed(tab: &SearchTab) -> Vec<&str> {
|
|
tab.order
|
|
.iter()
|
|
.map(|&i| tab.results[i as usize].name.as_str())
|
|
.collect()
|
|
}
|
|
|
|
/// The cascade streams in scan order; the table must stay ordered by its
|
|
/// keyed column as batches land, not merely append them.
|
|
#[test]
|
|
fn later_batches_land_in_the_tables_sort_order() {
|
|
let mut tab = streaming_tab();
|
|
batch(&mut tab, vec![hit(1, "middling.txt", 4.0, 50)]);
|
|
assert_eq!(displayed(&tab), vec!["middling.txt"]);
|
|
|
|
// A rank-1 hit found later in the scan belongs on top.
|
|
batch(&mut tab, vec![hit(2, "best.txt", 1.0, 10)]);
|
|
assert_eq!(displayed(&tab), vec!["best.txt", "middling.txt"]);
|
|
|
|
// And a rank-10 one belongs at the bottom, not wherever it arrived.
|
|
batch(&mut tab, vec![hit(3, "worst.txt", 10.0, 90)]);
|
|
assert_eq!(
|
|
displayed(&tab),
|
|
vec!["best.txt", "middling.txt", "worst.txt"]
|
|
);
|
|
}
|
|
|
|
/// Rank is only the default. Under any other key, arrivals slot into that
|
|
/// key's order.
|
|
#[test]
|
|
fn batches_respect_a_non_rank_sort_key() {
|
|
let mut tab = streaming_tab();
|
|
tab.sort = (SortKey::Name, true);
|
|
batch(&mut tab, vec![hit(1, "mango.txt", 1.0, 50)]);
|
|
batch(&mut tab, vec![hit(2, "apple.txt", 9.0, 10)]);
|
|
batch(&mut tab, vec![hit(3, "zucchini.txt", 2.0, 90)]);
|
|
assert_eq!(
|
|
displayed(&tab),
|
|
vec!["apple.txt", "mango.txt", "zucchini.txt"],
|
|
"name order, not arrival or rank order"
|
|
);
|
|
|
|
tab.sort = (SortKey::Size, false);
|
|
tab.sort_dirty = true;
|
|
tab.resort();
|
|
assert_eq!(
|
|
displayed(&tab),
|
|
vec!["zucchini.txt", "mango.txt", "apple.txt"]
|
|
);
|
|
}
|
|
|
|
/// Re-keying the sort mid-stream re-orders rows already shown, and later
|
|
/// batches land under the new key.
|
|
#[test]
|
|
fn re_keying_the_sort_mid_stream_reorders_everything() {
|
|
let mut tab = streaming_tab();
|
|
batch(&mut tab, vec![hit(1, "delta.txt", 1.0, 30)]);
|
|
batch(&mut tab, vec![hit(2, "alpha.txt", 5.0, 10)]);
|
|
assert_eq!(
|
|
displayed(&tab),
|
|
vec!["delta.txt", "alpha.txt"],
|
|
"rank order"
|
|
);
|
|
|
|
// Header click, mid-search.
|
|
tab.sort = (SortKey::Name, true);
|
|
tab.sort_dirty = true;
|
|
tab.resort();
|
|
assert_eq!(
|
|
displayed(&tab),
|
|
vec!["alpha.txt", "delta.txt"],
|
|
"rows that already arrived re-order under the new key"
|
|
);
|
|
|
|
batch(&mut tab, vec![hit(3, "bravo.txt", 2.0, 20)]);
|
|
assert_eq!(
|
|
displayed(&tab),
|
|
vec!["alpha.txt", "bravo.txt", "delta.txt"],
|
|
"and the next batch lands under it too"
|
|
);
|
|
}
|
|
|
|
/// At the display cap, retention stays keyed on rank even when the table
|
|
/// is shown in another order.
|
|
#[test]
|
|
fn a_late_better_hit_displaces_the_worst_at_the_cap() {
|
|
let mut tab = streaming_tab();
|
|
tab.sort = (SortKey::Name, true);
|
|
let limit = 3;
|
|
|
|
let send = |tab: &mut SearchTab, hits: Vec<SearchHit>| {
|
|
tab.apply_update(
|
|
SearchUpdate::Hits {
|
|
generation: tab.generation,
|
|
hits,
|
|
},
|
|
limit,
|
|
);
|
|
if tab.sort_dirty {
|
|
tab.resort();
|
|
}
|
|
};
|
|
|
|
send(
|
|
&mut tab,
|
|
vec![
|
|
hit(1, "aaa.txt", 9.0, 10),
|
|
hit(2, "bbb.txt", 8.0, 20),
|
|
hit(3, "ccc.txt", 7.0, 30),
|
|
],
|
|
);
|
|
assert_eq!(displayed(&tab), vec!["aaa.txt", "bbb.txt", "ccc.txt"]);
|
|
assert!(!tab.limited);
|
|
|
|
// Full. A rank-1 arrival must still get in, evicting rank 9.
|
|
send(&mut tab, vec![hit(4, "zzz.txt", 1.0, 40)]);
|
|
assert!(tab.limited, "the cap was hit");
|
|
assert_eq!(tab.results.len(), limit);
|
|
assert_eq!(
|
|
displayed(&tab),
|
|
vec!["bbb.txt", "ccc.txt", "zzz.txt"],
|
|
"worst rank dropped, display still in name order"
|
|
);
|
|
}
|
|
|
|
/// Batches arriving while the old table fades out are ordered at the swap.
|
|
#[test]
|
|
fn staged_batches_are_ordered_once_the_fade_swaps() {
|
|
let mut tab = SearchTab::new(false);
|
|
tab.focus_query = false;
|
|
tab.query = "zebra".into();
|
|
tab.on_search_started(1);
|
|
assert!(tab.swap_pending);
|
|
|
|
for h in [hit(1, "worst.txt", 9.0, 10), hit(2, "best.txt", 1.0, 20)] {
|
|
tab.apply_update(
|
|
SearchUpdate::Hits {
|
|
generation: 1,
|
|
hits: vec![h],
|
|
},
|
|
1000,
|
|
);
|
|
}
|
|
assert!(tab.results.is_empty(), "still staged behind the fade");
|
|
|
|
// What the fade does when it reaches zero.
|
|
tab.results = std::mem::take(&mut tab.staging);
|
|
tab.swap_pending = false;
|
|
tab.sort_dirty = true;
|
|
tab.resort();
|
|
assert_eq!(displayed(&tab), vec!["best.txt", "worst.txt"]);
|
|
}
|
|
|
|
/// Step the transition at a steady 60 fps until `done`, and report how
|
|
/// long it took.
|
|
fn run_fade(tab: &mut SearchTab, done: impl Fn(&SearchTab) -> bool) -> f32 {
|
|
let dt = 1.0 / 60.0;
|
|
for frame in 0..1000 {
|
|
if done(tab) {
|
|
return frame as f32 * dt;
|
|
}
|
|
tab.advance_fade(dt);
|
|
}
|
|
panic!("the transition never finished");
|
|
}
|
|
|
|
#[test]
|
|
fn each_half_of_the_transition_takes_its_own_duration() {
|
|
let mut tab = SearchTab::new(false);
|
|
tab.swap_pending = true;
|
|
let out = run_fade(&mut tab, |t| t.fade <= 0.0);
|
|
assert_eq!(tab.fade, 0.0, "settles exactly on invisible");
|
|
assert!(
|
|
(out - FADE_OUT_SECS).abs() <= 1.0 / 60.0,
|
|
"clearing runs for FADE_OUT_SECS, took {out}"
|
|
);
|
|
|
|
// What `ui` does at the swap.
|
|
tab.swap_pending = false;
|
|
tab.wipe = 1.0;
|
|
let into = run_fade(&mut tab, |t| t.wipe <= 0.0);
|
|
assert_eq!(tab.fade, 1.0, "and the reveal settles on fully opaque");
|
|
assert!(
|
|
(into - FADE_IN_SECS).abs() <= 1.0 / 60.0,
|
|
"the reveal runs for FADE_IN_SECS, took {into}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_stalled_frame_does_not_overshoot() {
|
|
let mut tab = SearchTab::new(false);
|
|
tab.swap_pending = true;
|
|
tab.advance_fade(10.0);
|
|
assert_eq!(tab.fade, 0.0, "a whole ten seconds lands, not passes");
|
|
|
|
tab.swap_pending = false;
|
|
tab.wipe = 1.0;
|
|
tab.advance_fade(10.0);
|
|
assert_eq!(tab.wipe, 0.0);
|
|
assert_eq!(tab.fade, 1.0);
|
|
}
|
|
|
|
/// Clearing the old results holds the reveal where it stands — run
|
|
/// backwards it would flash just-covered rows back on screen.
|
|
#[test]
|
|
fn clearing_results_holds_the_reveal_where_it_stands() {
|
|
let mut tab = SearchTab::new(false);
|
|
tab.wipe = 1.0;
|
|
tab.advance_fade(FADE_IN_SECS / 5.0);
|
|
let standing = tab.wipe;
|
|
assert!((standing - 0.8).abs() < 1e-4, "one fifth in: {standing}");
|
|
let carried = tab.fade;
|
|
|
|
tab.swap_pending = true;
|
|
tab.advance_fade(0.0);
|
|
assert_eq!(tab.wipe, standing, "the reveal is frozen, not rewound");
|
|
assert_eq!(tab.fade, carried, "and the opacity carries on from here");
|
|
|
|
// The scrim holds its position for the whole of the fade-out, and
|
|
// the opacity takes the full FADE_OUT_SECS to get from here to zero.
|
|
let out = run_fade(&mut tab, |t| t.fade <= 0.0);
|
|
assert_eq!(tab.wipe, standing, "still frozen at the end of it");
|
|
let expected = carried * FADE_OUT_SECS;
|
|
assert!(
|
|
(out - expected).abs() <= 1.0 / 60.0,
|
|
"a partly faded section clears proportionally: {out} vs {expected}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_settled_section_stops_asking_for_frames() {
|
|
let mut tab = SearchTab::new(false);
|
|
// Nothing pending, nothing covered, nothing dimmed: the steady state
|
|
// must not repaint forever.
|
|
assert!(tab.fade_settled());
|
|
tab.advance_fade(1.0 / 60.0);
|
|
assert!(tab.fade_settled());
|
|
|
|
// Whereas each stage of a transition keeps the frames coming, the
|
|
// swap frame — cleared out but not yet revealing — included.
|
|
tab.swap_pending = true;
|
|
assert!(!tab.fade_settled());
|
|
tab.advance_fade(FADE_OUT_SECS);
|
|
tab.swap_pending = false;
|
|
tab.wipe = 1.0;
|
|
assert!(!tab.fade_settled());
|
|
}
|
|
|
|
/// Drive frames until the reveal has uncovered all but `to` of the
|
|
/// section, and hand back the frame it got there on. `run_frame` leaves
|
|
/// `RawInput::time` unset, so egui advances its own clock a predicted
|
|
/// frame at a time and the tab sees a steady `stable_dt`.
|
|
fn reveal_to(ctx: &egui::Context, tab: &mut SearchTab, to: f32) -> egui::FullOutput {
|
|
for _ in 0..200 {
|
|
let out = run_frame(ctx, tab, vec![]);
|
|
if tab.wipe <= to {
|
|
return out;
|
|
}
|
|
}
|
|
panic!("the reveal never got down to {to}");
|
|
}
|
|
|
|
/// Drive frames until the staged results swap in, and hand back the
|
|
/// frame it happened on.
|
|
fn swap_in(ctx: &egui::Context, tab: &mut SearchTab) -> egui::FullOutput {
|
|
for _ in 0..200 {
|
|
let out = run_frame(ctx, tab, vec![]);
|
|
if !tab.swap_pending {
|
|
return out;
|
|
}
|
|
}
|
|
panic!("the staged results never swapped in");
|
|
}
|
|
|
|
/// Twenty staged hits under whatever generation is in flight.
|
|
fn stage_results(tab: &mut SearchTab) {
|
|
batch(
|
|
tab,
|
|
(0..20)
|
|
.map(|i| hit(i, &format!("alpha_widget_{i}.txt"), 3.0, 116))
|
|
.collect(),
|
|
);
|
|
}
|
|
|
|
/// Where the first and last result rows were painted.
|
|
fn row_bounds(out: &egui::FullOutput) -> (egui::Rect, egui::Rect) {
|
|
let rows: Vec<egui::Rect> = crate::test_ui::painted(out)
|
|
.into_iter()
|
|
.filter(|(text, _)| text.starts_with("alpha_widget_"))
|
|
.map(|(_, rect)| rect)
|
|
.collect();
|
|
(
|
|
*rows.first().expect("rows painted"),
|
|
*rows.last().expect("rows painted"),
|
|
)
|
|
}
|
|
|
|
/// Vertices down the scrim as (y, alpha), in paint order.
|
|
fn scrim(out: &egui::FullOutput) -> Vec<(f32, u8)> {
|
|
let meshes = crate::test_ui::painted_meshes(out);
|
|
assert_eq!(meshes.len(), 1, "one scrim over the section, no more");
|
|
meshes[0]
|
|
.vertices
|
|
.iter()
|
|
.map(|v| (v.pos.y, v.color.a()))
|
|
.collect()
|
|
}
|
|
|
|
/// The y where the scrim first turns fully solid — the edge of what is
|
|
/// still hidden.
|
|
fn solid_from(ramp: &[(f32, u8)]) -> f32 {
|
|
ramp.iter()
|
|
.find(|&&(_, a)| a == 255)
|
|
.expect("a solid stretch")
|
|
.0
|
|
}
|
|
|
|
/// Clearing the old results paints no scrim: it is a plain dip to nothing.
|
|
#[test]
|
|
fn clearing_results_paints_no_scrim() {
|
|
let ctx = egui::Context::default();
|
|
let mut tab = tab_with_results(20);
|
|
|
|
let settled = run_frame(&ctx, &mut tab, vec![]);
|
|
assert!(
|
|
crate::test_ui::painted_meshes(&settled).is_empty(),
|
|
"a settled table pays nothing for the effect"
|
|
);
|
|
|
|
tab.on_search_started(1);
|
|
stage_results(&mut tab);
|
|
let mut dimmest: f32 = 1.0;
|
|
for frame in 0..200 {
|
|
let out = run_frame(&ctx, &mut tab, vec![]);
|
|
if !tab.swap_pending {
|
|
// The swap frame belongs to the new set, which starts
|
|
// covered — checked separately below.
|
|
assert!(frame > 0, "the fade-out was over before it began");
|
|
break;
|
|
}
|
|
assert!(
|
|
crate::test_ui::painted_meshes(&out).is_empty(),
|
|
"no scrim while the old results clear, at fade {}",
|
|
tab.fade
|
|
);
|
|
dimmest = dimmest.min(tab.fade);
|
|
}
|
|
assert!(
|
|
dimmest < 0.35,
|
|
"the section really does dim on the way out: got no lower than {dimmest}"
|
|
);
|
|
}
|
|
|
|
/// The new set arrives fully covered, headers included. The scrim carries
|
|
/// its own alpha — painted through the `Ui` it would be scaled by the
|
|
/// section opacity, which is exactly zero on this frame.
|
|
#[test]
|
|
fn new_results_start_completely_covered() {
|
|
let ctx = egui::Context::default();
|
|
let mut tab = tab_with_results(20);
|
|
run_frame(&ctx, &mut tab, vec![]);
|
|
|
|
tab.on_search_started(1);
|
|
stage_results(&mut tab);
|
|
let swapped = swap_in(&ctx, &mut tab);
|
|
assert_eq!(tab.wipe, 1.0, "the reveal starts from the top");
|
|
|
|
let ramp = scrim(&swapped);
|
|
assert!(
|
|
ramp.iter().all(|&(_, a)| a == 255),
|
|
"nothing shows through: {ramp:?}"
|
|
);
|
|
assert!(
|
|
!crate::test_ui::painted_text(&swapped)
|
|
.iter()
|
|
.any(|t| t.starts_with("alpha_widget_")),
|
|
"at zero opacity egui drops the section's shapes outright, so \
|
|
the scrim is belt to that braces"
|
|
);
|
|
|
|
// Which is also why the rows have to be measured from a frame the
|
|
// reveal has let some light through.
|
|
let (first, last) = row_bounds(&reveal_to(&ctx, &mut tab, 0.8));
|
|
let (top, bottom) = (
|
|
ramp.first().expect("vertices").0,
|
|
ramp.last().expect("vertices").0,
|
|
);
|
|
assert!(
|
|
top < first.top(),
|
|
"the scrim starts above the first row, so the column headers \
|
|
are covered too: {top} vs {}",
|
|
first.top()
|
|
);
|
|
assert!(
|
|
bottom >= last.bottom(),
|
|
"and runs past the last one: {bottom} vs {}",
|
|
last.bottom()
|
|
);
|
|
}
|
|
|
|
/// The reveal uncovers the table from the top down, first rows early.
|
|
#[test]
|
|
fn new_results_are_uncovered_from_the_top_down() {
|
|
let ctx = egui::Context::default();
|
|
let mut tab = tab_with_results(20);
|
|
run_frame(&ctx, &mut tab, vec![]);
|
|
|
|
tab.on_search_started(1);
|
|
stage_results(&mut tab);
|
|
swap_in(&ctx, &mut tab);
|
|
|
|
// A fifth of the way in: the head of the table is out from behind
|
|
// the scrim while the foot is still under it.
|
|
let early_frame = reveal_to(&ctx, &mut tab, 0.8);
|
|
let (first, last) = row_bounds(&early_frame);
|
|
let early = solid_from(&scrim(&early_frame));
|
|
assert!(
|
|
early > first.bottom(),
|
|
"the first row is readable a fifth of the way in: {early} vs {}",
|
|
first.bottom()
|
|
);
|
|
assert!(
|
|
early < last.top(),
|
|
"while the last is still covered: {early} vs {}",
|
|
last.top()
|
|
);
|
|
|
|
// …and the edge keeps going down, not back up.
|
|
let later = solid_from(&scrim(&reveal_to(&ctx, &mut tab, 0.4)));
|
|
assert!(
|
|
later > early,
|
|
"the edge travels downward: {early} then {later}"
|
|
);
|
|
assert!(
|
|
later > last.top(),
|
|
"and has uncovered the last row by then: {later} vs {}",
|
|
last.top()
|
|
);
|
|
|
|
// It ends with the scrim gone entirely rather than lingering.
|
|
let done = reveal_to(&ctx, &mut tab, 0.0);
|
|
assert!(
|
|
crate::test_ui::painted_meshes(&done).is_empty(),
|
|
"the scrim clears away at the end of the reveal"
|
|
);
|
|
assert!(tab.fade_settled(), "and the section stops animating");
|
|
}
|
|
|
|
/// A selected row is identified by file id, so it survives both the
|
|
/// re-ordering and the eviction that a new batch can cause.
|
|
#[test]
|
|
fn the_selection_follows_its_file_across_batches() {
|
|
let mut tab = streaming_tab();
|
|
batch(&mut tab, vec![hit(1, "chosen.txt", 5.0, 10)]);
|
|
tab.selected = Some(0);
|
|
|
|
batch(&mut tab, vec![hit(2, "better.txt", 1.0, 20)]);
|
|
let sel = tab.selected.expect("still selected");
|
|
assert_eq!(
|
|
tab.results[sel as usize].file_id, 1,
|
|
"selection follows the file, not the slot"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn rows_respond_over_selectable_label_text() {
|
|
let ctx = egui::Context::default();
|
|
let mut tab = tab_with_results(3);
|
|
run_frame(&ctx, &mut tab, Vec::new());
|
|
|
|
// Hovering glyphs still marks the row hovered (drives the hover fill).
|
|
let pos = hover_row_text(&ctx, &mut tab, 0);
|
|
|
|
// Left click on glyphs selects the row.
|
|
run_frame(&ctx, &mut tab, click(pos, egui::PointerButton::Primary));
|
|
assert_eq!(tab.selected, Some(0));
|
|
|
|
// Right click on glyphs selects the row and opens the context menu.
|
|
let pos = hover_row_text(&ctx, &mut tab, 1);
|
|
run_frame(&ctx, &mut tab, click(pos, egui::PointerButton::Secondary));
|
|
assert_eq!(tab.selected, Some(1));
|
|
assert!(egui::Popup::is_any_open(&ctx));
|
|
}
|
|
|
|
/// Patterns are spelled natively and a drive root does not become the
|
|
/// never-matching `C:\/*`.
|
|
#[test]
|
|
fn dir_ignore_patterns_use_the_platform_separator() {
|
|
use std::path::Path;
|
|
#[cfg(unix)]
|
|
{
|
|
assert_eq!(dir_ignore_pattern(Path::new("/home/x")), "/home/x/*");
|
|
assert_eq!(dir_ignore_pattern(Path::new("/")), "/*");
|
|
}
|
|
#[cfg(windows)]
|
|
{
|
|
assert_eq!(
|
|
dir_ignore_pattern(Path::new(r"C:\Users\x")),
|
|
r"C:\Users\x\*"
|
|
);
|
|
assert_eq!(dir_ignore_pattern(Path::new(r"C:\")), r"C:\*");
|
|
}
|
|
}
|
|
|
|
/// The freshness fade ends where the theme's own weak text does.
|
|
#[test]
|
|
fn the_recency_fade_ends_at_the_theme_color() {
|
|
with_ui(|ui| {
|
|
let now = quicksearch_core::log::now_unix() as i64;
|
|
let ancient = recency_color(ui, now - 60 * 60 * 24 * 365 * 20);
|
|
assert_eq!(ancient, ui.visuals().weak_text_color());
|
|
let fresh = recency_color(ui, now);
|
|
assert_eq!(fresh, crate::color::palette(ui.visuals().dark_mode).green);
|
|
});
|
|
}
|
|
|
|
// --- snippet rendering ----------------------------------------------
|
|
|
|
use crate::test_ui::{painted_rows, with_ui};
|
|
|
|
/// The rows `job` actually lays out. `Galley::text` hands back the whole
|
|
/// job, including every row epaint dropped at `wrap.max_rows`, so it
|
|
/// cannot see a truncation at all.
|
|
fn laid_out_rows(ui: &egui::Ui, job: LayoutJob) -> Vec<String> {
|
|
ui.fonts(|f| f.layout_job(job))
|
|
.rows
|
|
.iter()
|
|
.map(|r| r.text())
|
|
.collect()
|
|
}
|
|
|
|
/// A content snippet whose lead-in is `lines` short lines. The lead-in is
|
|
/// multi-byte: snippet ranges are byte offsets while row arithmetic counts
|
|
/// characters.
|
|
fn ragged_snippet(lines: usize) -> Snippet {
|
|
let lead = "café\n".repeat(lines);
|
|
Snippet {
|
|
ranges: vec![(lead.len(), lead.len() + 6)],
|
|
window: format!("{lead}NEEDLE and trailing context"),
|
|
truncated_start: true,
|
|
truncated_end: true,
|
|
}
|
|
}
|
|
|
|
/// A window whose lead-in is dozens of short lines must still get the hit
|
|
/// on screen within the row budget.
|
|
#[test]
|
|
fn the_hover_snippet_keeps_the_match_when_the_lead_in_is_all_newlines() {
|
|
with_ui(|ui| {
|
|
ui.set_max_width(520.0); // what the Match cell's tooltip sets
|
|
let snip = ragged_snippet(40);
|
|
let rows = laid_out_rows(ui, snippet_job(ui, &snip, 10));
|
|
assert!(rows.len() <= 10, "over the row budget: {rows:#?}");
|
|
assert!(
|
|
rows.iter().any(|r| r.contains("NEEDLE")),
|
|
"the match never made it on screen: {rows:#?}"
|
|
);
|
|
// Trimmed at a line boundary and said so. A start landing mid
|
|
// character would read "…afé" — or panic on a byte offset that
|
|
// is not a char boundary.
|
|
assert_eq!(rows[0], "… café", "{rows:#?}");
|
|
});
|
|
}
|
|
|
|
/// The two-row preview strip keeps the match too.
|
|
#[test]
|
|
fn the_preview_strip_keeps_the_match_too() {
|
|
with_ui(|ui| {
|
|
let snip = ragged_snippet(40);
|
|
let rows = laid_out_rows(ui, snippet_job(ui, &snip, 2));
|
|
assert!(rows.len() <= 2, "over the row budget: {rows:#?}");
|
|
assert!(
|
|
rows.iter().any(|r| r.contains("NEEDLE")),
|
|
"the match never made it on screen: {rows:#?}"
|
|
);
|
|
});
|
|
}
|
|
|
|
/// A window that already fits is rendered exactly as it arrived: no
|
|
/// trimming, and no ellipsis for a trim that did not happen.
|
|
#[test]
|
|
fn a_snippet_that_fits_is_left_alone() {
|
|
with_ui(|ui| {
|
|
let snip = Snippet {
|
|
window: "alpha beta NEEDLE gamma".into(),
|
|
ranges: vec![(11, 17)],
|
|
truncated_start: false,
|
|
truncated_end: false,
|
|
};
|
|
assert_eq!(
|
|
laid_out_rows(ui, snippet_job(ui, &snip, 10)),
|
|
vec!["alpha beta NEEDLE gamma".to_string()]
|
|
);
|
|
});
|
|
}
|
|
|
|
/// The Match cell is laid out in Extend mode (infinite wrap width), so
|
|
/// only its own budget keeps it inside the column; an overshoot is
|
|
/// clipped on *both* sides with no ellipsis.
|
|
#[test]
|
|
fn the_match_cell_stays_inside_its_column() {
|
|
with_ui(|ui| {
|
|
let snip = Snippet {
|
|
window: "a long stretch of leading context NEEDLE and a long tail after it".into(),
|
|
ranges: vec![(34, 40)],
|
|
truncated_start: true,
|
|
truncated_end: true,
|
|
};
|
|
// Down to widths the column itself cannot reach, so the budget
|
|
// degrades rather than overflowing.
|
|
for width in [20.0, 60.0, 90.0, 120.0, 150.0, 240.0, 400.0, 4000.0] {
|
|
for whole_field in [false, true] {
|
|
let job = centered_match_job(ui, &snip, width, whole_field);
|
|
let galley = ui.fonts(|f| f.layout_job(job));
|
|
assert!(
|
|
galley.size().x <= width,
|
|
"{}pt of text in a {width}pt column (whole_field={whole_field}): {:?}",
|
|
galley.size().x,
|
|
galley.text()
|
|
);
|
|
// At the column's 120pt floor the whole hit must survive;
|
|
// below that, its head still gets the room over context.
|
|
let kept = if width >= 120.0 { "NEEDLE" } else { "N" };
|
|
assert!(
|
|
galley.text().contains(kept),
|
|
"the match was budgeted away at {width}pt: {:?}",
|
|
galley.text()
|
|
);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/// Hovering the Match cell puts the hit on screen. The cell itself paints
|
|
/// the match once, so the tooltip is the *second* appearance.
|
|
#[test]
|
|
fn hovering_the_match_cell_shows_the_match_in_the_tooltip() {
|
|
let ctx = egui::Context::default();
|
|
// Testing that the tooltip carries the match, not egui's hover timing.
|
|
ctx.style_mut(|s| {
|
|
s.interaction.tooltip_delay = 0.0;
|
|
s.interaction.show_tooltips_only_when_still = false;
|
|
});
|
|
let mut tab = tab_with_results(1);
|
|
tab.has_snippets = true;
|
|
tab.results[0].stage = 6; // a full-text stage: no [brackets]
|
|
tab.results[0].snippet = Some(ragged_snippet(40));
|
|
|
|
run_frame(&ctx, &mut tab, vec![]); // settle the table's layout
|
|
for y in 40..250 {
|
|
// x lands in the Match column, past Name and Path.
|
|
let pos = egui::pos2(600.0, y as f32);
|
|
let mut out = run_frame(&ctx, &mut tab, vec![egui::Event::PointerMoved(pos)]);
|
|
if tab.hovered_row != Some(0) {
|
|
continue;
|
|
}
|
|
// The tooltip is its own area, so it may land a frame behind.
|
|
for _ in 0..3 {
|
|
let showing = painted_rows(&out)
|
|
.iter()
|
|
.filter(|r| r.contains("NEEDLE"))
|
|
.count();
|
|
if showing >= 2 {
|
|
return;
|
|
}
|
|
out = run_frame(&ctx, &mut tab, vec![]);
|
|
}
|
|
}
|
|
panic!("the match never appeared in the hover tooltip");
|
|
}
|