GitCorner

Code

ossartcraftdesigncraft🌐
88f5a00e389b
use super::*;
use std::collections::HashSet;

/// Every per-language table `tr` looks up, by interface language.
const LANGUAGE_TABLES: &[(&str, &[(&str, &str)])] = &[
    ("ar", ar::TABLE),
    ("cs", cs::TABLE),
    ("de", de::TABLE),
    ("fr", fr::TABLE),
    ("hu", hu::TABLE),
    ("it", it::TABLE),
    ("ja", ja::TABLE),
    ("ka", ka::TABLE),
    ("pl", pl::TABLE),
    ("pt-br", pt_br::TABLE),
    ("ru", ru::TABLE),
    ("sv", sv::TABLE),
    ("uk", uk::TABLE),
];

/// Every per-language table `tr_context` looks up.
const CONTEXT_TABLES: &[(&str, &[(&str, &str, &str)])] = &[
    ("ar", ar::CONTEXT),
    ("cs", cs::CONTEXT),
    ("hu", hu::CONTEXT),
    ("ja", ja::CONTEXT),
    ("pl", pl::CONTEXT),
    ("ru", ru::CONTEXT),
    ("sv", sv::CONTEXT),
    ("uk", uk::CONTEXT),
];

/// The languages of the shared tables' columns, in column order.
const SHARED_COLUMNS: [&str; 5] = ["de", "fr", "es", "ja", "zh"];

/// The German and Japanese tables translate the whole interface and win over the shared columns.
const WHOLE_INTERFACE: [&str; 2] = ["de", "ja"];

/// What `tr` shows for a row: an empty one is still untranslated.
fn or_english<'a>(text: &'a str, english: &'a str) -> &'a str {
    if text.trim().is_empty() { english } else { text }
}

/// Checks cached catalog lookup across language switches, including source-text fallback.
#[test]
fn cached_lookup_preserves_every_translation_across_language_switches() {
    let own = |lang: &str, key: &str| {
        LANGUAGE_TABLES.iter().find(|(code, _)| *code == lang).and_then(|(_, table)| table.iter().find(|(k, _)| *k == key)).map(|(_, text)| *text)
    };
    for (key, translations) in TABLE {
        for (lang, shared) in SHARED_COLUMNS.into_iter().zip(translations) {
            // A language's own table is looked up before the shared column.
            let expected = own(lang, key).filter(|text| !text.trim().is_empty()).unwrap_or(*shared);
            assert_eq!(tr(lang, key), or_english(expected, key), "{lang}: {key}");
        }
        assert_eq!(tr("", key), *key);
    }
    for (lang, table) in LANGUAGE_TABLES {
        for (key, expected) in *table {
            if !expected.trim().is_empty() {
                assert_eq!(tr(lang, key), *expected, "{lang}: {key}");
            }
            assert_eq!(tr("", key), *key);
        }
    }
    // Strings no catalog has stay as they are, in every language.
    let unknown = String::from("A user-defined untranslated label");
    for lang in LANGUAGES.iter().map(|(code, _)| *code).chain(["en", "unknown"]) {
        assert!(std::ptr::eq(tr(lang, &unknown), unknown.as_str()), "{lang}");
        // Fixed standard names stay identical.
        assert_eq!(tr(lang, "PDF/X-4"), "PDF/X-4", "{lang}");
    }
}

