Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

26.4 KB
Raw Blame
use super::*;

#[cfg(feature = "raytrace-cpu")]
mod camera_passes {
    use super::primary::PrimaryFilm;
    use super::*;
    use crate::job::CpuProgressiveOptions;

    fn primary() -> PrimaryFilm {
        let options = CpuProgressiveOptions { samples_per_pixel: 4, seed: 7 };
        let bytes = PrimaryFilm::required_bytes(2, 1, options, crate::job::CpuBudget::Compact).unwrap();
        let mut film = PrimaryFilm::new(2, 1, options, bytes, &CancelToken::default(), crate::job::CpuBudget::Compact).unwrap();
        assert!(!film.ready());
        let mut charged = 0;
        while !film.ready() {
            film.initialize_one(&CancelToken::default(), &mut || {
                charged += 1;
                Ok(())
            })
            .unwrap();
        }
        assert_eq!(charged, 2);
        film
    }

    #[test]
    fn camera_film_keeps_linear_sums_coverage_and_uniform_absolute_passes() {
        let mut film = primary();
        let cancel = CancelToken::default();
        assert!(film.pixel(0).is_err());
        for ordinal in 0..4 {
            film.add(0, ordinal, [2.0, 4.0, 8.0], true, &cancel, &mut || Ok(())).unwrap();
            assert!(film.pixel(0).is_err(), "a partial pass cannot be resolved");
            assert!(film.add(0, ordinal, [0.0; 3], false, &cancel, &mut || Ok(())).is_err(), "duplicate pixel must not consume a sample");
            let covered = ordinal % 2 == 0;
            film.add(1, ordinal, if covered { [6.0; 3] } else { [0.0; 3] }, covered, &cancel, &mut || Ok(())).unwrap();
            assert_eq!(film.samples(), ordinal + 1);
        }
        assert_eq!(film.pixel(0).unwrap(), ([2.0, 4.0, 8.0], 4, 4));
        assert_eq!(film.pixel(1).unwrap(), ([3.0; 3], 2, 4));
        assert!(film.add(0, 4, [1.0; 3], true, &cancel, &mut || Ok(())).is_err());
    }

    #[test]
    fn camera_film_cancellation_invalid_radiance_and_work_failure_are_atomic() {
        let mut film = primary();
        let cancel = CancelToken::default();
        let observer = cancel.clone();
        assert_eq!(
            film.add(0, 0, [1.0; 3], true, &cancel, &mut || {
                observer.cancel();
                Ok(())
            })
            .unwrap_err()
            .code,
            ErrorCode::Cancelled
        );
        for (rgb, covered) in [([1.0; 3], false), ([f64::NAN; 3], true), ([-1.0; 3], true)] {
            assert!(film.add(0, 0, rgb, covered, &CancelToken::default(), &mut || Ok(())).is_err());
        }
        assert!(film.add(0, 0, [1.0; 3], true, &CancelToken::default(), &mut || Err(limit("work exhausted"))).is_err());
        film.add(0, 0, [4.0; 3], true, &CancelToken::default(), &mut || Ok(())).unwrap();
        film.add(1, 0, [0.0; 3], false, &CancelToken::default(), &mut || Ok(())).unwrap();
        assert_eq!(film.pixel(0).unwrap(), ([4.0; 3], 1, 1));
        assert_eq!(film.pixel(1).unwrap(), ([0.0; 3], 0, 1));
    }
}

fn film(width: u32, height: u32, limit: u32) -> FilmAccumulator {
    let bytes = FilmAccumulator::required_bytes(width, height, limit).unwrap();
    FilmAccumulator::new(width, height, limit, bytes, &CancelToken::default(), &mut |_| Ok(())).unwrap()
}

fn add(film: &mut FilmAccumulator, start: usize, values: &[[f64; 3]]) {
    film.add_range(start, values, &CancelToken::default(), &mut |_| Ok(())).unwrap();
}

#[test]
fn constant_and_alternating_samples_have_analytic_statistics() {
    let mut film = film(2, 1, 4);
    for value in [0.0, 2.0, 0.0, 2.0] {
        add(&mut film, 0, &[[7.0, 3.0, 1.0], [value; 3]]);
    }
    assert_eq!(film.pixel_statistics(0).unwrap(), PixelStatistics { mean: [7.0, 3.0, 1.0], variance: [0.0; 3], count: 4 });
    let statistics = film.pixel_statistics(1).unwrap();
    assert_eq!(statistics.mean, [1.0; 3]);
    assert_eq!(statistics.variance, [4.0 / 3.0; 3]);
}

