以这种方式调用目标允许 function 设置调用的环境。这非常有用，例如，用于模糊测试 Substrate 外部性。

no_auto_generate

不要尝试为该目标自动生成语料库文件。

only_generic_args

在运行测试时记录目标泛型参数，但不生成语料库文件，也不实现模糊测试框架。当目标是泛型函数，但不确定应该使用哪些类型参数进行模糊测试时，这可能很有用。

预期的流程是：启用only_generic_args，然后运行cargo test，然后运行cargo test-fuzz --display generic-args。结果中的一个泛型参数可能可以用作generic_args的parameters。同样，由cargo test-fuzz --display impl-generic-args产生的泛型参数可能可以用作impl_generic_args的parameters。

但是请注意，即使目标在测试期间以某些参数被调用，这并不意味着当使用这些参数时，目标的参数是可序列化/反序列化的。`--display generic-args`/`--display impl-generic-args`的结果只是建议性的。

重命名= "名称"

在将模块添加到封装作用域时，将目标视为具有name的名称。`test_fuzz`宏的展开向封装作用域添加了一个模块定义。默认情况下，模块的名称如下

• 如果目标不出现在impl块中，模块的名称为target_fuzz，其中target是目标的名称。
• 如果目标出现在impl块中，模块的名称为path_target_fuzz，其中path是impl's Self类型的路径，将其转换为蛇形并使用_连接。

但是，使用此选项会导致模块被命名为name_fuzz。例如

#[test_fuzz(rename = "bar")]
fn foo() {}

// Without the use of `rename`, a name collision and compile error would result.
mod foo_fuzz {}

test_fuzz_impl 宏

每当在impl块中使用test_fuzz宏时，必须在该impl之前使用test_fuzz_impl宏。例如

#[test_fuzz_impl]
impl Foo {
    #[test_fuzz]
    fn bar(&self, x: &str) {
        ...
    }
}

此要求的原因如下。《test_fuzz》宏的展开向封装作用域添加了一个模块定义。然而，模块定义不能出现在impl块中。在impl之前使用test_fuzz_impl宏会导致模块添加到impl块之外。

如果您看到以下类似的错误，则很可能意味着缺少对test_fuzz_impl宏的使用

error: module is not supported in `trait`s or `impl`s

test_fuzz_impl目前没有选项。

cargo test-fuzz 命令

使用cargo test-fuzz命令与模糊目标进行交互，并操作它们的语料库、崩溃、挂起和工作队列。示例调用包括

1. 列出模糊目标

   cargo test-fuzz --list
   

2. 显示目标 foo 的语料库

   cargo test-fuzz foo --display corpus
   

3. 模糊目标 foo

   cargo test-fuzz foo
   

4. 重放针对目标 foo 找到的崩溃

   cargo test-fuzz foo --replay crashes
   

用法

Usage: cargo test-fuzz [OPTIONS] [TARGETNAME] [-- <ARGS>...]

Arguments:
  [TARGETNAME]  String that fuzz target's name must contain
  [ARGS]...     Arguments for the fuzzer

Options:
      --backtrace                 Display backtraces
      --consolidate               Move one target's crashes, hangs, and work queue to its corpus; to
                                  consolidate all targets, use --consolidate-all
      --cpus <N>                  Fuzz using at most <N> cpus; default is all but one
      --display <OBJECT>          Display corpus, crashes, generic args, `impl` generic args, hangs,
                                  or work queue. By default, an uninstrumented fuzz target is used.
                                  To display with instrumentation, append `-instrumented` to
                                  <OBJECT>, e.g., --display corpus-instrumented.
      --exact                     Target name is an exact name rather than a substring
      --exit-code                 Exit with 0 if the time limit was reached, 1 for other
                                  programmatic aborts, and 2 if an error occurred; implies --no-ui,
                                  does not imply --run-until-crash or --max-total-time <SECONDS>
      --features <FEATURES>       Space or comma separated list of features to activate
      --list                      List fuzz targets
      --manifest-path <PATH>      Path to Cargo.toml
      --max-total-time <SECONDS>  Fuzz at most <SECONDS> of time (equivalent to -- -V <SECONDS>)
      --no-default-features       Do not activate the `default` feature
      --no-run                    Compile, but don't fuzz
      --no-ui                     Disable user interface
  -p, --package <PACKAGE>         Package containing fuzz target
      --persistent                Enable persistent mode fuzzing
      --pretty                    Pretty-print debug output when displaying/replaying
      --replay <OBJECT>           Replay corpus, crashes, hangs, or work queue. By default, an
                                  uninstrumented fuzz target is used. To replay with instrumentation
                                  append `-instrumented` to <OBJECT>, e.g., --replay
                                  corpus-instrumented.
      --reset                     Clear fuzzing data for one target, but leave corpus intact; to
                                  reset all targets, use --reset-all
      --resume                    Resume target's last fuzzing session
      --run-until-crash           Stop fuzzing once a crash is found
      --slice <SECONDS>           If there are not sufficiently many cpus to fuzz all targets
                                  simultaneously, fuzz them in intervals of <SECONDS> [default:
                                  1200]
      --test <NAME>               Integration test containing fuzz target
      --timeout <TIMEOUT>         Number of seconds to consider a hang when fuzzing or replaying
                                  (equivalent to -- -t <TIMEOUT * 1000> when fuzzing)
      --verbose                   Show build output when displaying/replaying
  -h, --help                      Print help
  -V, --version                   Print version

Try `cargo afl fuzz --help` to see additional fuzzer options.

便利函数和宏

警告： 这些实用工具不包括在语义版本控制中，并且可能在 test-fuzz 的未来版本中被移除。

dont_care!

dont_care! 宏可用于实现易于构造且不需要记录值的类型的 serde::Serialize/serde::Deserialize。直观上，dont_care!($ty, $expr) 表示

• 序列化时跳过类型 $ty 的值。
• 反序列化时，使用 $expr 初始化类型 $ty 的值。

impl serde::Serialize for $ty {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        ().serialize(serializer)
    }
}

impl<'de> serde::Deserialize<'de> for $ty {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        <()>::deserialize(deserializer).map(|_| $expr)
    }
}

leak!(X, LeakedX);

#[test_fuzz::test_fuzz(convert = "&X, LeakedX")

#[derive(Clone, std::fmt::Debug, serde::Deserialize, serde::Serialize)]
struct $ident(<$ty as ToOwned>::Owned);

impl From<&$ty> for $ident {
    fn from(ty: &$ty) -> Self {
        Self(ty.to_owned())
    }
}

impl test_fuzz::Into<&$ty> for $ident {
    fn into(self) -> &'static $ty {
        Box::leak(Box::new(self.0))
    }
}

fn serialize_ref<S, T>(x: &&T, serializer: S) -> Result<S::Ok, S::Error>
where
    S: serde::Serializer,
    T: serde::Serialize,
{
    <T as serde::Serialize>::serialize(*x, serializer)
}

fn deserialize_ref<'de, D, T>(deserializer: D) -> Result<&'static T, D::Error>
where
    D: serde::Deserializer<'de>,
    T: serde::de::DeserializeOwned + std::fmt::Debug,
{
    let x = <T as serde::de::Deserialize>::deserialize(deserializer)?;
    Ok(Box::leak(Box::new(x)))
}

test-fuzz = { version = "*", features = ["cast_checks"] }