Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

วิธีเขียนเทสต์

เทสต์ (test หรือการทดสอบ) คือฟังก์ชันใน Rust ที่ทำหน้าที่ตรวจสอบว่าโค้ดส่วนอื่นๆ ที่ไม่ใช่เทสต์ทำงานได้ถูกต้องตรงตามความคาดหวังหรือไม่ โดยทั่วไปแล้ว เนื้อหาภายในฟังก์ชันเทสต์มักจะดำเนินการตาม 3 ขั้นตอนนี้:

  • ตระเตรียมข้อมูลหรือสถานะ (state) ที่จำเป็น
  • สั่งทำงานโค้ดส่วนที่คุณต้องการทดสอบ
  • ยืนยัน (assert) ว่าผลลัพธ์ที่ได้ตรงตามสิ่งที่คุณคาดหวังไว้

มาดูฟีเจอร์ต่างๆ ที่ Rust มีให้สำหรับการเขียนเทสต์โดยเฉพาะ ซึ่งรวมถึงแอตทริบิวต์ test มาโครสำหรับการตรวจสอบค่า และแอตทริบิวต์ should_panic

โครงสร้างของฟังก์ชันเทสต์

ในรูปแบบที่เรียบง่ายที่สุด เทสต์ใน Rust คือฟังก์ชันที่กำกับไว้ด้วยแอตทริบิวต์ (attribute) test โดยแอตทริบิวต์คือข้อมูลเมทาดาทาที่ใช้อธิบายส่วนต่างๆ ของโค้ด Rust ตัวอย่างเช่น แอตทริบิวต์ derive ที่เราเคยใช้กับ struct ในบทที่ 5 การจะเปลี่ยนฟังก์ชันทั่วไปให้กลายเป็นฟังก์ชันเทสต์ ทำได้โดยเพิ่ม #[test] ไว้บนบรรทัดก่อนหน้า fn เมื่อคุณสั่งรันเทสต์ด้วยคำสั่ง cargo test Rust จะคอมไพล์ไบนารีสำหรับตัวรันทดสอบ (test runner binary) ขึ้นมา เพื่อรันฟังก์ชันทั้งหมดที่มีแอตทริบิวต์นี้กำกับอยู่ พร้อมทั้งรายงานผลลัพธ์ว่าฟังก์ชันเทสต์แต่ละตัวนั้นผ่าน (pass) หรือล้มเหลว (fail)

ทุกครั้งที่เราสร้างโปรเจกต์ไลบรารีใหม่ขึ้นมาด้วย Cargo ระบบจะสร้างมอดูลเทสต์พร้อมฟังก์ชันเทสต์ตัวอย่างมาให้เราโดยอัตโนมัติ มอดูลนี้เปรียบเสมือนแม่แบบ (template) ในการเขียนเทสต์ของคุณ ช่วยให้คุณไม่ต้องคอยเปิดหาโครงสร้างและวากยสัมพันธ์ที่ถูกต้องทุกครั้งที่เริ่มโปรเจกต์ใหม่ และคุณสามารถเพิ่มฟังก์ชันเทสต์รวมถึงมอดูลเทสต์เพิ่มเติมได้มากเท่าที่ต้องการ!

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

มาสร้างโปรเจกต์ไลบรารีใหม่ชื่อ adder ที่จะบวกตัวเลขสองตัวกัน:

$ cargo new adder --lib
     Created library `adder` project
$ cd adder

เนื้อหาของไฟล์ src/lib.rs ในไลบรารี adder ของคุณควรมีหน้าตาดังลิสติ้ง 11-1

pub fn add(left: u64, right: u64) -> u64 {
    left + right
}

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

    #[test]
    fn it_works() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }
}

ไฟล์นี้เริ่มต้นด้วยฟังก์ชัน add ตัวอย่าง เพื่อให้เรามีฟังก์ชันสำหรับนำมาทดสอบ

สำหรับตอนนี้ ขอให้เราโฟกัสเฉพาะฟังก์ชัน it_works เพียงอย่างเดียวก่อน โปรดสังเกตการกำกับด้วย #[test] แอตทริบิวต์นี้เป็นตัวบ่งบอกว่านี่คือฟังก์ชันเทสต์ ตัวรันทดสอบจึงทราบว่าจะต้องปฏิบัติต่อฟังก์ชันนี้ในฐานะการทดสอบ เราอาจมีฟังก์ชันที่ไม่ใช่เทสต์อยู่ภายในมอดูล tests ด้วย เพื่อช่วยเตรียมสถานการณ์จำลองหรือดำเนินการทั่วไป ดังนั้นเราจึงจำเป็นต้องระบุให้ชัดเจนเสมอว่าฟังก์ชันใดบ้างที่เป็นเทสต์

เนื้อหาภายในฟังก์ชันตัวอย่างจะใช้มาโคร assert_eq! เพื่อยืนยันว่า result ซึ่งเก็บผลลัพธ์จากการเรียก add ด้วยค่า 2 และ 2 มีค่าเท่ากับ 4 การตรวจสอบแบบยืนยันค่า (assertion) นี้เป็นตัวอย่างรูปแบบของเทสต์ทั่วไป มาลองรันคำสั่งเพื่อดูว่าเทสต์นี้ผ่านหรือไม่

คำสั่ง cargo test รันเทสต์ทั้งหมดในโปรเจกต์ของเรา ดังที่แสดงในลิสติ้ง 11-2

$ cargo test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.57s
     Running unittests src/lib.rs (target/debug/deps/adder-01ad14159ff659ab)

running 1 test
test tests::it_works ... ok

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

   Doc-tests adder

running 0 tests

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

