Skip to content

ProCraft for Android: An Android native painting app written in Rust

Rust

test(files): every reader survives damaged files

Josh6d54d38e38c1
diff --git a/crates/engine/src/abr.rs b/crates/engine/src/abr.rs
index 460d804..a37ca48 100644
--- a/crates/engine/src/abr.rs
+++ b/crates/engine/src/abr.rs
@@ -319,6 +319,15 @@ mod tests {
}
}
+ #[test]
+ fn a_damaged_file_is_refused_not_a_crash() {
+ let good = version6();
+ assert!(read(&good).is_some());
+ crate::damaged::survives("ABR", &good, |b| {
+ let _ = read(b);
+ });
+ }
+
/// A version 6 file with one 3 x 2 tip (raw) named by its preset.
fn version6() -> Vec<u8> {
let id = "tip-one";
diff --git a/crates/engine/src/damaged.rs b/crates/engine/src/damaged.rs
new file mode 100644
index 0000000..5b350a7
--- /dev/null
+++ b/crates/engine/src/damaged.rs
@@ -0,0 +1,252 @@
+//! Damaged files: each reader, given a good file cut short or with bytes changed, says it can't
+//! read it (or reads what it can) and never panics.
+
+use std::collections::HashMap;
+use std::panic::{AssertUnwindSafe, catch_unwind};
+
+use crate::brush::Brush;
+use crate::brushfile::{self, Pictures};
+use crate::document::{BlendMode, Document};
+use crate::formats::{self, PsdKind, PsdLayer};
+use crate::native::{self, Export, TimeLapse};
+use crate::profile::Profile;
+
+/// Gives `read` the file `good` cut short at many lengths and with bytes changed at many places;
+/// fails, naming the cases, if any of them panicked.
+pub(crate) fn survives(name: &str, good: &[u8], read: impl Fn(&[u8])) {
+ let n = good.len();
+ assert!(n > 0, "{name}: no sample");
+ let mut cases: Vec<(String, Vec<u8>)> = Vec::new();
+ // cut short: every length near the start and the end, and others spread between
+ let mut lengths: Vec<usize> =
+ (0..n.min(64)).chain(n.saturating_sub(64)..n).chain((0..256).map(|i| i * n / 256)).collect();
+ lengths.sort_unstable();
+ lengths.dedup();
+ for len in lengths {
+ cases.push((format!("cut to {len} bytes"), good[..len].to_vec()));
+ }
+ // a byte changed: each of the first ones (headers), then places spread over the file
+ let mut seed = 0x2545_F491_4F6C_DD1D_u64;
+ let mut next = move || {
+ seed ^= seed << 13;
+ seed ^= seed >> 7;
+ seed ^= seed << 17;
+ seed
+ };
+ for i in 0..512usize {
+ let at = if i < 64 { i % n } else { (next() % n as u64) as usize };
+ let mut bad = good.to_vec();
+ bad[at] ^= match i % 4 {
+ 0 => 0xFF,
+ 1 => 0x80,
+ 2 => 0x01,
+ _ => (next() as u8) | 1,
+ };
+ cases.push((format!("byte {at} changed"), bad));
+ }
+ // several at once
+ for i in 0..64 {
+ let mut bad = good.to_vec();
+ for _ in 0..8 {
+ let at = (next() % n as u64) as usize;
+ bad[at] = next() as u8;
+ }
+ cases.push((format!("eight bytes changed ({i})"), bad));
+ }
+ let failed: Vec<&str> = cases
+ .iter()
+ .filter(|(_, bad)| catch_unwind(AssertUnwindSafe(|| read(bad))).is_err())
+ .map(|c| c.0.as_str())
+ .collect();
+ assert!(failed.is_empty(), "{name}: panicked when {}", failed.join("; "));
+}
+
+/// A small layered artwork with a mask and a time-lapse, as a package.
+fn package() -> Vec<u8> {
+ let (w, h) = (300, 280);
+ let mut doc = Document::new(w, h);
+ let base = doc.current();
+ doc.set_blend(base, BlendMode::Multiply);
+ let top = doc.add_layer();
+ doc.set_clipped(top, true);
+ let mask = doc.add_mask(base).unwrap();
+ let paint = |f: &dyn Fn(u32, u32) -> [u8; 4]| -> Vec<u8> {
+ (0..h).flat_map(|y| (0..w).flat_map(move |x| f(x, y))).collect()
+ };
+ let pixels = HashMap::from([
+ (base, paint(&|x, y| [(x % 256) as u8, (y % 256) as u8, 0, 255])),
+ (top, paint(&|x, y| if (x / 37 + y / 41) % 3 == 0 { [10, 20, 30, 128] } else { [0; 4] })),
+ (mask, paint(&|x, _| if x < 150 { [255; 4] } else { [0, 0, 0, 255] })),
+ ]);
+ let time_lapse =
+ TimeLapse { segments: vec![b"segment one".to_vec()], frame_size: (64, 48), ..TimeLapse::default() };
+ native::write(&Export {
+ document: &doc,
+ pixels: &pixels,
+ composite: &vec![255u8; (w * h * 4) as usize],
+ thumbnail_png: b"preview",
+ name: "Damaged",
+ author: "Someone",
+ strokes: 3,
+ tracked_seconds: 1.5,
+ seed: 9,
+ time_lapse: Some(&time_lapse),
+ })
+}
+
+/// A brush with pictures of its own, as a brush file.
+fn brush_file() -> Vec<u8> {
+ let mut brush = Brush::round_pen();
+ brush.set_setting("spacing", 0.3);
+ brush.set_setting("grain_scale", 0.4);
+ brushfile::write(&brush, "Someone", &pictures())
+}
+
+fn pictures() -> Pictures<'static> {
+ Pictures {
+ shape_png: b"shape picture",
+ grain_png: Some(b"grain picture"),
+ metallic_png: None,
+ roughness_png: None,
+ thumbnail_png: b"preview",
+ author_png: Some(b"author"),
+ signature_png: None,
+ }
+}
+
+#[test]
+fn a_damaged_package_is_refused_not_a_crash() {
+ let good = package();
+ assert!(native::read(&good).is_ok());
+ survives("package", &good, |b| {
+ let _ = native::read(b);
+ });
+ survives("package's time-lapse", &good, |b| {
+ let _ = native::read_time_lapse(b);
+ });
+}
+
+#[test]
+fn a_damaged_brush_or_brush_set_is_refused_not_a_crash() {
+ let good = brush_file();
+ assert!(brushfile::read(&good).is_some());
+ survives("brush", &good, |b| {
+ let _ = brushfile::read(b);
+ });
+ let (one, two) = (Brush::round_pen(), Brush { name: "Second".to_owned(), ..Brush::round_pen() });
+ let set = brushfile::write_set("Set", &[(&one, "", pictures()), (&two, "", pictures())], |i| format!("brush-{i}"));
+ assert_eq!(brushfile::read_set(&set).map(|s| s.1.len()), Some(2));
+ survives("brush set", &set, |b| {
+ let _ = brushfile::read_set(b);
+ });
+}
+
+#[test]
+fn a_damaged_psd_is_refused_not_a_crash() {
+ let (w, h) = (40u32, 30u32);
+ let rgba: Vec<u8> = (0..w * h).flat_map(|i| [(i % 251) as u8, 40, 90, 255]).collect();
+ let grey: Vec<u8> = (0..w * h).map(|i| (i % 256) as u8).collect();
+ let layers = [
+ PsdLayer {
+ name: "Inked",
+ kind: PsdKind::Pixels { rgba: &rgba, mask: Some(&grey) },
+ opacity: 0.8,
+ visible: true,
+ blend: BlendMode::Screen,
+ clipped: false,
+ },
+ PsdLayer {
+ name: "Base",
+ kind: PsdKind::Pixels { rgba: &rgba, mask: None },
+ opacity: 1.0,
+ visible: true,
+ blend: BlendMode::Normal,
+ clipped: false,
+ },
+ ];
+ let good = formats::psd(w, h, 132.0, &crate::icc::icc(Profile::DisplayP3), &layers, &rgba, None);
+ assert!(crate::psd::read(&good).is_ok());
+ survives("PSD", &good, |b| {
+ let _ = crate::psd::read(b);
+ });
+}
+
+#[test]
+fn a_damaged_colour_profile_is_refused_not_a_crash() {
+ for profile in [Profile::Srgb, Profile::DisplayP3] {
+ let good = crate::icc::icc(profile);
+ assert!(crate::cms::IccProfile::parse(&good).is_some());
+ survives("colour profile", &good, |b| {
+ let _ = crate::cms::IccProfile::parse(b);
+ });
+ }
+}
+
+#[test]
+fn damaged_archives_and_tiles_are_refused_not_a_crash() {
+ use crate::plist::Value;
+ let value = Value::Dict(vec![
+ ("name".to_owned(), Value::String("A name".to_owned())),
+ (
+ "list".to_owned(),
+ Value::Array(vec![Value::Int(-3), Value::Real(0.5), Value::Bool(true), Value::Data(vec![1, 2, 3])]),
+ ),
+ ]);
+ let good = crate::plist::write(&value);
+ assert_eq!(crate::plist::read(&good), Some(value));
+ survives("property list", &good, |b| {
+ let _ = crate::plist::read(b);
+ let _ = crate::keyed::Archive::read(b);
+ });
+ let tile: Vec<u8> = (0..256 * 64).map(|i| (i % 7 * 30) as u8).collect();
+ let good = crate::applz4::encode(&tile);
+ assert_eq!(crate::applz4::decode(&good, tile.len()).as_deref(), Some(&tile[..]));
+ survives("tile", &good, |b| {
+ let _ = crate::applz4::decode(b, tile.len());
+ });
+ let good = package();
+ survives("zip", &good, |b| {
+ if let Some(z) = crate::zip::ZipReader::new(b) {
+ let names: Vec<String> = z.names().map(str::to_owned).collect();
+ for n in names {
+ let _ = z.read(&n);
+ }
+ }
+ });
+}
+
+#[test]
+fn damaged_models_and_environments_are_refused_not_a_crash() {
+ let usdz = include_bytes!("../tests/models/cube.usdz");
+ assert!(crate::usd::read_usdz(usdz).is_ok());
+ survives("USDZ", usdz, |b| {
+ let _ = crate::usd::read_usdz(b);
+ });
+ let usdc = include_bytes!("../tests/models/grid.usdc");
+ survives("USD crate file", usdc, |b| {
+ let _ = crate::usd::read_usd(b);
+ });
+ let usda = include_bytes!("../tests/models/cube.usda");
+ survives("USD text", usda, |b| {
+ let _ = crate::usd::read_usda(&String::from_utf8_lossy(b));
+ });
+ let obj = b"mtllib cube.mtl\nv 0 0 0\nv 1 0 0\nv 1 1 0\nv 0 1 0\nvt 0 0\nvt 1 0\nvt 1 1\nvt 0 1\nvn 0 0 1\nusemtl Paint\nf 1/1/1 2/2/1 3/3/1 4/4/1\n";
+ let mtl = b"newmtl Paint\nKd 0.5 0.5 0.5\nmap_Kd paint.png\n";
+ assert!(crate::mesh::read_obj(&String::from_utf8_lossy(obj), Some(&String::from_utf8_lossy(mtl))).is_ok());
+ survives("OBJ", obj, |b| {
+ let _ = crate::mesh::read_obj(&String::from_utf8_lossy(b), Some(&String::from_utf8_lossy(mtl)));
+ });
+ survives("MTL", mtl, |b| {
+ let _ = crate::mesh::read_mtl(&String::from_utf8_lossy(b));
+ });
+ let sky = crate::environment::Equirect {
+ width: 16,
+ height: 8,
+ pixels: (0..128).map(|i| [i as f32 / 128.0, 0.5, 2.0]).collect(),
+ };
+ let good = crate::environment::write_hdr(&sky);
+ assert!(crate::environment::read_hdr(&good).is_some());
+ survives("HDR", &good, |b| {
+ let _ = crate::environment::read_hdr(b);
+ });
+}
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index a1d5a1b..72963f0 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -12,6 +12,8 @@ pub mod cms;
pub mod cmyk;
pub mod crop;
pub mod curve;
+#[cfg(test)]
+mod damaged;
pub mod document;
pub mod environment;
pub mod fill;