a770fa5a5e5f
collections.rs
//! Drawing-collection contracts beyond model space. Assertions cover explicitly authored data,
//! not generated timestamps/extents, allocation seeds or extra implementation-owned objects.
//! Named tables are compared by identity; paper entities retain order and handles. These are
//! focused collection contracts, not a claim that every Drawing/session field is persistent.
use super::{
cases::{self, Case},
compare,
};
use cadcraft_color::Color;
use cadcraft_doc::{
Common, Drawing, EntityKind, Group, HVal, Layer, LayerState, Layout, Line, Linetype, NamedView, Space, TextStyle, Ucs, Viewport, VportConfig,
VportTile,
};
use cadcraft_geom::{Vec2, Vec3};
pub(super) fn foreign_records() -> Case {
use cadcraft_doc::{Handle, RawTag, foreign::ForeignObject};
let mut drawing = cases::drawing();
let foreign = std::sync::Arc::make_mut(&mut drawing.foreign);
foreign.dictionary.push(("SYNTHETIC_PAYLOAD".into(), Handle(0xA000)));
foreign.targets.insert(Handle(0xA001), ("NOD".into(), String::new()));
foreign.objects.push(ForeignObject {
handle: Handle(0xA000),
kind: "XRECORD".into(),
tags: [
(5, "A000"),
(330, "A001"),
(100, "AcDbXrecord"),
(280, "1"),
(1, "Original Ø payload"),
(90, "-7"),
(310, "00FF80"),
(10, "1.25"),
(20, "-2.5"),
(30, "3.75"),
]
.map(|(code, value)| RawTag { code, value: value.into() })
.into(),
});
drawing.handseed = 0xA100;
Case { name: "drawing/foreign-xrecord".into(), drawing }
}
pub(super) fn assert_foreign_records(a: &Drawing, b: &Drawing, context: &str) {
// Rereads may add implementation-owned dictionaries; this case owns one explicit key.
let key = "SYNTHETIC_PAYLOAD";
let (_, handle) = a.foreign.dictionary.iter().find(|(name, _)| name == key).expect("authored dictionary entry");
let (_, target) = b.foreign.dictionary.iter().find(|(name, _)| name == key).unwrap_or_else(|| panic!("{context}.dictionary[{key}]: missing key"));
let source = a.foreign.objects.iter().find(|o| o.handle == *handle).unwrap();
let back = b.foreign.objects.iter().find(|o| o.handle == *target).expect("dictionary target must resolve");
assert_eq!(back.kind, source.kind, "{context}.object.kind");
let owner = back.tags.iter().find(|t| t.code == 330).and_then(|t| cadcraft_doc::Handle::parse_hex(&t.value)).expect("XRECORD owner");
assert_eq!(b.foreign.targets.get(&owner), Some(&("NOD".into(), String::new())), "{context}.object.owner");
// Foreign's documented contract reallocates object handles and remaps references.
// Identity here is the NOD key and its resolved target, not the numeric allocation.
// Preserve every payload tag (including its order) after the subclass marker.
fn payload(tags: &[cadcraft_doc::RawTag]) -> &[cadcraft_doc::RawTag] {
let start =
tags.iter().position(|t| t.code == 100 && t.value == "AcDbXrecord").unwrap_or_else(|| panic!("missing XRECORD subclass: {tags:?}"));
&tags[start + 1..]
}
assert_eq!(payload(&back.tags), payload(&source.tags), "{context}.object.payload");
}
const HEADER_KEYS: &[&str] = &["LTSCALE", "CELTSCALE", "LUPREC", "AUPREC", "INSBASE", "TEXTSIZE", "CLAYER", "TEXTSTYLE"];
pub(super) fn headers() -> Case {
let mut drawing = cases::drawing();
drawing.header.set_f64("LTSCALE", 2.75);
drawing.header.set_f64("CELTSCALE", 0.125);
drawing.header.set_i64("LUPREC", 7);
drawing.header.set_i64("AUPREC", 3);
drawing.header.set("INSBASE", HVal::Point(Vec3::new(1.25, -2.5, 3.75)));
drawing.header.set_f64("TEXTSIZE", 3.25);
Case { name: "drawing/header-variables".into(), drawing }
}
pub(super) fn named_header_reference(key: &str) -> Case {
let mut case = headers();
case.name = format!("drawing/header-reference/{key}");
case.drawing.header.set_str(
key,
match key {
"CLAYER" => "Survey_Ä",
"TEXTSTYLE" => "Notes",
_ => panic!("unknown header reference"),
},
);
case
}
pub(super) fn assert_headers(a: &Drawing, b: &Drawing, context: &str) {
for key in HEADER_KEYS {
assert_eq!(b.header.get(key), a.header.get(key), "{context}.header.{key}");
}
}
pub(super) fn symbol_tables() -> Case {
let mut drawing = cases::drawing();
drawing.layers.push(Layer {
name: "UnusedLayer".into(),
color: Color::Index(5),
locked: true,
description: "Unused Ø".into(),
..Layer::default()
});
drawing.linetypes.push(Linetype::simple("UnusedDash", "Unused synthetic", &[3.0, -0.5, 0.0, -0.25]));
drawing.text_styles.push(TextStyle { name: "UnusedStyle".into(), font: "SyntheticSans.ttf".into(), width_factor: 1.25, ..TextStyle::default() });
Case { name: "drawing/unreferenced-tables".into(), drawing }
}
pub(super) fn assert_symbol_tables(a: &Drawing, b: &Drawing, context: &str) {
for layer in &a.layers {
assert_eq!(b.layer(&layer.name), Some(layer), "{context}.layer[{}]", layer.name);
}
for linetype in &a.linetypes {
assert_eq!(b.linetype(&linetype.name), Some(linetype), "{context}.linetype[{}]", linetype.name);
}
for style in &a.text_styles {
assert_eq!(b.text_style(&style.name), Some(style), "{context}.style[{}]", style.name);
}
}
pub(super) fn views_and_ucs() -> Case {
let mut drawing = cases::drawing();
drawing.views.push(NamedView { name: "SurveyView".into(), center: Vec2::new(1.25, -2.5), height: 25.0, width: 40.0, ..NamedView::default() });
drawing.ucss.push(Ucs {
name: "RotatedUCS".into(),
origin: Vec3::new(3.0, 4.0, 5.0),
x_axis: Vec3::new(0.0, 1.0, 0.0),
y_axis: Vec3::new(-1.0, 0.0, 0.0),
});
Case { name: "drawing/views-and-ucs".into(), drawing }
}
pub(super) fn assert_views_and_ucs(a: &Drawing, b: &Drawing, context: &str) {
assert_eq!(b.views, a.views, "{context}.views");
assert_eq!(b.ucss, a.ucss, "{context}.ucss");
}
pub(super) fn vports() -> Case {
let mut drawing = cases::drawing();
drawing.vports.push(VportConfig {
name: "Split".into(),
tiles: vec![
VportTile { min: Vec2::ZERO, max: Vec2::new(0.5, 1.0), center: Vec2::new(2.0, 3.0), height: 20.0, aspect: 0.75, twist: 0.0 },
VportTile { min: Vec2::new(0.5, 0.0), max: Vec2::new(1.0, 1.0), center: Vec2::new(7.0, 8.0), height: 30.0, aspect: 0.75, twist: 0.0 },
],
});
Case { name: "drawing/tiled-viewports".into(), drawing }
}
pub(super) fn assert_vports(a: &Drawing, b: &Drawing, context: &str) {
for viewport in &a.vports {
assert_eq!(b.vports.iter().find(|v| v.name == viewport.name), Some(viewport), "{context}.vport[{}]", viewport.name);
}
}
pub(super) fn groups() -> Case {
let mut case = cases::common_case("drawing/groups", Common::default());
let handles: Vec<_> = case.drawing.model.iter().map(|e| e.handle).collect();
case.drawing.groups.push(Group {
name: "Synthetic".into(),
description: "Ordered overlapping membership Ø".into(),
selectable: true,
members: vec![handles[2], handles[0]],
});
case.drawing.groups.push(Group { name: "Other".into(), description: String::new(), selectable: false, members: vec![handles[1], handles[2]] });
case
}
pub(super) fn assert_groups(a: &Drawing, b: &Drawing, context: &str) {
assert_eq!(b.groups.len(), a.groups.len(), "{context}.groups.len");
for group in &a.groups {
assert_eq!(b.groups.iter().find(|g| g.name == group.name), Some(group), "{context}.group[{}]", group.name);
}
}
pub(super) fn layer_states() -> Case {
let mut drawing = cases::drawing();
let mut layers = drawing.layers.clone();
for layer in &mut layers {
layer.on = false;
layer.locked = true;
}
drawing.layer_states.push(LayerState { name: "Saved".into(), layers });
Case { name: "drawing/layer-state".into(), drawing }
}
pub(super) fn assert_layer_states(a: &Drawing, b: &Drawing, context: &str) {
assert_eq!(b.layer_states, a.layer_states, "{context}.layer_states");
}
pub(super) fn layouts() -> Case {
let mut drawing = cases::drawing();
drawing.layouts = vec![Layout::new("Sheet_A", 1), Layout::new("Sheet_B", 2)];
for (index, layout) in drawing.layouts.iter_mut().enumerate() {
layout.page.paper_mm = true;
// PageSetup stores portrait dimensions; landscape is a separate orientation flag.
layout.page.width_mm = 297.0;
layout.page.height_mm = 420.0;
layout.page.scale = 0.5;
layout.page.plot_area = "window".into();
layout.page.plot_window = [1.0, 2.0, 201.0, 142.0];
layout.view = Some((Vec2::new(10.0, 20.0), 100.0 + index as f64));
}
drawing.active_layout = Some("Sheet_B".into());
for name in ["Sheet_A", "Sheet_B"] {
drawing.add(&Space::Paper(name.into()), Common::default(), EntityKind::Line(Line { a: Vec3::ZERO, b: Vec3::new(10.0, 20.0, 0.0) })).unwrap();
drawing
.add(
&Space::Paper(name.into()),
Common::default(),
EntityKind::Viewport(Viewport {
center: Vec3::new(50.0, 60.0, 0.0),
width: 80.0,
height: 50.0,
view_center: Vec2::new(5.0, 7.0),
view_height: 25.0,
id: 2,
locked: true,
frozen_layers: vec!["Survey_Ä".into()],
..Viewport::default()
}),
)
.unwrap();
}
Case { name: "drawing/layouts-and-paper-entities".into(), drawing }
}
#[test]
fn collection_assertions_reject_lost_authored_data() {
type Check = fn(&Drawing, &Drawing, &str);
type Mutate = fn(&mut Drawing);
let cases: [(Case, Check, Mutate); 6] = [
(headers(), assert_headers, |d| d.header.set_f64("TEXTSIZE", 9.0)),
(symbol_tables(), assert_symbol_tables, |d| d.layers.retain(|l| l.name != "UnusedLayer")),
(views_and_ucs(), assert_views_and_ucs, |d| d.ucss.clear()),
(groups(), assert_groups, |d| d.groups.first_mut().unwrap().members.reverse()),
(layouts(), assert_layouts, |d| d.layouts.first_mut().unwrap().page.scale = 2.0),
(foreign_records(), assert_foreign_records, |d| std::sync::Arc::make_mut(&mut d.foreign).objects.clear()),
];
for (case, verify, mutate) in cases {
verify(&case.drawing, &case.drawing, &case.name);
let mut changed = case.drawing.clone();
mutate(&mut changed);
assert!(std::panic::catch_unwind(|| verify(&case.drawing, &changed, &case.name)).is_err(), "{}: lost data must fail", case.name);
}
}
pub(super) fn assert_layouts(a: &Drawing, b: &Drawing, context: &str) {
assert_eq!(b.layouts.len(), a.layouts.len(), "{context}.layouts.len");
assert_eq!(b.active_layout, a.active_layout, "{context}.active_layout");
for layout in &a.layouts {
let back = b.layouts.iter().find(|l| l.name == layout.name).expect("layout must survive");
assert_eq!(back.tab_order, layout.tab_order, "{context}.{}.tab_order", layout.name);
// The groups 44, 45 and 73 the file stored are provenance, not a setting.
let setting = |p: &cadcraft_doc::PageSetup| cadcraft_doc::PageSetup { file_paper: None, ..p.clone() };
assert_eq!(setting(&back.page), setting(&layout.page), "{context}.{}.page", layout.name);
assert_eq!(back.view, layout.view, "{context}.{}.view", layout.name);
compare::entities(a, b, &layout.entities, &back.entities, &format!("{context}.layout[{}]", layout.name));
}
}
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.