Cargo ได้คอมไพล์และรันเทสต์เรียบร้อยแล้ว เราจะเห็นบรรทัด running 1 test บรรทัดถัดมาแสดงชื่อของฟังก์ชันเทสต์ที่ถูกสร้างขึ้นคือ tests::it_works และผลลัพธ์ของการรันเทสต์นั้นคือ ok ส่วนข้อความสรุปภาพรวม test result: ok. หมายความว่าเทสต์ทั้งหมดผ่าน และข้อความ 1 passed; 0 failed เป็นการสรุปยอดรวมของจำนวนเทสต์ที่ผ่านหรือล้มเหลว

เราสามารถทำเครื่องหมายให้ข้าม (ignore) เทสต์บางตัวได้ เพื่อไม่ให้ถูกรันในแต่ละรอบ ซึ่งเราจะอธิบายเรื่องนี้ในหัวข้อ“การข้ามเทสต์เว้นแต่จะถูกร้องขออย่างเจาะจง” ในช่วงถัดไปของบทนี้ และเนื่องจากตอนนี้เรายังไม่ได้ข้ามเทสต์ใดๆ ข้อความสรุปจึงแสดง 0 ignored นอกจากนี้ เรายังสามารถส่งอาร์กิวเมนต์ให้กับคำสั่ง cargo test เพื่อเลือกสั่งรันเฉพาะเทสต์ที่มีชื่อตรงกับข้อความที่ระบุได้ ซึ่งสิ่งนี้เรียกว่า_การกรอง_ (filtering) โดยจะกล่าวถึงในหัวข้อ“การรันเทสต์บางส่วนตามชื่อ” ในที่นี้เราไม่ได้กรองเทสต์ใดๆ ออก ท้ายบรรทัดสรุปจึงแสดง 0 filtered out

สถิติ 0 measured มีไว้สำหรับเทสต์วัดประสิทธิภาพ (benchmark tests) ซึ่ง ณ ตอนที่เขียนนี้ เบนช์มาร์กเทสต์มีให้ใช้งานเฉพาะใน Rust เวอร์ชัน nightly เท่านั้น สามารถดูรายละเอียดเพิ่มเติมได้ที่เอกสารเกี่ยวกับเทสต์แบบเบนช์มาร์ก

ส่วนถัดไปของเอาต์พุตที่ขึ้นต้นด้วย Doc-tests adder เป็นผลลัพธ์ของด็อกเทสต์ (documentation tests) แม้ว่าตอนนี้เราจะยังไม่ได้เขียนด็อกเทสต์ไว้ แต่ Rust มีความสามารถในการนำตัวอย่างโค้ดที่ปรากฏอยู่ในเอกสารประกอบ API มาคอมไพล์และทดสอบได้ ฟีเจอร์นี้ช่วยให้เอกสารและโค้ดของคุณตรงกันอยู่เสมอ! เราจะพูดถึงวิธีการเขียนด็อกเทสต์ในหัวข้อ“คอมเมนต์เอกสารประกอบในฐานะเทสต์” ของบทที่ 14 แต่ในตอนนี้เราจะข้ามผลลัพธ์ในส่วน Doc-tests ไปก่อน

มาเริ่มปรับแต่งเทสต์ให้ตรงตามความต้องการของเรากัน อันดับแรก ให้เปลี่ยนชื่อฟังก์ชัน it_works เป็นชื่ออื่น เช่น exploration ดังนี้:

ชื่อไฟล์: src/lib.rs

pub fn add(left: u64, right: u64) -> u64 {
    left + right
}

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

    #[test]
    fn exploration() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }
}

จากนั้นรัน cargo test อีกครั้ง เอาต์พุตจะแสดงชื่อ exploration แทนที่ it_works:

$ cargo test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.59s
     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)

running 1 test
test tests::exploration ... ok

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

   Doc-tests adder

running 0 tests

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

คราวนี้เราจะเพิ่มเทสต์อีกตัวหนึ่ง แต่รอบนี้เราจะตั้งใจสร้างเทสต์ที่ล้มเหลว! เทสต์จะถือว่าล้มเหลวเมื่อมีบางอย่างในฟังก์ชันเทสต์เกิดการแพนิก (panic) ขึ้น โดยเทสต์แต่ละตัวจะถูกรันแยกในเธรด (thread) ใหม่ และเมื่อเธรดหลักตรวจพบว่าเธรดของเทสต์ตัวนั้นยุติลงอย่างกะทันหัน เทสต์ดังกล่าวก็จะถูกบันทึกว่าล้มเหลว ในบทที่ 9 เราได้เรียนรู้ไปแล้วว่าวิธีที่ง่ายที่สุดในการทำให้เกิดการแพนิกก็คือการเรียกใช้มาโคร panic! ให้เพิ่มฟังก์ชันเทสต์ใหม่ชื่อ another เพื่อให้ไฟล์ src/lib.rs ของคุณมีลักษณะดังลิสติ้ง 11-3

pub fn add(left: u64, right: u64) -> u64 {
    left + right
}

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

    #[test]
    fn exploration() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }

    #[test]
    fn another() {
        panic!("Make this test fail");
    }
}

รันเทสต์อีกครั้งโดยใช้ cargo test เอาต์พุตควรมีหน้าตาดังลิสติ้ง 11-4 ซึ่งแสดงว่าเทสต์ exploration ของเราผ่านและ another ล้มเหลว

$ cargo test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.72s
     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)

running 2 tests
test tests::another ... FAILED
test tests::exploration ... ok

failures:

---- tests::another stdout ----

thread 'tests::another' (6019162) panicked at src/lib.rs:17:9:
Make this test fail
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::another

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

error: test failed, to rerun pass `--lib`

