Files
pdfcraft/crates/engine/tests/form_date_language.rs
T
chamber074 79b76e609b fix(forms): draw field text the field font cannot hold from the bundled face instead of ?
Fixes #3913 (also reported as #6822, closed as its duplicate).

## What was wrong

The field value was never lost: `/V` is stored losslessly as UTF-16BE, and PdfCraft sets `/NeedAppearances`, which is why other viewers show the Greek correctly. The `?` is only in the appearance PdfCraft draws itself: when the field's `/DR` font can't encode the text, `field_appearance_fit` falls back to Helvetica/WinAnsi, and every character outside WinAnsi is drawn as `?` (and reported through the "This field's font can't draw…" notice).

## The fix

At that fallback decision, characters that neither the field's font nor Helvetica holds but the bundled Inter face does (Latin, Greek, Cyrillic) are now drawn as Type 3 glyphs built from Inter — the same mechanism Thai text already uses in field appearances. Characters no available face holds (e.g. CJK in a Helvetica field) are still drawn as `?` and reported, exactly as before. Text the field's font holds is byte-for-byte unchanged, and no font resource is added in that case.

## Behaviour change to be aware of

Date names in Russian, Czech, Greek, etc. in Helvetica fields (#5303) are now drawn in the date language rather than falling back to English — the "a font that holds them keeps them" rule applied to the bundled face. Japanese still falls back to English. Push-button captions are unchanged (still `?`); same mechanism, possible follow-up.

## Tests

- New forms test `greek_a_field_font_cannot_hold_is_drawn_from_the_bundled_face`: Greek, mixed Latin+Greek (multiline), and exact-WinAnsi strings in a `/Helv` field; asserts the `/V` bytes, no `?` in the appearance, a `PCLa` Type 3 font with ToUnicode, and no undrawn report; a CJK character is still reported. It fails on unmodified code and passes with this change.
- New fonts unit test for splitting a line between the standard font and Inter.
- Updated the engine signature test and the #5303 `form_date_language` tests where they pinned the old `?` behaviour.

Verified locally: `cargo test` for fonts, forms, edit and engine — 1,813 passed, 0 failed; `cargo fmt --check` clean; clippy clean on the touched crates.

*Disclosure: this change was drafted with AI assistance (Claude) under my direction; the diff was reviewed and the verification above was run before opening this PR.*
2026-11-18 16:37:14 +07:00

470 lines
22 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Form date fields name months in the app's date language (#5303). Its own test binary: the
//! names are process-wide, so other tests must not see them change, and its tests take turns.
use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
use pdfcraft_cos::{Document, Object};
use pdfcraft_engine::dates::use_form_date_language;
use pdfcraft_engine::js::JsRunner;
use pdfcraft_forms::FieldValue;
use pdfcraft_forms::af::{DateTime, Format, format_date, format_value, keystroke, parse_date};
use pdfcraft_js::{DocInfo, Event, Limits, run};
/// Held by each test while it changes the process-wide date names, which start as English (a
/// failed test may have left others).
fn names_lock() -> MutexGuard<'static, ()> {
static LOCK: Mutex<()> = Mutex::new(());
let lock = LOCK.lock().unwrap_or_else(PoisonError::into_inner);
use_form_date_language("en");
lock
}
/// `util.printd(fmt)` of 18 October 2026, then of what `util.scand(fmt, typed)` reads.
fn printd(fmt: &str, typed: &str) -> String {
let doc = DocInfo { file_name: "form.pdf".into(), num_pages: 1, page: 0, ..Default::default() };
let script = format!("event.value = util.printd('{fmt}', new Date(2026, 9, 18)) + '|' + util.printd('{fmt}', util.scand('{fmt}', '{typed}'));");
let o = run(&script, &Event::field("Format", "date", ""), &doc, &[], &[], Limits::default());
assert_eq!(o.error, None);
o.value
}
#[test]
fn form_dates_follow_the_date_language() {
let _names = names_lock();
let oct18 = DateTime { y: 2026, m: 10, d: 18, hh: 0, mm: 0, ss: 0 };
let dd_mmm_yy = Format::Date("dd-mmm-yy".into());
// English until the app says otherwise.
assert_eq!(format_date(oct18, "dd-mmm-yy dddd ddd mmmm"), "18-Oct-26 Sunday Sun October");
use_form_date_language("it");
// AFDate_FormatEx("dd-mmm-yy"), what the issue's form used.
assert_eq!(format_value(&dd_mmm_yy, "18-10-26"), "18-ott-26");
assert_eq!(format_date(oct18, "dddd d mmmm yyyy, ddd"), "domenica 18 ottobre 2026, dom");
// What it writes reads back, and so does English typing.
assert_eq!(parse_date("18-ott-26", "dd-mmm-yy"), Some(oct18));
assert_eq!(parse_date("18 ottobre 2026", "dd mmmm yyyy"), Some(oct18));
assert_eq!(parse_date("18-Oct-26", "dd-mmm-yy"), Some(oct18));
assert!(keystroke(&dd_mmm_yy, "date", "18-ott-26").is_ok());
// util.printd writes Italian names; util.scand reads them.
assert_eq!(printd("dd-mmm-yy", "18-ott-26"), "18-ott-26|18-ott-26");
assert_eq!(printd("dd-mmm-yy", "18-Oct-26"), "18-ott-26|18-ott-26", "English typing reads too");
assert_eq!(printd("dddd d mmmm yyyy", "domenica 18 ottobre 2026"), "domenica 18 ottobre 2026|domenica 18 ottobre 2026");
// German short names end in a dot; they are written and read whole.
use_form_date_language("de");
assert_eq!(format_value(&dd_mmm_yy, "18-10-26"), "18-Okt.-26");
assert_eq!(parse_date("18-Okt.-26", "dd-mmm-yy"), Some(oct18));
// An unknown language is English again.
use_form_date_language("xx");
assert_eq!(format_value(&dd_mmm_yy, "18-10-26"), "18-Oct-26");
assert_eq!(printd("dd-mmm-yy", "18-Oct-26"), "18-Oct-26|18-Oct-26");
every_date_language_reads_back_what_it_writes();
// Hostile typing never panics and stays quick: long, odd and mixed-script text.
use_form_date_language("th");
let junk = ["", " ", "ม.", "ม.ค.ม.ค.ม.ค.", "\u{0}", "1月1月1月", "tháng tháng", "Ottobre", "🙂ott🙂", "İstanbul ott 26"];
for t in junk.iter().map(|s| s.to_string()).chain(["ม.ค.1".repeat(5000), "9".repeat(100_000)]) {
let started = std::time::Instant::now();
let _ = parse_date(&t, "dd-mmm-yy");
let _ = keystroke(&dd_mmm_yy, "date", &t);
assert!(started.elapsed() < std::time::Duration::from_secs(2), "{} chars took {:?}", t.len(), started.elapsed());
}
use_form_date_language("en");
}
/// An English weekday typed before the month fills the format's weekday, so a month name that
/// the date language shares with a weekday (Italian, Spanish, Romanian and Albanian "mar") is
/// still read as the month: "Tue 17 Mar 2026" read as "Tue 17 Tuesday 2026" (#5303).
#[test]
fn an_english_weekday_before_a_shared_month_name_reads_as_english() {
let _names = names_lock();
let doc = DocInfo { file_name: "form.pdf".into(), num_pages: 1, page: 0, ..Default::default() };
let mar17 = DateTime { y: 2026, m: 3, d: 17, hh: 0, mm: 0, ss: 0 };
let mut bad = Vec::new();
for language in ["it", "es", "ro", "sq"] {
use_form_date_language(language);
let ddd_d_mmm = "ddd d mmm yyyy";
let typed = [
// What the language writes, then English, then English and localized mixed.
(ddd_d_mmm, format_date(mar17, ddd_d_mmm)),
(ddd_d_mmm, "Tue 17 Mar 2026".into()),
(ddd_d_mmm, "Tuesday 17 Mar 2026".into()),
(ddd_d_mmm, "tue 17 mar 2026".into()),
(ddd_d_mmm, format!("Tue 17 {}", format_date(mar17, "mmm yyyy"))),
(ddd_d_mmm, format!("{} 17 Mar 2026", format_date(mar17, "ddd"))),
("mmm d yyyy ddd", "Mar 17 2026 Tue".into()),
("dddd d mmmm yyyy", "Tuesday 17 March 2026".into()),
];
for (fmt, text) in typed {
if parse_date(&text, fmt) != Some(mar17) {
bad.push(format!("{language} forms {fmt}: {text:?} -> {:?}", parse_date(&text, fmt)));
}
let script = format!("var d = util.scand('{fmt}', {text:?}); event.value = d ? util.printd('yyyy-mm-dd', d) : 'null';");
let o = run(&script, &Event::field("Format", "date", ""), &doc, &[], &[], Limits::default());
if o.value != "2026-03-17" {
bad.push(format!("{language} scand {fmt}: {text:?} -> {:?} {:?}", o.value, o.error));
}
}
}
use_form_date_language("en");
assert!(bad.is_empty(), "{}", bad.join("; "));
}
/// Every date language: what a date field writes reads back as the same date, for each date
/// letter that writes a name, through the form path and through `util.scand`. Called from the
/// one test, which owns the process-wide names.
fn every_date_language_reads_back_what_it_writes() {
let doc = DocInfo { file_name: "form.pdf".into(), num_pages: 1, page: 0, ..Default::default() };
let mut bad = Vec::new();
for l in pdfcraft_engine::dates::DATE_LANGUAGES.iter() {
use_form_date_language(l.code);
for m in 1..=12u32 {
let dt = DateTime { y: 2026, m, d: 18, hh: 0, mm: 0, ss: 0 };
for fmt in ["dd-mmm-yy", "d mmmm yyyy", "dddd, mmmm d, yyyy", "ddd d mmm yyyy", "mmm d, yyyy ddd", "yyyymmmdd"] {
let text = format_date(dt, fmt);
// A short month ending in a number ("Thg 1") glued to the day is ambiguous
// ("Thg 118": January 18 or November 8): nothing can read it back.
if fmt == "yyyymmmdd" && l.months_short.iter().any(|n| n.ends_with(|c: char| c.is_ascii_digit())) {
continue;
}
if parse_date(&text, fmt).map(|p| (p.y, p.m, p.d)) != Some((2026, m, 18)) {
bad.push(format!("{} forms {fmt}: {text:?}", l.code));
}
let script = format!("var d = util.scand('{fmt}', {text:?}); event.value = d ? util.printd('yyyy-mm-dd', d) : 'null';");
let o = run(&script, &Event::field("Format", "date", ""), &doc, &[], &[], Limits::default());
if o.value != format!("2026-{m:02}-18") {
bad.push(format!("{} scand {fmt}: {text:?} -> {:?} {:?}", l.code, o.value, o.error));
}
}
}
}
use_form_date_language("en");
assert!(bad.is_empty(), "{} failures:\n{}", bad.len(), bad.iter().take(40).cloned().collect::<Vec<_>>().join("\n"));
}
/// A form whose text fields are each `(name, font, format script)`: `/Helv` is Helvetica with
/// WinAnsi, `/Song` a Chinese font with a Unicode CMap, which also holds Cyrillic.
fn form(fields: &[(&str, &str, &str)]) -> Document {
let n = fields.len();
let first = 6;
let refs = |from: usize| (from..from + n).map(|i| format!("{i} 0 R")).collect::<Vec<_>>().join(" ");
let mut objs: Vec<String> = vec![
"<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),
"<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
format!("<< /Type /Page /Parent 2 0 R /Annots [{}] >>", refs(first)),
format!("<< /Fields [{}] /DA (/Helv 0 Tf 0 g) /DR << /Font << /Helv 5 0 R /Song {} 0 R >> >> >>", refs(first), first + n),
"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>".into(),
];
for (i, (name, font, js)) in fields.iter().enumerate() {
let js = js.replace('\\', "\\\\").replace('(', "\\(").replace(')', "\\)");
let y = 700 - 30 * i;
objs.push(format!(
"<< /Type /Annot /Subtype /Widget /FT /Tx /T ({name}) /DA (/{font} 10 Tf 0 g) /Rect [50 {y} 300 {}] /P 3 0 R /AA << /F << /S /JavaScript /JS ({js}) >> >> >>",
y + 20
));
}
objs.push("<< /Type /Font /Subtype /Type0 /BaseFont /STSong-Light /Encoding /UniGB-UCS2-H /DescendantFonts [<< /Type /Font /Subtype /CIDFontType0 /BaseFont /STSong-Light /CIDSystemInfo << /Registry (Adobe) /Ordering (GB1) /Supplement 4 >> >>] >>".into());
let mut out = b"%PDF-1.7
"
.to_vec();
let mut offsets = Vec::new();
for (i, o) in objs.iter().enumerate() {
offsets.push(out.len());
out.extend_from_slice(
format!(
"{} 0 obj
{o}
endobj
",
i + 1
)
.as_bytes(),
);
}
let xref = out.len();
out.extend_from_slice(
format!(
"xref
0 {}
0000000000 65535 f
",
objs.len() + 1
)
.as_bytes(),
);
for o in offsets {
out.extend_from_slice(
format!(
"{o:010} 00000 n
"
)
.as_bytes(),
);
}
out.extend_from_slice(
format!(
"trailer
<< /Size {} /Root 1 0 R >>
startxref
{xref}
%%EOF
",
objs.len() + 1
)
.as_bytes(),
);
Document::open(Arc::new(out)).expect("opens")
}
/// The content of field `name`'s normal appearance.
fn appearance(doc: &Document, name: &str) -> Vec<u8> {
let all = pdfcraft_forms::fields(doc);
let f = all.iter().find(|f| f.name == name).expect("field");
let widget = doc.get(f.widgets[0].obj);
let normal = widget.as_dict().and_then(|d| d.get(b"AP")).and_then(|a| doc.resolve(a).as_dict().and_then(|a| a.reference(b"N"))).expect("/AP /N");
match &*doc.get(normal) {
Object::Stream(s) => s.decoded().expect("decodes"),
other => panic!("not a stream: {other:?}"),
}
}
/// What a Unicode-CMap (UCS-2) font is given for `text`.
fn ucs2(text: &str) -> Vec<u8> {
text.encode_utf16().flat_map(u16::to_be_bytes).collect()
}
fn contains(hay: &[u8], needle: &[u8]) -> bool {
hay.windows(needle.len()).any(|w| w == needle)
}
/// Fills `form`'s field `name` with 18 October 2026 through the JavaScript runner.
fn fill(doc: &mut Document, name: &str) {
fill_with(doc, name, "18-10-26");
}
/// Fills `form`'s field `name` with `value` through the JavaScript runner.
fn fill_with(doc: &mut Document, name: &str, value: &str) {
let mut js = JsRunner::new(doc, "form.pdf", false);
pdfcraft_forms::set_value_with(doc, name, &FieldValue::Text(value.into()), &mut js).expect("fills");
}
/// Month names in the date language that no font of the field can draw are drawn in English,
/// never as `?` ("18-??-26" in Japanese); a font that holds them keeps them (#5303). Russian,
/// Czech and Greek names keep theirs in a Helvetica field too: the bundled Inter face draws the
/// letters Helvetica lacks (#6822).
#[test]
fn date_names_no_field_font_can_draw_are_drawn_in_english() {
let _names = names_lock();
let date = "AFDate_FormatEx(\"dd-mmm-yy\");";
let fields = [("helv", "Helv", date), ("song", "Song", date)];
for (language, local) in [("ru", "окт."), ("cs", "říj"), ("ja", "10月"), ("el", "Οκτ")] {
use_form_date_language(language);
let mut doc = form(&fields);
fill(&mut doc, "helv");
fill(&mut doc, "song");
let helv = appearance(&doc, "helv");
if language == "ja" {
assert!(contains(&helv, b"(18-Oct-26) Tj"), "{language}: {}", String::from_utf8_lossy(&helv));
} else {
assert!(contains(&helv, b"(18-) Tj") && contains(&helv, b"/PCLa"), "{language}: {}", String::from_utf8_lossy(&helv));
assert!(!contains(&helv, b"Oct"), "{language} keeps its name: {}", String::from_utf8_lossy(&helv));
}
assert!(!helv.contains(&b'?'), "{language}: {}", String::from_utf8_lossy(&helv));
assert!(pdfcraft_forms::undrawn_fields(&doc).is_empty(), "{language}");
let song = appearance(&doc, "song");
assert!(contains(&song, &ucs2(&format!("18-{local}-26"))), "{language} keeps its name: {song:?}");
}
// Names Helvetica holds are kept: Italian "ott".
use_form_date_language("it");
let mut doc = form(&fields);
fill(&mut doc, "helv");
assert!(contains(&appearance(&doc, "helv"), b"(18-ott-26) Tj"));
use_form_date_language("en");
}
/// A Format script's `util.printd` is run again with English names for a field whose fonts
/// can't draw the date language's, and kept where they can (#5303).
#[test]
fn format_scripts_print_dates_in_english_where_the_field_cannot_draw_them() {
let _names = names_lock();
let script = "event.value = event.value ? util.printd(\"dd-mmm-yy\", util.scand(\"dd-mm-yy\", event.value)) + \" !\" : \"\";";
let fields = [("helv", "Helv", script), ("song", "Song", script)];
// Japanese: no font of a Helvetica field draws 月, the bundled Inter face included.
use_form_date_language("ja");
let mut doc = form(&fields);
fill(&mut doc, "helv");
fill(&mut doc, "song");
let helv = appearance(&doc, "helv");
assert!(contains(&helv, b"(18-Oct-26 !) Tj"), "{}", String::from_utf8_lossy(&helv));
assert!(!helv.contains(&b'?'), "{}", String::from_utf8_lossy(&helv));
assert!(pdfcraft_forms::undrawn_fields(&doc).is_empty());
assert!(contains(&appearance(&doc, "song"), &ucs2("18-10月-26 !")));
// A script whose text has no English either keeps it, reported as undrawn.
let greeting = [("hi", "Helv", "event.value = \"你好 \" + util.printd(\"mmm\", new Date(2026, 9, 18));")];
let mut doc = form(&greeting);
fill(&mut doc, "hi");
assert_eq!(pdfcraft_forms::undrawn_fields(&doc), [("hi".to_string(), '你')]);
// The English run is the appearance's alone: scripts go on printing the date language.
assert_eq!(printd("dd-mmm-yy", "18-10月-26"), "18-10月-26|18-10月-26");
// Russian names a Helvetica field draws from the bundled face need no English run (#6822).
use_form_date_language("ru");
let mut doc = form(&fields);
fill(&mut doc, "helv");
let helv = appearance(&doc, "helv");
assert!(contains(&helv, b"(18-) Tj") && contains(&helv, b"/PCLa") && !contains(&helv, b"Oct"), "{}", String::from_utf8_lossy(&helv));
assert!(pdfcraft_forms::undrawn_fields(&doc).is_empty());
use_form_date_language("en");
}
/// A Format script's English run is kept when it ran, even where it prints the stored value
/// again: a Helvetica field storing "18-Oct-26", printed again as `dd-mmm-yy`, showed
/// "18-????.-26" in Russian. A script that fails keeps what it showed, reported undrawn (#5303).
#[test]
fn an_english_run_that_prints_the_stored_value_is_drawn() {
let _names = names_lock();
let script = "event.value = util.printd(\"dd-mmm-yy\", util.scand(\"dd-mmm-yy\", event.value));";
// Japanese, whose 月 no font of a Helvetica field draws (#6822 draws Russian there).
use_form_date_language("ja");
let mut doc = form(&[("helv", "Helv", script), ("fails", "Helv", "throw new Error(\"no\");")]);
fill_with(&mut doc, "helv", "18-Oct-26");
let helv = appearance(&doc, "helv");
assert!(contains(&helv, b"(18-Oct-26) Tj"), "{}", String::from_utf8_lossy(&helv));
assert!(!helv.contains(&b'?'), "{}", String::from_utf8_lossy(&helv));
assert!(pdfcraft_forms::undrawn_fields(&doc).is_empty());
fill_with(&mut doc, "fails", "18-10月-26");
assert_eq!(pdfcraft_forms::undrawn_fields(&doc), [("fails".to_string(), '月')]);
use_form_date_language("en");
}
/// What `util.scand(fmt, text)` reads, as `yyyy-mm-dd`, or `null`.
fn scanned(fmt: &str, text: &str) -> String {
let doc = DocInfo { file_name: "form.pdf".into(), num_pages: 1, page: 0, ..Default::default() };
let script = format!("var d = util.scand('{fmt}', {text:?}); event.value = d ? util.printd('yyyy-mm-dd', d) : 'null';");
let o = run(&script, &Event::field("Format", "date", ""), &doc, &[], &[], Limits::default());
assert_eq!(o.error, None);
o.value
}
/// A short weekday typed without its dot ("mar" for French "mar.", Tuesday) is the weekday where
/// the format has one, not the English "Mar" (March) that is the only other name of its length:
/// "mar 6 janv 2026" read as no date in French and Romanian (#5303).
#[test]
fn a_short_weekday_typed_without_its_dot_is_the_weekday() {
let _names = names_lock();
let mut bad = Vec::new();
let cases = [
("fr", "ddd d mmm yyyy", "Mar 6 janv 2026", "2026-01-06"),
("fr", "ddd d mmm yyyy", "mar 17 mars 2026", "2026-03-17"),
("fr", "mmm d yyyy ddd", "janv 6 2026 mar", "2026-01-06"),
("fr", "ddd dd/mm/yyyy", "mar 06/01/2026", "2026-01-06"),
("ro", "ddd d mmm yyyy", "mar 6 ian 2026", "2026-01-06"),
("ro", "ddd dd/mm/yyyy", "mar 06/01/2026", "2026-01-06"),
];
for (language, fmt, text, want) in cases {
use_form_date_language(language);
let got = scanned(fmt, text);
if got != want {
bad.push(format!("{language} scand {fmt}: {text:?} -> {got}"));
}
let read = parse_date(text, fmt).map(|d| format!("{:04}-{:02}-{:02}", d.y, d.m, d.d));
if read.as_deref() != Some(want) {
bad.push(format!("{language} forms {fmt}: {text:?} -> {read:?}"));
}
}
use_form_date_language("en");
assert!(bad.is_empty(), "{}", bad.join("; "));
}
/// A weekday left out of a format with one ("17 mar 2026" for "ddd d mmm yyyy") lets a name the
/// date language shares between a weekday and a month be the month: Italian, Spanish and
/// Albanian "mar" (Tuesday, March) and Albanian "sht" (Saturday, September) were read as the
/// weekday, leaving no month (#5303). Typed weekdays still go first.
#[test]
fn a_shared_name_is_the_month_when_the_weekday_is_left_out() {
let _names = names_lock();
let mut bad = Vec::new();
let cases = [
("it", "ddd d mmm yyyy", "17 Mar 2026", (2026, 3, 17)),
("es", "ddd d mmm yyyy", "17 Mar 2026", (2026, 3, 17)),
("sq", "ddd d mmm yyyy", "17 Mar 2026", (2026, 3, 17)),
("it", "ddd d mmm yyyy", "17 mar 2026", (2026, 3, 17)),
("it", "dddd, mmmm d, yyyy", "mar 17, 2026", (2026, 3, 17)),
("it", "dddd, mmm d, yyyy", "mar 17 2026", (2026, 3, 17)),
("sq", "ddd d mmm yyyy", "5 sht 2026", (2026, 9, 5)),
("it", "ddd d mmm yyyy", "mar 17 Mar 2026", (2026, 3, 17)),
("it", "ddd d mmm yyyy", "mar 17 mar 2026", (2026, 3, 17)),
];
for (language, fmt, text, want) in cases {
use_form_date_language(language);
let read = parse_date(text, fmt).map(|d| (d.y, d.m, d.d));
if read != Some(want) {
bad.push(format!("{language} forms {fmt}: {text:?} -> {read:?}"));
}
if keystroke(&Format::Date(fmt.into()), "date", text).is_err() {
bad.push(format!("{language} keystroke {fmt}: {text:?} refused"));
}
}
use_form_date_language("en");
assert!(bad.is_empty(), "{}", bad.join("; "));
}
/// Turkish names typed in capitals are read: lower-casing letter by letter made "MAYIS" "mayis"
/// (not "mayıs"), "SALI" "sali" and "EKİM" "eki̇m" (an i with a dot above), so no name matched.
/// Dotted, dotless and capital i are one letter when names are read (#5303).
#[test]
fn turkish_names_typed_in_capitals_are_read() {
let _names = names_lock();
use_form_date_language("tr");
let mut bad = Vec::new();
for (fmt, text, want) in [
("d mmmm yyyy", "1 MAYIS 2026", (2026, 5, 1)),
("d mmmm yyyy", "1 EKİM 2026", (2026, 10, 1)),
("d mmmm yyyy", "1 Ekim 2026", (2026, 10, 1)),
("d mmm yyyy", "1 EKİ 2026", (2026, 10, 1)),
("dddd d mmmm yyyy", "SALI 6 OCAK 2026", (2026, 1, 6)),
("dddd d mmmm yyyy", "Salı 6 Ocak 2026", (2026, 1, 6)),
] {
let read = parse_date(text, fmt).map(|d| (d.y, d.m, d.d));
if read != Some(want) {
bad.push(format!("forms {fmt}: {text:?} -> {read:?}"));
}
let (y, m, d) = want;
let got = scanned(fmt, text);
if got != format!("{y:04}-{m:02}-{d:02}") {
bad.push(format!("scand {fmt}: {text:?} -> {got}"));
}
}
// English is read as before, capitals and all.
use_form_date_language("en");
for (fmt, text) in [("d mmmm yyyy", "1 APRIL 2026"), ("dddd d mmmm yyyy", "FRIDAY 1 MAY 2026"), ("d mmm yyyy", "1 MAY 2026")] {
if parse_date(text, fmt).is_none() || scanned(fmt, text) == "null" {
bad.push(format!("en {fmt}: {text:?}"));
}
}
assert!(bad.is_empty(), "{}", bad.join("; "));
}
/// #5464 review: Greek names typed in capitals end in a capital Σ, which is the final ς of the
/// name ("ΙΑΝΟΥΆΡΙΟΣ" for "Ιανουάριος"); they read as they did before names were folded.
#[test]
fn greek_names_typed_in_capitals_are_read() {
let _names = names_lock();
use_form_date_language("el");
let mut bad = Vec::new();
for (fmt, text, want) in [
("d mmmm yyyy", "1 ΙΑΝΟΥΆΡΙΟΣ 2026", (2026, 1, 1)),
("d mmmm yyyy", "1 Ιανουάριος 2026", (2026, 1, 1)),
("d mmmm yyyy", "1 ιανουάριοσ 2026", (2026, 1, 1)),
("mmmm d, yyyy", "ΜΆΙΟΣ 5, 2026", (2026, 5, 5)),
("dddd, mmmm d, yyyy", "FRIDAY, ΙΑΝΟΥΆΡΙΟΣ 2, 2026", (2026, 1, 2)),
] {
let read = parse_date(text, fmt).map(|d| (d.y, d.m, d.d));
if read != Some(want) {
bad.push(format!("forms {fmt}: {text:?} -> {read:?}"));
}
let (y, m, d) = want;
let got = scanned(fmt, text);
if got != format!("{y:04}-{m:02}-{d:02}") {
bad.push(format!("scand {fmt}: {text:?} -> {got}"));
}
}
assert!(bad.is_empty(), "{}", bad.join("; "));
}