figcraft/crates/text/src/display_tests.rs

use super::*;

/// Every shown char 10 units wide, left to right.
fn edges(v: &VisualLine) -> Vec<(f64, f64)> {
    let chars: Vec<(f64, f64)> = (0..v.text.chars().count()).map(|k| (k as f64 * 10.0, k as f64 * 10.0 + 10.0)).collect();
    v.cluster_edges(&chars)
}

#[test]
fn left_to_right_text_shows_as_is() {
    let v = visual_line("Frame 12");
    assert_eq!(v.text, "Frame 12");
    assert!(!v.rtl_para);
    assert_eq!(v.clusters.len(), 8);
    assert!(!has_rtl("Frame 12"));
    let e = edges(&v);
    assert_eq!(v.caret_x(0, &e), 0.0);
    assert_eq!(v.caret_x(8, &e), 80.0);
    assert_eq!(v.hit(14.0, &e), 1);
    assert_eq!(v.hit(16.0, &e), 2);
    assert_eq!(v.step(3, true, &e), 4);
    assert_eq!(v.step(0, false, &e), 0);
}

#[test]
fn hebrew_runs_right_to_left() {
    let v = visual_line("שלום");
    assert_eq!(v.text, "םולש");
    assert!(v.rtl_para);
    assert!(v.clusters.iter().all(|c| c.rtl));
    // The caret before the first letter is at the right end; the end of the text at the left.
    let e = edges(&v);
    assert_eq!(v.caret_x(0, &e), 40.0);
    assert_eq!(v.caret_x(4, &e), 0.0);
    // Right of the text is its start, left of it its end.
    assert_eq!(v.hit(100.0, &e), 0);
    assert_eq!(v.hit(-5.0, &e), 4);
    // The right arrow goes back towards the start.
    assert_eq!(v.step(2, true, &e), 1);
    assert_eq!(v.step(2, false, &e), 3);
}

#[test]
fn mixed_direction_names_order_and_caret() {
    // A left-to-right name with a Hebrew word.
    let v = visual_line("abc אבג");
    assert_eq!(v.text, "abc גבא");
    assert!(!v.rtl_para);
    let e = edges(&v);
    assert_eq!(v.caret_x(4, &e), 70.0);
    assert_eq!(v.caret_x(7, &e), 40.0);
    // Visual right-arrow order across the runs.
    let mut at = 0;
    let mut seen = vec![at];
    for _ in 0..7 {
        at = v.step(at, true, &e);
        seen.push(at);
    }
    assert_eq!(seen, vec![0, 1, 2, 3, 7, 6, 5, 4]);
    assert_eq!(v.hit(65.0, &e), 4);
    assert_eq!(v.hit(62.0, &e), 5);
    // A selection inside the Hebrew word is one span on screen.
    assert_eq!(v.selection(4, 6, &e), vec![(50.0, 70.0)]);
    // One across the runs is two.
    assert_eq!(v.selection(2, 5, &e), vec![(20.0, 40.0), (60.0, 70.0)]);

    // A right-to-left name with a Latin word: the Latin word keeps its order, at the left.
    let v = visual_line("אב abc");
    assert_eq!(v.text, "abc בא");
    assert!(v.rtl_para);
    let e = edges(&v);
    assert_eq!(v.caret_x(0, &e), 60.0);
    assert_eq!(v.caret_x(3, &e), 0.0);
    assert_eq!(v.caret_x(6, &e), 30.0);
}

#[test]
fn brackets_mirror_in_right_to_left_runs() {
    assert_eq!(visual_line("(שלום)").text, "(םולש)");
    assert_eq!(visual_line("(abc)").text, "(abc)");
}

#[test]
fn arabic_letters_join() {
    // Salam: seen (initial), lam-alef (final ligature), meem (isolated after the alef).
    let v = visual_line("سلام");
    assert_eq!(v.text, "\u{FEE1}\u{FEFC}\u{FEB3}");
    assert_eq!(v.clusters.len(), 3);
    assert_eq!(v.clusters.get(1).map(|c| c.logical.clone()), Some(1..3));
    // The caret between lam and alef sits in the middle of the ligature.
    let e = edges(&v);
    assert_eq!(v.caret_x(2, &e), 15.0);
    // Beh: isolated, initial, medial, final.
    assert_eq!(visual_line("ب").text, "\u{FE8F}");
    assert_eq!(visual_line("ببب").text, "\u{FE90}\u{FE92}\u{FE91}");
    // Marks stay with their letter and don't break joins.
    let v = visual_line("بَب");
    assert_eq!(v.text, "\u{FE90}\u{FE91}\u{064E}");
    assert_eq!(v.clusters.len(), 2);
    // Persian letters too.
    assert_eq!(visual_line("پی").text, "\u{FBFD}\u{FB58}");
}

