856f865cf98d
tests.rs
use super::*;
use craft_psd::abr::{AbrSample, LegacyBrush, LegacyTip, write_v12};
use serde_json::json;
use std::path::PathBuf;
/// A fresh, empty directory under the system temp dir (tests never write anywhere else).
struct TempDir(PathBuf);
impl TempDir {
fn new(tag: &str) -> Self {
static N: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
let n = N.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let d = std::env::temp_dir().join(format!("pc-preset-store-{}-{tag}-{n}", std::process::id()));
let _ = std::fs::remove_dir_all(&d);
TempDir(d)
}
fn files(&self) -> Vec<String> {
let mut v: Vec<String> = DirBackend::new(&self.0).list().unwrap().into_iter().map(|(n, _)| n).collect();
v.sort();
v
}
}
impl Drop for TempDir {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A session with the store in `dir` attached.
fn session(dir: &TempDir) -> (Session, Vec<String>) {
let mut s = Session::new();
let w = s.attach_preset_store(open_dir(&dir.0));
(s, w)
}
fn tip8(w: u32, h: u32, seed: u32) -> GrayTile {
GrayTile::from_fn(w, h, |x, y| ((x * 7 + y * 13 + seed) % 256) as f32 / 255.0)
}
fn tip16(w: u32, h: u32, seed: u32) -> GrayTile {
let data = (0..w * h).map(|i| (i.wrapping_mul(2654435761).wrapping_add(seed) >> 16) as u16).collect();
GrayTile { width: w, height: h, data }
}
fn sampled(name: &str, group: &str, tip: GrayTile) -> BrushPreset {
let brush = BrushSettings { size: 42.0, spacing: 0.1, tip: TipShape::Sampled(tip), ..Default::default() };
BrushPreset { name: name.into(), brush, builtin: false, group: group.into(), folder: Vec::new(), captures: Default::default() }
}
fn user(s: &Session) -> Vec<BrushPreset> {
s.tools.presets.iter().filter(|p| !p.builtin).cloned().collect()
}
#[test]
fn sessions_have_no_store_by_default() {
let mut s = Session::new();
assert!(s.preset_store.is_none(), "headless sessions must stay hermetic");
s.execute("brush.presets.save", json!({"name": "Mine"})).unwrap();
assert!(s.preset_store.is_none());
}
#[test]
fn tip_codec_round_trips_8_and_16_bit() {
let t8 = tip8(37, 21, 3);
let t16 = tip16(40, 33, 9);
let e8 = encode_tip(&t8);
let e16 = encode_tip(&t16);
assert_eq!(e8[6], 8, "8-bit sourced tips are stored at 8 bits");
assert_eq!(e16[6], 16);
assert_eq!(decode_tip(&e8).unwrap(), t8);
assert_eq!(decode_tip(&e16).unwrap(), t16);
}
#[test]
fn tip_decoder_rejects_garbage() {
let good = encode_tip(&tip16(16, 16, 1));
for n in 0..good.len() {
assert!(decode_tip(&good[..n]).is_err(), "truncated at {n}");
}
let mut bad = good.clone();
bad[6] = 12;
assert!(decode_tip(&bad).is_err());
// A header claiming a huge bitmap is refused before allocating.
let mut huge = good.clone();
huge[7..11].copy_from_slice(&u32::MAX.to_le_bytes());
assert!(decode_tip(&huge).is_err());
let mut big = good.clone();
big[7..11].copy_from_slice(&MAX_TIP_SIDE.to_le_bytes());
big[11..15].copy_from_slice(&MAX_TIP_SIDE.to_le_bytes());
assert!(decode_tip(&big).is_err());
let mut rng = 0x1234_5678u32;
for _ in 0..200 {
let len = (rng % 64) as usize;
let v: Vec<u8> = (0..len)
.map(|_| {
rng ^= rng << 13;
rng ^= rng >> 17;
rng ^= rng << 5;
rng as u8
})
.collect();
let _ = decode_tip(&v);
let mut w = b"PCTIP1".to_vec();
w.extend_from_slice(&v);
let _ = decode_tip(&w);
}
}
#[test]
fn group_with_sampled_8_and_16_bit_tips_round_trips() {
let dir = TempDir::new("roundtrip");
let (mut s, w) = session(&dir);
assert!(w.is_empty(), "{w:?}");
assert!(dir.files().is_empty(), "attaching an empty store writes nothing");
let mut a = sampled("Eight", "Inks", tip8(64, 48, 1));
a.brush.dual_brush.tip = TipShape::Sampled(tip8(12, 12, 5));
a.brush.texture.pattern = Pattern::Tile(tip16(32, 32, 7));
let b = sampled("Sixteen", "Inks", tip16(50, 70, 2));
let mut c = sampled("Shared tip", "Other", tip8(64, 48, 1));
c.brush.size = 9.0;
s.tools.presets.extend([a, b, c]);
s.brush_presets_changed();
s.sync_preset_store();
let files = dir.files();
assert_eq!(files.iter().filter(|f| f.ends_with(".pcbrushes")).count(), 2, "{files:?}");
// Four distinct bitmaps (the 64×48 tip is shared by two presets) plus the previews of the two
// 16-bit ones: an 8-bit tip this small is its own preview.
assert_eq!(files.iter().filter(|f| f.starts_with("tips/")).count(), 6, "{files:?}");
// The session keeps previews, not the bitmaps (#1843).
assert!(user(&s).iter().all(|p| matches!(&p.brush.tip, TipShape::Stored(r) if !r.is_loaded())));
assert!(files.contains(&INDEX_FILE.to_string()));
let (t, w) = session(&dir);
assert!(w.is_empty(), "{w:?}");
assert_eq!(user(&t), user(&s));
let order: Vec<String> = user(&t).into_iter().map(|p| p.name).collect();
assert_eq!(order, ["Eight", "Sixteen", "Shared tip"]);
// Nothing changed: reloading rewrote nothing.
let before: Vec<_> = DirBackend::new(&dir.0).list().unwrap();
let mut t = t;
t.brush_presets_changed();
t.sync_preset_store();
assert_eq!(DirBackend::new(&dir.0).list().unwrap(), before);
}
#[test]
fn commands_persist_and_delete_removes_from_disk() {
let dir = TempDir::new("commands");
let (mut s, _) = session(&dir);
s.tools.brush.tip = TipShape::Sampled(tip16(20, 20, 4));
s.execute("brush.presets.save", json!({"name": "Scribble"})).unwrap();
assert_eq!(dir.files().iter().filter(|f| f.starts_with("tips/")).count(), 2, "the tip and its preview");
// The tool's brush now is the saved preset's stored tip, still loaded.
assert!(matches!(&s.tools.brush.tip, TipShape::Stored(r) if r.is_loaded()));
let (t, _) = session(&dir);
let p = photocraft_paint::presets::find(&t.tools.presets, "Scribble").expect("saved preset reloads");
assert_eq!(p.brush.tip, s.tools.brush.tip);
// Rename through the Preset Manager, then delete.
s.execute("edit.presets.presetManager", json!({"action": "rename", "kind": "brushes", "name": "Scribble", "newName": "Doodle"})).unwrap();
let (t, _) = session(&dir);
assert!(photocraft_paint::presets::find(&t.tools.presets, "Doodle").is_some());
assert!(photocraft_paint::presets::find(&t.tools.presets, "Scribble").is_none());
s.execute("brush.presets.delete", json!({"name": "Doodle"})).unwrap();
assert_eq!(dir.files(), [INDEX_FILE], "the group file and its tip are gone");
let (t, _) = session(&dir);
assert!(photocraft_paint::presets::find(&t.tools.presets, "Doodle").is_none());
}
/// The New Brush Preset dialog's boxes (#4490) are saved with the preset and come back with it;
/// a preset saved without them reloads with the default captures and writes no field for them.
#[test]
fn preset_captures_persist() {
let dir = TempDir::new("captures");
let (mut s, _) = session(&dir);
s.execute("brush.presets.save", json!({"name": "Bare", "captureSize": false, "toolSettings": false, "color": true})).unwrap();
s.execute("brush.presets.save", json!({"name": "Plain"})).unwrap();
let (t, _) = session(&dir);
let find = |n: &str| photocraft_paint::presets::find(&t.tools.presets, n).expect("reloads").captures.clone();
assert_eq!(find("Bare"), PresetCaptures { size: false, tool_settings: false, color: true });
assert!(find("Plain").is_default());
let written: String = dir.files().iter().filter(|f| !f.starts_with("tips/")).map(|f| std::fs::read_to_string(dir.0.join(f)).unwrap_or_default()).collect();
assert_eq!(written.matches("\"captures\"").count(), 1, "only the preset with boxes records them");
}
#[test]
fn imported_abr_group_persists() {
let dir = TempDir::new("abr");
let (mut s, _) = session(&dir);
let tip = AbrSample { id: String::new(), width: 6, height: 4, depth: 8, data: (0..24).map(|i| i * 10).collect() };
let abr = write_v12(
2,
&[
LegacyBrush { name: "Grit".into(), spacing: 25, anti_alias: true, tip: LegacyTip::Sampled(tip) },
LegacyBrush {
name: "Round 9".into(),
spacing: 10,
anti_alias: true,
tip: LegacyTip::Computed { diameter: 9, hardness: 100, angle: 0, roundness: 100 },
},
],
true,
)
.unwrap();
let data = photocraft_paint::tile::b64_encode(&abr);
s.execute("brush.presets.importAbr", json!({"data": data, "group": "Legacy Set"})).unwrap();
let (t, w) = session(&dir);
assert!(w.is_empty(), "{w:?}");
let grp: Vec<&BrushPreset> = t.tools.presets.iter().filter(|p| p.group == "Legacy Set").collect();
assert_eq!(grp.len(), 2);
assert_eq!(user(&t), user(&s));
// Deleting every preset of the group removes its file and tips.
let names: Vec<String> = grp.iter().map(|p| p.name.clone()).collect();
for n in names {
s.execute("brush.presets.delete", json!({"name": n})).unwrap();
}
assert!(!dir.files().iter().any(|f| f.ends_with(".pcbrushes") || f.starts_with("tips/")), "{:?}", dir.files());
}
#[test]
fn deleted_builtins_stay_deleted_and_overrides_replace_them() {
let dir = TempDir::new("builtins");
let (mut s, _) = session(&dir);
let first = s.tools.presets[0].name.clone();
let second = s.tools.presets[1].name.clone();
s.execute("brush.presets.delete", json!({"name": first})).unwrap();
s.tools.brush.size = 77.0;
s.execute("brush.presets.save", json!({"name": second})).unwrap();
let (t, _) = session(&dir);
assert!(photocraft_paint::presets::find(&t.tools.presets, &first).is_none());
let p = photocraft_paint::presets::find(&t.tools.presets, &second).unwrap();
assert_eq!((p.builtin, p.brush.size), (false, 77.0));
assert_eq!(t.tools.presets.iter().filter(|p| p.name.eq_ignore_ascii_case(&second)).count(), 1);
// No built-in is ever written.
let n = dir.files().iter().filter(|f| f.ends_with(".pcbrushes")).count();
assert_eq!(n, 1);
}
#[test]
fn startup_with_many_groups_loads_them_all() {
let dir = TempDir::new("many");
let (mut s, _) = session(&dir);
for g in 0..25 {
for i in 0..4 {
s.tools.presets.push(sampled(&format!("P{g}-{i}"), &format!("Group {g}"), tip8(16 + i, 16, g)));
}
}
s.brush_presets_changed();
s.sync_preset_store();
let (t, w) = session(&dir);
assert!(w.is_empty(), "{w:?}");
assert_eq!(user(&t).len(), 100);
let groups: Vec<String> = user(&t).iter().map(|p| p.group.clone()).fold(Vec::new(), |mut v, g| {
if !v.contains(&g) {
v.push(g);
}
v
});
assert_eq!(groups, (0..25).map(|g| format!("Group {g}")).collect::<Vec<_>>(), "group order survives");
}
#[test]
fn reordering_presets_and_groups_persists() {
let names = |s: &Session| s.tools.presets.iter().map(|p| (p.name.clone(), p.group.clone())).collect::<Vec<_>>();
let dir = TempDir::new("reorder");
let (mut s, _) = session(&dir);
for (n, g) in [("Ink 1", "Inks"), ("Ink 2", "Inks"), ("Wash", "Washes")] {
s.execute("brush.presets.save", json!({"name": n})).unwrap();
s.tools.presets.iter_mut().find(|p| p.name == n).unwrap().group = g.into();
}
s.brush_presets_changed();
s.sync_preset_store();
// Untouched order: no order list is written (the default order is implied).
let (t, _) = session(&dir);
assert_eq!(names(&t), names(&s));
// Reorder a built-in within its group, a user preset across groups, and whole groups.
let builtin_group = s.tools.presets[0].group.clone();
let last_builtin = s.tools.presets.iter().rfind(|p| p.builtin && p.group == builtin_group).unwrap().name.clone();
let first = s.tools.presets[0].name.clone();
s.execute("brush.presets.move", json!({"name": last_builtin, "before": first})).unwrap();
s.execute("brush.presets.move", json!({"name": "Ink 2", "group": "Washes", "index": 0})).unwrap();
s.execute("brush.presets.moveGroup", json!({"group": "Washes", "index": 0})).unwrap();
s.execute("brush.presets.moveGroup", json!({"group": "Inks", "before": builtin_group})).unwrap();
assert_eq!(s.tools.presets[0].name, "Ink 2");
let (t, w) = session(&dir);
assert!(w.is_empty(), "{w:?}");
assert_eq!(names(&t), names(&s), "the panel order survives a restart");
assert!(t.tools.presets.iter().find(|p| p.name == last_builtin).unwrap().builtin, "reordering keeps a built-in built-in");
// Renaming and deleting a group persist too.
s.execute("brush.presets.renameGroup", json!({"group": "Inks", "newName": "Pens"})).unwrap();
s.execute("brush.presets.deleteGroup", json!({"group": "Washes"})).unwrap();
let (t, _) = session(&dir);
assert_eq!(names(&t), names(&s));
assert!(t.tools.presets.iter().all(|p| p.group != "Washes" && p.group != "Inks"));
}
#[test]
fn corrupt_and_oversized_files_are_skipped_with_a_warning() {
let dir = TempDir::new("corrupt");
let (mut s, _) = session(&dir);
s.tools.presets.push(sampled("Good", "Fine", tip8(8, 8, 1)));
s.tools.presets.push(sampled("Lost", "Broken tip", tip16(9, 9, 2)));
s.brush_presets_changed();
s.sync_preset_store();
let be = DirBackend::new(&dir.0);
be.write("junk-00000000.pcbrushes", b"{not json").unwrap();
be.write("wrong-00000000.pcbrushes", br#"{"format":"other","version":1,"group":"x","presets":[]}"#).unwrap();
// Corrupt the 16-bit tip of "Broken tip".
let h = tip_hash(&tip16(9, 9, 2));
be.write(&tip_file(&h), b"PCTIP1\x10garbage").unwrap();
let (mut t, w) = session(&dir);
assert_eq!(w.len(), 2, "{w:?}");
assert!(photocraft_paint::presets::find(&t.tools.presets, "Good").is_some());
// Full tips load when a brush is used (#1843): the broken one fails then, not at start.
assert!(photocraft_paint::presets::find(&t.tools.presets, "Lost").is_some());
let before = t.tools.brush.clone();
let e = t.execute("tools.setBrush", json!({"preset": "Lost"})).unwrap_err().to_string();
assert!(e.contains(&h), "{e}");
assert_eq!(t.tools.brush, before, "a failed pick leaves the brush alone");
t.execute("tools.setBrush", json!({"preset": "Good"})).unwrap();
// The broken files are left alone for the user (never deleted by a sync).
t.execute("brush.presets.save", json!({"name": "Another"})).unwrap();
let files = dir.files();
assert!(files.contains(&"junk-00000000.pcbrushes".to_string()) && files.contains(&tip_file(&h)), "{files:?}");
// Oversized files are refused without reading them whole.
let mem = MemBackend::default();
mem.files.lock().unwrap().insert("big-00000000.pcbrushes".into(), vec![b' '; MAX_GROUP_BYTES as usize + 1]);
mem.files.lock().unwrap().insert(INDEX_FILE.into(), b"[1,2".to_vec());
let o = open(Box::new(mem));
assert!(o.presets.is_empty());
assert_eq!(o.warnings.len(), 2, "{:?}", o.warnings);
}
#[test]
fn write_failures_are_warnings() {
let dir = TempDir::new("readonly");
// The store "directory" is a file: every write fails.
std::fs::write(&dir.0, b"not a dir").unwrap();
let mut s = Session::new();
s.attach_preset_store(open_dir(&dir.0));
s.tools.brush.tip = TipShape::Sampled(tip8(4, 4, 0));
s.execute("brush.presets.save", json!({"name": "Nope"})).unwrap();
let w = s.preset_store.as_mut().unwrap().take_warnings();
assert!(!w.is_empty());
let _ = std::fs::remove_file(&dir.0);
}
#[test]
fn backends_refuse_paths_outside_the_store() {
let mem = MemBackend::default();
for n in ["../x.pcbrushes", "a/b.pcbrushes", "tips/../x", ".hidden", "", "tips/"] {
assert!(mem.write(n, b"x").is_err(), "{n}");
}
assert!(group_file_name("../../etc/passwd").ends_with(".pcbrushes"));
assert!(valid_name(&group_file_name("../../etc/passwd")));
assert!(valid_name(&group_file_name("")));
assert!(valid_name(&group_file_name("日本語 ブラシ")));
assert_ne!(group_file_name("a/b"), group_file_name("a_b"));
}
/// `cargo test --release -p photocraft-engine --lib preset_store::tests::bench_load_500 -- --ignored --nocapture`
#[test]
#[ignore]
fn bench_load_500_sampled_presets() {
let dir = TempDir::new("bench");
let (mut s, _) = session(&dir);
for i in 0..500u32 {
// A mix of 8-bit (most .abr tips) and 16-bit tips, 64..319 px.
let side = 64 + (i * 37) % 256;
let t = if i % 4 == 0 { tip16(side, side, i) } else { tip8(side, side, i) };
s.tools.presets.push(sampled(&format!("Brush {i}"), &format!("Set {}", i / 50), t));
}
s.brush_presets_changed();
let t0 = std::time::Instant::now();
s.sync_preset_store();
let write = t0.elapsed();
let bytes = s.preset_store.as_ref().unwrap().bytes();
let t0 = std::time::Instant::now();
let o = open_dir(&dir.0);
let load = t0.elapsed();
assert_eq!(o.presets.len(), 500);
let t0 = std::time::Instant::now();
s.execute("edit.presets.presetManager", json!({"action": "rename", "kind": "brushes", "name": "Brush 3", "newName": "Renamed"})).unwrap();
let rename = t0.elapsed();
eprintln!("500 sampled presets: {:.1} MB on disk; write {write:?}, load {load:?}, rename {rename:?}", bytes as f64 / 1e6);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_store_directory_that_does_not_exist_yet_opens_without_warnings() {
// Windows reports a file under a missing directory as "path not found" (os error 3), not
// "file not found"; both mean an empty store, as on a first launch.
let parent = TempDir::new("missing-store");
let dir = parent.0.join("not-created-yet");
assert!(!dir.exists());
let opened = open_dir(&dir);
assert!(opened.warnings.is_empty(), "{:?}", opened.warnings);
assert!(opened.actions.actions().is_empty());
let err = DirBackend::new(&dir).read(ACTIONS_FILE, MAX_ACTIONS_BYTES).unwrap_err();
assert!(missing_file(&err), "{err}");
}
// ------------------------------------------------------------------ on-demand tips (#1843)
/// A session on an in-memory store holding `n` presets with distinct `side`-px 8-bit tips (one
/// group), synced; plus the backend to reopen it.
fn library(n: u32, side: u32) -> (Session, MemBackend) {
let mem = MemBackend::default();
let mut s = Session::new();
s.attach_preset_store(open(Box::new(mem.clone())));
for i in 0..n {
s.tools.presets.push(sampled(&format!("Big {i}"), "Big Set", tip8(side, side, i)));
}
s.brush_presets_changed();
s.sync_preset_store();
(s, mem)
}
/// Bitmap samples a preset library holds (full tips, or previews of stored ones not loaded).
fn library_samples(s: &Session) -> usize {
let b = |p: &BrushPreset| {
[
p.brush.tip.bitmap().map(|g| g.data.len()),
p.brush.dual_brush.tip.bitmap().map(|g| g.data.len()),
p.brush.texture.pattern.bitmap().map(|g| g.data.len()),
]
};
s.tools.presets.iter().flat_map(b).flatten().sum()
}
fn cache(s: &Session) -> TipCacheStats {
s.preset_store.as_ref().unwrap().tip_cache()
}
#[test]
fn reopening_a_library_decodes_no_tips_and_using_a_brush_decodes_only_its_own() {
let (n, side) = (20u32, 512u32);
let (s, mem) = library(n, side);
// Once written, the imported presets keep previews only (built-ins keep their small tips).
let budget = (n as usize + 40) * (PREVIEW_SIDE * PREVIEW_SIDE) as usize;
assert!(library_samples(&s) < budget, "{}", library_samples(&s));
assert_eq!(cache(&s).decodes, 0);
let files = mem.list().unwrap();
drop(s);
// A restart: nothing is decoded at full size.
let mut t = Session::new();
let w = t.attach_preset_store(open(Box::new(mem.clone())));
assert!(w.is_empty(), "{w:?}");
assert_eq!(mem.list().unwrap(), files, "attaching an unchanged store rewrites nothing");
let user_presets = user(&t);
assert_eq!(user_presets.len(), n as usize);
for p in &user_presets {
let TipShape::Stored(r) = &p.brush.tip else { panic!("{} is not a stored tip", p.name) };
assert!(!r.is_loaded() && (r.width, r.height) == (side, side));
assert!(r.preview.width <= PREVIEW_SIDE && r.preview.height <= PREVIEW_SIDE);
}
assert!(library_samples(&t) < budget);
assert_eq!(cache(&t), TipCacheStats { tips: 0, bytes: 0, decodes: 0, limit: TIP_CACHE_BYTES });
// Using one brush decodes exactly its tip; painting and picking it again reuse it.
t.execute("file.new", json!({"width": 64, "height": 64, "background": "white"})).unwrap();
t.execute("tools.setBrush", json!({"preset": "Big 3"})).unwrap();
let TipShape::Stored(r) = &t.tools.brush.tip else { panic!("the brush keeps its stored tip") };
assert_eq!(r.full.as_deref(), Some(&tip8(side, side, 3)), "the tool paints with the full tip");
assert_eq!(cache(&t).decodes, 1);
t.execute("paint.stroke", json!({"points": [[10, 10], [50, 50]], "brush": {"size": 30}})).unwrap();
t.execute("paint.stroke", json!({"points": [[10, 50], [50, 10]], "preset": "Big 3"})).unwrap();
t.execute("tools.setBrush", json!({"preset": "Big 3"})).unwrap();
assert_eq!((cache(&t).decodes, cache(&t).tips), (1, 1));
// Picking a preset never loads the library's other tips, and the library stays light.
assert!(user(&t).iter().all(|p| matches!(&p.brush.tip, TipShape::Stored(r) if !r.is_loaded())));
// The panel's "current brush" match still works on a stored tip.
let picked = photocraft_paint::presets::find(&t.tools.presets, "Big 3").unwrap();
assert_eq!(picked.brush.tip, t.tools.brush.tip);
}
#[test]
fn the_decoded_tip_cache_stays_within_its_budget() {
let (s, mem) = library(6, 256);
drop(s);
let mut t = Session::new();
t.attach_preset_store(open(Box::new(mem)));
let one = 256 * 256 * 2;
t.preset_store.as_ref().unwrap().set_tip_cache_limit(one * 2 + 1);
for i in 0..6 {
t.execute("tools.setBrush", json!({"preset": format!("Big {i}")})).unwrap();
let c = cache(&t);
assert!(c.bytes <= c.limit && c.tips <= 2, "{c:?}");
}
assert_eq!(cache(&t).decodes, 6);
// The two most recently used stay: picking them again decodes nothing.
t.execute("tools.setBrush", json!({"preset": "Big 4"})).unwrap();
t.execute("tools.setBrush", json!({"preset": "Big 5"})).unwrap();
assert_eq!(cache(&t).decodes, 6);
t.execute("tools.setBrush", json!({"preset": "Big 0"})).unwrap();
assert_eq!(cache(&t).decodes, 7);
// A budget below one tip still loads it (the brush in use holds its own reference).
t.preset_store.as_ref().unwrap().set_tip_cache_limit(0);
assert_eq!(cache(&t).tips, 0);
t.execute("tools.setBrush", json!({"preset": "Big 1"})).unwrap();
assert!(matches!(&t.tools.brush.tip, TipShape::Stored(r) if r.is_loaded()));
}
#[test]
fn missing_corrupt_or_unknown_tips_fail_when_used_without_panicking() {
let (s, mem) = library(3, 64);
drop(s);
let mut t = Session::new();
t.attach_preset_store(open(Box::new(mem.clone())));
t.execute("file.new", json!({"width": 32, "height": 32})).unwrap();
let key = |t: &Session, name: &str| match &photocraft_paint::presets::find(&t.tools.presets, name).unwrap().brush.tip {
TipShape::Stored(r) => r.key.clone(),
other => panic!("{other:?}"),
};
// Deleted behind the store's back.
let k0 = key(&t, "Big 0");
mem.remove(&tip_file(&k0)).unwrap();
t.execute("tools.setBrush", json!({"preset": "Hard Round"})).unwrap();
let broken = t.tools.presets.iter_mut().find(|p| p.name == "Big 0").unwrap();
broken.captures.color = true;
broken.brush.color = [1.0, 0.0, 0.0, 1.0];
t.tools.foreground = [0.0, 0.0, 1.0, 1.0];
let before = t.tools.brush.clone();
let preset_before = t.tools.current_preset.clone();
let foreground_before = t.tools.foreground;
let revision_before = t.tools.brush_rev;
assert!(t.execute("tools.setBrush", json!({"preset": "Big 0"})).is_err());
assert!(t.execute("paint.stroke", json!({"points": [[1, 1], [9, 9]], "preset": "Big 0"})).is_err());
assert_eq!(t.tools.brush, before);
assert_eq!(t.tools.current_preset, preset_before);
assert_eq!(t.tools.foreground, foreground_before);
assert_eq!(t.tools.brush_rev, revision_before);
// Corrupt, or a different bitmap under the same name.
let k1 = key(&t, "Big 1");
mem.write(&tip_file(&k1), b"PCTIP1\x08garbage").unwrap();
assert!(t.execute("tools.setBrush", json!({"preset": "Big 1"})).is_err());
let k2 = key(&t, "Big 2");
mem.write(&tip_file(&k2), &encode_tip(&tip8(10, 10, 0))).unwrap();
let e = t.execute("tools.setBrush", json!({"preset": "Big 2"})).unwrap_err().to_string();
assert!(e.contains("expected 64×64"), "{e}");
// Exporting a library whose tip is gone is an error too, not a file with a hole.
assert!(t.execute("edit.presets.exportImportPresets", json!({"action": "export"})).is_err());
// A stored reference the store doesn't know, or with no store at all.
let stray = json!({"tip": {"stored": {"key": "../../etc/passwd", "width": 4, "height": 4,
"preview": {"width": 1, "height": 1, "data": [1.0]}}}});
assert!(t.execute("tools.setBrush", json!({"brush": stray})).is_err());
let mut headless = Session::new();
assert!(headless.execute("tools.setBrush", json!({"brush": stray})).is_err());
assert!(headless.execute("brush.presets.list", json!({"full": true})).is_ok());
}
#[test]
fn a_store_without_previews_makes_them_once_and_then_loads_lazily() {
// A store written before #1843: group files without tip sizes, no preview files.
let mem = MemBackend::default();
let tips = [tip16(300, 200, 1), tip8(40, 40, 2)];
let hashes: Vec<String> = tips.iter().map(tip_hash).collect();
for (t, h) in tips.iter().zip(&hashes) {
mem.write(&tip_file(h), &encode_tip(t)).unwrap();
}
let group = json!({"format": GROUP_FORMAT, "version": 1, "group": "Old", "presets": [
{"name": "Old A", "brush": {"size": 30}, "tips": {"tip": hashes[0], "texture": hashes[1]}},
{"name": "Old B", "brush": {"size": 12}, "tips": {"tip": hashes[1]}},
]});
let file = group_file_name("Old");
mem.write(&file, &serde_json::to_vec(&group).unwrap()).unwrap();
let mut s = Session::new();
let w = s.attach_preset_store(open(Box::new(mem.clone())));
assert!(w.is_empty(), "{w:?}");
let a = photocraft_paint::presets::find(&s.tools.presets, "Old A").unwrap().clone();
assert!(matches!(&a.brush.tip, TipShape::Stored(r) if (r.width, r.height) == (300, 200) && !r.is_loaded()));
assert!(matches!(&a.brush.texture.pattern, Pattern::Stored(r) if r.key == hashes[1]));
// Attaching rewrote the group with sizes and previews.
let rewritten: serde_json::Value = serde_json::from_slice(&mem.read(&file, MAX_GROUP_BYTES).unwrap()).unwrap();
assert_eq!(rewritten["tips"][&hashes[0]]["width"], 300);
assert_eq!(rewritten["presets"][0]["brush"]["size"], 30.0);
// The next start reads previews only and changes nothing.
let files = mem.list().unwrap();
let mut t = Session::new();
assert!(t.attach_preset_store(open(Box::new(mem.clone()))).is_empty());
assert_eq!(mem.list().unwrap(), files);
assert_eq!(user(&t), user(&s));
t.execute("tools.setBrush", json!({"preset": "Old A"})).unwrap();
assert_eq!(t.tools.brush.tip.bitmap(), Some(&tips[0]));
assert_eq!(t.tools.brush.texture.pattern.bitmap(), Some(&tips[1]));
assert_eq!(cache(&t).decodes, 2);
// Exported presets embed the full bitmaps, as before.
let out = t.execute("edit.presets.exportImportPresets", json!({"action": "export"})).unwrap();
let back: Vec<BrushPreset> = serde_json::from_value(out["data"]["brushes"].clone()).unwrap();
let a = back.iter().find(|p| p.name == "Old A").unwrap();
assert_eq!(a.brush.tip, TipShape::Sampled(tips[0].clone()));
assert_eq!(a.brush.texture.pattern, Pattern::Tile(tips[1].clone()));
}
/// A v6 `.abr` whose presets sit in Photoshop folders (`phry`).
fn abr_with_folders(presets: &[(&str, &[&str])]) -> Vec<u8> {
use craft_psd::descriptor::{Descriptor, UnicodeString, Value};
let descs: Vec<Descriptor> = presets.iter().map(|(n, _)| Descriptor::new("brushPreset").with("Nm ", Value::Text(UnicodeString::new_nul(n)))).collect();
let folders: Vec<Vec<String>> = presets.iter().map(|(_, f)| f.iter().map(|x| x.to_string()).collect()).collect();
craft_psd::abr::write_v6_folders(2, &[], &[], &descs, &folders, true).unwrap()
}
#[test]
fn imported_abr_folders_persist_and_old_stores_load_flat() {
let dir = TempDir::new("abr-folders");
let (mut s, _) = session(&dir);
let abr = abr_with_folders(&[("Loose", &[]), ("Pen", &["Inks"]), ("Nib", &["Inks", "Fine"]), ("Kit Chalk", &["Dry"])]);
let r = s.execute("brush.presets.importAbr", json!({"data": photocraft_paint::tile::b64_encode(&abr), "group": "Kit"})).unwrap();
assert_eq!((r["count"].as_u64(), r["folders"].as_u64()), (Some(4), Some(3)));
let folder = |s: &Session, n: &str| photocraft_paint::presets::find(&s.tools.presets, n).unwrap().folder.join("/");
assert_eq!((folder(&s, "Loose"), folder(&s, "Nib"), folder(&s, "Kit Chalk")), ("".into(), "Inks/Fine".into(), "Dry".into()));
// One group file still holds the whole imported set, folders included.
let groups: Vec<String> = dir.files().into_iter().filter(|f| f.ends_with(".pcbrushes")).collect();
assert_eq!(groups, [group_file_name("Kit")]);
let (t, w) = session(&dir);
assert!(w.is_empty(), "{w:?}");
assert_eq!(user(&t), user(&s));
// Renaming a nested folder rewrites the group; the next start sees the new name.
s.execute("brush.presets.renameGroup", json!({"group": "Kit", "folder": ["Inks"], "newName": "Ink"})).unwrap();
let (t, _) = session(&dir);
assert_eq!(folder(&t, "Nib"), "Ink/Fine");
// Exported preset files keep the folders.
let out = s.execute("edit.presets.exportImportPresets", json!({"action": "export"})).unwrap();
assert_eq!(out["data"]["brushes"].as_array().unwrap().iter().find(|b| b["name"] == "Nib").unwrap()["folder"], json!(["Ink", "Fine"]));
// A group file written before #1851 has no `folder`: every preset loads directly in its group,
// without a warning and without rewriting the file.
let mem = MemBackend::default();
let old = json!({"format": GROUP_FORMAT, "version": 1, "group": "Old", "presets": [{"name": "Plain", "brush": {"size": 5}}]});
let file = group_file_name("Old");
mem.write(&file, &serde_json::to_vec(&old).unwrap()).unwrap();
let before = mem.read(&file, MAX_GROUP_BYTES).unwrap();
let mut o = Session::new();
assert!(o.attach_preset_store(open(Box::new(mem.clone()))).is_empty());
let p = photocraft_paint::presets::find(&o.tools.presets, "Plain").unwrap();
assert!(p.group == "Old" && p.folder.is_empty());
assert_eq!(mem.read(&file, MAX_GROUP_BYTES).unwrap(), before);
// A hand-edited folder path is bounded.
let deep = json!({"format": GROUP_FORMAT, "version": 1, "group": "Deep", "presets": [
{"name": "Deep", "brush": {}, "folder": vec!["x"; 1000]},
{"name": "Blank", "brush": {}, "folder": ["", " "]},
]});
mem.write(&group_file_name("Deep"), &serde_json::to_vec(&deep).unwrap()).unwrap();
let mut d = Session::new();
d.attach_preset_store(open(Box::new(mem.clone())));
assert_eq!(photocraft_paint::presets::find(&d.tools.presets, "Deep").unwrap().folder.len(), crate::brush_preset_cmds::MAX_FOLDER_DEPTH);
assert!(photocraft_paint::presets::find(&d.tools.presets, "Blank").unwrap().folder.is_empty());
}
/// Moving a group into another group's folder rewrites the target group's file and removes the
/// moved group's; moving a folder out to the top level makes a group file for it (#2014).
#[test]
fn folders_moved_into_other_folders_persist() {
let dir = TempDir::new("folder-into");
let (mut s, _) = session(&dir);
let set = abr_with_folders(&[("Kit Loose", &[]), ("Kit Pen", &["Inks"]), ("Kit Nib", &["Inks", "Fine"])]);
let other = abr_with_folders(&[("Pack Chalk", &["Dry"])]);
s.execute("brush.presets.importAbr", json!({"data": photocraft_paint::tile::b64_encode(&set), "group": "Kit"})).unwrap();
s.execute("brush.presets.importAbr", json!({"data": photocraft_paint::tile::b64_encode(&other), "group": "Pack"})).unwrap();
let group_files = |d: &TempDir| -> Vec<String> { d.files().into_iter().filter(|f| f.ends_with(".pcbrushes")).collect() };
let mut both = vec![group_file_name("Kit"), group_file_name("Pack")];
both.sort();
assert_eq!(group_files(&dir), both);
s.execute("brush.presets.moveGroup", json!({"group": "Pack", "into": {"group": "Kit", "folder": ["Inks"]}})).unwrap();
assert_eq!(group_files(&dir), [group_file_name("Kit")]);
let (t, w) = session(&dir);
assert!(w.is_empty(), "{w:?}");
assert_eq!(user(&t), user(&s));
let folder = |s: &Session, n: &str| {
let p = photocraft_paint::presets::find(&s.tools.presets, n).unwrap();
format!("{}:{}", p.group, p.folder.join("/"))
};
assert_eq!(folder(&t, "Pack Chalk"), "Kit:Inks/Pack/Dry");
// Out to the top level: a group (and file) of its own.
s.execute("brush.presets.moveGroup", json!({"group": "Kit", "folder": ["Inks", "Pack"], "into": {}})).unwrap();
let mut both = vec![group_file_name("Kit"), group_file_name("Pack")];
both.sort();
assert_eq!(group_files(&dir), both);
let (t, _) = session(&dir);
assert_eq!(folder(&t, "Pack Chalk"), "Pack:Dry");
assert_eq!(folder(&t, "Kit Nib"), "Kit:Inks/Fine");
}
#[test]
fn a_group_file_that_failed_to_load_is_not_overwritten() {
// e.g. written by a newer PhotoCraft: skipped on load, so a save must not replace it.
let mem = MemBackend::default();
let file = group_file_name("");
let newer = br#"{"format":"photocraft-brush-group","version":2,"group":"","presets":[]}"#.to_vec();
mem.files.lock().unwrap().insert(file.clone(), newer.clone());
let mut s = Session::new();
s.attach_preset_store(open(Box::new(mem.clone())));
s.tools.brush.tip = TipShape::Sampled(tip8(4, 4, 0));
s.execute("brush.presets.save", json!({"name": "New"})).unwrap();
assert_eq!(mem.files.lock().unwrap().get(&file), Some(&newer), "a file the store could not read was overwritten");
assert!(!s.preset_store.as_mut().unwrap().take_warnings().is_empty());
}
#[test]
fn an_actions_file_that_failed_to_load_is_not_overwritten() {
// e.g. written by a newer PhotoCraft: skipped on load, so recording an action must not replace it.
let mem = MemBackend::default();
let newer = br#"{"version":2,"actions":[{"name":"Keep","steps":[]}]}"#.to_vec();
mem.files.lock().unwrap().insert(ACTIONS_FILE.into(), newer.clone());
let mut s = Session::new();
s.attach_preset_store(open(Box::new(mem.clone())));
s.execute("actions.record", json!({"name": "New"})).unwrap();
s.execute("actions.stop", json!({})).unwrap();
s.sync_preset_store();
assert_eq!(mem.files.lock().unwrap().get(ACTIONS_FILE), Some(&newer), "an actions file the store could not read was overwritten");
assert!(!s.preset_store.as_mut().unwrap().take_warnings().is_empty());
}
// A PhotoCraft actions file that keyed calls and shortcuts by stored action id loads with names
// only: the calls and the `actions.playById:<id>` keys move to the names loading gave the ids, and
// the file is written back once without them.
#[test]
fn stored_action_ids_move_to_names_on_load() {
let id = "0123456789abcdef0123456789abcdef";
let mem = MemBackend::default();
let file = format!(
r#"{{"version":1,"actions":[
{{"name":"Same","steps":[],"legacy_shortcut_owner":true}},
{{"name":"Same","steps":[],"action_id":"{id}"}},
{{"name":"Caller","steps":[["actions.play",{{"action":"Same","actionId":"{id}"}}]]}}]}}"#
);
mem.files.lock().unwrap().insert(ACTIONS_FILE.into(), file.into_bytes());
let mut s = Session::new();
s.edit_prefs(|prefs| {
prefs.shortcuts.insert(format!("actions.playById:{id}"), "F6".into());
});
s.attach_preset_store(open(Box::new(mem.clone())));
let names: Vec<&str> = s.actions.list.actions().iter().map(|action| action.name.as_str()).collect();
assert_eq!(names, ["Same", "Same 2", "Caller"]);
assert_eq!(s.actions.list.actions()[2].steps[0].params, json!({"action": "Same 2"}));
assert_eq!(s.prefs().shortcuts.get("actions.play:Same 2").map(String::as_str), Some("F6"));
assert!(!s.prefs().shortcuts.keys().any(|key| key.starts_with("actions.playById:")));
let saved = String::from_utf8(mem.files.lock().unwrap()[ACTIONS_FILE].clone()).unwrap();
assert!(!saved.contains(id), "{saved}");
}
/// A large pattern opens as a small preview (texture libraries run to gigabytes) and is read at
/// full size when it is used; its preview file goes with it on delete.
#[test]
fn large_patterns_load_on_use() {
let dir = TempDir::new("patterns-large");
let (mut s, _) = session(&dir);
s.execute("file.new", json!({"width": 300, "height": 200})).unwrap();
s.execute("edit.fill", json!({"color": "#ffffff"})).unwrap();
s.execute("select.rect", json!({"x": 250, "y": 150, "width": 50, "height": 50})).unwrap();
s.execute("edit.fill", json!({"color": "#ff0000"})).unwrap();
s.execute("select.deselect", json!({})).unwrap();
s.execute("edit.definePattern", json!({"name": "Big"})).unwrap();
assert_eq!(dir.files().iter().filter(|f| f.ends_with(".preview.pat")).count(), 1);
let (mut t, w) = session(&dir);
assert!(w.is_empty(), "{w:?}");
let held = t.patterns.items.iter().find(|p| p.name == "Big").unwrap();
assert!(held.width <= PATTERN_PREVIEW_SIDE && held.height <= PATTERN_PREVIEW_SIDE, "held as a preview: {}x{}", held.width, held.height);
let listed = t.execute("pattern.list", json!({})).unwrap();
let big = listed.as_array().unwrap().iter().find(|p| p["name"] == "Big").unwrap();
assert_eq!((big["width"].as_u64(), big["height"].as_u64()), (Some(300), Some(200)), "the list reports the full size");
// Checks that only need the pattern's id (Pattern Stamp's enabled state) don't read its file.
let id = t.patterns.items.iter().find(|p| p.name == "Big").unwrap().id.clone();
let file = dir.0.join(patterns::file_name_for_test(&id));
let moved = file.with_extension("moved");
std::fs::rename(&file, &moved).unwrap();
assert_eq!(crate::pattern_cmds::resolve_id(&t, "Big"), Some(id.clone()));
assert!(crate::pattern_cmds::resolve(&t, "Big").is_none(), "the full pixels come from the file");
std::fs::rename(&moved, &file).unwrap();
let full = crate::pattern_cmds::resolve(&t, "Big").unwrap();
assert_eq!((full.width, full.height), (300, 200));
assert!(full.surface.pixel(280, 180)[1] < 0.01 && full.surface.pixel(10, 10)[1] > 0.99, "full pixels");
// Once read, it is kept: using it again doesn't read the file.
std::fs::rename(&file, &moved).unwrap();
assert_eq!(crate::pattern_cmds::resolve(&t, "Big").map(|p| p.width), Some(300));
std::fs::rename(&moved, &file).unwrap();
// A Pattern Fill layer gets the full pattern into the document.
t.execute("file.new", json!({"width": 40, "height": 40})).unwrap();
t.execute("layer.newFillLayer.pattern", json!({"pattern": "Big"})).unwrap();
let doc_pat = &t.active().unwrap().doc.patterns[0];
assert_eq!((doc_pat.width, doc_pat.height), (300, 200));
// Exporting the library writes full pixels too.
let out = dir.0.join("export.pat");
t.execute("pattern.export", json!({"path": out.to_string_lossy()})).unwrap();
let back = photocraft_io::pattern_map::read_pat(&std::fs::read(&out).unwrap()).unwrap();
assert!(back.iter().any(|p| p.name == "Big" && p.width == 300));
std::fs::remove_file(&out).unwrap();
t.execute("pattern.delete", json!({"pattern": "Big"})).unwrap();
assert!(!dir.files().iter().any(|f| f.starts_with("pattern-")), "{:?}", dir.files());
}
/// A corrupt pattern file is skipped with a warning and left on disk; the others load, and later
/// saves never delete or overwrite it. A corrupt index is never overwritten.
#[test]
fn corrupt_pattern_files_are_skipped_and_kept() {
let dir = TempDir::new("patterns-corrupt");
let (mut s, _) = session(&dir);
define_pattern(&mut s, "Grit", "#202020", 8);
define_pattern(&mut s, "Paper", "#f0e0c0", 12);
let grit = s.patterns.items.iter().find(|p| p.name == "Grit").unwrap().id.clone();
let file = dir.0.join(patterns::file_name_for_test(&grit));
std::fs::write(&file, b"not a pattern").unwrap();
let (mut t, w) = session(&dir);
assert!(w.iter().any(|w| w.contains("Grit")), "{w:?}");
assert_eq!(user_patterns(&t), [("Paper".to_string(), 12)]);
define_pattern(&mut t, "Ink", "#000000", 4);
assert_eq!(std::fs::read(&file).unwrap(), b"not a pattern", "the unreadable file is left alone");
let index = std::fs::read_to_string(dir.0.join(PATTERNS_FILE)).unwrap();
assert!(index.contains("Grit") && index.contains("Ink"), "{index}");
std::fs::write(dir.0.join(PATTERNS_FILE), b"{").unwrap();
let (mut u, w) = session(&dir);
assert!(w.iter().any(|w| w.contains(PATTERNS_FILE)), "{w:?}");
assert!(user_patterns(&u).is_empty());
define_pattern(&mut u, "Late", "#808080", 4);
assert_eq!(std::fs::read(dir.0.join(PATTERNS_FILE)).unwrap(), b"{", "an unreadable index is never overwritten");
}
/// Imported and defined patterns survive a restart: one file each, written once, plus the index;
/// a rename rewrites only the index, a delete removes the file.
#[test]
fn patterns_survive_a_restart() {
let dir = TempDir::new("patterns");
let (mut s, w) = session(&dir);
assert!(w.is_empty(), "{w:?}");
define_pattern(&mut s, "Grit", "#202020", 8);
define_pattern(&mut s, "Paper", "#f0e0c0", 12);
let pattern_files = |d: &TempDir| d.files().into_iter().filter(|f| f.starts_with("pattern-")).collect::<Vec<_>>();
assert_eq!(pattern_files(&dir).len(), 2);
assert!(dir.files().contains(&PATTERNS_FILE.to_string()));
assert!(!dir.files().iter().any(|f| f.contains("Checkerboard")), "built-ins are never written");
let (mut t, w) = session(&dir);
assert!(w.is_empty(), "{w:?}");
assert_eq!(user_patterns(&t), [("Grit".to_string(), 8), ("Paper".to_string(), 12)]);
// The pixels come back too.
let paper = t.patterns.items.iter().find(|p| p.name == "Paper").unwrap();
let px = paper.surface.pixel(3, 3);
assert!((px[0] - 240.0 / 255.0).abs() < 0.01, "{px:?}");
let before = std::fs::metadata(dir.0.join(&pattern_files(&dir)[0])).unwrap().modified().unwrap();
t.execute("pattern.rename", json!({"pattern": "Grit", "name": "Toner"})).unwrap();
assert_eq!(std::fs::metadata(dir.0.join(&pattern_files(&dir)[0])).unwrap().modified().unwrap(), before, "a rename rewrites only the index");
t.execute("pattern.delete", json!({"pattern": "Paper"})).unwrap();
assert_eq!(pattern_files(&dir).len(), 1, "the deleted pattern's file is gone");
let (u, _) = session(&dir);
assert_eq!(user_patterns(&u), [("Toner".to_string(), 8)]);
}
fn define_pattern(s: &mut Session, name: &str, color: &str, width: u32) {
s.execute("file.new", json!({"width": width, "height": 6})).unwrap();
s.execute("edit.fill", json!({"color": color})).unwrap();
s.execute("edit.definePattern", json!({"name": name})).unwrap();
}
fn user_patterns(s: &Session) -> Vec<(String, u32)> {
let builtins: Vec<String> = crate::pattern_cmds::builtin().into_iter().map(|p| p.id).collect();
s.patterns.items.iter().filter(|p| !builtins.contains(&p.id)).map(|p| (p.name.clone(), p.width)).collect()
}
/// #9317: a defined or imported pattern survives a restart, as in Photoshop; the built-in
/// patterns are never written, and deleting the last user pattern removes the file.
#[test]
fn user_patterns_survive_a_restart() {
let dir = TempDir::new("patterns");
let builtin = Session::new().patterns.items.len();
let (mut s, w) = session(&dir);
assert!(w.is_empty(), "{w:?}");
s.execute("file.new", json!({"width": 12, "height": 10})).unwrap();
s.execute("edit.fill", json!({"color": "#1ea05a"})).unwrap();
let id = s.execute("edit.definePattern", json!({"name": "Green Tile"})).unwrap()["pattern"].as_str().unwrap().to_string();
s.sync_preset_store();
assert!(dir.files().contains(&PATTERNS_FILE.to_string()), "{:?}", dir.files());
// Only the user's pattern is in the file.
let bytes = std::fs::read(dir.0.join(PATTERNS_FILE)).unwrap();
let index: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
let saved: Vec<photocraft_doc::Pattern> = index["patterns"]
.as_array()
.unwrap()
.iter()
.map(|e| photocraft_io::pattern_map::read_pat(&std::fs::read(dir.0.join(e["file"].as_str().unwrap())).unwrap()).unwrap().remove(0))
.collect();
assert_eq!(saved.iter().map(|p| p.name.as_str()).collect::<Vec<_>>(), ["Green Tile"]);
drop(s);
let (mut t, w) = session(&dir);
assert!(w.is_empty(), "{w:?}");
assert_eq!(t.patterns.items.len(), builtin + 1);
let back = t.patterns.items.iter().find(|p| p.id == id).expect("the defined pattern is back after a restart");
assert_eq!((back.name.as_str(), back.width, back.height), ("Green Tile", 12, 10));
assert_eq!(back.surface, saved[0].surface, "with its pixels");
// Renames are kept; deleting the last user pattern removes the file.
t.execute("pattern.rename", json!({"pattern": id, "name": "Moss"})).unwrap();
t.sync_preset_store();
let (u, _) = session(&dir);
assert!(u.patterns.items.iter().any(|p| p.id == id && p.name == "Moss"));
t.execute("pattern.delete", json!({"pattern": id})).unwrap();
t.sync_preset_store();
assert!(
serde_json::from_slice::<serde_json::Value>(&std::fs::read(dir.0.join(PATTERNS_FILE)).unwrap()).unwrap()["patterns"].as_array().unwrap().is_empty(),
"empty authoritative index prevents resurrection"
);
}
#[test]
fn a_patterns_file_that_failed_to_load_is_not_overwritten() {
let mem = MemBackend::default();
let unreadable = b"not a pattern file".to_vec();
mem.files.lock().unwrap().insert(PATTERNS_FILE.into(), unreadable.clone());
let mut s = Session::new();
let w = s.attach_preset_store(open(Box::new(mem.clone())));
assert!(w.iter().any(|w| w.contains(PATTERNS_FILE)), "{w:?}");
s.execute("file.new", json!({"width": 4, "height": 4})).unwrap();
s.execute("edit.definePattern", json!({"name": "New"})).unwrap();
s.sync_preset_store();
assert_eq!(mem.files.lock().unwrap().get(PATTERNS_FILE), Some(&unreadable), "a patterns file the store could not read was overwritten");
assert!(!s.preset_store.as_mut().unwrap().take_warnings().is_empty());
}
/// A `.pat` of one 4×4 pattern with id `id`, filled with `rgba`.
fn pat_bytes(id: &str, rgba: [f32; 4]) -> String {
use photocraft_geom::Rect;
use photocraft_raster::Surface;
let mut surface = Surface::new(photocraft_color::PixelFormat::RGBA8);
surface.fill_rect(Rect::new(0, 0, 4, 4), &rgba);
let mut p = photocraft_doc::Pattern::new("Same", surface, 4, 4);
p.id = id.into();
photocraft_paint::tile::b64_encode(&photocraft_io::pattern_map::write_pat(&[p]).unwrap())
}
/// #9318 review: re-importing a pattern under the same id, name and size but with other pixels
/// (an edited `.pat`) is written, so a restart doesn't bring the old pixels back.
#[test]
fn a_same_id_pattern_replacement_survives_a_restart() {
let mem = MemBackend::default();
let mut s = Session::new();
s.attach_preset_store(open(Box::new(mem.clone())));
let id = "6f1c2c1e-0000-4000-8000-000000009318";
s.execute("pattern.import", json!({"data": pat_bytes(id, [1.0, 0.0, 0.0, 1.0])})).unwrap();
s.sync_preset_store();
s.execute("pattern.import", json!({"data": pat_bytes(id, [0.0, 0.0, 1.0, 1.0])})).unwrap();
s.sync_preset_store();
let mut t = Session::new();
t.attach_preset_store(open(Box::new(mem.clone())));
let back = t.patterns.items.iter().find(|p| p.id == id).expect("the pattern is back");
let want = s.patterns.items.iter().find(|p| p.id == id).unwrap();
assert_eq!(back.surface, want.surface, "with the replacement's pixels, not the first import's");
}
/// A [`MemBackend`] whose removals fail while `fail` is set.
#[derive(Clone, Default)]
struct FlakyRemove {
mem: MemBackend,
fail: std::sync::Arc<std::sync::atomic::AtomicBool>,
}
impl PresetBackend for FlakyRemove {
fn list(&self) -> Result<Vec<(String, u64)>, String> {
self.mem.list()
}
fn read(&self, name: &str, max: u64) -> Result<Vec<u8>, String> {
self.mem.read(name, max)
}
fn write(&self, name: &str, bytes: &[u8]) -> Result<(), String> {
self.mem.write(name, bytes)
}
fn remove(&self, name: &str) -> Result<(), String> {
if self.fail.load(std::sync::atomic::Ordering::SeqCst) {
return Err(format!("{name}: busy"));
}
self.mem.remove(name)
}
}
/// #9318 review: deleting the last user pattern while `patterns.pat` can't be removed is
/// warned and retried, so the deleted pattern doesn't come back after a restart.
#[test]
fn a_failed_patterns_removal_is_retried() {
let backend = FlakyRemove::default();
let mut s = Session::new();
s.attach_preset_store(open(Box::new(backend.clone())));
s.execute("file.new", json!({"width": 4, "height": 4})).unwrap();
let id = s.execute("edit.definePattern", json!({"name": "Gone"})).unwrap()["pattern"].as_str().unwrap().to_string();
s.sync_preset_store();
assert!(backend.mem.files.lock().unwrap().contains_key(PATTERNS_FILE));
backend.fail.store(true, std::sync::atomic::Ordering::SeqCst);
s.execute("pattern.delete", json!({"pattern": id})).unwrap();
s.sync_preset_store();
assert!(!s.preset_store.as_mut().unwrap().take_warnings().is_empty(), "the failure is warned");
backend.fail.store(false, std::sync::atomic::Ordering::SeqCst);
s.execute("file.new", json!({"width": 4, "height": 4})).unwrap();
s.sync_preset_store();
assert!(!backend.mem.files.lock().unwrap().keys().any(|f| f.starts_with("pattern-")), "owned asset removal is retried");
assert!(
serde_json::from_slice::<serde_json::Value>(backend.mem.files.lock().unwrap().get(PATTERNS_FILE).unwrap()).unwrap()["patterns"]
.as_array()
.unwrap()
.is_empty()
);
}
/// #9318 review: an imported `.pat` that replaces a built-in pattern's pixels (same id) is saved
/// and replaces the built-in after a restart, once; untouched built-ins are still never written.
#[test]
fn an_imported_builtin_replacement_survives_a_restart() {
let mem = MemBackend::default();
let mut s = Session::new();
s.attach_preset_store(open(Box::new(mem.clone())));
let builtin = s.patterns.items[0].id.clone();
s.execute("pattern.import", json!({"data": pat_bytes(&builtin, [0.9, 0.1, 0.4, 1.0])})).unwrap();
s.sync_preset_store();
let index: serde_json::Value = serde_json::from_slice(mem.files.lock().unwrap().get(PATTERNS_FILE).expect("written")).unwrap();
let saved: Vec<photocraft_doc::Pattern> = index["patterns"]
.as_array()
.unwrap()
.iter()
.map(|e| photocraft_io::pattern_map::read_pat(mem.files.lock().unwrap().get(e["file"].as_str().unwrap()).unwrap()).unwrap().remove(0))
.collect();
assert_eq!(saved.iter().map(|p| p.id.as_str()).collect::<Vec<_>>(), [builtin.as_str()], "only the replaced built-in");
let mut t = Session::new();
t.attach_preset_store(open(Box::new(mem.clone())));
let back: Vec<_> = t.patterns.items.iter().filter(|p| p.id == builtin).collect();
assert_eq!(back.len(), 1, "once");
let want = s.patterns.items.iter().find(|p| p.id == builtin).unwrap();
assert_eq!(back[0].surface, want.surface, "with the imported pixels");
}
/// #9318 review: a pattern imported before the store finished loading, with the id, name and
/// size of a saved one but other pixels, wins the merge and is written, so a restart keeps it.
#[test]
fn an_early_same_id_import_wins_and_is_saved() {
let mem = MemBackend::default();
let id = "6f1c2c1e-0000-4000-8000-00000000e4a1";
let mut s = Session::new();
s.attach_preset_store(open(Box::new(mem.clone())));
s.execute("pattern.import", json!({"data": pat_bytes(id, [1.0, 0.0, 0.0, 1.0])})).unwrap();
s.sync_preset_store();
// Next start: the same pattern with other pixels arrives before the store is attached.
let mut t = Session::new();
t.execute("pattern.import", json!({"data": pat_bytes(id, [0.0, 1.0, 0.0, 1.0])})).unwrap();
let early = t.patterns.items.iter().find(|p| p.id == id).unwrap().surface.clone();
t.attach_preset_store(open(Box::new(mem.clone())));
t.sync_preset_store();
let mut u = Session::new();
u.attach_preset_store(open(Box::new(mem.clone())));
assert_eq!(u.patterns.items.iter().find(|p| p.id == id).unwrap().surface, early, "the early import's pixels were saved");
}
#[derive(Clone)]
struct MigrationFail {
mem: MemBackend,
fail_name: String,
}
impl PresetBackend for MigrationFail {
fn list(&self) -> Result<Vec<(String, u64)>, String> {
self.mem.list()
}
fn read(&self, n: &str, m: u64) -> Result<Vec<u8>, String> {
self.mem.read(n, m)
}
fn write(&self, n: &str, b: &[u8]) -> Result<(), String> {
if n == self.fail_name { Err("injected migration write failure".into()) } else { self.mem.write(n, b) }
}
fn remove(&self, n: &str) -> Result<(), String> {
self.mem.remove(n)
}
}
fn legacy_store() -> (MemBackend, Vec<u8>, String) {
let mem = MemBackend::default();
let id = "6f1c2c1e-0000-4000-8000-000000005176".to_string();
let bytes = photocraft_paint::tile::b64_decode(&pat_bytes(&id, [0.2, 0.6, 0.8, 1.0])).unwrap();
mem.write(LEGACY_PATTERNS_FILE, &bytes).unwrap();
(mem, bytes, id)
}
#[test]
fn legacy_migration_commits_last_and_never_resurrects_renames_or_deletions() {
let (mem, old, id) = legacy_store();
let mut s = Session::new();
assert!(s.attach_preset_store(open(Box::new(mem.clone()))).is_empty());
assert!(mem.read(PATTERNS_FILE, 1 << 20).is_ok());
assert_eq!(mem.read(LEGACY_PATTERNS_FILE, MAX_PATTERNS_BYTES).unwrap(), old);
s.execute("pattern.rename", json!({"pattern":id,"name":"Migrated"})).unwrap();
s.sync_preset_store();
let mut t = Session::new();
t.attach_preset_store(open(Box::new(mem.clone())));
assert_eq!(t.patterns.items.iter().find(|p| p.id == id).unwrap().name, "Migrated");
t.execute("pattern.delete", json!({"pattern":id})).unwrap();
t.sync_preset_store();
for _ in 0..2 {
let mut u = Session::new();
u.attach_preset_store(open(Box::new(mem.clone())));
assert!(!u.patterns.items.iter().any(|p| p.id == id));
}
assert_eq!(mem.read(LEGACY_PATTERNS_FILE, MAX_PATTERNS_BYTES).unwrap(), old);
}
#[test]
fn interrupted_migration_preserves_legacy_and_reuses_only_identical_orphans() {
for fail_index in [false, true] {
let (mem, old, id) = legacy_store();
let file = patterns::file_name_for_test(&id);
let fail_name = if fail_index { PATTERNS_FILE.to_string() } else { file.clone() };
let opened = open(Box::new(MigrationFail { mem: mem.clone(), fail_name }));
assert!(!opened.warnings.is_empty());
assert!(opened.patterns.iter().any(|p| p.pattern.id == id), "legacy remains usable");
assert!(mem.read(PATTERNS_FILE, 1 << 20).is_err(), "no commit marker on failure");
assert_eq!(mem.read(LEGACY_PATTERNS_FILE, MAX_PATTERNS_BYTES).unwrap(), old);
let retry = open(Box::new(mem.clone()));
assert!(retry.warnings.is_empty(), "{:?}", retry.warnings);
assert!(retry.patterns.iter().any(|p| p.pattern.id == id));
}
let (mem, old, id) = legacy_store();
let file = patterns::file_name_for_test(&id);
mem.write(&file, b"unknown content").unwrap();
let opened = open(Box::new(mem.clone()));
assert!(!opened.warnings.is_empty());
assert_eq!(mem.read(&file, 100).unwrap(), b"unknown content");
assert!(mem.read(PATTERNS_FILE, 1 << 20).is_err());
assert_eq!(mem.read(LEGACY_PATTERNS_FILE, MAX_PATTERNS_BYTES).unwrap(), old);
}
#[test]
fn malformed_authoritative_index_never_falls_back_to_stale_legacy() {
let (mem, _, id) = legacy_store();
drop(open(Box::new(mem.clone())));
for bytes in [b"{".as_slice(), b"{\"version\":1,\"patterns\":[{\"id\":\"x\",\"name\":\"bad\",\"file\":\"../secret\"}]}".as_slice()] {
mem.write(PATTERNS_FILE, bytes).unwrap();
let opened = open(Box::new(mem.clone()));
assert!(!opened.warnings.is_empty());
assert!(opened.patterns.is_empty());
assert_eq!(mem.read(PATTERNS_FILE, 1 << 20).unwrap(), bytes);
assert!(!opened.patterns.iter().any(|p| p.pattern.id == id));
}
let mem = MemBackend::default();
mem.write(LEGACY_PATTERNS_FILE, b"broken PAT").unwrap();
let opened = open(Box::new(mem.clone()));
assert!(!opened.warnings.is_empty());
assert!(mem.read(PATTERNS_FILE, 1 << 20).is_err());
assert_eq!(mem.read(LEGACY_PATTERNS_FILE, 20).unwrap(), b"broken PAT");
}
#[test]
fn migration_preserves_duplicate_names_but_refuses_duplicate_ids() {
let (mem, _, id) = legacy_store();
let bytes = mem.read(LEGACY_PATTERNS_FILE, MAX_PATTERNS_BYTES).unwrap();
let mut pats = photocraft_io::pattern_map::read_pat(&bytes).unwrap();
let mut other = pats[0].clone();
other.id = "6f1c2c1e-0000-4000-8000-000000005177".into();
pats.push(other);
mem.write(LEGACY_PATTERNS_FILE, &photocraft_io::pattern_map::write_pat(&pats).unwrap()).unwrap();
let opened = open(Box::new(mem.clone()));
assert!(opened.warnings.is_empty());
assert_eq!(opened.patterns.len(), 2);
let mem = MemBackend::default();
pats[1].id = id;
let old = photocraft_io::pattern_map::write_pat(&pats).unwrap();
mem.write(LEGACY_PATTERNS_FILE, &old).unwrap();
let opened = open(Box::new(mem.clone()));
assert!(!opened.warnings.is_empty());
assert!(mem.read(PATTERNS_FILE, 1 << 20).is_err());
assert_eq!(mem.read(LEGACY_PATTERNS_FILE, MAX_PATTERNS_BYTES).unwrap(), old);
}
/// A symlink planted among the presets must not carry a managed write to its target: the
/// document writer follows links on purpose, the store confines itself to its directory.
#[cfg(unix)]
#[test]
fn a_symlinked_preset_entry_is_refused_not_written_through() {
let dir = TempDir::new("symlink");
std::fs::create_dir_all(&dir.0).unwrap();
let outside = dir.0.join("outside.txt");
std::fs::write(&outside, b"victim").unwrap();
std::os::unix::fs::symlink(&outside, dir.0.join("planted.json")).unwrap();
let be = DirBackend::new(&dir.0);
let e = be.write("planted.json", b"{}").unwrap_err();
assert!(e.contains("symbolic link"), "{e}");
assert_eq!(std::fs::read(&outside).unwrap(), b"victim");
be.write("fresh.json", b"{}").unwrap();
assert_eq!(be.read("fresh.json", 1024).unwrap(), b"{}");
}
#[test]
fn tip_adapter_matches_shared_codec_and_keeps_preview_limit() {
for t in [tip8(37, 21, 3), tip16(40, 33, 9)] {
let shared = craft_pcraft_tip::tip::encode(t.width, t.height, &t.data);
assert_eq!(encode_tip(&t), shared);
assert_eq!(decode_tip(&shared).unwrap(), t);
assert!(decode_tip_max(&shared, t.width - 1).is_err());
assert_eq!(decode_tip_max(&shared, t.width).unwrap(), t);
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.