Merge remote-tracking branch 'origin/gpu-test-group' into ci-fixes

# Conflicts:
#	.config/nextest.toml
#	crates/ui-egui/tests/it/main.rs
This commit is contained in:
aiongg committed 2026-11-18 20:11:50 +00:00
commit 36aa7a8f69
33 files changed
+1336 -1299

No files matched your search

+13 -7
View File
@@ -13,11 +13,17 @@ nextest-version = "0.9.150"
# serialize them. Too many concurrent wgpu devices time out (`PollError: ... Wait timed out`), so
# this group caps them at 4. `cargo xtask ci tests --gpu` reads this group's filters directly: the
# Linux gate runs the group in a shard of its own on lavapipe (scripts/ci-gpu-lavapipe.py).
#
# The group is photocraft-gpu and every test in a module named `gpu_tests` or `<name>_gpu_tests`.
# A test that builds a wgpu device (a kittest `.wgpu()` harness, `create_render_state`, its own
# instance, or a harness `.render()`) lives in such a module and takes `gpu_lock()`. Every other
# test runs on the CPU canvas (the app draws on it unless `set_wgpu` hands it a device) at full
# parallelism.
[test-groups]
gpu = { max-threads = 4 }
[[profile.default.overrides]]
filter = 'package(photocraft-gpu) | (package(photocraft-ui-egui) & (kind(test) | test(/canvas|gpu|mip|type_tool|background_redraw::|floating_group_titles|swap_arrow::tests::rendered_glyph/))) | (package(photocraft-automation) & test(/^gpu_backend::/))'
filter = 'package(photocraft-gpu) | test(/(^|::|_)gpu_tests::/)'
test-group = 'gpu'
# CI (`--profile ci`, .github/workflows/ci.yml). Collect all failures in one integration run
@@ -71,16 +77,16 @@ filter = '''
(package(photocraft-engine) & test(=crop_content_aware_layers::unmeasured_active_targets_and_delete_off_keep_the_legacy_target)) |
(package(photocraft-engine) & test(=cmd::retouch_cmds::content_aware_move::color_tests::a_flat_patch_matches_the_new_surroundings_at_color_ten)) |
(package(photocraft-ui-egui) & test(=tools::type_tool::canvas_tests::every_paragraph_box_handle_resizes_the_box_with_snapping_on)) |
(package(photocraft-ui-egui) & test(=checker_canvas::pixel_grid_is_solid_and_visible_gpu_2x)) |
(package(photocraft-ui-egui) & test(=gpu_tests::checker_canvas::pixel_grid_is_solid_and_visible_gpu_2x)) |
(package(photocraft-engine) & test(=cmd::retouch_cmds::tests::content_aware_move_coarse_preview_handles_transform_extend_and_limits)) |
(package(photocraft-ui-egui) & test(=checker_canvas::pixel_grid_is_solid_and_visible_cpu_2x)) |
(package(photocraft-ui-egui) & test(=drag_preview_canvas::marquee_previews_show_while_dragging_on_white_and_black_at_1x_and_2x)) |
(package(photocraft-ui-egui) & test(=gpu_tests::checker_canvas::pixel_grid_is_solid_and_visible_cpu_2x)) |
(package(photocraft-ui-egui) & test(=gpu_tests::drag_preview_canvas::marquee_previews_show_while_dragging_on_white_and_black_at_1x_and_2x)) |
(package(photocraft-gpu) & test(=camera_raw::shadows_and_highlights_with_per_pixel_stages)) |
(package(photocraft-engine) & test(=cmd::retouch_cmds::content_aware_move::color_tests::a_brightness_change_shifts_the_middle_only_past_color_five)) |
(package(photocraft-engine) & test(=cmd::retouch_cmds::tests::content_aware_move_previews_large_selections_coarse_then_exact_at_all_depths)) |
(package(photocraft-ui-egui) & test(=live_stroke_canvas::live_tool_camera_navigation_is_visible_in_the_input_frame)) |
(package(photocraft-ui-egui) & test(=live_stroke_canvas::the_canvas_shows_the_committed_stroke_part_0)) |
(package(photocraft-ui-egui) & test(=full_res_preview::adjustment_layer_drag_previews_at_full_resolution_when_low_res_is_off)) |
(package(photocraft-ui-egui) & test(=gpu_tests::live_stroke_canvas::live_tool_camera_navigation_is_visible_in_the_input_frame)) |
(package(photocraft-ui-egui) & test(=gpu_tests::live_stroke_canvas::the_canvas_shows_the_committed_stroke_part_0)) |
(package(photocraft-ui-egui) & test(=gpu_tests::full_res_preview::adjustment_layer_drag_previews_at_full_resolution_when_low_res_is_off)) |
(package(photocraft-ui-egui) & test(=input::hold_keys::tests::cmd_gives_the_move_tool_only_where_the_tool_does_not_take_cmd)) |
(package(photocraft-ui-egui) & test(=guide_cursor_tests::command_over_a_guide_takes_it_where_command_is_the_move_tool)) |
(package(photocraft-gpu) & test(=parity::documents_larger_than_the_texture_limit)) |
+1 -1
View File
@@ -1,7 +1,7 @@
//! Tests for the headless GPU backend, capability isolation, cache mutation, and CPU/GPU parity.
#[cfg(all(feature = "gpu", not(target_arch = "wasm32")))]
mod tests {
mod gpu_tests {
use std::fs;
use photocraft_codecs::decode;
+3 -3
View File
@@ -614,11 +614,11 @@ mod zoom_animation_tests {
mod display_memo_tests;
#[cfg(test)]
mod cpu_background_tests;
mod cpu_background_gpu_tests;
#[cfg(test)]
#[path = "canvas/blend_viewport_tests.rs"]
mod blend_viewport_regression;
#[path = "canvas/blend_viewport_gpu_tests.rs"]
mod blend_viewport_gpu_tests;
#[cfg(test)]
#[path = "canvas/pixel_alignment_tests.rs"]
@@ -584,5 +584,7 @@ fn draw(
}
}
#[cfg(test)]
mod gpu_tests;
#[cfg(test)]
mod tests;
@@ -0,0 +1,664 @@
//! Background full CPU redraws (#4024) on a device: the GPU tests skip when there is no adapter.
use super::*;
use serde_json::json;
struct Gpu {
harness: egui_kittest::Harness<'static, Box<PhotocraftApp>>,
observer: GpuCanvas,
}
/// The app on a real device with background jobs, or `None` without a GPU adapter.
fn gpu_app() -> Option<Gpu> {
let observer = Arc::new(std::sync::Mutex::new(None));
let observer_out = observer.clone();
let built = std::panic::catch_unwind(std::panic::AssertUnwindSafe(move || {
egui_kittest::Harness::builder()
.with_size(egui::vec2(1000.0, 700.0))
.with_pixels_per_point(1.0)
.with_max_steps(64)
.wgpu_setup(crate::gpu_canvas::wgpu_setup())
.build_eframe(move |cc| {
PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
let mut app = PhotocraftApp::with_context(cc.egui_ctx.clone(), photocraft_engine::Session::new(), Default::default());
if let Some(rs) = cc.wgpu_render_state.as_ref() {
*observer_out.lock().expect("observer") = Some(GpuCanvas::new(rs));
app.set_wgpu(rs.clone());
}
app.background_jobs = true;
app
})
}));
let Ok(harness) = built else {
eprintln!("skipping: no GPU adapter");
return None;
};
let observer = observer.lock().expect("observer").take()?;
Some(Gpu { harness, observer })
}
/// A document the wgpu compositor leaves to the CPU (knockout on its top layer, which also has
/// Blend If).
fn cpu_only_document(app: &mut PhotocraftApp, w: u32, h: u32) -> DocId {
app.run("file.new", json!({"width": w, "height": h, "background": "#336699"})).expect("new");
app.run("layer.new.layer", json!({})).expect("layer");
app.run("edit.fill", json!({"color": "#cc8844"})).expect("fill");
app.run("layer.layerStyle.blendingOptions", json!({"opacity": 60, "knockout": "shallow", "blendIf": {"channel": "gray", "underlying": [0, 10, 245, 255]}}))
.expect("blending options");
app.session.active().expect("document").doc.id
}
/// Frames until no redraw is running.
fn settle(g: &mut Gpu) {
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
loop {
g.harness.step();
if g.harness.state().redraws.is_empty() {
return;
}
assert!(std::time::Instant::now() < deadline, "the redraw didn't finish");
std::thread::sleep(std::time::Duration::from_millis(2));
}
}
/// Run the frame that starts `doc`'s redraw with its worker held before the first batch, and wait
/// until that very worker reaches the hold: the redraw runs, every block still to draw, until the
/// returned guard drops. Without it a test that needs the redraw still running at its next frame
/// races the worker: a fast machine draws the document first, and so does a slow frame (a
/// software adapter's uploads) that keeps taking blocks as they land until the last one.
fn start_held_redraw(g: &mut Gpu, doc: DocId) -> HoldRedraws {
let held = hold_redraws();
g.harness.step();
let generation = g.harness.state().redraws.get(&doc).expect("the frame started a redraw").worker_generation;
assert!(wait_for_held_redraw(g.harness.state(), doc, generation, std::time::Duration::from_secs(10)), "the redraw worker never reached the pre-batch hold");
held
}
/// The canvas texture of `doc` against the synchronous CPU refresh of the current document.
fn assert_matches_synchronous(g: &mut Gpu, doc: DocId) {
let app = g.harness.state_mut();
let d = app.session.active().expect("document").doc.clone();
let (display, _) = crate::canvas::canvas_display(app, &d, None);
let reference = doc.0 ^ (1u64 << 60);
g.observer.upload_composite(reference, &d, display.as_deref());
let (_, size, shown) = g.observer.read_texels(doc.0).expect("canvas texture");
let (_, _, want) = g.observer.read_texels(reference).expect("reference texture");
assert_eq!(size, [d.size.width, d.size.height]);
let differ = shown.iter().zip(&want).filter(|(a, b)| a != b).count();
assert_eq!(differ, 0, "{differ} texels differ from the synchronous refresh");
}
#[test]
fn a_full_cpu_refresh_draws_in_the_background_with_the_synchronous_pixels() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 2600, 1700);
// Held, so the frame's later runs can't see the redraw already finished.
let held = hold_redraws();
g.harness.step();
assert!(g.harness.state().redraws.contains_key(&doc), "the frame started a redraw instead of compositing inline");
drop(held);
settle(&mut g);
let app = g.harness.state();
assert_eq!(app.perf.last_refresh, "background");
assert!(app.perf.gpu_fallback.as_deref().is_some_and(|f| f.contains("Advanced Blending")), "{:?}", app.perf.gpu_fallback);
assert_matches_synchronous(&mut g, doc);
}
#[test]
fn an_edit_during_a_redraw_is_not_overwritten_by_blocks_drawn_before_it() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
// Hold the worker before its first batch and wait until this very worker acknowledges that
// hold: when the fill lands, all 12 blocks of this 4×3 document are still to draw by it.
// Without the hold a fast machine finishes them before the next frame, so the edit never
// races the worker and this test only checked a completed redraw; without the per-worker
// acknowledgement an edit could beat the worker to the hold, and its restarted replacement
// would satisfy the checks.
let held = hold_redraws();
let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
g.harness.step();
let generation = g.harness.state().redraws.get(&doc).expect("the frame started a redraw").worker_generation;
assert!(
wait_for_held_redraw(g.harness.state(), doc, generation, std::time::Duration::from_secs(10)),
"the redraw worker never reached the pre-batch hold; an edit would race an unstarted redraw"
);
// A corner, drawn last (farthest from the view's centre), changes on a layer of its own while
// the redraw runs: a small edit, drawn at once.
g.harness.state_mut().run("layer.new.layer", json!({})).expect("layer");
g.harness.step();
g.harness.state_mut().run("select.rect", json!({"x": 3900, "y": 2900, "width": 150, "height": 150})).expect("select");
g.harness.step();
g.harness.state_mut().run("edit.fill", json!({"color": "#22ee22"})).expect("fill");
g.harness.step();
assert_eq!(g.harness.state().perf.last_refresh, "rect", "the fill's damage was drawn synchronously");
// Still running with blocks to draw, and drawing the edited document, not the state before it.
let current = g.harness.state().session.active().expect("document").doc.clone();
let r = g.harness.state().redraws.get(&doc).expect("the redraw goes on");
assert!(r.pending.iter().any(|p| *p), "blocks are still to draw");
assert!(Arc::ptr_eq(&r.doc, &current) || *r.doc == *current, "the blocks left draw the edit");
drop(held);
settle(&mut g);
assert_matches_synchronous(&mut g, doc);
}
#[test]
fn an_edit_damaging_most_of_a_large_document_is_drawn_in_the_background_too() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 2600, 1700);
settle(&mut g);
// Filling most of the Blend If layer touches tiles all over it: the whole canvas (a fill of a
// small part damages only its own tiles, #9329).
g.harness.state_mut().run("select.rect", json!({"x": 100, "y": 100, "width": 2500, "height": 1500})).expect("select");
g.harness.step();
g.harness.state_mut().run("edit.fill", json!({"color": "#22ee22"})).expect("fill");
assert_eq!(g.harness.state().session.active().expect("document").last_damage, Some(Rect::new(0, 0, 2600, 1700)));
g.harness.step();
assert!(g.harness.state().redraws.contains_key(&doc), "not composited inline: {}", g.harness.state().perf.last_refresh);
settle(&mut g);
assert_eq!(g.harness.state().perf.last_refresh, "background");
assert_matches_synchronous(&mut g, doc);
}
#[test]
fn showing_a_hidden_layer_again_reuses_the_redraw_from_before_it_was_hidden() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 2600, 1700);
let layer = g.harness.state().session.active().and_then(|st| st.active_layer).expect("layer");
settle(&mut g);
assert_eq!(g.harness.state().perf.last_refresh, "background");
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "visible": false})).expect("hide");
settle(&mut g);
// Back to the state drawn before: its blocks come back, nothing is composited.
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "visible": true})).expect("show");
g.harness.step();
assert!(g.harness.state().redraws.is_empty(), "no redraw: {}", g.harness.state().perf.last_refresh);
assert_eq!(g.harness.state().perf.last_refresh, KEPT);
assert_matches_synchronous(&mut g, doc);
// A real change composites again. `last_refresh` is only set when that redraw finishes, so
// check that one started, then that it was a composite rather than kept blocks.
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "opacity": 0.3})).expect("opacity");
g.harness.step();
assert!(g.harness.state().redraws.contains_key(&doc), "not served from kept blocks: {}", g.harness.state().perf.last_refresh);
settle(&mut g);
assert_eq!(g.harness.state().perf.last_refresh, "background");
assert_matches_synchronous(&mut g, doc);
}
/// Memory Usage lowered while a redraw runs: the finished composite is kept within what it leaves
/// now, not what it left when the redraw began.
#[test]
fn a_redraw_finishing_after_memory_usage_drops_keeps_nothing_over_it() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
let held = start_held_redraw(&mut g, doc);
// Less than the document's own pixels: nothing is left for kept composites.
g.harness.state_mut().session.edit_prefs(|p| p.performance.memory_usage_mb = 1);
drop(held);
settle(&mut g);
assert!(g.harness.state().kept.entries.is_empty(), "a composite was kept over the current cap");
}
/// Color Settings › "Blend Text Colors Using Gamma" isn't part of the document, but type layers
/// composite with it: a state drawn before it changed is composited again, not uploaded from
/// blocks drawn with the old gamma. Only the session's setting changes here, not the process-wide
/// gamma compose reads, so tests compositing type layers at the same time aren't affected.
#[test]
fn a_state_drawn_before_the_text_gamma_changed_is_composited_again() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 2600, 1700);
let layer = g.harness.state().session.active().and_then(|st| st.active_layer).expect("layer");
settle(&mut g);
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "visible": false})).expect("hide");
settle(&mut g);
g.harness.state_mut().session.color.settings.blend_text_gamma = 1.0;
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "visible": true})).expect("show");
g.harness.step();
assert!(g.harness.state().redraws.contains_key(&doc), "served from blocks of the old gamma: {}", g.harness.state().perf.last_refresh);
settle(&mut g);
assert_eq!(g.harness.state().perf.last_refresh, "background");
assert_matches_synchronous(&mut g, doc);
}
/// The text gamma changing while a redraw runs: its blocks were drawn with both, so it isn't kept.
#[test]
fn a_redraw_across_a_text_gamma_change_is_not_kept() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
let held = start_held_redraw(&mut g, doc);
g.harness.state_mut().session.color.settings.blend_text_gamma = 1.0;
drop(held);
settle(&mut g);
assert!(g.harness.state().kept.entries.is_empty(), "a composite of two gammas was kept");
}
/// Changed and changed back while a redraw runs: blocks drawn in between still mix both.
#[test]
fn a_redraw_across_a_text_gamma_change_and_back_is_not_kept() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
let gamma = g.harness.state().session.color.settings.blend_text_gamma;
let held = start_held_redraw(&mut g, doc);
g.harness.state_mut().session.color.settings.blend_text_gamma = 1.0;
g.harness.step();
g.harness.state_mut().session.color.settings.blend_text_gamma = gamma;
assert!(g.harness.state().redraws.contains_key(&doc), "the redraw finished before the change back");
drop(held);
settle(&mut g);
assert!(g.harness.state().kept.entries.is_empty(), "a composite of two gammas was kept");
}
/// The same while another document is shown: its redraw goes on without being polled, so the
/// change is seen every frame, not only when it shows again.
#[test]
fn a_hidden_documents_redraw_across_a_text_gamma_change_and_back_is_not_kept() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
let gamma = g.harness.state().session.color.settings.blend_text_gamma;
let held = start_held_redraw(&mut g, doc);
g.harness.state_mut().run("file.new", json!({"width": 64, "height": 64})).expect("another document");
g.harness.step();
g.harness.state_mut().session.color.settings.blend_text_gamma = 1.0;
g.harness.step();
g.harness.state_mut().session.color.settings.blend_text_gamma = gamma;
g.harness.step();
assert!(g.harness.state().redraws.contains_key(&doc), "the hidden document's redraw stopped");
let i = g.harness.state().session.documents().iter().position(|st| st.doc.id == doc).expect("document");
g.harness.state_mut().session.set_active(i);
drop(held);
settle(&mut g);
assert!(g.harness.state().kept.entries.iter().all(|k| k.id != doc), "a composite of two gammas was kept");
}
/// Memory Usage lowered with no redraw running: the kept composites go at the next frame, not
/// only when the next redraw starts.
#[test]
fn kept_composites_go_when_memory_usage_drops_between_redraws() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
cpu_only_document(g.harness.state_mut(), 2600, 1700);
settle(&mut g);
assert!(!g.harness.state().kept.entries.is_empty(), "the finished redraw is kept");
g.harness.state_mut().session.edit_prefs(|p| p.performance.memory_usage_mb = 1);
g.harness.step();
assert!(g.harness.state().redraws.is_empty());
assert!(g.harness.state().kept.entries.is_empty(), "kept over the current cap");
}
/// An edit too small for a background redraw that grows the document past what Memory Usage
/// leaves: the kept composite goes at the next frame. The test holds the kept state itself, so
/// only the cap can drop it, not History letting go of the state.
#[test]
fn kept_composites_go_when_a_small_edit_grows_the_document_past_the_cap() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
cpu_only_document(g.harness.state_mut(), 2600, 1700);
settle(&mut g);
let app = g.harness.state_mut();
let st = app.session.active().expect("document");
let held = st.doc.clone();
let (used, kept) = (st.memory_bytes() as u64, app.kept.bytes());
assert!(kept > 0, "the finished redraw is kept");
// Room for the kept composite and 2-3 MB more.
let mb = (used + kept).div_ceil(1 << 20) + 2;
app.session.edit_prefs(|p| p.performance.memory_usage_mb = mb as _);
g.harness.step();
assert_eq!(g.harness.state().kept.entries.len(), 1, "still within the cap");
// 2 MP of new pixels (8 MB): under the size that redraws in the background.
for (cmd, p) in
[("layer.new.layer", json!({})), ("select.rect", json!({"x": 0, "y": 0, "width": 2000, "height": 1000})), ("edit.fill", json!({"color": "#cc2244"}))]
{
g.harness.state_mut().run(cmd, p).expect(cmd);
g.harness.step();
assert!(g.harness.state().redraws.is_empty(), "{cmd} redrew in the background");
}
assert!(g.harness.state().kept.entries.is_empty(), "kept over the cap after the edit");
drop(held);
}
/// The same for an older kept composite of another document: every kept document's edits count,
/// not only the newest one's.
#[test]
fn an_older_kept_composite_goes_when_its_document_grows_past_the_cap() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let a = cpu_only_document(g.harness.state_mut(), 2600, 1700);
settle(&mut g);
let b = cpu_only_document(g.harness.state_mut(), 2600, 1700);
settle(&mut g);
let app = g.harness.state_mut();
let held: Vec<_> = app.session.documents().iter().map(|st| st.doc.clone()).collect();
assert_eq!(app.kept.entries.iter().map(|k| k.id).collect::<Vec<_>>(), [b, a], "both kept, the second newest");
let used = app.session.documents().iter().map(|st| st.memory_bytes() as u64).max().unwrap_or(0);
let mb = (used + app.kept.bytes()).div_ceil(1 << 20) + 2;
app.session.edit_prefs(|p| p.performance.memory_usage_mb = mb as _);
let i = app.session.documents().iter().position(|st| st.doc.id == a).expect("document");
app.session.set_active(i);
g.harness.step();
assert_eq!(g.harness.state().kept.entries.len(), 2, "still within the cap");
for (cmd, p) in
[("layer.new.layer", json!({})), ("select.rect", json!({"x": 0, "y": 0, "width": 2000, "height": 1000})), ("edit.fill", json!({"color": "#cc2244"}))]
{
g.harness.state_mut().run(cmd, p).expect(cmd);
g.harness.step();
assert!(g.harness.state().redraws.is_empty(), "{cmd} redrew in the background");
}
assert!(g.harness.state().kept.entries.len() < 2, "kept over the cap after the older document grew");
drop(held);
}
/// A kept state History no longer holds goes at the next frame: its texels aren't held until
/// some later redraw.
#[test]
fn a_kept_state_history_purged_goes_at_the_next_frame() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
cpu_only_document(g.harness.state_mut(), 2600, 1700);
let layer = g.harness.state().session.active().and_then(|st| st.active_layer).expect("layer");
settle(&mut g);
// Hidden, the document is drawn on the GPU: the kept state is the one before, in History.
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "visible": false})).expect("hide");
settle(&mut g);
assert_eq!(g.harness.state().kept.entries.len(), 1, "the state before hiding is kept");
g.harness.state_mut().run("edit.purge.histories", json!({})).expect("purge");
g.harness.step();
assert!(g.harness.state().redraws.is_empty());
assert!(g.harness.state().kept.entries.is_empty(), "the purged state's composite is still held");
}
#[test]
fn closing_the_document_stops_its_redraw() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
// Held: the close lands while the redraw runs, and a cancelled worker leaves the hold.
let _held = start_held_redraw(&mut g, doc);
g.harness.state_mut().run("file.close", json!({"save": false})).expect("close");
g.harness.step();
assert!(g.harness.state().redraws.is_empty());
}
#[test]
fn hiding_a_large_layer_over_the_gpu_budget_redraws_in_the_background() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
// A layer covering most, but not all, of the document: hiding it damages a large rect that
// isn't the whole canvas.
let app = g.harness.state_mut();
app.run("file.new", json!({"width": 5000, "height": 2000, "background": "#336699"})).expect("new");
app.run("layer.new.layer", json!({})).expect("layer");
app.run("select.rect", json!({"x": 0, "y": 0, "width": 4800, "height": 1800})).expect("select");
app.run("edit.fill", json!({"color": "#cc8844"})).expect("fill");
app.run("select.deselect", json!({})).expect("deselect");
let (doc, layer) = {
let st = app.session.active().expect("document");
(st.doc.id, st.active_layer.expect("layer"))
};
settle(&mut g);
assert!(g.harness.state().perf.last_refresh.starts_with("gpu"), "the document fits the GPU: {}", g.harness.state().perf.last_refresh);
// A budget the pages of one 2048 px page cell fit (about 33 MB here) but not those of the
// whole width (80 MB), as on a multi-gigabyte PSB. Damage refreshes keep it: `gpu_budget`
// recomputes it for full ones only. A small edit still draws on the GPU at once.
g.harness.state_mut().run("layer.new.layer", json!({})).expect("layer");
g.harness.step();
g.harness.state_mut().run("select.rect", json!({"x": 100, "y": 100, "width": 64, "height": 64})).expect("select");
g.harness.step();
g.observer.set_memory_budget(48 << 20);
g.harness.state_mut().run("edit.fill", json!({"color": "#22ee22"})).expect("fill");
g.harness.step();
assert_eq!(g.harness.state().perf.last_refresh, "gpu-rect", "{:?}", g.harness.state().perf.gpu_fallback);
g.harness.state_mut().run("select.deselect", json!({})).expect("deselect");
g.harness.step();
assert!(g.harness.state().redraws.is_empty());
g.observer.set_memory_budget(48 << 20);
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "visible": false})).expect("hide");
let damage = g.harness.state().session.active().expect("document").last_damage.expect("damage");
assert!(damage != Rect::new(0, 0, 5000, 2000) && damage.width() as u64 * damage.height() as u64 >= crate::gpu_canvas::DEFER_PX, "{damage:?}");
g.harness.step();
assert!(g.harness.state().redraws.contains_key(&doc), "not composited inline: {}", g.harness.state().perf.last_refresh);
settle(&mut g);
assert_eq!(g.harness.state().perf.last_refresh, "background");
let app = g.harness.state();
assert!(matches!(app.render_path.current(doc.0), Some(crate::render_path::CpuReason::OverBudget { .. })), "{:?}", app.perf.gpu_fallback);
assert_matches_synchronous(&mut g, doc);
}
/// The active document's render path: its reason's kind.
fn render_path_of(g: &Gpu) -> Option<&'static str> {
let app = g.harness.state();
let doc = app.session.active().expect("document").doc.id.0;
app.render_path.current(doc).map(crate::render_path::CpuReason::kind)
}
/// On the GPU canvas: no reason, or only a software adapter's (CI's runners have one).
fn on_gpu_canvas(g: &Gpu) -> bool {
matches!(render_path_of(g), None | Some("softwareAdapter"))
}
#[test]
fn advanced_blending_fallback_is_shown_in_the_status_bar() {
use egui_kittest::kittest::Queryable;
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
cpu_only_document(g.harness.state_mut(), 800, 600);
g.harness.step();
settle(&mut g);
g.harness.run_steps(2);
assert_eq!(render_path_of(&g), Some("unsupported"));
// PLAN: assumes the status bar's CPU Rendering message exposes its tooltip text to kittest after a hover (panels-w19).
g.harness.get_by_label("CPU Rendering").hover();
g.harness.run_steps(40);
assert!(g.harness.query_by_label_contains("Advanced Blending").is_some(), "the tooltip names the cause");
}
#[test]
fn completed_compositor_build_refreshes_an_unchanged_cached_document() {
let _gpu = photocraft_testkit::gpu_lock();
for success in [true, false] {
let Some(mut g) = gpu_app() else { return };
let gpu = g.harness.state().gpu.as_ref().expect("GPU canvas").clone();
gpu.simulate_compositor_build();
g.harness.state_mut().run("file.new", json!({"width": 400, "height": 300, "background": "#336699"})).expect("new");
g.harness.step();
settle(&mut g);
let doc = g.harness.state().session.active().expect("document").doc.id;
let revision = g.harness.state().session.active().expect("document").revision;
assert_eq!(render_path_of(&g), Some("compositorBuilding"));
assert!(gpu.simulate_compositor_completion(success), "test compositor must build");
g.harness.step();
settle(&mut g);
g.harness.run_steps(2);
assert_eq!(g.harness.state().session.active().expect("document").revision, revision);
if success {
assert!(on_gpu_canvas(&g), "successful build should replace the temporary reason: {:?}", render_path_of(&g));
} else {
assert_eq!(render_path_of(&g), Some("compositorBuild"));
assert!(g.harness.state().perf.gpu_fallback.as_deref().is_some_and(|s| s.contains("simulated build failure")));
assert_matches_synchronous(&mut g, doc);
}
}
}
#[test]
fn a_canvas_over_the_texture_budget_records_its_reason() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
// The app's canvas, not the observer: each `GpuCanvas::new` shares a new budget.
g.harness.state().gpu.as_ref().expect("gpu canvas").set_canvas_budget(1);
g.harness.state_mut().run("file.new", json!({"width": 400, "height": 300, "background": "#336699"})).expect("new");
g.harness.run_steps(3);
assert_eq!(render_path_of(&g), Some("canvasTooLarge"));
let doc = g.harness.state().session.active().expect("document").doc.id.0;
assert_eq!(g.harness.state().render_path.history().filter(|c| c.doc == doc).count(), 1, "once, not every frame");
}
/// Frames until the active document's viewport pages are all rendered and uploaded.
fn settle_pages(g: &mut Gpu) {
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
loop {
g.harness.step();
let app = g.harness.state();
let id = app.session.active().expect("document").doc.id;
if app.streams.get(&id).is_some_and(|s| !s.busy() && s.stats.wanted > 0 && s.stats.ready == s.stats.wanted) {
return;
}
assert!(std::time::Instant::now() < deadline, "the viewport pages didn't finish");
std::thread::sleep(std::time::Duration::from_millis(2));
}
}
/// The screen pixel at the window's centre.
fn centre_pixel(g: &mut Gpu) -> [u8; 4] {
let img = g.harness.render().expect("render");
let p = img.get_pixel(img.width() / 2, img.height() / 2);
p.0
}
/// #5332: a document whose texture set doesn't fit the canvas budget stays on the GPU canvas,
/// drawn from the pages in view instead of the CPU canvas, with the same pixels; an edit
/// re-renders only the pages, and closing it frees them.
#[test]
fn a_canvas_over_the_texture_budget_draws_its_viewport_pages_on_the_gpu() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
g.harness.state_mut().run("file.new", json!({"width": 3000, "height": 2000, "background": "#336699"})).expect("new");
g.harness.run_steps(3);
assert!(on_gpu_canvas(&g));
let whole = centre_pixel(&mut g);
let gpu = g.harness.state().gpu.clone().expect("gpu canvas");
let doc = g.harness.state().session.active().expect("document").doc.clone();
let key = crate::canvas::viewport_pages::stream_key(doc.id.0);
// Room for pages (half the budget), not for the document's texture set.
let (set, _) = gpu.canvas_fit(&doc).expect("fit");
gpu.set_canvas_budget(set - 1);
settle_pages(&mut g);
assert!(on_gpu_canvas(&g), "{:?}", render_path_of(&g));
assert!(gpu.texture_info(doc.id.0).is_none(), "no texture set");
let (pages, bytes) = gpu.pages(key);
let stats = g.harness.state().streams[&doc.id].stats.clone();
assert_eq!(pages.len(), stats.resident);
assert!(stats.wanted > 0 && stats.last_error.is_none(), "{stats:?}");
assert!(bytes <= (set - 1) / 2, "pages stay within half the budget: {bytes}");
let shown = centre_pixel(&mut g);
assert!((0..3).all(|i| shown[i].abs_diff(whole[i]) <= 2), "pages {shown:?}, texture set {whole:?}");
// An edit re-renders the pages it reaches.
let uploads = stats.uploads;
g.harness.state_mut().run("edit.fill", json!({"color": "#cc8844"})).expect("fill");
settle_pages(&mut g);
let stats = g.harness.state().streams[&doc.id].stats.clone();
assert!(stats.dirtied > 0 && stats.uploads > uploads, "{stats:?}");
let filled = centre_pixel(&mut g);
assert!(filled[0] > 0xb0 && filled[2] < 0x60, "the fill is shown: {filled:?}");
// A small edit re-renders only the part of each page it reaches, into the page held.
let (held, partial) = (gpu.pages(key).0.len(), stats.partial);
// (A frame between the steps, as in use: the edit's damage is known one revision at a time.)
g.harness.state_mut().run("select.rect", json!({"x": 1400, "y": 900, "width": 200, "height": 200})).expect("select");
settle_pages(&mut g);
g.harness.state_mut().run("edit.fill", json!({"color": "#22aa22"})).expect("small fill");
settle_pages(&mut g);
let stats = g.harness.state().streams[&doc.id].stats.clone();
assert!(stats.partial > partial, "{stats:?}");
assert_eq!(gpu.pages(key).0.len(), held, "no new page textures");
// Just its square is shown: 200 px at about 20% zoom, some 40 screen pixels a side.
let img = g.harness.render().expect("render");
let green = img.pixels().filter(|p| p.0[1] > 0x90 && p.0[0] < 0x50 && p.0[2] < 0x50).count();
assert!((1000..2500).contains(&green), "the small fill is shown: {green} pixels");
// A budget too small for one page draws it on the CPU canvas, as before.
gpu.set_canvas_budget(1);
g.harness.run_steps(3);
assert_eq!(render_path_of(&g), Some("canvasTooLarge"));
// Its pages and their work are freed meanwhile (#5332 review).
assert!(gpu.pages(key).0.is_empty(), "pages freed");
assert!(!g.harness.state().streams.contains_key(&doc.id), "stream dropped");
gpu.set_canvas_budget(set - 1);
settle_pages(&mut g);
// Closing the document cancels its work and frees its pages.
g.harness.state_mut().run("file.close", json!({"save": false})).expect("close");
g.harness.run_steps(3);
assert!(g.harness.state().streams.is_empty());
assert!(gpu.pages(key).0.is_empty());
}
/// Runs a Window › Arrange command, as its menu item does, and lets the layout settle.
fn arrange(g: &mut Gpu, command: &str) {
let ctx = g.harness.ctx.clone();
crate::menus::invoke(g.harness.state_mut(), &ctx, command, json!({})).expect("arrange");
g.harness.run_steps(3);
}
/// #5332 review: the open documents share one texture budget rather than each having all of
/// it. A document alone on screen keeps the whole budget; one in a background tab gives its
/// textures up when the shown one needs the room; and documents shown side by side split it,
/// a document over its share drawing from viewport pages.
#[test]
fn open_documents_share_one_texture_budget_with_the_shown_ones_first() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let gpu = g.harness.state().gpu.clone().expect("gpu canvas");
let new = |g: &mut Gpu| {
g.harness.state_mut().run("file.new", json!({"width": 3000, "height": 2000, "background": "#336699"})).expect("new");
g.harness.run_steps(3);
assert!(on_gpu_canvas(g), "{:?}", render_path_of(g));
g.harness.state().session.active().expect("document").doc.clone()
};
let a = new(&mut g);
let (set, _) = gpu.canvas_fit(&a).expect("fit");
// Room for one texture set and a half: a document alone on screen has all of it.
let budget = set + set / 2;
gpu.set_canvas_budget(budget);
assert_eq!(gpu.canvas_fit(&a), Some((set, budget)), "alone, the whole budget");
assert!(gpu.texture_info(a.id.0).is_some());
// A second tab: the shown document's texture set takes the room of the background one's.
let b = new(&mut g);
assert_eq!(gpu.canvas_fit(&b), Some((set, budget)));
assert!(gpu.texture_info(b.id.0).is_some());
assert!(gpu.texture_info(a.id.0).is_none(), "the background document's textures are freed");
// Back to the first tab: it gets its texture set back and the other gives its up.
g.harness.state_mut().session.set_active(0);
g.harness.run_steps(3);
assert!(on_gpu_canvas(&g), "{:?}", render_path_of(&g));
assert!(gpu.texture_info(a.id.0).is_some());
assert!(gpu.texture_info(b.id.0).is_none());
// Side by side, they split the budget: neither set fits its half, so both draw from pages.
arrange(&mut g, "window.arrange.twoUpVertical");
assert_eq!(gpu.canvas_fit(&a), Some((set, budget / 2)));
assert_eq!(gpu.canvas_fit(&b), Some((set, budget - budget / 2)));
settle_pages(&mut g);
assert!(on_gpu_canvas(&g), "{:?}", render_path_of(&g));
let streams = &g.harness.state().streams;
assert!(streams.contains_key(&a.id) && streams.contains_key(&b.id), "both on pages");
assert!(gpu.texture_info(a.id.0).is_none() && gpu.texture_info(b.id.0).is_none());
// Switching between them re-splits nothing: no page set is dropped.
let held = gpu.pages(crate::canvas::viewport_pages::stream_key(a.id.0)).0;
g.harness.state_mut().session.set_active(1);
g.harness.run_steps(3);
assert_eq!(gpu.canvas_fit(&a), Some((set, budget / 2)));
assert_eq!(gpu.pages(crate::canvas::viewport_pages::stream_key(a.id.0)).0, held, "no churn on a switch");
// Back to tabs: the shown document has the whole budget, and its texture set, again.
arrange(&mut g, "window.arrange.consolidateAllToTabs");
assert_eq!(gpu.canvas_fit(&b), Some((set, budget)));
assert!(on_gpu_canvas(&g), "{:?}", render_path_of(&g));
assert!(gpu.texture_info(b.id.0).is_some());
}
#[test]
fn a_flipped_view_records_why_it_draws_on_the_cpu() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
g.harness.state_mut().run("file.new", json!({"width": 400, "height": 300, "background": "#336699"})).expect("new");
g.harness.run_steps(3);
assert!(on_gpu_canvas(&g));
g.harness.state_mut().ui.view.flip_horizontal = true;
g.harness.run_steps(3);
assert_eq!(render_path_of(&g), Some("viewTransform"));
g.harness.state_mut().ui.view.flip_horizontal = false;
g.harness.run_steps(3);
assert!(on_gpu_canvas(&g), "back on the GPU");
}
@@ -1,7 +1,6 @@
//! Background full CPU redraws (#4024). The GPU tests skip when there is no adapter.
//! Background full CPU redraws (#4024): block order and the kept composites. The redraws on a device are in `gpu_tests`.
use super::*;
use serde_json::json;
#[test]
fn blocks_cover_the_document_once() {
@@ -119,663 +118,3 @@ fn kept_composites_come_back_only_for_the_exact_state_and_stay_bounded() {
cache.trim(u64::MAX);
assert!(cache.entries.is_empty());
}
struct Gpu {
harness: egui_kittest::Harness<'static, Box<PhotocraftApp>>,
observer: GpuCanvas,
}
/// The app on a real device with background jobs, or `None` without a GPU adapter.
fn gpu_app() -> Option<Gpu> {
let observer = Arc::new(std::sync::Mutex::new(None));
let observer_out = observer.clone();
let built = std::panic::catch_unwind(std::panic::AssertUnwindSafe(move || {
egui_kittest::Harness::builder()
.with_size(egui::vec2(1000.0, 700.0))
.with_pixels_per_point(1.0)
.with_max_steps(64)
.wgpu_setup(crate::gpu_canvas::wgpu_setup())
.build_eframe(move |cc| {
PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
let mut app = PhotocraftApp::with_context(cc.egui_ctx.clone(), photocraft_engine::Session::new(), Default::default());
if let Some(rs) = cc.wgpu_render_state.as_ref() {
*observer_out.lock().expect("observer") = Some(GpuCanvas::new(rs));
app.set_wgpu(rs.clone());
}
app.background_jobs = true;
app
})
}));
let Ok(harness) = built else {
eprintln!("skipping: no GPU adapter");
return None;
};
let observer = observer.lock().expect("observer").take()?;
Some(Gpu { harness, observer })
}
/// A document the wgpu compositor leaves to the CPU (knockout on its top layer, which also has
/// Blend If).
fn cpu_only_document(app: &mut PhotocraftApp, w: u32, h: u32) -> DocId {
app.run("file.new", json!({"width": w, "height": h, "background": "#336699"})).expect("new");
app.run("layer.new.layer", json!({})).expect("layer");
app.run("edit.fill", json!({"color": "#cc8844"})).expect("fill");
app.run("layer.layerStyle.blendingOptions", json!({"opacity": 60, "knockout": "shallow", "blendIf": {"channel": "gray", "underlying": [0, 10, 245, 255]}}))
.expect("blending options");
app.session.active().expect("document").doc.id
}
/// Frames until no redraw is running.
fn settle(g: &mut Gpu) {
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
loop {
g.harness.step();
if g.harness.state().redraws.is_empty() {
return;
}
assert!(std::time::Instant::now() < deadline, "the redraw didn't finish");
std::thread::sleep(std::time::Duration::from_millis(2));
}
}
/// Run the frame that starts `doc`'s redraw with its worker held before the first batch, and wait
/// until that very worker reaches the hold: the redraw runs, every block still to draw, until the
/// returned guard drops. Without it a test that needs the redraw still running at its next frame
/// races the worker: a fast machine draws the document first, and so does a slow frame (a
/// software adapter's uploads) that keeps taking blocks as they land until the last one.
fn start_held_redraw(g: &mut Gpu, doc: DocId) -> HoldRedraws {
let held = hold_redraws();
g.harness.step();
let generation = g.harness.state().redraws.get(&doc).expect("the frame started a redraw").worker_generation;
assert!(wait_for_held_redraw(g.harness.state(), doc, generation, std::time::Duration::from_secs(10)), "the redraw worker never reached the pre-batch hold");
held
}
/// The canvas texture of `doc` against the synchronous CPU refresh of the current document.
fn assert_matches_synchronous(g: &mut Gpu, doc: DocId) {
let app = g.harness.state_mut();
let d = app.session.active().expect("document").doc.clone();
let (display, _) = crate::canvas::canvas_display(app, &d, None);
let reference = doc.0 ^ (1u64 << 60);
g.observer.upload_composite(reference, &d, display.as_deref());
let (_, size, shown) = g.observer.read_texels(doc.0).expect("canvas texture");
let (_, _, want) = g.observer.read_texels(reference).expect("reference texture");
assert_eq!(size, [d.size.width, d.size.height]);
let differ = shown.iter().zip(&want).filter(|(a, b)| a != b).count();
assert_eq!(differ, 0, "{differ} texels differ from the synchronous refresh");
}
#[test]
fn a_full_cpu_refresh_draws_in_the_background_with_the_synchronous_pixels() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 2600, 1700);
// Held, so the frame's later runs can't see the redraw already finished.
let held = hold_redraws();
g.harness.step();
assert!(g.harness.state().redraws.contains_key(&doc), "the frame started a redraw instead of compositing inline");
drop(held);
settle(&mut g);
let app = g.harness.state();
assert_eq!(app.perf.last_refresh, "background");
assert!(app.perf.gpu_fallback.as_deref().is_some_and(|f| f.contains("Advanced Blending")), "{:?}", app.perf.gpu_fallback);
assert_matches_synchronous(&mut g, doc);
}
#[test]
fn an_edit_during_a_redraw_is_not_overwritten_by_blocks_drawn_before_it() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
// Hold the worker before its first batch and wait until this very worker acknowledges that
// hold: when the fill lands, all 12 blocks of this 4×3 document are still to draw by it.
// Without the hold a fast machine finishes them before the next frame, so the edit never
// races the worker and this test only checked a completed redraw; without the per-worker
// acknowledgement an edit could beat the worker to the hold, and its restarted replacement
// would satisfy the checks.
let held = hold_redraws();
let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
g.harness.step();
let generation = g.harness.state().redraws.get(&doc).expect("the frame started a redraw").worker_generation;
assert!(
wait_for_held_redraw(g.harness.state(), doc, generation, std::time::Duration::from_secs(10)),
"the redraw worker never reached the pre-batch hold; an edit would race an unstarted redraw"
);
// A corner, drawn last (farthest from the view's centre), changes on a layer of its own while
// the redraw runs: a small edit, drawn at once.
g.harness.state_mut().run("layer.new.layer", json!({})).expect("layer");
g.harness.step();
g.harness.state_mut().run("select.rect", json!({"x": 3900, "y": 2900, "width": 150, "height": 150})).expect("select");
g.harness.step();
g.harness.state_mut().run("edit.fill", json!({"color": "#22ee22"})).expect("fill");
g.harness.step();
assert_eq!(g.harness.state().perf.last_refresh, "rect", "the fill's damage was drawn synchronously");
// Still running with blocks to draw, and drawing the edited document, not the state before it.
let current = g.harness.state().session.active().expect("document").doc.clone();
let r = g.harness.state().redraws.get(&doc).expect("the redraw goes on");
assert!(r.pending.iter().any(|p| *p), "blocks are still to draw");
assert!(Arc::ptr_eq(&r.doc, &current) || *r.doc == *current, "the blocks left draw the edit");
drop(held);
settle(&mut g);
assert_matches_synchronous(&mut g, doc);
}
#[test]
fn an_edit_damaging_most_of_a_large_document_is_drawn_in_the_background_too() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 2600, 1700);
settle(&mut g);
// Filling most of the Blend If layer touches tiles all over it: the whole canvas (a fill of a
// small part damages only its own tiles, #9329).
g.harness.state_mut().run("select.rect", json!({"x": 100, "y": 100, "width": 2500, "height": 1500})).expect("select");
g.harness.step();
g.harness.state_mut().run("edit.fill", json!({"color": "#22ee22"})).expect("fill");
assert_eq!(g.harness.state().session.active().expect("document").last_damage, Some(Rect::new(0, 0, 2600, 1700)));
g.harness.step();
assert!(g.harness.state().redraws.contains_key(&doc), "not composited inline: {}", g.harness.state().perf.last_refresh);
settle(&mut g);
assert_eq!(g.harness.state().perf.last_refresh, "background");
assert_matches_synchronous(&mut g, doc);
}
#[test]
fn showing_a_hidden_layer_again_reuses_the_redraw_from_before_it_was_hidden() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 2600, 1700);
let layer = g.harness.state().session.active().and_then(|st| st.active_layer).expect("layer");
settle(&mut g);
assert_eq!(g.harness.state().perf.last_refresh, "background");
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "visible": false})).expect("hide");
settle(&mut g);
// Back to the state drawn before: its blocks come back, nothing is composited.
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "visible": true})).expect("show");
g.harness.step();
assert!(g.harness.state().redraws.is_empty(), "no redraw: {}", g.harness.state().perf.last_refresh);
assert_eq!(g.harness.state().perf.last_refresh, KEPT);
assert_matches_synchronous(&mut g, doc);
// A real change composites again. `last_refresh` is only set when that redraw finishes, so
// check that one started, then that it was a composite rather than kept blocks.
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "opacity": 0.3})).expect("opacity");
g.harness.step();
assert!(g.harness.state().redraws.contains_key(&doc), "not served from kept blocks: {}", g.harness.state().perf.last_refresh);
settle(&mut g);
assert_eq!(g.harness.state().perf.last_refresh, "background");
assert_matches_synchronous(&mut g, doc);
}
/// Memory Usage lowered while a redraw runs: the finished composite is kept within what it leaves
/// now, not what it left when the redraw began.
#[test]
fn a_redraw_finishing_after_memory_usage_drops_keeps_nothing_over_it() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
let held = start_held_redraw(&mut g, doc);
// Less than the document's own pixels: nothing is left for kept composites.
g.harness.state_mut().session.edit_prefs(|p| p.performance.memory_usage_mb = 1);
drop(held);
settle(&mut g);
assert!(g.harness.state().kept.entries.is_empty(), "a composite was kept over the current cap");
}
/// Color Settings › "Blend Text Colors Using Gamma" isn't part of the document, but type layers
/// composite with it: a state drawn before it changed is composited again, not uploaded from
/// blocks drawn with the old gamma. Only the session's setting changes here, not the process-wide
/// gamma compose reads, so tests compositing type layers at the same time aren't affected.
#[test]
fn a_state_drawn_before_the_text_gamma_changed_is_composited_again() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 2600, 1700);
let layer = g.harness.state().session.active().and_then(|st| st.active_layer).expect("layer");
settle(&mut g);
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "visible": false})).expect("hide");
settle(&mut g);
g.harness.state_mut().session.color.settings.blend_text_gamma = 1.0;
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "visible": true})).expect("show");
g.harness.step();
assert!(g.harness.state().redraws.contains_key(&doc), "served from blocks of the old gamma: {}", g.harness.state().perf.last_refresh);
settle(&mut g);
assert_eq!(g.harness.state().perf.last_refresh, "background");
assert_matches_synchronous(&mut g, doc);
}
/// The text gamma changing while a redraw runs: its blocks were drawn with both, so it isn't kept.
#[test]
fn a_redraw_across_a_text_gamma_change_is_not_kept() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
let held = start_held_redraw(&mut g, doc);
g.harness.state_mut().session.color.settings.blend_text_gamma = 1.0;
drop(held);
settle(&mut g);
assert!(g.harness.state().kept.entries.is_empty(), "a composite of two gammas was kept");
}
/// Changed and changed back while a redraw runs: blocks drawn in between still mix both.
#[test]
fn a_redraw_across_a_text_gamma_change_and_back_is_not_kept() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
let gamma = g.harness.state().session.color.settings.blend_text_gamma;
let held = start_held_redraw(&mut g, doc);
g.harness.state_mut().session.color.settings.blend_text_gamma = 1.0;
g.harness.step();
g.harness.state_mut().session.color.settings.blend_text_gamma = gamma;
assert!(g.harness.state().redraws.contains_key(&doc), "the redraw finished before the change back");
drop(held);
settle(&mut g);
assert!(g.harness.state().kept.entries.is_empty(), "a composite of two gammas was kept");
}
/// The same while another document is shown: its redraw goes on without being polled, so the
/// change is seen every frame, not only when it shows again.
#[test]
fn a_hidden_documents_redraw_across_a_text_gamma_change_and_back_is_not_kept() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
let gamma = g.harness.state().session.color.settings.blend_text_gamma;
let held = start_held_redraw(&mut g, doc);
g.harness.state_mut().run("file.new", json!({"width": 64, "height": 64})).expect("another document");
g.harness.step();
g.harness.state_mut().session.color.settings.blend_text_gamma = 1.0;
g.harness.step();
g.harness.state_mut().session.color.settings.blend_text_gamma = gamma;
g.harness.step();
assert!(g.harness.state().redraws.contains_key(&doc), "the hidden document's redraw stopped");
let i = g.harness.state().session.documents().iter().position(|st| st.doc.id == doc).expect("document");
g.harness.state_mut().session.set_active(i);
drop(held);
settle(&mut g);
assert!(g.harness.state().kept.entries.iter().all(|k| k.id != doc), "a composite of two gammas was kept");
}
/// Memory Usage lowered with no redraw running: the kept composites go at the next frame, not
/// only when the next redraw starts.
#[test]
fn kept_composites_go_when_memory_usage_drops_between_redraws() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
cpu_only_document(g.harness.state_mut(), 2600, 1700);
settle(&mut g);
assert!(!g.harness.state().kept.entries.is_empty(), "the finished redraw is kept");
g.harness.state_mut().session.edit_prefs(|p| p.performance.memory_usage_mb = 1);
g.harness.step();
assert!(g.harness.state().redraws.is_empty());
assert!(g.harness.state().kept.entries.is_empty(), "kept over the current cap");
}
/// An edit too small for a background redraw that grows the document past what Memory Usage
/// leaves: the kept composite goes at the next frame. The test holds the kept state itself, so
/// only the cap can drop it, not History letting go of the state.
#[test]
fn kept_composites_go_when_a_small_edit_grows_the_document_past_the_cap() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
cpu_only_document(g.harness.state_mut(), 2600, 1700);
settle(&mut g);
let app = g.harness.state_mut();
let st = app.session.active().expect("document");
let held = st.doc.clone();
let (used, kept) = (st.memory_bytes() as u64, app.kept.bytes());
assert!(kept > 0, "the finished redraw is kept");
// Room for the kept composite and 2-3 MB more.
let mb = (used + kept).div_ceil(1 << 20) + 2;
app.session.edit_prefs(|p| p.performance.memory_usage_mb = mb as _);
g.harness.step();
assert_eq!(g.harness.state().kept.entries.len(), 1, "still within the cap");
// 2 MP of new pixels (8 MB): under the size that redraws in the background.
for (cmd, p) in
[("layer.new.layer", json!({})), ("select.rect", json!({"x": 0, "y": 0, "width": 2000, "height": 1000})), ("edit.fill", json!({"color": "#cc2244"}))]
{
g.harness.state_mut().run(cmd, p).expect(cmd);
g.harness.step();
assert!(g.harness.state().redraws.is_empty(), "{cmd} redrew in the background");
}
assert!(g.harness.state().kept.entries.is_empty(), "kept over the cap after the edit");
drop(held);
}
/// The same for an older kept composite of another document: every kept document's edits count,
/// not only the newest one's.
#[test]
fn an_older_kept_composite_goes_when_its_document_grows_past_the_cap() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let a = cpu_only_document(g.harness.state_mut(), 2600, 1700);
settle(&mut g);
let b = cpu_only_document(g.harness.state_mut(), 2600, 1700);
settle(&mut g);
let app = g.harness.state_mut();
let held: Vec<_> = app.session.documents().iter().map(|st| st.doc.clone()).collect();
assert_eq!(app.kept.entries.iter().map(|k| k.id).collect::<Vec<_>>(), [b, a], "both kept, the second newest");
let used = app.session.documents().iter().map(|st| st.memory_bytes() as u64).max().unwrap_or(0);
let mb = (used + app.kept.bytes()).div_ceil(1 << 20) + 2;
app.session.edit_prefs(|p| p.performance.memory_usage_mb = mb as _);
let i = app.session.documents().iter().position(|st| st.doc.id == a).expect("document");
app.session.set_active(i);
g.harness.step();
assert_eq!(g.harness.state().kept.entries.len(), 2, "still within the cap");
for (cmd, p) in
[("layer.new.layer", json!({})), ("select.rect", json!({"x": 0, "y": 0, "width": 2000, "height": 1000})), ("edit.fill", json!({"color": "#cc2244"}))]
{
g.harness.state_mut().run(cmd, p).expect(cmd);
g.harness.step();
assert!(g.harness.state().redraws.is_empty(), "{cmd} redrew in the background");
}
assert!(g.harness.state().kept.entries.len() < 2, "kept over the cap after the older document grew");
drop(held);
}
/// A kept state History no longer holds goes at the next frame: its texels aren't held until
/// some later redraw.
#[test]
fn a_kept_state_history_purged_goes_at_the_next_frame() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
cpu_only_document(g.harness.state_mut(), 2600, 1700);
let layer = g.harness.state().session.active().and_then(|st| st.active_layer).expect("layer");
settle(&mut g);
// Hidden, the document is drawn on the GPU: the kept state is the one before, in History.
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "visible": false})).expect("hide");
settle(&mut g);
assert_eq!(g.harness.state().kept.entries.len(), 1, "the state before hiding is kept");
g.harness.state_mut().run("edit.purge.histories", json!({})).expect("purge");
g.harness.step();
assert!(g.harness.state().redraws.is_empty());
assert!(g.harness.state().kept.entries.is_empty(), "the purged state's composite is still held");
}
#[test]
fn closing_the_document_stops_its_redraw() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
// Held: the close lands while the redraw runs, and a cancelled worker leaves the hold.
let _held = start_held_redraw(&mut g, doc);
g.harness.state_mut().run("file.close", json!({"save": false})).expect("close");
g.harness.step();
assert!(g.harness.state().redraws.is_empty());
}
#[test]
fn hiding_a_large_layer_over_the_gpu_budget_redraws_in_the_background() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
// A layer covering most, but not all, of the document: hiding it damages a large rect that
// isn't the whole canvas.
let app = g.harness.state_mut();
app.run("file.new", json!({"width": 5000, "height": 2000, "background": "#336699"})).expect("new");
app.run("layer.new.layer", json!({})).expect("layer");
app.run("select.rect", json!({"x": 0, "y": 0, "width": 4800, "height": 1800})).expect("select");
app.run("edit.fill", json!({"color": "#cc8844"})).expect("fill");
app.run("select.deselect", json!({})).expect("deselect");
let (doc, layer) = {
let st = app.session.active().expect("document");
(st.doc.id, st.active_layer.expect("layer"))
};
settle(&mut g);
assert!(g.harness.state().perf.last_refresh.starts_with("gpu"), "the document fits the GPU: {}", g.harness.state().perf.last_refresh);
// A budget the pages of one 2048 px page cell fit (about 33 MB here) but not those of the
// whole width (80 MB), as on a multi-gigabyte PSB. Damage refreshes keep it: `gpu_budget`
// recomputes it for full ones only. A small edit still draws on the GPU at once.
g.harness.state_mut().run("layer.new.layer", json!({})).expect("layer");
g.harness.step();
g.harness.state_mut().run("select.rect", json!({"x": 100, "y": 100, "width": 64, "height": 64})).expect("select");
g.harness.step();
g.observer.set_memory_budget(48 << 20);
g.harness.state_mut().run("edit.fill", json!({"color": "#22ee22"})).expect("fill");
g.harness.step();
assert_eq!(g.harness.state().perf.last_refresh, "gpu-rect", "{:?}", g.harness.state().perf.gpu_fallback);
g.harness.state_mut().run("select.deselect", json!({})).expect("deselect");
g.harness.step();
assert!(g.harness.state().redraws.is_empty());
g.observer.set_memory_budget(48 << 20);
g.harness.state_mut().run("layer.setProps", json!({"layer": layer.0, "visible": false})).expect("hide");
let damage = g.harness.state().session.active().expect("document").last_damage.expect("damage");
assert!(damage != Rect::new(0, 0, 5000, 2000) && damage.width() as u64 * damage.height() as u64 >= crate::gpu_canvas::DEFER_PX, "{damage:?}");
g.harness.step();
assert!(g.harness.state().redraws.contains_key(&doc), "not composited inline: {}", g.harness.state().perf.last_refresh);
settle(&mut g);
assert_eq!(g.harness.state().perf.last_refresh, "background");
let app = g.harness.state();
assert!(matches!(app.render_path.current(doc.0), Some(crate::render_path::CpuReason::OverBudget { .. })), "{:?}", app.perf.gpu_fallback);
assert_matches_synchronous(&mut g, doc);
}
/// The active document's render path: its reason's kind.
fn render_path_of(g: &Gpu) -> Option<&'static str> {
let app = g.harness.state();
let doc = app.session.active().expect("document").doc.id.0;
app.render_path.current(doc).map(crate::render_path::CpuReason::kind)
}
/// On the GPU canvas: no reason, or only a software adapter's (CI's runners have one).
fn on_gpu_canvas(g: &Gpu) -> bool {
matches!(render_path_of(g), None | Some("softwareAdapter"))
}
#[test]
fn advanced_blending_fallback_is_shown_in_the_status_bar() {
use egui_kittest::kittest::Queryable;
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
cpu_only_document(g.harness.state_mut(), 800, 600);
g.harness.step();
settle(&mut g);
g.harness.run_steps(2);
assert_eq!(render_path_of(&g), Some("unsupported"));
// PLAN: assumes the status bar's CPU Rendering message exposes its tooltip text to kittest after a hover (panels-w19).
g.harness.get_by_label("CPU Rendering").hover();
g.harness.run_steps(40);
assert!(g.harness.query_by_label_contains("Advanced Blending").is_some(), "the tooltip names the cause");
}
#[test]
fn completed_compositor_build_refreshes_an_unchanged_cached_document() {
let _gpu = photocraft_testkit::gpu_lock();
for success in [true, false] {
let Some(mut g) = gpu_app() else { return };
let gpu = g.harness.state().gpu.as_ref().expect("GPU canvas").clone();
gpu.simulate_compositor_build();
g.harness.state_mut().run("file.new", json!({"width": 400, "height": 300, "background": "#336699"})).expect("new");
g.harness.step();
settle(&mut g);
let doc = g.harness.state().session.active().expect("document").doc.id;
let revision = g.harness.state().session.active().expect("document").revision;
assert_eq!(render_path_of(&g), Some("compositorBuilding"));
assert!(gpu.simulate_compositor_completion(success), "test compositor must build");
g.harness.step();
settle(&mut g);
g.harness.run_steps(2);
assert_eq!(g.harness.state().session.active().expect("document").revision, revision);
if success {
assert!(on_gpu_canvas(&g), "successful build should replace the temporary reason: {:?}", render_path_of(&g));
} else {
assert_eq!(render_path_of(&g), Some("compositorBuild"));
assert!(g.harness.state().perf.gpu_fallback.as_deref().is_some_and(|s| s.contains("simulated build failure")));
assert_matches_synchronous(&mut g, doc);
}
}
}
#[test]
fn a_canvas_over_the_texture_budget_records_its_reason() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
// The app's canvas, not the observer: each `GpuCanvas::new` shares a new budget.
g.harness.state().gpu.as_ref().expect("gpu canvas").set_canvas_budget(1);
g.harness.state_mut().run("file.new", json!({"width": 400, "height": 300, "background": "#336699"})).expect("new");
g.harness.run_steps(3);
assert_eq!(render_path_of(&g), Some("canvasTooLarge"));
let doc = g.harness.state().session.active().expect("document").doc.id.0;
assert_eq!(g.harness.state().render_path.history().filter(|c| c.doc == doc).count(), 1, "once, not every frame");
}
/// Frames until the active document's viewport pages are all rendered and uploaded.
fn settle_pages(g: &mut Gpu) {
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
loop {
g.harness.step();
let app = g.harness.state();
let id = app.session.active().expect("document").doc.id;
if app.streams.get(&id).is_some_and(|s| !s.busy() && s.stats.wanted > 0 && s.stats.ready == s.stats.wanted) {
return;
}
assert!(std::time::Instant::now() < deadline, "the viewport pages didn't finish");
std::thread::sleep(std::time::Duration::from_millis(2));
}
}
/// The screen pixel at the window's centre.
fn centre_pixel(g: &mut Gpu) -> [u8; 4] {
let img = g.harness.render().expect("render");
let p = img.get_pixel(img.width() / 2, img.height() / 2);
p.0
}
/// #5332: a document whose texture set doesn't fit the canvas budget stays on the GPU canvas,
/// drawn from the pages in view instead of the CPU canvas, with the same pixels; an edit
/// re-renders only the pages, and closing it frees them.
#[test]
fn a_canvas_over_the_texture_budget_draws_its_viewport_pages_on_the_gpu() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
g.harness.state_mut().run("file.new", json!({"width": 3000, "height": 2000, "background": "#336699"})).expect("new");
g.harness.run_steps(3);
assert!(on_gpu_canvas(&g));
let whole = centre_pixel(&mut g);
let gpu = g.harness.state().gpu.clone().expect("gpu canvas");
let doc = g.harness.state().session.active().expect("document").doc.clone();
let key = crate::canvas::viewport_pages::stream_key(doc.id.0);
// Room for pages (half the budget), not for the document's texture set.
let (set, _) = gpu.canvas_fit(&doc).expect("fit");
gpu.set_canvas_budget(set - 1);
settle_pages(&mut g);
assert!(on_gpu_canvas(&g), "{:?}", render_path_of(&g));
assert!(gpu.texture_info(doc.id.0).is_none(), "no texture set");
let (pages, bytes) = gpu.pages(key);
let stats = g.harness.state().streams[&doc.id].stats.clone();
assert_eq!(pages.len(), stats.resident);
assert!(stats.wanted > 0 && stats.last_error.is_none(), "{stats:?}");
assert!(bytes <= (set - 1) / 2, "pages stay within half the budget: {bytes}");
let shown = centre_pixel(&mut g);
assert!((0..3).all(|i| shown[i].abs_diff(whole[i]) <= 2), "pages {shown:?}, texture set {whole:?}");
// An edit re-renders the pages it reaches.
let uploads = stats.uploads;
g.harness.state_mut().run("edit.fill", json!({"color": "#cc8844"})).expect("fill");
settle_pages(&mut g);
let stats = g.harness.state().streams[&doc.id].stats.clone();
assert!(stats.dirtied > 0 && stats.uploads > uploads, "{stats:?}");
let filled = centre_pixel(&mut g);
assert!(filled[0] > 0xb0 && filled[2] < 0x60, "the fill is shown: {filled:?}");
// A small edit re-renders only the part of each page it reaches, into the page held.
let (held, partial) = (gpu.pages(key).0.len(), stats.partial);
// (A frame between the steps, as in use: the edit's damage is known one revision at a time.)
g.harness.state_mut().run("select.rect", json!({"x": 1400, "y": 900, "width": 200, "height": 200})).expect("select");
settle_pages(&mut g);
g.harness.state_mut().run("edit.fill", json!({"color": "#22aa22"})).expect("small fill");
settle_pages(&mut g);
let stats = g.harness.state().streams[&doc.id].stats.clone();
assert!(stats.partial > partial, "{stats:?}");
assert_eq!(gpu.pages(key).0.len(), held, "no new page textures");
// Just its square is shown: 200 px at about 20% zoom, some 40 screen pixels a side.
let img = g.harness.render().expect("render");
let green = img.pixels().filter(|p| p.0[1] > 0x90 && p.0[0] < 0x50 && p.0[2] < 0x50).count();
assert!((1000..2500).contains(&green), "the small fill is shown: {green} pixels");
// A budget too small for one page draws it on the CPU canvas, as before.
gpu.set_canvas_budget(1);
g.harness.run_steps(3);
assert_eq!(render_path_of(&g), Some("canvasTooLarge"));
// Its pages and their work are freed meanwhile (#5332 review).
assert!(gpu.pages(key).0.is_empty(), "pages freed");
assert!(!g.harness.state().streams.contains_key(&doc.id), "stream dropped");
gpu.set_canvas_budget(set - 1);
settle_pages(&mut g);
// Closing the document cancels its work and frees its pages.
g.harness.state_mut().run("file.close", json!({"save": false})).expect("close");
g.harness.run_steps(3);
assert!(g.harness.state().streams.is_empty());
assert!(gpu.pages(key).0.is_empty());
}
/// Runs a Window › Arrange command, as its menu item does, and lets the layout settle.
fn arrange(g: &mut Gpu, command: &str) {
let ctx = g.harness.ctx.clone();
crate::menus::invoke(g.harness.state_mut(), &ctx, command, json!({})).expect("arrange");
g.harness.run_steps(3);
}
/// #5332 review: the open documents share one texture budget rather than each having all of
/// it. A document alone on screen keeps the whole budget; one in a background tab gives its
/// textures up when the shown one needs the room; and documents shown side by side split it,
/// a document over its share drawing from viewport pages.
#[test]
fn open_documents_share_one_texture_budget_with_the_shown_ones_first() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
let gpu = g.harness.state().gpu.clone().expect("gpu canvas");
let new = |g: &mut Gpu| {
g.harness.state_mut().run("file.new", json!({"width": 3000, "height": 2000, "background": "#336699"})).expect("new");
g.harness.run_steps(3);
assert!(on_gpu_canvas(g), "{:?}", render_path_of(g));
g.harness.state().session.active().expect("document").doc.clone()
};
let a = new(&mut g);
let (set, _) = gpu.canvas_fit(&a).expect("fit");
// Room for one texture set and a half: a document alone on screen has all of it.
let budget = set + set / 2;
gpu.set_canvas_budget(budget);
assert_eq!(gpu.canvas_fit(&a), Some((set, budget)), "alone, the whole budget");
assert!(gpu.texture_info(a.id.0).is_some());
// A second tab: the shown document's texture set takes the room of the background one's.
let b = new(&mut g);
assert_eq!(gpu.canvas_fit(&b), Some((set, budget)));
assert!(gpu.texture_info(b.id.0).is_some());
assert!(gpu.texture_info(a.id.0).is_none(), "the background document's textures are freed");
// Back to the first tab: it gets its texture set back and the other gives its up.
g.harness.state_mut().session.set_active(0);
g.harness.run_steps(3);
assert!(on_gpu_canvas(&g), "{:?}", render_path_of(&g));
assert!(gpu.texture_info(a.id.0).is_some());
assert!(gpu.texture_info(b.id.0).is_none());
// Side by side, they split the budget: neither set fits its half, so both draw from pages.
arrange(&mut g, "window.arrange.twoUpVertical");
assert_eq!(gpu.canvas_fit(&a), Some((set, budget / 2)));
assert_eq!(gpu.canvas_fit(&b), Some((set, budget - budget / 2)));
settle_pages(&mut g);
assert!(on_gpu_canvas(&g), "{:?}", render_path_of(&g));
let streams = &g.harness.state().streams;
assert!(streams.contains_key(&a.id) && streams.contains_key(&b.id), "both on pages");
assert!(gpu.texture_info(a.id.0).is_none() && gpu.texture_info(b.id.0).is_none());
// Switching between them re-splits nothing: no page set is dropped.
let held = gpu.pages(crate::canvas::viewport_pages::stream_key(a.id.0)).0;
g.harness.state_mut().session.set_active(1);
g.harness.run_steps(3);
assert_eq!(gpu.canvas_fit(&a), Some((set, budget / 2)));
assert_eq!(gpu.pages(crate::canvas::viewport_pages::stream_key(a.id.0)).0, held, "no churn on a switch");
// Back to tabs: the shown document has the whole budget, and its texture set, again.
arrange(&mut g, "window.arrange.consolidateAllToTabs");
assert_eq!(gpu.canvas_fit(&b), Some((set, budget)));
assert!(on_gpu_canvas(&g), "{:?}", render_path_of(&g));
assert!(gpu.texture_info(b.id.0).is_some());
}
#[test]
fn a_flipped_view_records_why_it_draws_on_the_cpu() {
let _gpu = photocraft_testkit::gpu_lock();
let Some(mut g) = gpu_app() else { return };
g.harness.state_mut().run("file.new", json!({"width": 400, "height": 300, "background": "#336699"})).expect("new");
g.harness.run_steps(3);
assert!(on_gpu_canvas(&g));
g.harness.state_mut().ui.view.flip_horizontal = true;
g.harness.run_steps(3);
assert_eq!(render_path_of(&g), Some("viewTransform"));
g.harness.state_mut().ui.view.flip_horizontal = false;
g.harness.run_steps(3);
assert!(on_gpu_canvas(&g), "back on the GPU");
}
+2 -2
View File
@@ -1107,10 +1107,10 @@ impl GpuCanvas {
}
#[cfg(test)]
mod mip_tests;
mod mip_gpu_tests;
#[cfg(test)]
mod sharp_tests;
mod sharp_gpu_tests;
#[cfg(test)]
mod tests;
@@ -188,39 +188,6 @@ fn a_channel_view_draws_its_own_picture() {
assert_eq!(composite[6], Color32::WHITE, "the composite stays the document's");
}
/// The proxy preview is the GPU canvas's: without a GPU a large document's adjustment previews through the CPU proxy,
/// and the layer path shows nothing (`adjust_preview::cheap`).
#[test]
fn during_a_proxy_adjustment_the_overlay_reads_the_preview_and_the_composite_the_document() {
let _gpu = photocraft_testkit::gpu_lock();
let rs = match std::panic::catch_unwind(|| egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default())) {
Ok(rs) => rs,
Err(error) if std::env::var_os("PHOTOCRAFT_REQUIRE_GPU_TESTS").is_some() => std::panic::resume_unwind(error),
Err(_) => return,
};
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
app.set_wgpu(rs);
app.run("file.new", json!({"width": 2400, "height": 2200, "background": "#808080"})).unwrap();
let st = app.session.active().unwrap();
assert!(crate::proxy::preview_factor(&st.doc, crate::proxy::reduced_previews(&app)) > 1, "large enough for a proxy preview");
// Only the red channel shows: an opaque view over the composite.
let view = &mut app.session.active_mut().unwrap().channel_view;
view.set_color_visible(1, false);
view.set_color_visible(2, false);
let ctx = app.ctx().clone();
let at = PixelRect::new(0, 0, 1, 1);
let overlay_before = read(&OverlayPrep::new(&mut app, &ctx, 0, None, None).unwrap().source(&app), at, 1).pixels;
let composite_before = read(&CompositePrep::new(&mut app, &ctx, 0, None, None).unwrap().source(&app), at, 1).pixels;
let id = crate::adjust_dialog::open(&mut app, "image.adjustments.levels").unwrap();
assert!(crate::adjust_dialog::apply_params(&mut app, id, &json!({"inBlack": 100})), "the dialog takes the black point");
assert!(crate::adjust_preview::display_doc(&mut app, 0).is_some(), "the adjustment previews");
let overlay = read(&OverlayPrep::new(&mut app, &ctx, 0, None, None).unwrap().source(&app), at, 1).pixels;
let composite = read(&CompositePrep::new(&mut app, &ctx, 0, None, None).unwrap().source(&app), at, 1).pixels;
assert_ne!(overlay, overlay_before, "the overlay shows the live preview");
assert_eq!(composite, composite_before, "the composite shows the document");
}
/// The CPU canvas (no usable GPU; a flipped or pixel-aspect-corrected view, or a GPU fallback, on a GPU machine) shows
/// a filter dialog's live preview. It showed the document unfiltered.
#[test]
@@ -340,3 +307,40 @@ fn channel_views_show_live_strokes_and_drop_discarded_ones() {
assert_eq!(shown(&mut app), view(&app, &original), "{target}: a dropped stroke shows the channel as it was");
}
}
mod gpu_tests {
use super::*;
/// The proxy preview is the GPU canvas's: without a GPU a large document's adjustment previews through the CPU proxy,
/// and the layer path shows nothing (`adjust_preview::cheap`).
#[test]
fn during_a_proxy_adjustment_the_overlay_reads_the_preview_and_the_composite_the_document() {
let _gpu = photocraft_testkit::gpu_lock();
let rs = match std::panic::catch_unwind(|| egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default())) {
Ok(rs) => rs,
Err(error) if std::env::var_os("PHOTOCRAFT_REQUIRE_GPU_TESTS").is_some() => std::panic::resume_unwind(error),
Err(_) => return,
};
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
app.set_wgpu(rs);
app.run("file.new", json!({"width": 2400, "height": 2200, "background": "#808080"})).unwrap();
let st = app.session.active().unwrap();
assert!(crate::proxy::preview_factor(&st.doc, crate::proxy::reduced_previews(&app)) > 1, "large enough for a proxy preview");
// Only the red channel shows: an opaque view over the composite.
let view = &mut app.session.active_mut().unwrap().channel_view;
view.set_color_visible(1, false);
view.set_color_visible(2, false);
let ctx = app.ctx().clone();
let at = PixelRect::new(0, 0, 1, 1);
let overlay_before = read(&OverlayPrep::new(&mut app, &ctx, 0, None, None).unwrap().source(&app), at, 1).pixels;
let composite_before = read(&CompositePrep::new(&mut app, &ctx, 0, None, None).unwrap().source(&app), at, 1).pixels;
let id = crate::adjust_dialog::open(&mut app, "image.adjustments.levels").unwrap();
assert!(crate::adjust_dialog::apply_params(&mut app, id, &json!({"inBlack": 100})), "the dialog takes the black point");
assert!(crate::adjust_preview::display_doc(&mut app, 0).is_some(), "the adjustment previews");
let overlay = read(&OverlayPrep::new(&mut app, &ctx, 0, None, None).unwrap().source(&app), at, 1).pixels;
let composite = read(&CompositePrep::new(&mut app, &ctx, 0, None, None).unwrap().source(&app), at, 1).pixels;
assert_ne!(overlay, overlay_before, "the overlay shows the live preview");
assert_eq!(composite, composite_before, "the composite shows the document");
}
}
+33 -29
View File
@@ -82,35 +82,6 @@ fn redrawn_since(app: &mut PhotocraftApp, ctx: &egui::Context, seen: Revision) -
prep.source(app).damage(seen).map(|r| i64::from(r.width()) * i64::from(r.height()))
}
#[test]
fn gpu_display_luts_are_per_display() {
let _gpu = photocraft_testkit::gpu_lock();
let Ok(rs) = std::panic::catch_unwind(|| egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default())) else {
eprintln!("skipping: no GPU adapter");
return;
};
let mut app = app_on_two_displays();
app.set_wgpu(rs);
let doc = app.session.documents()[0].doc.clone();
let key = doc.id.0;
// sRGB on the sRGB display needs no LUT; on the P3 display it does.
assert_eq!(sync_display_lut(&mut app, &doc, key, Some(1)), 0);
assert_eq!(sync_display_lut(&mut app, &doc, key, Some(4)), 3);
let gpu = app.gpu.clone().unwrap();
let (s1, s4) = (gpu.display_lut_signature(key, 1).unwrap(), gpu.display_lut_signature(key, 4).unwrap());
assert_ne!(s1.0, s4.0);
assert!(gpu.has_display_lut(key, 4) && !gpu.has_display_lut(key, 1));
// Drawing one window leaves the other's LUT alone.
for _ in 0..3 {
assert_eq!(sync_display_lut(&mut app, &doc, key, Some(1)), 0);
assert_eq!(sync_display_lut(&mut app, &doc, key, Some(4)), 3);
}
assert_eq!((gpu.display_lut_signature(key, 1), gpu.display_lut_signature(key, 4)), (Some(s1), Some(s4)));
assert!(gpu.has_display_lut(key, 4));
// The shared texture's key is the same for both displays.
assert_eq!(texture_key(canvas_display(&app, &doc, Some(1)).0.as_deref(), &doc), texture_key(canvas_display(&app, &doc, Some(4)).0.as_deref(), &doc));
}
/// The GPU canvas texture of a Multichannel document is filled by the CPU compositor, so its
/// key carries the ink preview (Color Settings › Spot) like the CPU canvas key does.
#[test]
@@ -1098,3 +1069,36 @@ fn free_transform_redraws_only_the_moving_layer_when_the_box_opens_and_closes()
assert!(committed.contains(20, 20) && committed.contains(139, 49), "{committed:?}");
assert!(damage_since(&app, 0, (rev, key ^ dk), (rev + 2, 0), dk, (rev + 1, Some(moved))).is_none(), "a later revision isn't ours");
}
mod gpu_tests {
use super::*;
#[test]
fn gpu_display_luts_are_per_display() {
let _gpu = photocraft_testkit::gpu_lock();
let Ok(rs) = std::panic::catch_unwind(|| egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default())) else {
eprintln!("skipping: no GPU adapter");
return;
};
let mut app = app_on_two_displays();
app.set_wgpu(rs);
let doc = app.session.documents()[0].doc.clone();
let key = doc.id.0;
// sRGB on the sRGB display needs no LUT; on the P3 display it does.
assert_eq!(sync_display_lut(&mut app, &doc, key, Some(1)), 0);
assert_eq!(sync_display_lut(&mut app, &doc, key, Some(4)), 3);
let gpu = app.gpu.clone().unwrap();
let (s1, s4) = (gpu.display_lut_signature(key, 1).unwrap(), gpu.display_lut_signature(key, 4).unwrap());
assert_ne!(s1.0, s4.0);
assert!(gpu.has_display_lut(key, 4) && !gpu.has_display_lut(key, 1));
// Drawing one window leaves the other's LUT alone.
for _ in 0..3 {
assert_eq!(sync_display_lut(&mut app, &doc, key, Some(1)), 0);
assert_eq!(sync_display_lut(&mut app, &doc, key, Some(4)), 3);
}
assert_eq!((gpu.display_lut_signature(key, 1), gpu.display_lut_signature(key, 4)), (Some(s1), Some(s4)));
assert!(gpu.has_display_lut(key, 4));
// The shared texture's key is the same for both displays.
assert_eq!(texture_key(canvas_display(&app, &doc, Some(1)).0.as_deref(), &doc), texture_key(canvas_display(&app, &doc, Some(4)).0.as_deref(), &doc));
}
}
+1 -1
View File
@@ -186,7 +186,7 @@ impl CameraRawGpu {
}
#[cfg(test)]
mod tests {
mod gpu_tests {
use super::*;
use crate::camera_raw_ui::proxy::ProxyJob;
use craft::imaging::ui::raw_develop::RawPreviewRequest;
@@ -123,11 +123,15 @@ fn existing_document_profile_preset_and_recorded_export_keep_source_colors() {
verify_png(&writes.borrow()[0], [30, 30, 200], 0, true);
}
#[test]
fn export_as_color_space_gpu_snapshots() {
let Some(dir) = std::env::var_os("PHOTOCRAFT_SRGB_SNAPSHOTS") else { return };
let dir = std::path::PathBuf::from(dir);
let _gpu = photocraft_testkit::gpu_lock();
std::fs::create_dir_all(&dir).unwrap();
export_both_ways(Some(&dir));
mod gpu_tests {
use super::*;
#[test]
fn export_as_color_space_gpu_snapshots() {
let Some(dir) = std::env::var_os("PHOTOCRAFT_SRGB_SNAPSHOTS") else { return };
let dir = std::path::PathBuf::from(dir);
let _gpu = photocraft_testkit::gpu_lock();
std::fs::create_dir_all(&dir).unwrap();
export_both_ways(Some(&dir));
}
}
+77 -73
View File
@@ -407,82 +407,86 @@ mod tests {
assert!(launch(&files).session.prefs().performance.use_gpu, "the next launch retries the GPU");
}
/// #6564: an out-of-memory error on a device that still works rebuilds the GPU canvas by itself,
/// with no notice and the documents untouched, a few times a session; then the CPU renderer
/// stays until Retry GPU. Other errors and a loss still fall back at once.
#[test]
fn out_of_memory_rebuilds_the_gpu_canvas_by_itself() {
let _gpu = photocraft_testkit::gpu_lock();
let rs = std::panic::catch_unwind(|| egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default()));
let Ok(rs) = rs else {
eprintln!("skipping: no GPU adapter");
return;
};
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
app.set_wgpu(rs);
app.run("file.new", json!({"width": 64, "height": 48})).unwrap();
let ctx = app.ctx().clone();
let oom = || photocraft_gpu::Fault::Error("Out of Memory".into());
for n in 1..=OOM_AUTO_RETRIES {
mod gpu_tests {
use super::*;
/// #6564: an out-of-memory error on a device that still works rebuilds the GPU canvas by itself,
/// with no notice and the documents untouched, a few times a session; then the CPU renderer
/// stays until Retry GPU. Other errors and a loss still fall back at once.
#[test]
fn out_of_memory_rebuilds_the_gpu_canvas_by_itself() {
let _gpu = photocraft_testkit::gpu_lock();
let rs = std::panic::catch_unwind(|| egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default()));
let Ok(rs) = rs else {
eprintln!("skipping: no GPU adapter");
return;
};
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
app.set_wgpu(rs);
app.run("file.new", json!({"width": 64, "height": 48})).unwrap();
let ctx = app.ctx().clone();
let oom = || photocraft_gpu::Fault::Error("Out of Memory".into());
for n in 1..=OOM_AUTO_RETRIES {
app.gpu_health().unwrap().mark(oom());
check(&mut app, &ctx);
assert!(app.gpu_active(), "retry {n}: the GPU canvas is back");
assert!(app.gpu_health().unwrap().is_ok(), "retry {n}: with a fresh health flag");
assert_eq!(app.perf.gpu_info.canvas, "gpu");
assert!(app.ui.gpu_fallback_notice.is_none(), "retry {n}: no recovery dialog");
assert_eq!(app.session.documents().len(), 1);
}
// Past the limit the CPU renderer stays and the dialog offers Retry GPU.
app.gpu_health().unwrap().mark(oom());
check(&mut app, &ctx);
assert!(app.gpu_active(), "retry {n}: the GPU canvas is back");
assert!(app.gpu_health().unwrap().is_ok(), "retry {n}: with a fresh health flag");
assert_eq!(app.perf.gpu_info.canvas, "gpu");
assert!(app.ui.gpu_fallback_notice.is_none(), "retry {n}: no recovery dialog");
assert_eq!(app.session.documents().len(), 1);
assert!(!app.gpu_active() && app.ui.gpu_fallback_notice.is_some());
assert_eq!(app.perf.gpu_info.canvas, "cpu");
// A validation error is not retried by itself.
let rs = egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default());
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
app.set_wgpu(rs);
app.run("file.new", json!({"width": 64, "height": 48})).unwrap();
app.gpu_health().unwrap().mark(photocraft_gpu::Fault::Error("Validation Error".into()));
check(&mut app, &ctx);
assert!(!app.gpu_active() && app.ui.gpu_fallback_notice.is_some());
}
// Past the limit the CPU renderer stays and the dialog offers Retry GPU.
app.gpu_health().unwrap().mark(oom());
check(&mut app, &ctx);
assert!(!app.gpu_active() && app.ui.gpu_fallback_notice.is_some());
assert_eq!(app.perf.gpu_info.canvas, "cpu");
// A validation error is not retried by itself.
let rs = egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default());
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
app.set_wgpu(rs);
app.run("file.new", json!({"width": 64, "height": 48})).unwrap();
app.gpu_health().unwrap().mark(photocraft_gpu::Fault::Error("Validation Error".into()));
check(&mut app, &ctx);
assert!(!app.gpu_active() && app.ui.gpu_fallback_notice.is_some());
}
/// #6577: after a GPU error on a device that still works (out of memory, validation), Retry
/// GPU builds a new GPU canvas at once, without a restart or closing documents. After a loss
/// the device can't be used again, so the retry still waits for the next launch.
#[test]
fn retry_gpu_after_an_error_rebuilds_the_canvas_without_a_restart() {
let _gpu = photocraft_testkit::gpu_lock();
let rs = std::panic::catch_unwind(|| egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default()));
let Ok(rs) = rs else {
eprintln!("skipping: no GPU adapter");
return;
};
let mut app = launch(&std::sync::Arc::new(craft::settings::testing::MemoryFiles::new()));
app.set_wgpu(rs);
app.run("file.new", json!({"width": 64, "height": 48})).unwrap();
let ctx = app.ctx().clone();
// An error on a live device (one not retried by itself, see #6564): Retry GPU rebuilds
// the canvas now.
app.gpu_health().unwrap().mark(photocraft_gpu::Fault::Error("Validation Error".into()));
check(&mut app, &ctx);
assert!(!app.gpu_active() && app.ui.gpu_fallback_notice.is_some());
assert!(can_retry_now(&app));
choose_recovery(&mut app, true).unwrap();
assert!(app.gpu_active(), "Retry GPU rebuilt the GPU canvas");
assert!(app.gpu_health().unwrap().is_ok(), "with a fresh health flag");
assert_eq!(app.perf.gpu_info.canvas, "gpu");
assert_eq!((app.perf.gpu_info.lost.as_deref(), app.perf.gpu_fallback.as_deref()), (None, None));
assert_eq!(app.ui.status, "GPU acceleration resumed.");
assert!(app.ui.gpu_fallback_notice.is_none() && app.ui.notices.is_empty(), "no restart notice");
assert_eq!(app.session.documents().len(), 1, "the document stayed open");
// A loss: the device can't be reused, so the retry is scheduled for the next launch.
app.gpu_health().unwrap().mark(photocraft_gpu::Fault::Lost("simulated".into()));
check(&mut app, &ctx);
assert!(!can_retry_now(&app));
choose_recovery(&mut app, true).unwrap();
assert!(!app.gpu_active());
assert_eq!(app.ui.notices.len(), 1, "the restart notice");
/// #6577: after a GPU error on a device that still works (out of memory, validation), Retry
/// GPU builds a new GPU canvas at once, without a restart or closing documents. After a loss
/// the device can't be used again, so the retry still waits for the next launch.
#[test]
fn retry_gpu_after_an_error_rebuilds_the_canvas_without_a_restart() {
let _gpu = photocraft_testkit::gpu_lock();
let rs = std::panic::catch_unwind(|| egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default()));
let Ok(rs) = rs else {
eprintln!("skipping: no GPU adapter");
return;
};
let mut app = launch(&std::sync::Arc::new(craft::settings::testing::MemoryFiles::new()));
app.set_wgpu(rs);
app.run("file.new", json!({"width": 64, "height": 48})).unwrap();
let ctx = app.ctx().clone();
// An error on a live device (one not retried by itself, see #6564): Retry GPU rebuilds
// the canvas now.
app.gpu_health().unwrap().mark(photocraft_gpu::Fault::Error("Validation Error".into()));
check(&mut app, &ctx);
assert!(!app.gpu_active() && app.ui.gpu_fallback_notice.is_some());
assert!(can_retry_now(&app));
choose_recovery(&mut app, true).unwrap();
assert!(app.gpu_active(), "Retry GPU rebuilt the GPU canvas");
assert!(app.gpu_health().unwrap().is_ok(), "with a fresh health flag");
assert_eq!(app.perf.gpu_info.canvas, "gpu");
assert_eq!((app.perf.gpu_info.lost.as_deref(), app.perf.gpu_fallback.as_deref()), (None, None));
assert_eq!(app.ui.status, "GPU acceleration resumed.");
assert!(app.ui.gpu_fallback_notice.is_none() && app.ui.notices.is_empty(), "no restart notice");
assert_eq!(app.session.documents().len(), 1, "the document stayed open");
// A loss: the device can't be reused, so the retry is scheduled for the next launch.
app.gpu_health().unwrap().mark(photocraft_gpu::Fault::Lost("simulated".into()));
check(&mut app, &ctx);
assert!(!can_retry_now(&app));
choose_recovery(&mut app, true).unwrap();
assert!(!app.gpu_active());
assert_eq!(app.ui.notices.len(), 1, "the restart notice");
}
}
}
+72 -68
View File
@@ -17,74 +17,6 @@ fn doc_size() -> Size {
Size::new(f64::from(DOC[0]), f64::from(DOC[1]))
}
#[test]
fn gpu_zoom_animation_reuses_the_document_composite() {
let Ok(rs) = std::panic::catch_unwind(|| egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default())) else {
eprintln!("skipping: no GPU adapter");
return;
};
let renderer = egui_kittest::wgpu::WgpuTestRenderer::from_render_state(rs);
let mut h = Harness::builder().with_size(vec2(1000.0, 700.0)).with_pixels_per_point(1.0).renderer(renderer).build_eframe(|cc| {
PhotocraftApp::setup_context(&cc.egui_ctx, crate::theme::AppTheme::pro());
let mut app = PhotocraftApp::with_context(cc.egui_ctx.clone(), photocraft_engine::Session::new(), crate::Services::default());
app.set_wgpu(cc.wgpu_render_state.clone().unwrap());
app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
app.run("edit.fill", json!({"color": "#2060c0"})).unwrap();
app
});
// The harness sets egui's animation time to zero, which turns the framework's motion off; the ease needs it on.
h.ctx.all_styles_mut(|style| style.animation_time = egui::Style::default().animation_time);
let shown = |h: &Harness<'static, Box<PhotocraftApp>>| shown_camera(&h.ctx, CanvasHost::main(0), &h.state().ui.views[0], 1.0).0;
h.run_steps(4);
h.state_mut().run("view.actualPixels", json!({})).unwrap();
h.step();
let time = h.ctx.input(|i| i.time) + 0.3;
h.input_mut().time = Some(time);
h.step();
let id = h.state().session.documents()[0].doc.id;
assert!(h.state().canvases[&(id, crate::canvas::GPU_OUTPUT)].on_gpu);
let directory = std::env::var_os("CRAFT_UI_ZOOM_FIXTURES").map(std::path::PathBuf::from);
if let Some(directory) = &directory {
std::fs::create_dir_all(directory).unwrap();
}
h.state_mut().run("view.zoomIn", json!({})).unwrap();
// The canvas runs the command in its next pass: the zoom it asks for is the rung after 100 %.
let target = craft::behavior::canvas::ZoomLadder::step(1.0, 1, craft::behavior::kurbo::Size::new(400.0, 300.0)) as f32;
// The ease's length belongs to the framework's motion settings, so the steps are short and the test looks for a
// frame between the start and the target zoom rather than naming a time for it.
let mut midway = false;
for step in 0..=10 {
let name = format!("{:.2}s", f64::from(step) * 0.03);
h.state_mut().perf.last_refresh = "";
h.input_mut().time = Some(time + f64::from(step) * 0.03);
h.step();
assert!(h.state().perf.gpu, "{name}: keep the GPU canvas");
assert_eq!(h.state().perf.last_refresh, "", "{name}: reuse the composite");
let zoom = shown(&h);
midway |= zoom > 1.0 && zoom < target;
let image = h.render().unwrap();
let center = h.state().last_canvas_rect.center();
let pixel = image.get_pixel(center.x as u32, center.y as u32);
assert!(pixel[2] > pixel[0] * 2, "{name}: document remains visible: {pixel:?}");
if let Some(directory) = &directory {
image.save(directory.join(format!("photocraft-zoom-{name}.png"))).unwrap();
}
}
assert!(midway, "a frame of the ease showed a zoom between 1 and {target}");
assert_eq!(shown(&h), target);
h.state_mut().run("prefs.set", json!({"values": {"general.animatedZoom": false}})).unwrap();
h.state_mut().run("view.zoomIn", json!({})).unwrap();
h.state_mut().perf.last_refresh = "";
h.step();
assert_eq!(shown(&h), h.state().current_zoom());
assert!(h.state().perf.gpu);
assert_eq!(h.state().perf.last_refresh, "", "immediate zoom reuses the GPU composite");
let image = h.render().unwrap();
if let Some(directory) = &directory {
image.save(directory.join("photocraft-zoom-disabled.png")).unwrap();
}
}
/// The platform's modifiers for `Cmd` (⌘ on the Mac, Ctrl elsewhere), as egui-winit reports them.
fn platform(m: Modifiers) -> Modifiers {
let mut out = Modifiers { alt: m.alt, shift: m.shift, ctrl: m.ctrl, ..Default::default() };
@@ -156,3 +88,75 @@ fn temporary_and_spring_zooms_ignore_the_zoom_out_mode() {
assert!(!h.state().ui.tool_options.zoom_in, "{name}: Zoom Out stays selected");
}
}
mod gpu_tests {
use super::*;
#[test]
fn gpu_zoom_animation_reuses_the_document_composite() {
let Ok(rs) = std::panic::catch_unwind(|| egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default())) else {
eprintln!("skipping: no GPU adapter");
return;
};
let renderer = egui_kittest::wgpu::WgpuTestRenderer::from_render_state(rs);
let mut h = Harness::builder().with_size(vec2(1000.0, 700.0)).with_pixels_per_point(1.0).renderer(renderer).build_eframe(|cc| {
PhotocraftApp::setup_context(&cc.egui_ctx, crate::theme::AppTheme::pro());
let mut app = PhotocraftApp::with_context(cc.egui_ctx.clone(), photocraft_engine::Session::new(), crate::Services::default());
app.set_wgpu(cc.wgpu_render_state.clone().unwrap());
app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
app.run("edit.fill", json!({"color": "#2060c0"})).unwrap();
app
});
// The harness sets egui's animation time to zero, which turns the framework's motion off; the ease needs it on.
h.ctx.all_styles_mut(|style| style.animation_time = egui::Style::default().animation_time);
let shown = |h: &Harness<'static, Box<PhotocraftApp>>| shown_camera(&h.ctx, CanvasHost::main(0), &h.state().ui.views[0], 1.0).0;
h.run_steps(4);
h.state_mut().run("view.actualPixels", json!({})).unwrap();
h.step();
let time = h.ctx.input(|i| i.time) + 0.3;
h.input_mut().time = Some(time);
h.step();
let id = h.state().session.documents()[0].doc.id;
assert!(h.state().canvases[&(id, crate::canvas::GPU_OUTPUT)].on_gpu);
let directory = std::env::var_os("CRAFT_UI_ZOOM_FIXTURES").map(std::path::PathBuf::from);
if let Some(directory) = &directory {
std::fs::create_dir_all(directory).unwrap();
}
h.state_mut().run("view.zoomIn", json!({})).unwrap();
// The canvas runs the command in its next pass: the zoom it asks for is the rung after 100 %.
let target = craft::behavior::canvas::ZoomLadder::step(1.0, 1, craft::behavior::kurbo::Size::new(400.0, 300.0)) as f32;
// The ease's length belongs to the framework's motion settings, so the steps are short and the test looks for a
// frame between the start and the target zoom rather than naming a time for it.
let mut midway = false;
for step in 0..=10 {
let name = format!("{:.2}s", f64::from(step) * 0.03);
h.state_mut().perf.last_refresh = "";
h.input_mut().time = Some(time + f64::from(step) * 0.03);
h.step();
assert!(h.state().perf.gpu, "{name}: keep the GPU canvas");
assert_eq!(h.state().perf.last_refresh, "", "{name}: reuse the composite");
let zoom = shown(&h);
midway |= zoom > 1.0 && zoom < target;
let image = h.render().unwrap();
let center = h.state().last_canvas_rect.center();
let pixel = image.get_pixel(center.x as u32, center.y as u32);
assert!(pixel[2] > pixel[0] * 2, "{name}: document remains visible: {pixel:?}");
if let Some(directory) = &directory {
image.save(directory.join(format!("photocraft-zoom-{name}.png"))).unwrap();
}
}
assert!(midway, "a frame of the ease showed a zoom between 1 and {target}");
assert_eq!(shown(&h), target);
h.state_mut().run("prefs.set", json!({"values": {"general.animatedZoom": false}})).unwrap();
h.state_mut().run("view.zoomIn", json!({})).unwrap();
h.state_mut().perf.last_refresh = "";
h.step();
assert_eq!(shown(&h), h.state().current_zoom());
assert!(h.state().perf.gpu);
assert_eq!(h.state().perf.last_refresh, "", "immediate zoom reuses the GPU composite");
let image = h.render().unwrap();
if let Some(directory) = &directory {
image.save(directory.join("photocraft-zoom-disabled.png")).unwrap();
}
}
}
@@ -20,13 +20,10 @@ fn form_fields(h: &mut Harness) -> Value {
}
fn harness() -> Harness {
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1100.0, 760.0)).with_max_steps(64).wgpu().build_eframe(|cc| {
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1100.0, 760.0)).with_max_steps(64).build_eframe(|cc| {
PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
let mut app = PhotocraftApp::with_context(cc.egui_ctx.clone(), photocraft_engine::Session::new(), Default::default());
app.session.prefs.edit(|p| p.interface.language = "en".into());
if let Some(rs) = cc.wgpu_render_state.as_ref() {
app.set_wgpu(rs.clone());
}
app.run("file.new", json!({"width": 8, "height": 8, "background": "white"})).unwrap();
app.run("actions.record", json!({"name": "Invert"})).unwrap();
app.run("image.adjustments.invert", json!({})).unwrap();
@@ -81,7 +78,6 @@ fn edit_path(h: &mut Harness, name: &str, value: &Path) {
#[test]
fn batch_menu_offers_webp() {
let _gpu = photocraft_testkit::gpu_lock();
let mut h = harness();
open(&mut h, "file.automate.batch");
open_format_choices(&mut h);
@@ -91,7 +87,6 @@ fn batch_menu_offers_webp() {
#[test]
fn batch_menu_offers_quality() {
let _gpu = photocraft_testkit::gpu_lock();
let mut h = harness();
open(&mut h, "file.automate.batch");
evidence(&mut h, "batch-quality");
@@ -100,7 +95,6 @@ fn batch_menu_offers_quality() {
#[test]
fn image_processor_menu_offers_independent_file_types() {
let _gpu = photocraft_testkit::gpu_lock();
let mut h = harness();
open(&mut h, "file.scripts.imageProcessor");
for label in ["Save as JPEG", "Save as PSD", "Save as TIFF"] {
@@ -182,7 +176,6 @@ fn existing_engine_batch_and_image_processor_support_webp_quality() {
#[test]
fn batch_naming_controls_export_the_requested_names_and_reset_on_cancel() {
let _gpu = photocraft_testkit::gpu_lock();
let dir = Scratch::new();
let input = dir.0.join("input");
let output = dir.0.join("output");
@@ -232,7 +225,6 @@ fn batch_naming_controls_export_the_requested_names_and_reset_on_cancel() {
#[test]
fn batch_default_quality_keeps_lossless_webp_and_existing_jpeg_bytes() {
let _gpu = photocraft_testkit::gpu_lock();
let dir = Scratch::new();
let input = dir.0.join("input");
std::fs::create_dir(&input).unwrap();
+361 -356
View File
@@ -26,133 +26,6 @@ fn doc() -> Document {
Document::with_background("t", Size::new(300, 200), ColorMode::Rgb, SampleType::U8, Color::rgba(0.2, 0.5, 0.8, 1.0))
}
#[test]
fn composite_reuse_reports_held_bytes_and_honors_the_canvas_override() {
let _gpu = gpu_lock();
let Some(rs) = render_state() else { return };
let g = GpuCanvas::new(&rs);
let mut d = doc();
d.layers.push(photocraft_doc::Layer::new("top", photocraft_doc::LayerContent::Fill(photocraft_doc::Fill::Solid(Color::rgba(0.8, 0.1, 0.2, 0.5)))));
g.set_memory_budget(1 << 30);
g.set_composite_cache_budget(0);
assert_eq!(g.composite(&d, d.bounds(), false).unwrap().prefix_hits, 0);
assert_eq!(g.compositor_bytes().unwrap().1, 0, "no effect maps or composite chunks");
g.set_composite_cache_budget(512 << 20);
assert_eq!(g.composite(&d, d.bounds(), false).unwrap().prefix_hits, 0);
let bpp = if photocraft_gpu::Compositor::preferred_acc_format(&rs.adapter) == eframe::wgpu::TextureFormat::Rgba32Float { 16 } else { 8 };
// The cache holds whole chunk-aligned cells, not the document's exact rectangle.
let cell = u64::from(photocraft_gpu::CHUNK);
let cells = u64::from(d.size.width).div_ceil(cell) * cell * u64::from(d.size.height).div_ceil(cell) * cell;
assert_eq!(g.compositor_bytes().unwrap().1 as u64, cells * bpp);
d.layers[1].opacity = 0.4;
assert!(g.composite(&d, d.bounds(), false).unwrap().prefix_hits > 0);
g.set_composite_cache_budget(0);
g.set_memory_budget(512 << 20);
assert_eq!(g.composite(&d, d.bounds(), false).unwrap().prefix_hits, 0);
assert_eq!(g.compositor_bytes().unwrap().1, 0, "override survives the overall budget update");
}
#[test]
fn injected_loss_stops_gpu_work_without_panicking() {
let _gpu = gpu_lock();
let Some(rs) = render_state() else { return };
let g = GpuCanvas::new(&rs);
let d = doc();
let key = d.id.0;
let first = g.refresh(key, &d, None, None);
assert_ne!(first.kind, "lost");
assert!(g.fault().is_none());
g.health().mark(Fault::Lost("test".into()));
// Every entry point is a no-op or an error now.
let r = g.refresh(key, &d, None, None);
assert_eq!(r.kind, "lost");
assert!(r.fallback.as_ref().is_some_and(|f| f.to_string().contains("GPU device lost")));
assert!(g.composite(&d, d.bounds(), false).is_err());
assert!(!g.upload_rect(key, [0, 0], [1, 1], &[0; 4]));
g.upload_full(key, [1, 1], &[0; 4]);
g.set_display_lut(key, 0, 2, Some(&[0; 32]));
assert!(g.read_texels(key).is_none());
g.release();
assert!(!g.has(key, [300, 200]));
}
#[test]
fn destroyed_device_falls_back_without_panicking() {
let _gpu = gpu_lock();
let Some(rs) = render_state() else { return };
let g = GpuCanvas::new(&rs);
let d = doc();
let key = d.id.0;
g.refresh(key, &d, None, None);
rs.device.destroy();
// The next refreshes run into the destroyed device: errors are recorded, nothing panics.
let mut d2 = d.clone();
d2.layers[0].opacity = 0.5;
for _ in 0..3 {
let r = g.refresh(key, &d2, Some(photocraft_geom::Rect::new(0, 0, 50, 50)), None);
if r.kind == "lost" {
break;
}
}
assert!(g.read_texels(key).is_none() || g.fault().is_some());
assert!(g.fault().is_some(), "device loss not detected");
assert_eq!(g.refresh(key, &d2, None, None).kind, "lost");
}
#[test]
fn app_switches_to_the_cpu_canvas_and_keeps_the_documents() {
let _gpu = gpu_lock();
let Some(rs) = render_state() else { return };
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), photocraft_ui_egui::Services::default());
app.set_wgpu(rs);
app.run("file.new", json!({"width": 320, "height": 240})).unwrap();
app.sync_views();
assert!(app.gpu_active());
assert_eq!(app.perf.gpu_info.canvas, "gpu");
let started = std::rc::Rc::new(std::cell::Cell::new(false));
let flag = started.clone();
app.on_started(move |_| flag.set(true));
let mut h = egui_kittest::Harness::builder().with_context(app.ctx().clone()).with_size(egui::vec2(1000.0, 700.0)).build_ui_state(
|ui, app: &mut Box<PhotocraftApp>| {
let ctx = ui.ctx().clone();
if !ctx.fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
return;
}
app.check_gpu(&ctx);
egui::CentralPanel::default().show(ui, |ui| photocraft_ui_egui::canvas::document_area(app, ui));
app.check_gpu(&ctx);
},
app,
);
PhotocraftApp::setup_context(&h.ctx, photocraft_ui_egui::theme::AppTheme::pro());
h.run_steps(4);
assert!(h.state().gpu_active(), "GPU canvas in use before the loss");
// The device is lost (e.g. the OS killed a huge submission).
h.state().gpu_health().unwrap().mark(Fault::Lost("killed by the OS".into()));
h.run_steps(3);
let app = h.state();
assert!(!app.gpu_active(), "still on the GPU canvas");
assert_eq!(app.session.documents().len(), 1, "document kept");
assert_eq!(app.ui.status, gpu_status::LOST_MESSAGE);
assert!(app.ui.status_error);
assert!(app.ui.gpu_fallback_notice.as_deref().unwrap_or("").contains("killed by the OS"));
// UI passes drain the outbox into toasts, so the window's cards are checked as well.
let cards = craft::ui::runtime::toast::cards(&h.ctx, &craft::ui::runtime::env::WindowKey::main());
assert!(app.ui.notices.is_empty() && cards.is_empty(), "one recovery warning, no duplicate notice");
assert!(app.perf.gpu_info.lost.as_deref().unwrap_or("").contains("killed by the OS"));
assert_eq!(app.perf.gpu_info.canvas, "cpu");
// The CPU path draws the document: a refresh after the loss is a CPU one.
assert!(matches!(app.perf.last_refresh, "full" | "rect"), "{}", app.perf.last_refresh);
// Editing keeps working.
h.state_mut().run("layer.new.layer", json!({})).unwrap();
h.run_steps(2);
assert_eq!(h.state().session.active().map(|d| d.doc.layers.len()), Some(2));
// The perf output carries the state for agents.
let perf = serde_json::to_value(&h.state().perf).unwrap();
assert_eq!(perf["gpuInfo"]["canvas"], "cpu");
let _ = started;
}
#[test]
fn started_hook_runs_once_after_the_first_frames() {
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), photocraft_ui_egui::Services::default());
@@ -189,241 +62,373 @@ fn system_info_lists_the_graphics_state() {
assert_eq!(v["gpu"]["adapter"], "Test GPU");
}
/// A canvas whose display textures exceed the canvas budget gets none: no texture set is built,
/// the refresh says so and the app draws it on the CPU canvas instead (#2934).
#[test]
fn canvas_over_the_texture_budget_builds_no_textures() {
let _gpu = gpu_lock();
let Some(rs) = render_state() else { return };
let g = GpuCanvas::new(&rs);
let d = doc();
let (key, size) = (d.id.0, [d.size.width, d.size.height]);
// Less than the full-resolution level alone.
g.set_canvas_budget(u64::from(size[0] * size[1]) * 4 - 1);
assert!(!g.fits_canvas(&d));
let r = g.refresh(key, &d, None, None);
assert_eq!(r.kind, gpu_canvas::REFRESH_OVER_BUDGET);
assert!(!g.has(key, size) && g.texture_info(key).is_none());
assert!(g.composite(&d, d.bounds(), false).is_err());
g.upload_full(key, size, &vec![0; size[0] as usize * size[1] as usize * 4]);
assert!(g.texture_info(key).is_none(), "no entry point builds the set");
// Within the budget the same document is drawn on the GPU, at the bytes it was priced at.
g.set_canvas_budget(1 << 30);
assert!(g.fits_canvas(&d));
assert_ne!(g.refresh(key, &d, None, None).kind, gpu_canvas::REFRESH_OVER_BUDGET);
assert!(g.has(key, size));
let (format, bytes) = g.texture_info(key).unwrap();
let bpp = if format == eframe::wgpu::TextureFormat::Rgba16Float { 8 } else { 4 };
assert_eq!(bytes, gpu_canvas::canvas_texture_bytes(size, gpu_canvas::DEFAULT_TILE, bpp));
// Shrinking the budget below an existing set drops it on the next refresh.
g.set_canvas_budget(1);
assert_eq!(g.refresh(key, &d, None, None).kind, gpu_canvas::REFRESH_OVER_BUDGET);
assert!(g.texture_info(key).is_none());
g.release();
}
mod gpu_tests {
use super::*;
/// #3438, #1215: when the window's own device is really lost (a driver reset, for example after
/// the PC slept), egui-wgpu can't draw another frame. One with shapes panicked inside it ("Failed
/// to create staging buffer for index data"), and a frozen window's close button opened an
/// unsaved-changes prompt nobody could see. Now the app draws nothing, writes the unsaved document
/// for recovery and closes. Runs the real frame loop on the harness's own device.
#[test]
fn a_lost_window_device_saves_unsaved_work_for_recovery_and_closes() {
let _gpu = gpu_lock();
let log = std::sync::Arc::new(std::sync::Mutex::new(Vec::<String>::new()));
let (autosaves, flushes) = (log.clone(), log.clone());
let render_state = std::sync::Arc::new(std::sync::Mutex::new(None::<RenderState>));
let window = render_state.clone();
let built = std::panic::catch_unwind(std::panic::AssertUnwindSafe(move || {
egui_kittest::Harness::builder().with_size(egui::vec2(1000.0, 700.0)).with_max_steps(16).wgpu().build_eframe(move |cc| {
PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
let services = photocraft_ui_egui::Services {
autosave: Some(Box::new(move |doc: &std::sync::Arc<Document>, revision: u64, _: Option<&str>| {
autosaves.lock().unwrap().push(format!("autosave {} {revision}", doc.id.0));
Ok(())
})),
flush_autosaves: Some(Box::new(move || {
flushes.lock().unwrap().push("flush".into());
Vec::new()
})),
..Default::default()
};
let mut app = PhotocraftApp::with_context(cc.egui_ctx.clone(), photocraft_engine::Session::new(), services);
if let Some(rs) = cc.wgpu_render_state.as_ref() {
*window.lock().unwrap() = Some(rs.clone());
app.set_wgpu(rs.clone());
#[test]
fn composite_reuse_reports_held_bytes_and_honors_the_canvas_override() {
let _gpu = gpu_lock();
let Some(rs) = render_state() else { return };
let g = GpuCanvas::new(&rs);
let mut d = doc();
d.layers.push(photocraft_doc::Layer::new("top", photocraft_doc::LayerContent::Fill(photocraft_doc::Fill::Solid(Color::rgba(0.8, 0.1, 0.2, 0.5)))));
g.set_memory_budget(1 << 30);
g.set_composite_cache_budget(0);
assert_eq!(g.composite(&d, d.bounds(), false).unwrap().prefix_hits, 0);
assert_eq!(g.compositor_bytes().unwrap().1, 0, "no effect maps or composite chunks");
g.set_composite_cache_budget(512 << 20);
assert_eq!(g.composite(&d, d.bounds(), false).unwrap().prefix_hits, 0);
let bpp = if photocraft_gpu::Compositor::preferred_acc_format(&rs.adapter) == eframe::wgpu::TextureFormat::Rgba32Float { 16 } else { 8 };
// The cache holds whole chunk-aligned cells, not the document's exact rectangle.
let cell = u64::from(photocraft_gpu::CHUNK);
let cells = u64::from(d.size.width).div_ceil(cell) * cell * u64::from(d.size.height).div_ceil(cell) * cell;
assert_eq!(g.compositor_bytes().unwrap().1 as u64, cells * bpp);
d.layers[1].opacity = 0.4;
assert!(g.composite(&d, d.bounds(), false).unwrap().prefix_hits > 0);
g.set_composite_cache_budget(0);
g.set_memory_budget(512 << 20);
assert_eq!(g.composite(&d, d.bounds(), false).unwrap().prefix_hits, 0);
assert_eq!(g.compositor_bytes().unwrap().1, 0, "override survives the overall budget update");
}
#[test]
fn injected_loss_stops_gpu_work_without_panicking() {
let _gpu = gpu_lock();
let Some(rs) = render_state() else { return };
let g = GpuCanvas::new(&rs);
let d = doc();
let key = d.id.0;
let first = g.refresh(key, &d, None, None);
assert_ne!(first.kind, "lost");
assert!(g.fault().is_none());
g.health().mark(Fault::Lost("test".into()));
// Every entry point is a no-op or an error now.
let r = g.refresh(key, &d, None, None);
assert_eq!(r.kind, "lost");
assert!(r.fallback.as_ref().is_some_and(|f| f.to_string().contains("GPU device lost")));
assert!(g.composite(&d, d.bounds(), false).is_err());
assert!(!g.upload_rect(key, [0, 0], [1, 1], &[0; 4]));
g.upload_full(key, [1, 1], &[0; 4]);
g.set_display_lut(key, 0, 2, Some(&[0; 32]));
assert!(g.read_texels(key).is_none());
g.release();
assert!(!g.has(key, [300, 200]));
}
#[test]
fn destroyed_device_falls_back_without_panicking() {
let _gpu = gpu_lock();
let Some(rs) = render_state() else { return };
let g = GpuCanvas::new(&rs);
let d = doc();
let key = d.id.0;
g.refresh(key, &d, None, None);
rs.device.destroy();
// The next refreshes run into the destroyed device: errors are recorded, nothing panics.
let mut d2 = d.clone();
d2.layers[0].opacity = 0.5;
for _ in 0..3 {
let r = g.refresh(key, &d2, Some(photocraft_geom::Rect::new(0, 0, 50, 50)), None);
if r.kind == "lost" {
break;
}
app.run("file.new", json!({"width": 320, "height": 240})).unwrap();
app.run("layer.new.layer", json!({})).unwrap();
app
})
}));
// Upload and submit the last frame's shapes the way the window's renderer does each frame: on
// a lost device, egui-wgpu panics here when there is anything to draw (#1215).
let upload = |h: &egui_kittest::Harness<'_, Box<PhotocraftApp>>| {
let rs = render_state.lock().unwrap().clone().expect("the harness renders with wgpu");
let output = h.output();
let jobs = h.ctx.tessellate(output.shapes.clone(), output.pixels_per_point);
let screen = eframe::egui_wgpu::ScreenDescriptor { size_in_pixels: [1000, 700], pixels_per_point: output.pixels_per_point };
let mut encoder = rs.device.create_command_encoder(&Default::default());
let uploaded = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let commands = rs.renderer.write().update_buffers(&rs.device, &rs.queue, &mut encoder, &jobs, &screen);
rs.queue.submit(commands.into_iter().chain([encoder.finish()]));
}));
(jobs.len(), uploaded.is_ok())
};
let Ok(mut h) = built else {
eprintln!("skipping: no GPU adapter");
return;
};
h.run_steps(4);
let (jobs, uploaded) = upload(&h);
assert!(jobs > 0 && uploaded, "draws before the loss");
let (doc, revision, dirty) = h.state().session.active().map(|d| (d.doc.id.0, d.revision, d.is_dirty())).unwrap();
assert!(dirty, "the new layer is unsaved");
assert!(log.lock().unwrap().is_empty(), "no autosave before the loss");
assert!(h.state_mut().destroy_window_device());
// wgpu reports a destroyed device lost once the work submitted before finished (slow on a
// software adapter); a driver reset reports it at once.
if let Some(rs) = render_state.lock().unwrap().as_ref() {
let _ = rs.device.poll(eframe::wgpu::PollType::Wait { submission_index: None, timeout: Some(std::time::Duration::from_secs(30)) });
}
h.run_steps(2);
assert!(h.state().window_lost(), "the loss was noticed");
assert_eq!(*log.lock().unwrap(), vec![format!("autosave {doc} {revision}"), "flush".to_string()], "saved for recovery once");
// The frame on the lost device has nothing to draw, so egui-wgpu has nothing to upload.
assert_eq!(upload(&h), (0, true), "a frame with shapes panics inside egui-wgpu on a lost device");
assert_eq!(h.state().session.documents().len(), 1, "the document stays until the app closes");
}
/// #6464 review: when the recovery save fails (a full disk, say), closing would lose the work, so
/// the app stays open with the document and tries again until the write succeeds, then closes.
#[test]
fn a_lost_window_device_closes_only_once_unsaved_work_is_saved() {
let _gpu = gpu_lock();
let disk_full = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(true));
let attempts = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let (full, tries) = (disk_full.clone(), attempts.clone());
let pending = std::sync::Arc::new(std::sync::Mutex::new(Vec::<(u64, u64)>::new()));
let queued = pending.clone();
let built = std::panic::catch_unwind(std::panic::AssertUnwindSafe(move || {
egui_kittest::Harness::builder().with_size(egui::vec2(1000.0, 700.0)).with_max_steps(16).wgpu().build_eframe(move |cc| {
PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
let services = photocraft_ui_egui::Services {
autosave: Some(Box::new(move |doc: &std::sync::Arc<Document>, revision: u64, _: Option<&str>| {
queued.lock().unwrap().push((doc.id.0, revision));
Ok(())
})),
autosave_results: Some(Box::new(Vec::new)),
flush_autosaves: Some(Box::new(move || {
tries.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
let outcome = if full.load(std::sync::atomic::Ordering::SeqCst) { Err("disk full".to_string()) } else { Ok(()) };
pending.lock().unwrap().drain(..).map(|(id, revision)| (id, revision, outcome.clone())).collect()
})),
..Default::default()
};
let mut app = PhotocraftApp::with_context(cc.egui_ctx.clone(), photocraft_engine::Session::new(), services);
if let Some(rs) = cc.wgpu_render_state.as_ref() {
app.set_wgpu(rs.clone());
}
app.run("file.new", json!({"width": 320, "height": 240})).unwrap();
app.run("layer.new.layer", json!({})).unwrap();
app
})
}));
let Ok(mut h) = built else {
eprintln!("skipping: no GPU adapter");
return;
};
h.run_steps(4);
assert!(h.state_mut().destroy_window_device());
for _ in 0..120 {
h.run_steps(1);
if h.state().window_lost() {
break;
}
std::thread::sleep(std::time::Duration::from_millis(250));
assert!(g.read_texels(key).is_none() || g.fault().is_some());
assert!(g.fault().is_some(), "device loss not detected");
assert_eq!(g.refresh(key, &d2, None, None).kind, "lost");
}
assert!(h.state().window_lost(), "the loss was noticed");
let tries = || attempts.load(std::sync::atomic::Ordering::SeqCst);
assert_eq!(tries(), 1);
assert!(h.state().has_unsaved_work(), "a failed recovery save doesn't let the app close");
// Each step is 0.25 s: no new attempt before the retry interval.
h.run_steps(4);
assert_eq!(tries(), 1, "waits before trying again");
h.run_steps(5);
assert_eq!(tries(), 2, "tries again");
assert!(h.state().has_unsaved_work());
disk_full.store(false, std::sync::atomic::Ordering::SeqCst);
h.run_steps(9);
assert_eq!(tries(), 3);
assert!(!h.state().has_unsaved_work(), "closes once the work is saved");
h.run_steps(9);
assert_eq!(tries(), 3, "saved once, not again");
assert_eq!(h.state().session.documents().len(), 1, "the document stays until the app closes");
}
/// Uploaded tiles retain their own placement when painted in the same view.
#[test]
fn tiled_canvas_keeps_tiles_in_place() {
use photocraft_ui_egui::gpu_canvas::ViewParams;
let tile_override = std::env::var("PHOTOCRAFT_GPU_TILE").ok().and_then(|v| v.parse::<u32>().ok());
if tile_override.is_some_and(|tile| tile > 64) {
eprintln!("skipping: PHOTOCRAFT_GPU_TILE must be at most 64 for this two-tile test");
return;
}
let _gpu = gpu_lock();
const N: u32 = 2;
const W: u32 = N * 64;
const H: u32 = 64;
let color = |tile: u32| if tile == 0 { [255, 0, 0, 255] } else { [0, 0, 255, 255] };
let rgba: Vec<u8> = (0..W * H).flat_map(|i| color((i % W) / 64)).collect();
struct TileApp {
canvas: GpuCanvas,
params: ViewParams,
}
impl eframe::App for TileApp {
fn ui(&mut self, ui: &mut egui::Ui, _: &mut eframe::Frame) {
GpuCanvas::paint(ui.painter(), egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(W as f32, H as f32)), self.params);
}
}
let Ok(builder) = std::panic::catch_unwind(|| egui_kittest::Harness::builder().with_size(egui::vec2(W as f32, H as f32)).with_pixels_per_point(1.0).wgpu())
else {
eprintln!("skipping: no GPU adapter");
return;
};
let mut h = builder.build_eframe(|cc| {
let rs = cc.wgpu_render_state.as_ref().expect("render state");
let info = rs.adapter.get_info();
eprintln!("tiled canvas adapter {info:?}");
// Small tiles exercise the placement bindings without a large canvas.
let canvas = GpuCanvas::with_tile(rs, Some(64));
canvas.upload_full(1, [W, H], &rgba);
TileApp {
canvas,
params: ViewParams {
doc: 1,
doc_size: [W, H],
zoom: 1.0,
center: [W as f32 / 2.0, H as f32 / 2.0],
rotation: 0.0,
view_key: 1,
display: 0,
output: 0,
hdr: None,
#[test]
fn app_switches_to_the_cpu_canvas_and_keeps_the_documents() {
let _gpu = gpu_lock();
let Some(rs) = render_state() else { return };
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), photocraft_ui_egui::Services::default());
app.set_wgpu(rs);
app.run("file.new", json!({"width": 320, "height": 240})).unwrap();
app.sync_views();
assert!(app.gpu_active());
assert_eq!(app.perf.gpu_info.canvas, "gpu");
let started = std::rc::Rc::new(std::cell::Cell::new(false));
let flag = started.clone();
app.on_started(move |_| flag.set(true));
let mut h = egui_kittest::Harness::builder().with_context(app.ctx().clone()).with_size(egui::vec2(1000.0, 700.0)).build_ui_state(
|ui, app: &mut Box<PhotocraftApp>| {
let ctx = ui.ctx().clone();
if !ctx.fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
return;
}
app.check_gpu(&ctx);
egui::CentralPanel::default().show(ui, |ui| photocraft_ui_egui::canvas::document_area(app, ui));
app.check_gpu(&ctx);
},
app,
);
PhotocraftApp::setup_context(&h.ctx, photocraft_ui_egui::theme::AppTheme::pro());
h.run_steps(4);
assert!(h.state().gpu_active(), "GPU canvas in use before the loss");
// The device is lost (e.g. the OS killed a huge submission).
h.state().gpu_health().unwrap().mark(Fault::Lost("killed by the OS".into()));
h.run_steps(3);
let app = h.state();
assert!(!app.gpu_active(), "still on the GPU canvas");
assert_eq!(app.session.documents().len(), 1, "document kept");
assert_eq!(app.ui.status, gpu_status::LOST_MESSAGE);
assert!(app.ui.status_error);
assert!(app.ui.gpu_fallback_notice.as_deref().unwrap_or("").contains("killed by the OS"));
// UI passes drain the outbox into toasts, so the window's cards are checked as well.
let cards = craft::ui::runtime::toast::cards(&h.ctx, &craft::ui::runtime::env::WindowKey::main());
assert!(app.ui.notices.is_empty() && cards.is_empty(), "one recovery warning, no duplicate notice");
assert!(app.perf.gpu_info.lost.as_deref().unwrap_or("").contains("killed by the OS"));
assert_eq!(app.perf.gpu_info.canvas, "cpu");
// The CPU path draws the document: a refresh after the loss is a CPU one.
assert!(matches!(app.perf.last_refresh, "full" | "rect"), "{}", app.perf.last_refresh);
// Editing keeps working.
h.state_mut().run("layer.new.layer", json!({})).unwrap();
h.run_steps(2);
assert_eq!(h.state().session.active().map(|d| d.doc.layers.len()), Some(2));
// The perf output carries the state for agents.
let perf = serde_json::to_value(&h.state().perf).unwrap();
assert_eq!(perf["gpuInfo"]["canvas"], "cpu");
let _ = started;
}
/// A canvas whose display textures exceed the canvas budget gets none: no texture set is built,
/// the refresh says so and the app draws it on the CPU canvas instead (#2934).
#[test]
fn canvas_over_the_texture_budget_builds_no_textures() {
let _gpu = gpu_lock();
let Some(rs) = render_state() else { return };
let g = GpuCanvas::new(&rs);
let d = doc();
let (key, size) = (d.id.0, [d.size.width, d.size.height]);
// Less than the full-resolution level alone.
g.set_canvas_budget(u64::from(size[0] * size[1]) * 4 - 1);
assert!(!g.fits_canvas(&d));
let r = g.refresh(key, &d, None, None);
assert_eq!(r.kind, gpu_canvas::REFRESH_OVER_BUDGET);
assert!(!g.has(key, size) && g.texture_info(key).is_none());
assert!(g.composite(&d, d.bounds(), false).is_err());
g.upload_full(key, size, &vec![0; size[0] as usize * size[1] as usize * 4]);
assert!(g.texture_info(key).is_none(), "no entry point builds the set");
// Within the budget the same document is drawn on the GPU, at the bytes it was priced at.
g.set_canvas_budget(1 << 30);
assert!(g.fits_canvas(&d));
assert_ne!(g.refresh(key, &d, None, None).kind, gpu_canvas::REFRESH_OVER_BUDGET);
assert!(g.has(key, size));
let (format, bytes) = g.texture_info(key).unwrap();
let bpp = if format == eframe::wgpu::TextureFormat::Rgba16Float { 8 } else { 4 };
assert_eq!(bytes, gpu_canvas::canvas_texture_bytes(size, gpu_canvas::DEFAULT_TILE, bpp));
// Shrinking the budget below an existing set drops it on the next refresh.
g.set_canvas_budget(1);
assert_eq!(g.refresh(key, &d, None, None).kind, gpu_canvas::REFRESH_OVER_BUDGET);
assert!(g.texture_info(key).is_none());
g.release();
}
/// #3438, #1215: when the window's own device is really lost (a driver reset, for example after
/// the PC slept), egui-wgpu can't draw another frame. One with shapes panicked inside it ("Failed
/// to create staging buffer for index data"), and a frozen window's close button opened an
/// unsaved-changes prompt nobody could see. Now the app draws nothing, writes the unsaved document
/// for recovery and closes. Runs the real frame loop on the harness's own device.
#[test]
fn a_lost_window_device_saves_unsaved_work_for_recovery_and_closes() {
let _gpu = gpu_lock();
let log = std::sync::Arc::new(std::sync::Mutex::new(Vec::<String>::new()));
let (autosaves, flushes) = (log.clone(), log.clone());
let render_state = std::sync::Arc::new(std::sync::Mutex::new(None::<RenderState>));
let window = render_state.clone();
let built = std::panic::catch_unwind(std::panic::AssertUnwindSafe(move || {
egui_kittest::Harness::builder().with_size(egui::vec2(1000.0, 700.0)).with_max_steps(16).wgpu().build_eframe(move |cc| {
PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
let services = photocraft_ui_egui::Services {
autosave: Some(Box::new(move |doc: &std::sync::Arc<Document>, revision: u64, _: Option<&str>| {
autosaves.lock().unwrap().push(format!("autosave {} {revision}", doc.id.0));
Ok(())
})),
flush_autosaves: Some(Box::new(move || {
flushes.lock().unwrap().push("flush".into());
Vec::new()
})),
..Default::default()
};
let mut app = PhotocraftApp::with_context(cc.egui_ctx.clone(), photocraft_engine::Session::new(), services);
if let Some(rs) = cc.wgpu_render_state.as_ref() {
*window.lock().unwrap() = Some(rs.clone());
app.set_wgpu(rs.clone());
}
app.run("file.new", json!({"width": 320, "height": 240})).unwrap();
app.run("layer.new.layer", json!({})).unwrap();
app
})
}));
// Upload and submit the last frame's shapes the way the window's renderer does each frame: on
// a lost device, egui-wgpu panics here when there is anything to draw (#1215).
let upload = |h: &egui_kittest::Harness<'_, Box<PhotocraftApp>>| {
let rs = render_state.lock().unwrap().clone().expect("the harness renders with wgpu");
let output = h.output();
let jobs = h.ctx.tessellate(output.shapes.clone(), output.pixels_per_point);
let screen = eframe::egui_wgpu::ScreenDescriptor { size_in_pixels: [1000, 700], pixels_per_point: output.pixels_per_point };
let mut encoder = rs.device.create_command_encoder(&Default::default());
let uploaded = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let commands = rs.renderer.write().update_buffers(&rs.device, &rs.queue, &mut encoder, &jobs, &screen);
rs.queue.submit(commands.into_iter().chain([encoder.finish()]));
}));
(jobs.len(), uploaded.is_ok())
};
let Ok(mut h) = built else {
eprintln!("skipping: no GPU adapter");
return;
};
h.run_steps(4);
let (jobs, uploaded) = upload(&h);
assert!(jobs > 0 && uploaded, "draws before the loss");
let (doc, revision, dirty) = h.state().session.active().map(|d| (d.doc.id.0, d.revision, d.is_dirty())).unwrap();
assert!(dirty, "the new layer is unsaved");
assert!(log.lock().unwrap().is_empty(), "no autosave before the loss");
assert!(h.state_mut().destroy_window_device());
// wgpu reports a destroyed device lost once the work submitted before finished (slow on a
// software adapter); a driver reset reports it at once.
if let Some(rs) = render_state.lock().unwrap().as_ref() {
let _ = rs.device.poll(eframe::wgpu::PollType::Wait { submission_index: None, timeout: Some(std::time::Duration::from_secs(30)) });
}
});
let (_, size, pixels) = h.state().canvas.read_texels(1).expect("uploaded pixels");
assert_eq!(size, [W, H]);
for tile in 0..N {
assert_eq!(pixels[(32 * W + tile * 64 + 32) as usize], color(tile).map(|v| f32::from(v) / 255.0), "upload tile {tile}");
h.run_steps(2);
assert!(h.state().window_lost(), "the loss was noticed");
assert_eq!(*log.lock().unwrap(), vec![format!("autosave {doc} {revision}"), "flush".to_string()], "saved for recovery once");
// The frame on the lost device has nothing to draw, so egui-wgpu has nothing to upload.
assert_eq!(upload(&h), (0, true), "a frame with shapes panics inside egui-wgpu on a lost device");
assert_eq!(h.state().session.documents().len(), 1, "the document stays until the app closes");
}
/// #6464 review: when the recovery save fails (a full disk, say), closing would lose the work, so
/// the app stays open with the document and tries again until the write succeeds, then closes.
#[test]
fn a_lost_window_device_closes_only_once_unsaved_work_is_saved() {
let _gpu = gpu_lock();
let disk_full = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(true));
let attempts = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let (full, tries) = (disk_full.clone(), attempts.clone());
let pending = std::sync::Arc::new(std::sync::Mutex::new(Vec::<(u64, u64)>::new()));
let queued = pending.clone();
let built = std::panic::catch_unwind(std::panic::AssertUnwindSafe(move || {
egui_kittest::Harness::builder().with_size(egui::vec2(1000.0, 700.0)).with_max_steps(16).wgpu().build_eframe(move |cc| {
PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
let services = photocraft_ui_egui::Services {
autosave: Some(Box::new(move |doc: &std::sync::Arc<Document>, revision: u64, _: Option<&str>| {
queued.lock().unwrap().push((doc.id.0, revision));
Ok(())
})),
autosave_results: Some(Box::new(Vec::new)),
flush_autosaves: Some(Box::new(move || {
tries.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
let outcome = if full.load(std::sync::atomic::Ordering::SeqCst) { Err("disk full".to_string()) } else { Ok(()) };
pending.lock().unwrap().drain(..).map(|(id, revision)| (id, revision, outcome.clone())).collect()
})),
..Default::default()
};
let mut app = PhotocraftApp::with_context(cc.egui_ctx.clone(), photocraft_engine::Session::new(), services);
if let Some(rs) = cc.wgpu_render_state.as_ref() {
app.set_wgpu(rs.clone());
}
app.run("file.new", json!({"width": 320, "height": 240})).unwrap();
app.run("layer.new.layer", json!({})).unwrap();
app
})
}));
let Ok(mut h) = built else {
eprintln!("skipping: no GPU adapter");
return;
};
h.run_steps(4);
assert!(h.state_mut().destroy_window_device());
for _ in 0..120 {
h.run_steps(1);
if h.state().window_lost() {
break;
}
std::thread::sleep(std::time::Duration::from_millis(250));
}
assert!(h.state().window_lost(), "the loss was noticed");
let tries = || attempts.load(std::sync::atomic::Ordering::SeqCst);
assert_eq!(tries(), 1);
assert!(h.state().has_unsaved_work(), "a failed recovery save doesn't let the app close");
// Each step is 0.25 s: no new attempt before the retry interval.
h.run_steps(4);
assert_eq!(tries(), 1, "waits before trying again");
h.run_steps(5);
assert_eq!(tries(), 2, "tries again");
assert!(h.state().has_unsaved_work());
disk_full.store(false, std::sync::atomic::Ordering::SeqCst);
h.run_steps(9);
assert_eq!(tries(), 3);
assert!(!h.state().has_unsaved_work(), "closes once the work is saved");
h.run_steps(9);
assert_eq!(tries(), 3, "saved once, not again");
assert_eq!(h.state().session.documents().len(), 1, "the document stays until the app closes");
}
/// Uploaded tiles retain their own placement when painted in the same view.
#[test]
fn tiled_canvas_keeps_tiles_in_place() {
use photocraft_ui_egui::gpu_canvas::ViewParams;
let tile_override = std::env::var("PHOTOCRAFT_GPU_TILE").ok().and_then(|v| v.parse::<u32>().ok());
if tile_override.is_some_and(|tile| tile > 64) {
eprintln!("skipping: PHOTOCRAFT_GPU_TILE must be at most 64 for this two-tile test");
return;
}
let _gpu = gpu_lock();
const N: u32 = 2;
const W: u32 = N * 64;
const H: u32 = 64;
let color = |tile: u32| if tile == 0 { [255, 0, 0, 255] } else { [0, 0, 255, 255] };
let rgba: Vec<u8> = (0..W * H).flat_map(|i| color((i % W) / 64)).collect();
struct TileApp {
canvas: GpuCanvas,
params: ViewParams,
}
impl eframe::App for TileApp {
fn ui(&mut self, ui: &mut egui::Ui, _: &mut eframe::Frame) {
GpuCanvas::paint(ui.painter(), egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(W as f32, H as f32)), self.params);
}
}
let Ok(builder) =
std::panic::catch_unwind(|| egui_kittest::Harness::builder().with_size(egui::vec2(W as f32, H as f32)).with_pixels_per_point(1.0).wgpu())
else {
eprintln!("skipping: no GPU adapter");
return;
};
let mut h = builder.build_eframe(|cc| {
let rs = cc.wgpu_render_state.as_ref().expect("render state");
let info = rs.adapter.get_info();
eprintln!("tiled canvas adapter {info:?}");
// Small tiles exercise the placement bindings without a large canvas.
let canvas = GpuCanvas::with_tile(rs, Some(64));
canvas.upload_full(1, [W, H], &rgba);
TileApp {
canvas,
params: ViewParams {
doc: 1,
doc_size: [W, H],
zoom: 1.0,
center: [W as f32 / 2.0, H as f32 / 2.0],
rotation: 0.0,
view_key: 1,
display: 0,
output: 0,
hdr: None,
},
}
});
let (_, size, pixels) = h.state().canvas.read_texels(1).expect("uploaded pixels");
assert_eq!(size, [W, H]);
for tile in 0..N {
assert_eq!(pixels[(32 * W + tile * 64 + 32) as usize], color(tile).map(|v| f32::from(v) / 255.0), "upload tile {tile}");
}
h.run_steps(3);
let image = h.render().expect("canvas frame");
let actual: Vec<_> = (0..N).map(|tile| image.get_pixel(tile * 64 + 32, 32).0).collect();
let expected: Vec<_> = (0..N).map(color).collect();
assert_eq!(actual, expected, "each tile must retain its own screen placement");
assert!(h.state().canvas.health().is_ok());
}
h.run_steps(3);
let image = h.render().expect("canvas frame");
let actual: Vec<_> = (0..N).map(|tile| image.get_pixel(tile * 64 + 32, 32).0).collect();
let expected: Vec<_> = (0..N).map(color).collect();
assert_eq!(actual, expected, "each tile must retain its own screen placement");
assert!(h.state().canvas.health().is_ok());
}
+40 -36
View File
@@ -215,44 +215,48 @@ fn the_move_preview_is_what_the_move_commits() {
}
}
#[test]
fn layout_document_composites_on_the_gpu_like_the_cpu() {
let _gpu = photocraft_testkit::gpu_lock();
use eframe::wgpu;
fn block_on<F: std::future::Future>(f: F) -> F::Output {
let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
let mut f = std::pin::pin!(f);
loop {
if let std::task::Poll::Ready(v) = f.as_mut().poll(&mut cx) {
return v;
mod gpu_tests {
use super::*;
#[test]
fn layout_document_composites_on_the_gpu_like_the_cpu() {
let _gpu = photocraft_testkit::gpu_lock();
use eframe::wgpu;
fn block_on<F: std::future::Future>(f: F) -> F::Output {
let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
let mut f = std::pin::pin!(f);
loop {
if let std::task::Poll::Ready(v) = f.as_mut().poll(&mut cx) {
return v;
}
std::thread::yield_now();
}
std::thread::yield_now();
}
}
let Ok(adapter) =
block_on(wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env()).request_adapter(&wgpu::RequestAdapterOptions::default()))
else {
eprintln!("skipping: no GPU adapter");
return;
};
if photocraft_gpu::Compositor::preferred_acc_format(&adapter) != wgpu::TextureFormat::Rgba32Float {
eprintln!("skipping: adapter can't render Rgba32Float");
return;
}
let Ok((device, queue)) = block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())) else { return };
let Ok(mut comp) = photocraft_gpu::Compositor::try_new_with_format(&device, wgpu::TextureFormat::Rgba32Float) else { return };
let (d, _) = layout_doc::build(layout_doc::Spec::small());
let (_, texts) = layout_doc::count(&d);
assert!(texts >= 10);
assert!(d.walk().iter().any(|(_, _, l)| matches!(l.content, LayerContent::Smart(_))));
let cpu = photocraft_compose::flatten(&d);
let gpu = photocraft_gpu::render_to_vec(&mut comp, &device, &queue, &d, d.bounds()).expect("the layout composites on the GPU");
let mut worst = 0.0f32;
for (c, g) in cpu.px.iter().zip(&gpu) {
for k in 0..4 {
let (a, b) = if k == 3 { (c[3], g[3]) } else { (c[k] * c[3], g[k] * g[3]) };
worst = worst.max((a - b).abs());
let Ok(adapter) = block_on(
wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env()).request_adapter(&wgpu::RequestAdapterOptions::default()),
) else {
eprintln!("skipping: no GPU adapter");
return;
};
if photocraft_gpu::Compositor::preferred_acc_format(&adapter) != wgpu::TextureFormat::Rgba32Float {
eprintln!("skipping: adapter can't render Rgba32Float");
return;
}
let Ok((device, queue)) = block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())) else { return };
let Ok(mut comp) = photocraft_gpu::Compositor::try_new_with_format(&device, wgpu::TextureFormat::Rgba32Float) else { return };
let (d, _) = layout_doc::build(layout_doc::Spec::small());
let (_, texts) = layout_doc::count(&d);
assert!(texts >= 10);
assert!(d.walk().iter().any(|(_, _, l)| matches!(l.content, LayerContent::Smart(_))));
let cpu = photocraft_compose::flatten(&d);
let gpu = photocraft_gpu::render_to_vec(&mut comp, &device, &queue, &d, d.bounds()).expect("the layout composites on the GPU");
let mut worst = 0.0f32;
for (c, g) in cpu.px.iter().zip(&gpu) {
for k in 0..4 {
let (a, b) = if k == 3 { (c[3], g[3]) } else { (c[k] * c[3], g[k] * g[3]) };
worst = worst.max((a - b).abs());
}
}
assert!(worst <= 2.0 / 255.0, "GPU differs from the CPU by {}/255", worst * 255.0);
}
assert!(worst <= 2.0 / 255.0, "GPU differs from the CPU by {}/255", worst * 255.0);
}
+16 -11
View File
@@ -2,26 +2,18 @@
mod actions_duplicate;
mod actions_panel_menu;
mod adjust_preview_gpu;
mod arbitrary_rotation_preview;
mod batch_export_options;
mod brush_reset_defaults;
mod camera_raw_histogram;
mod camera_raw_scope;
mod canvas_16f;
mod checker_canvas;
mod clipboard_svg;
mod color_managed_canvas;
mod crop_ctrl_straighten;
mod crop_defaults;
mod crop_options_bar_chrome;
mod crop_task_bar;
mod display_names;
mod display_shadows;
mod drag_preview_canvas;
mod eraser_reset_defaults;
mod flatpak_updates;
mod full_res_preview;
mod gpu_device_loss;
mod healing_reset_tip;
// The interactive bench's `#[cfg(test)]` reporting tests: CI runs `--tests`, never examples.
@@ -30,15 +22,12 @@ mod healing_reset_tip;
#[allow(dead_code)]
mod interactive_bench_reporting;
mod layout_perf;
mod live_stroke_canvas;
mod magnetic_lasso_right_click;
mod paint_bucket_all_layers;
mod pattern_preview_canvas;
mod radial_blur_center;
mod save_memory_gate;
mod system_locale;
mod tone_targets;
mod ui_scale_canvas;
mod variables_data_sets;
mod workspace_presets;
@@ -51,3 +40,19 @@ pub(crate) static HEADROOM: Mutex<()> = Mutex::new(());
pub(crate) fn lock(lock: &'static Mutex<()>) -> MutexGuard<'static, ()> {
lock.lock().unwrap_or_else(PoisonError::into_inner)
}
// Tests that draw on a GPU device. nextest runs every test in a `gpu_tests` module in its `gpu`
// test group (.config/nextest.toml); the rest run on the CPU canvas.
mod gpu_tests {
mod adjust_preview_gpu;
mod arbitrary_rotation_preview;
mod canvas_16f;
mod checker_canvas;
mod color_managed_canvas;
mod display_shadows;
mod drag_preview_canvas;
mod full_res_preview;
mod live_stroke_canvas;
mod pattern_preview_canvas;
mod ui_scale_canvas;
}
+1 -1
View File
@@ -65,7 +65,7 @@ cargo nextest run --workspace # parallel across binaries (cargo ins
cargo test --doc --workspace # nextest does not run doctests
```
[cargo-nextest](https://nexte.st) runs each test in its own process. `.config/nextest.toml` puts the GPU tests (`photocraft-gpu`, and ui-egui's integration and canvas/GPU tests) in a group of at most 4 at a time, because each process opens its own wgpu device and the in-process `gpu_lock()` no longer serializes them. On a 32-thread Windows machine the full workspace went from 297 s (`cargo test`) to about 120 s (#2204). Ignored tests run with `cargo nextest run --run-ignored only`. The longest sweeps (`photocraft-testkit`'s `Sweep`) run a quarter of their cases, a different quarter each UTC day; `PHOTOCRAFT_FULL_SWEEP=1` runs all of them, and `PHOTOCRAFT_SWEEP_PART=<n>` replays the part a failing run printed. CI runs it with `--profile ci` (fail-fast, a 10-minute hang timeout), plus `cargo test --doc` for the doctests (#6117); `PHOTOCRAFT_FULL_SWEEP=1 cargo test --workspace` stays the final check before a PR.
[cargo-nextest](https://nexte.st) runs each test in its own process. `.config/nextest.toml` puts the GPU tests (`photocraft-gpu`, and every test in a module named `gpu_tests` or `<name>_gpu_tests`: the tests that build a wgpu device) in a group of at most 4 at a time, because each process opens its own wgpu device and the in-process `gpu_lock()` no longer serializes them. Every other test runs on the CPU canvas at full parallelism, so a new test that needs a device goes in such a module. On a 32-thread Windows machine the full workspace went from 297 s (`cargo test`) to about 120 s (#2204). Ignored tests run with `cargo nextest run --run-ignored only`. The longest sweeps (`photocraft-testkit`'s `Sweep`) run a quarter of their cases, a different quarter each UTC day; `PHOTOCRAFT_FULL_SWEEP=1` runs all of them, and `PHOTOCRAFT_SWEEP_PART=<n>` replays the part a failing run printed. CI runs it with `--profile ci` (fail-fast, a 10-minute hang timeout), plus `cargo test --doc` for the doctests (#6117); `PHOTOCRAFT_FULL_SWEEP=1 cargo test --workspace` stays the final check before a PR.
### Long matrix tests and CI timings