Lib.rs

QuickCheck 是一种使用随机生成的输入进行属性测试的方法。该软件包包含随机生成和缩小整数、浮点数、元组、布尔值、列表、字符串、选项和结果的能力。QuickCheck 所需的只是一个属性函数——然后它将随机生成该函数的输入并针对每组输入调用属性。如果属性失败（无论是由于运行时错误，如索引越界，还是不满足您的属性），则输入将被“缩小”以找到更小的反例。

列表和数字的缩小策略使用二分搜索快速覆盖输入空间。（它应该与 Koen Claessen 的 Haskell QuickCheck 中使用的相同策略。）

MIT 或 UNLICENSE 双许可。

文档

API 已完全文档化： http://burntsushi.net/rustdoc/quickcheck/.

简单示例

以下是一个测试反转向量的函数的示例

#[cfg(test)]
#[macro_use]
extern crate quickcheck;

fn reverse<T: Clone>(xs: &[T]) -> Vec<T> {
    let mut rev = vec!();
    for x in xs.iter() {
        rev.insert(0, x.clone())
    }
    rev
}

#[cfg(test)]
mod tests {
  quickcheck! {
      fn prop(xs: Vec<u32>) -> bool {
          xs == reverse(&reverse(&xs))
      }
  }
}

此示例使用 quickcheck! 宏，该宏在稳定 Rust 中可用。

#[quickcheck] 属性（需要 Rust 夜间版本）

为了更容易编写 QuickCheck 测试，#[quickcheck] 属性将属性函数转换为 #[test] 函数。

要使用 #[quickcheck] 属性，您必须启用 plugin 功能并将 quickcheck_macros 软件包作为语法扩展导入

#![feature(plugin)]
#![plugin(quickcheck_macros)]

#[cfg(test)]
extern crate quickcheck;

#[cfg(test)]
mod tests {
    fn reverse<T: Clone>(xs: &[T]) -> Vec<T> {
        let mut rev = vec!();
        for x in xs {
            rev.insert(0, x.clone())
        }
        rev
    }

    #[quickcheck]
    fn double_reversal_is_identity(xs: Vec<isize>) -> bool {
        xs == reverse(&reverse(&xs))
    }
}

安装

quickcheck 在 crates.io 上，因此您可以将它包含到项目中，如下所示

[dependencies]
quickcheck = "0.3"

如果您的测试代码中只使用了 quickcheck，则可以将它添加为开发依赖项

[dev-dependencies]
quickcheck = "0.3"

如果您想使用 #[quickcheck] 属性，请添加 quickcheck_macros

[dev-dependencies]
quickcheck = "0.3"
quickcheck_macros = "0.2"

并只为测试构建启用 quickcheck_macros 插件

#![cfg_attr(test, feature(plugin))]
#![cfg_attr(test, plugin(quickcheck_macros))]

注意，当 Rust 1.0 稳定版发布时，#[quickcheck] 宏将不会工作，尽管它将在夜间构建中继续工作。

注意：当使用 quickcheck（无论是直接使用还是通过属性）时，RUST_LOG=quickcheck 启用 info! 以显示有用的输出（如通过测试的数量）。这不是显示失败证据所需的。

丢弃测试结果（或，属性是多态的！）

有时您只想测试对于可能输入的 子集 而言成立的属性，所以当您的属性被给定一个在这个子集之外的输入时，您会丢弃它。特别是，属性应该在您想要测试的子集之外的输入上既不通过也不失败。但是属性返回布尔值——这表示通过或失败。

为了解决这个问题，我们需要退后一步，看看 quickcheck 函数的类型

pub fn quickcheck<A: Testable>(f: A) {
    // elided
}

所以 quickcheck 可以测试任何满足 Testable 特质的类型。很好，那么这个 Testable 是什么意思？

pub trait Testable {
    fn result<G: Gen>(&self, &mut G) -> TestResult;
}

此特质表明，如果类型可以给定一个随机数源产生一个 TestResult，则类型是可测试的。（TestResult 存储有关测试结果的信息，例如它是否通过、失败或被丢弃。）

确实如此，bool 满足 Testable 特质

