tests/wsplit_parity.rs

//! Whitespace / Word parity: the atom masks vs the OLD pretokenizers' actual engines.
//!
//! Part A (definitive, no data): for every codepoint, does atom `WORD` == onig `\w` and atom `WS`
//!   == onig `\s`? onig is exactly what HF `SysRegex` uses, so this is the ground truth for the
//!   `Whitespace` (`\w+|[^\w\s]+`) pretokenizer. Also cross-checked against the `regex` crate
//!   (Unicode \p{word}/\p{White_Space}) and `std::char::is_whitespace` (WhitespaceSplit's engine).
//! Part B (span gate): run the two atom FSMs over real multilingual text (benches/data + tests/data/xnli
//!   if present) and diff spans against the reference engines.
//!
//! run: cargo test --release --test wsplit_parity -- --nocapture

use fast_split::classify::{classify, in_mask, mask, Atoms};
use fast_split::fsm::{self, Behavior};
use onig::Regex as Onig;

// ── atom membership for a single char ──────────────────────────────────────────────────────────
fn atom_tag(ch: char) -> u8 {
    let mut buf = [0u8; 4];
    let b = ch.encode_utf8(&mut buf).as_bytes();
    let mut tags = [0u8; 4];
    classify::<Atoms>(b, &mut tags[..b.len()]);
    tags[0]
}
fn atom_word(ch: char) -> bool { in_mask(atom_tag(ch), mask::WORD) }
fn atom_ws(ch: char) -> bool { in_mask(atom_tag(ch), mask::WS) }

fn cp_name(cp: u32) -> &'static str {
    match cp {
        0x09 => "TAB", 0x0A => "LF", 0x0B => "VT", 0x0C => "FF", 0x0D => "CR", 0x20 => "SPACE",
        0x85 => "NEL", 0xA0 => "NBSP", 0x1680 => "OGHAM SP", 0x2007 => "FIGURE SP",
        0x2009 => "THIN SP", 0x2028 => "LINE SEP", 0x2029 => "PARA SEP", 0x202F => "NARROW NBSP",
        0x205F => "MMSP", 0x3000 => "IDEOGRAPHIC SP", 0x180E => "MONGOLIAN VOWEL SEP",
        0x200B => "ZWSP", 0x200C => "ZWNJ", 0x200D => "ZWJ", 0x5F => "LOW LINE",
        0xBD => "1/2", 0xBC => "1/4", 0xB2 => "SUPER 2", 0x2168 => "ROMAN IX", _ => "",
    }
}

#[test]
fn a_codepoint_diff_word_and_ws() {
    let w_onig = Onig::new(r"\A\w\z").unwrap();
    let s_onig = Onig::new(r"\A\s\z").unwrap();
    let w_re = regex::Regex::new(r"\A\w\z").unwrap();
    let s_re = regex::Regex::new(r"\A\s\z").unwrap();

    // divergence buckets: (label, list of cps)
    let mut w_atom_vs_onig: Vec<u32> = vec![]; // atom \w  !=  onig \w   (THE gate for `Whitespace`)
    let mut w_atom_vs_re: Vec<u32> = vec![];   // atom \w  !=  Unicode \p{word}
    let mut w_onig_vs_re: Vec<u32> = vec![];    // onig \w  !=  Unicode \p{word}  (is onig standard?)
    let mut s_atom_vs_onig: Vec<u32> = vec![];
    let mut s_atom_vs_re: Vec<u32> = vec![];
    let mut s_atom_vs_std: Vec<u32> = vec![]; // atom \s != std::char::is_whitespace (WhitespaceSplit gate)
    let mut s_onig_vs_std: Vec<u32> = vec![];

    for cp in 0u32..=0x10FFFF {
        if (0xD800..=0xDFFF).contains(&cp) { continue; }
        let ch = char::from_u32(cp).unwrap();
        let mut buf = [0u8; 4];
        let s = ch.encode_utf8(&mut buf);

        let aw = atom_word(ch);
        let ow = w_onig.find(s).is_some();
        let rw = w_re.is_match(s);
        if aw != ow { w_atom_vs_onig.push(cp); }
        if aw != rw { w_atom_vs_re.push(cp); }
        if ow != rw { w_onig_vs_re.push(cp); }

        let as_ = atom_ws(ch);
        let os = s_onig.find(s).is_some();
        let rs = s_re.is_match(s);
        let ss = ch.is_whitespace();
        if as_ != os { s_atom_vs_onig.push(cp); }
        if as_ != rs { s_atom_vs_re.push(cp); }
        if as_ != ss { s_atom_vs_std.push(cp); }
        if os != ss { s_onig_vs_std.push(cp); }
    }

    let show = |name: &str, v: &[u32]| {
        println!("  {name}: {} divergent cp(s)", v.len());
        for &cp in v.iter().take(40) {
            let ch = char::from_u32(cp).unwrap();
            let nm = cp_name(cp);
            let a = if atom_word(ch) { "W" } else { "." };
            let s = if atom_ws(ch) { "S" } else { "." };
            println!("     U+{cp:04X} [{a}{s}] {nm:<22} {ch:?}");
        }
        if v.len() > 40 { println!("     … +{} more", v.len() - 40); }
    };

    println!("\n=== PART A — all-codepoint property diff ===");
    println!("\n-- WORD (\\w) --");
    show("atom \\w  vs  onig \\w   [Whitespace GATE]", &w_atom_vs_onig);
    show("atom \\w  vs  Unicode \\p{{word}}", &w_atom_vs_re);
    show("onig \\w  vs  Unicode \\p{{word}}", &w_onig_vs_re);
    println!("\n-- WS (\\s) --");
    show("atom \\s  vs  onig \\s   [Whitespace GATE]", &s_atom_vs_onig);
    show("atom \\s  vs  Unicode \\p{{White_Space}}", &s_atom_vs_re);
    show("atom \\s  vs  std::is_whitespace [WhitespaceSplit GATE]", &s_atom_vs_std);
    show("onig \\s  vs  std::is_whitespace", &s_onig_vs_std);

    // The two gates that actually decide pretokenizer parity:
    println!("\n=== GATES ===");
    println!("  Whitespace   (\\w): atom==onig? {}", w_atom_vs_onig.is_empty());
    println!("  Whitespace   (\\s): atom==onig? {}", s_atom_vs_onig.is_empty());
    println!("  WhitespaceSplit  : atom \\s == std::is_whitespace? {}", s_atom_vs_std.is_empty());
}

