* 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)
554 lines
28 KiB
Rust
554 lines
28 KiB
Rust
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,
|
||
}
|
||
}
|