`teste (#[test])` în Rust

Module, macro-uri, atribute și teste Rust 1.0 (#[ignore = "motiv"]: 1.61)

O funcție marcată cu #[test] este un test automat: cargo test o rulează și raportează dacă a trecut sau a dat panică.

Sintaxă

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn nume_test() {
        assert_eq!(functie(2), 4);
    }

    #[test]
    #[should_panic(expected = "text")]
    fn trebuie_sa_dea_panica() { ... }
}

Ce face `teste (#[test])`

Rust are testele integrate în limbaj. Orice funcție fără parametri marcată cu #[test] este un test: trece dacă se termină normal și eșuează dacă dă panică (de exemplu un assert_eq! neîndeplinit). cargo test compilează proiectul în mod test și rulează toate testele în paralel.

Prin convenție, testele unitare stau în același fișier cu codul, într-un modul #[cfg(test)] mod tests. #[cfg(test)] face ca modulul să fie compilat doar la cargo test, nu și în programul final, iar use super::*; aduce în test funcțiile din fișier (inclusiv cele private). Testele de integrare, care folosesc biblioteca din exterior, se pun în directorul tests/.

#[should_panic] marchează un test care trebuie să dea panică (opțional cu expected = "fragment din mesaj"). #[ignore] sare peste un test lent, care se rulează doar cu cargo test -- --ignored. Un test poate returna și Result<(), E>, ca să folosească ?.

Exemple

Exemplul 1: Teste unitare care trec

Fișierul src/lib.rs al bibliotecii note conține două funcții și testele lor. Ambele teste trec.

// src/lib.rs
pub fn media(note: &[u8]) -> f64 {
    let suma: u32 = note.iter().map(|&n| n as u32).sum();
    suma as f64 / note.len() as f64
}

pub fn calificativ(media: f64) -> &'static str {
    if media >= 9.0 {
        "FB"
    } else if media >= 7.0 {
        "B"
    } else if media >= 5.0 {
        "S"
    } else {
        "I"
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn media_corecta() {
        assert_eq!(media(&[10, 9, 8]), 9.0);
    }

    #[test]
    fn calificative() {
        assert_eq!(calificativ(9.5), "FB");
        assert_eq!(calificativ(7.0), "B");
        assert_eq!(calificativ(4.99), "I");
    }
}

$ cargo test

Rezultat în terminal

   Compiling note v0.1.0 (/home/ana/proiecte/note)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 1.66s
     Running unittests src/lib.rs (target/debug/deps/note-acd73a4da84441e9)

running 2 tests
test tests::calificative ... ok
test tests::media_corecta ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests note

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Exemplul 2: should_panic, ignore și un test care eșuează

nota_prea_mare trece pentru că funcția dă panica așteptată. toate_notele este sărit. nota_zece are o greșeală în valoarea așteptată, deci eșuează: raportul arată ambele valori (left = cea calculată, right = cea așteptată) și mesajul nostru. Numărul dintre paranteze după numele firului diferă la fiecare rulare.

// src/lib.rs
pub fn nota_din_text(text: &str) -> u8 {
    let n: u8 = text.trim().parse().expect("nota trebuie să fie un număr");
    assert!((1..=10).contains(&n), "nota {n} nu este între 1 și 10");
    n
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn spatii_ignorate() {
        assert_eq!(nota_din_text(" 9\n"), 9);
    }

    #[test]
    #[should_panic(expected = "nu este între 1 și 10")]
    fn nota_prea_mare() {
        nota_din_text("11");
    }

    #[test]
    fn nota_zece() {
        assert_eq!(nota_din_text("10"), 1, "zece trebuie citit ca 10");
    }

    #[test]
    #[ignore = "durează mult"]
    fn toate_notele() {
        for n in 1..=10 {
            assert_eq!(nota_din_text(&n.to_string()), n);
        }
    }
}

$ cargo test