Learn Rust Coding · Pelajaran

Pengujian Unit

Atribut test

Pengujian Unit adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Pengujian dalam Rust

Rust memiliki pengujian bawaan—tidak diperlukan kerangka kerja eksternal. Pengujian adalah fungsi biasa yang diberi anotasi #[test], lalu dijalankan oleh cargo test.

Pengujian Pertama Anda

Fungsi pengujian tidak menerima argumen dan menggunakan pernyataan. Jika selesai secara normal, pengujian berhasil; jika mengalami panic, pengujian gagal.

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

Makro Pernyataan

Pernyataan standar adalah:

assert!(cond) — gagal jika kondisi bernilai salah
assert_eq!(a, b) — gagal jika nilainya tidak sama
assert_ne!(a, b) — gagal jika nilainya sama

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

Modul tests

Sesuai konvensi, pengujian unit berada dalam modul yang diberi anotasi #[cfg(test)] agar hanya dikompilasi selama pengujian.

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

Karena modul pengujian bersarang, use super::* membawa item modul induk (fungsi yang ingin Anda uji) ke dalam cakupan.

Menjalankan Pengujian

cargo test mengompilasi dan menjalankan setiap pengujian. Perintah ini melaporkan jumlah pengujian yang berhasil, gagal, atau diabaikan.

cargo test

Menguji Panic

Gunakan #[should_panic] untuk memastikan bahwa suatu fungsi mengalami panic dalam kondisi tertentu.

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

Pengujian yang Mengembalikan Result

Pengujian dapat mengembalikan Result, sehingga Anda dapat menggunakan operator ?. Mengembalikan Err membuat pengujian gagal.

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

Mengabaikan Pengujian

Tandai pengujian yang lambat atau bergantung pada lingkungan dengan #[ignore]. Jalankan secara eksplisit dengan cargo test -- --ignored.

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

fn main() {}

Opsi Pengujian yang Berguna

Opsi yang membantu saat menjalankan pengujian:

cargo test name — menjalankan pengujian yang cocok dengan nama tertentu
cargo test -- --nocapture — menampilkan keluaran println
cargo test -- --test-threads=1 — menjalankan secara berurutan

Menguji Fungsi Privat

Karena modul pengujian bersarang di dalam berkas yang sama, modul tersebut dapat mengakses fungsi privat—hal yang tidak dapat dilakukan pengujian integrasi. Ini adalah keunggulan utama pengujian unit.

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

Pemeriksaan Singkat

Atribut apa yang menandai suatu fungsi sebagai pengujian yang harus dijalankan Cargo?

Ringkasan

Anda telah mempelajari pengujian bawaan Rust:

#[test] menandai fungsi pengujian
Pernyataan: assert!, assert_eq!, assert_ne!
Pengujian berada dalam modul #[cfg(test)] dengan use super::*
#[should_panic] dan pengujian yang mengembalikan Result menangani kesalahan
cargo test menjalankan semuanya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pengujian Unit” gratis?

Ya — teks lengkap “Pengujian Unit” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pengujian Unit”?

Atribut test Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Pengujian Unit” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Learn Rust Coding