แทนที่จะแสดงผลลัพธ์เป็น ok บรรทัด test tests::another กลับแสดงเป็น FAILED และมีส่วนแสดงผลใหม่ 2 ส่วนปรากฏขึ้นคั่นระหว่างผลลัพธ์รายตัวกับข้อความสรุป: ส่วนแรกจะแสดงเหตุผลอย่างละเอียดของความล้มเหลวในแต่ละเทสต์ ในที่นี้เราระบุรายละเอียดได้ว่า tests::another ล้มเหลวเพราะเกิดการแพนิกพร้อมข้อความ Make this test fail ที่บรรทัดที่ 17 ของไฟล์ src/lib.rs ส่วนถัดมาจะสรุปเฉพาะรายชื่อของเทสต์ทั้งหมดที่ล้มเหลว ซึ่งมีประโยชน์มากเมื่อชุดทดสอบมีจำนวนมากและมีข้อความแสดงความล้มเหลวที่ยาวเหยียด เราสามารถนำชื่อของเทสต์ที่ล้มเหลวนี้ไปใช้สั่งรันเฉพาะเทสต์นั้นเพื่อดีบักโค้ดได้ง่ายขึ้น เราจะพูดถึงวิธีควบคุมการรันเทสต์เพิ่มเติมในหัวข้อ“ควบคุมวิธีการรันเทสต์”

บรรทัดสรุปภาพรวมจะแสดงที่ตอนท้ายสุด: โดยรวมแล้วผลลัพธ์ของเทสต์คือ FAILED โดยเรามีเทสต์ที่ผ่าน 1 ตัว และเทสต์ที่ล้มเหลว 1 ตัว

เมื่อคุณได้เห็นหน้าตาของผลลัพธ์จากการรันเทสต์ในสถานการณ์ต่างๆ แล้ว ต่อไปเรามาดูมาโครอื่นๆ นอกเหนือจาก panic! ที่มีประโยชน์อย่างยิ่งในการเขียนเทสต์

การตรวจสอบผลลัพธ์ด้วย assert!

มาโคร assert! จากไลบรารีมาตรฐาน มีประโยชน์มากเมื่อคุณต้องการตรวจสอบให้มั่นใจว่าเงื่อนไขบางอย่างในการทดสอบให้ผลลัพธ์เป็น true เราจะส่งอาร์กิวเมนต์ที่ประเมินค่าออกมาเป็นค่าบูลีนให้กับมาโคร assert! หากค่านั้นเป็น true จะไม่มีอะไรเกิดขึ้นและเทสต์จะผ่าน แต่หากค่านั้นเป็น false มาโคร assert! จะเรียกใช้คำสั่ง panic! ส่งผลให้เทสต์นั้นล้มเหลวทันที การใช้มาโคร assert! จึงช่วยให้เราตรวจสอบยืนยันได้อย่างมั่นใจว่าโค้ดกำลังทำงานได้ตรงตามที่เราตั้งใจไว้

ในบทที่ 5 ลิสติ้ง 5-15 เราเคยใช้งาน struct Rectangle และเมธอด can_hold ซึ่งนำมาแสดงซ้ำอีกครั้งในลิสติ้ง 11-5 ให้เรานำโค้ดนี้ไปใส่ไว้ในไฟล์ src/lib.rs แล้วเขียนเทสต์สำหรับทดสอบเมธอดดังกล่าวโดยใช้มาโคร assert!

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

เมธอด can_hold จะส่งคืนค่าเป็นบูลีน ซึ่งเหมาะเจาะอย่างยิ่งกับการใช้งานร่วมกับมาโคร assert! ในลิสติ้ง 11-6 เราได้เขียนเทสต์เพื่อทดสอบเมธอด can_hold โดยสร้างอินสแตนซ์ Rectangle ที่มีความกว้าง 8 และความสูง 7 ขึ้นมา แล้วยืนยันว่ามันสามารถบรรจุอินสแตนซ์ Rectangle อีกตัวที่มีความกว้าง 5 และความสูง 1 ได้

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

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

    #[test]
    fn larger_can_hold_smaller() {
        let larger = Rectangle {
            width: 8,
            height: 7,
        };
        let smaller = Rectangle {
            width: 5,
            height: 1,
        };

        assert!(larger.can_hold(&smaller));
    }
}

โปรดสังเกตบรรทัด use super::*; ภายในมอดูล tests มอดูล tests นั้นเป็นมอดูลธรรมดาทั่วไปที่ปฏิบัติตามกฎเรื่องการเปิดเผย (visibility) ตามที่เราได้เรียนรู้กันไปในบทที่ 7 หัวข้อ“พาธสำหรับอ้างถึงรายการในแผนผังมอดูล” และเนื่องจากมอดูล tests เป็นมอดูลชั้นใน เราจึงจำเป็นต้องนำโค้ดที่ต้องการทดสอบซึ่งอยู่ในมอดูลชั้นนอกเข้ามายังสโคปของมอดูลชั้นในนี้ การใช้เครื่องหมายดอกจัน (glob) ตรงนี้จะช่วยให้ทุกสิ่งที่เรานิยามไว้ในมอดูลชั้นนอกสามารถเรียกใช้งานในมอดูล tests ได้ทั้งหมด

เราตั้งชื่อเทสต์นี้ว่า larger_can_hold_smaller และสร้างอินสแตนซ์ Rectangle สองตัวที่ต้องการ จากนั้นจึงเรียกใช้มาโคร assert! โดยส่งผลลัพธ์ของ larger.can_hold(&smaller) ให้มัน เอ็กซ์เพรสชันนี้ควรให้ผลลัพธ์เป็น true ดังนั้นเทสต์ของเราจึงควรจะผ่าน มาลองรันดูกันเลย!

$ cargo test
   Compiling rectangle v0.1.0 (file:///projects/rectangle)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
     Running unittests src/lib.rs (target/debug/deps/rectangle-6584c4561e48942e)

running 1 test
test tests::larger_can_hold_smaller ... ok

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

   Doc-tests rectangle

running 0 tests

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

มันผ่านจริงด้วย! มาเพิ่มเทสต์อีกตัว ครั้งนี้ยืนยันว่าสี่เหลี่ยมที่เล็กกว่าไม่สามารถบรรจุสี่เหลี่ยมที่ใหญ่กว่าได้:

ชื่อไฟล์: src/lib.rs

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

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

    #[test]
    fn larger_can_hold_smaller() {
        // --snip--
        let larger = Rectangle {
            width: 8,
            height: 7,
        };
        let smaller = Rectangle {
            width: 5,
            height: 1,
        };

        assert!(larger.can_hold(&smaller));
    }

    #[test]
    fn smaller_cannot_hold_larger() {
        let larger = Rectangle {
            width: 8,
            height: 7,
        };
        let smaller = Rectangle {
            width: 5,
            height: 1,
        };

        assert!(!smaller.can_hold(&larger));
    }
}

เนื่องจากผลลัพธ์ที่ถูกต้องของฟังก์ชัน can_hold ในกรณีนี้จะต้องเป็น false เราจึงต้องกลับค่าผลลัพธ์นั้น (negate) ด้วยตัวดำเนินการ ! ก่อนส่งให้กับมาโคร assert! ส่งผลให้เทสต์ของเราจะผ่านก็ต่อเมื่อ can_hold ส่งคืนค่า false:

$ cargo test
   Compiling rectangle v0.1.0 (file:///projects/rectangle)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
     Running unittests src/lib.rs (target/debug/deps/rectangle-6584c4561e48942e)

running 2 tests
test tests::larger_can_hold_smaller ... ok
test tests::smaller_cannot_hold_larger ... ok

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

   Doc-tests rectangle

running 0 tests

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

เทสต์ทั้งสองตัวผ่านฉลุย! คราวนี้มาดูกันว่าจะเกิดอะไรขึ้นกับผลลัพธ์ของเทสต์ หากเราลองใส่บั๊กลงไปในโค้ด เราจะลองแก้ไขการทำงานของเมธอด can_hold โดยเปลี่ยนเครื่องหมายมากกว่า (>) ให้กลายเป็นเครื่องหมายน้อยกว่า (<) ในขั้นตอนการเปรียบเทียบความกว้าง:

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

// --snip--
impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width < other.width && self.height > other.height
    }
}

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

    #[test]
    fn larger_can_hold_smaller() {
        let larger = Rectangle {
            width: 8,
            height: 7,
        };
        let smaller = Rectangle {
            width: 5,
            height: 1,
        };

        assert!(larger.can_hold(&smaller));
    }

    #[test]
    fn smaller_cannot_hold_larger() {
        let larger = Rectangle {
            width: 8,
            height: 7,
        };
        let smaller = Rectangle {
            width: 5,
            height: 1,
        };

        assert!(!smaller.can_hold(&larger));
    }
}

การรันเทสต์ตอนนี้ให้ผลลัพธ์ดังนี้:

$ cargo test
   Compiling rectangle v0.1.0 (file:///projects/rectangle)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
     Running unittests src/lib.rs (target/debug/deps/rectangle-6584c4561e48942e)

running 2 tests
test tests::larger_can_hold_smaller ... FAILED
test tests::smaller_cannot_hold_larger ... ok

failures:

---- tests::larger_can_hold_smaller stdout ----

thread 'tests::larger_can_hold_smaller' (6020788) panicked at src/lib.rs:28:9:
assertion failed: larger.can_hold(&smaller)
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::larger_can_hold_smaller

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

error: test failed, to rerun pass `--lib`

เทสต์ของเราสามารถตรวจจับบั๊กได้ทันที! เนื่องจาก larger.width มีค่าเป็น 8 และ smaller.width มีค่าเป็น 5 การเปรียบเทียบความกว้างใน can_hold ตอนนี้จึงได้ผลลัพธ์เป็น false: เพราะ 8 ไม่ได้น้อยกว่า 5

การทดสอบความเท่ากันด้วย assert_eq! และ assert_ne!

วิธีทั่วไปในการตรวจสอบการทำงานของโค้ดคือ การทดสอบความเท่ากันระหว่างผลลัพธ์ที่ได้จากการทำงานจริงกับค่าที่เราคาดหวังไว้ คุณสามารถทำสิ่งนี้ได้โดยใช้มาโคร assert! แล้วส่งเอ็กซ์เพรสชันที่ใช้ตัวดำเนินการเปรียบเทียบ == เข้าไป อย่างไรก็ตาม รูปแบบการทดสอบเช่นนี้พบได้บ่อยมากจนไลบรารีมาตรฐานได้จัดเตรียมมาโครคู่หนึ่งมาให้โดยเฉพาะ นั่นคือ assert_eq! และ assert_ne! เพื่อให้การทดสอบสะดวกสบายยิ่งขึ้น มาโครทั้งสองจะเปรียบเทียบอาร์กิวเมนต์ 2 ตัวเพื่อดูว่าเท่ากันหรือไม่เท่ากันตามลำดับ และที่สำคัญคือ หากการยืนยันค่านั้นล้มเหลว มาโครเหล่านี้จะพิมพ์ค่าของอาร์กิวเมนต์ทั้งสองตัวออกมาให้เห็นด้วย ซึ่งช่วยให้เราทราบได้ทันทีว่า_เหตุใด_เทสต์จึงล้มเหลว ในทางตรงกันข้าม มาโคร assert! จะบอกเพียงแค่ว่าเอ็กซ์เพรสชัน == ได้ผลลัพธ์เป็น false โดยไม่แสดงให้เห็นค่าที่นำไปสู่ผลลัพธ์ false นั้นเลย

ในลิสติ้ง 11-7 เราได้เขียนฟังก์ชันชื่อ add_two ที่จะนำ 2 ไปบวกเข้ากับพารามิเตอร์ของมัน จากนั้นจึงทำการทดสอบฟังก์ชันนี้ด้วยมาโคร assert_eq!

pub fn add_two(a: u64) -> u64 {
    a + 2
}

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

    #[test]
    fn it_adds_two() {
        let result = add_two(2);
        assert_eq!(result, 4);
    }
}

มาตรวจสอบว่ามันผ่านกันเถอะ!