#[test]
fn bidi_controls_show_nothing() {
    let v = visual_line("\u{200F}abc");
    assert!(!v.text.contains('\u{200F}'));
    assert_eq!(v.len, 4);
    let e = edges(&v);
    // Every logical caret position still has a place.
    for i in 0..=4 {
        assert!(v.caret_x(i, &e).is_finite());
    }
}

#[test]
fn elision_keeps_the_start_and_follows_the_direction() {
    let fits = |v: &VisualLine| v.text.chars().count() <= 5;
    assert_eq!(elide("Frame", fits).text, "Frame");
    assert_eq!(elide("Rectangle 12", fits).text, "Rect…");
    let v = elide("שלום עולם", fits);
    // The ellipsis is at the left of a right-to-left name; its right end (the start) stays.
    assert_eq!(v.text, "…םולש");
    // Nothing fits: just the ellipsis.
    assert_eq!(elide("abcdef", |v: &VisualLine| v.text.chars().count() <= 1).text, "…");
    // A letter is never cut from its marks.
    let v = elide("بَبَبَبَ", |v: &VisualLine| v.text.chars().count() <= 3);
    assert!(v.text.contains('\u{064E}'));
}

#[test]
fn junk_input_never_panics() {
    for s in ["", " ", "\u{0644}", "\u{064E}", "\u{0644}\u{0627}", "a\nב\tc", "\u{202E}\u{2067}x\u{2069}", "ـبـ", "‏‎‏"] {
        let v = visual_line(s);
        let e = edges(&v);
        for i in 0..=v.len + 2 {
            let _ = v.caret_x(i, &e);
            let _ = v.step(i, true, &e);
            let _ = v.step(i, false, &e);
        }
        let _ = v.hit(-1.0, &e);
        let _ = v.hit(1e9, &e);
        let _ = v.selection(0, v.len + 3, &e);
        let _ = elide(s, |t: &VisualLine| t.text.len() < 3);
        // Too few measured edges.
        let _ = v.caret_x(1, &[]);
        let _ = v.cluster_edges(&[]);
    }
}

/// The joined forms are the ones the shaper picks in context (when Noto Sans Arabic is built in).
#[test]
fn presentation_forms_match_the_shaper() {
    let Some(face) = crate::find_face("Noto Sans Arabic", "Regular").filter(|f| f.family == "Noto Sans Arabic") else {
        eprintln!("no Noto Sans Arabic; skipping");
        return;
    };
    let mut wrong = Vec::new();
    for (base, iso, n) in FORMS {
        // Isolated, then (dual-joining) initial, medial and final via tatweels around the letter.
        let mut cases = vec![(base.to_string(), iso as u32)];
        if n >= 2 {
            cases.push((format!("\u{0640}{base}"), iso as u32 + 1));
        }
        if n == 4 {
            cases.push((format!("{base}\u{0640}"), iso as u32 + 2));
            cases.push((format!("\u{0640}{base}\u{0640}"), iso as u32 + 3));
        }
        for (s, form) in cases {
            let form = char::from_u32(form).unwrap();
            assert!(face.has_char(form), "{base:?} form {form:?} missing");
            let mut t = figcraft_doc::TextData::new(s.clone());
            t.style.font_family = "Noto Sans Arabic".into();
            let l = crate::layout(&t, None, None);
            let at = s.chars().position(|c| c == base).unwrap();
            // The font may draw a letter as a skeleton plus dots: compare the cluster's advance.
            let shaped: f64 = l.glyphs.iter().filter(|g| g.char_start <= at && at < g.char_end).map(|g| g.advance).sum();
            // (Kerning and contextual alternates shift it a little: the right form is the nearest.)
            let adv = |c: u32| char::from_u32(c).map_or(f64::NAN, |c| face.advance(face.glyph_for(c)) * t.style.font_size / face.upem);
            let nearest =
                (iso as u32..iso as u32 + u32::from(n)).min_by(|a, b| (adv(*a) - shaped).abs().total_cmp(&(adv(*b) - shaped).abs())).unwrap();
            // Noto draws a lone heh wider than its isolated presentation form (a design choice).
            if (adv(nearest) - adv(form as u32)).abs() > 1e-9 && s != "\u{0647}" {
                wrong.push(format!("{base:?} in {s:?} should show as {form:?} ({shaped} vs {})", adv(form as u32)));
            }
        }
    }
    assert!(wrong.is_empty(), "{wrong:#?}");
}