From bb6fb3ef61cca49d243b4d0416d7d49e908fe014 Mon Sep 17 00:00:00 2001 From: aiongg <67543387+aiongg@users.noreply.github.com> Date: Wed, 7 Oct 2026 19:59:06 +0000 Subject: [PATCH] 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. --- src/database.rs | 41 +++++++ src/idml/attrs.rs | 32 +++++ src/idml/format.rs | 32 +++++ src/idml/mod.rs | 288 +-------------------------------------------- src/idml/pages.rs | 77 ++++++++++++ src/idml/spread.rs | 72 ++++++++++++ src/idml/story.rs | 80 +++++++++++++ src/idml/xml.rs | 10 ++ src/model/cjk.rs | 123 +++++++++++++++++++ src/model/table.rs | 172 +++++++++++++++++++++++++++ 10 files changed, 645 insertions(+), 282 deletions(-) diff --git a/src/database.rs b/src/database.rs index 6720f5c..b4367d4 100644 --- a/src/database.rs +++ b/src/database.rs @@ -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)], + 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 { + 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)]) -> Vec { let mut out = Vec::new(); diff --git a/src/idml/attrs.rs b/src/idml/attrs.rs index 22f0653..e70a64d 100644 --- a/src/idml/attrs.rs +++ b/src/idml/attrs.rs @@ -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()); + } +} diff --git a/src/idml/format.rs b/src/idml/format.rs index 057ef7a..27b0435 100644 --- a/src/idml/format.rs +++ b/src/idml/format.rs @@ -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::>(), [76, 4]); + assert!(base64_lines(&[0xFF; 57]).find('\n').is_none()); + } +} diff --git a/src/idml/mod.rs b/src/idml/mod.rs index 5a4ba54..5bdbda9 100644 --- a/src/idml/mod.rs +++ b/src/idml/mod.rs @@ -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::>() - .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\" />\ - <{csr}><{c}><{d} XMLContent=\"u20\" />\ - <{csr}>\u{FEFF}", - 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("")); - } - - #[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("Cyan")); - 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::>(), [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") - ); - } - - #[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()); + } } } diff --git a/src/idml/pages.rs b/src/idml/pages.rs index d4c19ea..07921a3 100644 --- a/src/idml/pages.rs +++ b/src/idml/pages.rs @@ -185,3 +185,80 @@ pub(super) fn page_numbers(doc: &Document) -> Vec { } 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), "一〇二"); + } +} diff --git a/src/idml/spread.rs b/src/idml/spread.rs index d5ef656..beece26 100644 --- a/src/idml/spread.rs +++ b/src/idml/spread.rs @@ -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("")); + } + + #[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("Cyan")); + 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\"")); + } +} diff --git a/src/idml/story.rs b/src/idml/story.rs index bb539ab..b52de60 100644 --- a/src/idml/story.rs +++ b/src/idml/story.rs @@ -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::>() + .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\" />\ + <{csr}><{c}><{d} XMLContent=\"u20\" />\ + <{csr}>\u{FEFF}", + a = el("di2"), + b = el("di2i5"), + c = el("di2i6"), + d = el("di2i6i7"), + ); + assert!(out.contains(&want), "{out}"); + } +} diff --git a/src/idml/xml.rs b/src/idml/xml.rs index 671da4a..5813f70 100644 --- a/src/idml/xml.rs +++ b/src/idml/xml.rs @@ -267,4 +267,14 @@ mod tests { x.text("p\u{FFFF}q").end(); assert!(x.finish().ends_with("pq")); } + + #[test] + fn splits_cdata_sections() { + let mut x = Xml::new(); + x.start("Contents").cdata("abcde", 2).end(); + assert!( + x.finish() + .ends_with("\n") + ); + } } diff --git a/src/model/cjk.rs b/src/model/cjk.rs index 42108e2..c7d60c5 100644 --- a/src/model/cjk.rs +++ b/src/model/cjk.rs @@ -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 { + 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()); + } +} diff --git a/src/model/table.rs b/src/model/table.rs index 30ace5e..b0598bf 100644 --- a/src/model/table.rs +++ b/src/model/table.rs @@ -458,4 +458,176 @@ mod tests { let reader = Reader::new(&db); assert!(reader.table(5).is_err()); } + + fn le(v: u32) -> Vec { + 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 { + 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 { + 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 { + 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)> { + 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)]); + } }