use super::*; /// Dynamic Text is off for new type and for type saved before it, and saved only when on. #[test] fn dynamic_text_is_saved_only_when_on() { let t = TextObject::point(Point::ZERO, "Hi", CharStyle::default()); assert!(!t.dynamic_text); let off = serde_json::to_value(&t).unwrap(); assert!(off.get("dynamicText").is_none()); assert!(!serde_json::from_value::(off).unwrap().dynamic_text); let on = TextObject { dynamic_text: true, ..t }; let saved = serde_json::to_value(&on).unwrap(); assert_eq!(saved["dynamicText"], true); assert!(serde_json::from_value::(saved).unwrap().dynamic_text); } /// Character Direction is saved only when set, and styles written before it existed read as /// Default. #[test] fn character_direction_is_saved_only_when_set() { let st = CharStyle::default(); assert_eq!(st.char_direction, None); assert!(serde_json::to_value(&st).unwrap().get("charDirection").is_none()); for (d, key) in [(ParaDirection::LeftToRight, "leftToRight"), (ParaDirection::RightToLeft, "rightToLeft")] { let set = CharStyle { char_direction: Some(d), ..CharStyle::default() }; assert_eq!(serde_json::to_value(&set).unwrap()["charDirection"], key); assert_eq!(serde_json::from_value::(serde_json::to_value(&set).unwrap()).unwrap(), set); } let old = serde_json::to_value(&st).unwrap(); assert_eq!(serde_json::from_value::(old).unwrap().char_direction, None); } /// Ruby saves with the type and a file saved before it (no `ruby` key) reads with none. #[test] fn ruby_is_saved_and_missing_ruby_reads_as_none() { let mut t = TextObject::point(Point::ZERO, "漢字", CharStyle::default()); t.ruby = vec![RubySpan { size_percent: 40.0, overhang: false, ..RubySpan::new(0, 6, "かんじ") }]; let json = serde_json::to_string(&t).unwrap(); assert!(json.contains("かんじ")); let back: TextObject = serde_json::from_str(&json).unwrap(); assert_eq!(back.ruby, t.ruby); assert!((back.ruby[0].size_percent - 40.0).abs() < 1e-9 && !back.ruby[0].overhang); // Old files have no `ruby` key: none. let mut old: serde_json::Value = serde_json::from_str(&json).unwrap(); old.as_object_mut().unwrap().remove("ruby"); assert!(serde_json::from_value::(old).unwrap().ruby.is_empty()); // A damaged file's range past the text and its empty reading are clamped away. let mut damaged = t.clone(); damaged.ruby = vec![RubySpan::new(0, 10_000, "かんじ"), RubySpan::new(3, 2, " "), RubySpan::new(0, 3, "")]; damaged.normalize_ruby(); assert_eq!((damaged.ruby[0].start, damaged.ruby[0].end), (0, 6)); } /// Digits map every digit of the three sets into the chosen one, leave the rest alone, and /// are saved only when set. #[test] fn digits_map_between_the_numeral_systems() { let map = |d: Digits, s: &str| -> String { s.chars().map(|c| d.map(c)).collect() }; for s in ["0123456789", "٠١٢٣٤٥٦٧٨٩", "۰۱۲۳۴۵۶۷۸۹"] { assert_eq!(map(Digits::Default, s), s); assert_eq!(map(Digits::Arabic, s), "0123456789"); assert_eq!(map(Digits::Hindi, s), "٠١٢٣٤٥٦٧٨٩"); assert_eq!(map(Digits::Farsi, s), "۰۱۲۳۴۵۶۷۸۹"); } // Letters, punctuation and other scripts' digits (Devanagari ३) are not digits of these sets. assert_eq!(map(Digits::Hindi, "a-Z ३ ٪ ۔"), "a-Z ३ ٪ ۔"); let st = CharStyle::default(); assert!(serde_json::to_value(&st).unwrap().get("digits").is_none()); let farsi = CharStyle { digits: Digits::Farsi, ..CharStyle::default() }; assert_eq!(serde_json::to_value(&farsi).unwrap()["digits"], "farsi"); // Styles written before the attribute existed (no `digits` key) read as Default. let old = serde_json::to_value(&st).unwrap(); assert_eq!(serde_json::from_value::(old).unwrap().digits, Digits::Default); assert_eq!(serde_json::from_value::(serde_json::to_value(&farsi).unwrap()).unwrap(), farsi); } /// The font height reference is the em box by default and is saved only when it is another. #[test] fn font_height_reference_is_saved_only_when_not_the_em_box() { let st = CharStyle::default(); assert_eq!(st.font_height_reference, FontHeightReference::EmBox); assert!(serde_json::to_value(&st).unwrap().get("fontHeightReference").is_none()); for (r, key) in [(FontHeightReference::CapHeight, "capHeight"), (FontHeightReference::XHeight, "xHeight"), (FontHeightReference::IcfBox, "icfBox")] { let set = CharStyle { font_height_reference: r, ..CharStyle::default() }; assert_eq!(serde_json::to_value(&set).unwrap()["fontHeightReference"], key); assert_eq!(serde_json::from_value::(serde_json::to_value(&set).unwrap()).unwrap(), set); } // Styles written before the attribute existed read as the em box. let old = serde_json::to_value(&st).unwrap(); assert_eq!(serde_json::from_value::(old).unwrap().font_height_reference, FontHeightReference::EmBox); } /// Insert Aki Left and Right are 0 by default and saved only when not 0, each side on its own; /// styles written before them read as 0, and a value out of range from a file is kept from 0 to one /// em. #[test] fn insert_aki_is_saved_only_when_set() { let st = CharStyle::default(); assert_eq!((st.aki_left, st.aki_right), (0.0, 0.0)); let saved = serde_json::to_value(&st).unwrap(); assert!(saved.get("akiLeft").is_none() && saved.get("akiRight").is_none()); for set in [ CharStyle { aki_left: 250.0, ..CharStyle::default() }, CharStyle { aki_right: 500.0, ..CharStyle::default() }, CharStyle { aki_left: 125.5, aki_right: 1000.0, ..CharStyle::default() }, ] { let saved = serde_json::to_value(&set).unwrap(); assert_eq!(saved.get("akiLeft").and_then(serde_json::Value::as_f64).unwrap_or(0.0), set.aki_left); assert_eq!(saved.get("akiRight").and_then(serde_json::Value::as_f64).unwrap_or(0.0), set.aki_right); assert_eq!(saved.get("akiLeft").is_some(), set.aki_left != 0.0); assert_eq!(serde_json::from_value::(saved).unwrap(), set); } let old = serde_json::to_value(&st).unwrap(); let read = serde_json::from_value::(old).unwrap(); assert_eq!((read.aki_left, read.aki_right), (0.0, 0.0)); let mut damaged = CharStyle { aki_left: -20.0, aki_right: 4000.0, ..CharStyle::default() }; damaged.keep_dimensions_in_range(); assert_eq!((damaged.aki_left, damaged.aki_right), (0.0, MAX_AKI)); let mut damaged = CharStyle { aki_left: f64::NAN, aki_right: f64::INFINITY, ..CharStyle::default() }; damaged.keep_dimensions_in_range(); assert_eq!((damaged.aki_left, damaged.aki_right), (0.0, MAX_AKI)); // A character style from a file is kept in range the same way. let mut d = crate::Document::new(100.0, 100.0); let attrs = serde_json::json!({"akiLeft": 5000, "akiRight": -1}); d.char_styles.push(TextStyleDef { name: "Spaced".into(), attrs: attrs.as_object().cloned().unwrap_or_default() }); d.keep_type_values_in_range(); assert_eq!((d.char_styles[0].attrs["akiLeft"].as_f64(), d.char_styles[0].attrs["akiRight"].as_f64()), (Some(MAX_AKI), Some(0.0))); } /// Tsume is 0 by default and saved only when not 0; styles written before it read as 0, and a /// value out of range from a file, in a run or a character style, is kept from 0 to 100. #[test] fn tsume_is_saved_only_when_set_and_kept_in_range() { let st = CharStyle::default(); assert_eq!(st.tsume, 0.0); let saved = serde_json::to_value(&st).unwrap(); assert!(saved.get("tsume").is_none()); let read = serde_json::from_value::(saved).unwrap(); assert_eq!(read.tsume, 0.0); let set = CharStyle { tsume: 37.5, ..CharStyle::default() }; let saved = serde_json::to_value(&set).unwrap(); assert_eq!(saved.get("tsume").and_then(serde_json::Value::as_f64), Some(37.5)); assert_eq!(serde_json::from_value::(saved).unwrap(), set); for (stored, kept) in [(-5.0, 0.0), (250.0, MAX_TSUME), (f64::NAN, 0.0), (f64::INFINITY, MAX_TSUME), (50.0, 50.0)] { let mut damaged = CharStyle { tsume: stored, ..CharStyle::default() }; damaged.keep_dimensions_in_range(); assert_eq!(damaged.tsume, kept, "{stored}"); } let mut d = crate::Document::new(100.0, 100.0); for tsume in [500, -1] { let attrs = serde_json::json!({ "tsume": tsume }); d.char_styles.push(TextStyleDef { name: format!("Tight {tsume}"), attrs: attrs.as_object().cloned().unwrap_or_default() }); } d.keep_type_values_in_range(); assert_eq!((d.char_styles[0].attrs["tsume"].as_f64(), d.char_styles[1].attrs["tsume"].as_f64()), (Some(MAX_TSUME), Some(0.0))); } /// Each Indic numeral system draws 0–9 (and the Arabic-Indic sets) as the ten digits of its /// script's block; every system saves under its id, which reads back, and other names are refused. #[test] fn indic_digits_map_to_their_scripts_block() { let map = |d: Digits, s: &str| -> String { s.chars().map(|c| d.map(c)).collect() }; for (d, zero) in [ (Digits::Devanagari, 0x966), (Digits::Bengali, 0x9E6), (Digits::Gurmukhi, 0xA66), (Digits::Gujarati, 0xAE6), (Digits::Odia, 0xB66), (Digits::Tamil, 0xBE6), (Digits::Telugu, 0xC66), (Digits::Kannada, 0xCE6), (Digits::Malayalam, 0xD66), ] { let block: String = (zero..zero + 10).map(|u| char::from_u32(u).unwrap()).collect(); assert!(block.chars().all(char::is_numeric), "{d:?}: {block}"); for s in ["0123456789", "٠١٢٣٤٥٦٧٨٩", "۰۱۲۳۴۵۶۷۸۹"] { assert_eq!(map(d, s), block, "{d:?}"); } assert_eq!(map(d, "a-Z ٪"), "a-Z ٪"); } assert_eq!(map(Digits::Devanagari, "page 12"), "page १२"); for d in Digits::ALL { assert_eq!(serde_json::to_value(d).unwrap(), d.id()); assert_eq!(serde_json::from_value::(d.id().into()).unwrap(), d); assert_eq!(Digits::from_id(d.id()), Some(d)); } assert_eq!(Digits::from_id("roman"), None); assert!(serde_json::from_value::("roman".into()).is_err()); } /// Language is saved only when set; styles written before it existed read as the default. #[test] fn language_is_saved_only_when_set() { let st = CharStyle::default(); let old = serde_json::to_value(&st).unwrap(); assert!(old.get("language").is_none()); assert_eq!(serde_json::from_value::(old).unwrap().language, None); let turkish = CharStyle { language: Some("tr".into()), ..CharStyle::default() }; assert_eq!(serde_json::to_value(&turkish).unwrap()["language"], "tr"); assert_eq!(serde_json::from_value::(serde_json::to_value(&turkish).unwrap()).unwrap(), turkish); } /// Auto leading follows the paragraph's Auto Leading; a set leading doesn't. #[test] fn paragraph_effective_leading_follows_auto_leading() { let st = CharStyle { size: 10.0, leading: None, ..CharStyle::default() }; let mut para = ParaStyle::default(); assert_eq!(para.effective_leading(&st), st.effective_leading(), "default 120%"); para.justification.auto_leading = 200.0; assert_eq!(para.effective_leading(&st), 20.0); para.justification.auto_leading = 0.0; assert_eq!(para.effective_leading(&st), 0.0); let set = CharStyle { leading: Some(14.0), ..st.clone() }; assert_eq!(para.effective_leading(&set), 14.0); para.justification.auto_leading = f64::NAN; assert_eq!(para.effective_leading(&st), st.effective_leading(), "not a number"); } /// A file can't feed layout justification values `text.setFormat` would refuse: each is /// clamped to its range, one that isn't finite takes its default, and a Minimum, Desired and /// Maximum out of order go back to their defaults. #[test] fn justification_options_read_from_a_file_stay_in_range() { let d = JustificationOptions::default(); let read: ParaStyle = serde_json::from_value(serde_json::json!({ "justification": { "word_spacing": [-5.0, 1e300, 1e308], "letter_spacing": [10.0, 5.0, 20.0], "glyph_scaling": [1.0, 100.0, 9e9], "auto_leading": -1e12 } })) .unwrap(); let j = read.justification; assert_eq!(j.word_spacing, [0.0, 1000.0, 1000.0]); assert_eq!(j.letter_spacing, d.letter_spacing, "out of order"); assert_eq!(j.glyph_scaling, [50.0, 100.0, 200.0]); assert_eq!(j.auto_leading, 0.0); let mut j = JustificationOptions { word_spacing: [f64::NAN, 100.0, f64::INFINITY], letter_spacing: [-1.0, 0.0, f64::NEG_INFINITY], auto_leading: f64::NAN, ..d.clone() }; j.keep_in_range(); assert_eq!((j.word_spacing, j.letter_spacing, j.auto_leading), (d.word_spacing, [-1.0, 0.0, 0.0], d.auto_leading)); let mut same = d.clone(); same.keep_in_range(); assert_eq!(same, d); } /// Korean Line Break Anywhere is off for a new paragraph and saved only when off; a paragraph /// saved before it existed, or a text object saved without paragraph attributes, reads with it on, /// and both values read back as saved. #[test] fn korean_line_break_anywhere_is_saved_only_when_off() { let off = ParaStyle::default(); assert!(!off.korean_line_break_anywhere); let saved = serde_json::to_value(&off).unwrap(); assert_eq!(saved["korean_line_break_anywhere"], false); assert_eq!(serde_json::from_value::(saved).unwrap(), off); let on = ParaStyle { korean_line_break_anywhere: true, ..ParaStyle::default() }; let saved = serde_json::to_value(&on).unwrap(); assert!(saved.get("korean_line_break_anywhere").is_none()); assert_eq!(serde_json::from_value::(saved).unwrap(), on); let old: ParaStyle = serde_json::from_str(r#"{"justify":"Left"}"#).unwrap(); assert!(old.korean_line_break_anywhere); let mut saved = serde_json::to_value(TextObject::point(Point::ZERO, "가나", CharStyle::default())).unwrap(); assert_eq!(saved["para"]["korean_line_break_anywhere"], false); saved.as_object_mut().unwrap().remove("para"); let old: TextObject = serde_json::from_value(saved).unwrap(); assert_eq!(old.para, ParaStyle { korean_line_break_anywhere: true, ..ParaStyle::default() }); } /// Numbered lists: each number style writes its numbers and rolls over (letters after Z, /// roman numerals in subtractive forms, zero-padded numbers past their digits), the marker adds /// a period, and the count runs through list paragraphs, skips empty and bulleted ones and /// starts again after a paragraph in no list. A list from before number styles reads as /// bulleted, and a bulleted list saves no number style. #[test] fn number_styles_write_their_numbers_and_roll_over() { let numbers = |style: NumberStyle, ns: &[u32]| ns.iter().map(|&n| style.format(n)).collect::>(); assert_eq!(numbers(NumberStyle::Arabic, &[1, 9, 10, 123]), ["1", "9", "10", "123"]); assert_eq!( numbers(NumberStyle::UpperLetters, &[1, 2, 26, 27, 28, 52, 53, 3999, 4000]), ["A", "B", "Z", "AA", "BB", "ZZ", "AAA", &"U".repeat(154), "4000"] ); assert_eq!(numbers(NumberStyle::LowerLetters, &[1, 26, 27]), ["a", "z", "aa"]); assert_eq!( numbers(NumberStyle::UpperRoman, &[1, 2, 3, 4, 5, 9, 14, 40, 90, 400, 1994, 3999, 4000]), ["I", "II", "III", "IV", "V", "IX", "XIV", "XL", "XC", "CD", "MCMXCIV", "MMMCMXCIX", "4000"] ); assert_eq!(numbers(NumberStyle::LowerRoman, &[1, 4, 9, 12]), ["i", "iv", "ix", "xii"]); assert_eq!(numbers(NumberStyle::TwoDigits, &[1, 9, 10, 99, 100]), ["01", "09", "10", "99", "100"]); assert_eq!(numbers(NumberStyle::ThreeDigits, &[1, 10, 999, 1000]), ["001", "010", "999", "1000"]); assert_eq!(ParaList::numbered(NumberStyle::UpperRoman).marker(4), "IV."); assert_eq!(ParaList::bulleted(Bullet::Square).marker(4), "\u{25AA}"); let (num, dot) = (Some(ParaList::numbered(NumberStyle::Arabic)), Some(ParaList::bulleted(Bullet::Dot))); let mut count = ListCounts::default(); let markers: Vec> = [(num, false), (num, true), (dot, false), (num, false), (None, false), (num, false)] .iter() .map(|&(l, empty)| ParaList::next_marker(l, empty, &mut count)) .collect(); assert_eq!(markers, [Some("1.".into()), None, Some("\u{2022}".into()), Some("2.".into()), None, Some("1.".into())]); assert_eq!(count.parts(), (1, vec![])); let read = |v: serde_json::Value| serde_json::from_value::(v).unwrap(); assert_eq!(read(serde_json::json!({"bullet": "dash"})), ParaList::bulleted(Bullet::Dash)); assert_eq!(read(serde_json::json!({"number": "threeDigits"})), ParaList::numbered(NumberStyle::ThreeDigits)); assert_eq!(serde_json::to_value(ParaList::bulleted(Bullet::Dash)).unwrap(), serde_json::json!({"bullet": "dash"})); assert_eq!( serde_json::to_value(ParaList::numbered(NumberStyle::LowerRoman)).unwrap(), serde_json::json!({"bullet": "dot", "number": "lowerRoman"}) ); } /// A list's marker alignment: Left by default and not saved, Right saved as `"align": "right"`; /// a list saved without it reads as Left. #[test] fn a_list_saves_its_marker_alignment_only_when_it_is_right() { let right = ParaList::numbered(NumberStyle::Arabic).aligned(ListAlign::Right); assert_eq!(ParaList::bulleted(Bullet::Dot).align, ListAlign::Left); assert_eq!(serde_json::to_value(right).unwrap(), serde_json::json!({"bullet": "dot", "number": "arabic", "align": "right"})); assert_eq!(serde_json::to_value(ParaList::bulleted(Bullet::Dash)).unwrap(), serde_json::json!({"bullet": "dash"})); let read = |v: serde_json::Value| serde_json::from_value::(v).unwrap(); assert_eq!(read(serde_json::json!({"bullet": "dot", "number": "arabic", "align": "right"})), right); assert_eq!(read(serde_json::json!({"bullet": "square"})).align, ListAlign::Left); assert!(serde_json::from_value::(serde_json::json!({"align": "center"})).is_err()); } /// Typed list detection: "1.", "1)", "A." and "A)" and a space at the start of a paragraph /// start a numbered list, and "*", "+", "#" and ">" and a space start a bulleted list with the /// filled dot, the hollow circle, the filled square and the dash. Other text, the same characters /// later in a paragraph or without the space, and a paragraph already in a list start nothing. #[test] fn typed_list_starts_are_found_at_a_paragraphs_start() { let (arabic, letters, dot) = (ParaList::numbered(NumberStyle::Arabic), ParaList::numbered(NumberStyle::UpperLetters), ParaList::bulleted(Bullet::Dot)); let (circle, square, dash) = (ParaList::bulleted(Bullet::Circle), ParaList::bulleted(Bullet::Square), ParaList::bulleted(Bullet::Dash)); let typed = ["1.", "1)", "A.", "A)", "*", "+", "#", ">"].map(ParaList::typed); assert_eq!(typed, [arabic, arabic, letters, letters, dot, circle, square, dash].map(Some)); for other in ["", "2.", "a.", "a)", "I.", "1", "A", "1:", "-", "•", "1.)", " 1.", "*1", "1."] { assert_eq!(ParaList::typed(other), None, "{other:?}"); } let mut t = TextObject::point(Point::ZERO, "Fruit\n1. Apples\nA) x * y\n+ ", CharStyle::default()); assert_eq!(t.typed_list_at(9), Some((6, arabic))); assert_eq!(t.typed_list_at(19), Some((16, letters))); assert_eq!(t.typed_list_at(27), Some((25, circle))); // Not at the paragraph's start, not right after the space, or past the end. for at in [0, 5, 8, 10, 15, 23, 25, 26, 99] { assert_eq!(t.typed_list_at(at), None, "{at}"); } let mut styles = t.paragraph_styles(); styles[1].list = Some(ParaList::bulleted(Bullet::Square)); t.set_paragraph_styles(styles); assert_eq!(t.typed_list_at(9), None, "a list paragraph stays as it is"); assert_eq!(t.typed_list_at(19), Some((16, letters))); } /// List levels: each level counts its own numbers, a deeper paragraph starts its count at 1, /// a paragraph back at a shallower level goes on with that level's count, and a paragraph in /// no list starts every level again. A level past the first sets the paragraph 18 pt further /// in; the file saves the level only when it is not 1, and a level outside 1 to 9 reads as the /// nearest one. A type object's counts save level 1 and the deeper levels apart. #[test] fn list_levels_count_their_own_numbers_and_save_only_past_the_first() { let num = |level| Some(ParaList::numbered(NumberStyle::Arabic).at_level(level)); let dot = |level| Some(ParaList::bulleted(Bullet::Dot).at_level(level)); let mut counts = ListCounts::default(); let markers: Vec> = [ (num(1), false), (num(2), false), (num(2), false), (num(3), false), (num(2), true), (num(2), false), (num(1), false), (num(2), false), (dot(1), false), (num(2), false), (num(1), false), (None, false), (num(2), false), ] .iter() .map(|&(l, empty)| ParaList::next_marker(l, empty, &mut counts)) .collect(); let want = ["1.", "1.", "2.", "1.", "", "3.", "2.", "1.", "\u{2022}", "1.", "3.", "", "1."]; assert_eq!(markers.iter().map(|m| m.as_deref().unwrap_or("")).collect::>(), want); assert_eq!(counts, ListCounts([0, 1, 0, 0, 0, 0, 0, 0, 0])); assert_eq!((ParaList::default().level, ParaList::bulleted(Bullet::Dot).depth()), (1, 1)); assert_eq!([0, 1, 4, 9, 12].map(|l| ParaList::bulleted(Bullet::Dot).at_level(l).depth()), [1, 1, 4, 9, 9]); assert_eq!([1, 2, 9].map(|l| ParaList::bulleted(Bullet::Dot).at_level(l).level_indent()), [0.0, 18.0, 144.0]); let para = ParaStyle { left_indent: 18.0, list: dot(3), ..Default::default() }; assert_eq!((para.laid_out_left_indent(), ParaStyle { list: None, ..para.clone() }.laid_out_left_indent()), (54.0, 18.0)); assert_eq!(serde_json::to_value(dot(1)).unwrap(), serde_json::json!({"bullet": "dot"})); assert_eq!(serde_json::to_value(num(4)).unwrap(), serde_json::json!({"bullet": "dot", "number": "arabic", "level": 4})); let read = |v: serde_json::Value| serde_json::from_value::(v).unwrap(); assert_eq!((read(serde_json::json!({"bullet": "dash"})).level, read(serde_json::json!({"level": 4}))), (1, dot(4).unwrap())); assert!(serde_json::from_value::(serde_json::json!({"level": "two"})).is_err()); assert!(serde_json::from_value::(serde_json::json!({"level": 2.5})).is_err()); let levels = [serde_json::json!(0), serde_json::json!(-1), serde_json::json!(12), serde_json::json!(300), serde_json::json!(u64::MAX)]; assert_eq!( levels.map(|l| read(serde_json::json!({ "level": l })).level), [1, 1, 9, 9, 9], "a saved level outside 1 to 9 reads as the nearest one" ); let deep = ListCounts([5, 0, 2, 0, 0, 0, 0, 0, 0]); assert_eq!(deep.parts(), (5, vec![0, 2])); assert_eq!((ListCounts::from_parts(5, &[0, 2]), ListCounts::default().parts()), (deep, (0, vec![]))); let mut t = TextObject::point(Point::ZERO, "Text", CharStyle::default()); t.set_list_counts(deep); assert_eq!((t.list_count, t.list_level_counts.as_slice(), t.list_counts()), (5, &[0, 2][..], deep)); let saved = serde_json::to_value(&t).unwrap(); assert_eq!((&saved["listCount"], &saved["listLevelCounts"]), (&serde_json::json!(5), &serde_json::json!([0, 2]))); t.set_list_counts(ListCounts::default()); assert!(serde_json::to_value(&t).unwrap().get("listLevelCounts").is_none(), "no counts past level 1 are saved without them"); let mut saved = serde_json::to_value(&t).unwrap(); saved["listLevelCounts"] = serde_json::json!((1..=20).collect::>()); let opened = serde_json::from_value::(saved).unwrap(); assert_eq!(opened.list_level_counts, (1..=8).collect::>(), "a file keeps only the counts of levels 2 to 9"); } /// In a threaded frame whose first paragraph continues from the frame before, the text at the /// frame's start is not the start of a paragraph, so typing a list's start there starts nothing. /// The paragraphs after it still start lists. #[test] fn typed_list_starts_skip_a_continued_paragraph() { let dot = ParaList::bulleted(Bullet::Dot); let mut t = TextObject::point(Point::ZERO, "* Pears\n* ", CharStyle::default()); assert_eq!(t.typed_list_at(2), Some((0, dot))); t.first_para_continues = true; assert_eq!(t.typed_list_at(2), None, "a continued paragraph starts no list"); assert_eq!(t.typed_list_at(10), Some((8, dot))); } #[test] fn character_controls_reject_collapsed_and_nonfinite_transforms() { let mut t = TextObject::point(Point::ZERO, "Text", CharStyle::default()); for matrix in [[0.0; 6], [1.0, 1.0, 2.0, 2.0, 0.0, 0.0], [f64::INFINITY, 0.0, 0.0, 1.0, 0.0, 0.0], [1.0, 0.0, 0.0, 1.0, f64::NAN, 0.0]] { t.xf = Affine::new(matrix); assert!(t.effective_char_style(&t.first_style()).is_none()); } t.xf = Affine::rotate(0.83); assert_eq!(t.effective_char_style(&t.first_style()).unwrap().size, 12.0); t.xf = Affine::scale(1e308); assert!(t.effective_char_style(&t.first_style()).is_none(), "overflowing point size"); } #[test] fn point_text_basics() { let t = TextObject::point(Point::new(10.0, 20.0), "Hello", CharStyle::default()); assert_eq!(t.plain_text(), "Hello"); let b = t.bounds().unwrap(); assert!(b.x0 >= 10.0 - 1e-9 && b.y1 > 20.0); assert_eq!(CharStyle::default().effective_leading(), 14.399999999999999); } fn justified(j: Justify) -> ParaStyle { ParaStyle { justify: j, ..ParaStyle::default() } } #[test] fn paragraph_styles_split_merge_and_normalize() { let mut t = TextObject::point(Point::ZERO, "one\ntwo\nthree", CharStyle::default()); assert_eq!((t.paragraph_count(), t.paras.len()), (3, 0), "one style for all: nothing stored"); assert_eq!(t.paragraphs_in(0, 0), 0..1); assert_eq!(t.paragraphs_in(4, 4), 1..2); assert_eq!(t.paragraphs_in(2, 9), 0..3); assert_eq!(t.paragraphs_in(99, 99), 2..3, "clamped to the text"); t.edit_paras(Some(1..2), |p| p.justify = Justify::Center); let js = |t: &TextObject| t.paragraph_styles().iter().map(|p| p.justify).collect::>(); assert_eq!(js(&t), [Justify::Left, Justify::Center, Justify::Left]); // Return inside "two": the new paragraph continues its style. t.splice_paras(5, 5, "\n"); t.runs[0].text.insert(5, '\n'); assert_eq!(js(&t), [Justify::Left, Justify::Center, Justify::Center, Justify::Left]); // Deleting the break between "one" and "t": the first paragraph's style wins. t.splice_paras(3, 4, ""); t.runs[0].text.remove(3); assert_eq!(t.plain_text(), "onet\nwo\nthree"); assert_eq!(js(&t), [Justify::Left, Justify::Center, Justify::Left]); // An edit that skips the splice is repaired by normalizing (the last style continues). t.runs[0].text.push_str("\nfour"); t.normalize_paras(); assert_eq!(js(&t), [Justify::Left, Justify::Center, Justify::Left, Justify::Left]); // `para` is paragraph 0's; all alike collapses to `para` alone. t.edit_paras(Some(0..1), |p| p.justify = Justify::Right); assert_eq!(t.para.justify, Justify::Right); t.edit_paras(None, |p| p.justify = Justify::Right); assert!(t.paras.is_empty() && t.para.justify == Justify::Right); // A short list repeats its last entry, a long one is cut. t.set_paragraph_styles(vec![justified(Justify::Left), justified(Justify::Center)]); assert_eq!(js(&t), [Justify::Left, Justify::Center, Justify::Center, Justify::Center]); t.set_paragraph_styles(vec![justified(Justify::Center); 9]); assert!(t.paras.is_empty() && t.para.justify == Justify::Center); // Old documents (no `paras`) load; new ones keep paragraph 0 in `para`. t.edit_paras(Some(3..4), |p| p.space_before = 4.0); let json = serde_json::to_value(&t).unwrap(); assert_eq!(json["para"]["justify"], json["paras"][0]["justify"]); let mut old = json.clone(); old.as_object_mut().unwrap().remove("paras"); let back: TextObject = serde_json::from_value(old).unwrap(); assert!(back.paras.is_empty() && back.para_at(3).justify == Justify::Center); let back: TextObject = serde_json::from_value(json).unwrap(); assert_eq!(back.para_at(3).space_before, 4.0); } /// Text Flow is saved only when by rows: area type by columns (the default) saves as it did before /// the option, and files from before it read by columns; other values don't read. #[test] fn text_flow_is_saved_only_when_by_rows() { let by_columns = serde_json::to_value(AreaOptions::default()).unwrap(); assert!(by_columns.get("flow").is_none()); assert_eq!(serde_json::from_value::(by_columns).unwrap().flow, TextFlow::Columns); let by_rows = serde_json::to_value(AreaOptions { flow: TextFlow::Rows, ..AreaOptions::default() }).unwrap(); assert_eq!(by_rows["flow"], "rows"); assert_eq!(serde_json::from_value::(by_rows).unwrap().flow, TextFlow::Rows); assert!(serde_json::from_value::(serde_json::json!({"flow": "diagonal"})).is_err()); } /// 120 × 40 area type at (40, 40), its text drawn at twice its size. fn area_type() -> TextObject { let mut t = TextObject::point(Point::ZERO, "Some text", CharStyle::default()); t.kind = TextKind::Area { frame: vectorcraft_geom::shapes::rectangle(Rect::new(0.0, 0.0, 60.0, 20.0)) }; t.xf = Affine::translate((40.0, 40.0)) * Affine::scale(2.0); t } #[test] fn area_resizes_its_frame_and_keeps_its_type() { let mut t = area_type(); assert_eq!(t.bounds(), Some(Rect::new(40.0, 40.0, 160.0, 80.0))); // Bottom-right handle to (200, 140), about the top-left corner. let o = Affine::translate((40.0, 40.0)); assert!(t.transform_area(o * Affine::scale_non_uniform(160.0 / 120.0, 100.0 / 40.0) * o.inverse())); assert_eq!(t.xf, Affine::translate((40.0, 40.0)) * Affine::scale(2.0), "the type keeps its size"); let b = t.bounds().unwrap(); assert!((b.x1 - 200.0).abs() < 1e-9 && (b.y1 - 140.0).abs() < 1e-9 && b.x0 == 40.0, "{b:?}"); assert_eq!(t.area_frame().unwrap().bounds(), Some(b)); // Point type has no area; a degenerate transform or a non-finite frame changes nothing. let mut p = TextObject::point(Point::ZERO, "x", CharStyle::default()); assert!(!p.transform_area(Affine::scale(2.0)) && p.area_frame().is_none()); let before = t.clone(); assert!(!t.transform_area(Affine::scale(f64::INFINITY))); t.xf = Affine::scale(0.0); assert!(!t.transform_area(Affine::scale(2.0))); t.xf = before.xf; assert_eq!(t, before); } #[test] fn area_anchors_move_in_document_space() { let mut t = area_type(); // The bottom-right corner (anchor 2) 20 pt right: 10 pt in text space at 2×. assert!(t.move_area_anchors(&[(0, 2)], Vec2::new(20.0, 0.0))); let TextKind::Area { frame } = &t.kind else { panic!() }; assert_eq!(frame.subpaths[0].anchors[2].p, Point::new(70.0, 20.0)); assert_eq!(frame.subpaths[0].anchors[1].p, Point::new(60.0, 0.0), "the others stay"); // A missing anchor changes nothing. let before = t.clone(); assert!(!t.move_area_anchors(&[(0, 1), (0, 9)], Vec2::new(5.0, 5.0))); assert!(!t.move_area_anchors(&[(3, 0)], Vec2::new(5.0, 5.0))); assert_eq!(t, before); } /// Type on an open path may start before the path's start: the start is kept, saved and read back, /// while the start bracket stays at the path's start. On a closed path, and for a start that is not /// finite, the start is the start bracket as before. #[test] fn type_on_an_open_path_starts_before_the_path() { let pts = [Point::new(0.0, 0.0), Point::new(100.0, 0.0), Point::new(100.0, 100.0)]; let on = |closed: bool, start: f64| TextKind::OnPath { path: PathData::new(vec![vectorcraft_geom::SubPath::polyline(&pts, closed)]), start, end: None, }; let open = on(false, -0.25); assert_eq!(open.path_text_start(), Some(-0.25)); assert!(open.starts_before_path()); assert_eq!(open.path_span(), Some((0.0, 1.0))); let saved = serde_json::to_value(&open).unwrap(); assert_eq!(saved["start"], -0.25); assert_eq!(serde_json::from_value::(saved).unwrap(), open); assert_eq!(on(false, -1e9).path_text_start(), Some(-PATH_LEAD_MAX)); assert_eq!(on(false, f64::NEG_INFINITY).path_text_start(), Some(0.0)); assert_eq!(on(false, 0.25).path_text_start(), Some(0.25)); assert!(!on(false, 0.0).starts_before_path()); assert_eq!(on(true, -0.25).path_text_start(), Some(0.0)); assert!(!on(true, -0.25).starts_before_path()); assert_eq!(TextKind::Point.path_text_start(), None); } /// Builds from before [`Justify::Auto`] read new type's alignment as Left or Right (and ignore /// `justify_auto`); this build reads Auto back. #[test] fn auto_alignment_saves_readable_by_older_builds() { #[derive(Deserialize, Debug, PartialEq)] enum OldJustify { Left, Center, Right, JustifyLeft, JustifyCenter, JustifyRight, JustifyAll, } #[derive(Deserialize)] struct OldPara { justify: OldJustify, } #[derive(Deserialize)] struct OldText { para: OldPara, } for (direction, physical) in [(Some(ParaDirection::RightToLeft), OldJustify::Right), (Some(ParaDirection::LeftToRight), OldJustify::Left), (None, OldJustify::Left)] { let mut t = TextObject::point(Point::ZERO, "שלום", CharStyle::default()); t.para = ParaStyle { justify: Justify::Auto, direction, ..Default::default() }; let json = serde_json::to_string(&t).unwrap(); let old: OldText = serde_json::from_str(&json).unwrap(); assert_eq!(old.para.justify, physical, "{json}"); assert_eq!(serde_json::from_str::(&json).unwrap(), t); } // Other alignments save as before, without the flag. let p = ParaStyle { justify: Justify::Right, ..Default::default() }; let json = serde_json::to_string(&p).unwrap(); assert!(!json.contains("justify_auto"), "{json}"); assert_eq!(serde_json::from_str::(&json).unwrap(), p); // Files from before the flag keep their alignment. assert_eq!(serde_json::from_str::(r#"{"justify":"Center"}"#).unwrap().justify, Justify::Center); }