readsight 1.0.1

//! Full-language smoke test: build every language, analyze, and run every
//! supported formula, asserting no panics and finite numbers.

use readsight::ReadSight;

const TEXTS: &[&str] = &[
    "The quick brown fox jumps over the lazy dog. This is a second sentence for good measure.",
    "Быстрая коричневая лиса прыгает через ленивую собаку. Это второе предложение.",
];

#[test]
fn every_language_builds_and_scores() {
    let langs = ReadSight::supported_languages(None);
    assert_eq!(langs.len(), 86);

    for code in &langs {
        let rs = ReadSight::new(code).unwrap_or_else(|e| panic!("build {code}: {e}"));

        for text in TEXTS {
            // analyze must not panic; may error only on empty (won't here)
            let stats = rs
                .analyze(text)
                .unwrap_or_else(|e| panic!("analyze {code}: {e}"));
            assert!(stats.word_count > 0, "{code}: word_count");
            assert!(
                stats.average_syllables_per_word.is_finite(),
                "{code}: asw finite"
            );
            assert!(
                stats.average_words_per_sentence.is_finite(),
                "{code}: asl finite"
            );

            for formula in rs.supported_formulas() {
                let r = rs
                    .score(&formula, text)
                    .unwrap_or_else(|e| panic!("{code}/{formula}: {e}"));
                assert!(r.score.is_finite(), "{code}/{formula}: score finite");
                if let Some(g) = r.grade_level {
                    assert!(g.is_finite(), "{code}/{formula}: grade finite");
                }
                assert!(!r.interpretation.is_empty(), "{code}/{formula}: interp");
            }
        }
    }
}

#[test]
fn every_language_syllable_invariants() {
    for code in ReadSight::supported_languages(None) {
        let rs = ReadSight::new(&code).unwrap();
        for word in ["test", "sample", "reading", "a"] {
            let count = rs.syllable_count(word);
            assert!(count >= 0, "{code}: {word} count {count}");
            let parts = rs.split_word(word);
            // split_word must reconstruct the original word exactly
            assert_eq!(parts.concat(), word, "{code}: {word} reconstruct");
        }
    }
}