#[test]
fn complete_pass_refuses_empty_or_uneven_counts_and_keeps_linear_values() {
    let mut film = film(2, 1, 3);
    assert!(film.complete_pass(&CancelToken::default(), &mut |_| Ok(())).is_err());
    add(&mut film, 0, &[[20.0, 2.0, 0.0]]);
    assert!(film.complete_pass(&CancelToken::default(), &mut |_| Ok(())).is_err());
    add(&mut film, 1, &[[4.0, 8.0, 16.0]]);
    let pass = film.complete_pass(&CancelToken::default(), &mut |_| Ok(())).unwrap();
    assert_eq!(pass.samples_per_pixel(), 1);
    assert_eq!(pass.dimensions(), (2, 1));
    assert_eq!(pass.pixels().collect::<Vec<_>>(), vec![[20.0, 2.0, 0.0], [4.0, 8.0, 16.0]]);
}

#[test]
fn invalid_sample_at_end_leaves_entire_update_unchanged() {
    for bad in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, -1.0] {
        let mut film = film(2, 1, 3);
        add(&mut film, 0, &[[1.0; 3], [2.0; 3]]);
        let before = film.pixels.clone();
        assert_eq!(film.add_range(0, &[[3.0; 3], [bad; 3]], &CancelToken::default(), &mut |_| Ok(())).unwrap_err().code, ErrorCode::InvalidRequest);
        assert_eq!(film.pixels, before);
    }
}

#[test]
fn sample_limit_and_numeric_overflow_refuse_atomically() {
    let mut limited = film(2, 1, 1);
    add(&mut limited, 1, &[[1.0; 3]]);
    let before = limited.pixels.clone();
    assert_eq!(limited.add_range(0, &[[1.0; 3]; 2], &CancelToken::default(), &mut |_| Ok(())).unwrap_err().code, ErrorCode::LimitExceeded);
    assert_eq!(limited.pixels, before);
    let mut extreme = film(2, 1, 3);
    add(&mut extreme, 0, &[[1.0; 3], [f64::MAX; 3]]);
    let before = extreme.pixels.clone();
    assert!(extreme.add_range(0, &[[2.0; 3], [0.0; 3]], &CancelToken::default(), &mut |_| Ok(())).is_err());
    assert_eq!(extreme.pixels, before);
}

#[test]
fn dimensions_bytes_and_actual_capacity_are_checked() {
    for (width, height, samples) in [(0, 1, 1), (1, 0, 1), (u32::MAX, u32::MAX, 1), (1, 1, 0), (1, 1, MAX_SAMPLES + 1)] {
        assert!(FilmAccumulator::required_bytes(width, height, samples).is_err());
    }
    assert!(FilmAccumulator::required_bytes(MAX_DIMENSION, MAX_DIMENSION, 1).is_err());
    assert!(bytes_for_capacity(usize::MAX).is_err());
    let bytes = FilmAccumulator::required_bytes(2, 2, 1).unwrap();
    assert!(FilmAccumulator::new(2, 2, 1, bytes - 1, &CancelToken::default(), &mut |_| Ok(())).is_err());
    let film = film(2, 2, 1);
    assert!(film.allocated_bytes().unwrap() <= bytes);
    assert_eq!(film.allocated_bytes().unwrap(), bytes_for_capacity(film.pixels.capacity()).unwrap());
    assert!(film.allocated_bytes().unwrap() >= (std::mem::size_of::<Pixel>() * (4 + MAX_UPDATE)) as u64);
}

#[test]
fn invalid_ranges_and_oversized_updates_preserve_state() {
    let mut film = film(2, 1, 1);
    for (start, values) in [(0, Vec::new()), (usize::MAX, vec![[1.0; 3]]), (2, vec![[1.0; 3]]), (0, vec![[1.0; 3]; MAX_UPDATE + 1])] {
        assert!(film.add_range(start, &values, &CancelToken::default(), &mut |_| Ok(())).is_err());
        assert!(film.pixels.iter().all(|p| *p == Pixel::default()));
    }
    assert!(film.pixel_statistics(2).is_err());
}

