วิธีเขียนเทสต์
เทสต์ (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 ได้