/// Checks Hungarian catalog integrity, context captions and count substitutions, including
/// English fallback and preservation of user-defined style and workspace names.
#[test]
fn hungarian_catalog_preserves_placeholders_context_and_counts() {
    let catalog: HashMap<_, _> = hu::TABLE.iter().copied().collect();
    assert_eq!(catalog.len(), hu::TABLE.len(), "duplicate Hungarian keys");
    let placeholders = |s: &str| {
        let mut names: Vec<_> = s.split('{').skip(1).filter_map(|part| part.split_once('}').map(|(name, _)| name.to_owned())).collect();
        names.sort();
        names
    };
    for (key, translation) in hu::TABLE {
        assert!(!translation.trim().is_empty(), "empty {key}");
        assert_eq!(placeholders(key), placeholders(translation), "placeholders: {key}");
        assert_eq!(key.ends_with('…'), translation.ends_with('…'), "ellipsis: {key}");
    }
    assert!(!is_rtl("hu"));
    assert_eq!(tr("hu", "File"), "Fájl");
    assert_eq!(tr("hu", "Bleed"), "Kifutó");
    assert_eq!(tr("hu", "Arrangement"), "Elrendezés");
    assert_eq!(tr("hu", "Unknown label"), "Unknown label");
    assert_eq!(tr("hu", "Columns"), "Hasábok");
    assert_eq!(tr_context("hu", "Columns", "table"), "Oszlopok");
    assert_eq!(tr("hu", "Columns:"), "Hasábok:");
    assert_eq!(tr_context("hu", "Columns:", "grid"), "Oszlopok:");
    assert_eq!(tr_context("hu", "Columns:", "unknown"), "Hasábok:");
    assert_eq!(tr("hu", "Group"), "Csoportosítás");
    assert_eq!(tr_context("hu", "Group", "selection"), "Csoport");
    assert_eq!(tr_context("hu", "Columns", "unknown"), "Hasábok");
    assert_eq!(tr_context("", "Columns", "table"), "Columns");
    for n in [0, 1, 2, 5, 21] {
        assert_eq!(count_label("hu", "pages", n), format!("{n} oldal"));
        assert_eq!(count_label("hu", "objects", n), format!("{n} objektum"));
        assert_eq!(count_label("hu", "errors", n), format!("{n} hiba"));
        assert_eq!(
            tr("hu", "{pages} Pages in {spreads} Spreads").replace("{pages}", &n.to_string()).replace("{spreads}", &n.to_string()),
            format!("{n} oldal, {n} oldalpáron")
        );
    }
    assert_eq!(style_name("hu", "[Basic Paragraph]"), "[Alapbekezdés]");
    assert_eq!(style_name("hu", "Saját stílus"), "Saját stílus");
    assert_eq!(workspace_name("hu", "Essentials"), "Alapok");
    assert_eq!(workspace_name("hu", "Saját munkaterület"), "Saját munkaterület");
}

