Silence fuzz build unused import warnings

[rust-lightning] / fuzz / src / bin / msg_update_add_htlc_target.rs

diff --git a/fuzz/src/bin/msg_update_add_htlc_target.rs b/fuzz/src/bin/msg_update_add_htlc_target.rs
index cc8f67306a28c7b1944fd3abf2fc6bcbcc044a64..b4b9bc9f34dda28709458eefa861714fb0d640c6 100644 (file)
--- a/fuzz/src/bin/msg_update_add_htlc_target.rs
+++ b/fuzz/src/bin/msg_update_add_htlc_target.rs
@@ -1,14 +1,11 @@
 // This file is auto-generated by gen_target.sh based on target_template.txt
 // To modify it, modify target_template.txt and run gen_target.sh instead.
 
-//Uncomment this for libfuzzer builds:
-//#![no_main]
+#![cfg_attr(feature = "libfuzzer_fuzz", no_main)]
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_update_add_htlc::*;
 
-use std::io::Read;
-
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
@@ -38,7 +35,59 @@ fuzz_target!(|data: &[u8]| {
 
 #[cfg(feature = "stdin_fuzz")]
 fn main() {
+       use std::io::Read;
+
        let mut data = Vec::with_capacity(8192);
        std::io::stdin().read_to_end(&mut data).unwrap();
        msg_update_add_htlc_run(data.as_ptr(), data.len());
 }
+
+#[test]
+fn run_test_cases() {
+       use std::fs;
+       use std::io::Read;
+       use lightning_fuzz::utils::test_logger::StringBuffer;
+
+       use std::sync::{atomic, Arc};
+       {
+               let data: Vec<u8> = vec![0];
+               msg_update_add_htlc_run(data.as_ptr(), data.len());
+       }
+       let mut threads = Vec::new();
+       let threads_running = Arc::new(atomic::AtomicUsize::new(0));
+       if let Ok(tests) = fs::read_dir("test_cases/msg_update_add_htlc") {
+               for test in tests {
+                       let mut data: Vec<u8> = Vec::new();
+                       let path = test.unwrap().path();
+                       fs::File::open(&path).unwrap().read_to_end(&mut data).unwrap();
+                       threads_running.fetch_add(1, atomic::Ordering::AcqRel);
+
+                       let thread_count_ref = Arc::clone(&threads_running);
+                       let main_thread_ref = std::thread::current();
+                       threads.push((path.file_name().unwrap().to_str().unwrap().to_string(),
+                               std::thread::spawn(move || {
+                                       let string_logger = StringBuffer::new();
+
+                                       let panic_logger = string_logger.clone();
+                                       let res = if ::std::panic::catch_unwind(move || {
+                                               msg_update_add_htlc_test(&data, panic_logger);
+                                       }).is_err() {
+                                               Some(string_logger.into_string())
+                                       } else { None };
+                                       thread_count_ref.fetch_sub(1, atomic::Ordering::AcqRel);
+                                       main_thread_ref.unpark();
+                                       res
+                               })
+                       ));
+                       while threads_running.load(atomic::Ordering::Acquire) > 32 {
+                               std::thread::park();
+                       }
+               }
+       }
+       for (test, thread) in threads.drain(..) {
+               if let Some(output) = thread.join().unwrap() {
+                       println!("Output of {}:\n{}", test, output);
+                       panic!();
+               }
+       }
+}