#[test]
fn incremental_partitions_preserve_bitwise_results_in_sample_order() {
    let mut whole = film(4, 1, 3);
    let mut partitioned = film(4, 1, 3);
    for values in [
        [[1.0; 3], [1e12; 3], [0.25; 3], [4.0; 3]],
        [[2.0; 3], [1e12 + 1.0; 3], [0.5; 3], [2.0; 3]],
        [[4.0; 3], [1e12 - 1.0; 3], [0.75; 3], [0.0; 3]],
    ] {
        add(&mut whole, 0, &values);
        add(&mut partitioned, 0, &values[..1]);
        add(&mut partitioned, 1, &values[1..3]);
        add(&mut partitioned, 3, &values[3..]);
    }
    assert_eq!(whole.pixels, partitioned.pixels);
    assert_eq!(whole.pixel_statistics(1).unwrap().variance, [1.0; 3]);
}

#[test]
fn cancellation_and_work_failure_preserve_all_pixels() {
    let mut film = film(2, 1, 3);
    let cancel = CancelToken::default();
    let observer = cancel.clone();
    assert_eq!(
        film.add_range(0, &[[1.0; 3]; 2], &cancel, &mut |_| {
            observer.cancel();
            Ok(())
        })
        .unwrap_err()
        .code,
        ErrorCode::Cancelled
    );
    assert!(film.pixels.iter().all(|p| *p == Pixel::default()));
    let mut charged = 0;
    assert_eq!(
        film.add_range(0, &[[1.0; 3]; 2], &CancelToken::default(), &mut |units| {
            charged += units;
            if charged > 2 { Err(limit("job work exhausted")) } else { Ok(()) }
        })
        .unwrap_err()
        .code,
        ErrorCode::LimitExceeded
    );
    assert_eq!(charged, 4);
    assert!(film.pixels.iter().all(|p| *p == Pixel::default()));
}

#[test]
fn construction_and_complete_pass_share_caller_work_and_cancel() {
    let bytes = FilmAccumulator::required_bytes(2, 1, 1).unwrap();
    let cancel = CancelToken::default();
    cancel.cancel();
    assert!(FilmAccumulator::new(2, 1, 1, bytes, &cancel, &mut |_| panic!("cancelled construction charged work")).is_err());
    let mut charged = 0;
    let mut film = FilmAccumulator::new(2, 1, 1, bytes, &CancelToken::default(), &mut |n| {
        charged += n;
        Ok(())
    })
    .unwrap();
    assert_eq!(charged, 2);
    add(&mut film, 0, &[[1.0; 3]; 2]);
    assert!(film.complete_pass(&CancelToken::default(), &mut |_| Err(limit("job exhausted"))).is_err());
    let pass = film
        .complete_pass(&CancelToken::default(), &mut |n| {
            charged += n;
            Ok(())
        })
        .unwrap();
    assert_eq!(charged, 4);
    assert_eq!(pass.samples_per_pixel(), 1);
}

#[test]
fn sample_counts_reach_4096_and_the_declared_cap_without_truncation() {
    for samples in [4096, MAX_SAMPLES] {
        let mut film = film(1, 1, samples);
        let cancel = CancelToken::default();
        let mut charged = 0u64;
        for _ in 0..samples {
            film.add_range(0, &[[7.0, 3.0, 1.0]], &cancel, &mut |n| {
                charged += n;
                Ok(())
            })
            .unwrap();
        }
        assert_eq!(charged, u64::from(samples) * 2);
        let expected = PixelStatistics { mean: [7.0, 3.0, 1.0], variance: [0.0; 3], count: samples };
        assert_eq!(film.pixel_statistics(0).unwrap(), expected);
        assert_eq!(film.complete_pass(&cancel, &mut |_| Ok(())).unwrap().samples_per_pixel(), samples);
        assert_eq!(film.add_range(0, &[[1.0; 3]], &cancel, &mut |_| Ok(())).unwrap_err().code, ErrorCode::LimitExceeded);
        assert_eq!(film.pixel_statistics(0).unwrap(), expected);
    }
}

