//! Memory lifetimes, eviction by owner and the runtime sub-id derivation. use craft_ui::runtime::memory::{Remember, SaveKey}; use craft_ui::testing::memory::{Stage, dispose_evicted, forget, forget_saved, global, records_written}; use craft_ui::testing::{Frames, trial}; const PLACE: SaveKey = SaveKey::new("craft_tests.place"); /// The lifetimes of 7.2, through `Remember`: shown entries go with their owner; session and saved ones only /// through `forget` and `forget_saved`; a press entry goes when its press ends. #[trial] fn lifetimes_follow_their_owner_until_forgotten() { let mut frames = Frames::new(); let id = global("owner", ()); let mut appeared = Vec::new(); for _ in 0..2 { frames.frame(vec![], |ui| { let mut stage = Stage::open(ui.ctx(), id); appeared.push(stage.appeared()); *stage.memory::() += 1; *stage.memory_at::("part") += 10; *stage.keep::() = 5; *stage.saved::(&PLACE) = 6; *stage.press_slot::() = Some(8); stage.finish(); }); } assert_eq!(appeared, vec![true, false], "appeared is true on the first pass only"); frames.frame(vec![], |ui| { let mut stage = Stage::open(ui.ctx(), id); assert_eq!(*stage.memory::(), 2); assert_eq!(*stage.memory_at::("part"), 20, "memory_at keeps its own slot"); assert_eq!(*stage.press_slot::(), Some(8), "a press entry lives while its press does"); *stage.press_slot::() = None; stage.finish(); }); frames.frame(vec![], |ui| { let mut stage = Stage::open(ui.ctx(), id); assert_eq!(*stage.press_slot::(), None, "an ended press leaves no entry"); stage.finish(); }); frames.idle(60, |_| {}); dispose_evicted(&frames.ctx); frames.frame(vec![], |ui| { let mut stage = Stage::open(ui.ctx(), id); assert!(stage.appeared(), "a re-shown component appears again"); assert_eq!(*stage.memory::(), 0, "the shown entry went with its owner"); assert_eq!(*stage.memory_at::("part"), 0, "and the memory_at entry"); assert_eq!(*stage.keep::(), 5, "the session entry stayed"); assert_eq!(*stage.saved::(&PLACE), 6, "the saved entry stayed"); stage.finish(); }); forget(&frames.ctx, id); frames.frame(vec![], |ui| { let mut stage = Stage::open(ui.ctx(), id); assert_eq!(*stage.keep::(), 0, "forget removes the session entry"); assert_eq!(*stage.saved::(&PLACE), 6, "and not the saved one"); stage.finish(); }); forget_saved(&frames.ctx, &PLACE); frames.frame(vec![], |ui| { let mut stage = Stage::open(ui.ctx(), id); assert_eq!(*stage.saved::(&PLACE), 0, "forget_saved removes the saved entry written through Remember::saved"); stage.finish(); }); } /// A slot that a stage owned by another component writes back goes with that owner: a popup body's or a /// settled body's slots stay while their container is shown, even after the component that made them stops. #[trial] fn a_slot_written_by_an_owning_stage_goes_with_that_owner() { let mut frames = Frames::new(); let (base, container) = (global("made_by", ()), global("kept_by", ())); frames.frame(vec![], |ui| { let mut stage = Stage::open(ui.ctx(), base); *stage.memory::() += 1; stage.finish(); }); let mut last = 0; frames.idle(60, |ui| { let mut stage = Stage::open_owned(ui.ctx(), base, container); *stage.memory::() += 10; last = *stage.memory::(); stage.finish(); }); dispose_evicted(&frames.ctx); assert_eq!(last % 10, 1, "the slot its maker wrote stayed with the container that keeps showing it"); } /// Write-back records a slot once: a stage that keeps writing the same slots records nothing after its first /// frame, and a stage owned by another component than its base records what it writes every frame. #[trial] fn a_settled_stage_records_no_slot_again() { let mut frames = Frames::new(); let (base, container) = (global("settled", ()), global("settled_owner", ())); let show = |ui: &mut egui::Ui| { let mut stage = Stage::open(ui.ctx(), base); *stage.memory::() += 1; stage.finish(); }; frames.frame(vec![], show); let first = records_written(&frames.ctx); assert!(first > 0, "the first frame records the slot and its seen mark"); frames.idle(3, show); assert_eq!(records_written(&frames.ctx), first, "settled frames record nothing"); frames.idle(3, |ui| { let mut stage = Stage::open_owned(ui.ctx(), base, container); *stage.memory::() += 1; stage.finish(); }); assert!(records_written(&frames.ctx) >= first + 3, "an owning stage records what it writes in every frame"); }