mirror of
https://github.com/storytold/indd-utils.git
synced 2026-11-22 10:10:47 +01:00
test: move writer tests into their modules; unit tests for tables and CJK objects
Tables and composite fonts, entries and kinsoku tables are tested on synthetic objects, including big-endian composite font entries.
This commit is contained in:
1 parent
ece97ec5f1
commit
bb6fb3ef61
10 files changed
+645
-282
No files matched your search
@@ -411,6 +411,47 @@ pub(crate) mod synthetic {
|
||||
}
|
||||
}
|
||||
|
||||
/// An object of class `class` made of chunks (ID, data), in
|
||||
/// `encoding`.
|
||||
pub fn object(
|
||||
uid: u32,
|
||||
class: u32,
|
||||
chunks: &[(u32, Vec<u8>)],
|
||||
encoding: Encoding,
|
||||
) -> crate::Object {
|
||||
let mut bytes = Vec::new();
|
||||
for (id, data) in chunks {
|
||||
bytes.extend_from_slice(&encoding.u32_bytes(*id));
|
||||
bytes.extend_from_slice(&encoding.u32_bytes(data.len() as u32));
|
||||
bytes.extend_from_slice(data);
|
||||
}
|
||||
crate::Object {
|
||||
uid,
|
||||
class: Some(class),
|
||||
bytes,
|
||||
encoding,
|
||||
recorder: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// A flag byte and an in-object string of single-byte characters, as
|
||||
/// stored in `encoding` (in big-endian data the string tag comes
|
||||
/// before the flag; `docs/format/big-endian.md`).
|
||||
pub fn flagged_string(encoding: Encoding, flag: u8, s: &str) -> Vec<u8> {
|
||||
let tag = encoding.string_tag();
|
||||
let mut out = if encoding.big_endian() {
|
||||
vec![tag, flag, 0]
|
||||
} else {
|
||||
vec![flag, tag, 0]
|
||||
};
|
||||
out.extend_from_slice(&encoding.u16_bytes(s.len() as u16));
|
||||
if !s.is_empty() {
|
||||
out.extend_from_slice(&encoding.u16_bytes(0x4000 | s.len() as u16));
|
||||
out.extend_from_slice(s.as_bytes());
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Object bytes made of chunks (ID, data).
|
||||
pub fn chunks(chunks: &[(u32, Vec<u8>)]) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
|
||||
@@ -684,3 +684,35 @@ impl Writer<'_> {
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn writes_tab_stops() {
|
||||
let stop = |position, alignment, leader: &str| crate::model::attrs::TabStop {
|
||||
position,
|
||||
alignment,
|
||||
leader: leader.into(),
|
||||
};
|
||||
let stops = tab_list(&[stop(12.0, 0, ""), stop(237.5, 2, ".")]).unwrap();
|
||||
assert_eq!(stops[0][0].2, "LeftAlign");
|
||||
assert_eq!(stops[0][3].2, "12");
|
||||
assert_eq!(stops[1][0].2, "RightAlign");
|
||||
assert_eq!(stops[1][2].2, ".");
|
||||
assert_eq!(stops[1][3].2, "237.5");
|
||||
// Unknown alignment code.
|
||||
assert!(tab_list(&[stop(12.0, 1, "")]).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn writes_bullet_char() {
|
||||
let Some(PropValue::Attributes(a)) = bullet_char(0, 0x2022) else {
|
||||
panic!("not written");
|
||||
};
|
||||
assert_eq!(a[0].1, "UnicodeOnly");
|
||||
assert_eq!(a[1].1, "8226");
|
||||
assert!(bullet_char(3, 0x2022).is_none());
|
||||
}
|
||||
}
|
||||
@@ -272,3 +272,35 @@ impl Writer<'_> {
|
||||
x.end();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn numbers_without_text_are_written_as_zero() {
|
||||
assert_eq!(num(1.5), "1.5");
|
||||
assert_eq!(num(f64::NAN), "0");
|
||||
assert_eq!(num(f64::INFINITY), "0");
|
||||
assert_eq!(num(f64::NEG_INFINITY), "0");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn formats_numbers_like_idml() {
|
||||
assert_eq!(num(205.2), "205.2");
|
||||
assert_eq!(num(-0.0), "-0");
|
||||
assert_eq!(num(1.0), "1");
|
||||
assert_eq!(num(-89.99999999999999), "-89.99999999999999");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encodes_base64_in_lines() {
|
||||
assert_eq!(base64_lines(b""), "");
|
||||
assert_eq!(base64_lines(b"f"), "Zg==");
|
||||
assert_eq!(base64_lines(b"fo"), "Zm8=");
|
||||
assert_eq!(base64_lines(b"foobar"), "Zm9vYmFy");
|
||||
let lines = base64_lines(&[0xFF; 58]);
|
||||
assert_eq!(lines.split('\n').map(str::len).collect::<Vec<_>>(), [76, 4]);
|
||||
assert!(base64_lines(&[0xFF; 57]).find('\n').is_none());
|
||||
}
|
||||
}
|
||||
+6
-282
@@ -158,73 +158,11 @@ pub fn write(doc: &Document, name: &str, out: impl std::io::Write) -> std::io::R
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::spread::spread_origin;
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn numbers_without_text_are_written_as_zero() {
|
||||
assert_eq!(num(1.5), "1.5");
|
||||
assert_eq!(num(f64::NAN), "0");
|
||||
assert_eq!(num(f64::INFINITY), "0");
|
||||
assert_eq!(num(f64::NEG_INFINITY), "0");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn writes_xml_elements_at_their_markers() {
|
||||
use crate::model::{Attrs, XmlStructure};
|
||||
let element = |name: &str, content, story_content, block| XmlElement {
|
||||
name: name.into(),
|
||||
tag: "t".into(),
|
||||
content,
|
||||
story_content,
|
||||
block,
|
||||
};
|
||||
let (a, b, c, d) = ((9, 2), (9, 5), (9, 6), (9, 7));
|
||||
let markers = [
|
||||
(0, XmlMarker::Hidden),
|
||||
(1, XmlMarker::Start(a)),
|
||||
(2, XmlMarker::Placeholder(b)),
|
||||
(3, XmlMarker::Start(c)),
|
||||
(4, XmlMarker::Placeholder(d)),
|
||||
(5, XmlMarker::End(c)),
|
||||
(6, XmlMarker::End(a)),
|
||||
];
|
||||
let story = Story {
|
||||
uid: 9,
|
||||
runs: vec![TextRun {
|
||||
start: 0,
|
||||
text: "\u{FEFF}".repeat(8) + "\r",
|
||||
paragraph_style: None,
|
||||
character_style: None,
|
||||
paragraph_attrs: Attrs::default(),
|
||||
character_attrs: Attrs::default(),
|
||||
}],
|
||||
anchors: Default::default(),
|
||||
tables: Default::default(),
|
||||
text_variables: Default::default(),
|
||||
sources: Vec::new(),
|
||||
xml_markers: markers.into_iter().collect(),
|
||||
xml_element: None,
|
||||
orientation: None,
|
||||
toc_style: None,
|
||||
};
|
||||
let doc = Document {
|
||||
xml: XmlStructure {
|
||||
story: Some(story),
|
||||
elements: [
|
||||
(a, element("di2", None, false, true)),
|
||||
(b, element("di2i5", Some(0x10), true, false)),
|
||||
(c, element("di2i6", None, false, false)),
|
||||
(d, element("di2i6i7", Some(0x20), false, false)),
|
||||
]
|
||||
.into_iter()
|
||||
.collect(),
|
||||
},
|
||||
..Document::default()
|
||||
};
|
||||
let w = Writer {
|
||||
doc: &doc,
|
||||
impl<'a> Writer<'a> {
|
||||
/// A writer for `doc` with no derived state, for unit tests.
|
||||
pub(super) fn for_test(doc: &'a Document) -> Writer<'a> {
|
||||
Writer {
|
||||
doc,
|
||||
dom: "20.0".into(),
|
||||
name: String::new(),
|
||||
group_path: Default::default(),
|
||||
@@ -232,220 +170,6 @@ mod tests {
|
||||
observed: Default::default(),
|
||||
page_layouts: Vec::new(),
|
||||
page_sections: Vec::new(),
|
||||
};
|
||||
let out: String = w
|
||||
.backing_story()
|
||||
.lines()
|
||||
.map(str::trim)
|
||||
.collect::<Vec<_>>()
|
||||
.concat();
|
||||
let csr =
|
||||
"CharacterStyleRange AppliedCharacterStyle=\"CharacterStyle/$ID/[No character style]\"";
|
||||
let el = |name: &str| format!("XMLElement Self=\"{name}\" MarkupTag=\"XMLTag/t\"");
|
||||
let want = format!(
|
||||
"<{csr} /><{a}><{csr}><{b} XMLContent=\"u10\" /></CharacterStyleRange>\
|
||||
<{csr}><{c}><{d} XMLContent=\"u20\" /></XMLElement></CharacterStyleRange>\
|
||||
</XMLElement><{csr}><Content>\u{FEFF}</Content></CharacterStyleRange>",
|
||||
a = el("di2"),
|
||||
b = el("di2i5"),
|
||||
c = el("di2i6"),
|
||||
d = el("di2i6i7"),
|
||||
);
|
||||
assert!(out.contains(&want), "{out}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn numbers_pages_by_section() {
|
||||
use crate::model::{Page, Section, Spread, numbering};
|
||||
let page = |uid| Page {
|
||||
uid,
|
||||
bounds: [0.0; 4],
|
||||
transform: Matrix::IDENTITY,
|
||||
master: None,
|
||||
master_transform: Matrix::IDENTITY,
|
||||
margins: None,
|
||||
columns: None,
|
||||
grid: None,
|
||||
settings: Default::default(),
|
||||
};
|
||||
let section = |uid, page, continue_numbering, start| Section {
|
||||
uid,
|
||||
page,
|
||||
continue_numbering,
|
||||
start,
|
||||
style: numbering::ARABIC,
|
||||
prefix: String::new(),
|
||||
marker: String::new(),
|
||||
alternate_layout: None,
|
||||
};
|
||||
let doc = Document {
|
||||
spreads: vec![Spread {
|
||||
uid: 1,
|
||||
master_name: None,
|
||||
transform: Matrix::IDENTITY,
|
||||
binding_location: 0,
|
||||
pages: (10..16).map(page).collect(),
|
||||
items: Vec::new(),
|
||||
guides: Vec::new(),
|
||||
shuffle: None,
|
||||
flattener_resolution: None,
|
||||
show_master_items: None,
|
||||
}],
|
||||
// Listed out of page order, as in some samples.
|
||||
sections: vec![
|
||||
section(1, None, true, 1),
|
||||
section(3, Some(14), true, 9),
|
||||
section(2, Some(12), false, 1),
|
||||
],
|
||||
..Document::default()
|
||||
};
|
||||
assert_eq!(page_numbers(&doc), [1, 2, 1, 2, 3, 4]);
|
||||
let ranges: Vec<_> = section_ranges(&doc)
|
||||
.iter()
|
||||
.map(|(s, first, len)| (s.uid, *first, *len))
|
||||
.collect();
|
||||
assert_eq!(ranges, [(1, 0, 2), (2, 2, 2), (3, 4, 2)]);
|
||||
let mut doc = doc;
|
||||
doc.sections[0].style = numbering::LOWER_ROMAN;
|
||||
assert_eq!(page_names(&doc), ["i", "ii", "1", "2", "3", "4"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn writes_wrap_offsets_by_side() {
|
||||
let wrap = TextWrap {
|
||||
mode: wrap_mode::BOUNDING_BOX,
|
||||
offsets: [1.0, 2.0, 3.0, 4.0],
|
||||
flags: 1,
|
||||
};
|
||||
let mut x = Xml::new();
|
||||
Writer::text_wrap_preference(&mut x, Some(&wrap), None);
|
||||
let out = x.finish();
|
||||
assert!(out.contains("TextWrapMode=\"BoundingBoxTextWrap\""));
|
||||
assert!(out.contains("<TextWrapOffset Top=\"2\" Left=\"1\" Bottom=\"4\" Right=\"3\" />"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn measures_guides_from_spread_origin() {
|
||||
use crate::model::Page;
|
||||
let page = |uid, tx| Page {
|
||||
uid,
|
||||
bounds: [0.0, 0.0, 612.0, 792.0],
|
||||
transform: Matrix([1.0, 0.0, 0.0, 1.0, tx, -396.0]),
|
||||
master: None,
|
||||
master_transform: Matrix::IDENTITY,
|
||||
margins: None,
|
||||
columns: None,
|
||||
grid: None,
|
||||
settings: Default::default(),
|
||||
};
|
||||
let origin = spread_origin(&[page(1, -612.0), page(2, 0.0)]);
|
||||
assert_eq!(origin, (-612.0, -396.0));
|
||||
let guide = Guide {
|
||||
uid: 0x2299,
|
||||
horizontal: true,
|
||||
position: 339.5,
|
||||
owner: 2,
|
||||
fit_to_page: true,
|
||||
view_threshold: 0.05,
|
||||
color: 6,
|
||||
guide_type: Some(0),
|
||||
layer: 0xcc,
|
||||
locked: false,
|
||||
zone: Some(1.0),
|
||||
overridden: None,
|
||||
};
|
||||
let mut x = Xml::new();
|
||||
Writer::guide(&mut x, &guide, origin, -1);
|
||||
let out = x.finish();
|
||||
assert!(
|
||||
out.contains("Orientation=\"Horizontal\" Location=\"735.5\""),
|
||||
"{out}"
|
||||
);
|
||||
assert!(
|
||||
out.contains("ItemLayer=\"ucc\" GuideType=\"Ruler\""),
|
||||
"{out}"
|
||||
);
|
||||
assert!(out.contains("<GuideColor type=\"enumeration\">Cyan</GuideColor>"));
|
||||
assert!(out.contains("PageIndex=\"-1\" GuideZone=\"1\""), "{out}");
|
||||
let vertical = Guide {
|
||||
horizontal: false,
|
||||
position: 28.0,
|
||||
..guide
|
||||
};
|
||||
let mut x = Xml::new();
|
||||
Writer::guide(&mut x, &vertical, origin, 1);
|
||||
assert!(x.finish().contains("Location=\"640\""));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn names_pages_in_lower_roman() {
|
||||
assert_eq!(lower_roman(1), "i");
|
||||
assert_eq!(lower_roman(4), "iv");
|
||||
assert_eq!(lower_roman(12), "xii");
|
||||
assert_eq!(lower_roman(49), "xlix");
|
||||
assert_eq!(lower_roman(1994), "mcmxciv");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn names_pages_in_kanji_digits() {
|
||||
assert_eq!(kanji_digits(8), "八");
|
||||
assert_eq!(kanji_digits(10), "一〇");
|
||||
assert_eq!(kanji_digits(102), "一〇二");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn formats_numbers_like_idml() {
|
||||
assert_eq!(num(205.2), "205.2");
|
||||
assert_eq!(num(-0.0), "-0");
|
||||
assert_eq!(num(1.0), "1");
|
||||
assert_eq!(num(-89.99999999999999), "-89.99999999999999");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encodes_base64_in_lines() {
|
||||
assert_eq!(base64_lines(b""), "");
|
||||
assert_eq!(base64_lines(b"f"), "Zg==");
|
||||
assert_eq!(base64_lines(b"fo"), "Zm8=");
|
||||
assert_eq!(base64_lines(b"foobar"), "Zm9vYmFy");
|
||||
let lines = base64_lines(&[0xFF; 58]);
|
||||
assert_eq!(lines.split('\n').map(str::len).collect::<Vec<_>>(), [76, 4]);
|
||||
assert!(base64_lines(&[0xFF; 57]).find('\n').is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn splits_cdata_sections() {
|
||||
let mut x = Xml::new();
|
||||
x.start("Contents").cdata("abcde", 2).end();
|
||||
assert!(
|
||||
x.finish()
|
||||
.ends_with("\n<Contents><![CDATA[ab]]><![CDATA[cd]]><![CDATA[e]]></Contents>")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn writes_tab_stops() {
|
||||
let stop = |position, alignment, leader: &str| crate::model::attrs::TabStop {
|
||||
position,
|
||||
alignment,
|
||||
leader: leader.into(),
|
||||
};
|
||||
let stops = tab_list(&[stop(12.0, 0, ""), stop(237.5, 2, ".")]).unwrap();
|
||||
assert_eq!(stops[0][0].2, "LeftAlign");
|
||||
assert_eq!(stops[0][3].2, "12");
|
||||
assert_eq!(stops[1][0].2, "RightAlign");
|
||||
assert_eq!(stops[1][2].2, ".");
|
||||
assert_eq!(stops[1][3].2, "237.5");
|
||||
// Unknown alignment code.
|
||||
assert!(tab_list(&[stop(12.0, 1, "")]).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn writes_bullet_char() {
|
||||
let Some(PropValue::Attributes(a)) = bullet_char(0, 0x2022) else {
|
||||
panic!("not written");
|
||||
};
|
||||
assert_eq!(a[0].1, "UnicodeOnly");
|
||||
assert_eq!(a[1].1, "8226");
|
||||
assert!(bullet_char(3, 0x2022).is_none());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -185,3 +185,80 @@ pub(super) fn page_numbers(doc: &Document) -> Vec<u32> {
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn numbers_pages_by_section() {
|
||||
use crate::model::{Page, Section, Spread, numbering};
|
||||
let page = |uid| Page {
|
||||
uid,
|
||||
bounds: [0.0; 4],
|
||||
transform: Matrix::IDENTITY,
|
||||
master: None,
|
||||
master_transform: Matrix::IDENTITY,
|
||||
margins: None,
|
||||
columns: None,
|
||||
grid: None,
|
||||
settings: Default::default(),
|
||||
};
|
||||
let section = |uid, page, continue_numbering, start| Section {
|
||||
uid,
|
||||
page,
|
||||
continue_numbering,
|
||||
start,
|
||||
style: numbering::ARABIC,
|
||||
prefix: String::new(),
|
||||
marker: String::new(),
|
||||
alternate_layout: None,
|
||||
};
|
||||
let doc = Document {
|
||||
spreads: vec![Spread {
|
||||
uid: 1,
|
||||
master_name: None,
|
||||
transform: Matrix::IDENTITY,
|
||||
binding_location: 0,
|
||||
pages: (10..16).map(page).collect(),
|
||||
items: Vec::new(),
|
||||
guides: Vec::new(),
|
||||
shuffle: None,
|
||||
flattener_resolution: None,
|
||||
show_master_items: None,
|
||||
}],
|
||||
// Listed out of page order, as in some samples.
|
||||
sections: vec![
|
||||
section(1, None, true, 1),
|
||||
section(3, Some(14), true, 9),
|
||||
section(2, Some(12), false, 1),
|
||||
],
|
||||
..Document::default()
|
||||
};
|
||||
assert_eq!(page_numbers(&doc), [1, 2, 1, 2, 3, 4]);
|
||||
let ranges: Vec<_> = section_ranges(&doc)
|
||||
.iter()
|
||||
.map(|(s, first, len)| (s.uid, *first, *len))
|
||||
.collect();
|
||||
assert_eq!(ranges, [(1, 0, 2), (2, 2, 2), (3, 4, 2)]);
|
||||
let mut doc = doc;
|
||||
doc.sections[0].style = numbering::LOWER_ROMAN;
|
||||
assert_eq!(page_names(&doc), ["i", "ii", "1", "2", "3", "4"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn names_pages_in_lower_roman() {
|
||||
assert_eq!(lower_roman(1), "i");
|
||||
assert_eq!(lower_roman(4), "iv");
|
||||
assert_eq!(lower_roman(12), "xii");
|
||||
assert_eq!(lower_roman(49), "xlix");
|
||||
assert_eq!(lower_roman(1994), "mcmxciv");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn names_pages_in_kanji_digits() {
|
||||
assert_eq!(kanji_digits(8), "八");
|
||||
assert_eq!(kanji_digits(10), "一〇");
|
||||
assert_eq!(kanji_digits(102), "一〇二");
|
||||
}
|
||||
}
|
||||
@@ -813,3 +813,75 @@ impl Writer<'_> {
|
||||
x.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn writes_wrap_offsets_by_side() {
|
||||
let wrap = TextWrap {
|
||||
mode: wrap_mode::BOUNDING_BOX,
|
||||
offsets: [1.0, 2.0, 3.0, 4.0],
|
||||
flags: 1,
|
||||
};
|
||||
let mut x = Xml::new();
|
||||
Writer::text_wrap_preference(&mut x, Some(&wrap), None);
|
||||
let out = x.finish();
|
||||
assert!(out.contains("TextWrapMode=\"BoundingBoxTextWrap\""));
|
||||
assert!(out.contains("<TextWrapOffset Top=\"2\" Left=\"1\" Bottom=\"4\" Right=\"3\" />"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn measures_guides_from_spread_origin() {
|
||||
use crate::model::Page;
|
||||
let page = |uid, tx| Page {
|
||||
uid,
|
||||
bounds: [0.0, 0.0, 612.0, 792.0],
|
||||
transform: Matrix([1.0, 0.0, 0.0, 1.0, tx, -396.0]),
|
||||
master: None,
|
||||
master_transform: Matrix::IDENTITY,
|
||||
margins: None,
|
||||
columns: None,
|
||||
grid: None,
|
||||
settings: Default::default(),
|
||||
};
|
||||
let origin = spread_origin(&[page(1, -612.0), page(2, 0.0)]);
|
||||
assert_eq!(origin, (-612.0, -396.0));
|
||||
let guide = Guide {
|
||||
uid: 0x2299,
|
||||
horizontal: true,
|
||||
position: 339.5,
|
||||
owner: 2,
|
||||
fit_to_page: true,
|
||||
view_threshold: 0.05,
|
||||
color: 6,
|
||||
guide_type: Some(0),
|
||||
layer: 0xcc,
|
||||
locked: false,
|
||||
zone: Some(1.0),
|
||||
overridden: None,
|
||||
};
|
||||
let mut x = Xml::new();
|
||||
Writer::guide(&mut x, &guide, origin, -1);
|
||||
let out = x.finish();
|
||||
assert!(
|
||||
out.contains("Orientation=\"Horizontal\" Location=\"735.5\""),
|
||||
"{out}"
|
||||
);
|
||||
assert!(
|
||||
out.contains("ItemLayer=\"ucc\" GuideType=\"Ruler\""),
|
||||
"{out}"
|
||||
);
|
||||
assert!(out.contains("<GuideColor type=\"enumeration\">Cyan</GuideColor>"));
|
||||
assert!(out.contains("PageIndex=\"-1\" GuideZone=\"1\""), "{out}");
|
||||
let vertical = Guide {
|
||||
horizontal: false,
|
||||
position: 28.0,
|
||||
..guide
|
||||
};
|
||||
let mut x = Xml::new();
|
||||
Writer::guide(&mut x, &vertical, origin, 1);
|
||||
assert!(x.finish().contains("Location=\"640\""));
|
||||
}
|
||||
}
|
||||
@@ -429,3 +429,83 @@ impl Writer<'_> {
|
||||
x.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn writes_xml_elements_at_their_markers() {
|
||||
use crate::model::{Attrs, XmlStructure};
|
||||
let element = |name: &str, content, story_content, block| XmlElement {
|
||||
name: name.into(),
|
||||
tag: "t".into(),
|
||||
content,
|
||||
story_content,
|
||||
block,
|
||||
};
|
||||
let (a, b, c, d) = ((9, 2), (9, 5), (9, 6), (9, 7));
|
||||
let markers = [
|
||||
(0, XmlMarker::Hidden),
|
||||
(1, XmlMarker::Start(a)),
|
||||
(2, XmlMarker::Placeholder(b)),
|
||||
(3, XmlMarker::Start(c)),
|
||||
(4, XmlMarker::Placeholder(d)),
|
||||
(5, XmlMarker::End(c)),
|
||||
(6, XmlMarker::End(a)),
|
||||
];
|
||||
let story = Story {
|
||||
uid: 9,
|
||||
runs: vec![TextRun {
|
||||
start: 0,
|
||||
text: "\u{FEFF}".repeat(8) + "\r",
|
||||
paragraph_style: None,
|
||||
character_style: None,
|
||||
paragraph_attrs: Attrs::default(),
|
||||
character_attrs: Attrs::default(),
|
||||
}],
|
||||
anchors: Default::default(),
|
||||
tables: Default::default(),
|
||||
text_variables: Default::default(),
|
||||
sources: Vec::new(),
|
||||
xml_markers: markers.into_iter().collect(),
|
||||
xml_element: None,
|
||||
orientation: None,
|
||||
toc_style: None,
|
||||
};
|
||||
let doc = Document {
|
||||
xml: XmlStructure {
|
||||
story: Some(story),
|
||||
elements: [
|
||||
(a, element("di2", None, false, true)),
|
||||
(b, element("di2i5", Some(0x10), true, false)),
|
||||
(c, element("di2i6", None, false, false)),
|
||||
(d, element("di2i6i7", Some(0x20), false, false)),
|
||||
]
|
||||
.into_iter()
|
||||
.collect(),
|
||||
},
|
||||
..Document::default()
|
||||
};
|
||||
let w = Writer::for_test(&doc);
|
||||
let out: String = w
|
||||
.backing_story()
|
||||
.lines()
|
||||
.map(str::trim)
|
||||
.collect::<Vec<_>>()
|
||||
.concat();
|
||||
let csr =
|
||||
"CharacterStyleRange AppliedCharacterStyle=\"CharacterStyle/$ID/[No character style]\"";
|
||||
let el = |name: &str| format!("XMLElement Self=\"{name}\" MarkupTag=\"XMLTag/t\"");
|
||||
let want = format!(
|
||||
"<{csr} /><{a}><{csr}><{b} XMLContent=\"u10\" /></CharacterStyleRange>\
|
||||
<{csr}><{c}><{d} XMLContent=\"u20\" /></XMLElement></CharacterStyleRange>\
|
||||
</XMLElement><{csr}><Content>\u{FEFF}</Content></CharacterStyleRange>",
|
||||
a = el("di2"),
|
||||
b = el("di2i5"),
|
||||
c = el("di2i6"),
|
||||
d = el("di2i6i7"),
|
||||
);
|
||||
assert!(out.contains(&want), "{out}");
|
||||
}
|
||||
}
|
||||
@@ -267,4 +267,14 @@ mod tests {
|
||||
x.text("p\u{FFFF}q").end();
|
||||
assert!(x.finish().ends_with("<a k=\"x\u{FFFD}y\">pq</a>"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn splits_cdata_sections() {
|
||||
let mut x = Xml::new();
|
||||
x.start("Contents").cdata("abcde", 2).end();
|
||||
assert!(
|
||||
x.finish()
|
||||
.ends_with("\n<Contents><![CDATA[ab]]><![CDATA[cd]]><![CDATA[e]]></Contents>")
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -166,3 +166,126 @@ impl CjkTable {
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::database::synthetic::{flagged_string, object};
|
||||
use crate::object::Encoding;
|
||||
use crate::{ByteOrder, Version};
|
||||
|
||||
fn big_endian() -> Encoding {
|
||||
Encoding::new(ByteOrder::Big, Version { major: 4, minor: 0 })
|
||||
}
|
||||
|
||||
/// Chunk 0xCB03 of a composite font entry in `enc`: the Kanji entry,
|
||||
/// font family 7, style "W3", a BMP range and a range of surrogate
|
||||
/// pairs, scale option on.
|
||||
fn entry_chunk(enc: Encoding) -> Vec<u8> {
|
||||
let mut d = flagged_string(enc, 1, "Kanji");
|
||||
d.extend(enc.u32_bytes(7));
|
||||
d.extend(flagged_string(enc, 0, "W3"));
|
||||
for f in [100.0, 0.0, 100.0, 100.0] {
|
||||
d.extend(enc.f64_bytes(f));
|
||||
}
|
||||
d.extend(enc.u16_bytes(1));
|
||||
d.extend(enc.u16_bytes(2));
|
||||
// (first, last, first): U+4E00–U+4E01, then U+20000–U+20001.
|
||||
for u in [0x4E00u16, 0x4E01, 0x4E00] {
|
||||
d.extend(enc.u16_bytes(u));
|
||||
}
|
||||
for pair in [[0xD840u16, 0xDC00], [0xD840, 0xDC01], [0xD840, 0xDC00]] {
|
||||
for u in pair {
|
||||
d.extend(enc.u16_bytes(u));
|
||||
}
|
||||
}
|
||||
for _ in 0..4 {
|
||||
d.extend(enc.u16_bytes(1));
|
||||
}
|
||||
d
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_composite_font_entries_in_either_byte_order() {
|
||||
for enc in [Encoding::default(), big_endian()] {
|
||||
let obj = object(
|
||||
0x60,
|
||||
class::COMPOSITE_FONT_ENTRY,
|
||||
&[(chunk::COMPOSITE_FONT_ENTRY, entry_chunk(enc))],
|
||||
enc,
|
||||
);
|
||||
let e = CompositeFontEntry::read(0x60, &obj).unwrap().unwrap();
|
||||
assert_eq!(e.name.idml(), "$ID/Kanji");
|
||||
assert_eq!((e.font_family, e.font_style.idml()), (7, "W3".into()));
|
||||
assert_eq!(e.numbers, [100.0, 0.0, 100.0, 100.0]);
|
||||
assert_eq!(e.ranges, [(0x4E00, 0x4E01), (0x20000, 0x20001)]);
|
||||
assert_eq!(e.scale, [1; 4]);
|
||||
assert_eq!(e.characters(), "\u{4E00}\u{4E01}\u{20000}\u{20001}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn composite_fonts_end_with_their_entry_list() {
|
||||
let enc = Encoding::default();
|
||||
let mut d = flagged_string(enc, 1, "[No composite font]");
|
||||
// Fields not identified, then two entry UIDs.
|
||||
d.extend([9, 9, 9, 9, 9]);
|
||||
d.extend(enc.u16_bytes(2));
|
||||
d.extend(enc.u32_bytes(0x60));
|
||||
d.extend(enc.u32_bytes(0x61));
|
||||
let obj = object(
|
||||
0x5F,
|
||||
class::COMPOSITE_FONT,
|
||||
&[(chunk::COMPOSITE_FONT, d)],
|
||||
enc,
|
||||
);
|
||||
let (name, entries) = CompositeFont::read(&obj).unwrap().unwrap();
|
||||
assert!(name.builtin);
|
||||
assert_eq!(name.name, "[No composite font]");
|
||||
assert_eq!(entries, [0x60, 0x61]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_custom_kinsoku_characters() {
|
||||
let enc = Encoding::default();
|
||||
let lists = ["、。", "(", "", "、", "—"];
|
||||
let mut chars = Vec::new();
|
||||
for l in lists {
|
||||
chars.extend(enc.u16_bytes(l.encode_utf16().count() as u16));
|
||||
}
|
||||
for l in lists {
|
||||
for u in l.encode_utf16() {
|
||||
chars.extend(enc.u16_bytes(u));
|
||||
}
|
||||
}
|
||||
let obj = object(
|
||||
0x70,
|
||||
class::CUSTOM_KINSOKU,
|
||||
&[
|
||||
(chunk::TABLE_NAME, flagged_string(enc, 0, "Mine")),
|
||||
(chunk::KINSOKU_CHARS, chars),
|
||||
],
|
||||
enc,
|
||||
);
|
||||
let t = CjkTable::read(0x70, class::CUSTOM_KINSOKU, &obj)
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert!(!t.mojikumi && !t.name.builtin);
|
||||
assert_eq!(t.name.name, "Mine");
|
||||
assert_eq!(t.chars, Some(lists.map(String::from)));
|
||||
// A mojikumi table has no character lists.
|
||||
let obj = object(
|
||||
0x71,
|
||||
class::MOJIKUMI,
|
||||
&[(
|
||||
chunk::TABLE_NAME,
|
||||
flagged_string(enc, 1, "kMojikumiDefaultName1"),
|
||||
)],
|
||||
enc,
|
||||
);
|
||||
let t = CjkTable::read(0x71, class::MOJIKUMI, &obj)
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert!(t.mojikumi && t.name.builtin && t.chars.is_none());
|
||||
}
|
||||
}
|
||||
@@ -458,4 +458,176 @@ mod tests {
|
||||
let reader = Reader::new(&db);
|
||||
assert!(reader.table(5).is_err());
|
||||
}
|
||||
|
||||
fn le(v: u32) -> Vec<u8> {
|
||||
v.to_le_bytes().to_vec()
|
||||
}
|
||||
|
||||
/// One attribute record: ID, u16 size, u16 value count, then values
|
||||
/// (u32 type 0, u16 length, data).
|
||||
fn record(id: u32, values: &[&[u8]]) -> Vec<u8> {
|
||||
let mut payload = (values.len() as u16).to_le_bytes().to_vec();
|
||||
for v in values {
|
||||
payload.extend(le(0));
|
||||
payload.extend((v.len() as u16).to_le_bytes());
|
||||
payload.extend(*v);
|
||||
}
|
||||
let mut d = le(id);
|
||||
d.extend((payload.len() as u16).to_le_bytes());
|
||||
d.extend(payload);
|
||||
d
|
||||
}
|
||||
|
||||
/// A row or column group list with one group of `count` sharing one
|
||||
/// f64 attribute.
|
||||
fn one_group(count: u32, id: u32, value: f64) -> Vec<u8> {
|
||||
let mut d = le(1);
|
||||
d.extend(le(count));
|
||||
d.extend(0u16.to_le_bytes());
|
||||
d.extend(1u16.to_le_bytes());
|
||||
d.extend(record(id, &[&value.to_le_bytes()]));
|
||||
d.extend([0; 8]);
|
||||
d
|
||||
}
|
||||
|
||||
/// The second value of a cell record: text area width at 32 and
|
||||
/// height at 40.
|
||||
fn geometry(w: f64, h: f64) -> Vec<u8> {
|
||||
let mut g = vec![0; 32];
|
||||
g.extend(w.to_le_bytes());
|
||||
g.extend(h.to_le_bytes());
|
||||
g
|
||||
}
|
||||
|
||||
/// A 2 × 3 table: row 0 has a cell spanning columns 0–1 (its text
|
||||
/// area is wider than one column) and a cell in column 2; row 1 has
|
||||
/// three cells, the first with a cell format.
|
||||
fn table_objects() -> Vec<(u32, u32, Vec<u8>)> {
|
||||
let mut size = Vec::new();
|
||||
for v in [2u32, 3, 1, 0] {
|
||||
size.extend(le(v));
|
||||
}
|
||||
let mut parts = le(1);
|
||||
parts.extend(le(7));
|
||||
parts.extend(le(class::CELL_STRAND_OWNER));
|
||||
let mut strand = 1u16.to_le_bytes().to_vec();
|
||||
strand.extend(le(0));
|
||||
strand.extend(le(8));
|
||||
// Row group: one cell format for one column, then two rows of
|
||||
// positions with their records.
|
||||
let mut g = le(1);
|
||||
g.extend(le(1));
|
||||
g.extend(1u16.to_le_bytes());
|
||||
g.extend(1u16.to_le_bytes());
|
||||
g.extend(record(0xB63E, &[&50.0f64.to_le_bytes()]));
|
||||
g.extend(le(2));
|
||||
g.extend(le(0x11));
|
||||
g.extend(le(2));
|
||||
for row in [[1u32, 2, 3], [4, 5, 6]] {
|
||||
g.extend(le(3));
|
||||
for id in row {
|
||||
g.extend(le(id));
|
||||
}
|
||||
}
|
||||
g.extend(le(2));
|
||||
let cell = |w, h| record(attr::CELL, &[&[], &geometry(w, h)]);
|
||||
let covered = record(attr::COVERED, &[&[], &[]]);
|
||||
g.extend(3u16.to_le_bytes());
|
||||
g.extend(cell(150.0, 15.0));
|
||||
g.extend(covered);
|
||||
g.extend(cell(90.0, 15.0));
|
||||
g.extend(3u16.to_le_bytes());
|
||||
for _ in 0..3 {
|
||||
g.extend(cell(90.0, 15.0));
|
||||
}
|
||||
let mut runs = vec![0; 8];
|
||||
runs.extend(1u16.to_le_bytes());
|
||||
runs.extend(le(g.len() as u32));
|
||||
runs.extend(g);
|
||||
let strand_data = super::super::chunk::STRAND_DATA;
|
||||
let strand_runs = super::super::chunk::STRAND_RUNS;
|
||||
vec![
|
||||
(
|
||||
5,
|
||||
class::TABLE,
|
||||
synthetic::chunks(&[
|
||||
(chunk::TABLE_SIZE, size),
|
||||
(chunk::TABLE_PARTS, parts),
|
||||
(
|
||||
chunk::TABLE_COLUMNS,
|
||||
one_group(3, attr::COLUMN_WIDTH, 100.0),
|
||||
),
|
||||
(chunk::TABLE_ROWS, one_group(2, attr::ROW_HEIGHT, 20.0)),
|
||||
(chunk::TABLE_STYLE, le(0x30)),
|
||||
]),
|
||||
),
|
||||
(
|
||||
7,
|
||||
class::CELL_STRAND_OWNER,
|
||||
synthetic::chunks(&[(strand_data, strand)]),
|
||||
),
|
||||
(8, 0x1, synthetic::chunks(&[(strand_runs, runs)])),
|
||||
]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_rows_columns_and_cell_spans() {
|
||||
let objects = table_objects();
|
||||
let bytes = synthetic::image(&objects);
|
||||
let db = synthetic::database(&bytes, &objects);
|
||||
let reader = Reader::new(&db);
|
||||
let t = reader.table(5).unwrap();
|
||||
assert_eq!((t.header_rows, t.footer_rows, t.style), (1, 0, Some(0x30)));
|
||||
assert_eq!(t.columns, [100.0; 3]);
|
||||
assert_eq!(t.rows.len(), 2);
|
||||
assert_eq!(t.rows[1].height, Some(20.0));
|
||||
let cells: Vec<_> = t
|
||||
.cells
|
||||
.iter()
|
||||
.map(|c| (c.id, c.row, c.column, c.row_span, c.column_span))
|
||||
.collect();
|
||||
assert_eq!(
|
||||
cells,
|
||||
[
|
||||
(1, 0, 0, 1, 2),
|
||||
(3, 0, 2, 1, 1),
|
||||
(4, 1, 0, 1, 1),
|
||||
(5, 1, 1, 1, 1),
|
||||
(6, 1, 2, 1, 1)
|
||||
]
|
||||
);
|
||||
// The cell format applies to the first column of each row.
|
||||
let f = t.cells[0].format.as_ref().unwrap();
|
||||
assert_eq!((f.style_priority, f.style), (2, 0x11));
|
||||
assert_eq!(f.attrs.get(0xB63E), Some(&Value::Double(50.0)));
|
||||
assert!(t.cells[1].format.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cells_without_geometry_span_the_covered_positions() {
|
||||
let pos = |id, size, covered| Position {
|
||||
id,
|
||||
size,
|
||||
covered,
|
||||
format: None,
|
||||
};
|
||||
let grid = vec![vec![
|
||||
pos(1, Some((0.0, 0.0)), false),
|
||||
pos(2, None, true),
|
||||
pos(3, None, true),
|
||||
pos(4, Some((10.0, 30.0)), false),
|
||||
]];
|
||||
let row = |h| Row {
|
||||
height: Some(h),
|
||||
min_height: None,
|
||||
auto_grow: None,
|
||||
};
|
||||
let cells = cells_from_grid(&grid, &[row(20.0), row(20.0)], &[10.0; 4]);
|
||||
let spans: Vec<_> = cells
|
||||
.iter()
|
||||
.map(|c| (c.id, c.row_span, c.column_span))
|
||||
.collect();
|
||||
// Cell 4 is 30 high: two rows of 20.
|
||||
assert_eq!(spans, [(1, 1, 3), (4, 2, 1)]);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user