provide for cargo afl, but it is not complete.

.github/.cspell/project-dictionary.txt

@@ -23,3 +23,10 @@ winapi
 xargo
 Xdemangler
 xtask
+addseeds
+cmin
+gotcpu
+showmap
+tmin
+whatsup
+LOOPCOUNT

docs/cargo-llvm-cov-afl.txt

@@ -0,0 +1,26 @@
+cargo-llvm-cov-afl
+
+Use cargo llvm-cov afl to fuzz test your Rust projects with American Fuzzy Lop (AFL), a powerful fuzz testing tool that automatically finds bugs by feeding unexpected inputs to your programs.
+
+SUBCOMMANDS:
+  addseeds       Invoke afl-addseeds
+  analyze        Invoke afl-analyze
+  cmin           Invoke afl-cmin
+  config         Build or rebuild AFL++
+  fuzz           Invoke afl-fuzz
+  gotcpu         Invoke afl-gotcpu
+  plot           Invoke afl-plot
+  showmap        Invoke afl-showmap
+  system-config  Invoke afl-system-config (beware, called with sudo!)
+  tmin           Invoke afl-tmin
+  whatsup        Invoke afl-whatsup
+  help           Print this message or the help of the given subcommand(s)
+
+Arguments:
+  [ARGS]...  
+
+Options:
+  -h, --help     Print help
+  -V, --version  Print version
+
+In addition to the subcommands above, Cargo subcommands are also supported (see `cargo help` for a list of all Cargo subcommands).

src/cli.rs

@@ -947,6 +947,9 @@ pub(crate) enum Subcommand {
     /// Build and archive tests with cargo nextest
     NextestArchive,
 
+    /// Run afl with cargo nextest
+    Afl,
+
     // internal (unstable)
     Demangle,
 }
@@ -960,6 +963,7 @@ static CARGO_LLVM_COV_SHOW_ENV_USAGE: &str = include_str!("../docs/cargo-llvm-co
 static CARGO_LLVM_COV_NEXTEST_USAGE: &str = include_str!("../docs/cargo-llvm-cov-nextest.txt");
 static CARGO_LLVM_COV_NEXTEST_ARCHIVE_USAGE: &str =
     include_str!("../docs/cargo-llvm-cov-nextest-archive.txt");
+static CARGO_LLVM_COV_AFL_USAGE: &str = include_str!("../docs/cargo-llvm-cov-afl.txt");
 
 impl Subcommand {
     fn can_passthrough(subcommand: Self) -> bool {
@@ -976,6 +980,7 @@ impl Subcommand {
             Self::ShowEnv => CARGO_LLVM_COV_SHOW_ENV_USAGE,
             Self::Nextest { .. } => CARGO_LLVM_COV_NEXTEST_USAGE,
             Self::NextestArchive => CARGO_LLVM_COV_NEXTEST_ARCHIVE_USAGE,
+            Self::Afl => CARGO_LLVM_COV_AFL_USAGE,
             Self::Demangle => "", // internal API
         }
     }
@@ -990,6 +995,7 @@ impl Subcommand {
             Self::ShowEnv => "show-env",
             Self::Nextest { .. } => "nextest",
             Self::NextestArchive => "nextest-archive",
+            Self::Afl => "afl",
             Self::Demangle => "demangle",
         }
     }
@@ -1011,6 +1017,7 @@ impl FromStr for Subcommand {
             "show-env" => Ok(Self::ShowEnv),
             "nextest" => Ok(Self::Nextest { archive_file: false }),
             "nextest-archive" => Ok(Self::NextestArchive),
+            "afl" => Ok(Self::Afl),
             "demangle" => Ok(Self::Demangle),
             _ => bail!("unrecognized subcommand {s}"),
         }

src/main.rs

@@ -107,6 +107,15 @@ fn try_main() -> Result<()> {
             create_dirs(cx)?;
             archive_nextest(cx)?;
         }
+        Subcommand::Afl => {
+            let cx = &Context::new(args)?;
+            clean::clean_partial(cx)?;
+            create_dirs(cx)?;
+            run_afl(cx)?;
+            if !cx.args.cov.no_report {
+                generate_report(cx)?;
+            }
+        }
         Subcommand::None | Subcommand::Test => {
             let cx = &Context::new(args)?;
             clean::clean_partial(cx)?;
@@ -498,6 +507,63 @@ fn run_run(cx: &Context) -> Result<()> {
     Ok(())
 }
 
+fn run_afl(cx: &Context) -> Result<()> {
+    let mut cargo = cx.cargo();
+
+    set_env(cx, &mut cargo, IsNextest(false))?;
+
+    let input_dir = "inputs/";
+    let output_dir = "outputs/";
+
+    fs::create_dir_all(input_dir)?;
+    fs::create_dir_all(output_dir)?;
+
+    if !cx.args.ignore_run_fail {
+        {
+            let mut cargo = cargo.clone();
+
+            cargo.arg("afl").arg("build");
+            cargo.arg("--target-dir").arg(cx.ws.target_dir.as_str());
+            if term::verbose() {
+                status!("Running", "{cargo}");
+                cargo.stdout_to_stderr().run()?;
+            } else {
+                // Capture output to prevent duplicate warnings from appearing in two runs.
+                cargo.run_with_output()?;
+            }
+        }
+
+        // prepare seeds
+        let seeds = vec!["example input 1", "sample data 2", "test case 3"];
+
+        for (index, seed) in seeds.into_iter().enumerate() {
+            let file_path = format!("{input_dir}seed_{index}.txt");
+            let path = Path::new(&file_path);
+            let mut file = fs::File::create(path)?;
+            file.write_all(seed.as_bytes())?;
+        }
+
+        // set afl's loop count to 1000 to avoid AFL loop infinitely!
+        // AFL maybe exits a process several minutes later and produce a cov file.
+        cargo.set("AFL_FUZZER_LOOPCOUNT", "20")?;
+        cargo.arg("afl").arg("fuzz");
+        cargo.arg("-V").arg("10");
+        // set in and out
+        cargo.arg("-i").arg(input_dir);
+        cargo.arg("-o").arg(output_dir);
+        // set the executable
+        let bin_file = cx.ws.target_dir.join("debug").join(cx.ws.name.clone()).to_string();
+        cargo.arg(bin_file.as_str());
+
+        if term::verbose() {
+            status!("Running", "{cargo}");
+        }
+        stdout_to_stderr(cx, &mut cargo);
+        cargo.run()?;
+    }
+    Ok(())
+}
+
 fn stdout_to_stderr(cx: &Context, cargo: &mut ProcessBuilder) {
     if cx.args.cov.no_report
         || cx.args.cov.output_dir.is_some()