Files
vectorcraft/crates/cdr/tests/it/read.rs
T
dotCooCoo 5c28beca75 CDR import: a fill or outline whose record is missing is damage
A shape that names a fill or outline id no record has comes in without that paint and with the damage warning, so the open counts as lossy. Id 0 without a record stays no paint.
2026-11-14 17:40:04 -08:00

2164 lines
112 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.
//! Reading synthetic drawings of every version the reader takes, plain and compressed, and
//! hostile files.
use proptest::prelude::*;
use vectorcraft_cdr::model::{Blend, Cap, Color, Flags, Geometry, Join, LayerKind, Matrix, Object, Segment};
use vectorcraft_cdr::synth::{self, V, chunk, list};
use vectorcraft_cdr::{Error, Limits, Warning, read};
fn shapes(objects: &[Object]) -> Vec<&vectorcraft_cdr::model::Shape> {
let mut out = Vec::new();
let mut stack: Vec<&Object> = objects.iter().rev().collect();
while let Some(o) = stack.pop() {
match o {
Object::Shape(s) => out.push(&**s),
Object::Group { objects: kids, .. } => stack.extend(kids.iter().rev()),
Object::Clip { container, objects } => {
out.push(&**container);
stack.extend(objects.iter().rev());
}
}
}
out
}
/// The page and layers of the sample of `version`.
fn check_pages(d: &vectorcraft_cdr::Drawing, version: u16) {
assert_eq!(d.version, version);
let (w, h) = d.page_size.unwrap();
assert!((w - 612.0).abs() < 0.1 && (h - 792.0).abs() < 0.1, "{version}: {w} {h}");
assert_eq!(d.pages.len(), 1, "{version}");
let art = &d.pages[0].layers[0];
assert_eq!((art.name.as_str(), art.kind), ("Art", LayerKind::Drawing));
assert!(matches!(art.objects[3], Object::Group { objects: ref g, .. } if g.len() == 2));
assert!(d.warnings.contains(&Warning::UnsupportedObjects));
// The master page: its guideline every page shows, and its desktop object.
if version >= 600 {
assert_eq!(d.guides.len(), 1);
assert!((d.guides[0].angle - 90.0).abs() < 1e-9 && (d.guides[0].at.x - 36.0).abs() < 0.01);
}
assert_eq!(d.master.len(), 1);
assert_eq!(d.master[0].kind, LayerKind::Desktop);
}
/// The shapes of the sample of `version`: rectangle, ellipse, curve, and the group's polygon and
/// arc; the text is left out.
fn check_shapes(d: &vectorcraft_cdr::Drawing, version: u16) {
let s = shapes(&d.pages[0].layers[0].objects);
assert_eq!(s.len(), 5, "{version}");
assert!(matches!(s[0].geometry, Geometry::Rect { radii, .. } if radii.iter().all(|r| (r - 5.0).abs() < 0.1)));
// The samples of versions 3 and 4 store their red as CMYK in percent.
let red = if version < 500 { Color::Cmyk([0.0, 1.0, 1.0, 0.0]) } else { Color::Rgb([1.0, 0.0, 0.0]) };
assert_eq!(s[0].fill, Some(red), "{version}");
let o = s[0].outline.as_ref().unwrap();
assert!((o.width - 2.0).abs() < 0.05 && o.cap == Cap::Round, "{version}: {o:?}");
assert!((s[0].matrix.0[4] + 100.0).abs() < 0.1 && (s[0].matrix.0[5] - 100.0).abs() < 0.1);
assert!(matches!(s[1].geometry, Geometry::Ellipse { .. }) && s[1].outline.is_none());
assert!(matches!(&s[2].geometry, Geometry::Path(p) if p.subpaths[0].closed && matches!(p.subpaths[0].segments[1], Segment::Cubic(..))));
assert!(s[2].fill.is_none());
if version >= 600 {
let Geometry::Path(p) = &s[3].geometry else { panic!("polygon") };
assert_eq!(p.subpaths[0].segments.len(), 10, "five sides of two segments");
// 5 % of 1000 mm.
let r = p.subpaths[0].start.y;
assert!((r - 0.05 * synth::POLYGON_SIDE).abs() < 0.5, "{r}");
}
assert!(matches!(&s[4].geometry, Geometry::Path(p) if p.subpaths[0].closed));
}
#[test]
fn every_version_from_5_to_13_reads_its_sample() {
for version in [500, 600, 700, 800, 900, 1000, 1100, 1200, 1300] {
for compress in [false, version >= 700] {
let d = read(&synth::sample(version, compress), Limits::default()).unwrap_or_else(|e| panic!("{version} {compress}: {e}"));
check_pages(&d, version);
check_shapes(&d, version);
}
}
}
#[test]
fn versions_3_and_4_read_their_sample() {
for version in [300, 400] {
let file = synth::sample(version, false);
assert_eq!(&file[8..12], if version == 300 { b"CDR " } else { b"CDR4" });
assert!(vectorcraft_cdr::is_cdr(&file));
let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}"));
assert!(!d.warnings.contains(&Warning::Damaged), "{version}: {:?}", d.warnings);
check_pages(&d, version);
check_shapes(&d, version);
let s = shapes(&d.pages[0].layers[0].objects);
let o = s[0].outline.as_ref().unwrap();
assert_eq!((o.join, &o.color), (Join::Round, &Color::Cmyk([0.0, 0.0, 0.0, 1.0])), "{version}");
// The ellipse 50 pt right of and below the page centre, and the curve where it was drawn.
assert!((s[1].matrix.0[4] - 50.0).abs() < 0.1 && (s[1].matrix.0[5] + 50.0).abs() < 0.1, "{version}: {:?}", s[1].matrix);
assert_eq!(s[2].matrix, Matrix::IDENTITY, "{version}");
}
// The form type alone names version 3, and a `vrsn` chunk names it under another form type.
let mut plain = vec![];
plain.extend(synth::sample_content(300));
check_shapes(&read(&synth::riff(300, &plain), Limits::default()).unwrap(), 300);
let mut relabeled = synth::sample(300, false);
relabeled[11] = b'5';
assert_eq!(read(&relabeled, Limits::default()).unwrap().version, 300);
}
/// A version 3 drawing of one layer holding `objects`.
fn drawing3(objects: Vec<synth::Node>) -> Vec<u8> {
let page = synth::page(false, vec![synth::layer(V(300), [0, 0, 0, 0x98], "L", objects)]);
synth::riff(300, &[chunk(b"vrsn", 300u16.to_le_bytes().to_vec()), page])
}
/// A version 3 rectangle of 10 × 10 pt with the transforms `matrices`.
fn rect3(matrices: &[[f64; 6]]) -> synth::Node {
let v = V(300);
let mut args = vec![(30, v.rect(10.0, 10.0, 0.0))];
if !matrices.is_empty() {
args.push((100, synth::transforms3(matrices)));
}
synth::object(v, 1, &args, None)
}
#[test]
fn version_3_groups_place_their_objects() {
let shift = |x: f64, y: f64| [1.0, 0.0, 0.0, 1.0, x, y];
let double = [2.0, 0.0, 0.0, 2.0, 0.0, 0.0];
// A rectangle moved 72 pt right, in a group that doubles sizes, in a group that moves 36 pt
// up; beside the inner group, a rectangle of the outer group alone; then one outside both.
let inner = synth::group3(&[double], vec![rect3(&[shift(72.0, 0.0)])]);
let outer = synth::group3(&[shift(0.0, 36.0)], vec![inner, rect3(&[])]);
let d = read(&drawing3(vec![outer, rect3(&[shift(7.2, 0.0)])]), Limits::default()).unwrap();
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
let objects = &d.pages[0].layers[0].objects;
assert!(
matches!(&objects[0], Object::Group { objects: g, .. } if matches!(&g[0], Object::Group { objects: i, .. } if i.len() == 1) && g.len() == 2)
);
let s = shapes(objects);
let close = |m: &Matrix, want: [f64; 6]| m.0.iter().zip(want).all(|(a, b)| (a - b).abs() < 0.01);
// Its own shift, then the inner group's scale, then the outer group's shift.
assert!(close(&s[0].matrix, [2.0, 0.0, 0.0, 2.0, 144.0, 36.0]), "{:?}", s[0].matrix);
assert!(close(&s[1].matrix, [1.0, 0.0, 0.0, 1.0, 0.0, 36.0]), "{:?}", s[1].matrix);
assert!(close(&s[2].matrix, [1.0, 0.0, 0.0, 1.0, 7.2, 0.0]), "{:?}", s[2].matrix);
// Two matrices of one object apply in file order.
let d = read(&drawing3(vec![rect3(&[shift(72.0, 0.0), double])]), Limits::default()).unwrap();
assert!(close(&shapes(&d.pages[0].layers[0].objects)[0].matrix, [2.0, 0.0, 0.0, 2.0, 144.0, 0.0]));
}
#[test]
fn version_3_objects_and_groups_under_an_envelope_keep_their_outlines_and_matrices() {
// A transforms argument of one envelope entry (type 0x14).
let mut envelope = vec![0, 0, 1, 0, 0x14, 0];
envelope.resize(14 + 24, 0);
// A matrix that moves 72 pt right, then an envelope entry whose data follows the matrix's.
let matrix = synth::transforms3(&[[1.0, 0.0, 0.0, 1.0, 72.0, 0.0]]).split_off(14);
let mut shifted = vec![0, 0, 2, 0, 0x8c, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0x14, 0, 0, 0, 0, 0, 48, 0, 0, 0];
shifted.extend(matrix);
shifted.resize(48 + 24, 0);
let v = V(300);
let bent = synth::object(v, 1, &[(30, v.rect(10.0, 10.0, 0.0)), (100, envelope.clone())], None);
let moved = synth::object(v, 1, &[(30, v.rect(10.0, 10.0, 0.0)), (100, shifted)], None);
let group = list(b"grp ", vec![chunk(b"lobj", v.loda(0, &[(100, envelope)])), rect3(&[])]);
let d = read(&drawing3(vec![bent, moved, group, rect3(&[])]), Limits::default()).unwrap();
let objects = &d.pages[0].layers[0].objects;
assert_eq!(objects.len(), 4);
assert!(matches!(&objects[2], Object::Group { objects: g, .. } if g.len() == 1));
let s = shapes(objects);
assert_eq!(s.len(), 4);
assert!(matches!(s[0].geometry, Geometry::Rect { .. }) && s[0].matrix == Matrix::IDENTITY);
assert!((s[1].matrix.0[4] - 72.0).abs() < 0.01 && s[1].matrix.0[5].abs() < 0.01, "{:?}", s[1].matrix);
assert_eq!(s[2].matrix, Matrix::IDENTITY);
assert_eq!(d.warnings, vec![Warning::Envelopes]);
}
#[test]
fn version_3_object_types_count_from_0() {
let v = V(300);
// `lobj` records written with their stored types: 0 rectangle, 2 curve, 3 text, 4 bitmap.
let raw = |kind: u32, coords: Vec<u8>| list(b"obj ", vec![chunk(b"lobj", v.loda(kind, &[(30, coords)]))]);
let curve = v.points(&[(0.0, 0.0, 0x00), (10.0, 0.0, 0x40)]);
let ellipse = [v.coord(40.0), v.coord(20.0), v.angle(0.0), v.angle(0.0), v.word(0)].concat();
let d = read(
&drawing3(vec![raw(0, v.rect(10.0, 10.0, 0.0)), raw(1, ellipse), raw(2, curve), raw(3, vec![0; 8]), raw(4, vec![0; 8])]),
Limits::default(),
)
.unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert_eq!(s.len(), 3);
assert!(matches!(s[0].geometry, Geometry::Rect { .. }) && matches!(s[1].geometry, Geometry::Ellipse { .. }));
assert!(matches!(&s[2].geometry, Geometry::Path(p) if p.subpaths.len() == 1));
assert_eq!(d.warnings, vec![Warning::UnsupportedObjects]);
}
#[test]
fn version_3_fills_and_outlines_read_from_the_object() {
let v = V(300);
let styled = |fill: Vec<u8>, outline: Vec<u8>| synth::object(v, 1, &[(20, fill), (10, outline), (30, v.rect(10.0, 10.0, 0.0))], None);
let pen = |line_type: u16| synth::Pen { line_type, width: 3.0, cap: 2, join: 2 };
let black = synth::color3(1, [0, 0, 0, 100]);
let d = read(
&drawing3(vec![
styled(synth::fill3(1, &synth::color3(0, [0, 0, 40, 0])), synth::outline3(pen(0), black, &[3, 1])),
styled(synth::fill3(1, &synth::color3(0, [1, 0, 100, 0])), synth::outline3(pen(1), black, &[])),
styled(synth::fill3(0, &[]), synth::outline3(pen(0), synth::color3(0, [200, 0, 80, 0]), &[])),
]),
Limits::default(),
)
.unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
// Ink 0 is black at its tint, ink 1 white, and another number a library ink.
assert_eq!((s[0].fill.clone(), s[1].fill.clone(), s[2].fill.clone()), (Some(Color::Gray(0.4)), Some(Color::Gray(0.0)), None));
let o = s[0].outline.as_ref().unwrap();
assert!((o.width - 3.0).abs() < 0.05, "{}", o.width);
assert_eq!((o.cap, o.join, &o.dashes), (Cap::Square, Join::Bevel, &vec![3.0, 1.0]));
assert!(s[1].outline.is_none());
assert_eq!(s[2].outline.as_ref().unwrap().color, Color::Spot { name: "Spot 0:200".into(), tint: 0.8, look: None });
assert_eq!(d.warnings, vec![Warning::SpotLooks]);
// Fountain, texture and pattern fills are named and leave the shape unfilled; a fill or an
// outline cut short is damage.
for kind in [2, 4, 6, 7, 10] {
let d = read(&drawing3(vec![styled(synth::fill3(kind, &[0; 12]), synth::outline3(pen(1), black, &[]))]), Limits::default()).unwrap();
assert_eq!(d.warnings, vec![Warning::UnsupportedFills], "{kind}");
assert!(shapes(&d.pages[0].layers[0].objects)[0].fill.is_none());
}
let d = read(&drawing3(vec![styled(vec![1, 1], vec![1, 0])]), Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert!(s[0].fill.is_none() && s[0].outline.is_none());
assert_eq!(d.warnings, vec![Warning::Damaged]);
}
#[test]
fn version_3_dashes_count_toward_the_dash_limit() {
let v = V(300);
let pen = synth::Pen { line_type: 0, width: 1.0, cap: 0, join: 0 };
let dashed =
|| synth::object(v, 1, &[(10, synth::outline3(pen, synth::color3(1, [0, 0, 0, 100]), &[2, 2, 2])), (30, v.rect(10.0, 10.0, 0.0))], None);
let d = read(&drawing3(vec![dashed(), dashed()]), Limits { dashes: 4, ..Limits::default() }).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert_eq!((s[0].outline.as_ref().unwrap().dashes.len(), s[1].outline.as_ref().unwrap().dashes.len()), (3, 0));
assert_eq!(d.warnings, vec![Warning::TooDeep]);
}
#[test]
fn hostile_version_3_transforms_are_damage() {
let v = V(300);
let with = |arg: Vec<u8>| synth::object(v, 1, &[(30, v.rect(10.0, 10.0, 0.0)), (100, arg)], None);
// A matrix whose data offset lies past the argument, and an argument cut inside its header.
let mut past = synth::transforms3(&[[1.0, 0.0, 0.0, 1.0, 5.0, 5.0]]);
past[10..12].copy_from_slice(&60000u16.to_le_bytes());
for arg in [past, vec![0, 0, 9]] {
let d = read(&drawing3(vec![with(arg)]), Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert_eq!(s[0].matrix, Matrix::IDENTITY);
assert_eq!(d.warnings, vec![Warning::Damaged]);
}
// A count of 65,535 over one entry reads that entry.
let mut many = synth::transforms3(&[[1.0, 0.0, 0.0, 1.0, 72.0, 0.0]]);
many[2..4].copy_from_slice(&u16::MAX.to_le_bytes());
let d = read(&drawing3(vec![with(many)]), Limits::default()).unwrap();
assert!((shapes(&d.pages[0].layers[0].objects)[0].matrix.0[4] - 72.0).abs() < 0.01);
assert_eq!(d.warnings, vec![Warning::Damaged]);
}
#[test]
fn version_4_transforms_are_fixed_point_and_compose_in_file_order() {
let v = V(400);
let own = vec![
chunk(b"loda", v.loda(1, &[(30, v.rect(10.0, 10.0, 0.0))])),
list(b"trfl", vec![chunk(b"trfd", v.trfd(&[[1.0, 0.0, 0.0, 1.0, 72.0, 0.0], [0.0, 2.0, -2.0, 0.0, 0.0, 0.0]]))]),
];
let object = list(b"obj ", vec![list(b"lgob", own)]);
let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![object])]);
let d = read(&synth::riff(400, &[chunk(b"vrsn", 400u16.to_le_bytes().to_vec()), page]), Limits::default()).unwrap();
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
// Moved 72 pt right, then turned a quarter and doubled: (0, 0) lands at (0, 144).
let m = shapes(&d.pages[0].layers[0].objects)[0].matrix;
assert!(m.0.iter().zip([0.0, 2.0, -2.0, 0.0, 0.0, 144.0]).all(|(a, b)| (a - b).abs() < 0.01), "{m:?}");
}
#[test]
fn version_4_colors_are_words() {
let v = V(400);
let file = |fill: [u8; 12]| {
let doc = list(b"doc ", vec![list(b"filt", vec![chunk(b"fill", v.fill(1, &fill))])]);
let rect = synth::object(v, 1, &[(20, 1u32.to_le_bytes().to_vec()), (30, v.rect(10.0, 10.0, 0.0))], None);
let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![rect])]);
synth::riff(400, &[chunk(b"vrsn", 400u16.to_le_bytes().to_vec()), doc, page])
};
let fill_of = |fill: [u8; 12]| {
let d = read(&file(fill), Limits::default()).unwrap();
(shapes(&d.pages[0].layers[0].objects)[0].fill.clone(), d.warnings)
};
assert_eq!(fill_of(synth::color4(1, [20, 40, 60, 80])), (Some(Color::Cmyk([0.2, 0.4, 0.6, 0.8])), vec![]));
assert_eq!(fill_of(synth::color4(0, [0, 30, 0, 0])), (Some(Color::Gray(0.3)), vec![]));
assert_eq!(fill_of(synth::color4(0, [1, 30, 0, 0])), (Some(Color::Gray(0.0)), vec![]));
assert_eq!(
fill_of(synth::color4(0, [513, 30, 0, 0])),
(Some(Color::Spot { name: "Spot 0:513".into(), tint: 0.3, look: None }), vec![Warning::SpotLooks])
);
// The version 5 record read in the version 4 layout would take these values from other bytes.
assert_ne!(fill_of(synth::color(2, [20, 40, 60, 80])).0, Some(Color::Cmyk([0.2, 0.4, 0.6, 0.8])));
}
#[test]
fn the_version_3_page_size_is_the_distance_between_its_corners() {
let v = V(300);
for corners in [[-306.0, 396.0, 306.0, -396.0], [306.0, -396.0, -306.0, 396.0]] {
let mut b = vec![0xff; 2];
b.extend(corners.iter().flat_map(|c| v.coord(*c)));
let d = read(&synth::riff(300, &[list(b"doc ", vec![chunk(b"mcfg", b)])]), Limits::default()).unwrap();
let (w, h) = d.page_size.unwrap();
assert!((w - 612.0).abs() < 0.1 && (h - 792.0).abs() < 0.1, "{w} {h}");
}
// Corners that give no width, and a chunk cut inside them, give no page size.
let mut flat = vec![0; 2];
flat.extend([v.coord(10.0), v.coord(5.0), v.coord(10.0), v.coord(-5.0)].concat());
for b in [flat.clone(), flat[..9].to_vec()] {
assert_eq!(read(&synth::riff(300, &[list(b"doc ", vec![chunk(b"mcfg", b)])]), Limits::default()).unwrap().page_size, None);
}
}
#[test]
fn a_point_list_before_version_6_counts_its_points_with_a_u16() {
for version in [300, 400, 500] {
let v = V(version);
let mut points = v.points(&[(0.0, 0.0, 0x00), (10.0, 0.0, 0x40), (10.0, 10.0, 0x40)]);
// The u16 after the count is 1 in some curves; as part of a u32 count it would run the
// count past the points.
points[2] = 1;
let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 3, &[(30, points)], None)])]);
let d = read(&synth::riff(version, &[chunk(b"vrsn", version.to_le_bytes().to_vec()), page]), Limits::default()).unwrap();
assert!(d.warnings.is_empty(), "{version}: {:?}", d.warnings);
let s = shapes(&d.pages[0].layers[0].objects);
assert!(matches!(&s[0].geometry, Geometry::Path(p) if p.subpaths[0].segments.len() == 2), "{version}");
}
}
/// The objects of the one layer of a version 1 or 2 drawing.
fn wl_objects(d: &vectorcraft_cdr::Drawing) -> &[Object] {
assert_eq!((d.pages.len(), d.pages[0].layers.len(), d.master.len(), d.guides.len()), (1, 1, 0, 0));
&d.pages[0].layers[0].objects
}
#[test]
fn versions_1_and_2_read_their_sample() {
for (marker, version) in [(b'e', 100), (b'l', 200), (b'm', 200)] {
let file = synth::wl_sample(marker);
assert!(file.starts_with(b"WL") && vectorcraft_cdr::is_cdr(&file));
let d = read(&file, Limits::default()).unwrap();
assert_eq!(d.version, version);
let (w, h) = d.page_size.unwrap();
assert!((w - 612.0).abs() < 0.1 && (h - 792.0).abs() < 0.1, "{w} {h}");
// The text is left out, and the group record holds nothing.
assert_eq!(d.warnings, vec![Warning::UnsupportedObjects]);
let s = shapes(wl_objects(&d));
assert_eq!(s.len(), 3);
// Front to back: the rounded rectangle, the ellipse, the curve.
assert!(
matches!(s[0].geometry, Geometry::Rect { w, h, radii } if (w - 100.0).abs() < 0.1 && (h - 50.0).abs() < 0.1 && radii.iter().all(|r| (r - 5.0).abs() < 0.1))
);
assert_eq!(s[0].fill, Some(Color::Cmyk([0.0, 1.0, 1.0, 0.0])));
let o = s[0].outline.as_ref().unwrap();
assert!((o.width - 2.0).abs() < 0.05, "{}", o.width);
assert_eq!((&o.color, o.cap, o.join, o.dashes.len()), (&Color::Cmyk([0.0, 0.0, 0.0, 1.0]), Cap::Butt, Join::Miter, 0));
assert!((s[0].matrix.0[4] + 100.0).abs() < 0.1 && (s[0].matrix.0[5] - 100.0).abs() < 0.1, "{:?}", s[0].matrix);
assert!(matches!(s[1].geometry, Geometry::Ellipse { w, h } if (w - 40.0).abs() < 0.1 && (h + 40.0).abs() < 0.1));
assert!(s[1].outline.is_none() && (s[1].matrix.0[4] - 50.0).abs() < 0.1 && (s[1].matrix.0[5] + 50.0).abs() < 0.1);
assert!(matches!(&s[2].geometry, Geometry::Path(p) if p.subpaths[0].closed && matches!(p.subpaths[0].segments[1], Segment::Cubic(..))));
assert!(s[2].fill.is_none() && s[2].outline.is_some());
assert_eq!(&s[2].matrix.0[..4], &[2.0, 0.0, 0.0, 2.0]);
}
}
#[test]
fn a_version_1_matrix_and_point_place_the_shape() {
use synth::WlShape;
// x' = 0 x - 1 y + 72 and y' = 1 x + 0 y + 36: a quarter turn, then a shift.
let turned = synth::wl_object(WlShape::Rect { w: 10.0, h: 10.0, radius: 0.0 }, [0.0, 1.0, -1.0, 0.0, 72.0, 36.0], None, None);
let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[turned]), Limits::default()).unwrap();
let m = shapes(wl_objects(&d))[0].matrix;
assert!(m.0.iter().zip([0.0, 1.0, -1.0, 0.0, 72.0, 36.0]).all(|(a, b)| (a - b).abs() < 0.01), "{m:?}");
let at = m.apply(vectorcraft_cdr::model::Pt { x: 10.0, y: 0.0 });
assert!((at.x - 72.0).abs() < 0.01 && (at.y - 46.0).abs() < 0.01, "{at:?}");
}
#[test]
fn version_1_arcs_and_text_are_left_out_with_a_warning() {
use synth::WlShape;
let unit = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
let arc = synth::wl_object(WlShape::Ellipse { w: 40.0, h: 40.0, angles: (0, 900) }, unit, None, None);
let whole = synth::wl_object(WlShape::Ellipse { w: 40.0, h: 40.0, angles: (900, 900) }, unit, None, None);
let mut other = synth::wl_object(WlShape::Text, unit, None, None);
other[60] = 9;
for (records, kept) in [(vec![arc], 0), (vec![whole], 1), (vec![synth::wl_object(WlShape::Text, unit, None, None)], 0), (vec![other], 0)] {
let d = read(&synth::wl_file(b'e', (612.0, 792.0), &records), Limits::default()).unwrap();
assert_eq!(wl_objects(&d).len(), kept);
assert_eq!(d.warnings.contains(&Warning::UnsupportedObjects), kept == 0);
assert!(!d.warnings.contains(&Warning::Damaged));
}
}
#[test]
fn hostile_version_1_files_stop_within_their_bytes_and_limits() {
use synth::WlShape;
let unit = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
let rect = || synth::wl_object(WlShape::Rect { w: 10.0, h: 10.0, radius: 0.0 }, unit, None, None);
let file = synth::wl_sample(b'e');
// Cut at every length: an error, or what the bytes still hold.
for len in 0..file.len() {
let _ = read(&file[..len], Limits::default());
}
// A body size that runs past the records' end.
let mut long = rect();
long[28..30].copy_from_slice(&u16::MAX.to_le_bytes());
let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[rect(), long]), Limits::default()).unwrap();
assert_eq!((wl_objects(&d).len(), d.warnings.clone()), (1, vec![Warning::Damaged]));
// A point count larger than the record holds reads the points that fit.
let mut curve = synth::wl_object(WlShape::Curve(vec![(0.0, 0.0, 0x00), (10.0, 0.0, 0x40), (10.0, 10.0, 0x40)]), unit, None, None);
curve[114..116].copy_from_slice(&u16::MAX.to_le_bytes());
let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[curve.clone()]), Limits::default()).unwrap();
assert_eq!((wl_objects(&d).len(), d.warnings.clone()), (1, vec![Warning::Damaged]));
// Points past the coordinate limit leave the curve out.
curve[114..116].copy_from_slice(&3u16.to_le_bytes());
let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[curve]), Limits { coordinates: 2, ..Limits::default() }).unwrap();
assert_eq!(wl_objects(&d).len(), 0);
assert_eq!(d.warnings, vec![Warning::TooDeep]);
// Objects past the object limit are left out, and records past the chunk limit stop the read.
let many: Vec<Vec<u8>> = (0..10).map(|_| rect()).collect();
let d = read(&synth::wl_file(b'e', (612.0, 792.0), &many), Limits { objects: 4, ..Limits::default() }).unwrap();
assert_eq!((wl_objects(&d).len(), d.warnings.clone()), (4, vec![Warning::TooDeep]));
let groups: Vec<Vec<u8>> = (0..10).map(|_| synth::wl_group()).collect();
assert_eq!(read(&synth::wl_file(b'e', (612.0, 792.0), &groups), Limits { chunks: 4, ..Limits::default() }), Err(Error::Limit("chunk count")));
assert_eq!(read(&file, Limits { input: file.len() - 1, ..Limits::default() }), Err(Error::Limit("input size")));
// Bytes left after the last whole record are damage.
let mut ragged = vec![rect()];
ragged.push(vec![0; 5]);
let d = read(&synth::wl_file(b'e', (612.0, 792.0), &ragged), Limits::default()).unwrap();
assert_eq!((wl_objects(&d).len(), d.warnings.clone()), (1, vec![Warning::Damaged]));
}
#[test]
fn a_wl_prefix_alone_is_not_a_drawing() {
for bytes in [
&b"WL"[..],
b"WLe\0",
b"WLAN settings, exported as plain text for the help desk",
// Records that start inside the header, and a marker and a fourth byte no source gives.
b"WLe\0\x1c\0\0\0\x10\0\0\0\x1c\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",
b"WLAN\x1c\0\0\0\x1c\0\0\0\x1c\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",
] {
assert!(!vectorcraft_cdr::is_cdr(bytes));
assert_eq!(read(bytes, Limits::default()), Err(Error::NotCdr));
}
}
#[test]
fn versions_outside_1_to_27_and_other_files_are_refused() {
// No source shows a RIFF file of version 1 or 2: those versions are `WL` files.
for version in [100, 200] {
let refused = read(&synth::riff(version, &[]), Limits::default()).unwrap_err();
assert_eq!(refused, Error::Unsupported("RIFF files of versions before 3"), "{version}");
assert_eq!(refused.to_string(), "RIFF files of versions before 3 are not read");
}
assert_eq!(read(&synth::riff(2800, &[]), Limits::default()), Err(Error::Version(2800)));
assert_eq!(read(b"RIFF\x04\0\0\0WAVE", Limits::default()), Err(Error::NotCdr));
assert_eq!(read(b"RIFF\x04\0\0\0CDRX", Limits::default()), Err(Error::NotCdr));
assert!(!vectorcraft_cdr::is_cdr(b"PK\x03\x04"));
assert!(vectorcraft_cdr::is_cdr(&synth::sample(1100, true)));
}
#[test]
fn letters_that_count_differently_take_the_vrsn_version() {
// Version 27 saves the letter `U`, which counts as 29 the older way; the next letter with a
// `vrsn` of 2800 is refused as version 28.
let mut file = synth::sample(2700, false);
file[11] = b'U';
let d = read(&file, Limits::default()).unwrap();
check_pages(&d, 2700);
check_shapes(&d, 2700);
let mut file = synth::riff(2800, &[chunk(b"vrsn", 2800u16.to_le_bytes().to_vec())]);
file[11] = b'V';
assert_eq!(read(&file, Limits::default()), Err(Error::Version(2800)));
}
#[test]
fn every_version_from_14_to_27_reads_its_package() {
for version in [1400, 1500, 1600, 1700, 1800, 2000, 2200, 2400, 2430, 2600, 2700] {
for compress in [false, true] {
let file = synth::sample_file(version, compress);
assert!(file.starts_with(b"PK\x03\x04") && vectorcraft_cdr::is_cdr(&file), "{version}");
let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version} {compress}: {e}"));
assert!(!d.warnings.contains(&Warning::Damaged), "{version} {compress}: {:?}", d.warnings);
check_pages(&d, version);
check_shapes(&d, version);
}
}
}
/// The version 17 sample's content with `extra` added after it, as a package.
fn package17(extra: Vec<synth::Node>, members: &[synth::Member]) -> Vec<u8> {
let mut body = vec![chunk(b"vrsn", 1700u16.to_le_bytes().to_vec())];
body.extend(synth::sample_content(1700));
body.extend(extra);
synth::package16(1700, &body, true, members)
}
#[test]
fn lists_whose_bodies_move_to_a_data_stream_read_the_same() {
let mut body = vec![chunk(b"vrsn", 1700u16.to_le_bytes().to_vec())];
body.extend(synth::sample_content(1700));
for moved in [*b"layr", *b"obj ", *b"page"] {
let file = synth::package16_with(1700, &body, true, &[], &[moved]);
let d = read(&file, Limits::default()).unwrap();
assert!(!d.warnings.contains(&Warning::Damaged), "{moved:?}: {:?}", d.warnings);
check_pages(&d, 1700);
check_shapes(&d, 1700);
}
}
#[test]
fn a_data_stream_no_chunk_reads_is_not_inflated() {
// 32 MiB of picture data that the reader doesn't use, in a stream of its own.
let bitmaps = list(b"bmpt", vec![chunk(b"bmp ", vec![0; 32 << 20])]);
let file = package17(vec![bitmaps], &[]);
assert!(file.len() < 1 << 20);
let d = read(&file, Limits { inflated: 4 << 20, ..Limits::default() }).unwrap();
assert_eq!(d.warnings, vec![Warning::UnsupportedObjects]);
check_shapes(&d, 1700);
}
#[test]
fn a_redirected_list_is_inflated_and_counts_toward_the_limit() {
// A list whose body is in a stream must be inflated to be split; past the limit it is left
// out with a warning, and the rest of the drawing reads.
let mut body = vec![chunk(b"vrsn", 1700u16.to_le_bytes().to_vec())];
body.extend(synth::sample_content(1700));
body.push(list(b"bmpt", vec![chunk(b"bmp ", vec![0; 32 << 20])]));
let file = synth::package16_with(1700, &body, true, &[], &[*b"bmpt"]);
let d = read(&file, Limits { inflated: 4 << 20, ..Limits::default() }).unwrap();
assert!(d.warnings.contains(&Warning::TooDeep) && !d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings);
check_shapes(&d, 1700);
let d = read(&file, Limits::default()).unwrap();
assert!(!d.warnings.contains(&Warning::TooDeep));
}
#[test]
fn chunks_in_a_data_stream_past_a_limit_are_not_damage() {
// A record and a list in a 2 MiB stream, read with a 1 MiB member limit, stored and deflated
// with a 1 MiB inflate limit: only the limit warning.
let mcfg = synth::mcfg(V(1700), 300.0, 200.0);
let synth::Node::Chunk(_, mcfg) = mcfg else { panic!() };
let n = mcfg.len() as u32;
let mut stream = mcfg.clone();
stream.resize(2 << 20, 0);
stream[(1 << 20)..(1 << 20) + 4].copy_from_slice(b"fntt");
let mut root = b"RIFF".to_vec();
let body = doc_of(&[redirect(b"mcfg", 0, n, 0), redirect(b"LIST", 0, 4, 1 << 20)]);
root.extend(((body.len() + 4) as u32).to_le_bytes());
root.extend(b"CDRH");
root.extend(body);
let m = |name: &str, data: Vec<u8>, deflate: bool| synth::Member { name: name.into(), data, deflate };
for (deflate, limits) in [(false, Limits { member: 1 << 20, ..Limits::default() }), (true, Limits { inflated: 1 << 20, ..Limits::default() })] {
let file = synth::zip(
&[
m("content/root.dat", root.clone(), false),
m("content/dataFileList.dat", b"data1.dat".to_vec(), false),
m("content/data/data1.dat", stream.clone(), deflate),
],
b"",
);
let d = read(&file, limits).unwrap();
assert_eq!(d.warnings, vec![Warning::TooDeep], "{deflate}");
assert!(d.page_size.is_none());
let d = read(&file, Limits::default()).unwrap();
assert!(d.page_size.is_some() && d.warnings.is_empty(), "{deflate}: {:?}", d.warnings);
}
}
#[test]
fn encrypted_data_streams_and_other_methods_are_refused() {
let good = synth::sample_file(1700, false);
assert!(read(&good, Limits::default()).is_ok());
// The directory entry of a data stream: its name's last place, 46 bytes after the entry start.
let name = b"content/data/data1.dat";
let entry = good.windows(name.len()).rposition(|w| w == name).unwrap() - 46;
assert_eq!(&good[entry..entry + 4], b"PK\x01\x02");
let mut encrypted = good.clone();
encrypted[entry + 8] |= 1;
assert_eq!(read(&encrypted, Limits::default()), Err(Error::Unsupported("encrypted packages")));
let mut other = good.clone();
other[entry + 10] = 12;
assert_eq!(read(&other, Limits::default()), Err(Error::Unsupported("package compression methods other than storing and deflate")));
}
/// A version 17 package whose `root.dat` is `root` (the RIFF body after the form type) and whose
/// one data stream is `stream`.
fn raw_package(root: &[u8], stream: &[u8], list: &[u8]) -> Vec<u8> {
let mut riff = b"RIFF".to_vec();
riff.extend(((root.len() + 4) as u32).to_le_bytes());
riff.extend(b"CDRH");
riff.extend(root);
let m = |name: &str, data: &[u8]| synth::Member { name: name.into(), data: data.to_vec(), deflate: false };
synth::zip(&[m("content/root.dat", &riff), m("content/dataFileList.dat", list), m("content/data/data1.dat", stream)], b"")
}
/// A chunk header for a redirect record of `stream`, `len` and `offset`.
fn redirect(id: &[u8; 4], stream: u32, len: u32, offset: u32) -> Vec<u8> {
let mut out = id.to_vec();
out.extend(16u32.to_le_bytes());
for v in [stream, len, offset, 0] {
out.extend(v.to_le_bytes());
}
out
}
#[test]
fn a_list_redirected_into_its_own_bytes_is_read_once() {
// The stream holds a `grp ` body whose children are lists redirected to that body again:
// the bytes are taken, so each child is damage and the list is read once.
for children in [1, 2] {
let len = 4 + 24 * children;
let mut stream = b"grp ".to_vec();
for _ in 0..children {
stream.extend(redirect(b"LIST", 0, len, 0));
}
let file = raw_package(&redirect(b"LIST", 0, len, 0), &stream, b"data1.dat");
let d = read(&file, Limits { chunks: 100, ..Limits::default() }).unwrap();
assert_eq!(d.warnings, vec![Warning::Damaged], "{children}");
}
}
/// A `doc ` list holding `records`, as `root.dat`'s body.
fn doc_of(records: &[Vec<u8>]) -> Vec<u8> {
let records = records.concat();
let mut body = b"LIST".to_vec();
body.extend(((records.len() + 4) as u32).to_le_bytes());
body.extend(b"doc ");
body.extend(records);
body
}
#[test]
fn records_share_bytes_within_the_member_limit() {
let mcfg = synth::mcfg(V(1700), 300.0, 200.0);
let synth::Node::Chunk(_, mcfg) = mcfg else { panic!() };
let n = mcfg.len() as u32;
let mut stream = mcfg.clone();
stream.extend(&mcfg);
// The same bytes, bytes that overlap them, bytes that only touch them, and the same bytes
// through a second line naming the same member: both redirects read.
for (second, list) in [
(redirect(b"mcfg", 0, n, 0), &b"data1.dat"[..]),
(redirect(b"mcfg", 0, n, n - 1), b"data1.dat"),
(redirect(b"mcfg", 0, n, n), b"data1.dat"),
(redirect(b"mcfg", 1, n, 0), b"data1.dat\ndata1.dat"),
] {
let file = raw_package(&doc_of(&[redirect(b"mcfg", 0, n, 0), second.clone()]), &stream, list);
let d = read(&file, Limits::default()).unwrap();
assert!(d.page_size.is_some() && d.warnings.is_empty(), "{:?}: {:?}", &second[8..], d.warnings);
}
// Bytes read again take from the member limit: with a limit of the stream's 1,024 bytes, a
// record of all of them reads twice, and a third read is left out with the limit warning.
let mut stream = mcfg.clone();
stream.resize(1024, 0);
let limits = Limits { member: 1024, ..Limits::default() };
for (reads, warnings) in [(2, vec![]), (3, vec![Warning::TooDeep])] {
let records = vec![redirect(b"mcfg", 0, 1024, 0); reads];
let d = read(&raw_package(&doc_of(&records), &stream, b"data1.dat"), limits).unwrap();
assert!(d.page_size.is_some(), "{reads}");
assert_eq!(d.warnings, warnings, "{reads}");
}
}
#[test]
fn a_member_two_streams_name_is_inflated_once() {
// One deflated member of 2 MiB named on two lines, a list read from one and the page size
// from the other: within a 3 MiB inflate limit it is inflated once.
let mcfg = synth::mcfg(V(1700), 300.0, 200.0);
let synth::Node::Chunk(_, mcfg) = mcfg else { panic!() };
let n = mcfg.len() as u32;
let mut stream = mcfg.clone();
stream.resize(2 << 20, 0);
stream[(1 << 20)..(1 << 20) + 4].copy_from_slice(b"fntt");
let mut root = b"RIFF".to_vec();
let body = doc_of(&[redirect(b"LIST", 1, 4, 1 << 20), redirect(b"mcfg", 0, n, 0)]);
root.extend(((body.len() + 4) as u32).to_le_bytes());
root.extend(b"CDRH");
root.extend(body);
let m = |name: &str, data: Vec<u8>, deflate: bool| synth::Member { name: name.into(), data, deflate };
let file = synth::zip(
&[
m("content/root.dat", root, false),
m("content/dataFileList.dat", b"data1.dat\ndata1.dat".to_vec(), false),
m("content/data/data1.dat", stream, true),
],
b"",
);
let d = read(&file, Limits { inflated: 3 << 20, ..Limits::default() }).unwrap();
assert!(d.page_size.is_some() && d.warnings.is_empty(), "{:?}", d.warnings);
}
#[test]
fn redirects_past_their_stream_or_to_a_missing_one_are_damage() {
let mcfg = synth::mcfg(V(1700), 300.0, 200.0);
let synth::Node::Chunk(_, mcfg) = mcfg else { panic!() };
let n = mcfg.len() as u32;
for (root, list, damaged) in [
(redirect(b"mcfg", 0, n, 0), &b"data1.dat"[..], false),
(redirect(b"mcfg", 0, n, 0), b"data1.dat\r\n", false),
(redirect(b"mcfg", 0, n + 1, 0), b"data1.dat", true),
(redirect(b"mcfg", 0, n, u32::MAX), b"data1.dat", true),
(redirect(b"mcfg", 1, n, 0), b"data1.dat", true),
(redirect(b"mcfg", 0, n, 0), b"gone.dat", true),
(redirect(b"mcfg", 0, n, 0), b"", true),
] {
let mut body = b"LIST".to_vec();
body.extend(((root.len() + 4) as u32).to_le_bytes());
body.extend(b"doc ");
body.extend(&root);
let d = read(&raw_package(&body, &mcfg, list), Limits::default()).unwrap();
assert_eq!(d.warnings.contains(&Warning::Damaged), damaged, "{list:?} {:?}", &root[8..]);
assert_eq!(d.page_size.is_some(), !damaged);
}
}
#[test]
fn a_redirect_record_holds_up_to_8_bytes_itself() {
let mut inline = b"vrsn".to_vec();
inline.extend(16u32.to_le_bytes());
inline.extend(u32::MAX.to_le_bytes());
inline.extend(2u32.to_le_bytes());
inline.extend(1800u16.to_le_bytes());
inline.extend([0; 6]);
let d = read(&raw_package(&inline, b"", b""), Limits::default()).unwrap();
assert_eq!(d.version, 1800);
// A length past the record's 8 bytes is damage, and the form type's version stands.
inline[12] = 9;
let d = read(&raw_package(&inline, b"", b""), Limits::default()).unwrap();
assert!(d.warnings.contains(&Warning::Damaged));
assert_eq!(d.version, 1700);
}
fn zip_of(members: &[(&str, Vec<u8>)]) -> Vec<u8> {
let m: Vec<_> = members.iter().map(|(n, d)| synth::Member { name: (*n).into(), data: d.clone(), deflate: false }).collect();
synth::zip(&m, b"")
}
/// Where the first central directory entry starts.
fn directory(bytes: &[u8]) -> usize {
bytes.windows(4).position(|w| w == b"PK\x01\x02").unwrap()
}
#[test]
fn hostile_packages_are_refused() {
let riff = synth::sample(1400, false);
let good = zip_of(&[("content/riffData.cdr", riff.clone())]);
assert!(read(&good, Limits::default()).is_ok());
// More members than a read takes.
let many: Vec<(String, Vec<u8>)> = (0..4097).map(|i| (format!("m{i}"), vec![])).collect();
let many: Vec<(&str, Vec<u8>)> = many.iter().map(|(n, d)| (n.as_str(), d.clone())).collect();
assert_eq!(read(&zip_of(&many), Limits::default()), Err(Error::Limit("package member count")));
assert_eq!(read(&zip_of(&many[..4096]), Limits::default()), Err(Error::NotCdr));
// A member named twice.
let twice = zip_of(&[("content/riffData.cdr", riff.clone()), ("content/riffData.cdr", riff.clone())]);
assert_eq!(read(&twice, Limits::default()), Err(Error::Damaged("package member named twice")));
// A member whose bytes run into the next member's header.
let two = zip_of(&[("a", vec![1; 10]), ("content/riffData.cdr", riff.clone())]);
let mut overlap = two.clone();
let at = directory(&two) + 20;
overlap[at..at + 4].copy_from_slice(&20u32.to_le_bytes());
assert_eq!(read(&overlap, Limits::default()), Err(Error::Damaged("package members overlap")));
// A central directory cut short, and an archive without its end record.
let mut short = good.clone();
let n = short.len();
let len_at = n - 22 + 12;
let len = u32::from_le_bytes(short[len_at..len_at + 4].try_into().unwrap());
short[len_at..len_at + 4].copy_from_slice(&(len - 10).to_le_bytes());
assert_eq!(read(&short, Limits::default()), Err(Error::Damaged("package directory")));
assert_eq!(read(&good[..directory(&good) + 30], Limits::default()), Err(Error::Damaged("package directory")));
// Encrypted members, ZIP64 fields and archives split across files.
let mut encrypted = good.clone();
encrypted[directory(&good) + 8] |= 1;
assert_eq!(read(&encrypted, Limits::default()), Err(Error::Unsupported("encrypted packages")));
let mut zip64 = good.clone();
zip64[n - 22 + 10..n - 22 + 12].copy_from_slice(&[0xff, 0xff]);
assert_eq!(read(&zip64, Limits::default()), Err(Error::Unsupported("ZIP64 packages")));
let mut split = good.clone();
split[n - 22 + 4] = 1;
assert_eq!(read(&split, Limits::default()), Err(Error::Unsupported("packages split across files")));
}
#[test]
fn a_package_member_bomb_stops_at_its_stated_size_or_the_limit() {
let riff = synth::sample(1400, false);
let m = synth::Member { name: "content/riffData.cdr".into(), data: riff.clone(), deflate: true };
let good = synth::zip(std::slice::from_ref(&m), b"");
assert!(read(&good, Limits::default()).is_ok());
// A member that inflates past the size its entry states stops one byte past it.
let bomb = synth::zip(&[synth::Member { data: [riff.clone(), vec![0; 64 << 20]].concat(), ..m.clone() }], b"");
assert!(bomb.len() < 1 << 20);
let mut lying = bomb.clone();
let at = directory(&bomb) + 24;
lying[at..at + 4].copy_from_slice(&(riff.len() as u32).to_le_bytes());
assert_eq!(read(&lying, Limits::default()), Err(Error::Damaged("package member")));
// One that states more than a member may hold, or than is left to inflate, is not inflated.
assert_eq!(read(&bomb, Limits { member: 1 << 20, ..Limits::default() }), Err(Error::Limit("package member size")));
assert_eq!(read(&bomb, Limits { inflated: 1 << 20, ..Limits::default() }), Err(Error::Limit("inflated size")));
}
#[test]
fn stored_package_members_take_nothing_from_the_inflate_limit() {
// Nothing may be inflated, and the stored members of either package layout still read, as
// the same drawing does as a plain RIFF file.
let none = Limits { inflated: 0, ..Limits::default() };
assert!(read(&synth::sample(1400, false), none).is_ok());
for version in [1400, 1700] {
let d = read(&synth::sample_file(version, false), none).unwrap_or_else(|e| panic!("{version}: {e}"));
assert!(d.warnings.iter().all(|w| *w == Warning::UnsupportedObjects), "{version}: {:?}", d.warnings);
check_shapes(&d, version);
}
// Deflated members do take from it.
assert_eq!(read(&synth::sample_file(1400, true), none), Err(Error::Limit("inflated size")));
}
#[test]
fn redirect_records_that_lead_nowhere_count_toward_the_chunk_limit() {
// 3,000 redirects to a stream the package lacks: each lost record is counted.
let root: Vec<u8> = (0..3000).flat_map(|_| redirect(b"mcfg", 7, 4, 0)).collect();
let file = raw_package(&root, b"", b"data1.dat");
assert_eq!(read(&file, Limits { chunks: 2_000, ..Limits::default() }), Err(Error::Limit("chunk count")));
let d = read(&file, Limits { chunks: 4_000, ..Limits::default() }).unwrap();
assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings);
}
#[test]
fn rectangles_from_version_15_give_radii_as_shares_of_half_the_shorter_side() {
let v = V(1500);
let mut c = synth::V(1500).rect(100.0, 50.0, 0.0);
// The four shares: 0.2, 0.4, 0, and 3, which half the shorter side holds to 25 pt.
for (k, share) in [0.2f64, 0.4, 0.0, 3.0].iter().enumerate() {
let at = 40 + 24 * k;
c[at..at + 8].copy_from_slice(&share.to_le_bytes());
}
let file =
synth::riff(1500, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &[(30, c.clone())], None)])])]);
let d = read(&file, Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
let Geometry::Rect { w, h, radii } = s[0].geometry else { panic!("{:?}", s[0].geometry) };
assert!((w - 100.0).abs() < 1e-6 && (h - 50.0).abs() < 1e-6);
for (got, want) in radii.iter().zip([5.0, 10.0, 0.0, 25.0]) {
assert!((got - want).abs() < 1e-6, "{radii:?}");
}
// With the scale-with flag set the radii are inches, held to half the shorter side as well.
c[32] = 1;
let file = synth::riff(1500, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &[(30, c)], None)])])]);
let d = read(&file, Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
let Geometry::Rect { radii, .. } = s[0].geometry else { panic!("{:?}", s[0].geometry) };
for (got, want) in radii.iter().zip([14.4, 25.0, 0.0, 25.0]) {
assert!((got - want).abs() < 1e-6, "{radii:?}");
}
}
#[test]
fn paths_from_version_10_read_their_points() {
let v = V(1700);
let mut c = vec![0; 4];
c.extend(2u16.to_le_bytes());
c.extend(1u16.to_le_bytes());
c.extend([0; 16]);
c.extend(&v.points(&[(0.0, 0.0, 0x08), (50.0, 0.0, 0x40), (50.0, 20.0, 0x48)])[4..]);
let objects = |version: u16| {
let v = V(version);
synth::riff(
version,
&[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 0x25, &[(30, c.clone())], None)])])],
)
};
for version in [1000, 1300, 1500, 1700] {
let d = read(&objects(version), Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
let Geometry::Path(p) = &s[0].geometry else { panic!("{version}: {:?}", s[0].geometry) };
assert_eq!(p.subpaths[0].segments.len(), 2);
assert!(d.warnings.is_empty(), "{version}: {:?}", d.warnings);
}
// No sample before version 10 holds the type, so it is not read as a path there.
let d = read(&objects(900), Limits::default()).unwrap();
assert!(d.pages[0].layers[0].objects.is_empty() && d.warnings.contains(&Warning::UnsupportedObjects));
}
#[test]
fn a_template_takes_its_version_from_the_vrsn_chunk() {
let mut file = synth::sample(2100, false);
file[8..12].copy_from_slice(b"CDTQ");
assert!(vectorcraft_cdr::is_cdr(&file));
let d = read(&file, Limits::default()).unwrap();
assert_eq!(d.version, 2100);
check_shapes(&d, 2100);
let mut bare = synth::riff(2100, &[]);
bare[8..12].copy_from_slice(b"CDTQ");
assert_eq!(read(&bare, Limits::default()), Err(Error::NotCdr));
// A template of a version after 27 is refused by its version, and one before 3 as a RIFF
// file of those versions.
for (version, refused) in [(2800u16, Error::Version(2800)), (200, Error::Unsupported("RIFF files of versions before 3"))] {
let mut t = synth::riff(2100, &[chunk(b"vrsn", version.to_le_bytes().to_vec())]);
t[8..12].copy_from_slice(b"CDTQ");
assert_eq!(read(&t, Limits::default()), Err(refused));
}
}
#[test]
fn layers_take_their_kind_from_their_object_type() {
for version in [300, 800, 1300, 1700] {
let v = V(version);
let rect = || synth::object(v, 1, &[(30, v.rect(10.0, 10.0, 0.0))], None);
// Version 3 counts its types from 0 (R32).
let ty = |t: u32| if version < 400 { t - 1 } else { t };
// Master page layers flagged in the older way, with the types of guides and desktop layers,
// and a drawing layer whose flags would make it a desktop layer.
let master = synth::page(
true,
vec![
synth::layer_of_type(v, [2, 1, 1, 0x98], ty(12), "G", vec![rect()]),
synth::layer_of_type(v, [0, 1, 1, 0x98], ty(17), "D", vec![rect()]),
synth::layer_of_type(v, [8, 1, 0, 0x98], 0, "M", vec![rect()]),
],
);
// A drawing layer with flag bit 0x10 set, and a grid layer.
let own = synth::page(
false,
vec![
synth::layer_of_type(v, [0x10, 0, 0, 0x98], 0, "L", vec![rect()]),
synth::layer_of_type(v, [0x1a, 0, 1, 0x98], ty(11), "Grid", vec![rect()]),
],
);
let body = [chunk(b"vrsn", version.to_le_bytes().to_vec()), master, own];
let file = if version < 1400 { synth::riff(version, &body) } else { synth::package16(version, &body, true, &[]) };
let d = read(&file, Limits::default()).unwrap();
let kinds: Vec<_> = d.master.iter().map(|l| l.kind).collect();
assert_eq!(kinds, [LayerKind::Guides, LayerKind::Desktop, LayerKind::Drawing], "{version}");
let kinds: Vec<_> = d.pages[0].layers.iter().map(|l| (l.kind, l.objects.len())).collect();
assert_eq!(kinds, [(LayerKind::Drawing, 1), (LayerKind::Grid, 1)], "{version}");
}
}
#[test]
fn a_lower_case_form_type_names_the_same_versions() {
let mut file = synth::sample(600, false);
file[8..12].copy_from_slice(b"cdr6");
// The `vrsn` chunk agrees; without it the form type alone decides.
assert_eq!(read(&file, Limits::default()).unwrap().version, 600);
assert!(vectorcraft_cdr::is_cdr(&file));
file[8..12].copy_from_slice(b"cdrX");
assert_eq!(read(&file, Limits::default()), Err(Error::NotCdr));
}
#[test]
fn rectangles_keep_four_corner_radii_from_version_9() {
let v = V(900);
let c = [v.coord(100.0), v.coord(50.0), v.coord(1.0), v.coord(2.0), v.coord(3.0), v.coord(4.0)].concat();
let file = synth::riff(900, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &[(30, c)], None)])])]);
let d = read(&file, Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
let Geometry::Rect { radii, .. } = s[0].geometry else { panic!("{:?}", s[0].geometry) };
for (got, want) in radii.iter().zip([1.0, 2.0, 3.0, 4.0]) {
assert!((got - want).abs() < 0.01, "{radii:?}");
}
// Before version 9 one radius rounds every corner.
let v = V(800);
let c = [v.coord(100.0), v.coord(50.0), v.coord(6.0)].concat();
let file = synth::riff(800, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &[(30, c)], None)])])]);
let s = read(&file, Limits::default()).unwrap();
let s = shapes(&s.pages[0].layers[0].objects);
assert!(matches!(s[0].geometry, Geometry::Rect { radii, .. } if radii.iter().all(|r| (r - 6.0).abs() < 0.01)));
}
#[test]
fn version_7_guidelines_count_toward_the_object_limit() {
let v = V(700);
let mut guid = 1000u32.to_le_bytes().to_vec();
guid.extend(1000u32.to_le_bytes());
for i in 0..1000 {
guid.extend([0; 12]);
guid.extend(90_000_000i32.to_le_bytes());
guid.extend([v.coord(f64::from(i)), v.coord(0.0), v.coord(f64::from(i)), v.coord(1.0), v.coord(f64::from(i)), v.coord(0.0)].concat());
}
let file = synth::riff(700, &[chunk(b"vrsn", 700u16.to_le_bytes().to_vec()), list(b"doc ", vec![chunk(b"guid", guid)])]);
let d = read(&file, Limits::default()).unwrap();
assert_eq!(d.guides.len(), 1000);
let d = read(&file, Limits { objects: 10, ..Limits::default() }).unwrap();
assert_eq!(d.guides.len(), 10);
assert!(d.warnings.contains(&Warning::TooDeep));
}
/// Guidelines on any layer of the master page show on every page, not only those of its guides
/// layer: one on a drawing layer that also holds art, and one alone on the desktop layer.
#[test]
fn master_guidelines_on_any_layer_show_on_every_page() {
let v = V(1100);
let guide = |x: f64| {
let mut g = vec![0; 12];
g.extend(90_000_000i32.to_le_bytes());
g.extend([v.coord(x), v.coord(0.0)].concat());
synth::object(v, 0x16, &[(16000, g)], None)
};
let rect = synth::object(v, 1, &[(30, [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat())], None);
let master = synth::page(
true,
vec![synth::layer(v, [0, 0, 1, 0x98], "Art", vec![guide(10.0), rect]), synth::layer(v, [0x08, 0, 1, 0x98], "Desktop", vec![guide(20.0)])],
);
let file = synth::riff(1100, &[master, synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "Art", vec![])])]);
let d = read(&file, Limits::default()).unwrap();
let mut xs: Vec<f64> = d.guides.iter().map(|g| g.at.x).collect();
xs.sort_by(f64::total_cmp);
assert_eq!(xs.len(), 2, "{:?}", d.guides);
assert!((xs[0] - 10.0).abs() < 0.01 && (xs[1] - 20.0).abs() < 0.01, "{xs:?}");
assert_eq!(d.master.len(), 1);
assert_eq!(d.master[0].objects.len(), 1);
}
/// An object with more arguments than the limit keeps the ones read paired with their own types:
/// the types table runs from the stored count, not from the limit.
#[test]
fn arguments_past_the_limit_leave_the_first_ones_paired_with_their_types() {
let v = V(1100);
let mut args = vec![(30, [v.coord(40.0), v.coord(20.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat())];
args.extend((0..69).map(|i| (500 + i, vec![0; 4])));
let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &args, None)])])]);
let d = read(&file, Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert!(
matches!(s.first().map(|s| &s.geometry), Some(Geometry::Rect { w, h, .. }) if (w - 40.0).abs() < 0.01 && (h - 20.0).abs() < 0.01),
"{s:?}"
);
assert!(d.warnings.contains(&Warning::Damaged));
}
/// Groups count toward the object limit; a group past it leaves its objects ungrouped.
#[test]
fn groups_count_toward_the_object_limit() {
fn count(objects: &[Object]) -> usize {
objects.iter().map(|o| 1 + if let Object::Group { objects: kids, .. } = o { count(kids) } else { 0 }).sum()
}
let v = V(1100);
let rect = synth::object(v, 1, &[(30, [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat())], None);
let nested = list(b"grp ", vec![list(b"grp ", vec![rect])]);
let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![nested])])]);
let d = read(&file, Limits { objects: 2, ..Limits::default() }).unwrap();
let objects = &d.pages[0].layers[0].objects;
assert_eq!(count(objects), 2, "{objects:?}");
assert!(matches!(objects.as_slice(), [Object::Group { objects: kids, .. }] if matches!(kids.as_slice(), [Object::Shape(_)])), "{objects:?}");
assert!(d.warnings.contains(&Warning::TooDeep));
}
/// A rectangle, ellipse, curve or polygon stored without its coordinates is left out as damage.
#[test]
fn shapes_without_their_coordinates_are_damage() {
let v = V(1100);
for kind in [1, 2, 3, 0x14] {
let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, kind, &[], None)])])]);
let d = read(&file, Limits::default()).unwrap();
assert!(d.pages[0].layers[0].objects.is_empty(), "{kind}");
assert!(d.warnings.contains(&Warning::Damaged), "{kind}: {:?}", d.warnings);
}
}
/// An object list without its `loda`, a fill or outline record that can't be read, and a `guid`
/// chunk that counts more guidelines than it holds are each damage.
#[test]
fn unreadable_records_and_lists_are_damage() {
let v = V(1300);
let rect = |args: Vec<(u32, Vec<u8>)>| {
let mut args = args;
args.push((30, [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat()));
synth::object(v, 1, &args, None)
};
let on_page = |objects: Vec<synth::Node>, styles: Vec<synth::Node>| {
let mut kids = vec![chunk(b"vrsn", 1300u16.to_le_bytes().to_vec())];
kids.extend(styles);
kids.push(synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", objects)]));
read(&synth::riff(1300, &kids), Limits::default()).unwrap()
};
let d = on_page(vec![list(b"obj ", vec![chunk(b"flgs", vec![0, 0, 0, 0x08])])], vec![]);
assert!(d.warnings.contains(&Warning::Damaged), "no loda: {:?}", d.warnings);
// A fill record of only its id.
let d = on_page(vec![rect(vec![(20, 4u32.to_le_bytes().to_vec())])], vec![list(b"filt", vec![chunk(b"fild", 4u32.to_le_bytes().to_vec())])]);
assert_eq!(shapes(&d.pages[0].layers[0].objects)[0].fill, None);
assert!(d.warnings.contains(&Warning::Damaged), "fill: {:?}", d.warnings);
// A tagged outline whose first records are none of record 1.
let mut outl = 9u32.to_le_bytes().to_vec();
for _ in 0..16 {
outl.extend(5u32.to_le_bytes());
outl.extend(0u32.to_le_bytes());
}
let d = on_page(vec![rect(vec![(10, 9u32.to_le_bytes().to_vec())])], vec![list(b"otlt", vec![chunk(b"outl", outl)])]);
assert!(shapes(&d.pages[0].layers[0].objects)[0].outline.is_none());
assert!(d.warnings.contains(&Warning::Damaged), "outline: {:?}", d.warnings);
// Version 7: a `guid` chunk counting three guidelines and holding one.
let mut guid = 3u32.to_le_bytes().to_vec();
guid.extend(3u32.to_le_bytes());
guid.extend([0; 40]);
let d = read(&synth::riff(700, &[chunk(b"vrsn", 700u16.to_le_bytes().to_vec()), list(b"doc ", vec![chunk(b"guid", guid)])]), Limits::default())
.unwrap();
assert_eq!(d.guides.len(), 1);
assert!(d.warnings.contains(&Warning::Damaged), "guid: {:?}", d.warnings);
}
/// Pages keep their layers in a `gobj` list, and layers and objects their `loda` (and objects
/// their transform) in a `lgob` list. The layout with those chunks directly in the page, layer and
/// object lists reads the same.
#[test]
fn layers_and_objects_read_from_their_gobj_and_lgob_lists() {
let v = V(1000);
let c = [v.coord(10.0), v.coord(20.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat();
let m = [1.0, 0.0, 0.0, 1.0, 5.0, 6.0];
let nested = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &[(30, c.clone())], Some(m))])]);
let plain_object = list(b"obj ", vec![chunk(b"loda", v.loda(1, &[(30, c)])), list(b"trfl", vec![chunk(b"trfd", v.trfd(&[m]))])]);
let plain_layer = list(b"layr", vec![chunk(b"flgs", vec![0, 0, 0, 0x98]), chunk(b"loda", v.loda(0, &[(1000, b"L\0".to_vec())])), plain_object]);
let plain = list(b"page", vec![chunk(b"flgs", vec![0, 0, 0, 0x90]), plain_layer]);
for page in [nested, plain] {
let d = read(&synth::riff(1000, &[page]), Limits::default()).unwrap();
let layer = &d.pages[0].layers[0];
assert_eq!(layer.name, "L");
let s = shapes(&layer.objects);
assert_eq!(s.len(), 1, "{:?}", layer.objects);
assert!(matches!(s[0].geometry, Geometry::Rect { w, .. } if (w - 10.0).abs() < 0.01));
assert!((s[0].matrix.0[4] - 5.0).abs() < 0.01 && (s[0].matrix.0[5] - 6.0).abs() < 0.01, "{:?}", s[0].matrix);
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
}
}
/// From version 7 a `LIST stlt` holds the style tables, which don't parse as chunks: it is not
/// damage.
#[test]
fn a_style_table_list_is_not_read_as_chunks() {
let v = V(1000);
let stlt = chunk(b"LIST", [b"stlt".to_vec(), 3u32.to_le_bytes().to_vec(), vec![0xff; 30]].concat());
let d = read(&synth::riff(1000, &[list(b"doc ", vec![stlt, synth::mcfg(v, 100.0, 50.0)])]), Limits::default()).unwrap();
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
assert!(d.page_size.is_some_and(|(w, h)| (w - 100.0).abs() < 0.01 && (h - 50.0).abs() < 0.01));
}
/// Before version 7 a `LIST stlt` holds chunks (R4), which are read like the document's others.
#[test]
fn a_style_list_before_version_7_is_read_as_chunks() {
for version in [400, 500, 600] {
let v = V(version);
let red = if version < 500 { synth::color4(1, [0, 100, 100, 0]) } else { synth::color(5, [0, 0, 255, 0]) };
let styles = list(b"stlt", vec![list(b"filt", vec![chunk(b"fill", v.fill(1, &red))])]);
let rect = synth::object(v, 1, &[(20, 1u32.to_le_bytes().to_vec()), (30, v.rect(10.0, 10.0, 0.0))], None);
let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![rect])]);
let content = vec![list(b"doc ", vec![styles]), page];
let d = read(&synth::file_of(version, content.clone()), Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert!(s[0].fill.is_some(), "{version}");
assert!(d.warnings.is_empty(), "{version}: {:?}", d.warnings);
// A template, whose form type names no version, by its `vrsn` chunk.
let mut template = synth::file_of(version, content);
template[8..12].copy_from_slice(b"CDTA");
let d = read(&template, Limits::default()).unwrap();
assert!(shapes(&d.pages[0].layers[0].objects)[0].fill.is_some(), "{version}");
}
}
/// The objects of a styled drawing: a rectangle with only its style (argument 200), one whose
/// style leaves the fill and outline to its parent, and one with an outline argument of its own.
fn graphic_style_drawing(version: u16, table: synth::Node) -> Vec<u8> {
let v = V(version);
let black = synth::color(2, [0, 0, 0, 100]);
let doc = list(
b"doc ",
vec![
synth::mcfg(v, 612.0, 792.0),
list(b"filt", vec![chunk(if version >= 700 { b"fild" } else { b"fill" }, v.fill(1, &synth::color(5, [0, 0, 255, 0])))]),
list(
b"otlt",
vec![
chunk(b"outl", v.outline(2, synth::Pen { line_type: 0, width: 2.0, cap: 1, join: 1 }, &black, &[])),
chunk(b"outl", v.outline(3, synth::Pen { line_type: 1, width: 1.0, cap: 0, join: 0 }, &black, &[])),
],
),
table,
],
);
let rect = (30, v.rect(20.0, 10.0, 0.0));
let styled = |style: u32, own: &[(u32, Vec<u8>)]| {
let mut args = vec![(200, style.to_le_bytes().to_vec())];
args.extend(own.iter().cloned());
args.push(rect.clone());
synth::object(v, 1, &args, None)
};
let objects = vec![styled(0x10, &[]), styled(0x11, &[]), styled(0x10, &[(10, 3u32.to_le_bytes().to_vec())])];
let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", objects)]);
synth::file_of(version, vec![doc, page])
}
/// From version 7 an object without a fill or outline argument of its own takes its style's
/// (argument 200, `LIST stlt`), through the style's parent where the style names none; its own
/// argument wins over the style's.
#[test]
fn objects_without_their_own_fill_or_outline_take_their_styles() {
let styles = [synth::Style { id: 0x10, parent: 0, fill: 0x100, outline: 0x200 }, synth::Style { id: 0x11, parent: 0x10, fill: 0, outline: 0 }];
for version in [700, 800, 801, 900, 1000, 1100, 1200, 1300, 1400, 1500] {
for text in [false, true] {
let table = synth::stlt(V(version), &[(0x100, 1)], &[(0x200, 2)], &styles, text);
let d = read(&graphic_style_drawing(version, table), Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}"));
let s = shapes(&d.pages[0].layers[0].objects);
assert_eq!(s.len(), 3, "{version}");
for shape in &s[..2] {
assert_eq!(shape.fill, Some(Color::Rgb([1.0, 0.0, 0.0])), "{version} {text}");
assert!(shape.outline.as_ref().is_some_and(|o| (o.width - 2.0).abs() < 0.05), "{version} {text}: {:?}", shape.outline);
}
assert_eq!(s[2].fill, Some(Color::Rgb([1.0, 0.0, 0.0])), "{version} {text}");
assert!(s[2].outline.is_none(), "{version} {text}");
assert!(d.warnings.is_empty(), "{version} {text}: {:?}", d.warnings);
}
}
}
/// A template whose style table comes before its `vrsn` chunk still reads the table by the
/// version that chunk names.
#[test]
fn a_style_table_before_the_version_chunk_reads_by_that_version() {
let styles = [synth::Style { id: 0x10, parent: 0, fill: 0x100, outline: 0x200 }, synth::Style { id: 0x11, parent: 0x10, fill: 0, outline: 0 }];
let table = synth::stlt(V(1000), &[(0x100, 1)], &[(0x200, 2)], &styles, true);
let mut file = graphic_style_drawing(1000, chunk(b"junk", vec![]));
// The drawing's chunks, the table put first, ahead of `vrsn`.
let body = file.split_off(12);
file.extend(synth::plain(&table));
file.extend(body);
file[8..12].copy_from_slice(b"CDTA");
let len = (file.len() - 8) as u32;
file[4..8].copy_from_slice(&len.to_le_bytes());
let d = read(&file, Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert_eq!(s[0].fill, Some(Color::Rgb([1.0, 0.0, 0.0])));
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
}
/// A style table that doesn't parse to its end is damage when an object needs a style from it;
/// the object is drawn with what it holds itself.
#[test]
fn a_style_table_that_does_not_parse_is_damage_when_an_object_needs_it() {
let styles = [synth::Style { id: 0x10, parent: 0, fill: 0x100, outline: 0x200 }, synth::Style { id: 0x11, parent: 0x10, fill: 0, outline: 0 }];
let mut body = synth::stlt_body(V(1000), &[(0x100, 1)], &[(0x200, 2)], &styles, true);
body.push(0);
let table = chunk(b"LIST", [b"stlt".to_vec(), body].concat());
let d = read(&graphic_style_drawing(1000, table), Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert_eq!(s.len(), 3);
assert!(s[0].fill.is_none() && s[0].outline.is_none());
assert_eq!(d.warnings, vec![Warning::Damaged]);
}
/// A drawing with fill 1 (red), whose `LIST clpt` holds `groups` and whose page holds `objects`.
fn clip_drawing(version: u16, groups: Vec<(u32, Vec<synth::Node>)>, objects: Vec<synth::Node>) -> Vec<u8> {
let v = V(version);
let doc = list(
b"doc ",
vec![
synth::mcfg(v, 612.0, 792.0),
list(b"filt", vec![chunk(if version >= 700 { b"fild" } else { b"fill" }, v.fill(1, &synth::color(5, [0, 0, 255, 0])))]),
synth::clpt(groups),
],
);
let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", objects)]);
synth::file_of(version, vec![doc, page])
}
fn clip_rect(v: V, w: f64, extra: &[(u32, Vec<u8>)], at: [f64; 2]) -> synth::Node {
let mut args = vec![(20, 1u32.to_le_bytes().to_vec()), (30, v.rect(w, w, 0.0))];
args.extend(extra.iter().cloned());
synth::object(v, 1, &args, Some([1.0, 0.0, 0.0, 1.0, at[0], at[1]]))
}
/// A container (argument 8005) clips the group of `LIST clpt` whose `spnd` id it names; the
/// group's objects keep their own transforms, front to back.
#[test]
fn a_container_clips_the_group_it_names() {
for version in [700, 900, 1200, 1300, 1500, 1600, 2000] {
let v = V(version);
let contents = vec![clip_rect(v, 10.0, &[], [5.0, 6.0]), clip_rect(v, 20.0, &[], [-50.0, 0.0])];
let container = clip_rect(v, 40.0, &[synth::container(0x77)], [0.0, 0.0]);
let d = read(&clip_drawing(version, vec![(0x77, contents)], vec![container]), Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}"));
let objects = &d.pages[0].layers[0].objects;
let [Object::Clip { container, objects: clipped }] = objects.as_slice() else { panic!("{version}: {objects:?}") };
assert!(matches!(container.geometry, Geometry::Rect { w, .. } if (w - 40.0).abs() < 0.01), "{version}");
let s = shapes(clipped);
assert_eq!(s.len(), 2, "{version}");
assert!((s[0].matrix.0[4] - 5.0).abs() < 0.01 && (s[1].matrix.0[4] + 50.0).abs() < 0.01, "{version}: {:?}", s[0].matrix);
assert!(d.warnings.is_empty(), "{version}: {:?}", d.warnings);
}
}
/// The feature sample, the seed of the importer's fuzz tests, reads its style table, clipping
/// container, lens, flags, winding flag, transparency and named outline color in every version
/// from 7 to 13, plain and compressed.
#[test]
fn the_feature_sample_reads_its_styles_container_and_lens() {
for version in [700, 800, 900, 1000, 1100, 1200, 1300] {
for compress in [false, true] {
let d = read(&synth::feature_sample(version, compress), Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}"));
let objects = &d.pages[0].layers[0].objects;
let [
Object::Shape(styled),
Object::Clip { objects: clipped, .. },
Object::Shape(_),
Object::Shape(flagged),
Object::Group { objects: grouped, flags },
] = objects.as_slice()
else {
panic!("{version}: {objects:?}")
};
assert_eq!(styled.fill, Some(Color::Rgb([1.0, 0.0, 0.0])), "{version}");
assert!(styled.outline.as_ref().is_some_and(|o| o.dashes == [3.0, 1.0]), "{version}");
let s = shapes(clipped);
assert_eq!(s.len(), 2, "{version}");
assert!(s[1].outline.as_ref().is_some_and(|o| o.behind_fill), "{version}");
assert_eq!(flagged.flags, Flags { hidden: true, locked: true }, "{version}");
assert!(flagged.nonzero, "{version}");
assert_eq!(*flags, Flags { hidden: true, locked: false }, "{version}");
let named = shapes(grouped)[0].outline.as_ref().map(|o| o.color.clone());
// A transparency and a named outline color are read from version 13.
if version >= 1300 {
assert_eq!((flagged.opacity, flagged.blend), (0.75, Blend::Multiply), "{version}");
assert_eq!(named, Some(Color::Spot { name: "Sky Blue".into(), tint: 1.0, look: Some([1.0, 0.0, 0.0]) }), "{version}");
assert_eq!(d.warnings, vec![Warning::Lenses], "{version} {compress}");
} else {
assert_eq!((flagged.opacity, flagged.blend), (1.0, Blend::Normal), "{version}");
assert_eq!(named, Some(Color::Spot { name: "Spot 0:7".into(), tint: 1.0, look: None }), "{version}");
assert_eq!(d.warnings, vec![Warning::Lenses, Warning::SpotLooks], "{version} {compress}");
}
}
}
}
/// A container whose group isn't there is damage, and one whose group holds a container naming
/// it again is read once, with the limit warning; the containers stay as plain shapes.
#[test]
fn a_missing_or_repeating_clipped_group_keeps_the_container() {
let v = V(1100);
let missing = clip_rect(v, 40.0, &[synth::container(0x78)], [0.0, 0.0]);
let d = read(&clip_drawing(1100, vec![(0x77, vec![clip_rect(v, 10.0, &[], [0.0, 0.0])])], vec![missing]), Limits::default()).unwrap();
assert!(matches!(d.pages[0].layers[0].objects.as_slice(), [Object::Shape(_)]));
assert_eq!(d.warnings, vec![Warning::Damaged]);
let inner = clip_rect(v, 10.0, &[synth::container(0x77)], [0.0, 0.0]);
let outer = clip_rect(v, 40.0, &[synth::container(0x77)], [0.0, 0.0]);
let d = read(&clip_drawing(1100, vec![(0x77, vec![inner])], vec![outer]), Limits::default()).unwrap();
let [Object::Clip { objects: clipped, .. }] = d.pages[0].layers[0].objects.as_slice() else { panic!("{:?}", d.pages[0].layers[0].objects) };
assert!(matches!(clipped.as_slice(), [Object::Shape(_)]), "{clipped:?}");
assert_eq!(d.warnings, vec![Warning::TooDeep]);
}
/// Each chunk of a clipped group counts toward the clipped chunk limit every time a container
/// names the group, empty groups included; past it the containers stay as plain shapes, and a
/// group cut off at the limit leaves out its guidelines too.
#[test]
fn containers_naming_one_group_stop_at_the_clipped_chunk_limit() {
let v = V(1100);
// The group walks 53 chunks: its `spnd`, a guideline, 50 empty groups and a rectangle.
let mut guide = vec![0; 12];
guide.extend(90_000_000i32.to_le_bytes());
guide.extend([v.coord(36.0), v.coord(0.0)].concat());
let mut contents = vec![synth::object(v, 0x16, &[(16000, guide)], None)];
contents.extend((0..50).map(|_| list(b"grp ", vec![])));
contents.push(clip_rect(v, 10.0, &[], [0.0, 0.0]));
let containers: Vec<synth::Node> = (0..20).map(|_| clip_rect(v, 40.0, &[synth::container(0x77)], [0.0, 0.0])).collect();
let file = clip_drawing(1100, vec![(0x77, contents)], containers);
let count = |objects: &[Object]| objects.iter().filter(|o| matches!(o, Object::Clip { .. })).count();
let d = read(&file, Limits::default()).unwrap();
assert_eq!((count(&d.pages[0].layers[0].objects), d.pages[0].layers[0].guides.len()), (20, 20));
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
// The sixth container's walk stops after its guideline and 8 empty groups.
let d = read(&file, Limits { clipped_chunks: 53 * 5 + 10, ..Limits::default() }).unwrap();
let layer = &d.pages[0].layers[0];
assert_eq!((layer.objects.len(), count(&layer.objects), layer.guides.len()), (20, 5, 5));
assert_eq!(d.warnings, vec![Warning::TooDeep]);
}
/// A container, fill, outline or style argument too short for the id it names is damage: the
/// shape comes in as a plain shape without that id.
#[test]
fn an_id_argument_cut_short_is_damage() {
for version in [700, 1100, 1600] {
let v = V(version);
let group = vec![(0x77, vec![clip_rect(v, 10.0, &[], [0.0, 0.0])])];
let container = clip_rect(v, 40.0, &[(8005, vec![0x77, 0, 0])], [0.0, 0.0]);
let d = read(&clip_drawing(version, group, vec![container]), Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}"));
assert!(matches!(d.pages[0].layers[0].objects.as_slice(), [Object::Shape(_)]), "{version}: {:?}", d.pages[0].layers[0].objects);
assert_eq!(d.warnings, vec![Warning::Damaged], "{version}");
for kind in [20, 10, 200] {
let short = synth::object(v, 1, &[(kind, vec![1, 0]), (30, v.rect(10.0, 10.0, 0.0))], None);
let d = read(&clip_drawing(version, vec![], vec![short]), Limits::default()).unwrap_or_else(|e| panic!("{version} {kind}: {e}"));
let s = shapes(&d.pages[0].layers[0].objects);
assert!(s.len() == 1 && s[0].fill.is_none() && s[0].outline.is_none(), "{version} {kind}");
assert_eq!(d.warnings, vec![Warning::Damaged], "{version} {kind}");
}
}
}
/// A fill or outline id that no record has is damage: the shape comes in without that paint. Id 0
/// without a record is no paint.
#[test]
fn a_fill_or_outline_without_its_record_is_damage() {
for version in [700, 1100, 1600] {
let v = V(version);
for kind in [20, 10] {
for (id, want) in [(9u32, vec![Warning::Damaged]), (0, vec![])] {
let object = synth::object(v, 1, &[(kind, id.to_le_bytes().to_vec()), (30, v.rect(10.0, 10.0, 0.0))], None);
let d =
read(&clip_drawing(version, vec![], vec![object]), Limits::default()).unwrap_or_else(|e| panic!("{version} {kind} {id}: {e}"));
let s = shapes(&d.pages[0].layers[0].objects);
assert!(s.len() == 1 && s[0].fill.is_none() && s[0].outline.is_none(), "{version} {kind} {id}");
assert_eq!(d.warnings, want, "{version} {kind} {id}");
}
}
}
}
/// An object with a lens or transparency (argument 8000) comes in opaque, with the lenses
/// warning; one without the argument gives no warning.
#[test]
fn lenses_and_transparency_are_named_in_the_warnings() {
for (version, lens) in [(1000, [1u8, 0, 0, 0].to_vec()), (1200, [5, 0, 0, 0].to_vec()), (1500, [0x14, 5, 0, 0, 0x75, 0, 0, 0, 5].to_vec())] {
let v = V(version);
let plain = clip_rect(v, 10.0, &[], [0.0, 0.0]);
let d = read(&clip_drawing(version, vec![], vec![plain]), Limits::default()).unwrap();
assert!(d.warnings.is_empty(), "{version}: {:?}", d.warnings);
let see_through = clip_rect(v, 10.0, &[(8000, lens)], [0.0, 0.0]);
let d = read(&clip_drawing(version, vec![], vec![see_through]), Limits::default()).unwrap();
assert_eq!(shapes(&d.pages[0].layers[0].objects).len(), 1, "{version}");
assert_eq!(d.warnings, vec![Warning::Lenses], "{version}");
}
}
/// From version 13 a uniform transparency (a 117-byte record of version 1300 in argument 8000)
/// gives the shape its opacity and blend mode, records of other versions before it skipped. A
/// lens record, a value outside 0 to 100, a merge mode without a blend mode, and the record in an
/// earlier version are not applied: the shape stays opaque, with the lenses warning.
#[test]
fn a_uniform_transparency_from_version_13_applies() {
let record = |since: u32, body: Vec<u8>| [since.to_le_bytes().to_vec(), (body.len() as u32).to_le_bytes().to_vec(), body].concat();
for version in [1300, 1500, 1600, 2000] {
let v = V(version);
let read_with = |arg: Vec<u8>| {
let d = read(&clip_drawing(version, vec![], vec![clip_rect(v, 10.0, &[(8000, arg)], [0.0, 0.0])]), Limits::default())
.unwrap_or_else(|e| panic!("{version}: {e}"));
let s = shapes(&d.pages[0].layers[0].objects)[0];
((s.opacity, s.blend), d.warnings)
};
for (percent, merge, want) in [(25.0, 0, Blend::Normal), (0.0, 9, Blend::Multiply), (100.0, 28, Blend::Screen), (60.0, 36, Blend::Exclusion)]
{
let opacity = (1.0 - percent / 100.0) as f32;
assert_eq!(read_with(synth::transparency(percent, merge).1), ((opacity, want), vec![]), "{version} {percent} {merge}");
}
// A record of a later version comes first.
let later = [record(1600, vec![0; 20]), synth::transparency(25.0, 0).1].concat();
assert_eq!(read_with(later), ((0.75, Blend::Normal), vec![]), "{version}");
let opaque = ((1.0, Blend::Normal), vec![Warning::Lenses]);
assert_eq!(read_with(record(1300, vec![0; 84])), opaque, "{version}: a lens");
for bad in [150.0, -1.0, f64::NAN] {
assert_eq!(read_with(synth::transparency(bad, 0).1), opaque, "{version} {bad}");
}
for merge in [1, 2, 3, 6, 7, 8, 10, 13, 18, 19, 20, 27, 37, 255] {
assert_eq!(read_with(synth::transparency(25.0, merge).1), opaque, "{version} {merge}");
}
assert_eq!(read_with(vec![]), opaque, "{version}: empty");
}
let d =
read(&clip_drawing(1200, vec![], vec![clip_rect(V(1200), 10.0, &[synth::transparency(25.0, 0)], [0.0, 0.0])]), Limits::default()).unwrap();
assert_eq!(shapes(&d.pages[0].layers[0].objects)[0].opacity, 1.0);
assert_eq!(d.warnings, vec![Warning::Lenses]);
}
/// Bit 0x01 of byte 1 of a layer's, group's or object's flags hides it and bit 0x10 of byte 0
/// locks it, in every version; a group left ungrouped at the object limit passes its flags to its
/// objects.
#[test]
fn flags_hide_and_lock_layers_groups_and_objects() {
for version in [300, 700, 1100, 1300, 1600] {
let v = V(version);
let rect = |flags: [u8; 4]| synth::flagged(synth::object(v, 1, &[(30, v.rect(10.0, 10.0, 0.0))], None), flags);
let group = |flags: [u8; 4], objects: Vec<synth::Node>| {
let mut kids = vec![chunk(b"flgs", flags.to_vec())];
kids.extend(objects);
list(b"grp ", kids)
};
let objects = vec![
rect([0, 0, 0, 8]),
rect([0, 1, 0, 8]),
rect([0x10, 0, 0, 8]),
rect([0x10, 1, 0, 8]),
group([0x10, 1, 0, 0x10], vec![rect([0, 0, 0, 8])]),
];
let layers =
vec![synth::layer(v, [0, 0, 0, 0x98], "Shown", objects), synth::layer(v, [0x10, 1, 0, 0x98], "Hidden", vec![rect([0, 0, 0, 8])])];
let file = synth::file_of(version, vec![synth::page(false, layers)]);
let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}"));
let [shown, hidden] = d.pages[0].layers.as_slice() else { panic!("{version}: {:?}", d.pages[0].layers) };
assert_eq!(shown.flags, Flags::default(), "{version}");
assert_eq!(hidden.flags, Flags { hidden: true, locked: true }, "{version}");
let f = |hidden: bool, locked: bool| Flags { hidden, locked };
let own: Vec<Flags> = shown
.objects
.iter()
.map(|o| match o {
Object::Shape(s) => s.flags,
Object::Group { flags, .. } => *flags,
Object::Clip { container, .. } => container.flags,
})
.collect();
assert_eq!(own, [f(false, false), f(true, false), f(false, true), f(true, true), f(true, true)], "{version}");
assert!(
matches!(&shown.objects[4], Object::Group { objects, .. } if matches!(&objects[0], Object::Shape(s) if s.flags == Flags::default())),
"{version}"
);
assert!(d.warnings.contains(&Warning::UnsupportedObjects) || d.warnings.is_empty(), "{version}: {:?}", d.warnings);
// Past the object limit the group's rectangle comes in ungrouped, hidden and locked.
let d = read(&file, Limits { objects: 5, ..Limits::default() }).unwrap_or_else(|e| panic!("{version}: {e}"));
let last = d.pages[0].layers[0].objects.last();
assert!(matches!(last, Some(Object::Shape(s)) if s.flags == f(true, true)), "{version}: {last:?}");
}
}
/// A guideline is hidden when its own object, a group around it or its layer is.
#[test]
fn hidden_guidelines_say_so() {
for version in [700, 1300, 1600] {
let v = V(version);
let guide = |flags: [u8; 4]| {
let mut arg = vec![0; 12];
arg.extend(90_000_000i32.to_le_bytes());
arg.extend([v.coord(36.0), v.coord(0.0)].concat());
synth::flagged(synth::object(v, 0x16, &[(16000, arg)], None), flags)
};
let group = list(b"grp ", vec![chunk(b"flgs", vec![0, 1, 0, 0x10]), guide([0, 0, 0, 8])]);
let layers = vec![
synth::layer(v, [0, 0, 0, 0x98], "Shown", vec![guide([0, 0, 0, 8]), guide([0, 1, 0, 8]), group]),
synth::layer(v, [0, 1, 0, 0x98], "Hidden", vec![guide([0, 0, 0, 8])]),
];
let d = read(&synth::file_of(version, vec![synth::page(false, layers)]), Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}"));
let hidden: Vec<Vec<bool>> = d.pages[0].layers.iter().map(|l| l.guides.iter().map(|g| g.hidden).collect()).collect();
assert_eq!(hidden, [vec![false, true, true], vec![true]], "{version}");
}
}
/// Byte 0 of argument 14001 other than 0 fills the shape nonzero; 0, or no argument, fills it
/// even-odd; an argument without its byte is damage.
#[test]
fn a_winding_flag_fills_nonzero() {
for version in [300, 700, 1200, 1600] {
let v = V(version);
let read_with = |extra: &[(u32, Vec<u8>)]| {
let mut args = vec![(30, v.rect(10.0, 10.0, 0.0))];
args.extend(extra.iter().cloned());
let file = synth::file_of(
version,
vec![synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &args, None)])])],
);
let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}"));
(shapes(&d.pages[0].layers[0].objects)[0].nonzero, d.warnings)
};
assert_eq!(read_with(&[(14001, vec![1, 0, 0, 0])]), (true, vec![]), "{version}");
assert_eq!(read_with(&[(14001, vec![2])]), (true, vec![]), "{version}");
assert_eq!(read_with(&[(14001, vec![0, 0, 0, 0])]), (false, vec![]), "{version}");
assert_eq!(read_with(&[]), (false, vec![]), "{version}");
assert_eq!(read_with(&[(14001, vec![])]), (false, vec![Warning::Damaged]), "{version}");
}
}
/// A `cdr8` form type makes the file the 8.01 variant whatever its `vrsn` chunk names: its style
/// table is read with the 8.01 layout.
#[test]
fn a_cdr8_file_whose_version_chunk_names_800_reads_as_801() {
let styles = [synth::Style { id: 0x10, parent: 0, fill: 0x100, outline: 0x200 }, synth::Style { id: 0x11, parent: 0x10, fill: 0, outline: 0 }];
for named in [800u16, 900, 1300] {
let table = synth::stlt(V(801), &[(0x100, 1)], &[(0x200, 2)], &styles, true);
let mut file = graphic_style_drawing(801, table);
file[8..12].copy_from_slice(b"cdr8");
let at = file.windows(4).position(|w| w == b"vrsn").unwrap() + 8;
assert_eq!(&file[at..at + 2], &801u16.to_le_bytes());
file[at..at + 2].copy_from_slice(&named.to_le_bytes());
let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{named}: {e}"));
assert_eq!(d.version, 801, "{named}");
let s = shapes(&d.pages[0].layers[0].objects);
assert_eq!(s[0].fill, Some(Color::Rgb([1.0, 0.0, 0.0])), "{named}");
assert!(d.warnings.is_empty(), "{named}: {:?}", d.warnings);
}
}
/// Before version 6 an object names its style in 2 bytes, which is not damage; an argument too
/// short for them is.
#[test]
fn a_style_id_before_version_6_is_two_bytes() {
for version in [400, 500] {
let v = V(version);
let read_with = |style: Vec<u8>| {
let object = synth::object(v, 1, &[(200, style), (30, v.rect(10.0, 10.0, 0.0))], None);
let file = synth::file_of(version, vec![synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![object])])]);
let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}"));
(shapes(&d.pages[0].layers[0].objects).len(), d.warnings)
};
assert_eq!(read_with(vec![0x10, 0]), (1, vec![]), "{version}");
assert_eq!(read_with(vec![0x10]), (1, vec![Warning::Damaged]), "{version}");
}
}
/// A hidden or locked group of `LIST clpt` hides or locks the objects a container clips from it.
#[test]
fn a_clipped_groups_flags_reach_its_objects() {
for version in [700, 1300, 1600] {
let v = V(version);
let group = list(
b"grp ",
vec![chunk(b"flgs", vec![0x10, 1, 0x80, 0x10]), chunk(b"spnd", 0x77u32.to_le_bytes().to_vec()), clip_rect(v, 10.0, &[], [0.0, 0.0])],
);
let doc = list(b"doc ", vec![synth::mcfg(v, 612.0, 792.0), list(b"clpt", vec![group])]);
let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![clip_rect(v, 40.0, &[synth::container(0x77)], [0.0, 0.0])])]);
let d = read(&synth::file_of(version, vec![doc, page]), Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}"));
let [Object::Clip { container, objects }] = d.pages[0].layers[0].objects.as_slice() else {
panic!("{version}: {:?}", d.pages[0].layers[0].objects)
};
assert_eq!(container.flags, Flags::default(), "{version}");
assert!(matches!(objects.as_slice(), [Object::Shape(s)] if s.flags == Flags { hidden: true, locked: true }), "{version}: {objects:?}");
}
}
/// Before version 6 a clipped group's `spnd` id is 2 bytes.
#[test]
fn a_clipped_group_id_before_version_6_is_two_bytes() {
for version in [400, 500] {
let v = V(version);
let rect = |w: f64, extra: Vec<(u32, Vec<u8>)>| {
let mut args = vec![(30, v.rect(w, w, 0.0))];
args.extend(extra);
synth::object(v, 1, &args, None)
};
let clpt = list(b"clpt", vec![list(b"grp ", vec![chunk(b"spnd", vec![0x77, 0]), rect(10.0, vec![])])]);
let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![rect(40.0, vec![synth::container(0x77)])])]);
let d = read(&synth::file_of(version, vec![list(b"doc ", vec![synth::mcfg(v, 612.0, 792.0), clpt]), page]), Limits::default())
.unwrap_or_else(|e| panic!("{version}: {e}"));
let objects = &d.pages[0].layers[0].objects;
assert!(matches!(objects.as_slice(), [Object::Clip { objects, .. }] if objects.len() == 1), "{version}: {objects:?}");
assert!(d.warnings.is_empty(), "{version}: {:?}", d.warnings);
}
}
/// A `trfd` entry ends at the next offset: one too short for its matrix makes the transform
/// damage and leaves the shape in place, even when the bytes after it would read as a matrix. A
/// table that stops before the last entry's end offset leaves that entry the rest of the record.
#[test]
fn a_transform_entry_ends_at_the_next_offset() {
for version in [400, 1100, 1300, 1600] {
let v = V(version);
let w = if version < 600 { 2 } else { 4 };
let moved = [1.0, 0.0, 0.0, 1.0, 72.0, 0.0];
let object = |trfd: Vec<u8>| {
let own = vec![chunk(b"loda", v.loda(1, &[(30, v.rect(10.0, 10.0, 0.0))])), list(b"trfl", vec![chunk(b"trfd", trfd)])];
list(b"obj ", vec![chunk(b"flgs", vec![0, 0, 0, 8]), list(b"lgob", own)])
};
let read_with = |trfd: Vec<u8>| {
let file = synth::file_of(version, vec![synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![object(trfd)])])]);
let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}"));
(shapes(&d.pages[0].layers[0].objects)[0].matrix.0[4], d.warnings)
};
let whole = v.trfd(&[moved]);
assert!((read_with(whole.clone()).0 - 72.0).abs() < 0.01, "{version}");
// The end offset, right after the first, made 4 bytes past the entry's start.
let mut short = whole.clone();
let start = if w == 2 {
usize::from(u16::from_le_bytes([short[3 * w], short[3 * w + 1]]))
} else {
u32::from_le_bytes(short[12..16].try_into().unwrap()) as usize
};
short[4 * w..5 * w].copy_from_slice(&v.word(start + 4));
assert_eq!(read_with(short), (0.0, vec![Warning::Damaged]), "{version}");
// The entry first, then a table of its start alone at the record's end.
let entry = whole[5 * w..].to_vec();
let at = 3 * w + entry.len();
let mut end = [v.word(at + w), v.word(1), v.word(at)].concat();
end.extend(entry);
end.extend(v.word(3 * w));
let (x, warnings) = read_with(end);
assert!((x - 72.0).abs() < 0.01 && warnings.is_empty(), "{version}: {x} {warnings:?}");
}
}
/// From version 13 an outline's record of type 2 that names a library color gives the outline
/// that color; one without a name leaves the fixed color field.
#[test]
fn an_outline_takes_a_named_library_color_from_its_property_list() {
for version in [1300, 1500, 1600] {
let v = V(version);
let read_with = |props: Vec<u8>| {
let mut outl = v.outline(4, synth::Pen { line_type: 0, width: 1.0, cap: 0, join: 0 }, &synth::color(2, [0, 0, 0, 100]), &[]);
let mut record = 2u32.to_le_bytes().to_vec();
record.extend((props.len() as u32).to_le_bytes());
record.extend(props);
outl.splice(4..4, record);
let doc = list(b"doc ", vec![synth::mcfg(v, 612.0, 792.0), list(b"otlt", vec![chunk(b"outl", outl)])]);
let object = synth::object(v, 1, &[(10, 4u32.to_le_bytes().to_vec()), (30, v.rect(10.0, 10.0, 0.0))], None);
let file = synth::file_of(version, vec![doc, synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![object])])]);
let d = read(&file, Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}"));
(shapes(&d.pages[0].layers[0].objects)[0].outline.as_ref().map(|o| o.color.clone()), d.warnings)
};
let named = synth::properties(&synth::color(5, [0, 0, 255, 0]), Some("Sky Blue"));
assert_eq!(read_with(named), (Some(Color::Spot { name: "Sky Blue".into(), tint: 1.0, look: Some([1.0, 0.0, 0.0]) }), vec![]), "{version}");
let plain = synth::properties(&synth::color(5, [0, 0, 255, 0]), None);
assert_eq!(read_with(plain), (Some(Color::Cmyk([0.0, 0.0, 0.0, 1.0])), vec![]), "{version}");
}
}
#[test]
fn linked_groups_are_left_out_with_a_warning() {
let v = V(1100);
let rect = synth::object(v, 1, &[(30, [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat())], None);
let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![list(b"lnkg", vec![rect])])])]);
let d = read(&file, Limits::default()).unwrap();
assert!(d.pages[0].layers[0].objects.is_empty());
assert!(d.warnings.contains(&Warning::UnsupportedObjects));
}
#[test]
fn a_file_cut_short_keeps_what_it_holds() {
let full = synth::sample(900, false);
let cut = &full[..full.len() - 40];
let d = read(cut, Limits::default()).unwrap();
assert!(d.warnings.contains(&Warning::Damaged));
// The last page is cut inside its layer: the lists that hold the cut keep their whole
// children, so the rectangle, ellipse and curve before the cut are read.
assert_eq!(d.pages.len(), 1);
let s = shapes(&d.pages[0].layers[0].objects);
assert!(s.len() >= 3, "{}", s.len());
assert!(matches!(s[0].geometry, Geometry::Rect { .. }) && matches!(s[1].geometry, Geometry::Ellipse { .. }));
}
#[test]
fn a_riff_length_shorter_than_the_form_type_is_damage() {
for declared in 0u32..4 {
let mut file = synth::sample(900, false);
file[4..8].copy_from_slice(&declared.to_le_bytes());
let d = read(&file, Limits::default()).unwrap();
assert!(d.warnings.contains(&Warning::Damaged), "{declared}");
check_shapes(&d, 900);
}
}
#[test]
fn a_zip_bomb_stops_at_the_inflate_limit() {
let v = V(1100);
let big = chunk(b"junk", vec![0; 4 << 20]);
let file = synth::riff(1100, &[chunk(b"vrsn", 1100u16.to_le_bytes().to_vec()), synth::cmpr(&[big, synth::mcfg(v, 10.0, 10.0)])]);
assert!(file.len() < 64 << 10);
let limits = Limits { inflated: 1 << 20, ..Limits::default() };
assert_eq!(read(&file, limits), Err(Error::Limit("inflated size")));
}
/// What a compressed stream inflates before it fails counts toward the inflate limit, so that
/// streams failing at their checksum can't each inflate up to the limit.
#[test]
fn bytes_inflated_by_a_failing_stream_count_toward_the_limit() {
let failing = || {
let mut cmpr = synth::cmpr(&[chunk(b"junk", vec![0; 600 << 10])]);
if let synth::Node::Chunk(_, body) = &mut cmpr {
// The last byte of the first block's zlib stream is part of its checksum.
let first = u32::from_le_bytes(body[4..8].try_into().unwrap()) as usize;
body[4 + 16 + first - 1] ^= 0xff;
}
cmpr
};
let file = synth::riff(1100, &[chunk(b"vrsn", 1100u16.to_le_bytes().to_vec()), failing(), failing()]);
let one =
read(&synth::riff(1100, &[chunk(b"vrsn", 1100u16.to_le_bytes().to_vec()), failing()]), Limits { inflated: 1 << 20, ..Limits::default() });
assert!(one.is_ok_and(|d| d.warnings == vec![Warning::Damaged]));
assert_eq!(read(&file, Limits { inflated: 1 << 20, ..Limits::default() }), Err(Error::Limit("inflated size")));
}
#[test]
fn a_million_empty_chunks_stop_at_the_chunk_limit() {
let kids: Vec<_> = (0..5000).map(|_| chunk(b"junk", vec![])).collect();
let file = synth::riff(1100, &[list(b"doc ", kids)]);
let limits = Limits { chunks: 1000, ..Limits::default() };
assert_eq!(read(&file, limits), Err(Error::Limit("chunk count")));
assert!(read(&file, Limits::default()).is_ok());
}
#[test]
fn deep_nesting_is_left_out_with_a_warning() {
let v = V(1100);
let mut inner = synth::object(v, 1, &[(30, [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat())], None);
for _ in 0..300 {
inner = list(b"grp ", vec![inner]);
}
let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![inner])])]);
let d = read(&file, Limits::default()).unwrap();
assert!(d.warnings.contains(&Warning::TooDeep));
}
#[test]
fn a_size_pool_index_out_of_range_is_damage() {
// A compressed stream whose one chunk names pool entry 7 of a pool of one.
let mut cmpr = synth::cmpr(&[chunk(b"mcfg", vec![0; 8])]);
if let synth::Node::Chunk(_, body) = &mut cmpr {
// Rebuild the stream with a bad index: the pool keeps its one size.
let mut stream = b"mcfg".to_vec();
stream.extend(7u32.to_le_bytes());
stream.extend([0; 8]);
let mut e = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
std::io::Write::write_all(&mut e, &stream).unwrap();
let z = e.finish().unwrap();
let pool_block = body[4 + 16 + u32::from_le_bytes(body[4..8].try_into().unwrap()) as usize..].to_vec();
let mut b = b"cmpr".to_vec();
b.extend(((z.len() + 8) as u32).to_le_bytes());
b.extend((stream.len() as u32).to_le_bytes());
b.extend(body[12..20].to_vec());
b.extend(b"CPng\x01\x00\x04\x00");
b.extend(z);
b.extend(pool_block);
*body = b;
}
let d = read(&synth::riff(1100, &[cmpr]), Limits::default()).unwrap();
assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings);
}
#[test]
fn backward_and_huge_loda_offsets_do_not_panic() {
let v = V(1100);
let mut loda = v.loda(3, &[(30, v.points(&[(0.0, 0.0, 0), (1.0, 1.0, 0x40)]))]);
// The offsets table now points before the header and far past the end.
let at = u32::from_le_bytes(loda[8..12].try_into().unwrap()) as usize;
loda[at..at + 4].copy_from_slice(&40u32.to_le_bytes());
loda[at + 4..at + 8].copy_from_slice(&2u32.to_le_bytes());
let obj = list(b"obj ", vec![chunk(b"loda", loda)]);
let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![obj])])]);
let d = read(&file, Limits::default()).unwrap();
assert!(d.warnings.contains(&Warning::Damaged));
}
#[test]
fn outlines_flagged_none_and_dashes_read() {
let v = V(1300);
let black = synth::color(2, [0, 0, 0, 100]);
let dashed = v.outline(9, synth::Pen { line_type: 4, width: 1.0, cap: 2, join: 2 }, &black, &[3, 1]);
let style = vec![(10, 9u32.to_le_bytes().to_vec()), (30, v.points(&[(0.0, 0.0, 0), (10.0, 0.0, 0x40)]))];
let file = synth::riff(
1300,
&[
chunk(b"vrsn", 1300u16.to_le_bytes().to_vec()),
list(b"otlt", vec![chunk(b"outl", dashed)]),
synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 3, &style, None)])]),
],
);
let d = read(&file, Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
let o = s[0].outline.as_ref().unwrap();
assert_eq!(o.dashes, vec![3.0, 1.0]);
assert_eq!((o.cap, o.join), (Cap::Square, vectorcraft_cdr::model::Join::Bevel));
}
/// A curve or polygon left out at the coordinate limit gives the limit warning, not the damage
/// warning.
#[test]
fn shapes_past_the_coordinate_limit_are_not_damage() {
let v = V(1100);
let curve = synth::object(v, 3, &[(30, v.points(&[(0.0, 0.0, 0), (10.0, 0.0, 0x40), (10.0, 10.0, 0x40)]))], None);
let side = synth::POLYGON_SIDE;
let mut sides = vec![0; 4];
sides.extend(5u32.to_le_bytes());
sides.extend([0; 8]);
sides.extend(0.05f64.to_le_bytes());
sides.extend(0.05f64.to_le_bytes());
sides.extend([v.coord(0.0), v.coord(0.0)].concat());
let base = v.points(&[(0.0, side, 0x0C), (side * 0.587, side * 0.809, 0x44)]);
let polygon = synth::object(v, 0x14, &[(30, base.clone()), (11000, sides)], None);
for (objects, limit) in [(vec![curve], 2), (vec![polygon], 4)] {
let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", objects)])]);
let d = read(&file, Limits { coordinates: limit, ..Limits::default() }).unwrap();
assert!(d.pages[0].layers[0].objects.is_empty());
assert_eq!(d.warnings, vec![Warning::TooDeep]);
}
// A polygon without its sides is damage, past the limit too.
let sideless = synth::object(v, 0x14, &[(30, base)], None);
let file = synth::riff(1100, &[synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![sideless])])]);
let d = read(&file, Limits { coordinates: 1, ..Limits::default() }).unwrap();
assert_eq!(d.warnings, vec![Warning::Damaged]);
}
/// Dashes stored in an outline whose line type doesn't mark it dashed (bit 2) are not drawn: the
/// outline is solid.
#[test]
fn dashes_are_drawn_only_when_the_line_type_marks_them() {
let black = synth::color(2, [0, 0, 0, 100]);
for version in [700, 1200, 1500] {
for (line_type, dashed) in [(2, false), (0x22, false), (0x42, false), (4, true), (0x24, true), (0x44, true)] {
let v = V(version);
let outline = v.outline(9, synth::Pen { line_type, width: 1.0, cap: 0, join: 0 }, &black, &[2, 1]);
let style = vec![(10, 9u32.to_le_bytes().to_vec()), (30, v.points(&[(0.0, 0.0, 0), (10.0, 0.0, 0x40)]))];
let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 3, &style, None)])]);
let d = read(&synth::file_of(version, vec![list(b"otlt", vec![chunk(b"outl", outline)]), page]), Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
let o = s[0].outline.as_ref().unwrap();
assert_eq!(o.dashes.is_empty(), !dashed, "{version} {line_type:#x}: {:?}", o.dashes);
}
}
}
/// Bit 4 of the line type puts the outline behind the fill.
#[test]
fn outlines_flagged_behind_the_fill_say_so() {
let black = synth::color(2, [0, 0, 0, 100]);
for version in [700, 1300, 1600] {
for (line_type, behind) in [(2, false), (0x22, false), (0x12, true), (0x14, true)] {
let v = V(version);
let outline = v.outline(9, synth::Pen { line_type, width: 4.0, cap: 0, join: 0 }, &black, &[]);
let style = vec![(10, 9u32.to_le_bytes().to_vec()), (30, v.rect(10.0, 10.0, 0.0))];
let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &style, None)])]);
let d = read(&synth::file_of(version, vec![list(b"otlt", vec![chunk(b"outl", outline)]), page]), Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert_eq!(s[0].outline.as_ref().map(|o| o.behind_fill), Some(behind), "{version} {line_type:#x}");
}
}
}
/// Bit 5 of the line type scales the outline with the shape.
#[test]
fn outlines_flagged_to_scale_with_the_shape_say_so() {
let black = synth::color(2, [0, 0, 0, 100]);
for version in [700, 1300, 1600] {
for (line_type, scale_with) in [(2, false), (0x22, true), (0x12, false), (0x26, true)] {
let v = V(version);
let outline = v.outline(9, synth::Pen { line_type, width: 4.0, cap: 0, join: 0 }, &black, &[]);
let style = vec![(10, 9u32.to_le_bytes().to_vec()), (30, v.rect(10.0, 10.0, 0.0))];
let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &style, None)])]);
let d = read(&synth::file_of(version, vec![list(b"otlt", vec![chunk(b"outl", outline)]), page]), Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert_eq!(s[0].outline.as_ref().map(|o| o.scale_with), Some(scale_with), "{version} {line_type:#x}");
}
}
}
#[test]
fn library_colors_from_version_13_keep_their_names_and_tints() {
// A model 21 color (blue, green, red, tint) shown at 50 %, and its library name.
let shown = synth::color(21, [255, 191, 128, 50]);
let mut props = vec![1];
props.extend(12u32.to_le_bytes());
props.extend(shown);
props.push(8);
let name: Vec<u8> = "Sky Blue".encode_utf16().flat_map(|u| u.to_le_bytes()).collect();
props.extend((16 + 4 + name.len() as u32).to_le_bytes());
props.extend([0; 16]);
props.extend(8u32.to_le_bytes());
props.extend(name);
props.extend([0, 0, 0, 0, 0]);
let mut solid = 1300u32.to_le_bytes().to_vec();
solid.extend((props.len() as u32).to_le_bytes());
solid.extend(props);
let mut body = 1u16.to_le_bytes().to_vec();
body.extend(solid);
let mut fill = 4u32.to_le_bytes().to_vec();
// A record of a later layout first, which the reader steps over.
fill.extend(2400u32.to_le_bytes());
fill.extend(16u32.to_le_bytes());
fill.extend([0; 16]);
fill.extend(1300u32.to_le_bytes());
fill.extend((body.len() as u32).to_le_bytes());
fill.extend(body);
// The same records in a plain file of version 13 and the packages of later versions.
for version in [1300, 1400, 1700, 2700] {
let v = V(version);
let style = vec![(20, 4u32.to_le_bytes().to_vec()), (30, v.rect(1.0, 1.0, 0.0))];
let body = [
chunk(b"vrsn", version.to_le_bytes().to_vec()),
list(b"filt", vec![chunk(b"fild", fill.clone())]),
synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", vec![synth::object(v, 1, &style, None)])]),
];
let file = match version {
..1400 => synth::riff(version, &body),
1400..1600 => synth::package14(synth::riff(version, &body), true),
_ => synth::package16(version, &body, true, &[]),
};
let d = read(&file, Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
let Some(Color::Spot { name, tint, look: Some(look) }) = &s[0].fill else { panic!("{version}: {:?}", s[0].fill) };
assert_eq!((name.as_str(), *tint), ("Sky Blue", 0.5));
// 128/255 shown at half strength comes from about 1/255 at full strength.
assert!(look[0] < 0.01 && (look[2] - 1.0).abs() < 1e-6, "{version}: {look:?}");
}
}
/// One rectangle of version `v` that uses fill `fill` and outline `outline` (0: none).
fn styled_rect(v: V, fill: u32, outline: u32) -> synth::Node {
let mut args = vec![(30, [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat())];
if fill != 0 {
args.push((20, fill.to_le_bytes().to_vec()));
}
if outline != 0 {
args.push((10, outline.to_le_bytes().to_vec()));
}
synth::object(v, 1, &args, None)
}
/// A drawing of version `v` with `styles` in its `doc` list and `objects` on one page.
fn styled_drawing(v: V, styles: Vec<synth::Node>, objects: Vec<synth::Node>) -> Vec<u8> {
let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "L", objects)]);
synth::riff(v.0, &[chunk(b"vrsn", v.0.to_le_bytes().to_vec()), list(b"doc ", styles), page])
}
/// An outline's dashes count toward the read's dashes for every shape that uses it: one outline
/// of 65,535 dashes on 260 shapes would copy 17 million dashes, past the default limit.
#[test]
fn a_shared_dashed_outline_counts_its_dashes_for_every_shape() {
let v = V(1300);
let pen = synth::Pen { line_type: 4, width: 1.0, cap: 0, join: 0 };
let outl = |dashes: &[u16]| list(b"otlt", vec![chunk(b"outl", v.outline(9, pen, &synth::color(2, [0, 0, 0, 100]), dashes))]);
let file = styled_drawing(v, vec![outl(&[2, 1].repeat(10))], (0..20).map(|_| styled_rect(v, 0, 9)).collect());
let d = read(&file, Limits { dashes: 100, ..Limits::default() }).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert_eq!(s.len(), 20);
let dashed = s.iter().filter(|s| s.outline.as_ref().is_some_and(|o| o.dashes.len() == 20)).count();
assert_eq!(dashed, 5, "100 dashes hold five outlines of 20");
assert!(s.iter().all(|s| s.outline.as_ref().is_some_and(|o| o.dashes.is_empty() || o.dashes.len() == 20)));
assert!(d.warnings.contains(&Warning::TooDeep), "{:?}", d.warnings);
// An outline with more dashes than the limit is solid, not cut short.
let file = styled_drawing(v, vec![outl(&[2, 1])], vec![styled_rect(v, 0, 9)]);
let d = read(&file, Limits { dashes: 1, ..Limits::default() }).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert!(s[0].outline.as_ref().is_some_and(|o| o.dashes.is_empty()), "{:?}", s[0].outline);
assert_eq!(d.warnings, vec![Warning::TooDeep]);
// At the default limit.
let file = styled_drawing(v, vec![outl(&[1; 65_535])], (0..260).map(|_| styled_rect(v, 0, 9)).collect());
assert!(file.len() < 256 << 10);
let d = read(&file, Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
let total: usize = s.iter().filter_map(|s| s.outline.as_ref()).map(|o| o.dashes.len()).sum();
assert!(total <= Limits::default().dashes, "{total}");
assert!(d.warnings.contains(&Warning::TooDeep), "{:?}", d.warnings);
}
/// A library color's name is copied for every shape that uses it: a long one keeps its first 256
/// units and a hash of the whole name.
#[test]
fn a_library_color_keeps_the_first_256_units_of_its_name() {
let v = V(1300);
let mut props = vec![1];
props.extend(12u32.to_le_bytes());
props.extend(synth::color(21, [255, 191, 128, 100]));
props.push(8);
let name: Vec<u8> = "N".repeat(10_000).encode_utf16().flat_map(|u| u.to_le_bytes()).collect();
props.extend((16 + 4 + name.len() as u32).to_le_bytes());
props.extend([0; 16]);
props.extend(10_000u32.to_le_bytes());
props.extend(name);
props.extend([0, 0, 0, 0, 0]);
let mut body = 1u16.to_le_bytes().to_vec();
body.extend(1300u32.to_le_bytes());
body.extend((props.len() as u32).to_le_bytes());
body.extend(props);
let mut fill = 4u32.to_le_bytes().to_vec();
fill.extend(1300u32.to_le_bytes());
fill.extend((body.len() as u32).to_le_bytes());
fill.extend(body);
let d = read(&styled_drawing(v, vec![list(b"filt", vec![chunk(b"fild", fill)])], vec![styled_rect(v, 4, 0)]), Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
let Some(Color::Spot { name, .. }) = &s[0].fill else { panic!("{:?}", s[0].fill) };
assert_eq!(name.chars().count(), 256 + 17, "{name}");
assert!(name.starts_with(&"N".repeat(256)), "{name}");
assert!(d.warnings.contains(&Warning::TooDeep), "{:?}", d.warnings);
}
/// A transform or a uniform fill's color that is there but can't be read is damage: the shape
/// stays, without its transform or its fill, and the warnings say so.
#[test]
fn unreadable_transforms_and_fill_colors_are_damage() {
let v = V(1100);
let rect = [v.coord(1.0), v.coord(1.0), v.coord(0.0), v.coord(0.0), v.coord(0.0), v.coord(0.0)].concat();
let obj = list(b"obj ", vec![chunk(b"loda", v.loda(1, &[(30, rect)])), list(b"trfl", vec![chunk(b"trfd", vec![1, 2])])]);
let d = read(&styled_drawing(v, vec![], vec![obj]), Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert_eq!((s.len(), s[0].matrix), (1, vectorcraft_cdr::model::Matrix::IDENTITY));
assert!(d.warnings.contains(&Warning::Damaged), "trfd: {:?}", d.warnings);
// A uniform fill cut off in its color record, before version 13 and from it.
for v in [V(1100), V(1300)] {
let mut fill = v.fill(4, &synth::color(2, [0, 100, 0, 0]));
fill.truncate(fill.len() - 10);
let d = read(&styled_drawing(v, vec![list(b"filt", vec![chunk(b"fild", fill)])], vec![styled_rect(v, 4, 0)]), Limits::default()).unwrap();
let s = shapes(&d.pages[0].layers[0].objects);
assert_eq!(s[0].fill, None, "{}", v.0);
assert!(d.warnings.contains(&Warning::Damaged), "fill {}: {:?}", v.0, d.warnings);
}
}
/// The inflate limit may be as large as `usize` holds.
#[test]
fn the_largest_inflate_limit_reads_compressed_lists() {
let d = read(&synth::sample(1100, true), Limits { inflated: usize::MAX, ..Limits::default() }).unwrap();
check_shapes(&d, 1100);
}
proptest! {
#![proptest_config(ProptestConfig { cases: 256, ..ProptestConfig::default() })]
#[test]
fn never_panics_on_garbage(bytes in prop::collection::vec(any::<u8>(), 0..2048)) {
let mut b = b"RIFF".to_vec();
b.extend(bytes);
let _ = read(&b, Limits::default());
}
#[test]
fn never_panics_on_mutated_samples(version in prop::sample::select(vec![300u16, 400, 500, 700, 900, 1100, 1300]), compress: bool, edits in prop::collection::vec((any::<usize>(), any::<u8>()), 1..24)) {
let mut b = synth::sample(version, compress && version >= 700);
let n = b.len();
for (at, v) in edits {
b[at % n] = v;
}
let _ = read(&b, Limits::default());
}
#[test]
fn never_panics_on_garbage_after_a_wl_header(marker in prop::sample::select(vec![b'e', b'l', b'm']), bytes in prop::collection::vec(any::<u8>(), 0..2048)) {
// Offsets that fit the file, so the garbage is walked as records.
let mut b = vec![b'W', b'L', marker, 0];
b.extend(28u32.to_le_bytes());
b.extend(28u32.to_le_bytes());
b.extend((28 + bytes.len() as u32).to_le_bytes());
b.extend([0; 12]);
b.extend(bytes);
prop_assert!(vectorcraft_cdr::is_cdr(&b));
let _ = read(&b, Limits::default());
}
#[test]
fn never_panics_on_mutated_wl_files(marker in prop::sample::select(vec![b'e', b'l', b'm']), cut in any::<usize>(), edits in prop::collection::vec((any::<usize>(), any::<u8>()), 1..24)) {
let mut b = synth::wl_sample(marker);
let n = b.len();
for (at, v) in edits {
b[at % n] = v;
}
let _ = read(&b, Limits::default());
let _ = read(&b[..cut % (n + 1)], Limits::default());
}
#[test]
fn never_panics_on_mutated_packages(version in prop::sample::select(vec![1400u16, 1500, 1700, 2700]), edits in prop::collection::vec((any::<usize>(), any::<usize>(), any::<u8>()), 1..24)) {
// The members are edited before they are zipped, so that the edits reach the chunks and
// redirect records rather than stop at the CRC-32.
let mut body = vec![chunk(b"vrsn", version.to_le_bytes().to_vec())];
body.extend(synth::sample_content(version));
let mut members = if version < 1600 {
vec![synth::Member { name: "content/riffData.cdr".into(), data: synth::sample(version, false), deflate: false }]
} else {
synth::package16_members(version, &body, false, &[])
};
for (m, at, v) in edits {
let k = m % members.len();
let data = &mut members[k].data;
if !data.is_empty() {
let n = data.len();
data[at % n] = v;
}
}
let _ = read(&synth::zip(&members, b""), Limits::default());
}
}