Thread fuzz test cases

fuzz/Cargo.toml

@@ -37,6 +37,10 @@ members = ["."]
 lto = true
 codegen-units = 1
 
+# When testing a large fuzz corpus, -O1 offers a nice speedup
+[profile.dev]
+opt-level = 1
+
 [lib]
 name = "lightning_fuzz"
 path = "src/lib.rs"

fuzz/src/bin/chanmon_consistency_target.rs

@@ -45,15 +45,48 @@ fn main() {
 
 #[test]
 fn run_test_cases() {
-	let mut data: Vec<u8> = vec![0];
-	chanmon_consistency_run(data.as_ptr(), data.len());
+	use lightning_fuzz::utils::test_logger::StringBuffer;
+
+	use std::sync::{atomic, Arc};
+	{
+		let data: Vec<u8> = vec![0];
+		chanmon_consistency_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/chanmon_consistency") {
 		for test in tests {
-			data.clear();
+			let mut data: Vec<u8> = Vec::new();
 			let path = test.unwrap().path();
-			println!("Running test {}...", path.file_name().unwrap().to_str().unwrap());
-			fs::File::open(path).unwrap().read_to_end(&mut data).unwrap();
-			chanmon_consistency_run(data.as_ptr(), data.len());
+			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 || {
+						chanmon_consistency_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!();
 		}
 	}
 }

fuzz/src/bin/chanmon_deser_target.rs

@@ -45,15 +45,48 @@ fn main() {
 
 #[test]
 fn run_test_cases() {
-	let mut data: Vec<u8> = vec![0];
-	chanmon_deser_run(data.as_ptr(), data.len());
+	use lightning_fuzz::utils::test_logger::StringBuffer;
+
+	use std::sync::{atomic, Arc};
+	{
+		let data: Vec<u8> = vec![0];
+		chanmon_deser_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/chanmon_deser") {
 		for test in tests {
-			data.clear();
+			let mut data: Vec<u8> = Vec::new();
 			let path = test.unwrap().path();
-			println!("Running test {}...", path.file_name().unwrap().to_str().unwrap());
-			fs::File::open(path).unwrap().read_to_end(&mut data).unwrap();
-			chanmon_deser_run(data.as_ptr(), data.len());
+			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 || {
+						chanmon_deser_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!();
 		}
 	}
 }

fuzz/src/bin/full_stack_target.rs

@@ -45,15 +45,48 @@ fn main() {
 
 #[test]
 fn run_test_cases() {
-	let mut data: Vec<u8> = vec![0];
-	full_stack_run(data.as_ptr(), data.len());
+	use lightning_fuzz::utils::test_logger::StringBuffer;
+
+	use std::sync::{atomic, Arc};
+	{
+		let data: Vec<u8> = vec![0];
+		full_stack_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/full_stack") {
 		for test in tests {
-			data.clear();
+			let mut data: Vec<u8> = Vec::new();
 			let path = test.unwrap().path();
-			println!("Running test {}...", path.file_name().unwrap().to_str().unwrap());
-			fs::File::open(path).unwrap().read_to_end(&mut data).unwrap();
-			full_stack_run(data.as_ptr(), data.len());
+			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 || {
+						full_stack_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!();
 		}
 	}
 }

fuzz/src/bin/msg_accept_channel_target.rs

@@ -45,15 +45,48 @@ fn main() {
 
 #[test]
 fn run_test_cases() {
-	let mut data: Vec<u8> = vec![0];
-	msg_accept_channel_run(data.as_ptr(), data.len());
+	use lightning_fuzz::utils::test_logger::StringBuffer;
+
+	use std::sync::{atomic, Arc};
+	{
+		let data: Vec<u8> = vec![0];
+		msg_accept_channel_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_accept_channel") {
 		for test in tests {
-			data.clear();
+			let mut data: Vec<u8> = Vec::new();
 			let path = test.unwrap().path();
-			println!("Running test {}...", path.file_name().unwrap().to_str().unwrap());
-			fs::File::open(path).unwrap().read_to_end(&mut data).unwrap();
-			msg_accept_channel_run(data.as_ptr(), data.len());
+			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_accept_channel_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!();
 		}
 	}
 }

fuzz/src/bin/msg_announcement_signatures_target.rs

@@ -45,15 +45,48 @@ fn main() {
 
 #[test]
 fn run_test_cases() {
-	let mut data: Vec<u8> = vec![0];
-	msg_announcement_signatures_run(data.as_ptr(), data.len());
+	use lightning_fuzz::utils::test_logger::StringBuffer;
+
+	use std::sync::{atomic, Arc};
+	{
+		let data: Vec<u8> = vec![0];
+		msg_announcement_signatures_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_announcement_signatures") {
 		for test in tests {
-			data.clear();
+			let mut data: Vec<u8> = Vec::new();
 			let path = test.unwrap().path();
-			println!("Running test {}...", path.file_name().unwrap().to_str().unwrap());
-			fs::File::open(path).unwrap().read_to_end(&mut data).unwrap();
-			msg_announcement_signatures_run(data.as_ptr(), data.len());
+			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_announcement_signatures_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!();
 		}
 	}
 }

fuzz/src/bin/msg_channel_announcement_target.rs

@@ -45,15 +45,48 @@ fn main() {
 
 #[test]
 fn run_test_cases() {
-	let mut data: Vec<u8> = vec![0];
-	msg_channel_announcement_run(data.as_ptr(), data.len());
+	use lightning_fuzz::utils::test_logger::StringBuffer;
+
+	use std::sync::{atomic, Arc};
+	{
+		let data: Vec<u8> = vec![0];
+		msg_channel_announcement_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_channel_announcement") {
 		for test in tests {
-			data.clear();
+			let mut data: Vec<u8> = Vec::new();
 			let path = test.unwrap().path();
-			println!("Running test {}...", path.file_name().unwrap().to_str().unwrap());
-			fs::File::open(path).unwrap().read_to_end(&mut data).unwrap();
-			msg_channel_announcement_run(data.as_ptr(), data.len());
+			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_channel_announcement_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!();
 		}
 	}
 }

fuzz/src/bin/msg_channel_reestablish_target.rs

@@ -45,15 +45,48 @@ fn main() {
 
 #[test]
 fn run_test_cases() {
-	let mut data: Vec<u8> = vec![0];
-	msg_channel_reestablish_run(data.as_ptr(), data.len());
+	use lightning_fuzz::utils::test_logger::StringBuffer;
+
+	use std::sync::{atomic, Arc};
+	{
+		let data: Vec<u8> = vec![0];
+		msg_channel_reestablish_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_channel_reestablish") {
 		for test in tests {
-			data.clear();
+			let mut data: Vec<u8> = Vec::new();
 			let path = test.unwrap().path();
-			println!("Running test {}...", path.file_name().unwrap().to_str().unwrap());
-			fs::File::open(path).unwrap().read_to_end(&mut data).unwrap();
-			msg_channel_reestablish_run(data.as_ptr(), data.len());
+			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_channel_reestablish_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!();
 		}
 	}
 }