impl Testable for bool {
    fn result<G: Gen>(&self, _: &mut G) -> TestResult {
        TestResult::from_bool(*self)
    }
}

但在示例中，我们向 quickcheck 提供了一个 函数。是的，函数也可以满足 Testable！

impl<A: Arbitrary + Debug, B: Testable> Testable for fn(A) -> B {
    fn result<G: Gen>(&self, g: &mut G) -> TestResult {
        // elided
    }
}

这意味着一个函数满足 Testable，当且仅当它有一个单一参数类型（其值可以随机生成和缩小）并返回任何类型（也满足 Testable）。因此，类型为 fn(usize) -> bool 的函数满足 Testable，因为 usize 满足 Arbitrary 且 bool 满足 Testable。

所以，为了丢弃一个测试，我们需要返回除了 bool 之外的东西。如果我们直接返回一个 TestResult 会怎样？那应该可以工作，但我们需要确保 TestResult 满足 Testable

impl Testable for TestResult {
    fn result<G: Gen>(&self, _: &mut G) -> TestResult { self.clone() }
}

现在我们可以直接测试返回 TestResult 的函数。

作为一个例子，让我们测试我们的 reverse 函数，以确保长度为 1 的向量的反转等于自身。

fn prop(xs: Vec<isize>) -> TestResult {
    if xs.len() != 1 {
        return TestResult::discard()
    }
    TestResult::from_bool(xs == reverse(&xs))
}
quickcheck(prop as fn(Vec<isize>) -> TestResult);

（此示例的完整工作程序在 examples/reverse_single.rs。）

现在我们的属性返回一个 TestResult，这使我们能够编码更多的信息。为 TestResult 类型定义了一些额外的便捷函数。[更多详情](http://burntsushi.net/rustdoc/quickcheck/struct.TestResult.html) 。例如，我们不能只是返回一个 bool，所以我们将一个 bool 值转换为 TestResult。

（忽略测试的能力可以让你获得类似 Haskell 的 ==> 组合子。）

fn reverse<T: Clone>(xs: &[T]) -> Vec<T> {
    let mut rev = vec![];
    for i in 1..xs.len() {
        rev.insert(0, xs[i].clone())
    }
    rev
}

fn prop(xs: Vec<isize>) -> bool {
    xs == reverse(&reverse(&xs))
}
quickcheck(prop as fn(Vec<isize>) -> bool);

[quickcheck] TEST FAILED. Arguments: ([-17, 13, -12, 17, -8, -10, 15, -19,
-19, -9, 11, -5, 1, 19, -16, 6])

[quickcheck] TEST FAILED. Arguments: ([0])

fn sieve(n: usize) -> Vec<usize> {
    if n <= 1 {
        return vec![];
    }

    let mut marked = vec![false; n+1];
    marked[0] = true;
    marked[1] = true;
    marked[2] = true;
    for p in 2..n {
        for i in (2*p..n).filter(|&n| n % p == 0) {
            marked[i] = true;
        }
    }
    marked.iter()
          .enumerate()
          .filter_map(|(i, &m)| if m { None } else { Some(i) })
          .collect()
}

sieve(3) => [2, 3]
sieve(5) => [2, 3, 5]
sieve(8) => [2, 3, 5, 7, 8] # !!!

fn is_prime(n: usize) -> bool {
    n != 0 && n != 1 && (2..).take_while(|i| i*i <= n).all(|i| n % i != 0)
}

fn prop_all_prime(n: usize) -> bool {
    sieve(n).into_iter().all(is_prime)
}

fn main() {
    quickcheck(prop_all_prime as fn(usize) -> bool);
}

[quickcheck] TEST FAILED. Arguments: (4)

for i in (2*p..n).filter(|&n| n % p == 0) {
    marked[i] = true;
}

fn prop_prime_iff_in_the_sieve(n: usize) -> bool {
    sieve(n) == (0..(n + 1)).filter(|&i| is_prime(i)).collect::<Vec<_>>()
}

fn main() {
    quickcheck(prop_all_prime as fn(usize) -> bool);
    quickcheck(prop_prime_iff_in_the_sieve as fn(usize) -> bool);
}

[quickcheck] TEST FAILED. Arguments: (2)