$ cargo test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.58s
     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)

running 1 test
test tests::it_adds_two ... ok

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

   Doc-tests adder

running 0 tests

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

เราสร้างตัวแปรชื่อ result เพื่อเก็บผลลัพธ์จากการเรียก add_two(2) จากนั้นส่ง result และ 4 เป็นอาร์กิวเมนต์ให้กับมาโคร assert_eq! ผลการทดสอบสำหรับเทสต์นี้คือ test tests::it_adds_two ... ok ซึ่งข้อความ ok เป็นตัวบ่งชี้ว่าเทสต์ของเราผ่านเรียบร้อย!

คราวนี้มาลองใส่บั๊กลงในโค้ดเพื่อดูว่าเมื่อมาโคร assert_eq! ล้มเหลวจะมีหน้าตาเป็นอย่างไร โดยแก้ไขการทำงานของฟังก์ชัน add_two ให้บวกด้วย 3 แทน:

pub fn add_two(a: u64) -> u64 {
    a + 3
}

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

    #[test]
    fn it_adds_two() {
        let result = add_two(2);
        assert_eq!(result, 4);
    }
}

รันเทสต์อีกครั้ง:

$ cargo test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.61s
     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)

running 1 test
test tests::it_adds_two ... FAILED

failures:

---- tests::it_adds_two stdout ----

thread 'tests::it_adds_two' (6020955) panicked at src/lib.rs:12:9:
assertion `left == right` failed
  left: 5
 right: 4
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::it_adds_two

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

error: test failed, to rerun pass `--lib`

เทสต์ของเราตรวจจับบั๊กได้อีกแล้ว! เทสต์ tests::it_adds_two ล้มเหลว และข้อความรายงานว่าแอสเซอร์ชันที่ล้มเหลวคือ left == right พร้อมทั้งแสดงให้เห็นชัดเจนว่าค่า left และ right คืออะไร ข้อความนี้ช่วยให้เราเริ่มดีบักได้ทันที: อาร์กิวเมนต์ฝั่งซ้าย (left) ซึ่งเก็บผลลัพธ์จากการเรียก add_two(2) มีค่าเป็น 5 ในขณะที่อาร์กิวเมนต์ฝั่งขวา (right) มีค่าเป็น 4 คุณคงจินตนาการได้ว่าสิ่งนี้มีประโยชน์มหาศาลเพียงใด โดยเฉพาะเมื่อเรามีชุดทดสอบจำนวนมากที่กำลังรันอยู่

โปรดสังเกตว่า ในบางภาษาและบางเฟรมเวิร์กการทดสอบ พารามิเตอร์สำหรับฟังก์ชันตรวจสอบความเท่ากันมักจะใช้ชื่อว่า expected (ค่าที่คาดหวัง) และ actual (ค่าที่ได้จริง) ซึ่งลำดับการส่งอาร์กิวเมนต์จะมีผลต่อความหมายอย่างมาก แต่ใน Rust พารามิเตอร์เหล่านี้จะเรียกว่า left และ right ดังนั้นลำดับการส่งระหว่างค่าที่เราคาดหวังกับค่าที่โค้ดสร้างขึ้นจึงไม่มีความแตกต่างกัน เราสามารถเขียนแอสเซอร์ชันในเทสต์นี้เป็น assert_eq!(4, result) ก็ได้ ซึ่งจะให้ข้อความแสดงความล้มเหลวแบบเดียวกันว่า assertion `left == right` failed

สำหรับมาโคร assert_ne! จะผ่านเมื่อค่าสองค่าที่ส่งเข้าไปไม่เท่ากัน และจะล้มเหลวหากค่าทั้งสองเท่ากัน มาโครนี้มีประโยชน์อย่างยิ่งในกรณีที่เราไม่อาจทราบแน่ชัดว่าค่าลัพธ์_จะต้อง_เป็นอะไร แต่เรารู้ได้อย่างแน่นอนว่าค่านั้น_ต้องไม่ใช่_อะไร ตัวอย่างเช่น หากเรากำลังทดสอบฟังก์ชันที่รับประกันว่าจะต้องแปลงค่าอินพุตเป็นอย่างอื่นเสมอ แต่วิธีการแปลงขึ้นอยู่กับวันในสัปดาห์ที่เรารันเทสต์ สิ่งที่ดีที่สุดในการยืนยันผลลัพธ์อาจเป็นการตรวจสอบว่าผลลัพธ์ที่ได้ออกมาจะต้องไม่เท่ากับอินพุตเดิม

เบื้องหลังการทำงาน มาโคร assert_eq! และ assert_ne! จะใช้ตัวดำเนินการ == และ != ตามลำดับ และเมื่อแอสเซอร์ชันล้มเหลว มาโครเหล่านี้จะพิมพ์ค่าของอาร์กิวเมนต์ออกมาด้วยรูปแบบการแสดงผลแบบดีบัก (debug formatting) นั่นหมายความว่าค่าที่นำมาเปรียบเทียบกันจะต้องอิมพลีเมนต์เทรต PartialEq และ Debug เสมอ โดยชนิดข้อมูลพื้นฐานทั้งหมดรวมถึงชนิดข้อมูลส่วนใหญ่ในไลบรารีมาตรฐานต่างก็ได้อิมพลีเมนต์เทรตเหล่านี้ไว้เรียบร้อยแล้ว สำหรับ struct และ enum ที่คุณนิยามขึ้นเอง คุณจำเป็นต้องอิมพลีเมนต์ PartialEq เพื่อให้สามารถตรวจสอบความเท่ากันได้ และต้องอิมพลีเมนต์ Debug เพื่อให้สามารถพิมพ์ค่าออกมาได้เมื่อการตรวจสอบล้มเหลว เนื่องจากเทรตทั้งสองเป็นเทรตที่สามารถทำ derive ได้ (derivable traits) ดังที่กล่าวไว้ในลิสติ้ง 5-12 ของบทที่ 5 โดยทั่วไปจึงทำได้ง่ายๆ เพียงเพิ่มแอนโนเทชัน #[derive(PartialEq, Debug)] กำกับไว้ที่นิยาม struct หรือ enum ของคุณเท่านั้น ดูภาคผนวก C “เทรตที่ derive ได้” สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับเทรตเหล่านี้และเทรตอื่นๆ ที่ derive ได้