/// Checks every Latin catalog letter and all Hungarian accented vowels against the
/// configured bundled UI faces, with system and optional craft-fonts fallbacks disabled.
#[test]
fn hungarian_catalog_glyphs_exist_in_the_bundled_ui_fonts() {
    let definitions = crate::theme::font_definitions(&[], "hu");
    let db = designcraft_fonts::FontDb::with_font_dirs(Vec::new());
    db.set_system_fallback(false);
    let letters: std::collections::BTreeSet<_> = hu::TABLE
        .iter()
        .flat_map(|(_, text)| text.chars())
        .chain(hu::CONTEXT.iter().flat_map(|(_, _, text)| text.chars()))
        .chain("ÁáÉéÍíÓóÖöŐőÚúÜüŰű".chars())
        .filter(|c| c.is_alphabetic() && *c <= '\u{024f}')
        .collect();
    for (name, family, style, ui_family) in [
        ("ui", "Source Sans 3", "Regular", egui::FontFamily::Proportional),
        ("ui-semibold", "Source Sans 3", "Semibold", egui::FontFamily::Name("semibold".into())),
        ("mono", "JetBrains Mono", "Regular", egui::FontFamily::Monospace),
    ] {
        assert_eq!(definitions.families[&ui_family].first().map(String::as_str), Some(name));
        let face = db.face(family, style);
        assert_eq!(face.data(), definitions.font_data[name].bytes(), "configured UI face {name}");
        for letter in &letters {
            assert_ne!(face.glyph_for(*letter), 0, "missing {letter} in {family} {style}");
        }
    }
    eprintln!(
        "Hungarian glyph coverage: {} Latin catalog letters, including ŐőŰű, in Source Sans 3 Regular/Semibold and JetBrains Mono Regular; no system/craft fallback",
        letters.len()
    );
    if let Some(dir) = std::env::var_os("DESIGNCRAFT_HU_REVIEW_SHOTS") {
        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(820.0, 260.0)).build_ui_state(
            |ui, ready: &mut bool| {
                if !*ready {
                    ui.ctx().set_fonts(crate::theme::font_definitions(&[], "hu"));
                    *ready = true;
                    return;
                }
                ui.style_mut().visuals = egui::Visuals::light();
                ui.painter().rect_filled(ui.ctx().content_rect(), 0.0, egui::Color32::WHITE);
                ui.heading("Magyar ékezetek · ő, ű / Ő, Ű");
                for (name, family) in [
                    ("Source Sans 3 Regular", egui::FontFamily::Proportional),
                    ("Source Sans 3 Semibold", egui::FontFamily::Name("semibold".into())),
                    ("JetBrains Mono Regular", egui::FontFamily::Monospace),
                ] {
                    ui.label(egui::RichText::new(name).color(egui::Color32::DARK_GRAY));
                    ui.label(
                        egui::RichText::new("Árvíztűrő tükörfúrógép · Őő Űű · ÁÉÍÓÖŐÚÜŰ")
                            .font(egui::FontId::new(22.0, family))
                            .color(egui::Color32::BLACK),
                    );
                }
            },
            false,
        );
        h.run_steps(3);
        h.render().unwrap().save(std::path::Path::new(&dir).join("hungarian-bundled-ui-fonts.png")).unwrap();
        let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
        app.ui.language = "hu".into();
        app.run("file.new", serde_json::json!({"pages": 1})).unwrap();
        app.run(
            "frame.create",
            serde_json::json!({"rect": [60, 60, 420, 180], "content": "text", "text": "Magyar kiadvány
Árvíztűrő tükörfúrógép
Őő Űű · ÁÉÍÓÖŐÚÜŰ"}),
        )
        .unwrap();
        app.run("type.char", serde_json::json!({"attrs": {"fontFamily": "Source Sans 3", "size": 28}})).unwrap();
        app.run("window.panel.activate", serde_json::json!({"panel": "character"})).unwrap();
        let mut interface = crate::test_window::open(app, egui::vec2(1400.0, 900.0));
        interface.render().unwrap().save(std::path::Path::new(&dir).join("designcraft-hungarian-interface.png")).unwrap();
    }
}

/// Checks translated labels and source-text fallback, plus key uniqueness and nonempty rows
/// in the shared, Arabic, Brazilian Portuguese and Italian catalogs.
#[test]
fn translates_known_strings_and_keeps_the_rest() {
    assert_eq!(tr("de", "File"), "Datei");
    assert_eq!(tr("ja", "Swatches"), "スウォッチ");
    assert_eq!(tr("fr", "Something new"), "Something new");
    assert_eq!(tr("", "File"), "File");
    assert_eq!(tr("ar", "File"), "ملف");
    assert_eq!(tr("ar", "Unknown label"), "Unknown label");
    assert_eq!(tr("pt-br", "File"), "Arquivo");
    assert_eq!(tr("pt-br", "New Document…"), "Novo documento…");
    assert_eq!(tr("pt-br", "Unknown label"), "Unknown label");
    assert_eq!(tr("it", "Edit"), "Modifica");
    assert_eq!(tr("it", "New Document…"), "Nuovo documento…");
    assert_eq!(tr("it", "Unknown label"), "Unknown label");
    assert!(is_rtl("ar"));
    for (i, (en, translation)) in ar::TABLE.iter().enumerate() {
        assert!(ar::TABLE[..i].iter().all(|(key, _)| key != en), "duplicate {en}");
        assert!(!translation.is_empty(), "{en}");
    }
    for (i, (en, translation)) in pt_br::TABLE.iter().enumerate() {
        assert!(pt_br::TABLE[..i].iter().all(|(key, _)| key != en), "duplicate {en}");
        assert!(!translation.is_empty(), "{en}");
    }
    for (i, (en, translation)) in it::TABLE.iter().enumerate() {
        assert!(it::TABLE[..i].iter().all(|(key, _)| key != en), "duplicate {en}");
        assert!(!translation.is_empty(), "{en}");
    }
    // Italian entries are for keys the shared or Arabic table knows. A new English string
    // falls back to English until it is translated, so it doesn't fail here.
    for (en, _) in it::TABLE {
        assert!(TABLE.iter().any(|(key, _)| key == en) || ar::TABLE.iter().any(|(key, _)| key == en), "it: unknown key {en}");
    }
    // Every row is unique and complete.
    for (i, (en, t)) in TABLE.iter().enumerate() {
        assert!(TABLE[..i].iter().all(|(e, _)| e != en), "duplicate {en}");
        assert!(t.iter().all(|x| !x.is_empty()), "{en}");
    }
}

/// The Data Merge arrangement combo takes its accessible name from `tr(lang, "Arrangement")`.
/// A row in only the shared table leaves the languages whose lookup returns directly with the
/// English name.
#[test]
fn arrangement_accessible_name_is_localized_in_every_interface_language() {
    for (code, name) in LANGUAGES {
        let label = tr(code, "Arrangement");
        if code.is_empty() {
            assert_eq!(label, "Arrangement", "{name}");
        } else {
            assert_ne!(label, "Arrangement", "{name} still announces the English accessible name");
            assert!(!label.trim().is_empty(), "{name}");
        }
    }
}

/// File › Place Contact Sheet… and its dialog read in every interface language, including those
/// whose own catalog is all `tr` looks in.
#[test]
fn contact_sheet_strings_are_translated_in_every_interface_language() {
    let strings = [
        "Place Contact Sheet…",
        "Place Contact Sheet",
        "Place loaded images on new pages, in file order.",
        "Columns",
        "Rows",
        "Gutter",
        "Page margin",
    ];
    for (code, name) in LANGUAGES.iter().filter(|(code, _)| !code.is_empty()) {
        for s in strings {
            let text = tr(code, s);
            assert!(text != s && !text.trim().is_empty(), "{name}: {s:?} is still English");
        }
    }
    assert_eq!(["Columns", "Rows", "Gutter"].map(|s| tr("es", s)), ["Columnas", "Filas", "Medianil"]);
}

/// The Links panel's captions for a status its background check hasn't found yet, and for when
/// the check can't run.
#[test]
fn links_panel_check_captions_are_localized_in_every_interface_language() {
    for (code, name) in LANGUAGES {
        for key in ["Checking", "Link status is unavailable."] {
            let label = tr(code, key);
            if code.is_empty() {
                assert_eq!(label, key, "{name}");
            } else {
                assert_ne!(label, key, "{name} still shows the English caption");
                assert!(!label.trim().is_empty(), "{name}: {key}");
            }
        }
    }
}

/// Checks language-specific context precedence and fallback to the plain translation.
#[test]
fn duplicate_layer_menu_item_is_localized_in_every_interface_language() {
    let key = "Duplicate Layer \"{name}\"";
    for (code, name) in LANGUAGES {
        let label = tr(code, key);
        if code.is_empty() {
            assert_eq!(label, key, "{name}");
        } else {
            assert_ne!(label, key, "{name} shows the Layers panel's Duplicate Layer item in English");
            assert!(label.contains("{name}"), "{name}");
        }
    }
}

#[test]
fn context_captions_come_from_their_context_or_the_plain_translation() {
    for (lang, table) in CONTEXT_TABLES {
        for (key, scope, text) in *table {
            if !text.trim().is_empty() {
                assert_eq!(tr_context(lang, key, scope), *text, "{lang}: {key} ({scope})");
            }
        }
    }
    for (key, scope, row) in CONTEXT {
        for (lang, shared) in SHARED_COLUMNS.into_iter().zip(row) {
            // A language's own context table is looked up before the shared one.
            let own = CONTEXT_TABLES
                .iter()
                .filter(|(code, _)| *code == lang)
                .flat_map(|(_, table)| table.iter())
                .find(|(k, s, _)| k == key && s == scope)
                .map(|(_, _, text)| *text)
                .filter(|text| !text.trim().is_empty());
            let expected = own.or(Some(*shared).filter(|text| !text.trim().is_empty())).unwrap_or_else(|| tr(lang, key));
            assert_eq!(tr_context(lang, key, scope), expected, "{lang}: {key} ({scope})");
        }
    }
    // An unknown context, or a language without one, keeps the plain translation.
    let keys = CONTEXT.iter().map(|(key, _, _)| *key).chain(CONTEXT_TABLES.iter().flat_map(|(_, table)| table.iter().map(|(key, _, _)| *key)));
    for key in keys {
        for lang in LANGUAGES.iter().map(|(code, _)| *code).chain(["en"]) {
            assert_eq!(tr_context(lang, key, "no such context"), tr(lang, key), "{lang}: {key}");
        }
        assert_eq!(tr_context("", key, "count"), key);
    }
}

/// Keeps quantity labels distinct from numeric values and checks translated Pages-panel captions.
#[test]
fn a_column_count_and_a_list_number_read_differently() {
    for (lang, count, numeral) in [
        ("hu", "Darabszám:", "Szám:"),
        ("de", "Anzahl:", "Zahl:"),
        ("ja", "数:", "番号:"),
        ("uk", "Кількість:", "Номер:"),
        ("ar", "العدد:", "الرقم:"),
        ("fr", "Nombre :", "Numéro:"),
        ("zh", "数量:", "编号:"),
    ] {
        assert_eq!((tr_context(lang, "Number:", "count"), tr(lang, "Number:")), (count, numeral), "{lang}");
    }
    assert_eq!(tr_context("en", "Number:", "count"), "Number:");
    assert_eq!(tr("de", "Gutter:"), "Spaltenabstand:");
    // The Pages panel menu.
    for key in [
        "Insert Pages…",
        "Move Pages…",
        "New Parent…",
        "Override All Parent Page Items",
        "Remove All Local Overrides",
        "Detach All Objects from Parent",
        "Create Alternate Layout…",
        "Allow Selected Spread to Shuffle",
    ] {
        assert_ne!(tr("pt-br", key), key);
    }
    assert_ne!(tr("ar", "Apply Parent to Pages"), "Apply Parent to Pages");
}

/// The tables `tr` reads, as (language, key, translation), context captions included.
fn entries() -> Vec<(&'static str, &'static str, &'static str)> {
    let mut entries: Vec<_> = LANGUAGE_TABLES.iter().flat_map(|(lang, table)| table.iter().map(|(key, text)| (*lang, *key, *text))).collect();
    for (lang, i) in SHARED_COLUMNS.into_iter().zip(0..) {
        entries.extend(TABLE.iter().filter_map(|(key, row)| row.get(i).map(|text| (lang, *key, *text))));
        entries.extend(CONTEXT.iter().filter_map(|(key, _, row)| row.get(i).map(|text| (lang, *key, *text))));
    }
    entries.extend(CONTEXT_TABLES.iter().flat_map(|(lang, table)| table.iter().map(|(key, _, text)| (*lang, *key, *text))));
    entries
}

/// Every catalog has one row per key and keeps the English placeholders. A string a catalog
/// doesn't translate shows in English, so a missing or empty row fails nothing here; the
/// `missing_translations_report` lists them.
#[test]
fn every_catalog_has_unique_keys_and_keeps_placeholders() {
    for (lang, i) in SHARED_COLUMNS.iter().zip(0..) {
        assert_eq!(column(lang), Some(i), "{lang}");
    }
    for (lang, table) in LANGUAGE_TABLES {
        let keys: HashSet<_> = table.iter().map(|(key, _)| *key).collect();
        assert_eq!(keys.len(), table.len(), "{lang}: duplicate keys");
    }
    let shared: HashSet<_> = TABLE.iter().map(|(key, _)| *key).collect();
    assert_eq!(shared.len(), TABLE.len(), "duplicate keys in the shared table");
    let shared_contexts: HashSet<_> = CONTEXT.iter().map(|(key, scope, _)| (*key, *scope)).collect();
    assert_eq!(shared_contexts.len(), CONTEXT.len(), "duplicate keys in the shared context table");
    for (lang, table) in CONTEXT_TABLES {
        let keys: HashSet<_> = table.iter().map(|(key, scope, _)| (*key, *scope)).collect();
        assert_eq!(keys.len(), table.len(), "{lang}: duplicate context keys");
    }
    // A per-language table is looked up before the shared table, so a key in both hides the
    // shared column, except in the tables that translate the whole interface.
    for (lang, table) in LANGUAGE_TABLES.iter().filter(|(lang, _)| column(lang).is_some() && !WHOLE_INTERFACE.contains(lang)) {
        let both: Vec<_> = table.iter().map(|(key, _)| *key).filter(|key| shared.contains(key)).collect();
        assert!(both.is_empty(), "{lang} keys also in the shared table: {both:?}");
    }

    let placeholders = |s: &'static str| {
        let mut names: Vec<_> = s.split('{').skip(1).filter_map(|part| part.split_once('}').map(|(name, _)| name)).collect();
        names.sort_unstable();
        names
    };
    for (lang, key, text) in entries().into_iter().filter(|(_, _, text)| !text.trim().is_empty()) {
        assert_eq!(placeholders(key), placeholders(text), "{lang}: placeholders of {key:?}");
    }
}