#[test]
fn construction_stops_on_exhausted_caller_work() {
    let bytes = FilmAccumulator::required_bytes(4, 1, 1).unwrap();
    let mut charged = 0u64;
    let result = FilmAccumulator::new(4, 1, 1, bytes, &CancelToken::default(), &mut |n| {
        charged += n;
        if charged > 2 { Err(limit("existing job budget exhausted")) } else { Ok(()) }
    });
    assert!(matches!(result, Err(JobError { code: ErrorCode::LimitExceeded, .. })));
    assert_eq!(charged, 3);
}

#[cfg(feature = "raytrace-cpu")]
#[test]
fn primary_film_large_profile_keeps_every_sample_and_cancels_before_mutation() {
    use crate::film::primary::PrimaryFilm;
    use crate::job::{CancelToken, CpuBudget, CpuProgressiveOptions};
    let options = CpuProgressiveOptions { samples_per_pixel: 512, seed: 7 };
    assert!(PrimaryFilm::required_bytes(1, 1, options, CpuBudget::Compact).is_err());
    let bytes = PrimaryFilm::required_bytes(1, 1, options, CpuBudget::Studio).unwrap();
    let cancel = CancelToken::default();
    let mut film = PrimaryFilm::new(1, 1, options, bytes, &cancel, CpuBudget::Studio).unwrap();
    film.initialize_one(&cancel, &mut || Ok(())).unwrap();
    for ordinal in 0..512 {
        film.add(0, ordinal, [1e12, 2.0, 0.0], true, &cancel, &mut || Ok(())).unwrap();
    }
    assert_eq!(film.pixel(0).unwrap(), ([1e12, 2.0, 0.0], 512, 512));
    cancel.cancel();
    assert!(film.add(0, 512, [0.0; 3], true, &cancel, &mut || Ok(())).is_err());
    assert_eq!(film.samples(), 512);
}

mod cpu_adaptive_foundation {
    use super::adaptive::{AdaptiveCameraFilm, SamplingIdentity};
    use super::*;
    use crate::job::{
        CpuBudget, CpuProgressiveOptions,
        adaptive::{AdaptiveSampling, PreviewStage},
    };