// ── Part B: span parity over real corpora ───────────────────────────────────────────────────────
fn fsm_whitespace(text: &[u8]) -> Vec<(usize, usize)> {
    let mut tags = vec![0u8; text.len()];
    classify::<Atoms>(text, &mut tags);
    let mut out = Vec::new();
    fsm::fsm_class_runs::<{ mask::WS }, 0, { mask::WORD }>(text, &tags, &mut out);
    out.iter().map(|&(a, b)| (a as usize, b as usize)).collect()
}
fn fsm_wssplit(text: &[u8]) -> Vec<(usize, usize)> {
    let mut tags = vec![0u8; text.len()];
    classify::<Atoms>(text, &mut tags);
    let mut out = Vec::new();
    fsm::fsm_split::<{ mask::WS }, { Behavior::Removed as u8 }>(text, &tags, &mut out);
    out.iter().map(|&(a, b)| (a as usize, b as usize)).collect()
}
fn ref_whitespace(text: &str, re: &Onig) -> Vec<(usize, usize)> {
    re.find_iter(text).collect()
}
fn ref_wssplit(text: &str) -> Vec<(usize, usize)> {
    let mut out = Vec::new();
    let mut start: Option<usize> = None;
    for (i, ch) in text.char_indices() {
        if ch.is_whitespace() {
            if let Some(st) = start.take() { out.push((st, i)); }
        } else if start.is_none() {
            start = Some(i);
        }
    }
    if let Some(st) = start { out.push((st, text.len())); }
    out
}

fn diff_report(tag: &str, file: &str, text: &str, got: &[(usize, usize)], want: &[(usize, usize)]) -> usize {
    if got == want { return 0; }
    println!("  MISMATCH [{tag}] {file}: got {} spans, want {} spans", got.len(), want.len());
    let mut shown = 0;
    for i in 0..got.len().max(want.len()) {
        let g = got.get(i).copied();
        let w = want.get(i).copied();
        if g != w {
            let ctx = w.or(g).map(|(a, b)| {
                let a = a.saturating_sub(8);
                let b = (b + 8).min(text.len());
                &text[a..b]
            }).unwrap_or("");
            println!("     #{i}: got {g:?} want {w:?}  near {ctx:?}");
            shown += 1;
            if shown >= 6 { println!("     …"); break; }
        }
    }
    1
}

#[test]
fn b_span_parity_corpora() {
    let re_ws = Onig::new(r"\w+|[^\w\s]+").unwrap();
    let dirs = ["benches/data", "tests/data/xnli"];
    let mut files: Vec<std::path::PathBuf> = vec![];
    for d in dirs {
        if let Ok(rd) = std::fs::read_dir(d) {
            for e in rd.flatten() {
                let p = e.path();
                if p.extension().map_or(false, |x| x == "txt") { files.push(p); }
            }
        }
    }
    files.sort();
    assert!(!files.is_empty(), "no corpus files found in benches/data or tests/data/xnli");

    println!("\n=== PART B — span parity over {} files ===", files.len());
    let mut fails = 0;
    for p in &files {
        let text = std::fs::read_to_string(p).unwrap();
        let name = p.file_name().unwrap().to_string_lossy().to_string();
        let b = text.as_bytes();
        fails += diff_report("Whitespace", &name, &text, &fsm_whitespace(b), &ref_whitespace(&text, &re_ws));
        fails += diff_report("WhitespaceSplit", &name, &text, &fsm_wssplit(b), &ref_wssplit(&text));
    }
    println!("  files clean: {}/{}", (files.len() * 2 - fails), files.len() * 2);
    assert_eq!(fails, 0, "{fails} corpus/pretokenizer pairs diverged (see above)");
}