/// The strings each interface language shows in English, for the `cargo xtask ci` log. It
/// always passes: `cargo xtask i18n-report` runs it.
#[test]
#[ignore = "a report, run by `cargo xtask i18n-report`"]
fn missing_translations_report() {
    let interface = interface_strings();
    let catalogs: Vec<(&str, HashSet<&str>)> = LANGUAGE_TABLES
        .iter()
        .map(|(lang, table)| (*lang, table.iter().map(|(key, _)| *key).collect()))
        .chain([("shared", TABLE.iter().map(|(key, _)| *key).collect())])
        .collect();
    let mut keys: Vec<&str> = interface.iter().copied().chain(catalogs.iter().flat_map(|(_, keys)| keys.iter().copied())).collect();
    keys.sort_unstable();
    keys.dedup();
    // `tr` hands back the string it was given when it has no translation.
    let missing = |lang: &str| -> Vec<&str> {
        keys.iter()
            .copied()
            .filter(|key| {
                let english = (*key).to_owned();
                std::ptr::eq(tr(lang, &english), english.as_str())
            })
            .collect()
    };
    let report: Vec<(&str, Vec<&str>)> = LANGUAGES.iter().filter(|(code, _)| !code.is_empty()).map(|(code, _)| (*code, missing(code))).collect();
    println!("i18n report: {} interface strings; a missing translation shows in English.", keys.len());
    for (lang, missing) in &report {
        println!("  {lang:<6} {:>5} missing", missing.len());
    }
    for (lang, missing) in report.iter().filter(|(_, missing)| !missing.is_empty()) {
        println!("{lang} ({}): {}", missing.len(), missing.iter().map(|key| format!("{key:?}")).collect::<Vec<_>>().join(", "));
    }
    // A catalog key neither the interface list nor another catalog knows is stale, or a label
    // `interface_strings` doesn't list yet.
    for (name, own) in &catalogs {
        let mut unknown: Vec<_> = own
            .iter()
            .filter(|key| !interface.contains(*key) && !catalogs.iter().any(|(other, keys)| other != name && keys.contains(*key)))
            .collect();
        unknown.sort_unstable();
        if !unknown.is_empty() {
            println!("{name}: {} rows for keys the interface list doesn't have: {unknown:?}", unknown.len());
        }
    }
}

