mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 20:19:44 +00:00
A zlib stream that fails near its end has already inflated most of its bytes, which the reader discarded without counting them. Several such streams could each inflate up to the file's inflate limit. Those bytes now count toward it.
1713 lines
87 KiB
Rust
1713 lines
87 KiB
Rust
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
||
//! Reading synthetic drawings of every version the reader takes, plain and compressed, and
|
||
//! hostile files.
|
||
|
||
use proptest::prelude::*;
|
||
use vectorcraft_cdr::model::{Cap, Color, 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(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(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(g) if matches!(&g[0], Object::Group(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(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 the shorter side holds to 50 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, 50.0]) {
|
||
assert!((got - want).abs() < 1e-6, "{radii:?}");
|
||
}
|
||
// With the scale-with flag set the radii are inches, held to 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, 28.8, 0.0, 50.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(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(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));
|
||
}
|
||
|
||
/// 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 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);
|
||
}
|
||
}
|
||
|
||
/// 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]);
|
||
}
|
||
|
||
/// 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}");
|
||
}
|
||
}
|
||
|
||
#[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));
|
||
}
|
||
|
||
#[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}");
|
||
}
|
||
}
|
||
}
|
||
|
||
#[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());
|
||
}
|
||
}
|