Learn Rust Coding · Lektion

Unit-Tests

test-Attribut

Unit-Tests ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Testing in Rust

Rust has built-in testing — no external framework needed. Tests are ordinary functions annotated with #[test], run by cargo test.

Your First Test

A test function takes no arguments and uses assertions. If it returns normally, it passes; if it panics, it fails.

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));
}

Assertion Macros

The standard assertions are:

assert!(cond) — fails if condition is false
assert_eq!(a, b) — fails if not equal
assert_ne!(a, b) — fails if equal

fn main() {
    let x = 4;
    assert!(x > 0);
    assert_eq!(x, 4);
    assert_ne!(x, 5);
    println!("All assertions passed");
}

The tests Module

By convention, unit tests live in a module annotated with #[cfg(test)] so they are compiled only during testing.

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::*

Because the test module is nested, use super::* brings the parent module's items (the functions you want to test) into scope.

Running Tests

cargo test compiles and runs every test. It reports how many passed, failed, or were ignored.

cargo test

Testing for Panics

Use #[should_panic] to assert that a function panics under certain conditions.

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() {}

Tests Returning Result

A test can return Result, letting you use the ? operator. Returning Err fails the 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() {}

Ignoring Tests

Mark slow or environment-specific tests with #[ignore]. Run them explicitly with cargo test -- --ignored.

#[test]
#[ignore]
fn expensive_test() {
    // long-running work
}

fn main() {}

Useful Test Flags

Helpful options when running tests:

cargo test name — run tests matching a name
cargo test -- --nocapture — show println output
cargo test -- --test-threads=1 — run serially

Testing Private Functions

Because the test module is nested inside the same file, it can reach private functions — something integration tests cannot do. This is a key advantage of unit tests.

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));
}

Quick Check

What attribute marks a function as a test that Cargo should run?

Recap

You learned Rust's built-in testing:

#[test] marks test functions
Assertions: assert!, assert_eq!, assert_ne!
Tests live in a #[cfg(test)] module with use super::*
#[should_panic] and Result-returning tests handle errors
cargo test runs everything

Häufig gestellte Fragen

Ist die Lektion „Unit-Tests“ kostenlos?

Ja — der vollständige Text von „Unit-Tests“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Unit-Tests“?

test-Attribut Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Unit-Tests“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding