mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 01:44:25 +00:00
113 lines
4.8 KiB
Rust
113 lines
4.8 KiB
Rust
//! 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::<u32>() += 1;
|
|
*stage.memory_at::<u32>("part") += 10;
|
|
*stage.keep::<u32>() = 5;
|
|
*stage.saved::<u32>(&PLACE) = 6;
|
|
*stage.press_slot::<u32>() = 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::<u32>(), 2);
|
|
assert_eq!(*stage.memory_at::<u32>("part"), 20, "memory_at keeps its own slot");
|
|
assert_eq!(*stage.press_slot::<u32>(), Some(8), "a press entry lives while its press does");
|
|
*stage.press_slot::<u32>() = None;
|
|
stage.finish();
|
|
});
|
|
frames.frame(vec![], |ui| {
|
|
let mut stage = Stage::open(ui.ctx(), id);
|
|
assert_eq!(*stage.press_slot::<u32>(), 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::<u32>(), 0, "the shown entry went with its owner");
|
|
assert_eq!(*stage.memory_at::<u32>("part"), 0, "and the memory_at entry");
|
|
assert_eq!(*stage.keep::<u32>(), 5, "the session entry stayed");
|
|
assert_eq!(*stage.saved::<u32>(&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::<u32>(), 0, "forget removes the session entry");
|
|
assert_eq!(*stage.saved::<u32>(&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::<u32>(&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::<u32>() += 1;
|
|
stage.finish();
|
|
});
|
|
let mut last = 0;
|
|
frames.idle(60, |ui| {
|
|
let mut stage = Stage::open_owned(ui.ctx(), base, container);
|
|
*stage.memory::<u32>() += 10;
|
|
last = *stage.memory::<u32>();
|
|
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::<u32>() += 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::<u32>() += 1;
|
|
stage.finish();
|
|
});
|
|
assert!(records_written(&frames.ctx) >= first + 3, "an owning stage records what it writes in every frame");
|
|
}
|