Allow filtering observed functions and add debug functions for that

Author: loiclec

fuzzcheck/Cargo.toml

@@ -44,6 +44,7 @@ regex-syntax = { version = "0.6.27", optional = true }
 nu-ansi-term = "0.46.0"
 
 bit-vec = "0.6.3"
+rustc-demangle = "0.1.21"
 
 [lib]
 name = "fuzzcheck"

fuzzcheck/src/builder.rs

@@ -433,6 +433,22 @@ where
     V: Clone + 'static,
     M: Mutator<V>,
 {
+    #[no_coverage]
+    pub fn default_sensor_and_pool_with_custom_filter(
+        self,
+        keep: impl Fn(&Path, &str) -> bool,
+    ) -> FuzzerBuilder4<F, M, V, DiverseAndMaxHitsSensor, BasicAndDiverseAndMaxHitsPool> {
+        let (sensor, pool) = default_sensor_and_pool_with_custom_filter(keep).finish();
+        FuzzerBuilder4 {
+            test_function: self.test_function,
+            mutator: self.mutator,
+            serializer: self.serializer,
+            sensor,
+            pool,
+            _phantom: PhantomData,
+        }
+    }
+
     #[no_coverage]
     pub fn default_sensor_and_pool(
         self,
@@ -715,6 +731,20 @@ pub fn basic_sensor_and_pool() -> SensorAndPoolBuilder<BasicSensor, BasicPool> {
     }
 }
 
+/// Like [`basic_sensor_and_pool`], but uses a closure to determine which function should
+/// be observed by the code coverage sensor.
+#[no_coverage]
+pub fn basic_sensor_and_pool_with_custom_filter(
+    keep: impl Fn(&Path, &str) -> bool,
+) -> SensorAndPoolBuilder<BasicSensor, BasicPool> {
+    let sensor = CodeCoverageSensor::new(keep);
+    let nbr_counters = sensor.count_instrumented;
+    SensorAndPoolBuilder {
+        sensor,
+        pool: SimplestToActivateCounterPool::new("simplest_cov", nbr_counters),
+    }
+}
+
 /// Create the [sensor and pool builder](SensorAndPoolBuilder) that is used by default by fuzzcheck
 ///
 /// Currently, the result cannot be augmented any further. Thus, the only action you can take on the result is to
@@ -725,6 +755,18 @@ pub fn default_sensor_and_pool() -> SensorAndPoolBuilder<DiverseAndMaxHitsSensor
         .find_most_diverse_set_of_test_cases(20)
         .find_test_cases_repeatedly_hitting_coverage_counters()
 }
+
+/// Like [`default_sensor_and_pool`], but uses a closure to determine which function should
+/// be observed by the code coverage sensor.
+#[no_coverage]
+pub fn default_sensor_and_pool_with_custom_filter(
+    keep: impl Fn(&Path, &str) -> bool,
+) -> SensorAndPoolBuilder<DiverseAndMaxHitsSensor, BasicAndDiverseAndMaxHitsPool> {
+    basic_sensor_and_pool_with_custom_filter(keep)
+        .find_most_diverse_set_of_test_cases(20)
+        .find_test_cases_repeatedly_hitting_coverage_counters()
+}
+
 /// A builder to create a [sensor](Sensor) and [pool](crate::Pool) that can be given as argument to
 /// [`FuzzerBuilder3::sensor_and_pool`].
 ///

fuzzcheck/src/code_coverage_sensor/mod.rs

@@ -5,7 +5,7 @@ mod llvm_coverage;
 #[cfg(feature = "serde_json_serializer")]
 mod serialized;
 
-use std::collections::HashMap;
+use std::collections::{BTreeSet, HashMap};
 use std::convert::TryFrom;
 use std::path::{Path, PathBuf};
 
@@ -38,13 +38,13 @@ impl CodeCoverageSensor {
     pub fn observing_only_files_from_current_dir() -> Self {
         Self::new(
             #[no_coverage]
-            |f| f.is_relative(),
+            |file, _function| file.is_relative(),
         )
     }
     #[no_coverage]
     pub fn new<K>(keep: K) -> Self
     where
-        K: Fn(&Path) -> bool,
+        K: Fn(&Path, &str) -> bool,
     {
         let exec = std::env::current_exe().expect("could not read current executable");
         let LLVMCovSections {
@@ -160,3 +160,30 @@ impl SaveToStatsFolder for CodeCoverageSensor {
         }
     }
 }
+
+impl CodeCoverageSensor {
+    #[no_coverage]
+    pub fn print_observed_functions(&self) {
+        let mut all = BTreeSet::new();
+        for c in self.coverage.iter() {
+            let name = &c.function_record.name_function;
+            let name = rustc_demangle::demangle(name).to_string();
+            all.insert(name.clone());
+        }
+        for name in all {
+            println!("{name}");
+        }
+    }
+    #[no_coverage]
+    pub fn print_observed_files(&self) {
+        let mut all = BTreeSet::new();
+        for c in self.coverage.iter() {
+            for name in c.function_record.filenames.iter() {
+                all.insert(name.display().to_string());
+            }
+        }
+        for name in all {
+            println!("{name}");
+        }
+    }
+}