Files
solidcraft/crates/doc/src/drawing_tests.rs
T
raykholo 8e6a107f6e Lists many PRs add to: no written lengths, one file per theme (#7747) (#7898)
* Lists many PRs add to: no written lengths, one file per theme (#7747)

* xtask lists: the fixed-table allowlist in order, each with its own reason

* Lists: the wide-character blocks and the drawing scale presets as slices too (#7747)

* Lists: the drawing units test reads UNITS as a slice (#7747)
2026-10-28 21:33:34 +00:00

554 lines
28 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use serde_json::json;
use solidcraft_geom::drawing_sheet::{Margins, Orientation, PaperSize, SheetSize};
use super::*;
/// The seed every test drawing's ids come from.
const SEED: u64 = 3890;
/// A profile of its own: ISO 5457's filing margin and trimming marks, which the built-in leaves off.
fn own_border() -> DrawingBorderProfile {
DrawingBorderProfile { filing_margin: true, trimming_mark_mm: Some([10.0, 5.0]), ..DrawingBorderProfile::iso() }
}
/// Three designs on two sheets: the first sheet (A3, the ISO border) documents component 7 of the
/// first design; the second (A4 portrait, a border of its own, 600 dpi, left out of printing)
/// documents the second design. The third design is on no sheet yet.
fn plate() -> Drawing {
let mut id_source = IdSource::seeded(SEED);
let a3 = drawing_sheet::Sheet::standard(PaperSize::A3, Orientation::Landscape);
let mut d = Drawing::new("Plate assembly", "en-GB", "Assembly", a3, Some(DrawingBorderProfile::iso()), &mut id_source).unwrap();
for path in ["plate.sc", "../parts/bolt.sc", "bracket.sc"] {
let id = d.allocate_id(&mut id_source).unwrap();
d.sources.push(Source { id, path: path.into() });
}
let (plate_id, bolt_id) = (d.sources[0].id, d.sources[1].id);
let id = d.allocate_id(&mut id_source).unwrap();
d.sheets.push(Arc::new(Sheet {
id,
name: "Bolt".into(),
sheet: drawing_sheet::Sheet::standard(PaperSize::A4, Orientation::Portrait),
border: Some(own_border()),
dpi: 600.0,
documents: Some(SheetComponent { source: bolt_id, component: 0 }),
excluded: Excluded { count: false, print: true },
}));
Arc::make_mut(&mut d.sheets[0]).documents = Some(SheetComponent { source: plate_id, component: 7 });
d.properties.set(crate::metadata::Owner::Design, "author", json!("Jane Doe")).unwrap();
d.units = Units::Fixed { unit: "in".into() };
d.validate().unwrap();
d
}
/// One A4 sheet that documents nothing, no sources: the base the caps grow from.
fn bare() -> Drawing {
let a4 = drawing_sheet::Sheet::standard(PaperSize::A4, Orientation::Landscape);
Drawing::new("Bare", "en", "Sheet", a4, None, &mut IdSource::seeded(SEED)).unwrap()
}
fn file(d: &Drawing) -> Value {
serde_json::from_str(&d.to_json().unwrap()).unwrap()
}
fn read(file: &Value) -> Result<Drawing> {
Drawing::from_json(&file.to_string())
}
/// Why `file` is refused, or "read".
fn refusal(file: &Value) -> String {
read(file).map_or_else(|e| e.to_string(), |_| "read".into())
}
/// Why `d`'s file, changed by `edit`, is refused, or "read".
fn refused(d: &Drawing, edit: impl FnOnce(&mut Value)) -> String {
let mut v = file(d);
edit(&mut v);
refusal(&v)
}
/// A drawing reads back as it was saved, and save, open and save again writes the same bytes, as
/// does another run from the same seed. The file holds each field under the record's name for it,
/// ids as their 13 characters, and no counter.
#[test]
fn a_drawing_reads_back_as_saved_and_saves_the_same_bytes_again() {
let d = plate();
let saved = d.to_json().unwrap();
let reopened = Drawing::from_json(&saved).unwrap();
assert_eq!(reopened, d);
assert_eq!(reopened.to_json().unwrap(), saved);
assert_eq!(plate().to_json().unwrap(), saved, "a seeded run makes the same drawing");
let v = file(&d);
let [plate_id, bolt_id, bracket_id] = [0, 1, 2].map(|i| ids::encode(d.sources[i].id));
let [assembly_id, bolt_sheet_id] = [0, 1].map(|i| ids::encode(d.sheets[i].id));
assert_eq!(assembly_id, "1ge30wkvq38r0", "the seed's first id, as splitmix64 gives it");
assert_eq!(v["format"], DRAWING.format_string(DRAWING.current()));
assert_eq!(v.get("format_pending").is_some(), !DRAWING.pending_names().is_empty());
assert_eq!(v.get("next_id"), None);
assert_eq!((&v["name"], &v["language"]), (&json!("Plate assembly"), &json!("en-GB")));
assert_eq!(
v["sources"],
json!([{"id": plate_id, "path": "plate.sc"}, {"id": bolt_id, "path": "../parts/bolt.sc"}, {"id": bracket_id, "path": "bracket.sc"}])
);
assert_eq!(v["properties"], json!({"author": "Jane Doe"}));
assert_eq!(v["units"], json!({"fixed": {"unit": "in"}}));
assert_eq!((&v["sheets"][0]["id"], &v["sheets"][0]["dpi"]), (&json!(assembly_id), &json!(300.0)));
assert_eq!(v["sheets"][0]["sheet"], json!({"size": {"standard": "a3"}, "orientation": "landscape"}));
assert_eq!(v["sheets"][0]["documents"], json!({"source": plate_id, "component": 7}));
assert_eq!(v["sheets"][0]["excluded"], json!({"count": false, "print": false}));
assert_eq!(
v["sheets"][1],
json!({
"id": bolt_sheet_id, "name": "Bolt", "sheet": {"size": {"standard": "a4"}, "orientation": "portrait"},
"border": serde_json::to_value(own_border()).unwrap(), "dpi": 600.0,
"documents": {"source": bolt_id, "component": 0}, "excluded": {"count": false, "print": true}
})
);
}
/// A hand-written file may leave out what has a default, and reads as a new drawing has it; the
/// rest is needed.
#[test]
fn a_file_may_leave_out_what_has_a_default() {
let minimal = json!({
"format": DRAWING.format_string(1),
"name": "Bracket",
"sources": [],
"language": "de",
"sheets": [{"id": "0000000000001", "name": "Blatt 1", "sheet": {"size": {"standard": "a3"}}}]
});
let d = read(&minimal).unwrap();
assert_eq!((d.sheets[0].id, &d.units, d.properties.is_empty()), (1, &Units::FollowModel, true));
let sheet = &d.sheets[0];
assert_eq!(sheet.sheet, drawing_sheet::Sheet::standard(PaperSize::A3, Orientation::Landscape));
assert_eq!((sheet.border, sheet.dpi, sheet.documents, sheet.excluded), (None, DEFAULT_DPI, None, Excluded::default()));
// The format as this build writes it, however the file spelt it.
let mut spelt = minimal.clone();
spelt["format"] = json!("solidcraft-drawing/+1");
assert_eq!(read(&spelt).unwrap().format, DRAWING.format_string(DRAWING.current()));
for key in ["name", "sources", "language", "sheets"] {
let mut v = minimal.clone();
v.as_object_mut().unwrap().remove(key);
let why = refusal(&v);
assert!(why.starts_with("damaged drawing: ") && why.contains(&format!("missing field `{key}`")), "{why}");
}
}
/// Every cap on both sides: sheets, sources, the bytes of paths and names (two-byte characters too).
#[test]
fn every_cap_holds_on_both_sides() {
let base = file(&bare());
let with = |key: &str, value: Value| {
let mut v = base.clone();
v[key] = value;
v
};
let sheet = base["sheets"][0].clone();
let sheets = |n: u64| {
let one = |id: u64| {
let mut s = sheet.clone();
s["id"] = json!(ids::encode(id));
s
};
Value::Array((1..=n).map(one).collect())
};
assert_eq!(read(&with("sheets", sheets(1000))).unwrap().sheets.len(), 1000);
for n in [0, 1001] {
assert_eq!(refusal(&with("sheets", sheets(n))), "damaged drawing: a drawing has 1 to 1000 sheets", "{n} sheets");
}
// Sources from id 1: the sheet's id is the seed's, far from them.
let sources = |n: u64| Value::Array((1..=n).map(|id| json!({"id": ids::encode(id), "path": format!("part{id}.sc")})).collect());
assert_eq!(read(&with("sources", sources(64))).unwrap().sources.len(), 64);
assert_eq!(refusal(&with("sources", sources(65))), "damaged drawing: a drawing draws at most 64 designs");
let path = |p: &str| refusal(&with("sources", json!([{"id": ids::encode(1), "path": p}])));
for fits in ["a".repeat(4096), "é".repeat(2048), "/".into()] {
assert_eq!(path(fits.as_str()), "read", "{} bytes", fits.len());
}
let rule = "damaged drawing: source 0000000000001: a design's path is 1 to 4096 bytes, without NUL";
for broken in ["a".repeat(4097), "é".repeat(2048) + "a", String::new(), "plate\0.sc".into()] {
assert_eq!(path(broken.as_str()), rule, "{} bytes", broken.len());
}
let names = |name: &str| {
let mut sheet_named = base.clone();
sheet_named["sheets"][0]["name"] = json!(name);
(refusal(&with("name", json!(name))), refusal(&sheet_named))
};
for fits in ["x".repeat(256), "é".repeat(128), "A".into(), "Blatt 1 – Übersicht".into()] {
assert_eq!(names(fits.as_str()), ("read".to_string(), "read".to_string()), "{} bytes", fits.len());
}
let rule = "name is 1 to 256 bytes, not only spaces, without control characters";
let sheet_id = ids::encode(bare().sheets[0].id);
for broken in ["x".repeat(257), "é".repeat(128) + "a", String::new(), " ".into(), "two\nlines".into(), "bell\u{7}".into(), "nul\0".into()] {
let expected = (format!("damaged drawing: the drawing's {rule}"), format!("damaged drawing: sheet {sheet_id}: its {rule}"));
assert_eq!(names(broken.as_str()), expected, "{broken:?}");
}
}
/// The content language is a well-formed BCP 47 tag of 2 to 35 characters.
#[test]
fn the_language_is_a_bcp_47_tag_of_2_to_35_characters() {
let base = file(&bare());
let why = |tag: &str| {
let mut v = base.clone();
v["language"] = json!(tag);
refusal(&v)
};
let longest = "en-abcdefgh-abcdefgh-abcdefgh-abcde";
assert_eq!(longest.len(), 35);
for tag in ["en", "de", "ast", "en-GB", "EN-gb", "zh-Hans-CN", "sr-Latn-RS", "es-419", longest] {
assert_eq!(why(tag), "read", "{tag}");
}
let rule = "damaged drawing: the language is not a BCP 47 tag of 2 to 35 characters (such as `en` or `en-GB`)";
let too_long = format!("{longest}f");
let broken =
["e", "", too_long.as_str(), "en_GB", "en-", "-en", "en--GB", "e1", "x-private", "en-abcdefghi", "abcdefghi", "日本", "en GB", "en\n"];
for tag in broken {
assert_eq!(why(tag), rule, "{tag:?}");
}
}
/// A fixed unit is a length unit of the expression unit table, written as the table writes it.
#[test]
fn a_fixed_unit_is_a_length_unit_of_the_expression_table() {
let base = file(&bare());
let units = |units: Value| {
let mut v = base.clone();
v["units"] = units;
read(&v).map(|d| d.units)
};
for (unit, kind, _) in expr::UNITS {
assert_eq!(units(json!({"fixed": {"unit": unit}})).is_ok(), *kind == expr::Kind::Length, "{unit}");
}
assert_eq!(units(json!({"fixed": {"unit": "in"}})).unwrap(), Units::Fixed { unit: "in".into() });
assert_eq!(units(json!("follow_model")).unwrap(), Units::FollowModel);
let rule = "damaged drawing: the drawing's unit is not a length unit (such as `mm` or `in`)";
for unit in ["furlong", "deg", "°", "none", "", " in", "in ", "IN"] {
assert_eq!(units(json!({"fixed": {"unit": unit}})).unwrap_err().to_string(), rule, "{unit:?}");
}
for broken in [json!("follow_design"), json!({"fixed": "in"}), json!({"fixed": {}}), json!(null)] {
assert!(units(broken.clone()).is_err(), "{broken}");
}
}
/// A sheet's border is saved as a copy of its profile, field by field, and read back as saved, so
/// a later built-in never changes it; a profile's name in its place is refused.
#[test]
fn a_border_is_saved_as_a_copy_of_its_profile() {
let v = file(&plate());
assert_eq!(v["sheets"][0]["border"], serde_json::to_value(DrawingBorderProfile::iso()).unwrap());
assert_eq!(v["sheets"][1]["border"], serde_json::to_value(own_border()).unwrap());
assert_eq!(read(&v).unwrap().sheets[1].border, Some(own_border()));
let mut edited = v.clone();
edited["sheets"][0]["border"]["margins"]["left_mm"] = json!(15.0);
let iso = DrawingBorderProfile::iso();
let wider = DrawingBorderProfile { margins: Margins { left_mm: 15.0, ..iso.margins }, ..iso };
assert_eq!(read(&edited).unwrap().sheets[0].border, Some(wider));
edited["sheets"][0]["border"] = json!("iso");
assert!(refusal(&edited).starts_with("damaged drawing: "));
edited["sheets"][0]["border"] = Value::Null;
assert_eq!(read(&edited).unwrap().sheets[0].border, None, "no drawing border");
}
/// What reading refuses: each damage the rules name, refused rather than patched, and files this
/// build can't read.
#[test]
fn damaged_files_are_refused_and_never_patched() {
let d = plate();
let plate_id = ids::encode(d.sources[0].id);
let [assembly_id, bolt_sheet_id] = [0, 1].map(|i| ids::encode(d.sheets[i].id));
// Two objects with one id, of one kind and of two kinds.
assert_eq!(refused(&d, |v| v["sources"][1]["id"] = json!(plate_id)), format!("damaged drawing: two objects have the id {plate_id}"));
assert_eq!(refused(&d, |v| v["sheets"][1]["id"] = json!(assembly_id)), format!("damaged drawing: two objects have the id {assembly_id}"));
assert_eq!(refused(&d, |v| v["sources"][2]["id"] = json!(bolt_sheet_id)), format!("damaged drawing: two objects have the id {bolt_sheet_id}"));
// An id that isn't one, where an object has it and where a reference names it; no number form,
// and no counter.
let not_an_id = "damaged drawing: an id is 13 characters of lowercase Crockford base32, not all 0";
for text in ["0000000000000", "FZZZZZZZZZZZZ", "000000000001", "0000000000001 ", "000000000000o", "g000000000000"] {
assert_eq!(refused(&d, |v| v["sources"][2]["id"] = json!(text)), not_an_id, "{text:?}");
assert_eq!(refused(&d, |v| v["sheets"][1]["documents"]["source"] = json!(text)), not_an_id, "{text:?}");
}
assert!(refused(&d, |v| v["sources"][2]["id"] = json!(5)).starts_with("damaged drawing: invalid type"));
assert!(refused(&d, |v| v["next_id"] = json!(6)).contains("unknown field `next_id`"));
let mut in_memory = d.clone();
in_memory.sources[2].id = 0;
assert_eq!(in_memory.validate().unwrap_err().to_string(), "an object has the id 0, which is never one");
// A reference to nothing, or to an object of another kind; a source a sheet documents removed.
for missing in [ids::encode(99), assembly_id.clone()] {
let expected = format!("damaged drawing: sheet {bolt_sheet_id}: it documents source {missing}, which the drawing doesn't have");
assert_eq!(refused(&d, |v| v["sheets"][1]["documents"]["source"] = json!(missing)), expected);
}
let without_plate = refused(&d, |v| {
v["sources"].as_array_mut().unwrap().remove(0);
});
assert_eq!(without_plate, format!("damaged drawing: sheet {assembly_id}: it documents source {plate_id}, which the drawing doesn't have"));
// The paper, its border and its resolution, through the sheet's own rules.
let custom = |sides: Value| refused(&d, |v| v["sheets"][0]["sheet"]["size"] = json!({"custom": {"sides_mm": sides}}));
assert_eq!(custom(json!([5000.0, 0.5])), "read");
for sides in [json!([5000.1, 100.0]), json!([0.0, 100.0]), json!([-1.0, 100.0])] {
let expected = format!("damaged drawing: sheet {assembly_id}: drawing sheet: a custom side is finite, above 0 and at most 5000 mm");
assert_eq!(custom(sides), expected);
}
let why = custom(json!([1e10, 100.0]));
assert!(why.starts_with("damaged drawing: the number ") && why.ends_with(" is out of range"), "checked before the record: {why}");
let nan = d.to_json().unwrap().replacen("600.0", "NaN", 1);
assert!(Drawing::from_json(&nan).unwrap_err().to_string().starts_with("not a SolidCraft drawing: "), "NaN isn't JSON");
assert_eq!(
refused(&d, |v| v["sheets"][1]["border"]["margins"]["top_mm"] = json!(-1.0)),
format!("damaged drawing: sheet {bolt_sheet_id}: drawing sheet: a margin is finite and 0 to 5000 mm")
);
for dpi in [25.0, 2400.0] {
assert_eq!(refused(&d, |v| v["sheets"][1]["dpi"] = json!(dpi)), "read", "{dpi}");
}
for dpi in [24.9, 2400.1, 0.0, -300.0] {
let expected = format!("damaged drawing: sheet {bolt_sheet_id}: its pictures are 25 to 2400 dpi");
assert_eq!(refused(&d, |v| v["sheets"][1]["dpi"] = json!(dpi)), expected, "{dpi}");
}
// In memory, where NaN can be, the same rules.
let mut in_memory = plate();
Arc::make_mut(&mut in_memory.sheets[1]).dpi = f64::NAN;
assert_eq!(in_memory.validate().unwrap_err().to_string(), format!("sheet {bolt_sheet_id}: its pictures are 25 to 2400 dpi"));
let sheet = Arc::make_mut(&mut in_memory.sheets[1]);
sheet.dpi = DEFAULT_DPI;
sheet.sheet.size = SheetSize::Custom { sides_mm: [f64::NAN, 100.0] };
assert!(in_memory.validate().unwrap_err().to_string().starts_with(&format!("sheet {bolt_sheet_id}: drawing sheet: a custom side")));
// An unknown field anywhere.
let unknown: [fn(&mut Value); 8] = [
|v| v["views"] = json!([]),
|v| v["sources"][0]["name"] = json!("Plate"),
|v| v["sheets"][0]["scale"] = json!(1),
|v| v["sheets"][0]["sheet"]["colour"] = json!("white"),
|v| v["sheets"][0]["border"]["style"] = json!("iso"),
|v| v["sheets"][0]["documents"]["view"] = json!(1),
|v| v["sheets"][0]["excluded"]["export"] = json!(true),
|v| v["units"]["fixed"]["precision"] = json!(2),
];
for (i, edit) in unknown.into_iter().enumerate() {
let why = refused(&d, edit);
assert!(why.starts_with("damaged drawing: ") && why.contains("unknown field"), "{i}: {why}");
}
// A newer build's file is refused as one before anything in it is read: a field this build
// doesn't know, or a number out of its range.
let (current, newer) = (DRAWING.current(), DRAWING.current() + 1);
let why = refused(&d, |v| {
v["format"] = json!(DRAWING.format_string(newer));
v["views"] = json!([]);
v["sheets"][0]["dpi"] = json!(1e10);
});
assert_eq!(
why,
format!(
"this drawing was saved by a newer SolidCraft (file format {newer}; this version reads formats up to {current}): update SolidCraft to open it"
)
);
// A list of pending changes means nothing beside a format made of none; beside the pending
// number, a change this build doesn't know is a newer build's.
let why = refused(&d, |v| v["format_pending"] = json!(["a-later-change"]));
if DRAWING.pending_names().is_empty() {
assert_eq!(why, "read");
} else {
assert!(why.contains("newer SolidCraft"), "{why}");
}
// A design is never read as a drawing, nor a drawing as a design.
let design = crate::Document::new("Plate").to_json();
let design_format = crate::format::format_string(crate::format::FORMAT);
assert_eq!(Drawing::from_json(&design).unwrap_err().to_string(), format!("not a SolidCraft drawing (format `{design_format}`)"));
let drawing_format = DRAWING.format_string(current);
assert_eq!(
crate::Document::from_json(&d.to_json().unwrap()).unwrap_err().to_string(),
format!("not a SolidCraft design (format `{drawing_format}`)")
);
// Not an object, not JSON, nested too deeply, too large.
assert_eq!(Drawing::from_json("[]").unwrap_err().to_string(), "not a SolidCraft drawing (expected a JSON object)");
assert!(Drawing::from_json("").unwrap_err().to_string().starts_with("not a SolidCraft drawing: "));
let deep: Value = serde_json::from_str(&format!("{}1{}", "[".repeat(100), "]".repeat(100))).unwrap();
assert_eq!(refused(&d, |v| v["views"] = deep), "damaged drawing: nested too deeply");
let deeper = format!("{{\"format\": \"{drawing_format}\", \"views\": {}1{}}}", "[".repeat(200), "]".repeat(200));
assert!(Drawing::from_json(&deeper).unwrap_err().to_string().starts_with("not a SolidCraft drawing: "));
let text = d.to_json().unwrap();
let at_cap = text.clone() + &" ".repeat(MAX_DRAWING_BYTES - text.len());
assert_eq!(Drawing::from_json(&at_cap).unwrap(), d);
assert_eq!(Drawing::from_json(&(at_cap + " ")).unwrap_err().to_string(), "drawing too large (at most 16 MiB)");
}
/// A run never gives an id twice: not one in use, and not a removed object's. Only another run from
/// the same seed, which tests and replays start from the same file, can give a removed id again.
#[test]
fn a_run_never_gives_an_id_twice() {
let mut id_source = IdSource::seeded(SEED);
let a4 = drawing_sheet::Sheet::standard(PaperSize::A4, Orientation::Landscape);
let mut d = Drawing::new("Ids", "en", "Sheet", a4, None, &mut id_source).unwrap();
let mut given = BTreeSet::from([d.sheets[0].id]);
for _ in 0..MAX_SOURCES {
let id = d.allocate_id(&mut id_source).unwrap();
d.sources.push(Source { id, path: "part.sc".into() });
assert!(given.insert(id), "{id:#x} given twice");
}
let removed = d.sources.pop().unwrap().id;
for _ in 0..10_000 {
let id = d.allocate_id(&mut id_source).unwrap();
assert!(id != removed && given.insert(id), "{id:#x} given twice");
}
// The same seed, from the start, over a file it made: every draw up to the removed id is in use.
let reopened = Drawing::from_json(&d.to_json().unwrap()).unwrap();
let again = reopened.allocate_id(&mut IdSource::seeded(SEED)).unwrap();
assert!(!reopened.ids().any(|id| id == again));
assert_eq!(again, removed);
}
/// Properties follow the design metadata's rules: other tools' data and a well-known key of another
/// kind are kept as they are, never read as numbers, while the same number elsewhere is refused.
#[test]
fn properties_are_kept_as_they_are() {
let mut v = file(&plate());
v["properties"]["com.example.pdm"] = json!({"huge": 1e300, "ids": [1, 2, 3]});
v["properties"]["revision"] = json!(3);
let d = read(&v).unwrap();
assert_eq!(d.properties.get("com.example.pdm"), Some(&json!({"huge": 1e300, "ids": [1, 2, 3]})));
assert_eq!((d.properties.revision(), d.properties.get("revision")), (None, Some(&json!(3))));
assert_eq!(read(&file(&d)).unwrap(), d);
v["sheets"][0]["dpi"] = json!(1e300);
let why = refusal(&v);
assert!(why.starts_with("damaged drawing: the number ") && why.ends_with(" is out of range"), "{why}");
}
/// A drawing whose JSON would be over the read limit isn't saved. Other tools' properties are kept
/// as they came, and indenting them can grow a file read in under the limit past it, so the save
/// refuses rather than write a file that won't open: every drawing saved opens again.
#[test]
fn a_drawing_too_large_to_reopen_is_not_saved() {
let file = |zeros: usize| {
let items = vec!["0"; zeros].join(",");
let sheet = r#"{"id":"0000000000001","name":"S","sheet":{"size":{"standard":"a4"}}}"#;
let format = DRAWING.format_string(1);
format!(
r#"{{"format":"{format}","name":"A","sources":[],"language":"en","sheets":[{sheet}],"properties":{{"com.example":{{"items":[{items}]}}}}}}"#
)
};
// The case found in review (#3891): 2,000,000 zeros read in at about 4 MB and indent past 16 MiB.
let big = Drawing::from_json(&file(2_000_000)).unwrap();
assert_eq!(big.to_json().unwrap_err().to_string(), "drawing too large to save (at most 16 MiB)");
let small = Drawing::from_json(&file(100_000)).unwrap();
assert_eq!(Drawing::from_json(&small.to_json().unwrap()).unwrap(), small);
}
/// A new drawing has one sheet, its id the source's first, follows its designs' units and renders
/// pictures at 300 dpi; a name, language or border that breaks the rules is refused.
#[test]
fn a_new_drawing_has_one_sheet_and_keeps_the_rules() {
let d = bare();
let first = IdSource::seeded(SEED).next(&BTreeSet::new()).unwrap();
assert_eq!((d.sheets.len(), d.sheets[0].id, d.sheets[0].dpi, &d.units), (1, first, DEFAULT_DPI, &Units::FollowModel));
assert_eq!((d.format, d.format_pending), (DRAWING.format_string(DRAWING.current()), DRAWING.pending_names()));
let a4 = drawing_sheet::Sheet::standard(PaperSize::A4, Orientation::Landscape);
let thin = DrawingBorderProfile { drawing_border_line_mm: 0.0, ..DrawingBorderProfile::iso() };
let broken = [("", "en", "Sheet", None), ("Bare", "en_GB", "Sheet", None), ("Bare", "en", "\n", None), ("Bare", "en", "Sheet", Some(thin))];
for (name, language, sheet, border) in broken {
let made = Drawing::new(name, language, sheet, a4, border, &mut IdSource::seeded(SEED));
assert!(made.is_err(), "{name:?} {language:?} {sheet:?} {border:?}");
}
}
/// Hostile input never panics: a valid file's text cut, overwritten and given lies, and its JSON
/// values replaced, repeated and dropped. Each read gives an error, or a drawing that keeps the
/// rules and reads back as it saves.
#[test]
fn mutated_files_give_an_error_or_a_valid_drawing_never_a_panic() {
let good = plate().to_json().unwrap();
let tree: Value = serde_json::from_str(&good).unwrap();
let nodes = count(&tree) as u64;
let lies = [
json!(null),
json!(0),
json!(-1),
json!(1),
json!(1e10),
json!(u64::MAX),
json!(""),
json!("x".repeat(300)),
json!("0000000000000"),
json!("0000000000001"),
json!("fzzzzzzzzzzzz"),
json!("FZZZZZZZZZZZZ"),
json!([]),
json!({}),
json!(true),
json!("follow_model"),
json!({"fixed": {"unit": "deg"}}),
];
let words = ["NaN", "1e400", "-0", "18446744073709551616", "\"", "{", "]", ",", "null", "\u{0}", "é", "o", "I"];
let mut seed: u64 = 0x9e37_79b9_7f4a_7c15;
let mut rnd = move || {
seed ^= seed << 13;
seed ^= seed >> 7;
seed ^= seed << 17;
seed
};
let mut read_back = 0;
for i in 0..10_000 {
let text = if i % 2 == 0 {
let mut v = tree.clone();
let lie = &lies[(rnd() % lies.len() as u64) as usize];
mutate(&mut v, &mut ((rnd() % nodes) as usize), lie, rnd() % 3);
v.to_string()
} else {
let mut s = good.clone().into_bytes();
for _ in 0..1 + rnd() % 3 {
// A run of up to 15 bytes taken out, overwritten by one byte or replaced by a lie.
let at = (rnd() % (s.len() as u64 + 1)) as usize;
let cut = ((rnd() % 16) as usize).min(s.len() - at);
let byte = [(rnd() >> 56) as u8];
let put: &[u8] = match rnd() % 3 {
0 => &[],
1 => &byte,
_ => words[(rnd() % words.len() as u64) as usize].as_bytes(),
};
let next = [&s[..at], put, &s[at + cut..]].concat();
s = next;
if rnd() % 8 == 0 {
s.truncate(at);
}
}
String::from_utf8_lossy(&s).into_owned()
};
if let Ok(d) = Drawing::from_json(&text) {
assert!(d.validate().is_ok() && d.ids().all(|id| id != 0), "{text}");
assert_eq!(Drawing::from_json(&d.to_json().unwrap()).unwrap(), d, "{text}");
read_back += 1;
}
}
assert!(read_back > 50, "only {read_back} mutated files read: the mutations hardly reach the record's rules");
}
/// The number of values in `v`, itself included.
fn count(v: &Value) -> usize {
1 + match v {
Value::Array(a) => a.iter().map(count).sum::<usize>(),
Value::Object(o) => o.values().map(count).sum(),
_ => 0,
}
}
/// Change the `pick`th value of `v`, depth first: `how` 1 repeats a list's first element (two
/// objects with one id), 2 drops an object's first field, and otherwise `lie` takes its place.
fn mutate(v: &mut Value, pick: &mut usize, lie: &Value, how: u64) -> bool {
if *pick == 0 {
match (v, how) {
(Value::Array(a), 1) if !a.is_empty() => {
let first = a[0].clone();
a.push(first);
}
(Value::Object(o), 2) if !o.is_empty() => {
let key = o.keys().next().cloned().unwrap_or_default();
o.remove(&key);
}
(v, _) => *v = lie.clone(),
}
return true;
}
*pick -= 1;
match v {
Value::Array(a) => a.iter_mut().any(|x| mutate(x, pick, lie, how)),
Value::Object(o) => o.values_mut().any(|x| mutate(x, pick, lie, how)),
_ => false,
}
}