การเพิ่มข้อความความล้มเหลวแบบกำหนดเอง

คุณยังสามารถเพิ่มข้อความแบบกำหนดเอง (custom message) เพื่อให้พิมพ์ออกมาพร้อมกับข้อความแจ้งความล้มเหลวได้ โดยส่งเป็นอาร์กิวเมนต์เพิ่มเติมให้กับมาโคร assert!, assert_eq!, และ assert_ne! อาร์กิวเมนต์ใดๆ ที่ใส่ต่อท้ายอาร์กิวเมนต์บังคับจะถูกส่งต่อไปยังมาโคร format! (ซึ่งเราเคยพูดถึงใน“การเชื่อมด้วย + หรือ format!” ในบทที่ 8) คุณจึงสามารถส่งสตริงรูปแบบ (format string) ที่มีตัวยึดตำแหน่ง {} พร้อมค่าที่จะนำไปแทนที่ในตัวยึดตำแหน่งเหล่านั้นได้ ข้อความกำหนดเองเหล่านี้มีประโยชน์อย่างมากในการอธิบายความหมายของแอสเซอร์ชันนั้นๆ เมื่อเทสต์เกิดล้มเหลว คุณจะเข้าใจได้รวดเร็วยิ่งขึ้นว่าปัญหาที่แท้จริงของโค้ดคืออะไร

ตัวอย่างเช่น สมมติว่าเรามีฟังก์ชันสำหรับกล่าวคำทักทายผู้คนตามชื่อ และเราต้องการทดสอบว่าชื่อที่เราส่งเข้าไปในฟังก์ชันปรากฏอยู่ในข้อความเอาต์พุตจริงๆ หรือไม่:

ชื่อไฟล์: src/lib.rs

pub fn greeting(name: &str) -> String {
    format!("Hello {name}!")
}

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

    #[test]
    fn greeting_contains_name() {
        let result = greeting("Carol");
        assert!(result.contains("Carol"));
    }
}

ข้อกำหนด (requirements) ของโปรแกรมนี้ยังไม่ได้ข้อสรุปที่แน่นอน และเราค่อนข้างมั่นใจว่าข้อความ Hello ในช่วงต้นของคำทักทายอาจมีการเปลี่ยนแปลงในภายหลัง เราจึงไม่อยากต้องมาคอยอัปเดตเทสต์ทุกครั้งที่ข้อกำหนดเปลี่ยน ดังนั้นแทนที่จะตรวจสอบความเท่ากันแบบตรงตัวทุกตัวอักษรกับค่าที่ส่งคืนจากฟังก์ชัน greeting เราจะเลือกตรวจสอบเพียงว่าข้อความเอาต์พุตมีชื่อจากพารามิเตอร์อินพุตรวมอยู่ด้วยหรือไม่

คราวนี้มาลองใส่บั๊กลงในโค้ด โดยเปลี่ยนฟังก์ชัน greeting ไม่ให้นำ name ไปใส่ในผลลัพธ์ เพื่อดูว่าข้อความความล้มเหลวเริ่มต้นของเทสต์จะมีหน้าตาเป็นอย่างไร:

pub fn greeting(name: &str) -> String {
    String::from("Hello!")
}

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

    #[test]
    fn greeting_contains_name() {
        let result = greeting("Carol");
        assert!(result.contains("Carol"));
    }
}

การรันเทสต์นี้ให้ผลลัพธ์ดังนี้:

$ cargo test
   Compiling greeter v0.1.0 (file:///projects/greeter)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.91s
     Running unittests src/lib.rs (target/debug/deps/greeter-170b942eb5bf5e3a)

running 1 test
test tests::greeting_contains_name ... FAILED

failures:

---- tests::greeting_contains_name stdout ----

thread 'tests::greeting_contains_name' (6021143) panicked at src/lib.rs:12:9:
assertion failed: result.contains("Carol")
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::greeting_contains_name

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

error: test failed, to rerun pass `--lib`

ผลลัพธ์นี้บอกเพียงแค่ว่าแอสเซอร์ชันล้มเหลวและอยู่ที่บรรทัดใด แต่ข้อความความล้มเหลวที่มีประโยชน์กว่านั้นควรจะพิมพ์ค่าที่ได้จริงจากฟังก์ชัน greeting ออกมาด้วย ให้เราเพิ่มข้อความแจ้งความล้มเหลวแบบกำหนดเอง ซึ่งประกอบด้วยสตริงรูปแบบที่มีตัวยึดตำแหน่งสำหรับใส่ค่าจริงที่ได้รับจากฟังก์ชัน greeting:

pub fn greeting(name: &str) -> String {
    String::from("Hello!")
}

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

    #[test]
    fn greeting_contains_name() {
        let result = greeting("Carol");
        assert!(
            result.contains("Carol"),
            "Greeting did not contain name, value was `{result}`"
        );
    }
}

ตอนนี้เมื่อเรารันเทสต์ เราจะได้ข้อความแสดงข้อผิดพลาดที่ให้ข้อมูลมากกว่าเดิม:

$ cargo test
   Compiling greeter v0.1.0 (file:///projects/greeter)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.93s
     Running unittests src/lib.rs (target/debug/deps/greeter-170b942eb5bf5e3a)

running 1 test
test tests::greeting_contains_name ... FAILED

failures:

---- tests::greeting_contains_name stdout ----

thread 'tests::greeting_contains_name' (6021333) panicked at src/lib.rs:12:9:
Greeting did not contain name, value was `Hello!`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::greeting_contains_name

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

error: test failed, to rerun pass `--lib`

เราสามารถมองเห็นค่าที่ได้รับมาจริงๆ ในเอาต์พุตของเทสต์ ซึ่งช่วยให้เราดีบักได้ทันทีว่าเกิดอะไรขึ้น แทนที่จะเห็นแค่สิ่งที่เราคาดหวังว่าจะเกิดขึ้น

การตรวจสอบการแพนิกด้วย should_panic

นอกเหนือจากการตรวจสอบค่าที่ส่งคืนแล้ว การตรวจสอบว่าโค้ดของเราจัดการกับเงื่อนไขข้อผิดพลาดได้อย่างถูกต้องตามที่คาดหวังหรือไม่ก็มีความสำคัญไม่แพ้กัน ตัวอย่างเช่น ชนิดข้อมูล Guess ที่เราสร้างขึ้นในบทที่ 9 ลิสติ้ง 9-13 โค้ดส่วนอื่นๆ ที่เรียกใช้ Guess จะพึ่งพาการรับประกันว่าอินสแตนซ์ของ Guess จะเก็บเฉพาะค่าที่อยู่ระหว่าง 1 ถึง 100 เท่านั้น เราจึงสามารถเขียนเทสต์เพื่อตรวจสอบให้มั่นใจได้ว่าความพยายามสร้างอินสแตนซ์ Guess ด้วยค่าที่อยู่นอกช่วงดังกล่าวจะต้องเกิดการแพนิกขึ้น

เราทำเช่นนี้ได้โดยการเพิ่มแอตทริบิวต์ should_panic ให้กับฟังก์ชันเทสต์ เทสต์จะถือว่าผ่านหากโค้ดภายในฟังก์ชันเกิดการแพนิก และจะถือว่าล้มเหลวหากโค้ดภายในฟังก์ชันไม่เกิดการแพนิก

ลิสติ้ง 11-8 แสดงเทสต์ที่ตรวจสอบว่าเงื่อนไขข้อผิดพลาดของ Guess::new เกิดขึ้นเมื่อเราคาดหวังให้มันเกิดขึ้น

pub struct Guess {
    value: i32,
}

impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1 || value > 100 {
            panic!("Guess value must be between 1 and 100, got {value}.");
        }

        Guess { value }
    }
}

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

    #[test]
    #[should_panic]
    fn greater_than_100() {
        Guess::new(200);
    }
}

เราจะวางแอตทริบิวต์ #[should_panic] ไว้ถัดจากแอตทริบิวต์ #[test] บนบรรทัดก่อนหน้าฟังก์ชันเทสต์ที่ต้องการใช้ มาดูผลลัพธ์เมื่อเทสต์นี้ผ่าน:

$ cargo test
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.58s
     Running unittests src/lib.rs (target/debug/deps/guessing_game-57d70c3acb738f4d)

running 1 test
test tests::greater_than_100 - should panic ... ok

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

   Doc-tests guessing_game

running 0 tests

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

ดูดี! ตอนนี้มาใส่บั๊กในโค้ดของเราโดยลบเงื่อนไขที่ว่าฟังก์ชัน new จะแพนิกหากค่ามากกว่า 100:

pub struct Guess {
    value: i32,
}

// --snip--
impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1 {
            panic!("Guess value must be between 1 and 100, got {value}.");
        }

        Guess { value }
    }
}

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

    #[test]
    #[should_panic]
    fn greater_than_100() {
        Guess::new(200);
    }
}

เมื่อเรารันเทสต์ในลิสติ้ง 11-8 มันจะล้มเหลว:

$ cargo test
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.62s
     Running unittests src/lib.rs (target/debug/deps/guessing_game-57d70c3acb738f4d)

running 1 test
test tests::greater_than_100 - should panic ... FAILED

failures:

---- tests::greater_than_100 stdout ----
note: test did not panic as expected at src/lib.rs:21:8

failures:
    tests::greater_than_100

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

error: test failed, to rerun pass `--lib`

ในกรณีนี้เราไม่ได้ข้อความที่ช่วยอะไรมากนัก แต่เมื่อเราดูฟังก์ชันเทสต์ เราจะเห็นว่ามันถูกกำกับด้วย #[should_panic] ความล้มเหลวที่เราได้หมายความว่าโค้ดในฟังก์ชันเทสต์ไม่ได้ทำให้เกิดการแพนิก

การทดสอบด้วย should_panic เพียงอย่างเดียวอาจขาดความแม่นยำ เพราะเทสต์จะผ่านเสมอขอเพียงแค่เกิดการแพนิกขึ้น ไม่ว่าการแพนิกนั้นจะเกิดจากสาเหตุที่เราคาดไว้ หรือเกิดจากสาเหตุอื่นที่คาดไม่ถึงก็ตาม เพื่อให้เทสต์ should_panic มีความแม่นยำยิ่งขึ้น เราสามารถระบุพารามิเตอร์ expected เสริมเข้าไปในแอตทริบิวต์ should_panic ได้ โดยระบบรันทดสอบ (test harness) จะคอยตรวจสอบว่าข้อความแสดงการแพนิกนั้นมีข้อความที่เรากำหนดไว้รวมอยู่ด้วยหรือไม่ ตัวอย่างเช่น โค้ดของ Guess ที่ปรับปรุงใหม่ในลิสติ้ง 11-9 ซึ่งฟังก์ชัน new จะแพนิกด้วยข้อความที่แตกต่างกัน ขึ้นอยู่กับว่าค่าที่ส่งเข้ามามีขนาดเล็กเกินไปหรือใหญ่เกินไป

pub struct Guess {
    value: i32,
}

// --snip--

impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1 {
            panic!(
                "Guess value must be greater than or equal to 1, got {value}."
            );
        } else if value > 100 {
            panic!(
                "Guess value must be less than or equal to 100, got {value}."
            );
        }

        Guess { value }
    }
}

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

    #[test]
    #[should_panic(expected = "less than or equal to 100")]
    fn greater_than_100() {
        Guess::new(200);
    }
}