#[test]
fn only_arabic_lays_out_right_to_left() {
    for (code, _) in LANGUAGES {
        assert_eq!(is_rtl(code), *code == "ar", "{code}");
    }
}

/// Built-in style and workspace names follow the interface language; names people give their
/// own styles and workspaces are document data and stay as typed.
#[test]
fn only_built_in_style_and_workspace_names_are_translated() {
    for (code, _) in LANGUAGES {
        for name in [designcraft_doc::NO_PARA_STYLE, designcraft_doc::BASIC_PARAGRAPH, designcraft_doc::NO_CHAR_STYLE] {
            assert_eq!(style_name(code, name), tr(code, name), "{code}");
        }
        assert_eq!(workspace_name(code, "Essentials"), tr(code, "Essentials"), "{code}");
        for custom in ["Group", "Columns", "My layout style"] {
            assert_eq!(style_name(code, custom), custom, "{code}");
            assert_eq!(workspace_name(code, custom), custom, "{code}");
        }
    }
}

/// Languages with several plural forms put the category first, so every number reads the same.
#[test]
fn category_first_counts_put_the_category_before_every_number() {
    assert!(!category_first("de") && !category_first(""));
    for lang in ["ka", "uk", "ru", "pl"] {
        assert!(category_first(lang), "{lang}");
        for noun in ["pages", "objects", "errors"] {
            for n in [0, 1, 2, 4, 5, 11, 12, 21, 22, 25, 101, 111] {
                assert_eq!(count_label(lang, noun, n), format!("{}: {n}", tr(lang, noun)), "{lang}: {noun}");
            }
        }
    }
    assert_eq!(count_label("", "objects", 2), "2 objects");
}

