EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
refactor(ui-egui): move lifecycle_tests to lifecycle_tests.rs
aionggda99df18b4f2
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 8e9c69fbf..faf6d0fff 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -2999,519 +2999,4 @@ mod appearance_tests {}#[cfg(test)]-mod lifecycle_tests {- //! The logic-only / UI-pass split: queue work in `tick`, input, layout and setup in `draw`.- //!- //! The driver mirrors eframe's order for a hidden window: `raw_input_hook` prepares the raw- //! input, a logic-only iteration runs `tick`, and a forced pass runs `draw` with the same- //! prepared input. Nothing may depend on `current_pass_index`, which is zero in both.-- use super::*;- use effectcraft_engine::config::{ConfigStore, MemoryConfig};-- fn app_with_comp() -> EffectcraftApp {- let mut session = Session::default();- session.execute("comp.new", json!({"name": "Lifecycle", "width": 64, "height": 36, "duration": 1})).unwrap();- session.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();- let mut app = EffectcraftApp::new(session);- app.ui.start_screen = false;- app.ui.show_menu_bar = false;- app.use_manual_clock();- app- }-- fn raw(size: egui::Vec2) -> egui::RawInput {- egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)), ..Default::default() }- }-- fn tick_with(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, raw: &egui::RawInput) -> egui::LogicOutput {- ctx.run_logic(raw, |ctx| app.tick(ctx, frame))- }-- fn hidden_tick(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame) {- let _ = tick_with(app, ctx, frame, &raw(egui::vec2(800.0, 480.0)));- }-- /// One host iteration that ends in a UI pass (the forced hidden pass, or a visible frame).- fn pass(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, raw: &mut egui::RawInput) -> egui::FullOutput {- eframe::App::raw_input_hook(app, ctx, raw);- let mut out = ctx.run_ui(raw.take(), |ui| app.draw(ui, frame));- out.textures_delta.clear();- out- }-- fn ready(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame) -> DrawGeometry {- // The first pass installs the fonts, the second draws with them.- for _ in 0..3 {- let mut raw = raw(egui::vec2(800.0, 480.0));- pass(app, ctx, frame, &mut raw);- }- assert!(app.is_ready(), "fonts are ready after the warm-up passes");- app.draw_geometry().expect("a completed pass records its geometry")- }-- fn send(app: &mut EffectcraftApp, method: &str, params: serde_json::Value) -> std::sync::mpsc::Receiver<serde_json::Value> {- let (request, reply) = ControlRequest::new(method, params);- let (tx, rx) = std::sync::mpsc::channel();- tx.send(request).unwrap();- app.control_rx = Some(rx);- reply- }-- #[test]- fn a_logic_only_tick_installs_no_fonts_and_records_no_geometry() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- hidden_tick(&mut app, &ctx, &frame);- assert!(!app.is_ready(), "fonts need a real pass, not a logic-only tick");- assert!(app.draw_geometry().is_none(), "a logic-only tick is not a frame");- assert_eq!(app.ui_passes(), 0);- }-- #[test]- fn a_control_command_that_needs_no_ui_completes_without_a_pass() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- let reply = send(&mut app, "engine.execute", json!({"command": "comp.new", "params": {"name": "Queued", "width": 32, "height": 18, "duration": 1}}));- hidden_tick(&mut app, &ctx, &frame);- let value = reply.try_recv().expect("a command that needs no UI is answered by the tick");- assert_eq!(value["ok"], true, "{value}");- assert_eq!(app.ui_passes(), 0);- }-- #[test]- fn a_pass_that_cannot_draw_receives_no_synthetic_input() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- assert!(!app.is_ready(), "a fresh app installs its fonts in its first pass");- let reply = send(&mut app, "ui.click", json!({"x": 40, "y": 40}));- hidden_tick(&mut app, &ctx, &frame);- assert!(reply.try_recv().is_err(), "a click is not answered before its UI pass");- // The font-install pass cannot draw. It must not receive the click: `run_ui` applies what- // the hook feeds, and a batch cannot be put back without applying its pointer state twice.- let mut setup = raw(egui::vec2(800.0, 480.0));- eframe::App::raw_input_hook(&mut app, &ctx, &mut setup);- assert!(setup.events.is_empty(), "a pass that cannot draw gets no synthetic input");- assert_eq!(app.synthetic.len(), 5, "the whole gesture still waits for a drawing pass");- assert!(app.pending_synthetic_events().is_empty());- let mut setup_pass = ctx.run_ui(setup.take(), |ui| app.draw(ui, &frame));- setup_pass.textures_delta.clear();- assert!(!app.is_ready(), "the pass that installs the fonts draws nothing");- // Once fonts are ready the click reaches the UI exactly once, one event per pass.- let mut passes = 0;- while reply.try_recv().is_err() {- passes += 1;- assert!(passes < 40, "the click must be applied within a few passes");- let mut raw = raw(egui::vec2(800.0, 480.0));- pass(&mut app, &ctx, &frame, &mut raw);- }- assert!(reply.try_recv().is_err(), "the reply is sent once");- assert!(app.pending_synthetic_events().is_empty());- assert!(app.synthetic.is_empty(), "every event was applied once");- }-- #[test]- fn one_pending_synthetic_batch_is_never_duplicated_while_hidden() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- ready(&mut app, &ctx, &frame);- let reply = send(&mut app, "ui.click", json!({"x": 40, "y": 40}));- hidden_tick(&mut app, &ctx, &frame);- assert!(reply.try_recv().is_err(), "a click is not answered before its UI pass");- // Several hidden host iterations: eframe keeps the first prepared input; only its one- // event may reach the raw input, and a later hook must not add another.- let mut first = raw(egui::vec2(800.0, 480.0));- eframe::App::raw_input_hook(&mut app, &ctx, &mut first);- assert_eq!(first.events.len(), 1, "the first event of the gesture is fed");- let mut second = raw(egui::vec2(800.0, 480.0));- eframe::App::raw_input_hook(&mut app, &ctx, &mut second);- assert!(second.events.is_empty(), "an unapplied batch blocks the next event");- assert_eq!(app.pending_synthetic_events().len(), 1);- // The pass that applies the batch acknowledges it once; it is never fed again.- pass(&mut app, &ctx, &frame, &mut first);- assert!(app.pending_synthetic_events().is_empty());- // Drive real passes until the gesture is applied: exactly one reply, no lost events.- let mut passes = 0;- while reply.try_recv().is_err() {- passes += 1;- assert!(passes < 40, "the click must be applied within a few passes");- let mut raw = raw(egui::vec2(800.0, 480.0));- pass(&mut app, &ctx, &frame, &mut raw);- }- assert!(app.pending_synthetic_events().is_empty());- assert!(app.synthetic.is_empty());- assert!(reply.try_recv().is_err(), "the reply is sent once");- }-- #[test]- fn geometry_epoch_tracks_size_and_scale_but_not_window_position() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- let first = ready(&mut app, &ctx, &frame);- let mut moved = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::pos2(120.0, 80.0), first.rect.size())), ..Default::default() };- pass(&mut app, &ctx, &frame, &mut moved);- assert_eq!(app.draw_geometry().unwrap().epoch, first.epoch, "moving the window does not change a capture");- let mut resized = raw(egui::vec2(1024.0, 640.0));- pass(&mut app, &ctx, &frame, &mut resized);- let after_resize = app.draw_geometry().unwrap();- assert!(after_resize.epoch > first.epoch, "a resize advances the epoch");- let mut back = raw(egui::vec2(800.0, 480.0));- pass(&mut app, &ctx, &frame, &mut back);- assert!(app.draw_geometry().unwrap().epoch > after_resize.epoch, "changing back is another change, not the old epoch");- }-- #[test]- fn only_a_viewer_that_draws_records_a_prefetch_scale() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- ready(&mut app, &ctx, &frame);- assert!(app.last_viewer_scale.is_some(), "the visible viewer recorded the scale it drew at");- // The Home screen draws no viewer: the old comp's scale must not keep idle prefetch alive.- app.ui.start_screen = true;- let mut input = raw(egui::vec2(800.0, 480.0));- pass(&mut app, &ctx, &frame, &mut input);- assert!(app.last_viewer_scale.is_none(), "no viewer drew, so there is no scale to prefetch at");- // Back to the comp: the next pass records it again.- app.ui.start_screen = false;- let mut input = raw(egui::vec2(800.0, 480.0));- pass(&mut app, &ctx, &frame, &mut input);- assert!(app.last_viewer_scale.is_some());- }-- #[test]- fn playback_advances_on_a_logic_only_tick() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- app.playback.playing = true;- app.playback.plan = Some(effectcraft_engine::preview::PreviewPlan {- start: 1,- end: 1,- first: 1,- step: 1,- fps: 24.0,- looping: false,- cache_first: false,- video: false,- audio: false,- origin: Tick::ZERO,- });- app.playback.start_wall = 0.0;- app.playback.start_frame = 1;- app.clock_mut().advance(1.0);- hidden_tick(&mut app, &ctx, &frame);- assert!(!app.playback.playing, "a one-frame preview ends without any UI pass");- assert_eq!(app.playback.audio_frame, Some(1), "the audio-only playhead reached the plan's end");- assert_eq!(app.ui_passes(), 0);- }-- #[test]- fn workspace_layout_autosave_writes_on_a_hidden_tick() {- let store = Arc::new(MemoryConfig::default());- let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });- app.ui.start_screen = false;- app.use_manual_clock();- app.ui.focused = PanelKind::Timeline;- app.clock_mut().advance(2.0);- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- hidden_tick(&mut app, &ctx, &frame);- assert!(store.read(WORKSPACES_FILE).is_some(), "the layout is saved while the window is hidden");- assert_eq!(app.ui_passes(), 0);- }-- #[test]- fn the_close_guard_answers_a_close_request_without_a_pass() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- assert!(app.session.is_dirty(), "creating a comp and a layer leaves unsaved changes");- let mut raw = raw(egui::vec2(800.0, 480.0));- raw.viewports.insert(egui::ViewportId::ROOT, egui::ViewportInfo { events: vec![egui::ViewportEvent::Close], ..Default::default() });- let out = tick_with(&mut app, &ctx, &frame, &raw);- assert!(app.dialog.is_some(), "a hidden close request opens the unsaved-changes prompt");- let cancel = out.viewport_commands.values().flatten().any(|c| matches!(c, egui::ViewportCommand::CancelClose));- assert!(cancel, "the window stays open while the prompt is asking");- assert_eq!(app.ui_passes(), 0);- }-- // ---------------------------------------------------------------- screenshots-- fn screenshot_request(- app: &mut EffectcraftApp,- ctx: &egui::Context,- path: Option<&str>,- target: ShotTarget,- ) -> std::sync::mpsc::Receiver<serde_json::Value> {- let (tx, rx) = std::sync::mpsc::channel();- app.admit_screenshot(ctx, path.map(str::to_string), target, tx);- rx- }-- fn shot_callbacks(out: &egui::LogicOutput) -> Vec<egui::ScreenshotCallback> {- out.viewport_commands- .values()- .flatten()- .filter_map(|c| match c {- egui::ViewportCommand::Screenshot(cb) => Some(cb.clone()),- _ => None,- })- .collect()- }-- /// Three settled passes and the settle delay, then the tick that issues the capture.- fn issue_shot(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame) -> egui::ScreenshotCallback {- issue_shot_at(app, ctx, frame, egui::vec2(800.0, 480.0))- }-- fn issue_shot_at(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, size: egui::Vec2) -> egui::ScreenshotCallback {- for _ in 0..SCREENSHOT_SETTLE_PASSES {- let mut raw = raw(size);- pass(app, ctx, frame, &mut raw);- }- app.clock_mut().advance(SCREENSHOT_SETTLE_S + 0.01);- let out = tick_with(app, ctx, frame, &raw(size));- let cbs = shot_callbacks(&out);- assert_eq!(cbs.len(), 1, "one settled screenshot is issued once");- cbs.into_iter().next().unwrap()- }-- fn image(width: usize, height: usize) -> Arc<egui::ColorImage> {- Arc::new(egui::ColorImage::new([width, height], vec![egui::Color32::from_rgb(10, 20, 30); width.checked_mul(height).unwrap()]))- }-- #[test]- fn a_screenshot_is_issued_only_after_settled_passes_and_writes_from_the_tick() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- ready(&mut app, &ctx, &frame);- let path = std::env::temp_dir().join(format!("effectcraft-shot-{}-ok.png", std::process::id()));- let _ = std::fs::remove_file(&path);- let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Window);- // Not settled: a tick issues nothing and asks for passes instead.- let out = tick_with(&mut app, &ctx, &frame, &raw(egui::vec2(800.0, 480.0)));- assert!(shot_callbacks(&out).is_empty(), "no capture before the UI settles");- assert_eq!(out.viewport_commands.values().flatten().filter(|c| matches!(c, egui::ViewportCommand::RequestPaintWhileHidden)).count(), 1);- let cb = issue_shot(&mut app, &ctx, &frame);- assert!(reply.try_recv().is_err(), "the callback must not write or reply itself");- cb.complete(image(800, 480));- hidden_tick(&mut app, &ctx, &frame);- let value = reply.try_recv().expect("the tick drains the completed slot and replies");- assert_eq!(value["ok"], true, "{value}");- assert!(path.exists(), "{value}");- assert_eq!(value["result"]["width"], 800);- assert_eq!(value["result"]["height"], 480);- assert_eq!(app.shot_bytes, 0, "the reservation is released");- let _ = std::fs::remove_file(&path);- }-- #[test]- fn a_resize_between_issue_and_completion_rejects_the_pixels_and_retries() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- ready(&mut app, &ctx, &frame);- let path = std::env::temp_dir().join(format!("effectcraft-shot-{}-retry.png", std::process::id()));- let _ = std::fs::remove_file(&path);- let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Window);- let first = issue_shot(&mut app, &ctx, &frame);- let size = egui::vec2(1024.0, 640.0);- let mut resized = raw(size);- pass(&mut app, &ctx, &frame, &mut resized);- first.complete(image(800, 480));- let _ = tick_with(&mut app, &ctx, &frame, &raw(size));- assert!(reply.try_recv().is_err(), "pixels from the old surface epoch are discarded");- assert!(!path.exists(), "a stale image is never written");- // The retry is issued against the new geometry and the new image is accepted.- let second = issue_shot_at(&mut app, &ctx, &frame, size);- second.complete(image(1024, 640));- let _ = tick_with(&mut app, &ctx, &frame, &raw(size));- let value = reply.try_recv().expect("the retried capture replies");- assert_eq!(value["ok"], true, "{value}");- assert_eq!(value["result"]["width"], 1024);- let _ = std::fs::remove_file(&path);- }-- #[test]- fn screenshot_admission_bounds_requests_and_a_timeout_releases_its_reservation() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- ready(&mut app, &ctx, &frame);- let mut replies = Vec::new();- for _ in 0..MAX_PENDING_SHOTS {- replies.push(screenshot_request(&mut app, &ctx, None, ShotTarget::Rect([0.0, 0.0, 4.0, 4.0])));- }- let refused = screenshot_request(&mut app, &ctx, None, ShotTarget::Rect([0.0, 0.0, 4.0, 4.0]));- let value = refused.try_recv().expect("the fifth request is refused immediately");- assert_eq!(value["ok"], false, "{value}");- // Every queued request times out on a hidden window that presents no frame; each one- // releases its reservation exactly once.- app.clock_mut().advance(SCREENSHOT_TIMEOUT_S + 1.0);- hidden_tick(&mut app, &ctx, &frame);- for reply in replies {- let value = reply.try_recv().expect("a timed-out request gets an actionable reply");- assert_eq!(value["ok"], false, "{value}");- assert!(value["error"].as_str().is_some_and(|e| e.contains("no frame")), "{value}");- }- assert_eq!(app.shot_bytes, 0);- assert!(app.pending_screenshots.is_empty());- }-- #[test]- fn a_late_callback_after_cancellation_writes_nothing_and_replies_once() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- ready(&mut app, &ctx, &frame);- let path = std::env::temp_dir().join(format!("effectcraft-shot-{}-late.png", std::process::id()));- let _ = std::fs::remove_file(&path);- let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Window);- let late = issue_shot(&mut app, &ctx, &frame);- app.clock_mut().advance(SCREENSHOT_TIMEOUT_S + 1.0);- hidden_tick(&mut app, &ctx, &frame);- let timeout = reply.try_recv().expect("the request times out");- assert_eq!(timeout["ok"], false, "{timeout}");- late.complete(image(800, 480));- hidden_tick(&mut app, &ctx, &frame);- assert!(reply.try_recv().is_err(), "a late completion sends no second reply");- assert!(!path.exists(), "a late completion writes no file");- assert_eq!(app.shot_bytes, 0);- }-- /// Every repaint delay requested on `ctx` (what a host uses to wake the app).- fn wake_requests(ctx: &egui::Context) -> Arc<std::sync::Mutex<Vec<std::time::Duration>>> {- let wakes: Arc<std::sync::Mutex<Vec<std::time::Duration>>> = Arc::default();- let record = Arc::clone(&wakes);- ctx.set_repaint_observer(move |i| record.lock().unwrap_or_else(std::sync::PoisonError::into_inner).push(i.delay));- wakes- }-- #[test]- fn an_issued_capture_schedules_a_wake_up_for_its_deadline() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- ready(&mut app, &ctx, &frame);- let reply = screenshot_request(&mut app, &ctx, None, ShotTarget::Window);- for _ in 0..SCREENSHOT_SETTLE_PASSES {- let mut raw = raw(egui::vec2(800.0, 480.0));- pass(&mut app, &ctx, &frame, &mut raw);- }- app.clock_mut().advance(SCREENSHOT_SETTLE_S + 0.01);- // Record the repaint requests of the tick that issues the capture only.- let wakes = wake_requests(&ctx);- let out = tick_with(&mut app, &ctx, &frame, &raw(egui::vec2(800.0, 480.0)));- assert_eq!(shot_callbacks(&out).len(), 1, "the settled capture is issued once");- let delays = wakes.lock().unwrap_or_else(std::sync::PoisonError::into_inner).clone();- // The deadline is 8 s after admission; the capture was issued ~0.31 s in, so the app must- // ask for a wake-up close to that timeout, not only for the next paint.- let deadline_wake = delays.iter().any(|d| d.as_secs_f64() > 7.0 && d.as_secs_f64() <= SCREENSHOT_TIMEOUT_S);- assert!(deadline_wake, "an issued capture asks the host to wake for its timeout: {delays:?}");- // The callback never arrives (a hidden window or a display asleep). The host wakes at the- // requested delay; without this wake-up the timeout below could never be evaluated.- app.clock_mut().advance(SCREENSHOT_TIMEOUT_S + 1.0);- hidden_tick(&mut app, &ctx, &frame);- let value = reply.try_recv().expect("the deadline wake-up produces the timeout reply");- assert_eq!(value["ok"], false, "{value}");- assert!(value["error"].as_str().is_some_and(|e| e.contains("no frame")), "{value}");- assert_eq!(app.shot_bytes, 0);- assert!(app.pending_screenshots.is_empty());- }-- #[test]- fn a_downscaled_capture_is_cropped_with_the_images_own_scale() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- let geom = ready(&mut app, &ctx, &frame);- assert_eq!((geom.rect.width(), geom.rect.height(), geom.ppp), (800.0, 480.0, 1.0));- // The adapter-limit fit (E2) returned half the requested pixels. Left red, right blue.- let fitted =- Arc::new(egui::ColorImage::new([400, 240], (0..400 * 240).map(|i| if i % 400 < 200 { egui::Color32::RED } else { egui::Color32::BLUE }).collect()));- let dir = std::env::temp_dir();- for (name, crop, want) in [("left", [0.0, 0.0, 400.0, 240.0], egui::Color32::RED), ("right", [400.0, 0.0, 400.0, 240.0], egui::Color32::BLUE)] {- let path = dir.join(format!("effectcraft-shot-{}-scale-{name}.png", std::process::id()));- let _ = std::fs::remove_file(&path);- let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Rect(crop));- let cb = issue_shot(&mut app, &ctx, &frame);- cb.complete(Arc::clone(&fitted));- hidden_tick(&mut app, &ctx, &frame);- let value = reply.try_recv().expect("the downscaled capture replies");- assert_eq!(value["ok"], true, "{value}");- assert_eq!(value["result"]["width"], 200, "{value}");- assert_eq!(value["result"]["height"], 120, "{value}");- let png = std::fs::read(&path).expect("the PNG is written");- let decoded = image::load_from_memory(&png).expect("our PNG decodes").to_rgba8();- assert_eq!((decoded.width(), decoded.height()), (200, 120), "{value}");- let px = decoded.get_pixel(100, 60).0;- assert!(px[0] == want.r() && px[1] == want.g() && px[2] == want.b(), "{name}: {px:?} is not from its half of the fitted image");- let _ = std::fs::remove_file(&path);- }- }-- #[test]- fn a_capture_before_any_pass_never_uses_the_window_frame_rect() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- // Only the outer (title bar included) rectangle is known: it is not the captured surface.- let outer = egui::Rect::from_min_size(egui::pos2(0.0, -30.0), egui::vec2(800.0, 510.0));- let mut raw = egui::RawInput::default();- raw.viewports.insert(egui::ViewportId::ROOT, egui::ViewportInfo { outer_rect: Some(outer), ..Default::default() });- let _ = tick_with(&mut app, &ctx, &frame, &raw);- let (tx, reply) = std::sync::mpsc::channel();- app.admit_screenshot(&ctx, None, ShotTarget::Window, tx);- let value = reply.try_recv().expect("the request is answered now");- assert_eq!(value["ok"], false, "{value}");- assert!(value["error"].as_str().is_some_and(|e| e.contains("geometry is not known")), "{value}");- assert!(app.pending_screenshots.is_empty(), "nothing was reserved against the wrong rectangle");- assert_eq!(app.shot_bytes, 0);- assert!(app.want_paint, "the pass that records the geometry is requested");- }-- #[test]- fn an_element_that_moves_while_the_ui_settles_is_captured_where_it_is() {- let ctx = egui::Context::default();- let frame = eframe::Frame::_new_kittest();- let mut app = app_with_comp();- let geom = ready(&mut app, &ctx, &frame);- // Any registered panel: the crop follows this element's rectangle.- let panel = app.auto.previous.iter().chain(app.auto.elements.iter()).find(|e| e.id.starts_with("panel.")).map(|e| e.id.clone());- let panel = panel.expect("a dock panel is on screen after a completed pass");- let reply = screenshot_request(&mut app, &ctx, None, ShotTarget::Id(panel.clone()));- for _ in 0..SCREENSHOT_SETTLE_PASSES {- let mut raw = raw(egui::vec2(800.0, 480.0));- pass(&mut app, &ctx, &frame, &mut raw);- }- // The panel moves after its last draw: the crop must follow it, not the admission rect.- let moved = [40.0, 30.0, 300.0, 200.0];- for list in [&mut app.auto.previous, &mut app.auto.elements] {- if let Some(e) = list.iter_mut().find(|e| e.id == panel) {- e.rect = moved;- }- }- app.clock_mut().advance(SCREENSHOT_SETTLE_S + 0.01);- let out = tick_with(&mut app, &ctx, &frame, &raw(egui::vec2(800.0, 480.0)));- assert_eq!(shot_callbacks(&out).len(), 1, "the settled capture is issued once");- let crop = app.pending_screenshots.first().and_then(|s| s.crop).expect("the element crop is resolved at issuance");- assert!((crop[0] - (moved[0] - geom.rect.min.x)).abs() < 0.01, "{crop:?}");- assert!((crop[1] - (moved[1] - geom.rect.min.y)).abs() < 0.01, "{crop:?}");- assert!((crop[2] - moved[2]).abs() < 0.01 && (crop[3] - moved[3]).abs() < 0.01, "{crop:?}");- // Let it complete and reply, so the request does not outlive the test.- if let Some(cb) = shot_callbacks(&out).into_iter().next() {- cb.complete(image(800, 480));- }- hidden_tick(&mut app, &ctx, &frame);- let value = reply.try_recv().expect("the capture replies");- assert_eq!(value["ok"], true, "{value}");- assert_eq!((value["result"]["width"].as_u64(), value["result"]["height"].as_u64()), (Some(300), Some(200)), "{value}");- }-}+mod lifecycle_tests;diff --git a/crates/ui-egui/src/lifecycle_tests.rs b/crates/ui-egui/src/lifecycle_tests.rsnew file mode 100644index 000000000..6c9eb85d2--- /dev/null+++ b/crates/ui-egui/src/lifecycle_tests.rs@@ -0,0 +1,509 @@+//! The logic-only / UI-pass split: queue work in `tick`, input, layout and setup in `draw`.+//!+//! The driver mirrors eframe's order for a hidden window: `raw_input_hook` prepares the raw+//! input, a logic-only iteration runs `tick`, and a forced pass runs `draw` with the same+//! prepared input. Nothing may depend on `current_pass_index`, which is zero in both.++use super::*;+use effectcraft_engine::config::{ConfigStore, MemoryConfig};++fn app_with_comp() -> EffectcraftApp {+ let mut session = Session::default();+ session.execute("comp.new", json!({"name": "Lifecycle", "width": 64, "height": 36, "duration": 1})).unwrap();+ session.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();+ let mut app = EffectcraftApp::new(session);+ app.ui.start_screen = false;+ app.ui.show_menu_bar = false;+ app.use_manual_clock();+ app+}++fn raw(size: egui::Vec2) -> egui::RawInput {+ egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)), ..Default::default() }+}++fn tick_with(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, raw: &egui::RawInput) -> egui::LogicOutput {+ ctx.run_logic(raw, |ctx| app.tick(ctx, frame))+}++fn hidden_tick(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame) {+ let _ = tick_with(app, ctx, frame, &raw(egui::vec2(800.0, 480.0)));+}++/// One host iteration that ends in a UI pass (the forced hidden pass, or a visible frame).+fn pass(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, raw: &mut egui::RawInput) -> egui::FullOutput {+ eframe::App::raw_input_hook(app, ctx, raw);+ let mut out = ctx.run_ui(raw.take(), |ui| app.draw(ui, frame));+ out.textures_delta.clear();+ out+}++fn ready(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame) -> DrawGeometry {+ // The first pass installs the fonts, the second draws with them.+ for _ in 0..3 {+ let mut raw = raw(egui::vec2(800.0, 480.0));+ pass(app, ctx, frame, &mut raw);+ }+ assert!(app.is_ready(), "fonts are ready after the warm-up passes");+ app.draw_geometry().expect("a completed pass records its geometry")+}++fn send(app: &mut EffectcraftApp, method: &str, params: serde_json::Value) -> std::sync::mpsc::Receiver<serde_json::Value> {+ let (request, reply) = ControlRequest::new(method, params);+ let (tx, rx) = std::sync::mpsc::channel();+ tx.send(request).unwrap();+ app.control_rx = Some(rx);+ reply+}++#[test]+fn a_logic_only_tick_installs_no_fonts_and_records_no_geometry() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ hidden_tick(&mut app, &ctx, &frame);+ assert!(!app.is_ready(), "fonts need a real pass, not a logic-only tick");+ assert!(app.draw_geometry().is_none(), "a logic-only tick is not a frame");+ assert_eq!(app.ui_passes(), 0);+}++#[test]+fn a_control_command_that_needs_no_ui_completes_without_a_pass() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ let reply = send(&mut app, "engine.execute", json!({"command": "comp.new", "params": {"name": "Queued", "width": 32, "height": 18, "duration": 1}}));+ hidden_tick(&mut app, &ctx, &frame);+ let value = reply.try_recv().expect("a command that needs no UI is answered by the tick");+ assert_eq!(value["ok"], true, "{value}");+ assert_eq!(app.ui_passes(), 0);+}++#[test]+fn a_pass_that_cannot_draw_receives_no_synthetic_input() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ assert!(!app.is_ready(), "a fresh app installs its fonts in its first pass");+ let reply = send(&mut app, "ui.click", json!({"x": 40, "y": 40}));+ hidden_tick(&mut app, &ctx, &frame);+ assert!(reply.try_recv().is_err(), "a click is not answered before its UI pass");+ // The font-install pass cannot draw. It must not receive the click: `run_ui` applies what+ // the hook feeds, and a batch cannot be put back without applying its pointer state twice.+ let mut setup = raw(egui::vec2(800.0, 480.0));+ eframe::App::raw_input_hook(&mut app, &ctx, &mut setup);+ assert!(setup.events.is_empty(), "a pass that cannot draw gets no synthetic input");+ assert_eq!(app.synthetic.len(), 5, "the whole gesture still waits for a drawing pass");+ assert!(app.pending_synthetic_events().is_empty());+ let mut setup_pass = ctx.run_ui(setup.take(), |ui| app.draw(ui, &frame));+ setup_pass.textures_delta.clear();+ assert!(!app.is_ready(), "the pass that installs the fonts draws nothing");+ // Once fonts are ready the click reaches the UI exactly once, one event per pass.+ let mut passes = 0;+ while reply.try_recv().is_err() {+ passes += 1;+ assert!(passes < 40, "the click must be applied within a few passes");+ let mut raw = raw(egui::vec2(800.0, 480.0));+ pass(&mut app, &ctx, &frame, &mut raw);+ }+ assert!(reply.try_recv().is_err(), "the reply is sent once");+ assert!(app.pending_synthetic_events().is_empty());+ assert!(app.synthetic.is_empty(), "every event was applied once");+}++#[test]+fn one_pending_synthetic_batch_is_never_duplicated_while_hidden() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ ready(&mut app, &ctx, &frame);+ let reply = send(&mut app, "ui.click", json!({"x": 40, "y": 40}));+ hidden_tick(&mut app, &ctx, &frame);+ assert!(reply.try_recv().is_err(), "a click is not answered before its UI pass");+ // Several hidden host iterations: eframe keeps the first prepared input; only its one+ // event may reach the raw input, and a later hook must not add another.+ let mut first = raw(egui::vec2(800.0, 480.0));+ eframe::App::raw_input_hook(&mut app, &ctx, &mut first);+ assert_eq!(first.events.len(), 1, "the first event of the gesture is fed");+ let mut second = raw(egui::vec2(800.0, 480.0));+ eframe::App::raw_input_hook(&mut app, &ctx, &mut second);+ assert!(second.events.is_empty(), "an unapplied batch blocks the next event");+ assert_eq!(app.pending_synthetic_events().len(), 1);+ // The pass that applies the batch acknowledges it once; it is never fed again.+ pass(&mut app, &ctx, &frame, &mut first);+ assert!(app.pending_synthetic_events().is_empty());+ // Drive real passes until the gesture is applied: exactly one reply, no lost events.+ let mut passes = 0;+ while reply.try_recv().is_err() {+ passes += 1;+ assert!(passes < 40, "the click must be applied within a few passes");+ let mut raw = raw(egui::vec2(800.0, 480.0));+ pass(&mut app, &ctx, &frame, &mut raw);+ }+ assert!(app.pending_synthetic_events().is_empty());+ assert!(app.synthetic.is_empty());+ assert!(reply.try_recv().is_err(), "the reply is sent once");+}++#[test]+fn geometry_epoch_tracks_size_and_scale_but_not_window_position() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ let first = ready(&mut app, &ctx, &frame);+ let mut moved = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::pos2(120.0, 80.0), first.rect.size())), ..Default::default() };+ pass(&mut app, &ctx, &frame, &mut moved);+ assert_eq!(app.draw_geometry().unwrap().epoch, first.epoch, "moving the window does not change a capture");+ let mut resized = raw(egui::vec2(1024.0, 640.0));+ pass(&mut app, &ctx, &frame, &mut resized);+ let after_resize = app.draw_geometry().unwrap();+ assert!(after_resize.epoch > first.epoch, "a resize advances the epoch");+ let mut back = raw(egui::vec2(800.0, 480.0));+ pass(&mut app, &ctx, &frame, &mut back);+ assert!(app.draw_geometry().unwrap().epoch > after_resize.epoch, "changing back is another change, not the old epoch");+}++#[test]+fn only_a_viewer_that_draws_records_a_prefetch_scale() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ ready(&mut app, &ctx, &frame);+ assert!(app.last_viewer_scale.is_some(), "the visible viewer recorded the scale it drew at");+ // The Home screen draws no viewer: the old comp's scale must not keep idle prefetch alive.+ app.ui.start_screen = true;+ let mut input = raw(egui::vec2(800.0, 480.0));+ pass(&mut app, &ctx, &frame, &mut input);+ assert!(app.last_viewer_scale.is_none(), "no viewer drew, so there is no scale to prefetch at");+ // Back to the comp: the next pass records it again.+ app.ui.start_screen = false;+ let mut input = raw(egui::vec2(800.0, 480.0));+ pass(&mut app, &ctx, &frame, &mut input);+ assert!(app.last_viewer_scale.is_some());+}++#[test]+fn playback_advances_on_a_logic_only_tick() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ app.playback.playing = true;+ app.playback.plan = Some(effectcraft_engine::preview::PreviewPlan {+ start: 1,+ end: 1,+ first: 1,+ step: 1,+ fps: 24.0,+ looping: false,+ cache_first: false,+ video: false,+ audio: false,+ origin: Tick::ZERO,+ });+ app.playback.start_wall = 0.0;+ app.playback.start_frame = 1;+ app.clock_mut().advance(1.0);+ hidden_tick(&mut app, &ctx, &frame);+ assert!(!app.playback.playing, "a one-frame preview ends without any UI pass");+ assert_eq!(app.playback.audio_frame, Some(1), "the audio-only playhead reached the plan's end");+ assert_eq!(app.ui_passes(), 0);+}++#[test]+fn workspace_layout_autosave_writes_on_a_hidden_tick() {+ let store = Arc::new(MemoryConfig::default());+ let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });+ app.ui.start_screen = false;+ app.use_manual_clock();+ app.ui.focused = PanelKind::Timeline;+ app.clock_mut().advance(2.0);+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ hidden_tick(&mut app, &ctx, &frame);+ assert!(store.read(WORKSPACES_FILE).is_some(), "the layout is saved while the window is hidden");+ assert_eq!(app.ui_passes(), 0);+}++#[test]+fn the_close_guard_answers_a_close_request_without_a_pass() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ assert!(app.session.is_dirty(), "creating a comp and a layer leaves unsaved changes");+ let mut raw = raw(egui::vec2(800.0, 480.0));+ raw.viewports.insert(egui::ViewportId::ROOT, egui::ViewportInfo { events: vec![egui::ViewportEvent::Close], ..Default::default() });+ let out = tick_with(&mut app, &ctx, &frame, &raw);+ assert!(app.dialog.is_some(), "a hidden close request opens the unsaved-changes prompt");+ let cancel = out.viewport_commands.values().flatten().any(|c| matches!(c, egui::ViewportCommand::CancelClose));+ assert!(cancel, "the window stays open while the prompt is asking");+ assert_eq!(app.ui_passes(), 0);+}++// ---------------------------------------------------------------- screenshots++fn screenshot_request(app: &mut EffectcraftApp, ctx: &egui::Context, path: Option<&str>, target: ShotTarget) -> std::sync::mpsc::Receiver<serde_json::Value> {+ let (tx, rx) = std::sync::mpsc::channel();+ app.admit_screenshot(ctx, path.map(str::to_string), target, tx);+ rx+}++fn shot_callbacks(out: &egui::LogicOutput) -> Vec<egui::ScreenshotCallback> {+ out.viewport_commands+ .values()+ .flatten()+ .filter_map(|c| match c {+ egui::ViewportCommand::Screenshot(cb) => Some(cb.clone()),+ _ => None,+ })+ .collect()+}++/// Three settled passes and the settle delay, then the tick that issues the capture.+fn issue_shot(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame) -> egui::ScreenshotCallback {+ issue_shot_at(app, ctx, frame, egui::vec2(800.0, 480.0))+}++fn issue_shot_at(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, size: egui::Vec2) -> egui::ScreenshotCallback {+ for _ in 0..SCREENSHOT_SETTLE_PASSES {+ let mut raw = raw(size);+ pass(app, ctx, frame, &mut raw);+ }+ app.clock_mut().advance(SCREENSHOT_SETTLE_S + 0.01);+ let out = tick_with(app, ctx, frame, &raw(size));+ let cbs = shot_callbacks(&out);+ assert_eq!(cbs.len(), 1, "one settled screenshot is issued once");+ cbs.into_iter().next().unwrap()+}++fn image(width: usize, height: usize) -> Arc<egui::ColorImage> {+ Arc::new(egui::ColorImage::new([width, height], vec![egui::Color32::from_rgb(10, 20, 30); width.checked_mul(height).unwrap()]))+}++#[test]+fn a_screenshot_is_issued_only_after_settled_passes_and_writes_from_the_tick() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ ready(&mut app, &ctx, &frame);+ let path = std::env::temp_dir().join(format!("effectcraft-shot-{}-ok.png", std::process::id()));+ let _ = std::fs::remove_file(&path);+ let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Window);+ // Not settled: a tick issues nothing and asks for passes instead.+ let out = tick_with(&mut app, &ctx, &frame, &raw(egui::vec2(800.0, 480.0)));+ assert!(shot_callbacks(&out).is_empty(), "no capture before the UI settles");+ assert_eq!(out.viewport_commands.values().flatten().filter(|c| matches!(c, egui::ViewportCommand::RequestPaintWhileHidden)).count(), 1);+ let cb = issue_shot(&mut app, &ctx, &frame);+ assert!(reply.try_recv().is_err(), "the callback must not write or reply itself");+ cb.complete(image(800, 480));+ hidden_tick(&mut app, &ctx, &frame);+ let value = reply.try_recv().expect("the tick drains the completed slot and replies");+ assert_eq!(value["ok"], true, "{value}");+ assert!(path.exists(), "{value}");+ assert_eq!(value["result"]["width"], 800);+ assert_eq!(value["result"]["height"], 480);+ assert_eq!(app.shot_bytes, 0, "the reservation is released");+ let _ = std::fs::remove_file(&path);+}++#[test]+fn a_resize_between_issue_and_completion_rejects_the_pixels_and_retries() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ ready(&mut app, &ctx, &frame);+ let path = std::env::temp_dir().join(format!("effectcraft-shot-{}-retry.png", std::process::id()));+ let _ = std::fs::remove_file(&path);+ let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Window);+ let first = issue_shot(&mut app, &ctx, &frame);+ let size = egui::vec2(1024.0, 640.0);+ let mut resized = raw(size);+ pass(&mut app, &ctx, &frame, &mut resized);+ first.complete(image(800, 480));+ let _ = tick_with(&mut app, &ctx, &frame, &raw(size));+ assert!(reply.try_recv().is_err(), "pixels from the old surface epoch are discarded");+ assert!(!path.exists(), "a stale image is never written");+ // The retry is issued against the new geometry and the new image is accepted.+ let second = issue_shot_at(&mut app, &ctx, &frame, size);+ second.complete(image(1024, 640));+ let _ = tick_with(&mut app, &ctx, &frame, &raw(size));+ let value = reply.try_recv().expect("the retried capture replies");+ assert_eq!(value["ok"], true, "{value}");+ assert_eq!(value["result"]["width"], 1024);+ let _ = std::fs::remove_file(&path);+}++#[test]+fn screenshot_admission_bounds_requests_and_a_timeout_releases_its_reservation() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ ready(&mut app, &ctx, &frame);+ let mut replies = Vec::new();+ for _ in 0..MAX_PENDING_SHOTS {+ replies.push(screenshot_request(&mut app, &ctx, None, ShotTarget::Rect([0.0, 0.0, 4.0, 4.0])));+ }+ let refused = screenshot_request(&mut app, &ctx, None, ShotTarget::Rect([0.0, 0.0, 4.0, 4.0]));+ let value = refused.try_recv().expect("the fifth request is refused immediately");+ assert_eq!(value["ok"], false, "{value}");+ // Every queued request times out on a hidden window that presents no frame; each one+ // releases its reservation exactly once.+ app.clock_mut().advance(SCREENSHOT_TIMEOUT_S + 1.0);+ hidden_tick(&mut app, &ctx, &frame);+ for reply in replies {+ let value = reply.try_recv().expect("a timed-out request gets an actionable reply");+ assert_eq!(value["ok"], false, "{value}");+ assert!(value["error"].as_str().is_some_and(|e| e.contains("no frame")), "{value}");+ }+ assert_eq!(app.shot_bytes, 0);+ assert!(app.pending_screenshots.is_empty());+}++#[test]+fn a_late_callback_after_cancellation_writes_nothing_and_replies_once() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ ready(&mut app, &ctx, &frame);+ let path = std::env::temp_dir().join(format!("effectcraft-shot-{}-late.png", std::process::id()));+ let _ = std::fs::remove_file(&path);+ let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Window);+ let late = issue_shot(&mut app, &ctx, &frame);+ app.clock_mut().advance(SCREENSHOT_TIMEOUT_S + 1.0);+ hidden_tick(&mut app, &ctx, &frame);+ let timeout = reply.try_recv().expect("the request times out");+ assert_eq!(timeout["ok"], false, "{timeout}");+ late.complete(image(800, 480));+ hidden_tick(&mut app, &ctx, &frame);+ assert!(reply.try_recv().is_err(), "a late completion sends no second reply");+ assert!(!path.exists(), "a late completion writes no file");+ assert_eq!(app.shot_bytes, 0);+}++/// Every repaint delay requested on `ctx` (what a host uses to wake the app).+fn wake_requests(ctx: &egui::Context) -> Arc<std::sync::Mutex<Vec<std::time::Duration>>> {+ let wakes: Arc<std::sync::Mutex<Vec<std::time::Duration>>> = Arc::default();+ let record = Arc::clone(&wakes);+ ctx.set_repaint_observer(move |i| record.lock().unwrap_or_else(std::sync::PoisonError::into_inner).push(i.delay));+ wakes+}++#[test]+fn an_issued_capture_schedules_a_wake_up_for_its_deadline() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ ready(&mut app, &ctx, &frame);+ let reply = screenshot_request(&mut app, &ctx, None, ShotTarget::Window);+ for _ in 0..SCREENSHOT_SETTLE_PASSES {+ let mut raw = raw(egui::vec2(800.0, 480.0));+ pass(&mut app, &ctx, &frame, &mut raw);+ }+ app.clock_mut().advance(SCREENSHOT_SETTLE_S + 0.01);+ // Record the repaint requests of the tick that issues the capture only.+ let wakes = wake_requests(&ctx);+ let out = tick_with(&mut app, &ctx, &frame, &raw(egui::vec2(800.0, 480.0)));+ assert_eq!(shot_callbacks(&out).len(), 1, "the settled capture is issued once");+ let delays = wakes.lock().unwrap_or_else(std::sync::PoisonError::into_inner).clone();+ // The deadline is 8 s after admission; the capture was issued ~0.31 s in, so the app must+ // ask for a wake-up close to that timeout, not only for the next paint.+ let deadline_wake = delays.iter().any(|d| d.as_secs_f64() > 7.0 && d.as_secs_f64() <= SCREENSHOT_TIMEOUT_S);+ assert!(deadline_wake, "an issued capture asks the host to wake for its timeout: {delays:?}");+ // The callback never arrives (a hidden window or a display asleep). The host wakes at the+ // requested delay; without this wake-up the timeout below could never be evaluated.+ app.clock_mut().advance(SCREENSHOT_TIMEOUT_S + 1.0);+ hidden_tick(&mut app, &ctx, &frame);+ let value = reply.try_recv().expect("the deadline wake-up produces the timeout reply");+ assert_eq!(value["ok"], false, "{value}");+ assert!(value["error"].as_str().is_some_and(|e| e.contains("no frame")), "{value}");+ assert_eq!(app.shot_bytes, 0);+ assert!(app.pending_screenshots.is_empty());+}++#[test]+fn a_downscaled_capture_is_cropped_with_the_images_own_scale() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ let geom = ready(&mut app, &ctx, &frame);+ assert_eq!((geom.rect.width(), geom.rect.height(), geom.ppp), (800.0, 480.0, 1.0));+ // The adapter-limit fit (E2) returned half the requested pixels. Left red, right blue.+ let fitted =+ Arc::new(egui::ColorImage::new([400, 240], (0..400 * 240).map(|i| if i % 400 < 200 { egui::Color32::RED } else { egui::Color32::BLUE }).collect()));+ let dir = std::env::temp_dir();+ for (name, crop, want) in [("left", [0.0, 0.0, 400.0, 240.0], egui::Color32::RED), ("right", [400.0, 0.0, 400.0, 240.0], egui::Color32::BLUE)] {+ let path = dir.join(format!("effectcraft-shot-{}-scale-{name}.png", std::process::id()));+ let _ = std::fs::remove_file(&path);+ let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Rect(crop));+ let cb = issue_shot(&mut app, &ctx, &frame);+ cb.complete(Arc::clone(&fitted));+ hidden_tick(&mut app, &ctx, &frame);+ let value = reply.try_recv().expect("the downscaled capture replies");+ assert_eq!(value["ok"], true, "{value}");+ assert_eq!(value["result"]["width"], 200, "{value}");+ assert_eq!(value["result"]["height"], 120, "{value}");+ let png = std::fs::read(&path).expect("the PNG is written");+ let decoded = image::load_from_memory(&png).expect("our PNG decodes").to_rgba8();+ assert_eq!((decoded.width(), decoded.height()), (200, 120), "{value}");+ let px = decoded.get_pixel(100, 60).0;+ assert!(px[0] == want.r() && px[1] == want.g() && px[2] == want.b(), "{name}: {px:?} is not from its half of the fitted image");+ let _ = std::fs::remove_file(&path);+ }+}++#[test]+fn a_capture_before_any_pass_never_uses_the_window_frame_rect() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ // Only the outer (title bar included) rectangle is known: it is not the captured surface.+ let outer = egui::Rect::from_min_size(egui::pos2(0.0, -30.0), egui::vec2(800.0, 510.0));+ let mut raw = egui::RawInput::default();+ raw.viewports.insert(egui::ViewportId::ROOT, egui::ViewportInfo { outer_rect: Some(outer), ..Default::default() });+ let _ = tick_with(&mut app, &ctx, &frame, &raw);+ let (tx, reply) = std::sync::mpsc::channel();+ app.admit_screenshot(&ctx, None, ShotTarget::Window, tx);+ let value = reply.try_recv().expect("the request is answered now");+ assert_eq!(value["ok"], false, "{value}");+ assert!(value["error"].as_str().is_some_and(|e| e.contains("geometry is not known")), "{value}");+ assert!(app.pending_screenshots.is_empty(), "nothing was reserved against the wrong rectangle");+ assert_eq!(app.shot_bytes, 0);+ assert!(app.want_paint, "the pass that records the geometry is requested");+}++#[test]+fn an_element_that_moves_while_the_ui_settles_is_captured_where_it_is() {+ let ctx = egui::Context::default();+ let frame = eframe::Frame::_new_kittest();+ let mut app = app_with_comp();+ let geom = ready(&mut app, &ctx, &frame);+ // Any registered panel: the crop follows this element's rectangle.+ let panel = app.auto.previous.iter().chain(app.auto.elements.iter()).find(|e| e.id.starts_with("panel.")).map(|e| e.id.clone());+ let panel = panel.expect("a dock panel is on screen after a completed pass");+ let reply = screenshot_request(&mut app, &ctx, None, ShotTarget::Id(panel.clone()));+ for _ in 0..SCREENSHOT_SETTLE_PASSES {+ let mut raw = raw(egui::vec2(800.0, 480.0));+ pass(&mut app, &ctx, &frame, &mut raw);+ }+ // The panel moves after its last draw: the crop must follow it, not the admission rect.+ let moved = [40.0, 30.0, 300.0, 200.0];+ for list in [&mut app.auto.previous, &mut app.auto.elements] {+ if let Some(e) = list.iter_mut().find(|e| e.id == panel) {+ e.rect = moved;+ }+ }+ app.clock_mut().advance(SCREENSHOT_SETTLE_S + 0.01);+ let out = tick_with(&mut app, &ctx, &frame, &raw(egui::vec2(800.0, 480.0)));+ assert_eq!(shot_callbacks(&out).len(), 1, "the settled capture is issued once");+ let crop = app.pending_screenshots.first().and_then(|s| s.crop).expect("the element crop is resolved at issuance");+ assert!((crop[0] - (moved[0] - geom.rect.min.x)).abs() < 0.01, "{crop:?}");+ assert!((crop[1] - (moved[1] - geom.rect.min.y)).abs() < 0.01, "{crop:?}");+ assert!((crop[2] - moved[2]).abs() < 0.01 && (crop[3] - moved[3]).abs() < 0.01, "{crop:?}");+ // Let it complete and reply, so the request does not outlive the test.+ if let Some(cb) = shot_callbacks(&out).into_iter().next() {+ cb.complete(image(800, 480));+ }+ hidden_tick(&mut app, &ctx, &frame);+ let value = reply.try_recv().expect("the capture replies");+ assert_eq!(value["ok"], true, "{value}");+ assert_eq!((value["result"]["width"].as_u64(), value["result"]["height"].as_u64()), (Some(300), Some(200)), "{value}");+}