Rename coverage to coverage-legacy (#2685)

src/agent/coverage-legacy/examples/src-cov.rs

@@ -0,0 +1,143 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+use std::{process::Command, process::Stdio};
+
+use anyhow::Result;
+use coverage_legacy::block::CommandBlockCov as Coverage;
+use coverage_legacy::cache::ModuleCache;
+use coverage_legacy::code::CmdFilter;
+use structopt::StructOpt;
+
+#[derive(Debug, PartialEq, Eq, StructOpt)]
+struct Opt {
+    #[structopt(short, long, min_values = 1)]
+    inputs: Vec<PathBuf>,
+
+    #[structopt(short, long)]
+    dir: Option<PathBuf>,
+
+    #[structopt(min_values = 2)]
+    cmd: Vec<String>,
+
+    #[structopt(short, long, long_help = "Timeout in ms", default_value = "120000")]
+    timeout: u64,
+
+    #[structopt(short = "x", long)]
+    cobertura_xml: bool,
+}
+
+fn main() -> Result<()> {
+    let opt = Opt::from_args();
+    let filter = CmdFilter::default();
+
+    let mut cache = ModuleCache::default();
+    let mut total = Coverage::default();
+    let timeout = Duration::from_millis(opt.timeout);
+
+    if let Some(dir) = &opt.dir {
+        for entry in std::fs::read_dir(dir)? {
+            let input = entry?.path();
+
+            eprintln!("testing input: {}", input.display());
+
+            let cmd = input_command(&opt.cmd, &input);
+            let coverage = record(&mut cache, filter.clone(), cmd, timeout)?;
+
+            total.merge_max(&coverage);
+        }
+    }
+
+    for input in &opt.inputs {
+        eprintln!("testing input: {}", input.display());
+
+        let cmd = input_command(&opt.cmd, input);
+        let coverage = record(&mut cache, filter.clone(), cmd, timeout)?;
+
+        total.merge_max(&coverage);
+    }
+
+    let mut debug_info = coverage_legacy::debuginfo::DebugInfo::default();
+    let src_coverage = total.source_coverage(&mut debug_info)?;
+
+    if opt.cobertura_xml {
+        let cobertura = coverage_legacy::cobertura::cobertura(src_coverage)?;
+        println!("{}", cobertura);
+    } else {
+        for file_coverage in src_coverage.files {
+            for location in &file_coverage.locations {
+                println!(
+                    "{} {}:{}",
+                    location.count, file_coverage.file, location.line
+                );
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn input_command(argv: &[String], input: &Path) -> Command {
+    let mut cmd = Command::new(&argv[0]);
+    cmd.stdin(Stdio::null());
+    cmd.stderr(Stdio::null());
+    cmd.stdout(Stdio::null());
+
+    let args: Vec<_> = argv[1..]
+        .iter()
+        .map(|a| {
+            if a == "@@" {
+                input.display().to_string()
+            } else {
+                a.to_string()
+            }
+        })
+        .collect();
+
+    cmd.args(&args);
+
+    cmd
+}
+
+#[cfg(target_os = "linux")]
+fn record(
+    cache: &mut ModuleCache,
+    filter: CmdFilter,
+    cmd: Command,
+    timeout: Duration,
+) -> Result<Coverage> {
+    use coverage_legacy::block::linux::Recorder;
+
+    let now = std::time::Instant::now();
+
+    let coverage = Recorder::record(cmd, timeout, cache, filter)?;
+
+    let elapsed = now.elapsed();
+    log::info!("recorded in {:?}", elapsed);
+
+    Ok(coverage)
+}
+
+#[cfg(target_os = "windows")]
+fn record(
+    cache: &mut ModuleCache,
+    filter: CmdFilter,
+    cmd: Command,
+    timeout: Duration,
+) -> Result<Coverage> {
+    use coverage_legacy::block::windows::{Recorder, RecorderEventHandler};
+
+    let mut recorder = Recorder::new(cache, filter);
+    let mut handler = RecorderEventHandler::new(&mut recorder, timeout);
+
+    let now = std::time::Instant::now();
+
+    handler.run(cmd)?;
+
+    let elapsed = now.elapsed();
+    log::info!("recorded in {:?}", elapsed);
+
+    Ok(recorder.into_coverage())
+}