Rust 是被设计成用来开发高正确性程序的编程语言,运用了静态类型来增加程序的可靠性,也用了拥有权、生命周期等等的概念来保证程序的安全性。虽然 Rust 强大的编译器会替我们做很多代码方面的检查,但是程序逻辑上的正确性,就无法依靠它来验证了。
举例来说,我们实作了一个 add_two 函数,这个函数可以透过参数传入一个整数值,并且回传其加上 2 之后的结果。Rust 的编译器虽然可以在编译阶段时检查传进来的参数类型有没有错误,以及是不是已经被借用了,但是编译器并无法直接借由判断函数名称 add_two,就去推论这个函数就是要把参数的值加上 2 之后回传。如果我们不小心实作错了,使得 add_two 函数回传参数的值乘上 2 的结果,编译器是无法检查出来的。为了解决这个问题,我们必须要有另外的程序来验证 add_two 函数的运行结果,这项工作就称为测试(testing)。简单来说,我们可以写个程序,将数值 3 传给 add_two 函数的参数,并判断 add_two 函数的回传值是不是 5,如果不是,代表 add_two 函数的实作有错误。
测试是个复杂的技术,在这个章节中,我们会将重点放在如何使用 Rust 编程语言本身提供的机制来做测试。
如何撰写测试?
在先前的章节中我们有创建出 Cargo 的函数库项目,并且稍微了解到加上 #[cfg(test)] 的模块在运行 cargo test 指令的时候其底下有被加上 #[test] 的函数会被运行。没错,我们可以说,Rust 的「测试」就是一个函数,这个函数被用来验证其它非测试函数的函数(没有加上 #[test] 的函数)所实作的功能。测试函数的主体,通常会有以下三个行为:
2. 运行我们要测试的程序(例如要被测试的函数)。
3. 验证程序运行之后的结果是不是跟我们预期的一样。
测试函数,就是将函数使用 #[] 语法,并且给它一个 test 属性(attribute)。属性代表着一段 Rust 的代码,例如我们先前使用过的 derive 属性,将结构体加上 derive 属性之后,就可以替该结构体用预设的关联函数和方法来实作指定的特性。test 属性的作用是让一个函数变成测试用的函数,在使用 cargo test 指令时,就会自动产生出调用这些测试函数的程序,来运行这些测试函数,并且回报测试的结果。
我们先创建出一个新的 Cargo 函数库项目 adder。
接着看一下项目内的 lib.rs 文件。如下:
pub fn add(left: usize, right: usize) -> usize {
left + right
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_works() {
let result = add(2, 2);
assert_eq!(result, 4);
}
}
我们先忽略第 5 行的 #[cfg(test)] 属性,直接从第 9 行的 #[test] 属性开始讲起。以上程序,由于 it_works 函数被加上 #[test] 属性,因此它是一个测试函数。而 assert_eq! 宏有两个参数,第一个参数是我们要判断的值,第二个参数是我们预期第一个参数会是什么的值。如果传入 assert_eq! 宏的两个值并不相同,程序就会发生 panic。
运行 cargo test 指令看看,结果如下:
cargo test 指令会编译项目并自动产生出来一个主程序,然后运行。借由这支自动产生出来的主程序来运行所有的测试函数,我们可以大致依据其输出结果,将测试以「Doc-tests」(文档测试)为界线,以上就是测试函数的测试结果,以下是文档测试的结果。有关于 Rust 的文档,之后的章节会介绍,这边也先不管它。看一下测试函数的测试结果的部份,这支主程序会告诉我们总共有多少测试(测试函数的总数量)、是否通过所有测试、每个测试函数的运行结果、测试成功的数量、测试失败的数量、忽略测试的数量、性能测试(benchmark)的数量、被过滤掉的数量。这些数量的总和就是测试函数的总数量。
我们尝试在 tests 模块中再定义一个新的测试函数 another,并直接在其主体内使用 panic! 宏。如下:
pub fn add(left: usize, right: usize) -> usize {
left + right
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_works() {
let result = add(2, 2);
assert_eq!(result, 4);
}
#[test]
fn another() {
panic!("Make this test fail");
}
}
运行 cargo test 指令看看,结果如下:
由于 another 函数让程序发生 panic,表示这个测试函数并没有办法通过测试,除了测试结果的部份会出现测试失败的消息外,主程序还会将该测试函数所输出到标准输出和标准错误的文字印出来;如果该测试函数通过测试,其输出到标准输出和标准错误的文字就不会显示。
assert! 是一个方便用来撰写测试程序的宏,它可以传入一个布尔类型的参数,这个参数若不为 true,程序就会 panic。举例来说:
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: 7,
height: 8,
};
let smaller = Rectangle {
width: 5,
height: 1,
};
assert!(larger.can_hold(&smaller));
}
#[test]
fn smaller_cannot_hold_larger() {
let larger = Rectangle {
width: 7,
height: 8,
};
let smaller = Rectangle {
width: 5,
height: 1,
};
assert!(!smaller.can_hold(&larger));
}
}
以上的 larger_can_hold_smaller 和 smaller_cannot_hold_larger 两个测试函数,会测试 Rectangle 结构实体的 can_hold 方法的逻辑是否正确。不熟悉测试的人可能会觉得写这样的程序很累赘,原本没几行的程序还要多加好几个测试函数来测试,但只有这样才可以真正确保每个函数的程序逻辑,大大地降低程序发生问题的概率,也可以省下后期维护程序的功夫。
回到我们刚刚创建的 Cargo 函数库项目 adder 上吧!
先将 lib.rs 文件修改成:
pub fn add_two(a: i32) -> i32 {
a + 2
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_adds_two() {
assert_eq!(4, add_two(2));
}
}
运行 cargo test 指令看看,结果如下:
我们可以透过指令运行之后,测试主程序产生出来的消息,得知 it_adds_two 测试函数的测试结果是正确的。
如果将程序第 2 行的 a + 2 改成 a + 3:
pub fn add_two(a: i32) -> i32 {
a + 3
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_adds_two() {
assert_eq!(4, add_two(2));
}
}
运行 cargo test 指令,结果如下:
因为 assert_eq! 宏传入的两个参数不相等,会使得程序 panic,所以 it_adds_two 测试函数的测试结果就会是失败的,并且出现能协助我们调试的错误消息。
除了 assert_eq! 宏之外还有 assert_ne! 宏,它可以被用来判断传入的两个参数是否不相等,如果相等就会让程序发生 panic。
assert!、assert_eq! 和 assert_ne! 都是在写测试函数时会很常用到的宏,除了可以判断参数传进的值是否为 true、相同或是不相同来让程序发生 panic 外,它们也可以像是使用 panic! 宏一样,自订程序发生 panic 时要输出的消息,只要将消息的参数接在要判断的参数之后即可。如下:
pub fn add_two(a: i32) -> i32 {
a + 3
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_adds_two() {
let result = add_two(2);
assert_eq!(4, result, "4 != {result}");
}
}
运行 cargo test 指令,结果如下:
另外,对于有些程序逻辑,「运行函数导致程序发生 panic」是正常的行为,因为是有意为之的。但是我们在测试函数中调用这个函数后,这个函数就会让程序发生 panic,使得测试函数的测试结果被主程序判定为测试失败,然而我们的逻辑却是认为程序发生 panic 是正确的结果。这时该怎么处理呢?我们可以对发生 panic 为正常现象的测试函数,加上 #[should_panic] 属性。如下:
pub fn add_two(a: i32) -> i32 {
if a < 0 {
panic!("`a` shoud not smaller than zero, but `a` = {a}");
}
a + 2
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[should_panic]
fn it_adds_two() {
add_two(-1);
}
}
运行 cargo test 指令,结果如下:
当然,加上 #[should_panic] 属性,就会导致非预期的不可恢复错误也被当成是正确的结果,为了解决这个问题,我们要限制 #[should_panic] 属性的行为。可以对 #[should_panic] 属性加上 expected 参数来指定预期的 panic 的错误消息是什么。如下:
pub fn add_two(a: i32) -> i32 {
if a < 0 {
panic!("`a` shoud not smaller than zero, but `a` = {a}");
}
a + 2
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[should_panic(expected = "`a` shoud not smaller than zero, but `a` = -1")]
fn it_adds_two() {
add_two(-1);
}
}
如果 it_adds_two 测试函数运行时发生 panic,且错误消息为 `a` shoud not smaller than zero, but `a` = -1,测试主程序让这个 it_adds_two 测试函数通过测试。如果程序发生 panic,但却是其它的错误消息,或是程序没有发生 panic 的话,测试主程序就会将这个 it_adds_two 测试函数标记为测试失败。
cargo test 指令预设会使用多线程(thread)来运行所有的测试函数,且由于是使用多线程运行的关系,我们必须要让测试函数彼此的数据和状态各自独立。举例来说,假设有多个测试函数都要对同一个文件进行写入,此时使用 cargo test 指令就很有可能会造成文件写入异常,出现不可预期的错误。如果想要只用单线程来运行测试函数的话,可以替测试主程序加上 --test-threads 参数,来设置线程的数量。指令如下:
先前有提到,cargo test 指令会编译项目并自动产生出来一个主程序,然后运行。在 cargo test 和 --test-threads 选项之间还有一个 --,就是要用来区隔 cargo test 指令本身的选项和传递给 cargo test 指令所产生的主程序的参数。
cargo test 指令预设也不会将通过测试的测试函数所印出的东西显示出来,如果要将其显示,可以替测试主程序加上 --nocapture 参数。指令如下:
如果只想测试单一个测试函数,而不是所有的测试函数的话,在 cargo test 后直接接上要测试的测试函数名称即可。例如:
事实上,以上指令只要测试函数的名称有包含 it_adds_two 的话,例如 it_adds_two_1、it_adds_two_panic,都会被运行到。所以如果只想测试某几个测试函数,假设目前有 add_two_and_two 和 add_three_and_two 两个测试函数要测试,指令如下:
如果想让指定的测试函数在运行 cargo test 指令时不被运行,可以替该函数加上 #[ignore] 属性,测试时即可忽略它。需要很长时间来测试的测试函数可以将它们加上 #[ignore] 属性,可以缩短 cargo test 指令的运行时间。当我们有时间进行长时间的测试时,可以替测试主程序加上 --ignored 参数,来过滤掉没有 #[ignore] 属性的测试函数,并运行有 #[ignore] 属性的测试函数。指令如下:
Rust 编程语言将测试分为单元测试(unit tests)和集成测试(integration tests)。单元测试针对单一功能进行测试,会去测试模块内部私有的界面。集成测试是应用于函数库之外的测试,以外部程序使用这个函数库的角度来对整个函数库进行测试。
单元测试
我们可以将单元测试的程序和要测试的程序撰写在同一个文件,定义出一个模块,将其加上 #[cfg(test)] 属性,这个模块就只会在使用 cargo test 指令的时候才会被编译,因此不用担心写愈多的测试会导致 cargo build 指令编译出来的程序愈肥,且编译时间也不会变得愈久。将使用 #[test] 属性定义出来的测试函数放入这个使用 #[cfg(test)] 属性来定义的模块,在使用 cargo test 指令的时候才会被编译运行。
Rust 编程语言之所以会把单元测试以模块为单位来进行,并且与要测试的程序写在同一个文件,就是为了要让单元测试能够深及内部私有成员。先前我们有学到模块和子模块的用法,一个模块就是一个文件,也就是说每个文件都可以撰写其自己的单元测试模块,不用担心要测试的项目究竟是不是有用 pub 关键字设为公开的。
集成测试
要从外部对程序进行测试,我们可以在程序项目的根目录内置立一个 tests 目录,这个目录文件内的每个 Rust 程序源代码文件都是独立的 crate,也是独立的测试主程序。使用 cargo test 指令来编译并且运行主程序内所定义的测试函数。
举例来说,继续先前的 adder 程序项目,我们在程序项目的根目录内置立一个 tests 目录,并在 tests 目录中创建 integration_test.rs 文件,文件内容如下:
#[test]
fn it_adds_two() {
assert_eq!(4, adder::add_two(2));
}
运行 cargo test 指令,结果如下:
可以发现到,cargo test 指令除了有运行原先单元测试时的 target/debug/deps/adder-f12a4ff0ee820d36 测试主程序之外,还有运行到刚才增加的集成测试主程序 target/debug/deps/integration_test-4df8fa857a707db9。
预设的 cargo test 指令会编译并运行 tests 目录底下所有的 Rust 程序源代码文件,如果只想要指定一个来运行,可以加上 --test 参数,后面接上要编译并运行的 Rust 程序源代码的文件名称。举例来说,如果我们只想编译并运行 tests 目录中的 integration_test.rs 文件,指令如下:
tests 目录中的 Rust 程序也可以使用子模块的文件系统结构,但是如果没有使用创建新目录的方式在 tests 目录中存放子模块的代码的话,在使用 cargo test 指令时,这个子模块还是会被编译成独立的测试主程序来运行。另外,集成测试无法在 src 目录内只有 main.rs 文件而没有 lib.rs 文件的应用程序项目下使用。
总结
Rust 编程语言运用了模块、属性和文件系统的结构提供了基本的单元测试与集成测试机制,可以帮助我们减少程序逻辑上的错误。在下一章节中,我们要来实作一个完整、拥有 CLI 的应用程序项目。
下一章:制作 grep 命令行程序。