เทสต์นี้จะผ่านได้เนื่องจากค่าที่เราระบุไว้ในพารามิเตอร์ expected ของแอตทริบิวต์ should_panic เป็นสตริงย่อย (substring) ของข้อความที่ฟังก์ชัน Guess::new แพนิกออกมา เราจะเลือกใส่ข้อความแพนิกแบบเต็มทั้งหมดตามที่คาดหวังก็ได้ ซึ่งในกรณีนี้คือ Guess value must be less than or equal to 100, got 200 สิ่งที่คุณเลือกระบุขึ้นอยู่กับว่าข้อความแพนิกส่วนไหนที่มีความเฉพาะเจาะจงหรือมีการเปลี่ยนแปลงตามตัวแปร และคุณต้องการให้การทดสอบมีความแม่นยำเพียงใด ในกรณีนี้ เพียงแค่สตริงย่อยของข้อความแพนิกก็เพียงพอที่จะยืนยันได้แล้วว่าโค้ดในฟังก์ชันเทสต์ได้ทำงานตรงตามกรณี else if value > 100 จริงๆ

เพื่อดูว่าจะเกิดอะไรขึ้นเมื่อเทสต์ should_panic ที่มีข้อความ expected ล้มเหลว มาลองใส่บั๊กลงในโค้ดอีกครั้ง โดยสลับเนื้อหาภายในบล็อก if value < 1 กับ else if value > 100:

pub struct Guess {
    value: i32,
}

impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1 {
            panic!(
                "Guess value must be less than or equal to 100, got {value}."
            );
        } else if value > 100 {
            panic!(
                "Guess value must be greater than or equal to 1, got {value}."
            );
        }

        Guess { value }
    }
}

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

    #[test]
    #[should_panic(expected = "less than or equal to 100")]
    fn greater_than_100() {
        Guess::new(200);
    }
}

ครั้งนี้เมื่อเรารันเทสต์ should_panic มันจะล้มเหลว:

$ cargo test
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
     Running unittests src/lib.rs (target/debug/deps/guessing_game-57d70c3acb738f4d)

running 1 test
test tests::greater_than_100 - should panic ... FAILED

failures:

---- tests::greater_than_100 stdout ----

thread 'tests::greater_than_100' (6021675) panicked at src/lib.rs:12:13:
Guess value must be greater than or equal to 1, got 200.
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: panic did not contain expected string
      panic message: "Guess value must be greater than or equal to 1, got 200."
 expected substring: "less than or equal to 100"

failures:
    tests::greater_than_100

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

error: test failed, to rerun pass `--lib`

ข้อความแสดงความล้มเหลวชี้แจงว่า เทสต์นี้เกิดการแพนิกขึ้นจริงๆ ตามที่คาดไว้ แต่ข้อความของการแพนิกกลับไม่มีสตริงที่คาดหวังคือ less than or equal to 100 รวมอยู่ด้วย โดยข้อความแพนิกที่เราได้รับจริงในกรณีนี้คือ Guess value must be greater than or equal to 1, got 200 ตอนนี้เราจึงรู้จุดเริ่มต้นในการตามหาบั๊กในโค้ดของเราได้ทันที!

การใช้ Result<T, E> ในเทสต์

เทสต์ทั้งหมดที่เราเขียนมาจนถึงตอนนี้จะใช้วิธีการแพนิกเมื่อการทดสอบล้มเหลว แต่เรายังสามารถเขียนเทสต์โดยใช้ชนิดข้อมูล Result<T, E> ได้อีกด้วย! นี่คือเทสต์จากลิสติ้ง 11-1 ที่ถูกเขียนขึ้นใหม่ให้ใช้ Result<T, E> และส่งคืนค่า Err แทนที่จะเป็นการแพนิก:

pub fn add(left: u64, right: u64) -> u64 {
    left + right
}

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

    #[test]
    fn it_works() -> Result<(), String> {
        let result = add(2, 2);

        if result == 4 {
            Ok(())
        } else {
            Err(String::from("two plus two does not equal four"))
        }
    }
}

ฟังก์ชัน it_works ในตอนนี้มีชนิดข้อมูลที่ส่งคืนเป็น Result<(), String> โดยภายในเนื้อหาของฟังก์ชัน แทนที่เราจะเรียกใช้มาโคร assert_eq! เราจะส่งคืน Ok(()) เมื่อเทสต์ผ่าน และส่งคืน Err ที่บรรจุข้อความ String ไว้ข้างในเมื่อเทสต์ล้มเหลว

การเขียนเทสต์ให้ส่งคืน Result<T, E> ช่วยให้คุณสามารถใช้งานตัวดำเนินการเครื่องหมายคำถาม (?) ภายในเนื้อหาของเทสต์ได้ ซึ่งเป็นวิธีที่สะดวกมากในการเขียนเทสต์ที่ควรล้มเหลวทันทีหากมีการดำเนินการใดๆ ภายในส่งคืนวาเรียนต์ Err ออกมา

คุณไม่สามารถใช้แอนโนเทชัน #[should_panic] กับเทสต์ที่ใช้ Result<T, E> ได้ หากต้องการยืนยันว่าการดำเนินการหนึ่งคืนค่าวาเรียนต์ Err อย่า ใช้ตัวดำเนินการเครื่องหมายคำถามกับค่า Result<T, E> แต่ให้ใช้ assert!(value.is_err()) แทน

เมื่อคุณได้เรียนรู้วิธีการเขียนเทสต์หลากหลายรูปแบบแล้ว ต่อไปเรามาดูสิ่งที่เกิดขึ้นเมื่อสั่งรันเทสต์ และสำรวจตัวเลือกคำสั่งต่างๆ ที่เราสามารถใช้งานร่วมกับ cargo test ได้