Files
photocraft/crates/io/tests/it/flat_export_renderer.rs
T
Khawar Zamman WaniandFredApps 13b481f892 Expose optional GPU composition and export in photocraft-cli (#10912)
* Add headless GPU backend foundation for composition and flat export (issue #8062 PR 1)

* Fix headless GPU readback bounds, API compliance, and error preservation (#8062)

* Fix GPU readback bounds, context thread spawn error, and test parity (#8062)

* Fix BandRenderer Send bound, PNG reborrows, and clippy lints (#8062)

* Fix effect shadow test construction and remove dead code wrappers (#8062)

* Use short reborrows for Headless renderer without lifetime escaping (#8062)

* Fix clippy collapsible_if and ensure multi-band geometry in flat export tests (#8062)

* Fix automation Rect import, add renderer diagnostics, and harden flat export retries (#8062)

* Expose optional GPU rendering in photocraft-cli (#8062)

* Fix GPU feature test APIs and native target gates

* Fix CLI locked metadata, bounded benchmark params, and protocol diagnostics (#8062)

* Verify unsupported GPU effects before testing band seams

* Fix CLI renderer borrows and GPU-enabled test compilation

* Use compositor buffer ownership API after upstream memory accounting change

* Fix GPU CLI lint failures and validate run environment policy

* Update export renderer test helper for owned compositor buffers

* Fix needless benchmark layer name borrow

* Fix headless GPU backend review findings (#10842)

- release a closed document's GPU caches through a BandRenderer hook
- bound the monitored readback wait and report a stalled GPU as device loss
- reject 32-bit float documents before band readback so exports fall back to CPU
- keep previews at 8-bit RGBA and report the palette/Duotone renderer bypass
- retain renderer diagnostics when encoding fails
- strengthen renderer, save-path and GPU diagnostics tests

* Use valid batch arguments and inspect method in GPU CLI tests

* Add GPU close-hook and 8-bit preview regression tests (#10842)

* Fix GPU CLI review findings (#10912)

- guard the benchmark's modulo divisors for one-pixel dimensions
- count a cold export as GPU only when the renderer context was used
- report every batch file's export warnings, deduplicating only GPU diagnostics
- drain renderer diagnostics before propagating convert and run save errors
- cover renderer use in the GPU precedence, bridge and serve tests

* fix(io): correct renderer binding mutability

* test(cli): verify narrow benchmark inputs and GPU diagnostics

* Fix remaining headless GPU review findings (#10842)

- release a document's GPU caches when file.close, file.closeAll or
  file.closeOthers removes it through a command
- honor cancellation while band readback waits, polling in 100 ms slices
- fault the device after a readback timeout so later exports skip it
- report single-layer, CMYK ink-mixing, ORA and PDF CPU paths to a
  requested renderer
- keep fallback warnings in their export instead of leaking them into the
  next one
- requeue renderer diagnostics when a renderer-aware save's final write
  fails
- write MCP/serve diagnostics without panicking on a broken stderr
- document the actual colour-space contract and drop F32 from the GPU
  depth list

* Fix remaining headless GPU review findings (#10842)

- release a document's GPU caches when file.close, file.closeAll or
  file.closeOthers removes it through a command
- honor cancellation while band readback waits, polling in 100 ms slices
- fault the device after a readback timeout so later exports skip it
- report single-layer, CMYK ink-mixing, ORA and PDF CPU paths to a
  requested renderer
- keep fallback warnings in their export instead of leaking them into the
  next one
- requeue renderer diagnostics when a renderer-aware save's final write
  fails
- write MCP/serve diagnostics without panicking on a broken stderr
- document the actual colour-space contract and drop F32 from the GPU
  depth list

* Fix remaining GPU CLI review findings (#10912)

- reject non-UTF-8 PHOTOCRAFT_GPU values instead of silently using the CPU
- release a batch item's document caches before taking the renderer to the
  next item, and report fallbacks once
- count warm benchmark runs that fell back to CPU in the summary
- write serve diagnostics without panicking on a broken stderr
- assert that the batch test's --gpu policy reaches the renderer

* Use question mark for cancellable readback errors

* Use question mark for cancellable readback errors

* Keep GPU export diagnostics with their attempt and stop bands on cancel

Encode native .pcraft bytes before draining renderer diagnostics, and
requeue export warnings when a workspace write fails, so callers still
report the adapter or fallback reason with the error.

Move a failed GPU attempt's queued diagnostics into its CPU retry result
instead of leaving them for a later successful export to report.

Stop GPU band readback at the next band after cancellation, and check the
interrupt before each CpuRenderer sink delivery.

Band readback uploads half-precision textures, so reject U16 alongside
F32: their samples cannot survive the upload. Tighten the 8-bit CPU/GPU
parity checks to 1/255.

* Keep GPU export diagnostics with their attempt and stop bands on cancel

Encode native .pcraft bytes before draining renderer diagnostics, and
requeue export warnings when a workspace write fails, so callers still
report the adapter or fallback reason with the error.

Move a failed GPU attempt's queued diagnostics into its CPU retry result
instead of leaving them for a later successful export to report.

Stop GPU band readback at the next band after cancellation, and check the
interrupt before each CpuRenderer sink delivery.

Band readback uploads half-precision textures, so reject U16 alongside
F32: their samples cannot survive the upload. Tighten the 8-bit CPU/GPU
parity checks to 1/255.

* Report partial warm fallbacks and CPU fallback on stderr

The averaged GPU Warm row now says how many warm runs fell back to the
CPU and were excluded from the average, through the existing helper.

The single-layer convert diagnostic test checks that the CPU fallback is
reported on stderr, in GPU-enabled and CPU-only builds alike.

* Keep headless export warnings when a workspace write fails (#10842)

A capability-scoped save encodes the export, then writes it; when the write
fails, the export warnings (folded together with renderer diagnostics) were
pushed back through `BandRenderer::push_diagnostic`, whose default is a no-op.
A custom renderer that overrides only `drain_diagnostics` therefore lost the
adapter or fallback reason that belonged with the error.

Keep them in `Headless` instead and return them from the next
`drain_diagnostics`, alongside the renderer's own queue. The regression uses a
renderer without a `push_diagnostic` override and checks the warnings survive
the failed write and drain exactly once.

Also name the actual source of the depth limit in the headless GPU matrix:
layer content is uploaded as half-precision textures, not band readback.

* Stop CPU bands and CPU retries on cancellation (#10912)

The CPU retry after a retryable GPU error composes through
`FlatSource::bands`, whose shared `emit` sink did not poll the export
interrupt: a cancel was only observed after the whole composite finished.
Check it once per band, as `CpuRenderer` does, for both RGB and CMYK ink
bands. The flat and streamed-PNG retry branches also check before starting
the full CPU composite again, so a cancelled export returns
`IoError::Cancelled` instead of re-rendering the document.

Tests: band-sink cancellation for RGB and CMYK inks, a renderer call counter
proving a second export reaches the renderer, and a pending `wait_slices`
poll observing cancellation set mid-wait.

* Merge origin/main into GPU foundation (#10842)

* Keep GPU-path diagnostics on every failure path, honour cancel in native copy

- save: export warnings of a failed local write stay in Headless pending diagnostics
- render: preview fallback warnings are returned, drained, and added to the doc.render reply
- io: renderer-neutral fallback wording; native single-layer copy checks cancellation per band
- gpu: gate wait_slices tests off wasm32 (#10842)

* Address CodeRabbit review: keep fallback reasons on failed retries, report native-copy and quick-export CPU use, guard diagnostics drain (#10912)

* Accept render diagnostics from the doc.render reply in the serve GPU test (#10912)

---------

Co-authored-by: FredApps <153173854+FredApps@users.noreply.github.com>
2026-11-05 05:39:59 +01:00

505 lines
22 KiB
Rust

//! Tests for custom [`BandRenderer`] injection, complete CPU retry, and renderer error handling.
use std::sync::atomic::{AtomicUsize, Ordering};
use photocraft_codecs::Format;
use photocraft_color::{BlendMode, Color, ColorMode, SampleType};
use photocraft_doc::{Document, Layer, LayerContent};
use photocraft_geom::{Rect, Size};
use photocraft_io::{
BandRenderer, CpuRenderer, ExportOptions, IoError, RenderBand, RenderError, document_to_image_with_renderer, export_flat, export_flat_with_renderer,
export_png_streamed_with_renderer, export_preview_png_with_renderer,
};
use photocraft_raster::{Interrupt, Surface};
fn synthetic_doc() -> Document {
let mut doc = Document::with_background("synth", Size::new(128, 300), ColorMode::Rgb, SampleType::U8, Color::WHITE);
let mut s = Surface::new(doc.pixel_format());
s.fill_rect(Rect::new(20, 20, 100, 260), &[0.1, 0.4, 0.9, 0.7]);
let mut top = Layer::new("top", LayerContent::Raster(s));
top.opacity = 0.8;
top.blend = BlendMode::Multiply;
doc.layers.push(top);
doc
}
#[derive(Default)]
struct RecordingRenderer {
diagnostics: Vec<String>,
/// How many times `render_bands` was called.
renders: usize,
}
impl BandRenderer for RecordingRenderer {
fn render_bands(
&mut self,
doc: &Document,
rect: Rect,
band_rows: i32,
ctl: &Interrupt<'_>,
sink: &mut dyn FnMut(RenderBand) -> Result<(), IoError>,
) -> Result<(), RenderError> {
self.renders += 1;
let mut cpu = CpuRenderer;
cpu.render_bands(doc, rect, band_rows, ctl, sink)
}
fn drain_diagnostics(&mut self) -> Vec<String> {
std::mem::take(&mut self.diagnostics)
}
fn push_diagnostic(&mut self, diagnostic: String) {
self.diagnostics.push(diagnostic);
}
}
struct FailingRenderer {
fail_after_bands: usize,
call_count: AtomicUsize,
error_kind: &'static str,
}
impl FailingRenderer {
fn new(fail_after_bands: usize, error_kind: &'static str) -> Self {
Self { fail_after_bands, call_count: AtomicUsize::new(0), error_kind }
}
}
impl BandRenderer for FailingRenderer {
fn render_bands(
&mut self,
doc: &Document,
rect: Rect,
band_rows: i32,
_ctl: &Interrupt<'_>,
sink: &mut dyn FnMut(RenderBand) -> Result<(), IoError>,
) -> Result<(), RenderError> {
let rows = if band_rows > 0 { band_rows } else { 32 };
photocraft_compose::render_bands(doc, rect, rows, |buf| {
let count = self.call_count.fetch_add(1, Ordering::SeqCst);
if count >= self.fail_after_bands {
return match self.error_kind {
"unsupported" => Err(IoError::Render(RenderError::Unsupported("forced unsupported feature".into()))),
"device" => Err(IoError::Render(RenderError::Device("forced device loss".into()))),
"cancelled" => Err(IoError::Cancelled),
_ => Err(IoError::Render(RenderError::Execution("forced failure".into()))),
};
}
sink(RenderBand { rect: buf.rect, pixels: buf.into_px() })
})
.map_err(|e| match e {
IoError::Render(r) => r,
IoError::Cancelled => RenderError::Cancelled,
other => RenderError::sink(other),
})
}
}
struct GeometryViolatingRenderer {
violation: &'static str,
}
impl BandRenderer for GeometryViolatingRenderer {
fn render_bands(
&mut self,
_doc: &Document,
rect: Rect,
_band_rows: i32,
_ctl: &Interrupt<'_>,
sink: &mut dyn FnMut(RenderBand) -> Result<(), IoError>,
) -> Result<(), RenderError> {
let (w, h) = (rect.width(), rect.height());
match self.violation {
"wrong_pixels" => {
sink(RenderBand { rect: Rect::new(0, 0, w as i32, h as i32), pixels: vec![[0.0; 4]; (w as usize * h as usize).saturating_sub(10)] })
.map_err(RenderError::sink)
}
"out_of_order" => {
// Yield band starting at y=10 instead of 0
sink(RenderBand { rect: Rect::new(0, 10, w as i32, 20), pixels: vec![[0.0; 4]; w as usize * 10] }).map_err(RenderError::sink)
}
"wrong_width" => {
sink(RenderBand { rect: Rect::new(0, 0, (w as i32).saturating_sub(5), 10), pixels: vec![[0.0; 4]; (w as usize).saturating_sub(5) * 10] })
.map_err(RenderError::sink)
}
_ => Ok(()),
}
}
}
#[test]
fn single_layer_and_cmyk_exports_report_that_the_renderer_was_not_used() {
// A single plain layer takes the native copy path, never calling a renderer.
let mut single = Document::with_background("single", Size::new(24, 24), ColorMode::Rgb, SampleType::U8, Color::WHITE);
single.layers[0].name = "Background".into();
let mut renderer = RecordingRenderer::default();
let mut warnings = Vec::new();
document_to_image_with_renderer(&single, &mut warnings, Some(&mut renderer)).expect("single-layer export");
assert!(warnings.iter().any(|d| d.contains("single-layer") && d.contains("CPU")), "a requested renderer that is bypassed must report why: {warnings:?}");
assert_eq!(renderer.renders, 0, "the native copy never calls the renderer");
// A CMYK composite mixed on ink values likewise returns before the renderer branch.
let mut cmyk = Document::with_background("cmyk", Size::new(32, 32), ColorMode::Cmyk, SampleType::U8, Color::WHITE);
let mut s = Surface::new(cmyk.pixel_format());
s.fill_rect(Rect::new(4, 4, 28, 28), &[0.1, 0.2, 0.3, 0.4, 0.5]);
cmyk.layers.push(Layer::new("ink", LayerContent::Raster(s)));
let mut renderer = RecordingRenderer::default();
let res = export_flat_with_renderer(&cmyk, Format::Tiff, &ExportOptions::default(), &Interrupt::NONE, Some(&mut renderer)).expect("CMYK TIFF export");
assert!(
res.warnings.iter().any(|w| w.contains("CMYK ink mixing") && w.contains("CPU")),
"CMYK ink mixing must report its CPU fallback: {:?}",
res.warnings
);
}
struct FailOnceDiagnosingRenderer {
failed: bool,
calls: usize,
diagnostics: Vec<String>,
}
impl BandRenderer for FailOnceDiagnosingRenderer {
fn render_bands(
&mut self,
doc: &Document,
rect: Rect,
band_rows: i32,
ctl: &Interrupt<'_>,
sink: &mut dyn FnMut(RenderBand) -> Result<(), IoError>,
) -> Result<(), RenderError> {
self.calls += 1;
if !self.failed {
self.failed = true;
self.push_diagnostic("GPU readback error: forced device loss".into());
return Err(RenderError::Device("forced device loss".into()));
}
let mut cpu = CpuRenderer;
cpu.render_bands(doc, rect, band_rows, ctl, sink)
}
fn drain_diagnostics(&mut self) -> Vec<String> {
std::mem::take(&mut self.diagnostics)
}
fn push_diagnostic(&mut self, diagnostic: String) {
self.diagnostics.push(diagnostic);
}
}
#[test]
fn fallback_diagnostics_stay_with_the_failed_export() {
let doc = synthetic_doc();
let opts = ExportOptions::default();
let mut renderer = FailOnceDiagnosingRenderer { failed: false, calls: 0, diagnostics: Vec::new() };
let first = export_flat_with_renderer(&doc, Format::Png, &opts, &Interrupt::NONE, Some(&mut renderer)).expect("first export retries on CPU");
assert!(first.warnings.iter().any(|w| w.contains("falling back to CPU")), "the failed export reports its fallback: {:?}", first.warnings);
assert!(
first.warnings.iter().any(|w| w.contains("GPU readback error")),
"the failed attempt's queued diagnostics belong to its retry result: {:?}",
first.warnings
);
let calls_before_second = renderer.calls;
let second = export_flat_with_renderer(&doc, Format::Png, &opts, &Interrupt::NONE, Some(&mut renderer)).expect("second export uses the GPU path");
assert!(renderer.calls > calls_before_second, "the second export must call the renderer: {}", renderer.calls);
assert!(!second.warnings.iter().any(|w| w.contains("falling back to CPU")), "a fallback warning must not carry into a later export: {:?}", second.warnings);
assert!(
!second.warnings.iter().any(|w| w.contains("GPU readback error")),
"queued diagnostics must not carry into a later successful export: {:?}",
second.warnings
);
}
/// Composes bands through the reference compositor but never polls `ctl` itself, so a band only
/// reaches the export sink when the export checks cancellation. Counts the bands it forwarded.
#[derive(Default)]
struct UnpollingRenderer {
bands: usize,
}
impl BandRenderer for UnpollingRenderer {
fn render_bands(
&mut self,
doc: &Document,
rect: Rect,
band_rows: i32,
_ctl: &Interrupt<'_>,
sink: &mut dyn FnMut(RenderBand) -> Result<(), IoError>,
) -> Result<(), RenderError> {
let rows = if band_rows > 0 { band_rows } else { 32 };
photocraft_compose::render_bands(doc, rect, rows, |buf| {
sink(RenderBand { rect: buf.rect, pixels: buf.into_px() })?;
self.bands += 1;
Ok(())
})
.map_err(RenderError::sink)
}
}
#[test]
fn cancellation_stops_the_cpu_band_sink() {
let opts = ExportOptions::default();
// RGB bands: cancellation is checked per band, so the second band is never assembled.
let checks = AtomicUsize::new(0);
let cancel = || checks.fetch_add(1, Ordering::SeqCst) + 1 >= 2;
let mut renderer = UnpollingRenderer::default();
let res = export_flat_with_renderer(&synthetic_doc(), Format::Tiff, &opts, &Interrupt::cancel_only(&cancel), Some(&mut renderer));
assert!(matches!(res, Err(IoError::Cancelled)), "a cancelled RGB export must stop between bands: {res:?}");
assert_eq!(renderer.bands, 1, "the band after a cancellation request must not be assembled");
// CMYK inks mix in bands through the same sink: none is assembled once cancelled.
let mut cmyk = Document::with_background("cmyk", Size::new(32, 32), ColorMode::Cmyk, SampleType::U8, Color::WHITE);
let mut s = Surface::new(cmyk.pixel_format());
s.fill_rect(Rect::new(4, 4, 28, 28), &[0.1, 0.2, 0.3, 0.4, 0.5]);
cmyk.layers.push(Layer::new("ink", LayerContent::Raster(s)));
let mut renderer = UnpollingRenderer::default();
let res = export_flat_with_renderer(&cmyk, Format::Tiff, &opts, &Interrupt::cancel_only(&|| true), Some(&mut renderer));
assert!(matches!(res, Err(IoError::Cancelled)), "a cancelled CMYK export must stop before its first band: {res:?}");
assert_eq!(renderer.bands, 0, "no CMYK band may be assembled when the export is already cancelled");
}
#[test]
fn cancelled_export_leaves_queued_diagnostics_on_the_renderer() {
let doc = synthetic_doc();
let opts = ExportOptions::default();
let mut renderer = FailOnceDiagnosingRenderer { failed: false, calls: 0, diagnostics: Vec::new() };
let cancelled = Interrupt::cancel_only(&|| true);
let res = export_flat_with_renderer(&doc, Format::Png, &opts, &cancelled, Some(&mut renderer));
assert!(matches!(res, Err(IoError::Cancelled)), "cancellation must be observed before the CPU retry: {res:?}");
assert_eq!(renderer.calls, 1, "the cancelled export must not retry through the renderer: {}", renderer.calls);
let diagnostics = renderer.drain_diagnostics();
assert!(diagnostics.iter().any(|d| d.contains("GPU readback error")), "diagnostics must stay queued when the export is cancelled: {diagnostics:?}");
}
#[test]
fn ora_and_pdf_exports_report_cpu_use_when_a_renderer_is_set() {
let doc = synthetic_doc();
let opts = ExportOptions::default();
for (name, marker) in [("out.ora", "OpenRaster export uses CPU compositor"), ("out.pdf", "PDF export uses CPU compositor")] {
let mut renderer = RecordingRenderer::default();
let res = photocraft_io::export_with_renderer(&doc, name, &opts, &Interrupt::NONE, Some(&mut renderer)).expect("CPU-only format export");
assert!(res.warnings.iter().any(|w| w.contains(marker)), "{name} must report CPU use: {:?}", res.warnings);
}
}
#[test]
fn custom_cpu_renderer_matches_default_export() {
let doc = synthetic_doc();
let opts = ExportOptions::default();
let def = export_flat(&doc, Format::Png, &opts).expect("default export");
let mut custom = CpuRenderer;
let res = export_flat_with_renderer(&doc, Format::Png, &opts, &Interrupt::NONE, Some(&mut custom)).expect("custom export");
assert_eq!(def.bytes, res.bytes);
assert_eq!(def.warnings, res.warnings);
}
#[test]
fn renderer_preview_is_8bit_rgba_while_saved_export_keeps_depth() {
let mut doc = Document::with_background("preview16", Size::new(64, 48), ColorMode::Rgb, SampleType::U16, Color::WHITE);
let mut s = Surface::new(doc.pixel_format());
s.fill_rect(Rect::new(8, 8, 56, 40), &[0.2, 0.4, 0.8, 0.5]);
doc.layers.push(Layer::new("top", LayerContent::Raster(s)));
let mut preview_renderer = RecordingRenderer::default();
let preview = export_preview_png_with_renderer(&doc, Some(&mut preview_renderer)).expect("preview export");
assert!(preview_renderer.renders > 0, "the preview must render through the supplied renderer");
let img = photocraft_codecs::decode(&preview.bytes).expect("decode preview");
assert_eq!((img.width(), img.height()), (64, 48));
assert_eq!(img.layout(), photocraft_codecs::ChannelLayout::Rgba, "a preview is always RGBA");
assert_eq!(img.sample_type(), photocraft_codecs::SampleType::U8, "a preview is always 8-bit");
let pixel = |x: u32, y: u32| {
let at = ((y * img.width() + x) * 4) as usize;
&img.data()[at..at + 4]
};
// Inside the 50 % blue layer: half the layer colour over white.
let inside = pixel(32, 24);
for (got, want) in inside.iter().zip([153u8, 179, 230, 255]) {
assert!(got.abs_diff(want) <= 2, "preview compositing is wrong inside the layer: {inside:?}");
}
// Outside the layer: the white background.
assert_eq!(pixel(2, 2), [255, 255, 255, 255], "preview must keep the document background");
// A saved export keeps the document's native depth: the preview conversion is preview-only.
let opts = ExportOptions::default();
let mut save_renderer = CpuRenderer;
let saved = export_flat_with_renderer(&doc, Format::Png, &opts, &Interrupt::NONE, Some(&mut save_renderer)).expect("saved export");
let saved_img = photocraft_codecs::decode(&saved.bytes).expect("decode saved export");
assert_eq!(saved_img.sample_type(), photocraft_codecs::SampleType::U16, "saved exports keep the document's depth");
}
#[test]
fn forced_unsupported_renderer_restarts_complete_export_on_cpu() {
let doc = synthetic_doc();
let opts = ExportOptions::default();
let expected = export_flat(&doc, Format::Png, &opts).expect("baseline CPU export");
let mut failing = FailingRenderer::new(0, "unsupported");
let res = export_flat_with_renderer(&doc, Format::Png, &opts, &Interrupt::NONE, Some(&mut failing)).expect("export should retry and succeed on CPU");
assert_eq!(expected.bytes, res.bytes, "output after retry must match clean CPU output");
assert!(
res.warnings.iter().any(|w| w.contains("custom renderer unavailable") && w.contains("falling back to CPU")),
"fallback warning must be reported: {:?}",
res.warnings
);
}
#[test]
fn forced_mid_band_failure_restarts_complete_export_on_cpu() {
let doc = synthetic_doc();
let opts = ExportOptions::default();
let expected = export_flat(&doc, Format::Png, &opts).expect("baseline CPU export");
// Fail on the second band (mid-render)
let mut failing = FailingRenderer::new(1, "device");
let res = export_flat_with_renderer(&doc, Format::Png, &opts, &Interrupt::NONE, Some(&mut failing)).expect("export should restart completely on CPU");
assert_eq!(expected.bytes, res.bytes, "output after mid-band restart must match pure CPU output");
assert!(res.warnings.iter().any(|w| w.contains("falling back to CPU")), "fallback warning must be present: {:?}", res.warnings);
}
#[test]
fn cancellation_is_not_retried() {
let doc = synthetic_doc();
let opts = ExportOptions::default();
let mut failing = FailingRenderer::new(0, "cancelled");
let res = export_flat_with_renderer(&doc, Format::Png, &opts, &Interrupt::NONE, Some(&mut failing));
assert!(matches!(res, Err(IoError::Cancelled)), "cancelled render must not restart on CPU");
}
#[test]
fn encoder_and_sink_failures_are_not_retried_on_cpu() {
struct SinkFailingRenderer;
impl BandRenderer for SinkFailingRenderer {
fn render_bands(
&mut self,
_doc: &Document,
_rect: Rect,
_band_rows: i32,
_ctl: &Interrupt<'_>,
_sink: &mut dyn FnMut(RenderBand) -> Result<(), IoError>,
) -> Result<(), RenderError> {
Err(RenderError::sink(IoError::Unsupported("test sink failure".into())))
}
}
let doc = synthetic_doc();
let opts = ExportOptions::default();
// A non-cancellation sink error with no interrupt: a CPU retry would succeed with `Ok`, so
// this assertion fails if the error is ever retried on the CPU.
let mut renderer = SinkFailingRenderer;
let res = export_flat_with_renderer(&doc, Format::Png, &opts, &Interrupt::NONE, Some(&mut renderer));
assert!(matches!(res, Err(IoError::Unsupported(_))), "sink error must propagate without a CPU retry: {res:?}");
}
#[test]
fn band_geometry_violations_are_rejected() {
let doc = synthetic_doc();
let opts = ExportOptions::default();
for violation in ["wrong_pixels", "out_of_order", "wrong_width"] {
let mut renderer = GeometryViolatingRenderer { violation };
let res = export_flat_with_renderer(&doc, Format::Png, &opts, &Interrupt::NONE, Some(&mut renderer));
assert!(
matches!(res, Err(IoError::Render(RenderError::Execution(_)))),
"violation '{violation}' must be rejected before codec consumes corrupt data: {res:?}"
);
}
}
#[test]
fn streamed_png_retries_on_cpu_upon_renderer_failure() {
let doc = synthetic_doc();
let opts = ExportOptions::default();
let expected = export_png_streamed_with_renderer(&doc, &opts, &Interrupt::NONE, 16, None).expect("baseline streamed PNG");
let mut failing = FailingRenderer::new(1, "device");
let res = export_png_streamed_with_renderer(&doc, &opts, &Interrupt::NONE, 16, Some(&mut failing)).expect("streamed PNG should retry on CPU");
assert_eq!(expected.bytes, res.bytes);
assert!(res.warnings.iter().any(|w| w.contains("falling back to CPU")));
}
#[test]
fn unknown_export_format_is_rejected() {
let doc = synthetic_doc();
let opts = ExportOptions::default();
// `export` takes a name or bare extension; an unknown one fails before any codec runs.
let export_err = photocraft_io::export(&doc, "invalid_unknown_extension_xyz", &opts);
assert!(export_err.is_err());
}
/// A renderer that fails retryably on its first call and, as it does, requests cancellation, so
/// the complete CPU retry that follows cannot succeed. It queues pushed diagnostics for the test.
struct FailThenCancelRenderer {
cancel: std::sync::Arc<std::sync::atomic::AtomicBool>,
diagnostics: Vec<String>,
}
impl BandRenderer for FailThenCancelRenderer {
fn render_bands(
&mut self,
_doc: &Document,
_rect: Rect,
_band_rows: i32,
_ctl: &Interrupt<'_>,
_sink: &mut dyn FnMut(RenderBand) -> Result<(), IoError>,
) -> Result<(), RenderError> {
self.cancel.store(true, Ordering::SeqCst);
Err(RenderError::Device("forced device loss".into()))
}
fn drain_diagnostics(&mut self) -> Vec<String> {
std::mem::take(&mut self.diagnostics)
}
fn push_diagnostic(&mut self, diagnostic: String) {
self.diagnostics.push(diagnostic);
}
}
#[test]
fn a_failed_cpu_retry_keeps_the_fallback_reason_on_the_renderer() {
let doc = synthetic_doc();
let opts = ExportOptions::default();
for streamed in [false, true] {
let flag = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
let seen = flag.clone();
let cancel = move || seen.load(Ordering::SeqCst);
let ctl = Interrupt::cancel_only(&cancel);
let mut renderer = FailThenCancelRenderer { cancel: flag, diagnostics: Vec::new() };
let res = if streamed {
export_png_streamed_with_renderer(&doc, &opts, &ctl, 0, Some(&mut renderer))
} else {
export_flat_with_renderer(&doc, Format::Png, &opts, &ctl, Some(&mut renderer))
};
assert!(matches!(res, Err(IoError::Cancelled)), "the CPU retry is cancelled (streamed: {streamed}): {res:?}");
let diagnostics = renderer.drain_diagnostics();
assert!(
diagnostics.iter().any(|d| d.contains("custom renderer unavailable") && d.contains("falling back to CPU")),
"the fallback reason must survive the failed retry (streamed: {streamed}): {diagnostics:?}"
);
}
}
#[test]
fn single_layer_notice_reaches_the_export_warnings_without_renderer_diagnostics() {
// `FailingRenderer` keeps the default no-op `push_diagnostic`, like any renderer that ignores it.
let single = Document::with_background("single", Size::new(24, 24), ColorMode::Rgb, SampleType::U8, Color::WHITE);
let mut renderer = FailingRenderer::new(usize::MAX, "device");
let res = export_flat_with_renderer(&single, Format::Png, &ExportOptions::default(), &Interrupt::NONE, Some(&mut renderer)).expect("single-layer export");
assert!(res.warnings.iter().any(|w| w.contains("single-layer") && w.contains("CPU")), "{:?}", res.warnings);
let res = export_png_streamed_with_renderer(&single, &ExportOptions::default(), &Interrupt::NONE, 0, Some(&mut renderer)).expect("streamed single layer");
assert!(res.warnings.iter().any(|w| w.contains("single-layer") && w.contains("CPU")), "{:?}", res.warnings);
}