diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rs index 54130788e1..f4a307cd5c 100644 --- a/crates/doc/src/document.rs +++ b/crates/doc/src/document.rs @@ -752,6 +752,18 @@ impl Document { /// [`Document::locked_artboards`] leaving out artboard `index`. pub fn locked_artboards_except(&self, index: usize) -> LockedArtboards<'_> { + self.locks_except(index, false) + } + + /// [`Document::locked_artboards`] starting with the symbol art boxes earlier hit tests kept + /// ([`Document::kept_symbol_boxes`]). Kept boxes made after it keep its measurements too + /// ([`crate::symbols::KeptBoxes::keeping`]). + pub(crate) fn locked_artboards_kept(&self) -> LockedArtboards<'_> { + self.locks_except(usize::MAX, true) + } + + /// [`Document::locked_artboards_except`], with `kept` measuring with kept art boxes. + fn locks_except(&self, index: usize, kept: bool) -> LockedArtboards<'_> { // Art flush with an edge from outside can overlap it by a rounding error, as in // `art_bounds_on` (#1295). let rects: Vec = @@ -770,7 +782,9 @@ impl Document { if let Some(layer) = self.pattern_edit.as_ref().filter(|_| !rects.is_empty()).and_then(|e| self.layers.iter().find(|l| l.id == e.layer)) { objects(layer, &mut pattern_art); } - LockedArtboards { rects, symbols: self.symbol_boxes(), new_art: self.new_art.get(), pattern_art, held: Default::default() } + // Nothing is measured without a locked artboard. + let symbols = if kept && !rects.is_empty() { self.symbol_boxes_from_kept() } else { self.symbol_boxes() }; + LockedArtboards { rects, symbols, new_art: self.new_art.get(), pattern_art, held: Default::default() } } /// Is `id` on a locked artboard ([`LockedArtboards::holds_id`])? A layer or sublayer is on none. diff --git a/crates/doc/src/hit.rs b/crates/doc/src/hit.rs index ab571e50b2..3b415ef1ed 100644 --- a/crates/doc/src/hit.rs +++ b/crates/doc/src/hit.rs @@ -451,8 +451,9 @@ pub fn hit_test_visible_skipping(doc: &Document, p: Point, opt: HitOptions, skip /// outline, as a click there hits it. pub fn selected_hidden_at(doc: &Document, p: Point, opt: HitOptions, selected: &[NodeId]) -> Option { let _walk = ArtWalk::open(); - let symbols = doc.symbol_boxes(); - let locks = doc.locked_artboards(); + // The locks first: they copy the kept art boxes that `symbols` takes, and `symbols` keeps theirs. + let locks = doc.locked_artboards_kept(); + let symbols = doc.kept_symbol_boxes().keeping(&locks.symbols); selected.iter().rev().copied().find(|&id| { let Some(chain) = doc.ancestry(id) else { return false }; let nodes: Vec<&Node> = chain.iter().filter_map(|a| doc.node(*a)).collect(); @@ -520,7 +521,9 @@ pub fn objects_at(doc: &Document, p: Point, opt: HitOptions, scope: Option Vec { let _walk = ArtWalk::open(); - let symbols = doc.symbol_boxes(); + let symbols = doc.kept_symbol_boxes(); let mut out = Vec::new(); if let Some(scope) = opt.scope && let Some(isolated) = doc.node(scope) @@ -725,7 +727,7 @@ fn hit_test_skipping(doc: &Document, p: Point, opt: HitOptions, skip: &dyn Fn(No h.layers = h.ancestry.iter().take_while(|a| doc.node(**a).is_some_and(Node::is_layer)).count(); h }; - let locks = doc.locked_artboards(); + let locks = doc.locked_artboards_kept(); let on_locked = |id: NodeId| { editable_only && !locks.is_empty() @@ -733,7 +735,8 @@ fn hit_test_skipping(doc: &Document, p: Point, opt: HitOptions, skip: &dyn Fn(No && doc.node(id).is_some_and(|n| locks.holds(n)) }; let skip = &|id| skip(id) || on_locked(id); - let symbols = doc.symbol_boxes(); + // `locks` copies the kept art boxes that `symbols` takes, and `symbols` keeps theirs. + let symbols = doc.kept_symbol_boxes().keeping(&locks.symbols); // Isolation mode: only what is inside the isolated container hits. The art around it is // locked, and clicks pass through it (#833). if editable_only @@ -801,6 +804,12 @@ pub fn set_clip_region(f: ClipRegion) { let _ = CLIP_REGION.set(f); } +/// What the regions of clipping paths with live effects depend on outside the document: the +/// registered [`LiveInputs`] now, and whether a [`ClipRegion`] is registered. +pub(crate) fn clip_region_inputs() -> (u64, bool) { + (live_inputs(), CLIP_REGION.get().is_some()) +} + /// Does `clip`, or anything it holds, have a visible effect of its own or on a fill or stroke? Only /// then can the registered [`ClipRegion`] find a geometry effect in it. fn has_effects(clip: &Node) -> bool { @@ -1620,7 +1629,7 @@ fn moved(n: &Node, xf: vectorcraft_geom::Affine) -> Node { pub fn symbol_part_at(doc: &Document, inst: &Node, p: Point, opt: HitOptions) -> Option> { let _walk = ArtWalk::open(); let art = InstanceArt::of(doc, inst)?; - let symbols = doc.symbol_boxes(); + let symbols = doc.kept_symbol_boxes(); let mut path = vec![]; let outline = opt.outline || below_preview_off(doc, inst, opt.scope); let find = FindPart { art: &art, p, opt, symbols: &symbols, whole_instance: false }; @@ -2042,7 +2051,9 @@ fn previews_off(n: &Node) -> bool { fn marquee_with(doc: &Document, r: Rect, scope: Option, leaves: bool, whole_compounds: bool, outline: bool) -> Vec { let _walk = ArtWalk::open(); let mut out = Vec::new(); - let symbols = doc.symbol_boxes(); + // The locks first: they copy the kept art boxes that `symbols` takes, and `symbols` keeps theirs. + let locks = doc.locked_artboards_kept(); + let symbols = doc.kept_symbol_boxes().keeping(&locks.symbols); // The objects the marquee may touch ([`Top`]). let tops: Vec = match scope.and_then(|s| doc.node(s)) { // Isolated art whose layer, or a group around it, was locked or hidden afterwards: the @@ -2284,7 +2295,6 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option, leaves: bool, wh } } } - let locks = doc.locked_artboards(); for (t, r, outline, edge, drawn) in tops { if !t.visible || t.locked || locks.holds_id(t.id) { continue; diff --git a/crates/doc/src/symbols.rs b/crates/doc/src/symbols.rs index 99a65ae1f7..a1d34e6adb 100644 --- a/crates/doc/src/symbols.rs +++ b/crates/doc/src/symbols.rs @@ -107,6 +107,134 @@ pub struct SymbolBoxes<'a> { consulted: RefCell>>, } +/// What the art boxes and nesting depths of a document's symbols depend on: each symbol's name and +/// art, the symbols' 9-slice guides (which symbols' art holds instances placed through guides), and +/// the inputs of the live geometry effects of clipping paths ([`crate::hit::set_clip_region`]). +/// Symbol sizes only move art placed through guides, which is measured on each call. Each symbol's +/// art is held by a weak pointer. While a weak pointer to an art's allocation is held, nothing else +/// can be at that address, and the art can't be changed in place (`Arc::make_mut` moves it), so art +/// changed in any way no longer matches, as in the cache of `Document::inline_cycles`. +struct KeptKey { + symbols: Vec<(String, std::sync::Weak)>, + guides: Option, + inputs: (u64, bool), +} + +impl KeptKey { + /// The key of the document's 9-slice guides. + const GUIDES: &str = crate::symbol_nine_slice::SYMBOL_NINE_SLICE; + + fn of(doc: &Document, inputs: (u64, bool)) -> Self { + KeptKey { + symbols: doc.symbols.iter().map(|s| (s.name.clone(), Arc::downgrade(&s.art))).collect(), + guides: doc.unknown.get(Self::GUIDES).cloned(), + inputs, + } + } + + /// Does this describe `doc`'s symbols as they are now, with inputs `inputs`? + fn is_of(&self, doc: &Document, inputs: (u64, bool)) -> bool { + self.inputs == inputs + && self.symbols.len() == doc.symbols.len() + && self.symbols.iter().zip(&doc.symbols).all(|((name, art), s)| std::ptr::eq(art.as_ptr(), Arc::as_ptr(&s.art)) && *name == s.name) + && self.guides.as_ref() == doc.unknown.get(Self::GUIDES) + } + + fn same(&self, other: &KeptKey) -> bool { + self.inputs == other.inputs + && self.symbols.len() == other.symbols.len() + && self.symbols.iter().zip(&other.symbols).all(|((n, a), (m, b))| a.ptr_eq(b) && n == m) + && self.guides == other.guides + } +} + +/// Art boxes, nesting depths and the name index measured by boxes made by +/// [`Document::kept_symbol_boxes`], kept for the next ones made for the same symbols. +struct Kept { + key: KeptKey, + names: Option>, + measured: HashMap>, + depths: HashMap>, +} + +/// How many sets of symbols [`Document::kept_symbol_boxes`] keeps measurements for on each thread: +/// clicks can alternate between two open documents. +const KEPT_SETS: usize = 2; + +thread_local! { + /// The measurements [`Document::kept_symbol_boxes`] keeps, the latest first. + static KEPT: RefCell> = const { RefCell::new(Vec::new()) }; +} + +/// [`SymbolBoxes`] made by [`Document::kept_symbol_boxes`], which keep their measurements for the +/// next ones when dropped. +pub(crate) struct KeptBoxes<'a> { + boxes: SymbolBoxes<'a>, + /// What the measurements depend on, under which they are kept. + key: Option, + /// Other boxes of the same document whose measurements are kept with these + /// ([`Self::keeping`]). + also: Option<&'a SymbolBoxes<'a>>, +} + +impl<'a> std::ops::Deref for KeptBoxes<'a> { + type Target = SymbolBoxes<'a>; + + fn deref(&self) -> &SymbolBoxes<'a> { + &self.boxes + } +} + +impl<'a> KeptBoxes<'a> { + /// These boxes, which also keep the art boxes and nesting depths `other` has measured when + /// dropped. `other` measures the same document, as the boxes of + /// [`Document::locked_artboards_kept`] do. + pub(crate) fn keeping(mut self, other: &'a SymbolBoxes<'a>) -> Self { + self.also = Some(other); + self + } +} + +impl Drop for KeptBoxes<'_> { + /// Keeps the measurements, adding them to those kept for the same symbols by other boxes alive + /// at the same time. Art boxes of symbols whose art holds instances of symbols with 9-slice + /// guides are left out: measuring them places art within a budget the boxes share + /// ([`SymbolBoxes::sliced_visual`]). + fn drop(&mut self) { + let Some(key) = self.key.take() else { return }; + let b = &self.boxes; + let mut measured = b.measured.take(); + let mut depths = b.depths.take(); + if let Some(other) = self.also { + for (name, a) in other.measured.borrow().iter() { + measured.entry(name.clone()).or_insert(*a); + } + for (name, d) in other.depths.borrow().iter() { + depths.entry(name.clone()).or_insert(*d); + } + } + measured.retain(|_, a| a.is_none_or(|a| !a.sliced)); + let mut kept = Kept { key, names: b.names.get().cloned(), measured, depths }; + // Nothing is kept while the thread ends or the list is in use. + let _ = KEPT.try_with(|k| { + if let Ok(mut k) = k.try_borrow_mut() { + if let Some(i) = k.iter().position(|e| e.key.same(&kept.key)) { + let other = k.remove(i); + kept.names = kept.names.or(other.names); + for (name, a) in other.measured { + kept.measured.entry(name).or_insert(a); + } + for (name, d) in other.depths { + kept.depths.entry(name).or_insert(d); + } + } + k.insert(0, kept); + k.truncate(KEPT_SETS); + } + }); + } +} + impl Document { /// [`SymbolBoxes`] for this document's symbols, none measured yet. pub fn symbol_boxes(&self) -> SymbolBoxes<'_> { @@ -131,6 +259,56 @@ impl Document { } } + /// [`Self::symbol_boxes`] that start with the art boxes, nesting depths and name index measured + /// by the last such boxes made on this thread for the same symbols, and keep theirs for the next + /// ones when dropped. The measurements are made again when a symbol's name or art, the symbols' + /// 9-slice guides, or the inputs of the live geometry effects of clipping paths have + /// changed since. Measurements for the last [`KEPT_SETS`] sets of symbols are kept. + pub(crate) fn kept_symbol_boxes(&self) -> KeptBoxes<'_> { + self.kept_boxes(false) + } + + /// [`Self::symbol_boxes`] that start with a copy of the measurements + /// [`Self::kept_symbol_boxes`] would start with, and keep nothing themselves. + pub(crate) fn symbol_boxes_from_kept(&self) -> SymbolBoxes<'_> { + let mut kept = self.kept_boxes(true); + kept.key = None; + std::mem::replace(&mut kept.boxes, self.symbol_boxes()) + } + + /// [`Self::kept_symbol_boxes`], taking the kept measurements, or with `copy` copying them. + fn kept_boxes(&self, copy: bool) -> KeptBoxes<'_> { + let mut boxes = self.symbol_boxes(); + let inputs = crate::hit::clip_region_inputs(); + let found = KEPT + .try_with(|k| { + let mut k = k.try_borrow_mut().ok()?; + let i = k.iter().position(|e| e.key.is_of(self, inputs))?; + if copy { + let e = k.get(i)?; + let key = KeptKey { symbols: e.key.symbols.clone(), guides: e.key.guides.clone(), inputs }; + Some(Kept { key, names: e.names.clone(), measured: e.measured.clone(), depths: e.depths.clone() }) + } else { + Some(k.remove(i)) + } + }) + .ok() + .flatten(); + let key = match found { + Some(e) => { + if let Some(names) = e.names { + // The boxes were just made, so no index is set yet. + let _ = boxes.names.set(names); + } + *boxes.measured.get_mut() = e.measured; + *boxes.depths.get_mut() = e.depths; + e.key + } + None => KeptKey::of(self, inputs), + }; + KeptBoxes { boxes, key: Some(key), also: None } + } + /// Each symbol name of this document → the index of the first symbol of that name (the one a /// name finds). pub(crate) fn symbol_names(&self) -> SymbolNames { @@ -148,6 +326,8 @@ impl Document { thread_local! { /// How many symbols [`Document::symbol_names`] has read on this thread. pub(crate) static SYMBOLS_READ: Cell = const { Cell::new(0) }; + /// How many art boxes [`SymbolBoxes::art`] has measured on this thread. + static ART_BOXES_MEASURED: Cell = const { Cell::new(0) }; } impl<'a> SymbolBoxes<'a> { @@ -218,6 +398,8 @@ impl<'a> SymbolBoxes<'a> { pub(crate) fn art(&self, name: &str) -> Option { let cached = self.measured.borrow().get(name).copied(); let b = cached.unwrap_or_else(|| { + #[cfg(test)] + ART_BOXES_MEASURED.with(|c| c.set(c.get() + 1)); let b = self.measure_art(name, |art| self.in_art(|| art_box(art, self))).flatten(); self.measured.borrow_mut().insert(name.to_string(), b); b @@ -584,10 +766,10 @@ fn art_box(art: &Arc, symbols: &SymbolBoxes) -> Option { #[cfg(test)] mod tests { use vectorcraft_color::{Color, Paint}; - use vectorcraft_geom::shapes; + use vectorcraft_geom::{Point, shapes}; use super::*; - use crate::{Appearance, Symbol}; + use crate::{Appearance, NodeId, Symbol}; /// A rectangle filled black, with a `stroke` pt black stroke (0: none). fn rect(d: &mut Document, r: Rect, stroke: f64) -> Node { @@ -911,4 +1093,192 @@ mod tests { assert_eq!(s.effects_reach("Leaf", [2.0, 0.0, 0.0, 2.0], &measure(7.0)), 7.0); assert_eq!(runs.get(), MAX_REACHES + 2); } + + /// How many art boxes `f` measures on this thread. + fn art_boxes_measured(f: impl FnOnce()) -> usize { + let before = ART_BOXES_MEASURED.with(Cell::get); + f(); + ART_BOXES_MEASURED.with(Cell::get) - before + } + + /// A document with symbols "S 0" to "S 9", each a 10 × 10 square around the origin, and an + /// instance of each at (40 i + 20, 20). + fn ten_symbols() -> Document { + let mut d = Document::new(400.0, 100.0); + let layer = d.layers.first().map(|l| l.id); + for i in 0..10 { + let square = rect(&mut d, Rect::new(-5.0, -5.0, 5.0, 5.0), 0.0); + symbol(&mut d, &format!("S {i}"), vec![square]); + let at = instance(&mut d, &format!("S {i}"), Affine::translate((40.0 * f64::from(i) + 20.0, 20.0))); + d.insert(layer, usize::MAX, at).unwrap(); + } + d + } + + #[test] + fn hit_tests_measure_each_symbols_art_once_while_the_symbols_stay_the_same() { + use crate::hit::{self, HitOptions}; + let d = ten_symbols(); + let clicks = || { + for i in 0..10 { + let p = Point::new(40.0 * f64::from(i) + 20.0, 20.0); + assert!(hit::hit_test(&d, p, HitOptions::default()).is_some(), "instance {i} is hit"); + assert_eq!(hit::objects_at(&d, p, HitOptions::default(), None).len(), 1); + } + assert_eq!(hit::marquee(&d, Rect::new(0.0, 0.0, 400.0, 100.0), None, false).len(), 10); + }; + let first = art_boxes_measured(clicks); + assert_eq!(first, 10, "each symbol's art box measured once"); + assert_eq!(art_boxes_measured(clicks), 0, "art boxes measured again"); + } + + #[test] + fn hit_tests_measure_a_symbol_again_after_it_changes() { + use crate::hit::{self, HitOptions}; + let mut d = ten_symbols(); + // Past the square of "S 1" at (60, 20). + let past = Point::new(71.0, 20.0); + assert!(hit::hit_test(&d, past, HitOptions::default()).is_none()); + // The art grows 3 times in place: no other copy of it is held in the document. + Arc::make_mut(&mut d.symbols[1].art).transform(Affine::scale(3.0), false); + let measured = art_boxes_measured(|| assert!(hit::hit_test(&d, past, HitOptions::default()).is_some(), "the grown art is hit")); + assert!(measured > 0); + // New art for "S 2", 40 wide. + let wide = rect(&mut d, Rect::new(-20.0, -5.0, 20.0, 5.0), 0.0); + d.symbols[2].art = Arc::new(wide); + assert!(hit::hit_test(&d, Point::new(115.0, 20.0), HitOptions::default()).is_some(), "the new art is hit"); + // "S 3" renamed: its instance now shows the 20 × 20 square. + d.symbols[3].name = "Renamed".into(); + assert!(hit::hit_test(&d, Point::new(148.0, 28.0), HitOptions::default()).is_some(), "the square is hit"); + assert_eq!(hits(&d), fresh_hits(&d)); + } + + /// What clicks on a grid over `d` hit, and what a marquee over it selects. + fn hits(d: &Document) -> (Vec>>, Vec) { + use crate::hit::{self, HitOptions}; + let mut clicks = Vec::new(); + for y in (0..400).step_by(5) { + for x in (0..400).step_by(5) { + let p = Point::new(f64::from(x), f64::from(y)); + clicks.push(hit::hit_test(d, p, HitOptions::default()).map(|h| h.ancestry)); + } + } + (clicks, hit::marquee(d, Rect::new(0.0, 0.0, 400.0, 400.0), None, false)) + } + + /// [`hits`] with no measurements kept from earlier hit tests. + fn fresh_hits(d: &Document) -> (Vec>>, Vec) { + KEPT.with_borrow_mut(Vec::clear); + hits(d) + } + + /// A bar in a panel with or without 9-slice guides, in a holder whose instance at (50, 50) is + /// scaled 2 times across. With the guides, the bar draws from x 30 to 210 and y 90 to 110; without + /// them, from x 70 to 190, inside the panel's frame from x 50 to 250 and y 50 to 150. + fn sliced_holder(guides: bool) -> Document { + let mut d = Document::new(400.0, 400.0); + let bar = rect(&mut d, Rect::new(10.0, 40.0, 70.0, 60.0), 0.0); + symbol(&mut d, "Bar", vec![bar]); + let frame = rect(&mut d, Rect::new(0.0, 0.0, 100.0, 100.0), 0.0); + let inner = instance(&mut d, "Bar", Affine::IDENTITY); + symbol(&mut d, "Panel", vec![frame, inner]); + if guides { + d.set_symbol_nine_slice("Panel", Some(crate::SymbolNineSlice::default())); + } + let panel = instance(&mut d, "Panel", Affine::IDENTITY); + symbol(&mut d, "Holder", vec![panel]); + let layer = d.layers.first().map(|l| l.id); + let holder = instance(&mut d, "Holder", Affine::translate((50.0, 50.0)) * Affine::scale_non_uniform(2.0, 1.0)); + d.insert(layer, usize::MAX, holder).unwrap(); + d + } + + #[test] + fn hit_tests_follow_new_9_slice_guides_and_symbol_sizes() { + use crate::hit::{self, HitOptions}; + let mut d = sliced_holder(false); + // Left of the frame, where only the bar placed through the guides draws. + let left = Point::new(40.0, 100.0); + assert!(hit::hit_test(&d, left, HitOptions::default()).is_none()); + d.set_symbol_nine_slice("Panel", Some(crate::SymbolNineSlice::default())); + assert!(hit::hit_test(&d, left, HitOptions::default()).is_some(), "the bar placed through the guides is hit"); + assert_eq!(hits(&d), fresh_hits(&d)); + let before = hits(&d); + d.unknown.insert(crate::SYMBOL_SIZES.into(), serde_json::json!({ "Panel": [200.0, 100.0] })); + let after = hits(&d); + assert_ne!(after, before, "the size moves the guides"); + assert_eq!(after, fresh_hits(&d)); + } + + #[test] + fn hit_tests_measure_symbols_holding_9_slice_instances_on_each_call() { + use crate::hit::{self, HitOptions}; + let d = sliced_holder(true); + let left = Point::new(40.0, 100.0); + assert!(hit::hit_test(&d, left, HitOptions::default()).is_some()); + // The holder's art holds an instance of a symbol with guides; the panel's art holds none. + KEPT.with_borrow(|k| { + let measured = &k[0].measured; + assert!(measured.contains_key("Panel") && !measured.contains_key("Holder"), "{:?}", measured.keys()); + }); + let again = art_boxes_measured(|| assert!(hit::hit_test(&d, left, HitOptions::default()).is_some())); + assert!(again > 0, "the holder's art box measured again"); + } + + #[test] + fn kept_measurements_depend_on_the_inputs_of_clipping_path_effects() { + let d = ten_symbols(); + let key = KeptKey::of(&d, (0, false)); + assert!(key.is_of(&d, (0, false))); + assert!(!key.is_of(&d, (1, false)), "live inputs changed"); + assert!(!key.is_of(&d, (0, true)), "a clip region registered"); + } + + #[test] + fn hit_tests_with_a_locked_artboard_measure_each_symbols_art_once() { + use crate::hit::{self, HitOptions}; + let mut d = ten_symbols(); + d.artboards[0].locked = true; + let clicks = || { + for i in 0..10 { + let p = Point::new(40.0 * f64::from(i) + 20.0, 20.0); + assert!(hit::hit_test(&d, p, HitOptions::default()).is_none(), "instance {i} is on the locked artboard"); + assert!(hit::objects_at(&d, p, HitOptions::default(), None).is_empty()); + } + }; + assert!(art_boxes_measured(clicks) >= 10, "each symbol's art box measured"); + assert_eq!(art_boxes_measured(clicks), 0, "art boxes measured again"); + // A marquee passes over the objects on a locked artboard without measuring them itself: only + // its locks measure their art. + let mut d = ten_symbols(); + d.artboards[0].locked = true; + let marquee = || assert!(hit::marquee(&d, Rect::new(0.0, 0.0, 400.0, 100.0), None, false).is_empty()); + assert_eq!(art_boxes_measured(marquee), 10, "each symbol's art box measured once"); + assert_eq!(art_boxes_measured(marquee), 0, "art boxes measured again"); + } + + #[test] + fn hit_tests_hold_no_symbol_art() { + use crate::hit::{self, HitOptions}; + let d = ten_symbols(); + drop(hit::hit_test(&d, Point::new(20.0, 20.0), HitOptions::default())); + assert!(KEPT.with_borrow(|k| !k.is_empty())); + assert!(d.symbols.iter().all(|s| Arc::strong_count(&s.art) == 1), "only the document holds the symbols' art"); + } + + #[test] + fn hit_tests_keep_the_measurements_of_two_sets_of_symbols() { + use crate::hit::{self, HitOptions}; + let docs = [ten_symbols(), ten_symbols(), ten_symbols()]; + let p = Point::new(20.0, 20.0); + for d in &docs { + drop(hit::hit_test(d, p, HitOptions::default())); + } + assert_eq!(KEPT.with_borrow(Vec::len), KEPT_SETS); + // The last two are kept, the first is measured again. + let kept = art_boxes_measured(|| docs[1..].iter().for_each(|d| drop(hit::hit_test(d, p, HitOptions::default())))); + assert_eq!(kept, 0); + let first = art_boxes_measured(|| drop(hit::hit_test(&docs[0], p, HitOptions::default()))); + assert!(first > 0); + } }