0Pricing
Learn Rust Coding · บทเรียน

การทดสอบหน่วย

แอตทริบิวต์ test

การทดสอบหน่วย เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

การทดสอบใน Rust

Rust มีการทดสอบในตัว จึงไม่ต้องใช้เฟรมเวิร์กภายนอก การทดสอบเป็นฟังก์ชันทั่วไปที่ใส่คำอธิบายประกอบด้วย #[test] และเรียกใช้โดย cargo test

การทดสอบครั้งแรกของคุณ

ฟังก์ชันทดสอบไม่รับอาร์กิวเมนต์และใช้การยืนยัน หากฟังก์ชันจบการทำงานตามปกติ การทดสอบจะผ่าน หากเกิด panic การทดสอบจะล้มเหลว

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

มาโครการยืนยัน

การยืนยันมาตรฐานมีดังนี้:

  • assert!(cond) — ล้มเหลวหากเงื่อนไขเป็นเท็จ
  • assert_eq!(a, b) — ล้มเหลวหากค่าไม่เท่ากัน
  • assert_ne!(a, b) — ล้มเหลวหากค่าเท่ากัน
fn main() {
    let x = 4;
    assert!(x > 0);
    assert_eq!(x, 4);
    assert_ne!(x, 5);
    println!("All assertions passed");
}

โมดูล tests

ตามธรรมเนียม การทดสอบหน่วยจะอยู่ในโมดูลที่ใส่คำอธิบายประกอบด้วย #[cfg(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::*

เนื่องจากโมดูลทดสอบซ้อนอยู่ภายใน โมดูลนี้จึงใช้ use super::* เพื่อนำรายการของโมดูลแม่ (ฟังก์ชันที่คุณต้องการทดสอบ) เข้ามาในขอบเขต

การเรียกใช้การทดสอบ

cargo test จะคอมไพล์และเรียกใช้การทดสอบทุกรายการ โดยรายงานจำนวนที่ผ่าน ล้มเหลว หรือถูกข้าม

cargo test

การทดสอบการเกิด panic

ใช้ #[should_panic] เพื่อยืนยันว่าฟังก์ชันเกิด panic ภายใต้เงื่อนไขบางอย่าง

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

การทดสอบที่คืนค่า Result

การทดสอบสามารถคืนค่า Result ทำให้คุณใช้ตัวดำเนินการ ? ได้ การคืนค่า Err จะทำให้การทดสอบล้มเหลว

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

การข้ามการทดสอบ

กำกับการทดสอบที่ทำงานช้าหรือขึ้นอยู่กับสภาพแวดล้อมด้วย #[ignore] เรียกใช้การทดสอบเหล่านั้นโดยระบุอย่างชัดเจนด้วย cargo test -- --ignored

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

fn main() {}

แฟล็กที่มีประโยชน์สำหรับการทดสอบ

ตัวเลือกที่มีประโยชน์เมื่อเรียกใช้การทดสอบ:

  • cargo test name — เรียกใช้การทดสอบที่ตรงกับชื่อ
  • cargo test -- --nocapture — แสดงผลลัพธ์จาก println
  • cargo test -- --test-threads=1 — เรียกใช้ตามลำดับทีละรายการ

การทดสอบฟังก์ชันส่วนตัว

เนื่องจากโมดูลทดสอบซ้อนอยู่ในไฟล์เดียวกัน จึงเข้าถึงฟังก์ชันส่วนตัวได้ ซึ่งการทดสอบแบบบูรณาการทำไม่ได้ นี่คือข้อได้เปรียบสำคัญของการทดสอบหน่วย

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

ตรวจสอบอย่างรวดเร็ว

แอตทริบิวต์ใดใช้กำกับฟังก์ชันให้เป็นการทดสอบที่ Cargo ควรเรียกใช้

สรุปทบทวน

คุณได้เรียนรู้การทดสอบในตัวของ Rust:

  • #[test] ใช้กำกับฟังก์ชันทดสอบ
  • การยืนยัน: assert!, assert_eq!, assert_ne!
  • การทดสอบอยู่ในโมดูล #[cfg(test)] พร้อม use super::*
  • การทดสอบที่ใช้ #[should_panic] และคืนค่า Result จัดการข้อผิดพลาด
  • cargo test เรียกใช้ทุกอย่าง

คำถามที่พบบ่อย

บทเรียน “การทดสอบหน่วย” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การทดสอบหน่วย” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การทดสอบหน่วย”

แอตทริบิวต์ test คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “การทดสอบหน่วย” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การทดสอบหน่วย
  2. การทดสอบการผสานรวม
  3. คอมเมนต์เอกสาร
  4. การทดสอบเอกสาร
← กลับไปที่ Learn Rust Coding