    fn options() -> AdaptiveSampling {
        AdaptiveSampling { pilot_samples: 16, min_samples: 16, relative_error: 0.0, absolute_error: 0.1, coverage_error: 0.25 }
    }
    fn film(maximum: u32) -> AdaptiveCameraFilm {
        let production = CpuProgressiveOptions { samples_per_pixel: maximum, seed: 81 };
        let bytes = AdaptiveCameraFilm::required_bytes(2, 1, production, options(), CpuBudget::Compact).unwrap();
        AdaptiveCameraFilm::new(2, 1, production, options(), CpuBudget::Compact, bytes, &CancelToken::default()).unwrap()
    }
    fn source(index: usize, key: SamplingIdentity) -> ([f64; 3], bool) {
        match (key.stage, index) {
            (PreviewStage::Pilot, 0) => ([0.25, 0.5, 0.75], true),
            (PreviewStage::Pilot, _) => {
                if key.ordinal % 2 == 1 {
                    ([1.0, 0.0, 0.0], true)
                } else {
                    ([0.0; 3], false)
                }
            }
            (PreviewStage::Production, 0) => ([3.0, 1.0, 2.0], true),
            (PreviewStage::Production, _) => {
                if key.ordinal % 6 != 5 {
                    ([6.0, 0.0, 0.0], true)
                } else {
                    ([0.0; 3], false)
                }
            }
        }
    }
    fn step(film: &mut AdaptiveCameraFilm, work: &mut u64) {
        let cancel = CancelToken::default();
        let mut charge = || {
            *work += 1;
            Ok(())
        };
        if !film.ready() {
            film.initialize_one(&cancel, &mut charge).unwrap();
        } else if film.resetting() {
            film.reset_one(&cancel, &mut charge).unwrap();
        } else if film.complete_pass().is_ok_and(|pass| pass.metadata().stage == PreviewStage::Pilot && pass.metadata().completed == 16) {
            film.begin_production(&cancel, &mut charge).unwrap();
        } else {
            let index = film.next_pixel();
            if let Some(identity) = film.sampling_identity(index).unwrap() {
                let (rgb, covered) = source(index, identity);
                film.add(index, identity, rgb, covered, &cancel, &mut charge).unwrap();
            } else {
                film.skip_one(index, &cancel, &mut charge).unwrap();
            }
        }
    }
    type Snapshot = (PreviewStage, u32, Vec<([f64; 3], f64, u16, u16)>);
    fn snapshot(film: &AdaptiveCameraFilm) -> Option<Snapshot> {
        let pass = film.complete_pass().ok()?;
        let metadata = pass.metadata();
        let pixels = (0..pass.counts().len())
            .map(|index| {
                let (mean, alpha) = pass.pixel(index).unwrap();
                let count = pass.counts().pixel(index).unwrap();
                (mean, alpha, count.covered(), count.samples())
            })
            .collect();
        Some((metadata.stage, metadata.completed, pixels))
    }
    fn complete(maximum: u32, quantum: usize) -> (Vec<Snapshot>, crate::job::adaptive::SamplingReport, u64) {
        let mut film = film(maximum);
        let mut work = 0;
        let mut snapshots = Vec::new();
        for _ in 0..10_000 {
            for _ in 0..quantum {
                if film.is_final() {
                    break;
                }
                step(&mut film, &mut work);
                if let Some(next) = snapshot(&film)
                    && snapshots.last() != Some(&next)
                {
                    snapshots.push(next);
                }
            }
            if film.is_final() {
                return (snapshots, film.report().unwrap(), work);
            }
        }
        panic!("bounded adaptive foundation did not complete");
    }
    #[test]
    fn cpu_adaptive_film_independent_variance_allocation_discards_pilots_and_normalizes_heterogeneous_production() {
        let mut film = film(48);
        let mut work = 0;
        while film.completed_passes() < 16 {
            step(&mut film, &mut work);
        }
        let pilot = snapshot(&film).unwrap();
        assert_eq!(pilot.2[0], ([0.25, 0.5, 0.75], 1.0, 16, 16));
        assert_eq!(pilot.2[1], ([0.5, 0.0, 0.0], 0.5, 8, 16));
        assert_eq!(film.production_target(0).unwrap(), 16);
        // Eight0/eight1 pilots have M2=4, sample variance4/15. With
        // absolute RGB error0.1, ceil((4/15)/0.01)=27; alpha uses0.25.
        assert_eq!(film.production_target(1).unwrap(), 27);
        while !film.is_final() {
            step(&mut film, &mut work);
        }
        let final_pass = film.complete_pass().unwrap();
        assert_eq!(final_pass.pixel(0).unwrap(), ([3.0, 1.0, 2.0], 1.0), "pilot radiance is discarded rather than stopped into production");
        assert_eq!((final_pass.counts().pixel(0).unwrap().samples(), final_pass.counts().pixel(1).unwrap().samples()), (16, 27));
        let (mean, alpha) = final_pass.pixel(1).unwrap();
        assert_eq!(mean, [138.0 / 27.0, 0.0, 0.0]);
        assert_eq!(alpha, 23.0 / 27.0);
        let report = film.report().unwrap();
        assert_eq!((report.pilot_samples_per_pixel, report.minimum_production_samples, report.maximum_production_samples), (16, 16, 27));
        assert_eq!((report.production_samples, report.primary_path_evaluations, report.pixels_at_cap, report.transmission_strata), (43, 75, 0, 1));
        assert_eq!(work, 133, "init/reset and each sampled/skipped pixel own one exact work unit");
    }
    #[test]
    fn cpu_adaptive_counts_keep_five_of_six_alpha_exact_without_quantizing_raw_radiance() {
        let mut film = film(48);
        let mut work = 0;
        loop {
            if let Some((PreviewStage::Production, 6, _)) = snapshot(&film) {
                break;
            }
            step(&mut film, &mut work);
        }
        let pass = film.complete_pass().unwrap();
        let count = pass.counts().pixel(1).unwrap();
        assert_eq!((count.covered(), count.samples(), count.alpha8().unwrap()), (5, 6, 213));
        let (raw, alpha) = pass.pixel(1).unwrap();
        assert_eq!(raw, [5.0, 0.0, 0.0]);
        assert_eq!(alpha, 5.0 / 6.0);
        assert_eq!(alpha as f32, 5.0f32 / 6.0);
        assert_ne!(alpha as f32, 213.0f32 / 255.0, "PNG byte rounding cannot alter the raw FLOAT32 alpha");
    }
    #[test]
    fn cpu_adaptive_all_complete_passes_and_production_prefixes_are_quantum_and_cap_independent() {
        let (snapshots, report, work) = complete(48, 1);
        assert_eq!((snapshots.clone(), report.clone(), work), complete(48, 16384));
        assert_eq!(snapshots.len(), 64);
        assert_eq!(snapshots.iter().filter(|s| s.0 == PreviewStage::Pilot).count(), 16);
        assert_eq!(snapshots.last().unwrap().1, 48);
        for maximum in 16..=48 {
            let (prefix, _, _) = complete(maximum, 7);
            assert_eq!(&prefix[..16], &snapshots[..16], "the production cap never enters the pilot stream");
            assert_eq!(prefix.last().unwrap(), snapshots.iter().find(|s| s.0 == PreviewStage::Production && s.1 == maximum).unwrap());
        }
    }
    #[test]
    fn cpu_adaptive_sample_identities_separate_pilots_and_preserve_original_production_ordinals() {
        let mut film = film(48);
        let mut work = 0;
        while !film.ready() {
            step(&mut film, &mut work);
        }
        let pilot = film.sampling_identity(0).unwrap().unwrap();
        assert_eq!((pilot.seed, pilot.ordinal, pilot.stage), (81 ^ 0xa511_e9b3, 0, PreviewStage::Pilot));
        while film.complete_pass().is_err() || film.complete_pass().unwrap().metadata().stage == PreviewStage::Pilot {
            step(&mut film, &mut work);
        }
        // A complete first production pass has consumed ordinal0, so the next
        // active pixel receives original seed81 and absolute production ordinal1.
        let production = film.sampling_identity(0).unwrap().unwrap();
        assert_eq!((production.seed, production.ordinal, production.stage), (81, 1, PreviewStage::Production));
        assert_ne!(pilot.seed, production.seed);
        while film.completed_passes() < 32 {
            step(&mut film, &mut work);
        }
        assert!(film.sampling_identity(0).unwrap().is_none(), "a stopped pixel requests bookkeeping rather than another sample");
        assert!(film.complete_pass().unwrap().pixel(2).is_err());
    }
    #[test]
    fn cpu_adaptive_pilots_plus_production_obey_every_unchanged_profile_and_camera_work_cap() {
        for budget in CpuBudget::ALL {
            let maximum = budget.limits().max_samples_per_pixel;
            let make = |production| CpuProgressiveOptions { samples_per_pixel: production, seed: 0 };
            assert!(AdaptiveCameraFilm::required_bytes(1, 1, make(maximum - 16), options(), budget).is_ok());
            assert!(AdaptiveCameraFilm::required_bytes(1, 1, make(maximum - 15), options(), budget).is_err());
            assert!(AdaptiveCameraFilm::required_bytes(1, 1, make(maximum), options(), budget).is_err());
        }
        let production = CpuProgressiveOptions { samples_per_pixel: 16, seed: 0 };
        assert!(AdaptiveCameraFilm::required_bytes(1024, 512, production, options(), CpuBudget::Compact).is_ok());
        assert!(
            AdaptiveCameraFilm::required_bytes(1024, 513, production, options(), CpuBudget::Compact).is_err(),
            "pilot camera paths are included in the same total sample budget"
        );
        let one = AdaptiveCameraFilm::required_bytes(1, 1, production, options(), CpuBudget::Compact).unwrap();
        let two = AdaptiveCameraFilm::required_bytes(2, 1, production, options(), CpuBudget::Compact).unwrap();
        assert_eq!(two - one, 70, "64-byte moments plus6-byte exact count/allocation plane, with no snapshot plane");
        assert!(AdaptiveCameraFilm::new(1, 1, production, options(), CpuBudget::Compact, one - 1, &CancelToken::default()).is_err());
        assert!(AdaptiveCameraFilm::required_bytes(0, 1, production, options(), CpuBudget::Compact).is_err());
        assert!(
            AdaptiveCameraFilm::required_bytes(1, 1, production, AdaptiveSampling { pilot_samples: 15, ..options() }, CpuBudget::Compact).is_err()
        );
        assert!(
            AdaptiveCameraFilm::required_bytes(1, 1, production, AdaptiveSampling { relative_error: f64::NAN, ..options() }, CpuBudget::Compact)
                .is_err()
        );
    }
    #[test]
    fn cpu_adaptive_add_reset_skip_and_initialization_are_atomic_under_cancel_or_work_failure() {
        for operation in ["initialize", "pilot", "reset", "production", "skip"] {
            for cancelled in [false, true] {
                let mut film = film(48);
                let mut work = 0;
                if operation != "initialize" {
                    while !film.ready() {
                        step(&mut film, &mut work);
                    }
                }
                if matches!(operation, "reset" | "production" | "skip") {
                    while film.completed_passes() < 16 {
                        step(&mut film, &mut work);
                    }
                    film.begin_production(&CancelToken::default(), &mut || Ok(())).unwrap();
                }
                if matches!(operation, "production" | "skip") {
                    while film.resetting() {
                        step(&mut film, &mut work);
                    }
                }
                if operation == "skip" {
                    while film.completed_passes() < 32 {
                        step(&mut film, &mut work);
                    }
                }
                let before = (
                    film.initialized(),
                    film.ready(),
                    film.next_pixel(),
                    film.completed_passes(),
                    snapshot(&film),
                    film.sampling_identity(film.next_pixel()).ok(),
                );
                let cancel = CancelToken::default();
                let token = cancel.clone();
                let mut charge = || {
                    if cancelled {
                        token.cancel();
                        Ok(())
                    } else {
                        Err(JobError::new(ErrorCode::LimitExceeded, "test cumulative work exhausted"))
                    }
                };
                let result = match operation {
                    "initialize" => film.initialize_one(&cancel, &mut charge),
                    "reset" => film.reset_one(&cancel, &mut charge),
                    "skip" => film.skip_one(0, &cancel, &mut charge),
                    _ => {
                        let key = film.sampling_identity(0).unwrap().unwrap();
                        let (rgb, covered) = source(0, key);
                        film.add(0, key, rgb, covered, &cancel, &mut charge)
                    }
                };
                assert_eq!(result.unwrap_err().code, if cancelled { ErrorCode::Cancelled } else { ErrorCode::LimitExceeded }, "{operation}");
                assert_eq!(
                    (
                        film.initialized(),
                        film.ready(),
                        film.next_pixel(),
                        film.completed_passes(),
                        snapshot(&film),
                        film.sampling_identity(film.next_pixel()).ok()
                    ),
                    before,
                    "{operation} may not partially consume its cursor/count/stream"
                );
                assert!(film.report().is_err());
            }
        }
    }
    #[test]
    fn cpu_adaptive_integration_requires_explicit_progressive_intent_and_preserves_strict_input() {
        assert!(serde_json::to_value(crate::job::RaytraceOptions::default()).unwrap().get("adaptive").is_none());
        let invalid: crate::job::RaytraceOptions = serde_json::from_value(serde_json::json!({"adaptive":options()})).unwrap();
        assert!(invalid.validate().is_err(), "adaptive cannot silently introduce a camera film into a fixed saved setup");
        assert!(serde_json::from_value::<crate::job::RaytraceOptions>(serde_json::json!({"adaptive":{"noise_guarantee":true}})).is_err());
        let mut film = film(48);
        let mut work = 0;
        while !film.ready() {
            step(&mut film, &mut work);
        }
        assert!(film.complete_pass().is_err());
        assert!(film.begin_production(&CancelToken::default(), &mut || Ok(())).is_err());
        let key = film.sampling_identity(0).unwrap().unwrap();
        for (rgb, covered) in [([f64::NAN, 0.0, 0.0], true), ([f64::INFINITY, 0.0, 0.0], true), ([1.0, 0.0, 0.0], false)] {
            assert!(film.add(0, key, rgb, covered, &CancelToken::default(), &mut || panic!("invalid input must not debit or mutate work")).is_err());
            assert_eq!(film.sampling_identity(0).unwrap().unwrap(), key);
        }
        assert!(film.add(1, key, [0.0; 3], false, &CancelToken::default(), &mut || Ok(())).is_err());
        assert!(film.skip_one(0, &CancelToken::default(), &mut || Ok(())).is_err());
    }
}