88f5a00e389b
tests.rs
use super::*;
/// #777: an unknown attribute names the nearest one, or lists them all.
#[test]
fn unknown_attributes_suggest_the_right_name() {
let mut c = CharAttrs::default();
assert_eq!(c.set_json("font", &serde_json::json!("X")).unwrap_err(), "unknown attribute `font`; did you mean `fontFamily`?");
assert_eq!(c.set_json("fontFamly", &serde_json::json!("X")).unwrap_err(), "unknown attribute `fontFamly`; did you mean `fontFamily`?");
let all = c.set_json("zzzzzz", &serde_json::json!(1)).unwrap_err();
assert!(all.starts_with("unknown attribute `zzzzzz`; the attributes are: ") && all.contains("fontFamily") && all.contains("fontStyle"), "{all}");
assert!(c.set_json("font_family", &serde_json::json!("X")).is_ok() && c.set_json("fontFamily", &serde_json::json!("X")).is_ok());
let mut p = ParaAttrs::default();
assert_eq!(p.set_json("spaceBefor", &serde_json::json!(3)).unwrap_err(), "unknown attribute `spaceBefor`; did you mean `spaceBefore`?");
assert_eq!(camel("first_line_indent"), "firstLineIndent");
}
#[test]
fn levels_number_on_their_own_and_restart_after_a_higher_level() {
let at = |level: u32| ParaProps { list_type: ListType::Numbers, list_level: level, number_expression: "^1.^#".into(), ..ParaProps::default() };
let mut c = ListCounter::default();
let mut labels = vec![];
for level in [1, 2, 2, 1, 2] {
let pp = at(level);
c.advance(&pp);
labels.push(pp.number_label_in(&c));
}
assert_eq!(labels, ["1.1", "1.1", "1.2", "2.2", "2.1"]);
// Without the restart, level 2 carries on.
let mut c = ListCounter::default();
let keep = |level: u32| ParaProps { restart_numbers: false, ..at(level) };
let n: Vec<u32> = [1, 2, 1, 2].into_iter().map(|l| c.advance(&keep(l))).collect();
assert_eq!(n, [1, 1, 2, 2]);
}
#[test]
fn a_partial_rule_keeps_the_other_fields() {
let current = ParaProps {
rule_below: Rule { on: true, weight: 3.0, color: "Red".into(), offset: 4.0, column_width: false, ..Rule::default() },
..ParaProps::default()
};
let mut a = ParaAttrs::default();
a.set_json_over("ruleBelow", &serde_json::json!({"color": "Blue"}), ¤t).unwrap();
assert_eq!(a.rule_below, Some(Rule { color: "Blue".into(), ..current.rule_below.clone() }));
assert_eq!(a.rule_above, None);
assert!(a.set_json_over("ruleAbove", &serde_json::json!({"colour": "Blue"}), ¤t).is_err(), "unknown field");
a.set_json_over("ruleBelow", &serde_json::Value::Null, ¤t).unwrap();
assert_eq!(a.rule_below, None, "null clears the override");
}
#[test]
fn stroke_behind_fill_is_saved_only_when_set() {
assert!(!CharProps::default().stroke_behind_fill);
assert_eq!(serde_json::to_value(CharAttrs::default()).unwrap(), serde_json::json!({}));
let mut a = CharAttrs::default();
a.set_json("strokeBehindFill", &serde_json::json!(true)).unwrap();
let v = serde_json::to_value(&a).unwrap();
assert_eq!(v, serde_json::json!({"strokeBehindFill": true}));
assert_eq!(serde_json::from_value::<CharAttrs>(v).unwrap(), a);
let mut p = CharProps::default();
p.apply(&a);
assert!(p.stroke_behind_fill);
}
#[test]
fn digits_map_to_their_script() {
assert_eq!(Digits::Default.map('7', "Arabic"), '7');
assert_eq!(Digits::Hindi.map('3', ""), '\u{0663}');
assert_eq!(Digits::Farsi.map('0', ""), '\u{06F0}');
assert_eq!(Digits::Native.map('5', "Thai"), '\u{0E55}');
assert_eq!(Digits::Native.map('5', "English: USA"), '5');
assert_eq!(Digits::Hindi.map('x', ""), 'x');
}
#[test]
fn language_names_map_to_bcp47_tags() {
assert_eq!(language_tag("English: USA"), Some("en-US"));
assert_eq!(language_tag("English: Australian"), Some("en"));
assert_eq!(language_tag("Turkish"), Some("tr"));
assert_eq!(language_tag("Georgian"), Some("ka"));
assert_eq!(language_tag("Japanese"), Some("ja"));
assert_eq!(language_tag("Korean"), Some("ko"));
assert_eq!(language_tag("Chinese"), Some("zh"));
assert_eq!(language_tag("Chinese: Simplified"), Some("zh-Hans"));
assert_eq!(language_tag("Chinese: Traditional"), Some("zh-Hant"));
assert_eq!(language_tag("Arabic"), Some("ar"));
assert_eq!(language_tag("Persian"), Some("fa"));
assert_eq!(language_tag("Farsi"), Some("fa"));
assert_eq!(language_tag("Urdu"), Some("ur"));
assert_eq!(language_tag("Hebrew"), Some("he"));
assert_eq!(language_tag("Esperanto"), Some("eo"));
assert_eq!(language_tag("$ID/Esperanto"), Some("eo"));
assert_eq!(language_tag("[No Language]"), None);
assert_eq!(language_tag("Klingon"), None);
assert_eq!(language_tag(""), None);
}
#[test]
fn chinese_japanese_and_korean_names_map_in_their_common_spellings() {
for (name, tag) in [
("Chinese: Simplified", Some("zh-Hans")),
("Simplified Chinese", Some("zh-Hans")),
("Chinese Simplified", Some("zh-Hans")),
("Chinese (Simplified)", Some("zh-Hans")),
(" chinese: SIMPLIFIED ", Some("zh-Hans")),
("zh_CN", Some("zh-Hans")),
("zh-CN", Some("zh-Hans")),
("zh-Hans", Some("zh-Hans")),
("zh-Hans-CN", Some("zh-Hans")),
("Chinese: Traditional", Some("zh-Hant")),
("Traditional Chinese", Some("zh-Hant")),
("Chinese Traditional", Some("zh-Hant")),
("Chinese (Traditional)", Some("zh-Hant")),
("zh_TW", Some("zh-Hant")),
("zh-TW", Some("zh-Hant")),
("zh_HK", Some("zh-Hant")),
("zh-HK", Some("zh-Hant")),
("zh-Hant", Some("zh-Hant")),
("Chinese", Some("zh")),
("zh", Some("zh")),
("Japanese", Some("ja")),
("ja", Some("ja")),
("ja_JP", Some("ja-JP")),
("ja-JP", Some("ja-JP")),
("Korean", Some("ko")),
("ko_KR", Some("ko-KR")),
("ko-KR", Some("ko-KR")),
("English: USA", Some("en-US")),
("German: Swiss 2006 Reform", Some("de-CH")),
("Norwegian: Bokmål", Some("nb")),
("[No Language]", None),
] {
assert_eq!(language_tag(name), tag, "{name}");
}
}
#[test]
fn locale_codes_map_to_their_tags() {
for (name, tag) in [
// As InDesign-exported IDML writes them (AppliedLanguage).
("$ID/de_DE_2006", Some("de-DE")),
("$ID/nl_NL_2005", Some("nl-NL")),
("$ID/English: USA", Some("en-US")),
("$ID/English: UK", Some("en-GB")),
("$ID/Spanish: Castilian", Some("es-ES")),
("$ID/French", Some("fr")),
// As IDML import keeps them.
("de_DE_2006", Some("de-DE")),
("nl_NL_2005", Some("nl-NL")),
("Spanish: Castilian", Some("es-ES")),
("French", Some("fr")),
// Other locale codes.
("de-DE", Some("de-DE")),
("de_CH_2006", Some("de-CH")),
("pt_BR", Some("pt-BR")),
("en_us", Some("en-US")),
("es_419", Some("es-419")),
("fil_PH", Some("fil-PH")),
("sv", Some("sv")),
("ja", Some("ja")),
// Not codes.
("de_DE_2006_x", None),
("d_DE", None),
("de_D", None),
("de_DE_06", None),
("1e_DE", None),
("[No Language]", None),
] {
assert_eq!(language_tag(name), tag, "{name}");
}
assert_eq!(language_subtag("de-DE"), "de");
assert_eq!(language_subtag("zh-Hant"), "zh");
assert_eq!(language_subtag("ko"), "ko");
}
#[test]
fn merge_and_resolve() {
let mut a = CharAttrs { size: Some(10.0), ..Default::default() };
a.merge(&CharAttrs { tracking: Some(20.0), size: Some(11.0), ..Default::default() });
assert_eq!(a.size, Some(11.0));
assert_eq!(a.count(), 2);
let mut p = CharProps::default();
p.apply(&a);
assert_eq!(p.size, 11.0);
assert_eq!(p.tracking, 20.0);
assert_eq!(p.font_family, "Source Serif 4");
}
#[test]
fn tab_lists_are_checked() {
let stop = |position: f64| TabStop { position, align: TabAlign::Left, leader: String::new(), align_on: String::new() };
assert!(TabStop::checked_list(vec![stop(f64::NAN)]).is_err());
assert!(TabStop::checked_list(vec![stop(f64::INFINITY)]).is_err());
assert!(TabStop::checked_list((0..=MAX_TAB_STOPS).map(|i| stop(i as f64)).collect()).is_err());
let list = TabStop::checked_list(vec![stop(50.0), TabStop { leader: ".".into(), ..stop(10.0) }, stop(50.001)]).unwrap();
assert_eq!(list.iter().map(|t| t.position).collect::<Vec<_>>(), [10.0, 50.001], "sorted, one stop per position");
}
/// A file's tab list is repaired, never refused; a list the commands accept comes through
/// unchanged.
#[test]
fn tab_lists_from_files_are_sanitized() {
let stop = |position: f64| TabStop { position, align: TabAlign::Left, leader: String::new(), align_on: String::new() };
let mut tabs: Vec<TabStop> = (0..500).rev().map(|i| stop(i as f64 * 10.0)).collect();
tabs.push(stop(f64::NAN));
tabs.push(stop(f64::NEG_INFINITY));
tabs.push(TabStop { leader: "\u{7}0123456789".into(), align: TabAlign::Char, align_on: "\n,;".into(), ..stop(-3.0) });
let list = TabStop::sanitized_list(tabs);
assert_eq!(list.len(), MAX_TAB_STOPS);
assert!(list.windows(2).all(|w| w[1].position - w[0].position >= SAME_TAB_POSITION), "sorted, one stop per position");
let first = &list[0];
assert_eq!((first.position, first.leader.as_str(), first.align_on.as_str()), (0.0, "01234567", ","), "the later stop at 0 wins");
assert_eq!(list.last().map(|t| t.position), Some(990.0), "the first stops by position are kept");
let ok = TabStop::checked_list(vec![stop(72.0), TabStop { align: TabAlign::Char, ..stop(10.0) }]).unwrap();
assert_eq!(TabStop::sanitized_list(ok.clone()), ok);
// `null` is how JSON writes a non-finite position; that stop is dropped, the others kept.
let json = r#"{"tabs":[{"position":null},{"position":20000,"leader":"0123456789"},{"position":5}]}"#;
let a: ParaAttrs = serde_json::from_str(json).unwrap();
let tabs = a.tabs.unwrap();
assert_eq!(tabs.iter().map(|t| t.position).collect::<Vec<_>>(), [5.0, MAX_TAB_POSITION]);
assert_eq!(tabs[1].leader, "01234567");
let p: ParaProps = serde_json::from_str(json).unwrap();
assert_eq!(p.tabs, tabs);
assert!(serde_json::from_str::<TabStop>("{}").is_err(), "a stop names its position");
}
#[test]
fn set_json_by_name() {
let mut a = ParaAttrs::default();
a.set_json("spaceBefore", &serde_json::json!(6.0)).unwrap();
a.set_json("align", &serde_json::json!("center")).unwrap();
a.set_json("left_indent", &serde_json::json!(12)).unwrap();
assert_eq!(a.space_before, Some(6.0));
assert_eq!(a.align, Some(Align::Center));
assert_eq!(a.left_indent, Some(12.0));
assert!(a.set_json("nope", &serde_json::json!(1)).is_err());
a.set_json("align", &serde_json::Value::Null).unwrap();
assert_eq!(a.align, None);
}
#[test]
fn delta_and_common() {
let a = CharProps::default();
let mut b = a.clone();
b.size = 18.0;
let d = a.delta(&b);
assert_eq!(d.count(), 1);
let c = CharProps::common([&a, &b]);
assert_eq!(c.size, None);
assert_eq!(c.font_family.as_deref(), Some("Source Serif 4"));
}
#[test]
fn serde_skips_unset() {
let a = CharAttrs { size: Some(9.0), ..Default::default() };
assert_eq!(serde_json::to_string(&a).unwrap(), r#"{"size":9.0}"#);
let p: ParaProps = serde_json::from_str(r#"{"align":"center"}"#).unwrap();
assert_eq!(p.align, Align::Center);
assert_eq!(p.word_space_max, 1.33);
}
#[test]
fn same_para_style_spacing_ignore_survives_serde() {
for v in [None, Some(None), Some(Some(0.0))] {
let a = ParaAttrs { same_para_style_spacing: v, ..Default::default() };
let back: ParaAttrs = serde_json::from_str(&serde_json::to_string(&a).unwrap()).unwrap();
assert_eq!(back.same_para_style_spacing, v);
}
}
#[test]
fn numbering_styles() {
assert_eq!(NumberStyle::UpperRoman.format(14), "XIV");
assert_eq!(NumberStyle::LowerRoman.format(9), "ix");
assert_eq!(NumberStyle::UpperLetters.format(1), "A");
assert_eq!(NumberStyle::UpperLetters.format(27), "AA");
assert_eq!(NumberStyle::LowerLetters.format(28), "bb");
assert_eq!(NumberStyle::ArabicLeadingZero.format(3), "03");
assert_eq!(NumberStyle::ArabicThreeDigits.format(7), "007");
assert_eq!(NumberStyle::ArabicFourDigits.format(12), "0012");
// Repeating forms stay small for huge numbers.
assert_eq!(NumberStyle::UpperRoman.format(u32::MAX), u32::MAX.to_string());
assert_eq!(NumberStyle::LowerLetters.format(u32::MAX), u32::MAX.to_string());
assert_eq!(NumberStyle::Symbols.format(u32::MAX), u32::MAX.to_string());
}
#[test]
fn kanji_numbers_are_written_digit_by_digit() {
for (n, s) in [
(0, "〇"),
(1, "一"),
(5, "五"),
(10, "一〇"),
(11, "一一"),
(20, "二〇"),
(38, "三八"),
(99, "九九"),
(100, "一〇〇"),
(105, "一〇五"),
(1000, "一〇〇〇"),
(2026, "二〇二六"),
(u32::MAX, "四二九四九六七二九五"),
] {
assert_eq!(NumberStyle::Kanji.format(n), s, "{n}");
}
}
#[test]
fn list_labels_expand_metacharacters() {
let p = ParaProps { number_style: NumberStyle::UpperLetters, ..Default::default() };
assert_eq!(p.number_label(2), "B.\t");
let p = ParaProps { number_expression: "Tabel ^#^t".into(), ..Default::default() };
assert_eq!(p.number_label(3), "Tabel 3\t");
assert_eq!(expand_list_text("^2.^#.^>x^^^", "4"), ".4.\u{2002}x^^");
assert_eq!(expand_list_text("a\nb^p", "1"), "ab");
assert_eq!(ParaProps::default().bullet_label(), "\u{2022}\t");
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.