Files
photocraft/crates/psd/tests/it/corpus.rs
T

130 lines
5.9 KiB
Rust

//! Corpus test (feature `corpus`; run with `cargo xtask test-corpus`): iterates
//! `corpus/psd/**/*.{psd,psb}` and `corpus/psd-tools/**/*.{psd,psb}` at the workspace root
//! (gitignored, fetched and verified by `cargo xtask corpus --all`). A missing corpus fails.
#![cfg(feature = "corpus")]
use std::path::{Path, PathBuf};
use photocraft_psd::PsdFile;
fn collect(dir: &Path, out: &mut Vec<PathBuf>) {
let Ok(rd) = std::fs::read_dir(dir) else { return };
for e in rd.flatten() {
let p = e.path();
if p.is_dir() {
collect(&p, out);
} else if p.extension().and_then(|e| e.to_str()).is_some_and(|e| e.eq_ignore_ascii_case("psd") || e.eq_ignore_ascii_case("psb")) {
out.push(p);
}
}
}
/// The existing pinned ag-psd corpus includes public animation cases. Exercise typed syntax
/// against those without adding personal files or new corpus pins.
#[test]
fn corpus_animation_syntax() {
use photocraft_psd::ResourceData;
use photocraft_psd::animation::{frame_info, frame_sets, layer_frame_states};
use photocraft_psd::metadata::parse_shmd;
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../corpus/psd/ag-psd/read-write");
for (case, delay) in [("animation-frame", Some(30)), ("animation-offset", Some(50)), ("animation-effects", None)] {
for name in ["src.psd", "expected.psd"] {
let path = root.join(case).join(name);
let bytes = std::fs::read(&path).unwrap_or_else(|e| panic!("{}: {e}; run cargo xtask corpus --psd", path.display()));
let psd = PsdFile::from_bytes(&bytes).unwrap();
let mut found = 0;
let mut decoded_descriptors = 0;
for resource in &psd.resources {
if let Some(Ok(ResourceData::Animation(animation))) = resource.parsed() {
found += 1;
assert_eq!(animation.to_bytes().unwrap(), resource.data);
for record in &animation.records {
if let Some(d) = record.descriptor() {
let d = d.unwrap();
decoded_descriptors += 1;
let frames = frame_info(&d.descriptor).unwrap();
assert_eq!(frames.len(), 2, "{case}/{name}");
assert!(frames.iter().all(|f| f.delay_centiseconds == delay), "{case}/{name}");
let sets = frame_sets(&d.descriptor).unwrap();
assert_eq!(sets.len(), 1);
assert_eq!(sets[0].frame_ids.len(), 2);
assert!(sets[0].frame_ids.iter().all(|id| frames.iter().any(|f| f.id == *id)));
}
}
}
}
assert_eq!(found, 1, "{case}/{name}");
assert_eq!(decoded_descriptors, 1, "expected one decoded AnDs descriptor in {case}/{name}");
let mut state_layers = 0;
for layer in psd.layers() {
for block in &layer.blocks {
if block.key == *b"shmd" {
for item in parse_shmd(&block.data).unwrap() {
if item.key == *b"mlst" {
let d = item.animation_descriptor().unwrap().unwrap();
let states = layer_frame_states(&d.descriptor).unwrap();
assert!(!states.states.is_empty());
state_layers += 1;
}
}
}
}
}
assert_eq!(state_layers, 2, "{case}/{name}");
assert_eq!(psd.to_bytes().unwrap(), bytes);
}
}
}
/// Files known to be invalid upstream, with the reason. They are reported but
/// do not fail the test.
const KNOWN_BAD: &[(&str, &str)] =
&[("group-divider-blend-mode.psd", "malformed merged image data; strict parsing rejects it, but the importer recovers its group (#6152)")];
#[test]
fn corpus_parse_and_byte_stable() {
for dir in ["corpus/psd", "corpus/psd-tools"] {
parse_and_byte_stable(&Path::new(env!("CARGO_MANIFEST_DIR")).join("../..").join(dir));
}
}
fn parse_and_byte_stable(root: &Path) {
assert!(root.is_dir(), "{} is missing: run `cargo xtask corpus --all`", root.display());
let mut files = Vec::new();
collect(root, &mut files);
files.sort();
let mut failures = Vec::new();
for p in &files {
let name = p.strip_prefix(root).unwrap_or(p).display().to_string();
let bytes = match std::fs::read(p) {
Ok(b) => b,
Err(e) => {
failures.push(format!("{name}: read error {e}"));
continue;
}
};
match PsdFile::from_bytes(&bytes) {
Err(e) => {
if let Some((_, why)) = KNOWN_BAD.iter().find(|(f, _)| name.ends_with(f)) {
eprintln!("KNOWN {name}: parse error: {e} ({why})");
} else {
eprintln!("FAIL {name}: parse error: {e}");
failures.push(format!("{name}: parse: {e}"));
}
}
Ok(f) => match f.to_bytes() {
Ok(out) if out == bytes => eprintln!("ok {name} ({} layers)", f.layers().len()),
Ok(out) => {
let first = out.iter().zip(&bytes).position(|(a, b)| a != b).unwrap_or(out.len().min(bytes.len()));
eprintln!("DIFF {name}: first difference at {first} (len {} vs {})", out.len(), bytes.len());
failures.push(format!("{name}: not byte stable (first diff at {first})"));
}
Err(e) => failures.push(format!("{name}: write: {e}")),
},
}
}
eprintln!("corpus {}: {} files, {} failures", root.display(), files.len(), failures.len());
assert!(failures.is_empty(), "corpus failures:\n{}", failures.join("\n"));
}