f67d38b35cc5
tests.rs
use std::sync::Arc;
use std::sync::mpsc::{Receiver, channel};
use egui::{Color32, ColorImage, Rect, ViewportId, ViewportInfo, pos2, vec2};
use super::*;
use crate::automation::Registry;
use filmcraft_engine::Session;
/// App with a default session, for capture-state unit tests.
fn app() -> FilmcraftApp {
FilmcraftApp::new(Session::default())
}
/// A fixed 800×600, 1 px/pt capture identity for the app's current document with no focus.
fn geometry(app: &FilmcraftApp) -> CaptureGeometry {
CaptureGeometry {
surface: SurfaceGeometry { viewport: Some(egui::vec2(800.0, 600.0)), pixels_per_point: 1.0, max_texture_side: 8192, minimized: false, occluded: false },
document: active_document(app),
focus: None,
}
}
/// Raw input reporting an 800×600 root viewport.
fn raw() -> egui::RawInput {
egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0))), ..Default::default() }
}
/// Admit one uncropped in-memory capture at the default test surface; return its reply
/// receiver and token.
fn admit_one(app: &mut FilmcraftApp, ctx: &egui::Context) -> (Receiver<Value>, u64) {
admit_with_surface(app, ctx, geometry(app).surface)
}
/// Bind `surface` as the current capture geometry, admit one uncropped in-memory capture and
/// return its reply receiver and token.
fn admit_with_surface(app: &mut FilmcraftApp, ctx: &egui::Context, surface: SurfaceGeometry) -> (Receiver<Value>, u64) {
app.capture_geometry = Some(CaptureGeometry { surface, document: active_document(app), focus: None });
let (tx, rx) = channel();
admit(app, ctx, None, None, tx);
let token = app.shots.requests.last().map(|shot| shot.token).unwrap_or_default();
(rx, token)
}
/// `note_raw_geometry` uses the fresh raw 2x viewport (1600×1200) rather than the previous
/// pass's input and bumps the capture epoch.
#[test]
fn raw_geometry_uses_the_fresh_surface_not_the_previous_pass() {
let ctx = egui::Context::default();
let mut app = app();
let mut raw = raw();
let _ = raw.viewports.insert(ViewportId::ROOT, ViewportInfo { native_pixels_per_point: Some(2.0), ..Default::default() });
note_raw_geometry(&mut app, &ctx, &raw);
let geometry = app.capture_geometry.expect("geometry from raw input");
assert_eq!(geometry.surface.expected_size(), Some([1600, 1200]));
assert!(app.capture_epoch > 0);
}
/// Oversized surfaces shrink both axes by one factor to the texture limit and crop at the
/// matching rendered scale; a surface within the limit keeps the exact native scale.
#[test]
fn oversized_windows_predict_the_backends_uniformly_scaled_surface() {
let app = app();
let mut surface = geometry(&app).surface;
surface.viewport = Some(vec2(16_384.0, 4_000.0));
surface.max_texture_side = 8192;
assert_eq!(surface.expected_size(), Some([8192, 2000]), "both axes scale by the same factor, like egui-wgpu's surface_fit");
assert_eq!(surface.captured_pixels_per_point(), 0.5, "the fitted texture is drawn at the same factor");
surface.viewport = Some(vec2(4_000.0, 16_384.0));
assert_eq!(surface.expected_size(), Some([2000, 8192]));
assert_eq!(surface.captured_pixels_per_point(), 0.5);
surface.viewport = Some(vec2(1920.0, 1080.0));
assert_eq!(surface.expected_size(), Some([1920, 1080]), "within the limit nothing shrinks");
assert_eq!(surface.captured_pixels_per_point(), 1.0, "an uncapped surface keeps the native scale exactly");
}
/// Unusable viewport data preserves a valid native scale, while an invalid native scale falls
/// back to 1.0 so a crop can never divide by zero.
#[test]
fn captured_scale_falls_back_when_geometry_is_unusable() {
let app = app();
let mut surface = geometry(&app).surface;
surface.pixels_per_point = 2.0;
surface.viewport = None;
assert_eq!(surface.captured_pixels_per_point(), 2.0, "no viewport preserves the native scale");
surface.viewport = Some(vec2(0.0, 600.0));
assert_eq!(surface.captured_pixels_per_point(), 2.0);
surface.viewport = Some(vec2(f32::NAN, 600.0));
assert_eq!(surface.captured_pixels_per_point(), 2.0);
surface.viewport = Some(vec2(800.0, 600.0));
surface.pixels_per_point = f32::INFINITY;
assert_eq!(surface.captured_pixels_per_point(), 1.0, "an invalid native scale falls back to 1, like save_screenshot_with_ppp");
surface.pixels_per_point = 0.0;
assert_eq!(surface.captured_pixels_per_point(), 1.0);
}
/// A crop in points selects the region where a uniformly downscaled surface actually drew it,
/// using the rendered rather than the native scale.
#[test]
fn downscaled_capture_crops_with_the_rendered_scale() {
let ctx = egui::Context::default();
let mut app = app();
let surface = SurfaceGeometry {
viewport: Some(vec2(16_384.0, 2_000.0)),
// A 2x native surface fits at 0.25 render scale: crop at 0.5 pixels per point.
// This also catches accidentally returning render_scale without the native factor.
pixels_per_point: 2.0,
max_texture_side: 8192,
minimized: false,
occluded: false,
};
assert_eq!(surface.expected_size(), Some([8192, 1_000]));
assert_eq!(surface.captured_pixels_per_point(), 0.5);
let (rx, token) = admit_with_surface(&mut app, &ctx, surface);
let dir = tempfile::tempdir().expect("a temporary screenshot directory");
let path = dir.path().join("downscaled-crop.png");
// The crop is 400x200 points, which the fitted surface draws as 200x100 pixels. Paint a
// red rectangle at exactly that rendered position so a wrong (native) scale would crop
// black pixels or the wrong dimensions instead of this region.
let mut image = ColorImage::filled([8192, 1_000], Color32::BLACK);
for y in 25..125 {
for x in 50..250 {
image.pixels[y * 8192 + x] = Color32::RED;
}
}
let shot = &mut app.shots.requests[0];
shot.path = Some(path.to_string_lossy().into_owned());
shot.crop = Some([100.0, 50.0, 400.0, 200.0]);
shot.issued = true;
let callback = shot.callback.take().expect("a callback");
callback.complete(Arc::new(image));
drain(&mut app, &ctx);
let reply = rx.try_recv().expect("a screenshot reply");
assert_eq!(reply["request"], token);
assert_eq!(reply["ok"], true, "{reply}");
assert_eq!([reply["result"]["width"].as_u64(), reply["result"]["height"].as_u64()], [Some(200), Some(100)]);
let decoded = image::load_from_memory(&std::fs::read(&path).expect("the saved crop")).expect("decode the saved crop").to_rgba8();
assert_eq!(decoded.dimensions(), (200, 100));
assert!(decoded.pixels().all(|pixel| *pixel == image::Rgba([255, 0, 0, 255])), "the crop must select the red region where the downscaled surface drew it");
}
/// A 1.5x surface whose point size rounds up by one window pixel is still uncapped, so its
/// crop keeps the exact 1.5 scale instead of a slightly shrunk one.
#[test]
fn uncapped_hidpi_capture_keeps_the_native_scale() {
let ctx = egui::Context::default();
let mut app = app();
let surface = SurfaceGeometry {
// 801 points at 1.5x is 1201.5 window pixels, which rounds to 1202. The fitted scale
// must still be exactly 1.0 rather than 1202/1201.5 from that one-pixel difference.
viewport: Some(vec2(801.0, 600.0)),
pixels_per_point: 1.5,
max_texture_side: 8192,
minimized: false,
occluded: false,
};
assert_eq!(surface.expected_size(), Some([1202, 900]));
assert_eq!(surface.captured_pixels_per_point(), 1.5);
let (rx, token) = admit_with_surface(&mut app, &ctx, surface);
let dir = tempfile::tempdir().expect("a temporary screenshot directory");
let path = dir.path().join("hidpi-crop.png");
let mut image = ColorImage::filled([1202, 900], Color32::BLACK);
for y in 75..375 {
for x in 150..750 {
image.pixels[y * 1202 + x] = Color32::GREEN;
}
}
let shot = &mut app.shots.requests[0];
shot.path = Some(path.to_string_lossy().into_owned());
shot.crop = Some([100.0, 50.0, 400.0, 200.0]);
shot.issued = true;
let callback = shot.callback.take().expect("a callback");
callback.complete(Arc::new(image));
drain(&mut app, &ctx);
let reply = rx.try_recv().expect("a screenshot reply");
assert_eq!(reply["request"], token);
assert_eq!(reply["ok"], true, "{reply}");
assert_eq!([reply["result"]["width"].as_u64(), reply["result"]["height"].as_u64()], [Some(600), Some(300)]);
let decoded = image::load_from_memory(&std::fs::read(&path).expect("the saved crop")).expect("decode the saved crop").to_rgba8();
assert_eq!(decoded.dimensions(), (600, 300));
assert!(decoded.pixels().all(|pixel| *pixel == image::Rgba([0, 255, 0, 255])), "the HiDPI crop must select the green region at the native scale");
}
/// Minimized, occluded and window-focus flags do not bump the epoch or reject an already
/// issued capture; its pixels are still delivered once.
#[test]
fn presentation_flags_do_not_invalidate_an_issued_capture() {
let ctx = egui::Context::default();
let mut app = app();
let (rx, token) = admit_one(&mut app, &ctx);
let callback = app.shots.requests[0].callback.take().expect("a callback");
app.shots.requests[0].issued = true;
// The window is minimized or another application took focus while the callback was in
// flight. Those flags do not change captured pixels and must not reject the image.
let epoch = app.capture_epoch;
let mut raw = egui::RawInput {
screen_rect: Some(Rect::from_min_size(pos2(0.0, 0.0), vec2(800.0, 600.0))),
max_texture_side: Some(8192),
focused: false,
..Default::default()
};
let viewport = raw.viewports.entry(ViewportId::ROOT).or_default();
viewport.native_pixels_per_point = Some(1.0);
viewport.minimized = Some(true);
viewport.occluded = Some(true);
note_raw_geometry(&mut app, &ctx, &raw);
assert_eq!(app.capture_epoch, epoch, "presentation-only raw input retains the issued capture");
callback.complete(Arc::new(ColorImage::filled([800, 600], Color32::RED)));
drain(&mut app, &ctx);
let reply = rx.try_recv().expect("the issued capture completes instead of being rejected");
assert_eq!(reply["request"], token);
assert_eq!(reply["ok"], true, "{reply}");
}
/// Admission counts completed-but-undrained requests, so a new request over `MAX_REQUESTS`
/// is rejected instead of replacing a slot that still owes a reply.
#[test]
fn admission_counts_outstanding_and_completed_but_undrained_requests() {
let ctx = egui::Context::default();
let mut app = app();
let _receivers: Vec<_> = (0..MAX_REQUESTS).map(|_| admit_one(&mut app, &ctx)).collect();
assert_eq!(app.shots.requests.len(), MAX_REQUESTS);
let image = Arc::new(ColorImage::filled([800, 600], Color32::RED));
app.shots.requests[0].callback.take().expect("a callback").complete(image);
let (tx, rx) = channel();
admit(&mut app, &ctx, None, None, tx);
assert_eq!(app.shots.requests.len(), MAX_REQUESTS, "the fifth request is rejected, not admitted");
let reply = rx.recv().expect("a rejection reply");
assert_eq!(reply["ok"], false);
assert!(reply["error"].as_str().unwrap_or_default().contains("outstanding"), "{reply}");
}
/// A timed-out request replies once; its late callback cannot produce a second reply.
#[test]
fn a_late_completion_after_timeout_does_not_write_or_reply_twice() {
let ctx = egui::Context::default();
let mut app = app();
let (rx, token) = admit_one(&mut app, &ctx);
let callback = app.shots.requests[0].callback.take().expect("a callback");
app.shots.requests[0].issued = true;
app.shots.requests[0].deadline = Instant::now() - Duration::from_millis(1);
drain(&mut app, &ctx);
let reply = rx.recv().expect("timeout reply");
assert_eq!(reply["request"], token);
assert_eq!(reply["ok"], false);
callback.complete(Arc::new(ColorImage::filled([800, 600], Color32::RED)));
assert!(rx.try_recv().is_err(), "a late image must not produce another reply");
}
/// A near-per-image-limit surface is rejected before any slot exists because its crop/encode
/// reservation alone exceeds the aggregate bound.
#[test]
fn near_limit_images_are_rejected_for_encode_buffer_memory() {
let ctx = egui::Context::default();
let mut app = app();
// 8000×4000 RGBA is exactly 128,000,000 raw bytes, under the per-image bound, but the
// crop/PNG/base64 copies make its real peak several times larger than the aggregate bound.
app.capture_geometry = Some(CaptureGeometry {
surface: SurfaceGeometry { viewport: Some(vec2(8000.0, 4000.0)), pixels_per_point: 1.0, max_texture_side: 16384, minimized: false, occluded: false },
document: active_document(&app),
focus: None,
});
let (tx, rx) = channel();
admit(&mut app, &ctx, None, None, tx);
assert!(app.shots.requests.is_empty(), "the image is rejected before a slot or buffer is created");
let reply = rx.recv().expect("a rejection reply");
assert_eq!(reply["ok"], false);
assert!(reply["error"].as_str().unwrap_or_default().contains("budget"), "{reply}");
assert!(admitted_bytes([8000, 4000]).is_some_and(|bytes| bytes > MAX_TOTAL_BYTES));
}
/// A crop resolves only from the current pass's registry; a stale rect and a missing id both
/// error rather than using old coordinates.
#[test]
fn a_crop_is_resolved_from_the_current_pass_not_the_previous_one() {
let mut registry = Registry::default();
let old = Rect::from_min_size(pos2(0.0, 0.0), vec2(100.0, 50.0));
let fresh = Rect::from_min_size(pos2(300.0, 200.0), vec2(400.0, 250.0));
registry.add("panel.project", old, "Project");
registry.begin_frame(); // the previous pass keeps the old rect; this pass has not drawn yet
let target = CropTarget::Element("panel.project".into());
assert!(target.resolve(®istry).is_err(), "a stale rect must not be used");
registry.add("panel.project", fresh, "Project");
assert_eq!(target.resolve(®istry).expect("fresh rect"), [300.0, 200.0, 400.0, 250.0]);
assert!(CropTarget::Element("panel.missing".into()).resolve(®istry).is_err());
}
/// Issuing waits for the accepted final pass of a multipass layout, not the discarded first
/// pass.
#[test]
fn issue_runs_on_the_accepted_final_pass_of_a_multipass_layout() {
let ctx = egui::Context::default();
let mut app = app();
let (_rx, _token) = admit_one(&mut app, &ctx);
app.shots.requests[0].ready_at = Instant::now() - Duration::from_millis(1);
app.shots.requests[0].frames = SETTLE_PASSES;
app.timeline_still = 2;
let mut passes = 0;
let mut output = ctx.run_ui(egui::RawInput::default(), |ui| {
passes += 1;
if ui.ctx().current_pass_index() == 0 {
ui.ctx().request_discard("capture pass test");
}
issue(&mut app, ui.ctx());
});
output.textures_delta.clear();
assert_eq!(passes, 2, "the first pass was discarded and the second accepted");
assert!(app.shots.requests[0].issued, "the accepted pass must issue the capture");
}
/// `issue` consumes `monitor_inexact`, so the signal cannot stay sticky and delay later
/// screenshots until the five-second settle maximum.
#[test]
fn monitor_inexact_is_consumed_by_each_issue_attempt() {
let ctx = egui::Context::default();
let mut app = app();
app.monitor_inexact = true;
issue(&mut app, &ctx);
assert!(!app.monitor_inexact, "a sticky flag would delay every later screenshot by up to five seconds");
}
/// An unissued request follows a geometry change: its expected size and budget are recomputed
/// and it waits for fresh settling passes before issuing.
#[test]
fn a_geometry_change_retries_an_unissued_capture_with_new_budget() {
let ctx = egui::Context::default();
let mut app = app();
let (_rx, _) = admit_one(&mut app, &ctx);
app.shots.requests[0].ready_at = Instant::now() - Duration::from_millis(1);
app.shots.requests[0].frames = SETTLE_PASSES;
app.timeline_still = 2;
let mut changed = geometry(&app).surface;
changed.viewport = Some(egui::vec2(1024.0, 768.0));
app.capture_geometry = Some(CaptureGeometry { surface: changed, ..geometry(&app) });
app.capture_epoch += 1;
issue(&mut app, &ctx);
assert_eq!(app.shots.requests.len(), 1);
assert_eq!(app.shots.requests[0].expected, [1024, 768]);
assert!(!app.shots.requests[0].issued, "the retry waits for its own settling passes");
}
/// When a resize pushes both queued shots over the aggregate budget, each is rejected with
/// its own token and removal of the first cannot shift the second's index.
#[test]
fn mixed_order_geometry_failures_reject_every_shot_without_shifting_indices() {
let ctx = egui::Context::default();
let mut app = app();
let (rx0, token0) = admit_one(&mut app, &ctx);
let (rx1, token1) = admit_one(&mut app, &ctx);
for shot in &mut app.shots.requests {
shot.ready_at = Instant::now() - Duration::from_millis(1);
shot.frames = SETTLE_PASSES;
}
app.timeline_still = 2;
// A resize makes both queued shots need more crop/encode buffers than the aggregate
// budget, so the geometry retry fails for the last shot first.
app.capture_geometry = Some(CaptureGeometry {
surface: SurfaceGeometry { viewport: Some(vec2(8000.0, 4000.0)), pixels_per_point: 1.0, max_texture_side: 16384, minimized: false, occluded: false },
document: active_document(&app),
focus: None,
});
app.capture_epoch += 1;
issue(&mut app, &ctx);
assert!(app.shots.requests.is_empty(), "both failed shots were removed");
for (rx, token) in [(rx0, token0), (rx1, token1)] {
let reply = rx.try_recv().expect("each failed shot gets its own reply");
assert_eq!(reply["request"], token);
assert_eq!(reply["ok"], false, "{reply}");
assert!(reply["error"].as_str().unwrap_or_default().contains("aggregate"), "{reply}");
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.