/// Every English string the interface passes to `tr`, as far as the command and tool tables and
/// the list of UI-only labels know them.
fn interface_strings() -> HashSet<&'static str> {
    let mut keys = HashSet::new();
    // Command labels and menu names reach `tr` from the engine and the UI command table.
    for spec in designcraft_engine::command_specs() {
        keys.insert(spec.label);
        keys.extend(spec.menu.iter().copied());
    }
    keys.extend(crate::menus::UI_COMMANDS.iter().map(|(_, label, _, _)| *label));
    // Tool names reach `tr` from the Tools panel.
    keys.extend(designcraft_tools::TOOL_GROUPS.iter().flat_map(|group| group.iter()).map(|tool| tool.label));
    // So do the About window's tab names, app descriptions and the credits' column and sort labels.
    keys.extend(crate::about::ABOUT_TABS);
    keys.extend(crate::about::SIBLINGS.iter().map(|(_, _, what)| *what));
    keys.extend(crate::credits::NameMode::ALL.iter().map(|mode| mode.label()));
    keys.extend(crate::credits::SortKey::ALL.iter().flat_map(|key| [key.label().0, key.label().1]));
    // Docking chrome labels reach `tr` through craft-ui's localizer.
    keys.extend(crate::panel_docking::DOCK_LABELS.iter().map(|(_, english)| *english));
    // File › New's Units list passes each unit's name to `tr`.
    keys.extend(crate::new_document::NEW_DOCUMENT_UNITS.map(|unit| unit.label()));
    // UI labels passed to `tr` that no other catalog has yet.
    keys.extend([
        "Auto-Sizing",
        "Color Theme",
        "Imported {count} shortcuts from “{set}”; {unmatched} items not matched, {unreadable} unreadable.",
        "Minimum Height",
        "Minimum Width",
        "No Line Breaks",
        "Reference Point",
        "This document uses unavailable fonts. Choose replacements, or select Done to continue with fallback fonts.",
        "180°",
        "Create Links When Placing Text Files",
        "Delete Character Style…",
        "Delete Paragraph Style…",
        "Delete the character style \"{name}\"?",
        "Delete the paragraph style \"{name}\"?",
        "IT",
        "Replace with:",
        "Show the Typography panel",
        "Stroke Behind Fill",
        "Stylistic Set",
        "The selected fonts have no OpenType features.",
        "This story was edited in the layout: you'll be asked before those edits are replaced",
        "This style is in use. Text using it will be reassigned to:",
        "VA",
        "Y:",
        "“{}” has been edited in this layout. Updating replaces those edits with the text from the file.",
        "(any)",
        "(unchanged)",
        "[No Language]",
        "Cell Number:",
        "Differs from this document",
        "Digits:",
        "Change fill to:",
        "Chinese: Simplified",
        "Chinese: Traditional",
        "Don't Save",
        "Email Address:",
        "Email:",
        "Find fill:",
        "H:",
        "Message:",
        "Organization:",
        "Phone:",
        "W:",
        "Subject:",
        "Text:",
        "Unsaved Changes",
        "“{}” has changes that are not saved. Save them before closing?",
        "% of all commits",
        "{count} conflict(s): {names}",
        "{count} match(es)",
        "{count} replacement(s) made",
        "{contributors} contributors · {commits} commits",
        "{label}: {name} (double-click: Color Picker)",
        "All",
        "Align To",
        "Arrangement",
        "Auto Rename",
        "Character Style",
        "Company",
        "DesignCraft page",
        "Equal fixed heights for the selected rows; cell text may become overset.",
        "Found",
        "Grab bag",
        "Include Inside Edges",
        "Key Object",
        "Load Styles",
        "layer",
        "layers",
        "Lines +/−",
        "New Cell Style",
        "New Table Style",
        "No contributor data was built into this copy.",
        "No matches",
        "No model credits were built into this copy.",
        "Object Style",
        "Paragraph Style",
        "PDF/X-1a:2003",
        "Press keys…",
        "Range:",
        "Redefine Document Style",
        "Report an issue",
        "Reverse the order",
        "Sort Entries in Alphabetical Order",
        "Story {story} ← story {parent}",
        "Story Editor — {count} words",
        "Text Anchor",
        "Transparency Flattener",
        "Use Document Style Definition",
        // Status-bar messages.
        "Alternate layout",
        "Couldn't write recovery data: {error}",
        "Export a PDF, IDML or package to share — no cloud account needed.",
        "Import cancelled: the originating document has closed",
        "Invalid panel layout; restored the default dock",
        "PDF import cancelled: the originating document has closed",
        "Packaged {count} files into {dir}",
        "Relinked {count}",
        "Sent {count} page(s) to {printer}",
        "the default printer",
        "{name}: import cancelled while a dialog is open; choose the file again",
        "{name}: {count} step(s) done",
    ]);
    // The Keyboard Shortcuts dialog's strings (craft-keymap) reach `tr` too.
    keys.extend(crate::shortcuts_dialog::strings());
    keys
}

#[test]
fn czech_counts_use_the_plural_form_for_the_number() {
    for (noun, [one, few, other]) in cs::PLURALS {
        for (n, form) in [(0, other), (1, one), (2, few), (4, few), (5, other), (11, other), (22, other)] {
            let expected = if form.trim().is_empty() { format!("{n} {}", tr("cs", noun)) } else { format!("{n} {form}") };
            assert_eq!(count_label("cs", noun, n), expected, "{noun}");
        }
    }
    // A noun without plural forms keeps the plain translation.
    assert_eq!(count_label("cs", "a new noun", 3), "3 a new noun");
}