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:
aiongg committed 2026-10-07 19:59:06 +00:00
1 parent ece97ec5f1
commit bb6fb3ef61
10 files changed
+645 -282

No files matched your search

+41
View File
@@ -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();
+32
View File
@@ -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());
}
}
+32
View File
@@ -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
View File
@@ -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());
}
}
}
+77
View File
@@ -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), "一〇二");
}
}
+72
View File
@@ -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\""));
}
}
+80
View File
@@ -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}");
}
}
+10
View File
@@ -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>")
);
}
}
+123
View File
@@ -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());
}
}
+172
View File
@@ -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)]);
}
}