From 6194a157d724fb223a7aa39197d992280a0216f7 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Wed, 28 Oct 2026 06:09:21 +0000 Subject: [PATCH] Refactor automation tests for strict Clippy checks --- crates/automation/tests/qa/compositing.rs | 51 +++++++++++++++++------ 1 file changed, 39 insertions(+), 12 deletions(-) diff --git a/crates/automation/tests/qa/compositing.rs b/crates/automation/tests/qa/compositing.rs index 52d5e4fb2..da78ae116 100644 --- a/crates/automation/tests/qa/compositing.rs +++ b/crates/automation/tests/qa/compositing.rs @@ -7,6 +7,10 @@ use serde_json::{Value, json}; use crate::harness::{Img, Qa, coverage, luma, mean_diff}; +fn lum(i: &Img, x: u32, y: u32) -> f64 { + luma(i.get_pixel(x, y)) +} + fn px(img: &Img, x: u32, y: u32) -> [u8; 4] { img.get_pixel(x, y).0 } @@ -25,13 +29,12 @@ fn write_sequence(qa: &Qa) -> String { qa.path("seq/ball_000.png") } -#[test] -fn compositing_matte_blend_adjustment_3d_and_alpha_renders() { - let mut qa = Qa::new("compositing"); - +/// Import the sequence (reinterpreted at 12 fps) and a PSD written by the app; returns the +/// sequence item and the PSD's composition. +fn import_footage(qa: &mut Qa) -> (Value, Value) { // Footage: the sequence, and a layered PSD written by the app itself (Save Frame As ▸ // Photoshop Layers) from a small comp. - let seq = write_sequence(&qa); + let seq = write_sequence(qa); let imp = qa.exec("file.import", json!({"paths": [seq]})); let seq_item = imp["items"][0].clone(); let project = qa.tool("get_project", json!({})); @@ -55,10 +58,14 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() { let pc = qa.tool("get_comp", json!({"comp": psd_comp.clone()})); let names: Vec<&str> = pc["layers"].as_array().unwrap().iter().map(|l| l["name"].as_str().unwrap()).collect(); assert_eq!(names, ["Bar", "Gray"], "the PSD's layers, top first: {pc}"); + (seq_item, psd_comp) +} +/// The main comp: the sequence plays, then a Screen-blended PSD; returns the Normal-mode frame. +fn main_comp_and_blend(qa: &mut Qa, seq_item: &Value, psd_comp: &Value) -> Img { // The main comp. - let main = qa.exec("comp.new", json!({"name": "Main", "width": 160, "height": 90, "frameRate": 12, "duration": 1}))["comp"].clone(); - qa.exec("layer.addItem", json!({"item": seq_item})); + qa.exec("comp.new", json!({"name": "Main", "width": 160, "height": 90, "frameRate": 12, "duration": 1})); + qa.exec("layer.addItem", json!({"item": seq_item.clone()})); let a = qa.frame(None, 0.0); let b = qa.frame(None, 0.5); assert!(mean_diff(&a, &b) > 1.0, "the sequence plays"); @@ -75,7 +82,10 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() { for c in 0..3 { assert!(s[c] > n[c] && s[c] > [32, 64, 96][c], "Screen brightens channel {c}: {s:?}"); } + normal +} +fn track_matte(qa: &mut Qa) { // Track matte: a magenta solid seen only through text. qa.exec("layer.newText", json!({"text": "MATTE", "name": "Matte", "size": 40, "fill": "#ffffff"})); qa.exec("layer.newSolid", json!({"name": "Fill", "color": "#ff00ff", "width": 160, "height": 90})); @@ -91,7 +101,9 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() { let fill = info["layers"].as_array().unwrap().iter().find(|l| l["name"] == "Fill").unwrap().clone(); assert_eq!(fill["trackMatte"]["kind"], "Alpha Matte"); qa.exec("layer.setSwitch", json!({"layers": ["Fill", "Matte"], "switch": "video", "value": false})); +} +fn adjustment_layer(qa: &mut Qa, normal: &Img) { // Adjustment layer: Lumetri exposure, inside a feathered, expanded elliptical mask; then Glow. qa.exec("layer.newAdjustment", json!({"name": "Grade"})); let fx = qa.exec("effect.apply", json!({"effect": "Lumetri Color", "layers": ["Grade"]})); @@ -103,7 +115,6 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() { let mk = qa.exec("layer.addMask", json!({"layer": "Grade", "shape": "ellipse", "rect": [40, 20, 80, 50]})); assert!(mk["mask"].is_u64(), "{mk}"); let hard = qa.frame(None, 0.5); - let lum = |i: &Img, x, y| luma(i.get_pixel(x, y)); assert!(lum(&hard, 80, 45) > lum(&before, 80, 45) - 1.0 && lum(&hard, 5, 5) < lum(&before, 5, 5) - 10.0, "the mask limits the grade to the ellipse"); qa.exec("layer.mask.set", json!({"layer": "Grade", "field": "expansion", "value": 8})); let grown = qa.frame(None, 0.5); @@ -116,7 +127,7 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() { } n }; - assert!(bright(&grown, &normal) > bright(&hard, &normal) + 100, "expansion grows the graded area"); + assert!(bright(&grown, normal) > bright(&hard, normal) + 100, "expansion grows the graded area"); qa.exec("layer.mask.set", json!({"layer": "Grade", "field": "feather", "value": 20})); let soft = qa.frame(None, 0.5); // At the ellipse's edge (x = 40 − 8): feathered is in between none and full. @@ -125,7 +136,10 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() { qa.exec("effect.apply", json!({"effect": "Glow", "layers": ["Grade"]})); let glow = qa.frame(None, 0.5); assert!(mean_diff(&soft, &glow) > 0.5, "Glow changes the frame"); +} +/// The 3D stage with depth of field and a light; returns the stage comp. +fn stage_3d(qa: &mut Qa) -> Value { // 3D stage: a near and a far card, a camera with depth of field, a light. let stage = qa.exec("comp.new", json!({"name": "Stage", "width": 160, "height": 90, "frameRate": 12, "duration": 1}))["comp"].clone(); qa.exec("layer.newSolid", json!({"name": "Near", "color": "#ff4040", "width": 40, "height": 40})); @@ -155,7 +169,10 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() { let advanced = qa.frame(None, 0.0); assert!(mean_diff(&classic, &advanced) > 0.2, "Advanced 3D renders the stage its own way"); assert!(lum(&advanced, 50, 45) > 60.0, "Advanced 3D still lights the card"); + stage +} +fn alpha_renders(qa: &mut Qa, stage: &Value) { // Renders with alpha: the stage has no background layer, so most of it is transparent. let mov = qa.path("stage.mov"); let webm = qa.path("stage.webm"); @@ -165,7 +182,7 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() { assert!(done["items"].as_array().unwrap().iter().all(|i| i["status"] == "Done"), "{done}"); let reference = qa.tool("render_frame", json!({"comp": stage.clone(), "time": 0, "transparent": true, "inline": false})); assert_eq!(reference["width"], 160); - let refa = alpha_frame(&mut qa, stage.clone()); + let refa = alpha_frame(qa, stage.clone()); assert!(px(&refa, 2, 2)[3] < 40 && px(&refa, 50, 45)[3] == 255, "render_frame transparent keeps alpha: {:?} {:?}", px(&refa, 2, 2), px(&refa, 50, 45)); // ProRes 4444 carries alpha in the frame; WebM VP9 as a second VP9 stream in BlockAdditions // (AlphaMode 1), which FilmCraft's Matroska reader decodes into the frame's alpha plane. @@ -174,14 +191,24 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() { assert_eq!(r["errors"], json!([])); assert_eq!(r["unlabeledAlpha"], r["items"], "{path}: the importer sees an alpha channel"); let c = qa.exec("file.newCompFromSelection", json!({}))["comps"][0].clone(); - let f = alpha_frame(&mut qa, c.clone()); + let f = alpha_frame(qa, c.clone()); // The opaque card decodes to the stage's colours (lossy codecs, so loosely). let (got, want) = (px(&f, 50, 45), px(&refa, 50, 45)); assert!((0..3).all(|c| got[c].abs_diff(want[c]) < 12), "{path} decodes to the stage: {got:?} vs {want:?}"); assert!(mean_diff(&qa.frame(Some(c.clone()), 0.0), &qa.frame(Some(stage.clone()), 0.0)) < 8.0, "{path} composites like the stage"); assert!(px(&f, 2, 2)[3] < 40 && px(&f, 50, 45)[3] > 250, "{path}: transparent corners, opaque card: {:?} {:?}", px(&f, 2, 2), px(&f, 50, 45)); } - let _ = main; +} + +#[test] +fn compositing_matte_blend_adjustment_3d_and_alpha_renders() { + let mut qa = Qa::new("compositing"); + let (seq_item, psd_comp) = import_footage(&mut qa); + let normal = main_comp_and_blend(&mut qa, &seq_item, &psd_comp); + track_matte(&mut qa); + adjustment_layer(&mut qa, &normal); + let stage = stage_3d(&mut qa); + alpha_renders(&mut qa, &stage); } fn alpha_frame(qa: &mut Qa, comp: Value) -> Img {