Test unitari
Attributo test
Test unitari è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.
Test in Rust
Rust include un sistema di test integrato: non serve alcun framework esterno. I test sono normali funzioni annotate con #[test], eseguite da cargo test.
Il primo test
Una funzione di test non accetta argomenti e usa asserzioni. Se termina normalmente, il test ha esito positivo; se va in panic, ha esito negativo.
fn add(a: i32, b: i32) -> i32 {
a + b
}
#[test]
fn it_adds() {
assert_eq!(add(2, 3), 5);
}
fn main() {
println!("{}", add(2, 3));
}Macro di asserzione
Le asserzioni standard sono:
assert!(cond)— fallisce se la condizione è falsaassert_eq!(a, b)— fallisce se i valori non sono ugualiassert_ne!(a, b)— fallisce se i valori sono uguali
fn main() {
let x = 4;
assert!(x > 0);
assert_eq!(x, 4);
assert_ne!(x, 5);
println!("All assertions passed");
}Il modulo tests
Per convenzione, i test unitari si trovano in un modulo annotato con #[cfg(test)], in modo da essere compilati solo durante i test.
fn square(n: i32) -> i32 {
n * n
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn squares_correctly() {
assert_eq!(square(5), 25);
}
}
fn main() {
println!("{}", square(5));
}use super::*
Poiché il modulo dei test è annidato, use super::* rende disponibili nell'ambito gli elementi del modulo genitore, ovvero le funzioni da testare.
Eseguire i test
cargo test compila ed esegue tutti i test. Indica quanti test sono stati superati, non superati o ignorati.
cargo testVerificare i panic
Usate #[should_panic] per verificare che una funzione vada in panic in determinate condizioni.
fn checked_div(a: i32, b: i32) -> i32 {
if b == 0 {
panic!("division by zero");
}
a / b
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[should_panic(expected = "division by zero")]
fn panics_on_zero() {
checked_div(10, 0);
}
}
fn main() {}Test che restituiscono Result
Un test può restituire Result, consentendovi di usare l'operatore ?. La restituzione di Err fa fallire il test.
fn parse(s: &str) -> Result<i32, std::num::ParseIntError> {
s.parse::<i32>()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_number() -> Result<(), std::num::ParseIntError> {
let n = parse("42")?;
assert_eq!(n, 42);
Ok(())
}
}
fn main() {}Ignorare i test
Contrassegnate con #[ignore] i test lenti o dipendenti dall'ambiente. Eseguiteli esplicitamente con cargo test -- --ignored.
#[test]
#[ignore]
fn expensive_test() {
// long-running work
}
fn main() {}Flag utili per i test
Opzioni utili durante l'esecuzione dei test:
cargo test name— esegue i test il cui nome corrispondecargo test -- --nocapture— mostra l'output di printlncargo test -- --test-threads=1— esegue i test in sequenza
Testare funzioni private
Poiché il modulo dei test è annidato nello stesso file, può accedere alle funzioni private, cosa che i test di integrazione non possono fare. Questo è un vantaggio fondamentale dei test unitari.
fn internal(n: i32) -> i32 {
n + 1
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn tests_private() {
assert_eq!(internal(4), 5);
}
}
fn main() {
println!("{}", internal(4));
}Verifica rapida
Quale attributo contrassegna una funzione come test da eseguire con Cargo?
Riepilogo
Avete imparato a usare il sistema di test integrato di Rust:
#[test]contrassegna le funzioni di test- Asserzioni:
assert!,assert_eq!,assert_ne! - I test si trovano in un modulo
#[cfg(test)]conuse super::* #[should_panic]e i test che restituisconoResultgestiscono gli erroricargo testesegue tutti i test
Impara Rust con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 39
- Lezioni
- 144
Domande Frequenti
La lezione «Test unitari» è gratuita?
Sì — il testo completo di «Test unitari» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.
Cosa imparerò in «Test unitari»?
Attributo test Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn Rust Coding?
Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Test unitari»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?
Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.