LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
refactor(lightcraft-ui-egui): move render.rs thumbnail_tests to crates/ui-egui/src/render/thumbnail_tests.rs
aiongg2ca957b2968c
diff --git a/crates/ui-egui/src/render.rs b/crates/ui-egui/src/render.rsindex 973c0d8b8..31117b22e 100644--- a/crates/ui-egui/src/render.rs+++ b/crates/ui-egui/src/render.rs@@ -1073,778 +1073,7 @@ fn render_failure_message(slot: Slot, photo: PhotoId, source: Option<&lightcraft}#[cfg(test)]-mod thumbnail_tests {- use super::*;- use lightcraft_catalog::{Catalog, Op, Photo, Source};-- #[test]- fn render_failures_identify_the_file_for_thumbnail_and_view_slots() {- let source = Source::File { path: "/photos/trip/IMG_0042.nef".into() };- for slot in [Slot::Thumb(PhotoId(42)), Slot::Main, Slot::Before, Slot::Compare(1), Slot::Region] {- let message = render_failure_message(slot, PhotoId(42), Some(&source), "unsupported compression");- assert!(message.contains("/photos/trip/IMG_0042.nef"), "{message}");- assert!(message.contains("PhotoId(42)"), "{message}");- assert!(message.ends_with(": unsupported compression"), "{message}");- }- }-- #[test]- fn render_failure_paths_are_escaped_and_missing_sources_still_identified() {- let source = Source::File { path: "line\nbreak.nef".into() };- let message = render_failure_message(Slot::Main, PhotoId(42), Some(&source), "decode failed");- assert!(!message.contains('\n'));- assert!(message.contains("line\\nbreak.nef"));- assert!(render_failure_message(Slot::Main, PhotoId(42), None, "decode failed").contains("PhotoId(42), source unavailable"));- let demo = Source::Demo { scene: 7 };- assert!(render_failure_message(Slot::Main, PhotoId(42), Some(&demo), "decode failed").contains("demo scene 7"));- }-- struct Blocked;- impl RenderOffload for Blocked {- fn try_start(&mut self, _: Slot, job: RenderJob) -> Option<RenderJob> {- Some(job)- }- fn finished(&mut self) -> Vec<(Slot, RenderResult, f64)> {- vec![]- }- }- fn photo() -> Arc<Photo> {- Arc::new(Photo::new(PhotoId(1), Source::File { path: "audit.jpg".into() }, "audit.jpg", "JPEG", 6000, 4000, "2026-01-01"))- }- #[test]- fn snapshot_tracks_cow_edits_undo_reload_and_replacement() {- let mut catalog = Catalog::default();- catalog.apply(Op::AddPhoto { photo: Box::new((*photo()).clone()) }).unwrap();- let old = catalog.photo(PhotoId(1)).unwrap().clone();- let mut r = Renderer::default();- r.remember_thumb(&old, 384, 77, false);- r.pending.insert(Slot::Thumb(PhotoId(1)), (77, 10));- assert!(r.thumb_current(&old, 384, 10));- assert!(!r.thumb_current(&old, 512, 10));- let mut settings = lightcraft_develop::DevelopSettings::default();- settings.light.exposure = 1.0;- let undo = catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(settings), label: "edit".into(), edited: None }).unwrap();- assert!(!r.thumb_current(catalog.photo(PhotoId(1)).unwrap(), 384, 10));- catalog.apply(undo).unwrap();- assert!(!r.thumb_current(catalog.photo(PhotoId(1)).unwrap(), 384, 10));- catalog- .apply(Op::SetContent {- id: PhotoId(1),- width: 6000,- height: 4000,- file_size: 99,- content_hash: Some("changed".into()),- preview_only: None,- preview_checked: String::new(),- })- .unwrap();- assert!(!r.thumb_current(catalog.photo(PhotoId(1)).unwrap(), 384, 10));- assert!(!r.thumb_current(&photo(), 384, 10));- r.forget_all();- assert!(r.thumb_inputs.is_empty());- }- #[test]- fn queue_promotions_running_work_and_cancellation() {- let p = photo();- let slot = Slot::Thumb(p.id);- let mut session = Session::new();- session.catalog.apply(Op::AddPhoto { photo: Box::new((*p).clone()) }).unwrap();- let job = session.thumb_job(p.id, 384).unwrap();- let key = job.key;- let mut r = Renderer::default();- r.set_offload(Box::new(Blocked));- r.remember_thumb(&p, 384, key, false);- r.request(slot, job, 5);- assert!(r.thumb_current(&p, 384, 5));- assert!(!r.thumb_current(&p, 384, 10));- r.request(slot, session.thumb_job(p.id, 384).unwrap(), 10);- assert_eq!(r.pending.get(&slot), Some(&(key, 10)));- r.queue.clear(); // running work: cannot reprioritize, just as Renderer::request- assert!(r.thumb_current(&p, 384, 5));- r.pending.clear();- assert!(!r.thumb_current(&p, 384, 10));- r.evict_thumbs(&Default::default(), 600);- assert!(r.thumb_inputs.is_empty());- }- fn queued_quick_thumbnail(id: PhotoId) -> (Arc<Photo>, QuickJob) {- let mut session = Session::new();- session.media.preview_loader =- Some(Arc::new(|_, _| Some(lightcraft_raster::Rgba8 { width: 4, height: 4, data: vec![[200, 100, 50, 255]; 16] })));- let mut raw = (*photo()).clone();- raw.id = id;- raw.kind = lightcraft_catalog::MediaKind::Raw;- raw.develop = Arc::new(raw.camera_defaults());- session.catalog.apply(Op::AddPhoto { photo: Box::new(raw) }).unwrap();- let p = session.catalog.photo(id).unwrap().clone();- let job = session.thumb_job(id, 384).unwrap();- (p, session.quick_thumb_job(&job).unwrap())- }-- #[test]- fn queued_standin_promotes_from_prefetch_to_visible_without_restarting() {- let (p, quick) = queued_quick_thumbnail(PhotoId(1));- let (_, other) = queued_quick_thumbnail(PhotoId(2));- let slot = Slot::ThumbQuick(p.id);- // Deterministic queue: no native worker starts.- let mut r = Renderer { pool: JobPool::new(0), ..Default::default() };- r.remember_thumb(&p, 384, quick.key, true);- r.request_quick(slot, quick.clone(), 6); // grid prefetch: 5 + 1- r.request_quick(Slot::ThumbQuick(PhotoId(2)), other, 9); // filmstrip: 8 + 1- let request_id = r.requests[&slot].id;- assert!(r.thumb_current(&p, 384, 5));- assert!(!r.thumb_current(&p, 384, 10));- r.request_quick(slot, quick.clone(), 11); // visible grid: 10 + 1- assert!(r.thumb_current(&p, 384, 10));- r.request_quick(slot, quick.clone(), 11);- assert_eq!(r.requests[&slot].id, request_id);- assert_eq!(r.pool.queued(), 2);- r.pool.run_inline(1);- let done = r.pool.try_recv().unwrap();- assert_eq!(done.slot, slot);- assert_eq!(done.result.result.request_id, request_id);- assert_eq!(done.result.result.quick, Some(QuickSource::Embedded));- // A finished result awaiting collection also must not start another extraction.- r.request_quick(slot, quick, 6);- assert!(r.thumb_current(&p, 384, 5));- assert_eq!(r.pool.queued(), 1);- }-- #[test]- fn queued_standin_demotes_when_it_leaves_the_visible_grid() {- let (p, quick) = queued_quick_thumbnail(PhotoId(1));- let (_, other) = queued_quick_thumbnail(PhotoId(2));- let slot = Slot::ThumbQuick(p.id);- let mut r = Renderer { pool: JobPool::new(0), ..Default::default() };- r.remember_thumb(&p, 384, quick.key, true);- r.request_quick(slot, quick.clone(), 11);- r.request_quick(Slot::ThumbQuick(PhotoId(2)), other, 9);- assert!(!r.thumb_current(&p, 384, 5));- r.request_quick(slot, quick, 6);- assert!(r.thumb_current(&p, 384, 5));- r.pool.run_inline(1);- assert_eq!(r.pool.try_recv().unwrap().slot, Slot::ThumbQuick(PhotoId(2)));- }-- #[test]- fn failures_retry_after_revision_and_quick_only_is_not_final() {- let p = photo();- let slot = Slot::Thumb(p.id);- let mut r = Renderer::default();- r.remember_thumb(&p, 384, 77, false);- r.pending.insert(Slot::ThumbQuick(p.id), (77, 11));- assert!(!r.thumb_current(&p, 384, 10));- r.failed.insert(slot, (77, "no decoder".into(), 0, p.id));- assert!(r.thumb_current(&p, 384, 10));- assert_eq!(r.failure_of(slot, p.id), Some("no decoder"));- assert_eq!(r.failure_of(slot, PhotoId(p.id.0 + 1)), None, "another photo's error");- r.catalog_rev = 1;- assert!(!r.thumb_current(&p, 384, 10));- }-- #[test]- fn a_fast_draft_is_drawn_in_the_frame_that_asked_for_it() {- let mut s = Session::new();- s.media.file_loader = Some(Arc::new(|_, _| Ok((lightcraft_raster::Rgb32f::new(8, 8), Default::default()))));- s.catalog.apply(Op::AddPhoto { photo: Box::new((*photo()).clone()) }).unwrap();- let mut r = Renderer::with_worker_threads(1);- let ctx = egui::Context::default();- let budget = std::time::Duration::from_secs(10);- // the last loupe render took longer than the budget (a CPU render): not waited for- r.last_main_ms = 1e6;- r.request(Slot::Main, s.render_job(PhotoId(1), 64, 64, false, true).unwrap(), 100);- r.wait_for_draft(&ctx, &mut s, budget);- assert!(r.is_pending(Slot::Main) && !r.textures.contains_key(&Slot::Main));- // a fast one (GPU drafts): the texture is the new render when the wait returns- r.last_main_ms = 1.0;- r.request(Slot::Main, s.render_job(PhotoId(1), 32, 32, false, true).unwrap(), 100);- let want = r.wanted(Slot::Main);- r.wait_for_draft(&ctx, &mut s, budget);- assert!(!r.is_pending(Slot::Main));- assert_eq!(r.textures.get(&Slot::Main).map(|t| t.key), want);- }-- #[derive(Default)]- struct Work {- jobs: Vec<(Slot, RenderJob)>,- finished: Vec<(Slot, RenderResult, f64)>,- }- struct Manual(std::rc::Rc<std::cell::RefCell<Work>>);- impl RenderOffload for Manual {- fn try_start(&mut self, slot: Slot, job: RenderJob) -> Option<RenderJob> {- self.0.borrow_mut().jobs.push((slot, job));- None- }- fn finished(&mut self) -> Vec<(Slot, RenderResult, f64)> {- std::mem::take(&mut self.0.borrow_mut().finished)- }- }- fn fixture() -> (crate::LightcraftApp, std::rc::Rc<std::cell::RefCell<Work>>, egui::Context) {- fixture_with(Session::new(), (*photo()).clone())- }- fn fixture_with(mut s: Session, photo: Photo) -> (crate::LightcraftApp, std::rc::Rc<std::cell::RefCell<Work>>, egui::Context) {- s.media.file_loader = Some(Arc::new(|_, _| {- let mut image = lightcraft_raster::Rgb32f::new(8, 8);- image.data.fill([0.3, 0.2, 0.1]);- Ok((image, Default::default()))- }));- // (`with_fs` sets the file system's thumbnail loader, which wins over `file_loader`: thumbnails use the stub too)- s.media.reduced_loader = None;- s.catalog.apply(Op::AddPhoto { photo: Box::new(photo) }).unwrap();- let mut app = crate::LightcraftApp::new(s, crate::Services::default());- app.renderer.keep_pixels = true;- let work = std::rc::Rc::new(std::cell::RefCell::new(Work::default()));- app.renderer.set_offload(Box::new(Manual(work.clone())));- let ctx = egui::Context::default();- app.renderer.poll(&ctx, &mut app.session);- (app, work, ctx)- }- fn take_job(work: &std::rc::Rc<std::cell::RefCell<Work>>) -> (Slot, RenderJob) {- work.borrow_mut().jobs.pop().unwrap()- }- fn finish(app: &mut crate::LightcraftApp, work: &std::rc::Rc<std::cell::RefCell<Work>>, ctx: &egui::Context, slot: Slot, result: RenderResult) {- work.borrow_mut().finished.push((slot, result, 0.0));- app.renderer.poll(ctx, &mut app.session);- }- fn request(app: &mut crate::LightcraftApp) {- crate::panels::grid::request_thumb(app, PhotoId(1), 256, 10);- }-- fn relink_destination() -> std::path::PathBuf {- let path = std::env::temp_dir().join(format!("lc-render-relinked-{}-{}.nef", std::process::id(), lightcraft_preview::next_tick()));- std::fs::write(&path, b"replacement source").unwrap();- path- }-- #[test]- fn completed_failure_keeps_requested_source_after_relink() {- let replacement = relink_destination();- for slot in [Slot::Thumb(PhotoId(1)), Slot::Main, Slot::Before, Slot::Compare(1), Slot::Region] {- let (mut app, work, ctx) = fixture();- app.session.media.file_loader = Some(Arc::new(|_, _| Err("simulated decode failure".into())));- let job = app.session.render_job(PhotoId(1), 64, 64, false, true).unwrap();- app.renderer.request(slot, job, 100);- let (submitted, job) = take_job(&work);- assert_eq!(submitted, slot);- let result = job.run();- assert!(result.rendered.is_err(), "the old request has already failed");- app.session.execute("photo.relink", &serde_json::json!({"id": 1, "path": replacement})).unwrap();- assert!(- matches!(&app.session.catalog.photo(PhotoId(1)).unwrap().source, Source::File { path } if path.ends_with(replacement.file_name().unwrap().to_str().unwrap()))- );- finish(&mut app, &work, &ctx, slot, result);- assert_eq!(app.renderer.failure(slot), Some("simulated decode failure"));- assert!(!app.renderer.is_pending(slot));- let message = app.renderer.failure_messages.last().expect("the collector emitted a diagnostic");- assert!(message.contains("audit.jpg"), "{message}");- assert!(!message.contains("lc-render-relinked-"), "the failed request did not read the replacement: {message}");- assert!(message.ends_with(": simulated decode failure"), "{message}");- }- std::fs::remove_file(replacement).unwrap();- }-- #[test]- fn superseded_failure_does_not_take_the_new_requests_source() {- let replacement = relink_destination();- let (mut app, work, ctx) = fixture();- app.session.media.file_loader = Some(Arc::new(|_, _| Err("simulated decode failure".into())));- let slot = Slot::Main;- let old_job = app.session.render_job(PhotoId(1), 64, 64, false, true).unwrap();- app.renderer.request(slot, old_job, 100);- let (_, old_job) = take_job(&work);- let old_result = old_job.run();- app.session.execute("photo.relink", &serde_json::json!({"id": 1, "path": replacement})).unwrap();- let new_job = app.session.render_job(PhotoId(1), 64, 64, false, true).unwrap();- app.renderer.request(slot, new_job, 100);- let (_, new_job) = take_job(&work);- finish(&mut app, &work, &ctx, slot, old_result);- assert!(app.renderer.failure_messages.is_empty(), "obsolete failures stay suppressed");- assert!(app.renderer.is_pending(slot));- finish(&mut app, &work, &ctx, slot, new_job.run());- let message = app.renderer.failure_messages.last().expect("new failure is reported");- assert!(message.contains("lc-render-relinked-"), "{message}");- assert!(!message.contains("audit.jpg"), "{message}");- assert!(app.renderer.requests.is_empty(), "completed request identity is released");- std::fs::remove_file(replacement).unwrap();- }-- #[test]- fn grid_queued_standin_changes_priority_without_restarting() {- let mut s = Session::new();- s.media.preview_loader = Some(Arc::new(|_, _| Some(lightcraft_raster::Rgba8 { width: 4, height: 4, data: vec![[200, 100, 50, 255]; 16] })));- let mut raw = (*photo()).clone();- raw.kind = lightcraft_catalog::MediaKind::Raw;- raw.develop = Arc::new(raw.camera_defaults());- let (mut app, work, ctx) = fixture_with(s, raw);- app.renderer.pool = JobPool::new(0); // deterministic: no quick job starts until run_inline- let id = PhotoId(1);- let slot = Slot::ThumbQuick(id);-- crate::panels::grid::request_thumb(&mut app, id, 384, 5);- let request_id = app.renderer.requests[&slot].id;- assert_eq!(app.renderer.pending[&slot].1, 6);- assert_eq!(app.renderer.pool.queued(), 1);- crate::panels::grid::request_thumb(&mut app, id, 384, 10);- assert_eq!(app.renderer.pending[&slot].1, 11, "the grid must promote its queued stand-in");- assert_eq!(app.renderer.requests[&slot].id, request_id);- assert_eq!(app.renderer.pool.queued(), 1);-- crate::panels::grid::request_thumb(&mut app, id, 384, 5);- assert_eq!(app.renderer.pending[&slot].1, 6, "the grid must demote its queued stand-in");- assert_eq!(app.renderer.requests[&slot].id, request_id);- assert_eq!(app.renderer.pool.queued(), 1);- let built = app.renderer.thumb_jobs_built;- app.renderer.pool.run_inline(1);- crate::panels::grid::request_thumb(&mut app, id, 384, 10);- assert_eq!(app.renderer.pending[&slot].1, 6, "completed work must not be restarted");- assert_eq!(app.renderer.requests[&slot].id, request_id);- assert_eq!(app.renderer.pool.queued(), 0);- app.renderer.poll(&ctx, &mut app.session);- assert_eq!(app.renderer.textures[&slot].quick, Some(QuickSource::Embedded));-- crate::panels::grid::request_thumb(&mut app, id, 384, 10);- crate::panels::grid::request_thumb(&mut app, id, 384, 5);- assert_eq!(app.renderer.thumb_jobs_built, built);- assert_eq!(app.renderer.pool.queued(), 0);- assert!(!app.renderer.is_pending(Slot::Thumb(id)));- assert!(!app.renderer.textures.contains_key(&Slot::Thumb(id)));- assert!(work.borrow().jobs.is_empty(), "the final embedded thumbnail needs no real render");- }-- #[test]- fn unchanged_ready_and_running_frames_build_no_jobs() {- let (mut app, work, ctx) = fixture();- request(&mut app);- assert_eq!(app.renderer.thumb_jobs_built, 1);- for _ in 0..180 {- request(&mut app);- }- assert_eq!(app.renderer.thumb_jobs_built, 1);- let (slot, job) = take_job(&work);- finish(&mut app, &work, &ctx, slot, job.run());- for _ in 0..180 {- request(&mut app);- }- assert_eq!(app.renderer.thumb_jobs_built, 1);- assert!(work.borrow().jobs.is_empty());- }-- #[test]- fn a_slider_drag_leaves_the_edited_photos_thumbnail_until_it_ends() {- let (mut app, work, ctx) = fixture();- request(&mut app);- let (slot, job) = take_job(&work);- finish(&mut app, &work, &ctx, slot, job.run());- app.session.execute("library.select", &serde_json::json!({"ids": [1], "active": 1})).unwrap();- app.session.execute("develop.beginInteraction", &serde_json::json!({"label": "Exposure"})).unwrap();- for v in [0.1, 0.2, 0.3] {- app.session.execute("develop.set", &serde_json::json!({"control": "light.exposure", "value": v})).unwrap();- app.renderer.poll(&ctx, &mut app.session);- request(&mut app);- }- assert_eq!(app.renderer.thumb_jobs_built, 1, "the drag's frames render no thumbnail of the photo");- assert!(work.borrow().jobs.is_empty());- app.session.execute("develop.endInteraction", &serde_json::json!({})).unwrap();- request(&mut app);- assert_eq!(app.renderer.thumb_jobs_built, 2, "the thumbnail follows once the drag ends");- }-- #[test]- fn unchanged_queued_frames_build_no_jobs() {- let (mut app, _, _) = fixture();- app.renderer.set_offload(Box::new(Blocked));- request(&mut app);- for _ in 0..180 {- request(&mut app);- }- assert_eq!(app.renderer.thumb_jobs_built, 1);- assert_eq!(app.renderer.queue.len(), 1);- }-- #[test]- fn resizing_the_disk_cache_keeps_textures_and_skips_rebuilds() {- let lib = std::env::temp_dir().join(format!("lc-ui-thumb-resize-{}", std::process::id()));- let _ = std::fs::remove_dir_all(&lib);- let mut s = Session::new().with_fs();- s.open_library(&lib, false).unwrap();- let (mut app, work, ctx) = fixture_with(s, (*photo()).clone());- request(&mut app);- let (slot, job) = take_job(&work);- finish(&mut app, &work, &ctx, slot, job.run());- assert!(app.renderer.thumb(PhotoId(1)).is_some());- let cache = app.session.media.rendered.clone();- app.session.execute("library.preferences", &serde_json::json!({"cacheMb": 300})).unwrap();- app.renderer.poll(&ctx, &mut app.session);- // thumbnails are keyed by content: a new budget leaves them (and the cache) valid- assert!(app.renderer.thumb(PhotoId(1)).is_some());- assert!(Arc::ptr_eq(&cache, &app.session.media.rendered));- for _ in 0..30 {- request(&mut app);- }- assert_eq!(app.renderer.thumb_jobs_built, 1);- assert!(work.borrow().jobs.is_empty());- // an explicit clear still drops them- app.session.execute("library.clearPreviews", &serde_json::json!({})).unwrap();- app.renderer.poll(&ctx, &mut app.session);- assert!(app.renderer.thumb(PhotoId(1)).is_none());- drop(app);- let _ = std::fs::remove_dir_all(&lib);- }-- /// A render that panics (a decoder bug) is a failure like any other: the slot stops waiting,- /// the error is kept (not retried every frame), and the pool's workers live on. Before, the- /// worker died without an answer and the slot stayed pending forever.- #[test]- fn a_panicking_render_is_a_failure_not_a_dead_worker() {- let (mut app, _, ctx) = fixture_with(Session::new(), (*photo()).clone());- app.session.media.file_loader = Some(Arc::new(|_, _| panic!("decoder bug")));- app.renderer.offload = None; // the real job pool- let slot = Slot::Thumb(PhotoId(1));- let ask = |app: &mut crate::LightcraftApp| {- if let Some(job) = app.session.thumb_job(PhotoId(1), 256) {- app.renderer.request(slot, job, 30);- }- app.renderer.poll(&ctx, &mut app.session);- };- ask(&mut app);- let t0 = std::time::Instant::now();- while app.renderer.is_pending(slot) {- assert!(t0.elapsed() < std::time::Duration::from_secs(20), "the render never answered");- std::thread::sleep(std::time::Duration::from_millis(5));- app.renderer.poll(&ctx, &mut app.session);- }- assert_eq!(app.renderer.failure(slot), Some("the render failed unexpectedly: decoder bug"));- let workers = app.renderer.live_workers();- assert!(workers > 0, "the worker that panicked is still there");- let done = app.renderer.completed;- for _ in 0..30 {- ask(&mut app);- }- assert!(!app.renderer.is_pending(slot) && app.renderer.completed == done, "no retry loop");- assert_eq!(app.renderer.live_workers(), workers);- }-- #[test]- fn raw_quick_path_frames_build_no_jobs() {- // an unedited raw: the grid shows its embedded preview (held here until released) and stops- // there — the camera JPEG at 4 416 × 2 944 already covers a 512 px thumbnail, so decoding the- // whole raw behind it only costs the file read (45 s a photo on a 1.2 MB/s share)- let gate = Arc::new(std::sync::Mutex::new(()));- let held = gate.lock().unwrap();- let mut s = Session::new();- let g = gate.clone();- s.media.preview_loader = Some(Arc::new(move |_: &str, _| {- drop(g.lock().unwrap_or_else(std::sync::PoisonError::into_inner));- Some(lightcraft_raster::Rgba8 { width: 4, height: 4, data: vec![[200, 100, 50, 255]; 16] })- }));- let mut raw = (*photo()).clone();- raw.kind = lightcraft_catalog::MediaKind::Raw;- raw.develop = Arc::new(raw.camera_defaults());- let (mut app, _, ctx) = fixture_with(s, raw);- app.renderer.set_offload(Box::new(Blocked));- let quick = Slot::ThumbQuick(PhotoId(1));- // the stand-in is running- for _ in 0..180 {- request(&mut app);- }- assert!(app.renderer.is_pending(quick));- assert_eq!(app.renderer.thumb_jobs_built, 1);- drop(held);- let t0 = std::time::Instant::now();- while !app.renderer.textures.contains_key(&quick) {- assert!(t0.elapsed() < std::time::Duration::from_secs(20), "the embedded preview never arrived");- std::thread::sleep(std::time::Duration::from_millis(5));- app.renderer.poll(&ctx, &mut app.session);- }- // the embedded preview is the thumbnail: no real render is queued behind it, and the grid- // asking every frame neither rebuilds the job nor re-requests the preview- for _ in 0..180 {- request(&mut app);- }- assert_eq!(app.renderer.thumb_jobs_built, 1, "an unedited raw's embedded preview is the thumbnail");- assert!(app.renderer.queue.is_empty(), "nothing is decoded behind it");- assert!(!app.renderer.is_pending(Slot::Thumb(PhotoId(1))));-- // an edit takes the embedded preview out of the picture: the real thumbnail is rendered then- let mut edited = (*photo()).clone();- edited.kind = lightcraft_catalog::MediaKind::Raw;- edited.develop = Arc::new({- let mut d = edited.camera_defaults();- d.light.exposure = 0.5;- d- });- let (mut app, _, _ctx) = fixture_with(Session::new(), edited);- app.renderer.set_offload(Box::new(Blocked));- for _ in 0..180 {- request(&mut app);- }- assert_eq!(app.renderer.thumb_jobs_built, 1);- assert!(app.renderer.is_pending(Slot::Thumb(PhotoId(1))) || !app.renderer.queue.is_empty(), "an edited raw renders its thumbnail");- }-- #[test]- fn closing_import_review_cancels_queued_and_running_identities() {- let (mut app, work, ctx) = fixture();- let job = app.session.thumb_job(PhotoId(1), 256).unwrap();- app.renderer.request(Slot::Import(0), job.clone(), 10);- let (slot, running) = take_job(&work);- app.renderer.set_offload(Box::new(Blocked));- app.renderer.request(Slot::Import(1), job, 10);- app.renderer.forget_imports();- assert!(!app.renderer.is_pending(Slot::Import(0)));- assert!(!app.renderer.is_pending(Slot::Import(1)));- assert!(app.renderer.queue.is_empty());- work.borrow_mut().finished.push((slot, running.run(), 0.0));- app.renderer.set_offload(Box::new(Manual(work.clone())));- app.renderer.poll(&ctx, &mut app.session);- assert!(!app.renderer.textures.contains_key(&slot));- assert_eq!(app.session.media.source_usage().0, 0);- }-- #[test]- fn loupe_shows_superseded_drafts_newer_than_its_pixels_during_a_drag() {- let (mut app, work, ctx) = fixture();- let mut jobs = Vec::new();- for exposure in [0.0, 1.0, 2.0] {- let mut edit = lightcraft_develop::DevelopSettings::default();- edit.light.exposure = exposure;- app.session.catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(edit), label: "drag".into(), edited: None }).unwrap();- let job = app.session.loupe_job(PhotoId(1), 8, 8, true).unwrap().draft();- app.renderer.request(Slot::Main, job, 100);- jobs.push(take_job(&work).1);- }- let keys: Vec<u64> = jobs.iter().map(|j| j.key).collect();- let mut jobs = jobs.into_iter();- let (first, second, last) = (jobs.next().unwrap(), jobs.next().unwrap(), jobs.next().unwrap());- // the first draft lands while the newest is still rendering: the loupe moves on- finish(&mut app, &work, &ctx, Slot::Main, first.run());- assert_eq!(app.renderer.textures.get(&Slot::Main).map(|t| t.key), Some(keys[0]));- assert!(app.renderer.is_pending(Slot::Main));- finish(&mut app, &work, &ctx, Slot::Main, last.run());- assert_eq!(app.renderer.textures.get(&Slot::Main).map(|t| t.key), Some(keys[2]));- // a draft older than the pixels shown never replaces them- finish(&mut app, &work, &ctx, Slot::Main, second.run());- assert_eq!(app.renderer.textures.get(&Slot::Main).map(|t| t.key), Some(keys[2]));- assert!(!app.renderer.is_pending(Slot::Main));- }-- #[test]- fn a_drag_gets_its_live_hdr_histogram_beside_the_drafts() {- let (mut app, work, ctx) = fixture();- let mut jobs = Vec::new();- for exposure in [1.0, 2.0] {- let mut edit = lightcraft_develop::DevelopSettings::default();- edit.hdr.enabled = true;- edit.light.exposure = exposure;- app.session.catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(edit), label: "drag".into(), edited: None }).unwrap();- let job = app.session.render_job(PhotoId(1), 32, 32, false, true).unwrap();- app.renderer.request(Slot::HdrHistogram, job, 95);- jobs.push(take_job(&work).1);- }- let keys: Vec<u64> = jobs.iter().map(|j| j.key).collect();- let mut jobs = jobs.into_iter();- let (first, last) = (jobs.next().unwrap(), jobs.next().unwrap());- // superseded while the drag goes on, it still lands: the histogram keeps moving- finish(&mut app, &work, &ctx, Slot::HdrHistogram, first.run());- let live = app.renderer.live_hdr_histogram.clone().expect("a live HDR histogram");- assert_eq!((live.0, live.1), (PhotoId(1), keys[0]));- assert!(live.2.hdr.is_some(), "HDR bins");- finish(&mut app, &work, &ctx, Slot::HdrHistogram, last.run());- assert_eq!(app.renderer.live_hdr_histogram.as_ref().map(|l| l.1), Some(keys[1]));- // only the histogram is kept: no texture- assert!(!app.renderer.textures.contains_key(&Slot::HdrHistogram));- }-- #[test]- fn library_reset_rejects_old_job_even_when_photo_id_and_key_are_reused() {- let (mut app, work, ctx) = fixture();- request(&mut app);- let (slot, old) = take_job(&work);- let old_result = old.run();- app.renderer.forget_all();- let photo = app.session.catalog.photo(PhotoId(1)).unwrap().as_ref().clone();- app.session = lightcraft_engine::Session::new();- app.session.catalog.apply(Op::AddPhoto { photo: Box::new(photo) }).unwrap();- app.session.media.file_loader = Some(Arc::new(|_, _| {- let mut image = lightcraft_raster::Rgb32f::new(8, 8);- image.data.fill([0.1, 0.2, 0.9]);- Ok((image, Default::default()))- }));- app.renderer.poll(&ctx, &mut app.session);- request(&mut app);- let (_, new) = take_job(&work);- assert_eq!(old_result.key, new.key);- assert_ne!(old_result.request_id, new.request_id);- let expected = new.clone().run().rendered.unwrap().image.as_bytes();- finish(&mut app, &work, &ctx, slot, new.run());- finish(&mut app, &work, &ctx, slot, old_result);- assert_eq!(- app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels.iter().flat_map(|c| c.to_array()).collect::<Vec<_>>(),- expected- );- }-- #[test]- fn late_results_and_errors_cannot_replace_newest_pixels_or_sources() {- for order in [0, 1, 2] {- let (mut app, work, ctx) = fixture();- request(&mut app);- let (slot, old) = take_job(&work);- let mut edit = lightcraft_develop::DevelopSettings::default();- edit.light.exposure = 1.0;- app.session.catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(edit), label: "edit".into(), edited: None }).unwrap();- request(&mut app);- let (_, new) = take_job(&work);- let expected = new.clone().run().rendered.unwrap().image.as_bytes();- if order != 0 {- finish(&mut app, &work, &ctx, slot, new.run());- // An obsolete source and error must not poison the current successful request.- let mut stale = old.run();- if order == 2 {- stale.rendered = Err("old failure".into());- }- finish(&mut app, &work, &ctx, slot, stale);- } else {- finish(&mut app, &work, &ctx, slot, old.run());- assert!(app.renderer.thumb(PhotoId(1)).is_none());- assert_eq!(app.session.media.source_usage().0, 0);- finish(&mut app, &work, &ctx, slot, new.run());- }- assert_eq!(- app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels.iter().flat_map(|c| c.to_array()).collect::<Vec<_>>(),- expected- );- assert!(app.renderer.failure(slot).is_none());- }- }-- #[test]- fn undo_to_existing_texture_supersedes_pending_edit() {- let (mut app, work, ctx) = fixture();- request(&mut app);- let (slot, first) = take_job(&work);- let key = first.key;- finish(&mut app, &work, &ctx, slot, first.run());- let original = app.renderer.thumb(PhotoId(1)).unwrap().pixels.clone().unwrap();- let mut edit = lightcraft_develop::DevelopSettings::default();- edit.light.exposure = 1.0;- let undo =- app.session.catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(edit), label: "edit".into(), edited: None }).unwrap();- request(&mut app);- let (_, edited) = take_job(&work);- app.session.catalog.apply(undo).unwrap();- request(&mut app);- let (_, restored) = take_job(&work);- assert_eq!(restored.key, key);- finish(&mut app, &work, &ctx, slot, restored.run());- finish(&mut app, &work, &ctx, slot, edited.run());- assert_eq!(app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels, original.pixels);- }-- #[test]- fn explicit_clear_repairs_same_key_bad_pixels_and_rejects_old_same_key_job() {- let (mut app, work, ctx) = fixture();- let job = app.session.thumb_job(PhotoId(1), 256).unwrap();- let expected = job.clone().run().rendered.unwrap().image;- let (cache, key) = job.cache.clone().unwrap();- let mut bad = expected.clone();- bad.data.fill([255, 0, 255, 255]);- cache.put(key, Arc::new(bad.clone()));- request(&mut app);- let (slot, corrupt) = take_job(&work);- finish(&mut app, &work, &ctx, slot, corrupt.run());- assert_eq!(app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels[0].to_array(), [255, 0, 255, 255]);- // An old job can have the SAME render key and stale decoded pixels.- let mut old = job.clone();- old.source = lightcraft_engine::media::SourceRef::Loaded(Box::new(lightcraft_engine::media::DecodedSource::new(- Arc::new(lightcraft_raster::Rgb32f::new(8, 8)),- None,- )));- app.renderer.textures.clear();- app.renderer.request(slot, old, 10);- let (_, old) = take_job(&work);- app.session.execute("library.clearPreviews", &serde_json::json!({})).unwrap();- app.renderer.poll(&ctx, &mut app.session);- assert!(app.renderer.thumb(PhotoId(1)).is_none());- request(&mut app);- let (_, repaired) = take_job(&work);- assert_eq!(repaired.key, job.key);- finish(&mut app, &work, &ctx, slot, repaired.run());- finish(&mut app, &work, &ctx, slot, old.run());- assert_eq!(cache.get(key).unwrap().as_bytes(), expected.as_bytes());- assert_eq!(- app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels.iter().flat_map(|c| c.to_array()).collect::<Vec<_>>(),- expected.as_bytes()- );- }-- #[test]- fn undo_to_embedded_thumb_rejects_late_full_render() {- let mut s = Session::new();- s.media.preview_loader = Some(Arc::new(|_, _| Some(lightcraft_raster::Rgba8 { width: 4, height: 4, data: vec![[200, 100, 50, 255]; 16] })));- let mut raw = (*photo()).clone();- raw.kind = lightcraft_catalog::MediaKind::Raw;- raw.develop = Arc::new(raw.camera_defaults());- let (mut app, work, ctx) = fixture_with(s, raw);- app.renderer.pool = JobPool::new(0);- let id = PhotoId(1);- let quick_slot = Slot::ThumbQuick(id);- let full_slot = Slot::Thumb(id);- let settings_a = app.session.catalog.photo(id).unwrap().develop.clone();-- crate::panels::grid::request_thumb(&mut app, id, 384, 10);- assert_eq!(app.renderer.pool.run_inline(1), 1);- app.renderer.poll(&ctx, &mut app.session);- let (key_a, pixels_a) = {- let shown = app.renderer.thumb(id).unwrap();- assert_eq!(shown.quick, Some(QuickSource::Embedded));- (shown.key, shown.pixels.as_ref().unwrap().pixels.clone())- };- assert!(app.renderer.textures.contains_key(&quick_slot));- assert!(!app.renderer.textures.contains_key(&full_slot));- assert!(work.borrow().jobs.is_empty());-- let mut settings_b = (*settings_a).clone();- settings_b.light.exposure += 0.5;- app.session.commit("Exposure", Op::SetDevelop { id, settings: Arc::new(settings_b), label: "Exposure".into(), edited: None }).unwrap();- assert!(!app.session.embedded_thumb_is_final(app.session.catalog.photo(id).unwrap()));- crate::panels::grid::request_thumb(&mut app, id, 384, 10);- // Manual owns dispatched jobs: hold B until the real Undo command restores A.- let (slot, held_b) = take_job(&work);- assert_eq!(slot, full_slot);- let key_b = held_b.key;- assert_ne!(key_b, key_a);- assert!(app.renderer.is_pending(full_slot));-- app.run("edit.undo", serde_json::json!({})).unwrap();- assert_eq!(app.session.catalog.photo(id).unwrap().develop.as_ref(), settings_a.as_ref());- assert!(app.session.embedded_thumb_is_final(app.session.catalog.photo(id).unwrap()));- crate::panels::grid::request_thumb(&mut app, id, 384, 10);- {- let restored = app.renderer.thumb(id).unwrap();- assert_eq!(restored.key, key_a);- assert_eq!(restored.pixels.as_ref().unwrap().pixels, pixels_a);- assert_eq!(restored.quick, Some(QuickSource::Embedded));- }- assert!(work.borrow().jobs.is_empty(), "restoring embedded-final A needs no full render");- assert_eq!(app.renderer.pool.queued(), 0);-- let result_b = held_b.run();- assert_eq!(result_b.key, key_b);- let rendered_b = result_b.rendered.as_ref().expect("held edited thumbnail must render before the stale-result oracle");- assert_ne!(color_image(&rendered_b.image).pixels, pixels_a, "the held result must be distinguishable from A");- finish(&mut app, &work, &ctx, slot, result_b);-- let shown = app.renderer.thumb(id).unwrap();- assert_eq!(shown.key, key_a, "late edited Thumb(B) must not replace restored embedded ThumbQuick(A)");- assert_eq!(shown.pixels.as_ref().unwrap().pixels, pixels_a);- assert_eq!(shown.quick, Some(QuickSource::Embedded));- let quick = app.renderer.textures.get(&quick_slot).expect("the correct embedded thumbnail must remain installed");- assert_eq!(quick.key, key_a);- assert_eq!(quick.quick, Some(QuickSource::Embedded));- assert_eq!(quick.pixels.as_ref().unwrap().pixels, pixels_a);- assert!(!app.renderer.is_pending(full_slot));- }-}+mod thumbnail_tests;#[cfg(test)]mod stage_budget_tests {diff --git a/crates/ui-egui/src/render/thumbnail_tests.rs b/crates/ui-egui/src/render/thumbnail_tests.rsnew file mode 100644index 000000000..ddad90970--- /dev/null+++ b/crates/ui-egui/src/render/thumbnail_tests.rs@@ -0,0 +1,770 @@+use super::*;+use lightcraft_catalog::{Catalog, Op, Photo, Source};++#[test]+fn render_failures_identify_the_file_for_thumbnail_and_view_slots() {+ let source = Source::File { path: "/photos/trip/IMG_0042.nef".into() };+ for slot in [Slot::Thumb(PhotoId(42)), Slot::Main, Slot::Before, Slot::Compare(1), Slot::Region] {+ let message = render_failure_message(slot, PhotoId(42), Some(&source), "unsupported compression");+ assert!(message.contains("/photos/trip/IMG_0042.nef"), "{message}");+ assert!(message.contains("PhotoId(42)"), "{message}");+ assert!(message.ends_with(": unsupported compression"), "{message}");+ }+}++#[test]+fn render_failure_paths_are_escaped_and_missing_sources_still_identified() {+ let source = Source::File { path: "line\nbreak.nef".into() };+ let message = render_failure_message(Slot::Main, PhotoId(42), Some(&source), "decode failed");+ assert!(!message.contains('\n'));+ assert!(message.contains("line\\nbreak.nef"));+ assert!(render_failure_message(Slot::Main, PhotoId(42), None, "decode failed").contains("PhotoId(42), source unavailable"));+ let demo = Source::Demo { scene: 7 };+ assert!(render_failure_message(Slot::Main, PhotoId(42), Some(&demo), "decode failed").contains("demo scene 7"));+}++struct Blocked;+impl RenderOffload for Blocked {+ fn try_start(&mut self, _: Slot, job: RenderJob) -> Option<RenderJob> {+ Some(job)+ }+ fn finished(&mut self) -> Vec<(Slot, RenderResult, f64)> {+ vec![]+ }+}+fn photo() -> Arc<Photo> {+ Arc::new(Photo::new(PhotoId(1), Source::File { path: "audit.jpg".into() }, "audit.jpg", "JPEG", 6000, 4000, "2026-01-01"))+}+#[test]+fn snapshot_tracks_cow_edits_undo_reload_and_replacement() {+ let mut catalog = Catalog::default();+ catalog.apply(Op::AddPhoto { photo: Box::new((*photo()).clone()) }).unwrap();+ let old = catalog.photo(PhotoId(1)).unwrap().clone();+ let mut r = Renderer::default();+ r.remember_thumb(&old, 384, 77, false);+ r.pending.insert(Slot::Thumb(PhotoId(1)), (77, 10));+ assert!(r.thumb_current(&old, 384, 10));+ assert!(!r.thumb_current(&old, 512, 10));+ let mut settings = lightcraft_develop::DevelopSettings::default();+ settings.light.exposure = 1.0;+ let undo = catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(settings), label: "edit".into(), edited: None }).unwrap();+ assert!(!r.thumb_current(catalog.photo(PhotoId(1)).unwrap(), 384, 10));+ catalog.apply(undo).unwrap();+ assert!(!r.thumb_current(catalog.photo(PhotoId(1)).unwrap(), 384, 10));+ catalog+ .apply(Op::SetContent {+ id: PhotoId(1),+ width: 6000,+ height: 4000,+ file_size: 99,+ content_hash: Some("changed".into()),+ preview_only: None,+ preview_checked: String::new(),+ })+ .unwrap();+ assert!(!r.thumb_current(catalog.photo(PhotoId(1)).unwrap(), 384, 10));+ assert!(!r.thumb_current(&photo(), 384, 10));+ r.forget_all();+ assert!(r.thumb_inputs.is_empty());+}+#[test]+fn queue_promotions_running_work_and_cancellation() {+ let p = photo();+ let slot = Slot::Thumb(p.id);+ let mut session = Session::new();+ session.catalog.apply(Op::AddPhoto { photo: Box::new((*p).clone()) }).unwrap();+ let job = session.thumb_job(p.id, 384).unwrap();+ let key = job.key;+ let mut r = Renderer::default();+ r.set_offload(Box::new(Blocked));+ r.remember_thumb(&p, 384, key, false);+ r.request(slot, job, 5);+ assert!(r.thumb_current(&p, 384, 5));+ assert!(!r.thumb_current(&p, 384, 10));+ r.request(slot, session.thumb_job(p.id, 384).unwrap(), 10);+ assert_eq!(r.pending.get(&slot), Some(&(key, 10)));+ r.queue.clear(); // running work: cannot reprioritize, just as Renderer::request+ assert!(r.thumb_current(&p, 384, 5));+ r.pending.clear();+ assert!(!r.thumb_current(&p, 384, 10));+ r.evict_thumbs(&Default::default(), 600);+ assert!(r.thumb_inputs.is_empty());+}+fn queued_quick_thumbnail(id: PhotoId) -> (Arc<Photo>, QuickJob) {+ let mut session = Session::new();+ session.media.preview_loader =+ Some(Arc::new(|_, _| Some(lightcraft_raster::Rgba8 { width: 4, height: 4, data: vec![[200, 100, 50, 255]; 16] })));+ let mut raw = (*photo()).clone();+ raw.id = id;+ raw.kind = lightcraft_catalog::MediaKind::Raw;+ raw.develop = Arc::new(raw.camera_defaults());+ session.catalog.apply(Op::AddPhoto { photo: Box::new(raw) }).unwrap();+ let p = session.catalog.photo(id).unwrap().clone();+ let job = session.thumb_job(id, 384).unwrap();+ (p, session.quick_thumb_job(&job).unwrap())+}++#[test]+fn queued_standin_promotes_from_prefetch_to_visible_without_restarting() {+ let (p, quick) = queued_quick_thumbnail(PhotoId(1));+ let (_, other) = queued_quick_thumbnail(PhotoId(2));+ let slot = Slot::ThumbQuick(p.id);+ // Deterministic queue: no native worker starts.+ let mut r = Renderer { pool: JobPool::new(0), ..Default::default() };+ r.remember_thumb(&p, 384, quick.key, true);+ r.request_quick(slot, quick.clone(), 6); // grid prefetch: 5 + 1+ r.request_quick(Slot::ThumbQuick(PhotoId(2)), other, 9); // filmstrip: 8 + 1+ let request_id = r.requests[&slot].id;+ assert!(r.thumb_current(&p, 384, 5));+ assert!(!r.thumb_current(&p, 384, 10));+ r.request_quick(slot, quick.clone(), 11); // visible grid: 10 + 1+ assert!(r.thumb_current(&p, 384, 10));+ r.request_quick(slot, quick.clone(), 11);+ assert_eq!(r.requests[&slot].id, request_id);+ assert_eq!(r.pool.queued(), 2);+ r.pool.run_inline(1);+ let done = r.pool.try_recv().unwrap();+ assert_eq!(done.slot, slot);+ assert_eq!(done.result.result.request_id, request_id);+ assert_eq!(done.result.result.quick, Some(QuickSource::Embedded));+ // A finished result awaiting collection also must not start another extraction.+ r.request_quick(slot, quick, 6);+ assert!(r.thumb_current(&p, 384, 5));+ assert_eq!(r.pool.queued(), 1);+}++#[test]+fn queued_standin_demotes_when_it_leaves_the_visible_grid() {+ let (p, quick) = queued_quick_thumbnail(PhotoId(1));+ let (_, other) = queued_quick_thumbnail(PhotoId(2));+ let slot = Slot::ThumbQuick(p.id);+ let mut r = Renderer { pool: JobPool::new(0), ..Default::default() };+ r.remember_thumb(&p, 384, quick.key, true);+ r.request_quick(slot, quick.clone(), 11);+ r.request_quick(Slot::ThumbQuick(PhotoId(2)), other, 9);+ assert!(!r.thumb_current(&p, 384, 5));+ r.request_quick(slot, quick, 6);+ assert!(r.thumb_current(&p, 384, 5));+ r.pool.run_inline(1);+ assert_eq!(r.pool.try_recv().unwrap().slot, Slot::ThumbQuick(PhotoId(2)));+}++#[test]+fn failures_retry_after_revision_and_quick_only_is_not_final() {+ let p = photo();+ let slot = Slot::Thumb(p.id);+ let mut r = Renderer::default();+ r.remember_thumb(&p, 384, 77, false);+ r.pending.insert(Slot::ThumbQuick(p.id), (77, 11));+ assert!(!r.thumb_current(&p, 384, 10));+ r.failed.insert(slot, (77, "no decoder".into(), 0, p.id));+ assert!(r.thumb_current(&p, 384, 10));+ assert_eq!(r.failure_of(slot, p.id), Some("no decoder"));+ assert_eq!(r.failure_of(slot, PhotoId(p.id.0 + 1)), None, "another photo's error");+ r.catalog_rev = 1;+ assert!(!r.thumb_current(&p, 384, 10));+}++#[test]+fn a_fast_draft_is_drawn_in_the_frame_that_asked_for_it() {+ let mut s = Session::new();+ s.media.file_loader = Some(Arc::new(|_, _| Ok((lightcraft_raster::Rgb32f::new(8, 8), Default::default()))));+ s.catalog.apply(Op::AddPhoto { photo: Box::new((*photo()).clone()) }).unwrap();+ let mut r = Renderer::with_worker_threads(1);+ let ctx = egui::Context::default();+ let budget = std::time::Duration::from_secs(10);+ // the last loupe render took longer than the budget (a CPU render): not waited for+ r.last_main_ms = 1e6;+ r.request(Slot::Main, s.render_job(PhotoId(1), 64, 64, false, true).unwrap(), 100);+ r.wait_for_draft(&ctx, &mut s, budget);+ assert!(r.is_pending(Slot::Main) && !r.textures.contains_key(&Slot::Main));+ // a fast one (GPU drafts): the texture is the new render when the wait returns+ r.last_main_ms = 1.0;+ r.request(Slot::Main, s.render_job(PhotoId(1), 32, 32, false, true).unwrap(), 100);+ let want = r.wanted(Slot::Main);+ r.wait_for_draft(&ctx, &mut s, budget);+ assert!(!r.is_pending(Slot::Main));+ assert_eq!(r.textures.get(&Slot::Main).map(|t| t.key), want);+}++#[derive(Default)]+struct Work {+ jobs: Vec<(Slot, RenderJob)>,+ finished: Vec<(Slot, RenderResult, f64)>,+}+struct Manual(std::rc::Rc<std::cell::RefCell<Work>>);+impl RenderOffload for Manual {+ fn try_start(&mut self, slot: Slot, job: RenderJob) -> Option<RenderJob> {+ self.0.borrow_mut().jobs.push((slot, job));+ None+ }+ fn finished(&mut self) -> Vec<(Slot, RenderResult, f64)> {+ std::mem::take(&mut self.0.borrow_mut().finished)+ }+}+fn fixture() -> (crate::LightcraftApp, std::rc::Rc<std::cell::RefCell<Work>>, egui::Context) {+ fixture_with(Session::new(), (*photo()).clone())+}+fn fixture_with(mut s: Session, photo: Photo) -> (crate::LightcraftApp, std::rc::Rc<std::cell::RefCell<Work>>, egui::Context) {+ s.media.file_loader = Some(Arc::new(|_, _| {+ let mut image = lightcraft_raster::Rgb32f::new(8, 8);+ image.data.fill([0.3, 0.2, 0.1]);+ Ok((image, Default::default()))+ }));+ // (`with_fs` sets the file system's thumbnail loader, which wins over `file_loader`: thumbnails use the stub too)+ s.media.reduced_loader = None;+ s.catalog.apply(Op::AddPhoto { photo: Box::new(photo) }).unwrap();+ let mut app = crate::LightcraftApp::new(s, crate::Services::default());+ app.renderer.keep_pixels = true;+ let work = std::rc::Rc::new(std::cell::RefCell::new(Work::default()));+ app.renderer.set_offload(Box::new(Manual(work.clone())));+ let ctx = egui::Context::default();+ app.renderer.poll(&ctx, &mut app.session);+ (app, work, ctx)+}+fn take_job(work: &std::rc::Rc<std::cell::RefCell<Work>>) -> (Slot, RenderJob) {+ work.borrow_mut().jobs.pop().unwrap()+}+fn finish(app: &mut crate::LightcraftApp, work: &std::rc::Rc<std::cell::RefCell<Work>>, ctx: &egui::Context, slot: Slot, result: RenderResult) {+ work.borrow_mut().finished.push((slot, result, 0.0));+ app.renderer.poll(ctx, &mut app.session);+}+fn request(app: &mut crate::LightcraftApp) {+ crate::panels::grid::request_thumb(app, PhotoId(1), 256, 10);+}++fn relink_destination() -> std::path::PathBuf {+ let path = std::env::temp_dir().join(format!("lc-render-relinked-{}-{}.nef", std::process::id(), lightcraft_preview::next_tick()));+ std::fs::write(&path, b"replacement source").unwrap();+ path+}++#[test]+fn completed_failure_keeps_requested_source_after_relink() {+ let replacement = relink_destination();+ for slot in [Slot::Thumb(PhotoId(1)), Slot::Main, Slot::Before, Slot::Compare(1), Slot::Region] {+ let (mut app, work, ctx) = fixture();+ app.session.media.file_loader = Some(Arc::new(|_, _| Err("simulated decode failure".into())));+ let job = app.session.render_job(PhotoId(1), 64, 64, false, true).unwrap();+ app.renderer.request(slot, job, 100);+ let (submitted, job) = take_job(&work);+ assert_eq!(submitted, slot);+ let result = job.run();+ assert!(result.rendered.is_err(), "the old request has already failed");+ app.session.execute("photo.relink", &serde_json::json!({"id": 1, "path": replacement})).unwrap();+ assert!(+ matches!(&app.session.catalog.photo(PhotoId(1)).unwrap().source, Source::File { path } if path.ends_with(replacement.file_name().unwrap().to_str().unwrap()))+ );+ finish(&mut app, &work, &ctx, slot, result);+ assert_eq!(app.renderer.failure(slot), Some("simulated decode failure"));+ assert!(!app.renderer.is_pending(slot));+ let message = app.renderer.failure_messages.last().expect("the collector emitted a diagnostic");+ assert!(message.contains("audit.jpg"), "{message}");+ assert!(!message.contains("lc-render-relinked-"), "the failed request did not read the replacement: {message}");+ assert!(message.ends_with(": simulated decode failure"), "{message}");+ }+ std::fs::remove_file(replacement).unwrap();+}++#[test]+fn superseded_failure_does_not_take_the_new_requests_source() {+ let replacement = relink_destination();+ let (mut app, work, ctx) = fixture();+ app.session.media.file_loader = Some(Arc::new(|_, _| Err("simulated decode failure".into())));+ let slot = Slot::Main;+ let old_job = app.session.render_job(PhotoId(1), 64, 64, false, true).unwrap();+ app.renderer.request(slot, old_job, 100);+ let (_, old_job) = take_job(&work);+ let old_result = old_job.run();+ app.session.execute("photo.relink", &serde_json::json!({"id": 1, "path": replacement})).unwrap();+ let new_job = app.session.render_job(PhotoId(1), 64, 64, false, true).unwrap();+ app.renderer.request(slot, new_job, 100);+ let (_, new_job) = take_job(&work);+ finish(&mut app, &work, &ctx, slot, old_result);+ assert!(app.renderer.failure_messages.is_empty(), "obsolete failures stay suppressed");+ assert!(app.renderer.is_pending(slot));+ finish(&mut app, &work, &ctx, slot, new_job.run());+ let message = app.renderer.failure_messages.last().expect("new failure is reported");+ assert!(message.contains("lc-render-relinked-"), "{message}");+ assert!(!message.contains("audit.jpg"), "{message}");+ assert!(app.renderer.requests.is_empty(), "completed request identity is released");+ std::fs::remove_file(replacement).unwrap();+}++#[test]+fn grid_queued_standin_changes_priority_without_restarting() {+ let mut s = Session::new();+ s.media.preview_loader = Some(Arc::new(|_, _| Some(lightcraft_raster::Rgba8 { width: 4, height: 4, data: vec![[200, 100, 50, 255]; 16] })));+ let mut raw = (*photo()).clone();+ raw.kind = lightcraft_catalog::MediaKind::Raw;+ raw.develop = Arc::new(raw.camera_defaults());+ let (mut app, work, ctx) = fixture_with(s, raw);+ app.renderer.pool = JobPool::new(0); // deterministic: no quick job starts until run_inline+ let id = PhotoId(1);+ let slot = Slot::ThumbQuick(id);++ crate::panels::grid::request_thumb(&mut app, id, 384, 5);+ let request_id = app.renderer.requests[&slot].id;+ assert_eq!(app.renderer.pending[&slot].1, 6);+ assert_eq!(app.renderer.pool.queued(), 1);+ crate::panels::grid::request_thumb(&mut app, id, 384, 10);+ assert_eq!(app.renderer.pending[&slot].1, 11, "the grid must promote its queued stand-in");+ assert_eq!(app.renderer.requests[&slot].id, request_id);+ assert_eq!(app.renderer.pool.queued(), 1);++ crate::panels::grid::request_thumb(&mut app, id, 384, 5);+ assert_eq!(app.renderer.pending[&slot].1, 6, "the grid must demote its queued stand-in");+ assert_eq!(app.renderer.requests[&slot].id, request_id);+ assert_eq!(app.renderer.pool.queued(), 1);+ let built = app.renderer.thumb_jobs_built;+ app.renderer.pool.run_inline(1);+ crate::panels::grid::request_thumb(&mut app, id, 384, 10);+ assert_eq!(app.renderer.pending[&slot].1, 6, "completed work must not be restarted");+ assert_eq!(app.renderer.requests[&slot].id, request_id);+ assert_eq!(app.renderer.pool.queued(), 0);+ app.renderer.poll(&ctx, &mut app.session);+ assert_eq!(app.renderer.textures[&slot].quick, Some(QuickSource::Embedded));++ crate::panels::grid::request_thumb(&mut app, id, 384, 10);+ crate::panels::grid::request_thumb(&mut app, id, 384, 5);+ assert_eq!(app.renderer.thumb_jobs_built, built);+ assert_eq!(app.renderer.pool.queued(), 0);+ assert!(!app.renderer.is_pending(Slot::Thumb(id)));+ assert!(!app.renderer.textures.contains_key(&Slot::Thumb(id)));+ assert!(work.borrow().jobs.is_empty(), "the final embedded thumbnail needs no real render");+}++#[test]+fn unchanged_ready_and_running_frames_build_no_jobs() {+ let (mut app, work, ctx) = fixture();+ request(&mut app);+ assert_eq!(app.renderer.thumb_jobs_built, 1);+ for _ in 0..180 {+ request(&mut app);+ }+ assert_eq!(app.renderer.thumb_jobs_built, 1);+ let (slot, job) = take_job(&work);+ finish(&mut app, &work, &ctx, slot, job.run());+ for _ in 0..180 {+ request(&mut app);+ }+ assert_eq!(app.renderer.thumb_jobs_built, 1);+ assert!(work.borrow().jobs.is_empty());+}++#[test]+fn a_slider_drag_leaves_the_edited_photos_thumbnail_until_it_ends() {+ let (mut app, work, ctx) = fixture();+ request(&mut app);+ let (slot, job) = take_job(&work);+ finish(&mut app, &work, &ctx, slot, job.run());+ app.session.execute("library.select", &serde_json::json!({"ids": [1], "active": 1})).unwrap();+ app.session.execute("develop.beginInteraction", &serde_json::json!({"label": "Exposure"})).unwrap();+ for v in [0.1, 0.2, 0.3] {+ app.session.execute("develop.set", &serde_json::json!({"control": "light.exposure", "value": v})).unwrap();+ app.renderer.poll(&ctx, &mut app.session);+ request(&mut app);+ }+ assert_eq!(app.renderer.thumb_jobs_built, 1, "the drag's frames render no thumbnail of the photo");+ assert!(work.borrow().jobs.is_empty());+ app.session.execute("develop.endInteraction", &serde_json::json!({})).unwrap();+ request(&mut app);+ assert_eq!(app.renderer.thumb_jobs_built, 2, "the thumbnail follows once the drag ends");+}++#[test]+fn unchanged_queued_frames_build_no_jobs() {+ let (mut app, _, _) = fixture();+ app.renderer.set_offload(Box::new(Blocked));+ request(&mut app);+ for _ in 0..180 {+ request(&mut app);+ }+ assert_eq!(app.renderer.thumb_jobs_built, 1);+ assert_eq!(app.renderer.queue.len(), 1);+}++#[test]+fn resizing_the_disk_cache_keeps_textures_and_skips_rebuilds() {+ let lib = std::env::temp_dir().join(format!("lc-ui-thumb-resize-{}", std::process::id()));+ let _ = std::fs::remove_dir_all(&lib);+ let mut s = Session::new().with_fs();+ s.open_library(&lib, false).unwrap();+ let (mut app, work, ctx) = fixture_with(s, (*photo()).clone());+ request(&mut app);+ let (slot, job) = take_job(&work);+ finish(&mut app, &work, &ctx, slot, job.run());+ assert!(app.renderer.thumb(PhotoId(1)).is_some());+ let cache = app.session.media.rendered.clone();+ app.session.execute("library.preferences", &serde_json::json!({"cacheMb": 300})).unwrap();+ app.renderer.poll(&ctx, &mut app.session);+ // thumbnails are keyed by content: a new budget leaves them (and the cache) valid+ assert!(app.renderer.thumb(PhotoId(1)).is_some());+ assert!(Arc::ptr_eq(&cache, &app.session.media.rendered));+ for _ in 0..30 {+ request(&mut app);+ }+ assert_eq!(app.renderer.thumb_jobs_built, 1);+ assert!(work.borrow().jobs.is_empty());+ // an explicit clear still drops them+ app.session.execute("library.clearPreviews", &serde_json::json!({})).unwrap();+ app.renderer.poll(&ctx, &mut app.session);+ assert!(app.renderer.thumb(PhotoId(1)).is_none());+ drop(app);+ let _ = std::fs::remove_dir_all(&lib);+}++/// A render that panics (a decoder bug) is a failure like any other: the slot stops waiting,+/// the error is kept (not retried every frame), and the pool's workers live on. Before, the+/// worker died without an answer and the slot stayed pending forever.+#[test]+fn a_panicking_render_is_a_failure_not_a_dead_worker() {+ let (mut app, _, ctx) = fixture_with(Session::new(), (*photo()).clone());+ app.session.media.file_loader = Some(Arc::new(|_, _| panic!("decoder bug")));+ app.renderer.offload = None; // the real job pool+ let slot = Slot::Thumb(PhotoId(1));+ let ask = |app: &mut crate::LightcraftApp| {+ if let Some(job) = app.session.thumb_job(PhotoId(1), 256) {+ app.renderer.request(slot, job, 30);+ }+ app.renderer.poll(&ctx, &mut app.session);+ };+ ask(&mut app);+ let t0 = std::time::Instant::now();+ while app.renderer.is_pending(slot) {+ assert!(t0.elapsed() < std::time::Duration::from_secs(20), "the render never answered");+ std::thread::sleep(std::time::Duration::from_millis(5));+ app.renderer.poll(&ctx, &mut app.session);+ }+ assert_eq!(app.renderer.failure(slot), Some("the render failed unexpectedly: decoder bug"));+ let workers = app.renderer.live_workers();+ assert!(workers > 0, "the worker that panicked is still there");+ let done = app.renderer.completed;+ for _ in 0..30 {+ ask(&mut app);+ }+ assert!(!app.renderer.is_pending(slot) && app.renderer.completed == done, "no retry loop");+ assert_eq!(app.renderer.live_workers(), workers);+}++#[test]+fn raw_quick_path_frames_build_no_jobs() {+ // an unedited raw: the grid shows its embedded preview (held here until released) and stops+ // there — the camera JPEG at 4 416 × 2 944 already covers a 512 px thumbnail, so decoding the+ // whole raw behind it only costs the file read (45 s a photo on a 1.2 MB/s share)+ let gate = Arc::new(std::sync::Mutex::new(()));+ let held = gate.lock().unwrap();+ let mut s = Session::new();+ let g = gate.clone();+ s.media.preview_loader = Some(Arc::new(move |_: &str, _| {+ drop(g.lock().unwrap_or_else(std::sync::PoisonError::into_inner));+ Some(lightcraft_raster::Rgba8 { width: 4, height: 4, data: vec![[200, 100, 50, 255]; 16] })+ }));+ let mut raw = (*photo()).clone();+ raw.kind = lightcraft_catalog::MediaKind::Raw;+ raw.develop = Arc::new(raw.camera_defaults());+ let (mut app, _, ctx) = fixture_with(s, raw);+ app.renderer.set_offload(Box::new(Blocked));+ let quick = Slot::ThumbQuick(PhotoId(1));+ // the stand-in is running+ for _ in 0..180 {+ request(&mut app);+ }+ assert!(app.renderer.is_pending(quick));+ assert_eq!(app.renderer.thumb_jobs_built, 1);+ drop(held);+ let t0 = std::time::Instant::now();+ while !app.renderer.textures.contains_key(&quick) {+ assert!(t0.elapsed() < std::time::Duration::from_secs(20), "the embedded preview never arrived");+ std::thread::sleep(std::time::Duration::from_millis(5));+ app.renderer.poll(&ctx, &mut app.session);+ }+ // the embedded preview is the thumbnail: no real render is queued behind it, and the grid+ // asking every frame neither rebuilds the job nor re-requests the preview+ for _ in 0..180 {+ request(&mut app);+ }+ assert_eq!(app.renderer.thumb_jobs_built, 1, "an unedited raw's embedded preview is the thumbnail");+ assert!(app.renderer.queue.is_empty(), "nothing is decoded behind it");+ assert!(!app.renderer.is_pending(Slot::Thumb(PhotoId(1))));++ // an edit takes the embedded preview out of the picture: the real thumbnail is rendered then+ let mut edited = (*photo()).clone();+ edited.kind = lightcraft_catalog::MediaKind::Raw;+ edited.develop = Arc::new({+ let mut d = edited.camera_defaults();+ d.light.exposure = 0.5;+ d+ });+ let (mut app, _, _ctx) = fixture_with(Session::new(), edited);+ app.renderer.set_offload(Box::new(Blocked));+ for _ in 0..180 {+ request(&mut app);+ }+ assert_eq!(app.renderer.thumb_jobs_built, 1);+ assert!(app.renderer.is_pending(Slot::Thumb(PhotoId(1))) || !app.renderer.queue.is_empty(), "an edited raw renders its thumbnail");+}++#[test]+fn closing_import_review_cancels_queued_and_running_identities() {+ let (mut app, work, ctx) = fixture();+ let job = app.session.thumb_job(PhotoId(1), 256).unwrap();+ app.renderer.request(Slot::Import(0), job.clone(), 10);+ let (slot, running) = take_job(&work);+ app.renderer.set_offload(Box::new(Blocked));+ app.renderer.request(Slot::Import(1), job, 10);+ app.renderer.forget_imports();+ assert!(!app.renderer.is_pending(Slot::Import(0)));+ assert!(!app.renderer.is_pending(Slot::Import(1)));+ assert!(app.renderer.queue.is_empty());+ work.borrow_mut().finished.push((slot, running.run(), 0.0));+ app.renderer.set_offload(Box::new(Manual(work.clone())));+ app.renderer.poll(&ctx, &mut app.session);+ assert!(!app.renderer.textures.contains_key(&slot));+ assert_eq!(app.session.media.source_usage().0, 0);+}++#[test]+fn loupe_shows_superseded_drafts_newer_than_its_pixels_during_a_drag() {+ let (mut app, work, ctx) = fixture();+ let mut jobs = Vec::new();+ for exposure in [0.0, 1.0, 2.0] {+ let mut edit = lightcraft_develop::DevelopSettings::default();+ edit.light.exposure = exposure;+ app.session.catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(edit), label: "drag".into(), edited: None }).unwrap();+ let job = app.session.loupe_job(PhotoId(1), 8, 8, true).unwrap().draft();+ app.renderer.request(Slot::Main, job, 100);+ jobs.push(take_job(&work).1);+ }+ let keys: Vec<u64> = jobs.iter().map(|j| j.key).collect();+ let mut jobs = jobs.into_iter();+ let (first, second, last) = (jobs.next().unwrap(), jobs.next().unwrap(), jobs.next().unwrap());+ // the first draft lands while the newest is still rendering: the loupe moves on+ finish(&mut app, &work, &ctx, Slot::Main, first.run());+ assert_eq!(app.renderer.textures.get(&Slot::Main).map(|t| t.key), Some(keys[0]));+ assert!(app.renderer.is_pending(Slot::Main));+ finish(&mut app, &work, &ctx, Slot::Main, last.run());+ assert_eq!(app.renderer.textures.get(&Slot::Main).map(|t| t.key), Some(keys[2]));+ // a draft older than the pixels shown never replaces them+ finish(&mut app, &work, &ctx, Slot::Main, second.run());+ assert_eq!(app.renderer.textures.get(&Slot::Main).map(|t| t.key), Some(keys[2]));+ assert!(!app.renderer.is_pending(Slot::Main));+}++#[test]+fn a_drag_gets_its_live_hdr_histogram_beside_the_drafts() {+ let (mut app, work, ctx) = fixture();+ let mut jobs = Vec::new();+ for exposure in [1.0, 2.0] {+ let mut edit = lightcraft_develop::DevelopSettings::default();+ edit.hdr.enabled = true;+ edit.light.exposure = exposure;+ app.session.catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(edit), label: "drag".into(), edited: None }).unwrap();+ let job = app.session.render_job(PhotoId(1), 32, 32, false, true).unwrap();+ app.renderer.request(Slot::HdrHistogram, job, 95);+ jobs.push(take_job(&work).1);+ }+ let keys: Vec<u64> = jobs.iter().map(|j| j.key).collect();+ let mut jobs = jobs.into_iter();+ let (first, last) = (jobs.next().unwrap(), jobs.next().unwrap());+ // superseded while the drag goes on, it still lands: the histogram keeps moving+ finish(&mut app, &work, &ctx, Slot::HdrHistogram, first.run());+ let live = app.renderer.live_hdr_histogram.clone().expect("a live HDR histogram");+ assert_eq!((live.0, live.1), (PhotoId(1), keys[0]));+ assert!(live.2.hdr.is_some(), "HDR bins");+ finish(&mut app, &work, &ctx, Slot::HdrHistogram, last.run());+ assert_eq!(app.renderer.live_hdr_histogram.as_ref().map(|l| l.1), Some(keys[1]));+ // only the histogram is kept: no texture+ assert!(!app.renderer.textures.contains_key(&Slot::HdrHistogram));+}++#[test]+fn library_reset_rejects_old_job_even_when_photo_id_and_key_are_reused() {+ let (mut app, work, ctx) = fixture();+ request(&mut app);+ let (slot, old) = take_job(&work);+ let old_result = old.run();+ app.renderer.forget_all();+ let photo = app.session.catalog.photo(PhotoId(1)).unwrap().as_ref().clone();+ app.session = lightcraft_engine::Session::new();+ app.session.catalog.apply(Op::AddPhoto { photo: Box::new(photo) }).unwrap();+ app.session.media.file_loader = Some(Arc::new(|_, _| {+ let mut image = lightcraft_raster::Rgb32f::new(8, 8);+ image.data.fill([0.1, 0.2, 0.9]);+ Ok((image, Default::default()))+ }));+ app.renderer.poll(&ctx, &mut app.session);+ request(&mut app);+ let (_, new) = take_job(&work);+ assert_eq!(old_result.key, new.key);+ assert_ne!(old_result.request_id, new.request_id);+ let expected = new.clone().run().rendered.unwrap().image.as_bytes();+ finish(&mut app, &work, &ctx, slot, new.run());+ finish(&mut app, &work, &ctx, slot, old_result);+ assert_eq!(+ app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels.iter().flat_map(|c| c.to_array()).collect::<Vec<_>>(),+ expected+ );+}++#[test]+fn late_results_and_errors_cannot_replace_newest_pixels_or_sources() {+ for order in [0, 1, 2] {+ let (mut app, work, ctx) = fixture();+ request(&mut app);+ let (slot, old) = take_job(&work);+ let mut edit = lightcraft_develop::DevelopSettings::default();+ edit.light.exposure = 1.0;+ app.session.catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(edit), label: "edit".into(), edited: None }).unwrap();+ request(&mut app);+ let (_, new) = take_job(&work);+ let expected = new.clone().run().rendered.unwrap().image.as_bytes();+ if order != 0 {+ finish(&mut app, &work, &ctx, slot, new.run());+ // An obsolete source and error must not poison the current successful request.+ let mut stale = old.run();+ if order == 2 {+ stale.rendered = Err("old failure".into());+ }+ finish(&mut app, &work, &ctx, slot, stale);+ } else {+ finish(&mut app, &work, &ctx, slot, old.run());+ assert!(app.renderer.thumb(PhotoId(1)).is_none());+ assert_eq!(app.session.media.source_usage().0, 0);+ finish(&mut app, &work, &ctx, slot, new.run());+ }+ assert_eq!(+ app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels.iter().flat_map(|c| c.to_array()).collect::<Vec<_>>(),+ expected+ );+ assert!(app.renderer.failure(slot).is_none());+ }+}++#[test]+fn undo_to_existing_texture_supersedes_pending_edit() {+ let (mut app, work, ctx) = fixture();+ request(&mut app);+ let (slot, first) = take_job(&work);+ let key = first.key;+ finish(&mut app, &work, &ctx, slot, first.run());+ let original = app.renderer.thumb(PhotoId(1)).unwrap().pixels.clone().unwrap();+ let mut edit = lightcraft_develop::DevelopSettings::default();+ edit.light.exposure = 1.0;+ let undo =+ app.session.catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(edit), label: "edit".into(), edited: None }).unwrap();+ request(&mut app);+ let (_, edited) = take_job(&work);+ app.session.catalog.apply(undo).unwrap();+ request(&mut app);+ let (_, restored) = take_job(&work);+ assert_eq!(restored.key, key);+ finish(&mut app, &work, &ctx, slot, restored.run());+ finish(&mut app, &work, &ctx, slot, edited.run());+ assert_eq!(app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels, original.pixels);+}++#[test]+fn explicit_clear_repairs_same_key_bad_pixels_and_rejects_old_same_key_job() {+ let (mut app, work, ctx) = fixture();+ let job = app.session.thumb_job(PhotoId(1), 256).unwrap();+ let expected = job.clone().run().rendered.unwrap().image;+ let (cache, key) = job.cache.clone().unwrap();+ let mut bad = expected.clone();+ bad.data.fill([255, 0, 255, 255]);+ cache.put(key, Arc::new(bad.clone()));+ request(&mut app);+ let (slot, corrupt) = take_job(&work);+ finish(&mut app, &work, &ctx, slot, corrupt.run());+ assert_eq!(app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels[0].to_array(), [255, 0, 255, 255]);+ // An old job can have the SAME render key and stale decoded pixels.+ let mut old = job.clone();+ old.source = lightcraft_engine::media::SourceRef::Loaded(Box::new(lightcraft_engine::media::DecodedSource::new(+ Arc::new(lightcraft_raster::Rgb32f::new(8, 8)),+ None,+ )));+ app.renderer.textures.clear();+ app.renderer.request(slot, old, 10);+ let (_, old) = take_job(&work);+ app.session.execute("library.clearPreviews", &serde_json::json!({})).unwrap();+ app.renderer.poll(&ctx, &mut app.session);+ assert!(app.renderer.thumb(PhotoId(1)).is_none());+ request(&mut app);+ let (_, repaired) = take_job(&work);+ assert_eq!(repaired.key, job.key);+ finish(&mut app, &work, &ctx, slot, repaired.run());+ finish(&mut app, &work, &ctx, slot, old.run());+ assert_eq!(cache.get(key).unwrap().as_bytes(), expected.as_bytes());+ assert_eq!(+ app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels.iter().flat_map(|c| c.to_array()).collect::<Vec<_>>(),+ expected.as_bytes()+ );+}++#[test]+fn undo_to_embedded_thumb_rejects_late_full_render() {+ let mut s = Session::new();+ s.media.preview_loader = Some(Arc::new(|_, _| Some(lightcraft_raster::Rgba8 { width: 4, height: 4, data: vec![[200, 100, 50, 255]; 16] })));+ let mut raw = (*photo()).clone();+ raw.kind = lightcraft_catalog::MediaKind::Raw;+ raw.develop = Arc::new(raw.camera_defaults());+ let (mut app, work, ctx) = fixture_with(s, raw);+ app.renderer.pool = JobPool::new(0);+ let id = PhotoId(1);+ let quick_slot = Slot::ThumbQuick(id);+ let full_slot = Slot::Thumb(id);+ let settings_a = app.session.catalog.photo(id).unwrap().develop.clone();++ crate::panels::grid::request_thumb(&mut app, id, 384, 10);+ assert_eq!(app.renderer.pool.run_inline(1), 1);+ app.renderer.poll(&ctx, &mut app.session);+ let (key_a, pixels_a) = {+ let shown = app.renderer.thumb(id).unwrap();+ assert_eq!(shown.quick, Some(QuickSource::Embedded));+ (shown.key, shown.pixels.as_ref().unwrap().pixels.clone())+ };+ assert!(app.renderer.textures.contains_key(&quick_slot));+ assert!(!app.renderer.textures.contains_key(&full_slot));+ assert!(work.borrow().jobs.is_empty());++ let mut settings_b = (*settings_a).clone();+ settings_b.light.exposure += 0.5;+ app.session.commit("Exposure", Op::SetDevelop { id, settings: Arc::new(settings_b), label: "Exposure".into(), edited: None }).unwrap();+ assert!(!app.session.embedded_thumb_is_final(app.session.catalog.photo(id).unwrap()));+ crate::panels::grid::request_thumb(&mut app, id, 384, 10);+ // Manual owns dispatched jobs: hold B until the real Undo command restores A.+ let (slot, held_b) = take_job(&work);+ assert_eq!(slot, full_slot);+ let key_b = held_b.key;+ assert_ne!(key_b, key_a);+ assert!(app.renderer.is_pending(full_slot));++ app.run("edit.undo", serde_json::json!({})).unwrap();+ assert_eq!(app.session.catalog.photo(id).unwrap().develop.as_ref(), settings_a.as_ref());+ assert!(app.session.embedded_thumb_is_final(app.session.catalog.photo(id).unwrap()));+ crate::panels::grid::request_thumb(&mut app, id, 384, 10);+ {+ let restored = app.renderer.thumb(id).unwrap();+ assert_eq!(restored.key, key_a);+ assert_eq!(restored.pixels.as_ref().unwrap().pixels, pixels_a);+ assert_eq!(restored.quick, Some(QuickSource::Embedded));+ }+ assert!(work.borrow().jobs.is_empty(), "restoring embedded-final A needs no full render");+ assert_eq!(app.renderer.pool.queued(), 0);++ let result_b = held_b.run();+ assert_eq!(result_b.key, key_b);+ let rendered_b = result_b.rendered.as_ref().expect("held edited thumbnail must render before the stale-result oracle");+ assert_ne!(color_image(&rendered_b.image).pixels, pixels_a, "the held result must be distinguishable from A");+ finish(&mut app, &work, &ctx, slot, result_b);++ let shown = app.renderer.thumb(id).unwrap();+ assert_eq!(shown.key, key_a, "late edited Thumb(B) must not replace restored embedded ThumbQuick(A)");+ assert_eq!(shown.pixels.as_ref().unwrap().pixels, pixels_a);+ assert_eq!(shown.quick, Some(QuickSource::Embedded));+ let quick = app.renderer.textures.get(&quick_slot).expect("the correct embedded thumbnail must remain installed");+ assert_eq!(quick.key, key_a);+ assert_eq!(quick.quick, Some(QuickSource::Embedded));+ assert_eq!(quick.pixels.as_ref().unwrap().pixels, pixels_a);+ assert!(!app.renderer.is_pending(full_slot));+}