diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index 86ad12e8961..5bf899f34b1 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -39,6 +39,7 @@ cc = "1.0"
 members = ["."]
 
 [profile.release]
+panic = "abort"
 lto = true
 codegen-units = 1
 debug-assertions = true
@@ -46,12 +47,13 @@ overflow-checks = true
 
 # When testing a large fuzz corpus, -O1 offers a nice speedup
 [profile.dev]
+panic = "abort"
 opt-level = 1
 
 [lib]
 name = "lightning_fuzz"
 path = "src/lib.rs"
-crate-type = ["rlib", "dylib", "staticlib"]
+crate-type = ["rlib", "staticlib"]
 
 [lints.rust.unexpected_cfgs]
 level = "forbid"
diff --git a/fuzz/README.md b/fuzz/README.md
index cfdab4940bc..0516ca7d7ea 100644
--- a/fuzz/README.md
+++ b/fuzz/README.md
@@ -148,6 +148,16 @@ mv hfuzz_workspace/fuzz_target/SIGABRT.PC.7ffff7e21ce1.STACK.[…].fuzz ./test_c
 
 This will reproduce the failing fuzz input and yield a usable stack trace.
 
+Alternatively, you can use the `stdin_fuzz` feature to pipe the crash input directly without
+creating test case files on disk:
+
+```shell
+echo -ne '\x2d\x31\x36\x38\x37\x34\x09\x01...' | RUSTFLAGS="--cfg=fuzzing --cfg=secp256k1_fuzz --cfg=hashes_fuzz" cargo run --features stdin_fuzz --bin full_stack_target
+```
+
+Panics will abort the process directly (the crate uses `panic = "abort"`), resulting in a
+non-zero exit code. Piping via stdin is useful for reproducing crashes during `git bisect` or
+when working with AI agents that can construct and pipe byte sequences directly.
 
 ## How do I add a new fuzz test?
 
diff --git a/fuzz/src/bin/base32_target.rs b/fuzz/src/bin/base32_target.rs
index 7937f30855c..5f168fdcea3 100644
--- a/fuzz/src/bin/base32_target.rs
+++ b/fuzz/src/bin/base32_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::base32::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		base32_run(data.as_ptr(), data.len());
+		base32_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			base32_run(data.as_ptr(), data.len());
+			base32_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	base32_run(data.as_ptr(), data.len());
+	base32_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	base32_run(data.as_ptr(), data.len());
+	base32_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		base32_run(data.as_ptr(), data.len());
+		base32_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/bech32_parse_target.rs b/fuzz/src/bin/bech32_parse_target.rs
index 62f588d3169..ad2f6653843 100644
--- a/fuzz/src/bin/bech32_parse_target.rs
+++ b/fuzz/src/bin/bech32_parse_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::bech32_parse::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		bech32_parse_run(data.as_ptr(), data.len());
+		bech32_parse_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			bech32_parse_run(data.as_ptr(), data.len());
+			bech32_parse_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	bech32_parse_run(data.as_ptr(), data.len());
+	bech32_parse_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	bech32_parse_run(data.as_ptr(), data.len());
+	bech32_parse_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		bech32_parse_run(data.as_ptr(), data.len());
+		bech32_parse_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/bolt11_deser_target.rs b/fuzz/src/bin/bolt11_deser_target.rs
index f79140ae5eb..9e2f33d92cc 100644
--- a/fuzz/src/bin/bolt11_deser_target.rs
+++ b/fuzz/src/bin/bolt11_deser_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::bolt11_deser::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		bolt11_deser_run(data.as_ptr(), data.len());
+		bolt11_deser_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			bolt11_deser_run(data.as_ptr(), data.len());
+			bolt11_deser_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	bolt11_deser_run(data.as_ptr(), data.len());
+	bolt11_deser_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	bolt11_deser_run(data.as_ptr(), data.len());
+	bolt11_deser_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		bolt11_deser_run(data.as_ptr(), data.len());
+		bolt11_deser_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/chanmon_consistency_target.rs b/fuzz/src/bin/chanmon_consistency_target.rs
index c4788b0c1b2..a729e3df1d6 100644
--- a/fuzz/src/bin/chanmon_consistency_target.rs
+++ b/fuzz/src/bin/chanmon_consistency_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::chanmon_consistency::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		chanmon_consistency_run(data.as_ptr(), data.len());
+		chanmon_consistency_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			chanmon_consistency_run(data.as_ptr(), data.len());
+			chanmon_consistency_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	chanmon_consistency_run(data.as_ptr(), data.len());
+	chanmon_consistency_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	chanmon_consistency_run(data.as_ptr(), data.len());
+	chanmon_consistency_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		chanmon_consistency_run(data.as_ptr(), data.len());
+		chanmon_consistency_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/chanmon_deser_target.rs b/fuzz/src/bin/chanmon_deser_target.rs
index e58b8030217..a2f109f17c8 100644
--- a/fuzz/src/bin/chanmon_deser_target.rs
+++ b/fuzz/src/bin/chanmon_deser_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::chanmon_deser::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		chanmon_deser_run(data.as_ptr(), data.len());
+		chanmon_deser_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			chanmon_deser_run(data.as_ptr(), data.len());
+			chanmon_deser_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	chanmon_deser_run(data.as_ptr(), data.len());
+	chanmon_deser_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	chanmon_deser_run(data.as_ptr(), data.len());
+	chanmon_deser_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		chanmon_deser_run(data.as_ptr(), data.len());
+		chanmon_deser_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/feature_flags_target.rs b/fuzz/src/bin/feature_flags_target.rs
index 1be8fd12e8c..2d23f96b4e6 100644
--- a/fuzz/src/bin/feature_flags_target.rs
+++ b/fuzz/src/bin/feature_flags_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::feature_flags::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		feature_flags_run(data.as_ptr(), data.len());
+		feature_flags_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			feature_flags_run(data.as_ptr(), data.len());
+			feature_flags_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	feature_flags_run(data.as_ptr(), data.len());
+	feature_flags_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	feature_flags_run(data.as_ptr(), data.len());
+	feature_flags_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		feature_flags_run(data.as_ptr(), data.len());
+		feature_flags_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/fromstr_to_netaddress_target.rs b/fuzz/src/bin/fromstr_to_netaddress_target.rs
index d86d521c762..fd34e029722 100644
--- a/fuzz/src/bin/fromstr_to_netaddress_target.rs
+++ b/fuzz/src/bin/fromstr_to_netaddress_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::fromstr_to_netaddress::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		fromstr_to_netaddress_run(data.as_ptr(), data.len());
+		fromstr_to_netaddress_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			fromstr_to_netaddress_run(data.as_ptr(), data.len());
+			fromstr_to_netaddress_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	fromstr_to_netaddress_run(data.as_ptr(), data.len());
+	fromstr_to_netaddress_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	fromstr_to_netaddress_run(data.as_ptr(), data.len());
+	fromstr_to_netaddress_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		fromstr_to_netaddress_run(data.as_ptr(), data.len());
+		fromstr_to_netaddress_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/fs_store_target.rs b/fuzz/src/bin/fs_store_target.rs
index 804b09a84cf..8942ebea7f7 100644
--- a/fuzz/src/bin/fs_store_target.rs
+++ b/fuzz/src/bin/fs_store_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::fs_store::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		fs_store_run(data.as_ptr(), data.len());
+		fs_store_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			fs_store_run(data.as_ptr(), data.len());
+			fs_store_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	fs_store_run(data.as_ptr(), data.len());
+	fs_store_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	fs_store_run(data.as_ptr(), data.len());
+	fs_store_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		fs_store_run(data.as_ptr(), data.len());
+		fs_store_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/full_stack_target.rs b/fuzz/src/bin/full_stack_target.rs
index 33bac418f38..a0be19786b5 100644
--- a/fuzz/src/bin/full_stack_target.rs
+++ b/fuzz/src/bin/full_stack_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::full_stack::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		full_stack_run(data.as_ptr(), data.len());
+		full_stack_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			full_stack_run(data.as_ptr(), data.len());
+			full_stack_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	full_stack_run(data.as_ptr(), data.len());
+	full_stack_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	full_stack_run(data.as_ptr(), data.len());
+	full_stack_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		full_stack_run(data.as_ptr(), data.len());
+		full_stack_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/indexedmap_target.rs b/fuzz/src/bin/indexedmap_target.rs
index 3830e6a24a6..51d135b372e 100644
--- a/fuzz/src/bin/indexedmap_target.rs
+++ b/fuzz/src/bin/indexedmap_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::indexedmap::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		indexedmap_run(data.as_ptr(), data.len());
+		indexedmap_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			indexedmap_run(data.as_ptr(), data.len());
+			indexedmap_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	indexedmap_run(data.as_ptr(), data.len());
+	indexedmap_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	indexedmap_run(data.as_ptr(), data.len());
+	indexedmap_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		indexedmap_run(data.as_ptr(), data.len());
+		indexedmap_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/invoice_deser_target.rs b/fuzz/src/bin/invoice_deser_target.rs
index ed79d246a58..bcdbecd0706 100644
--- a/fuzz/src/bin/invoice_deser_target.rs
+++ b/fuzz/src/bin/invoice_deser_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::invoice_deser::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		invoice_deser_run(data.as_ptr(), data.len());
+		invoice_deser_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			invoice_deser_run(data.as_ptr(), data.len());
+			invoice_deser_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	invoice_deser_run(data.as_ptr(), data.len());
+	invoice_deser_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	invoice_deser_run(data.as_ptr(), data.len());
+	invoice_deser_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		invoice_deser_run(data.as_ptr(), data.len());
+		invoice_deser_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/invoice_request_deser_target.rs b/fuzz/src/bin/invoice_request_deser_target.rs
index 47fd3361fcc..f6eee60f142 100644
--- a/fuzz/src/bin/invoice_request_deser_target.rs
+++ b/fuzz/src/bin/invoice_request_deser_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::invoice_request_deser::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		invoice_request_deser_run(data.as_ptr(), data.len());
+		invoice_request_deser_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			invoice_request_deser_run(data.as_ptr(), data.len());
+			invoice_request_deser_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	invoice_request_deser_run(data.as_ptr(), data.len());
+	invoice_request_deser_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	invoice_request_deser_run(data.as_ptr(), data.len());
+	invoice_request_deser_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		invoice_request_deser_run(data.as_ptr(), data.len());
+		invoice_request_deser_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/lsps_message_target.rs b/fuzz/src/bin/lsps_message_target.rs
index 7ba7469ebc0..4c6a0f45655 100644
--- a/fuzz/src/bin/lsps_message_target.rs
+++ b/fuzz/src/bin/lsps_message_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::lsps_message::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		lsps_message_run(data.as_ptr(), data.len());
+		lsps_message_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			lsps_message_run(data.as_ptr(), data.len());
+			lsps_message_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	lsps_message_run(data.as_ptr(), data.len());
+	lsps_message_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	lsps_message_run(data.as_ptr(), data.len());
+	lsps_message_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		lsps_message_run(data.as_ptr(), data.len());
+		lsps_message_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_accept_channel_target.rs b/fuzz/src/bin/msg_accept_channel_target.rs
index 0b5fa27bcc7..aa3b6768eba 100644
--- a/fuzz/src/bin/msg_accept_channel_target.rs
+++ b/fuzz/src/bin/msg_accept_channel_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_accept_channel::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_accept_channel_run(data.as_ptr(), data.len());
+		msg_accept_channel_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_accept_channel_run(data.as_ptr(), data.len());
+			msg_accept_channel_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_accept_channel_run(data.as_ptr(), data.len());
+	msg_accept_channel_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_accept_channel_run(data.as_ptr(), data.len());
+	msg_accept_channel_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_accept_channel_run(data.as_ptr(), data.len());
+		msg_accept_channel_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_accept_channel_v2_target.rs b/fuzz/src/bin/msg_accept_channel_v2_target.rs
index efb02c7acf4..469ae98a410 100644
--- a/fuzz/src/bin/msg_accept_channel_v2_target.rs
+++ b/fuzz/src/bin/msg_accept_channel_v2_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_accept_channel_v2::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_accept_channel_v2_run(data.as_ptr(), data.len());
+		msg_accept_channel_v2_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_accept_channel_v2_run(data.as_ptr(), data.len());
+			msg_accept_channel_v2_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_accept_channel_v2_run(data.as_ptr(), data.len());
+	msg_accept_channel_v2_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_accept_channel_v2_run(data.as_ptr(), data.len());
+	msg_accept_channel_v2_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_accept_channel_v2_run(data.as_ptr(), data.len());
+		msg_accept_channel_v2_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_announcement_signatures_target.rs b/fuzz/src/bin/msg_announcement_signatures_target.rs
index 684f1361f38..f53aae636d5 100644
--- a/fuzz/src/bin/msg_announcement_signatures_target.rs
+++ b/fuzz/src/bin/msg_announcement_signatures_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_announcement_signatures::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_announcement_signatures_run(data.as_ptr(), data.len());
+		msg_announcement_signatures_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_announcement_signatures_run(data.as_ptr(), data.len());
+			msg_announcement_signatures_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_announcement_signatures_run(data.as_ptr(), data.len());
+	msg_announcement_signatures_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_announcement_signatures_run(data.as_ptr(), data.len());
+	msg_announcement_signatures_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_announcement_signatures_run(data.as_ptr(), data.len());
+		msg_announcement_signatures_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_blinded_message_path_target.rs b/fuzz/src/bin/msg_blinded_message_path_target.rs
index 5b8ec215bc4..4159e1c6499 100644
--- a/fuzz/src/bin/msg_blinded_message_path_target.rs
+++ b/fuzz/src/bin/msg_blinded_message_path_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_blinded_message_path::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_blinded_message_path_run(data.as_ptr(), data.len());
+		msg_blinded_message_path_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_blinded_message_path_run(data.as_ptr(), data.len());
+			msg_blinded_message_path_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_blinded_message_path_run(data.as_ptr(), data.len());
+	msg_blinded_message_path_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_blinded_message_path_run(data.as_ptr(), data.len());
+	msg_blinded_message_path_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_blinded_message_path_run(data.as_ptr(), data.len());
+		msg_blinded_message_path_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_channel_announcement_target.rs b/fuzz/src/bin/msg_channel_announcement_target.rs
index 8f326790e0a..31cb61165b0 100644
--- a/fuzz/src/bin/msg_channel_announcement_target.rs
+++ b/fuzz/src/bin/msg_channel_announcement_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_channel_announcement::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_channel_announcement_run(data.as_ptr(), data.len());
+		msg_channel_announcement_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_channel_announcement_run(data.as_ptr(), data.len());
+			msg_channel_announcement_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_channel_announcement_run(data.as_ptr(), data.len());
+	msg_channel_announcement_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_channel_announcement_run(data.as_ptr(), data.len());
+	msg_channel_announcement_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_channel_announcement_run(data.as_ptr(), data.len());
+		msg_channel_announcement_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_channel_details_target.rs b/fuzz/src/bin/msg_channel_details_target.rs
index 34f51a30bde..618c5d6d297 100644
--- a/fuzz/src/bin/msg_channel_details_target.rs
+++ b/fuzz/src/bin/msg_channel_details_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_channel_details::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_channel_details_run(data.as_ptr(), data.len());
+		msg_channel_details_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_channel_details_run(data.as_ptr(), data.len());
+			msg_channel_details_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_channel_details_run(data.as_ptr(), data.len());
+	msg_channel_details_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_channel_details_run(data.as_ptr(), data.len());
+	msg_channel_details_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_channel_details_run(data.as_ptr(), data.len());
+		msg_channel_details_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_channel_ready_target.rs b/fuzz/src/bin/msg_channel_ready_target.rs
index 76733dbecfe..eacacf10193 100644
--- a/fuzz/src/bin/msg_channel_ready_target.rs
+++ b/fuzz/src/bin/msg_channel_ready_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_channel_ready::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_channel_ready_run(data.as_ptr(), data.len());
+		msg_channel_ready_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_channel_ready_run(data.as_ptr(), data.len());
+			msg_channel_ready_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_channel_ready_run(data.as_ptr(), data.len());
+	msg_channel_ready_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_channel_ready_run(data.as_ptr(), data.len());
+	msg_channel_ready_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_channel_ready_run(data.as_ptr(), data.len());
+		msg_channel_ready_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_channel_reestablish_target.rs b/fuzz/src/bin/msg_channel_reestablish_target.rs
index cdb4f1048e3..9ed4a5d1ad3 100644
--- a/fuzz/src/bin/msg_channel_reestablish_target.rs
+++ b/fuzz/src/bin/msg_channel_reestablish_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_channel_reestablish::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_channel_reestablish_run(data.as_ptr(), data.len());
+		msg_channel_reestablish_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_channel_reestablish_run(data.as_ptr(), data.len());
+			msg_channel_reestablish_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_channel_reestablish_run(data.as_ptr(), data.len());
+	msg_channel_reestablish_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_channel_reestablish_run(data.as_ptr(), data.len());
+	msg_channel_reestablish_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_channel_reestablish_run(data.as_ptr(), data.len());
+		msg_channel_reestablish_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_channel_update_target.rs b/fuzz/src/bin/msg_channel_update_target.rs
index 0b567c18b81..56ffeff2c4d 100644
--- a/fuzz/src/bin/msg_channel_update_target.rs
+++ b/fuzz/src/bin/msg_channel_update_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_channel_update::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_channel_update_run(data.as_ptr(), data.len());
+		msg_channel_update_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_channel_update_run(data.as_ptr(), data.len());
+			msg_channel_update_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_channel_update_run(data.as_ptr(), data.len());
+	msg_channel_update_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_channel_update_run(data.as_ptr(), data.len());
+	msg_channel_update_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_channel_update_run(data.as_ptr(), data.len());
+		msg_channel_update_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_closing_complete_target.rs b/fuzz/src/bin/msg_closing_complete_target.rs
index d097e0f6b81..3d8b1375266 100644
--- a/fuzz/src/bin/msg_closing_complete_target.rs
+++ b/fuzz/src/bin/msg_closing_complete_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_closing_complete::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_closing_complete_run(data.as_ptr(), data.len());
+		msg_closing_complete_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_closing_complete_run(data.as_ptr(), data.len());
+			msg_closing_complete_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_closing_complete_run(data.as_ptr(), data.len());
+	msg_closing_complete_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_closing_complete_run(data.as_ptr(), data.len());
+	msg_closing_complete_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_closing_complete_run(data.as_ptr(), data.len());
+		msg_closing_complete_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_closing_sig_target.rs b/fuzz/src/bin/msg_closing_sig_target.rs
index 67150cef167..8bd8e30b50f 100644
--- a/fuzz/src/bin/msg_closing_sig_target.rs
+++ b/fuzz/src/bin/msg_closing_sig_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_closing_sig::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_closing_sig_run(data.as_ptr(), data.len());
+		msg_closing_sig_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_closing_sig_run(data.as_ptr(), data.len());
+			msg_closing_sig_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_closing_sig_run(data.as_ptr(), data.len());
+	msg_closing_sig_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_closing_sig_run(data.as_ptr(), data.len());
+	msg_closing_sig_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_closing_sig_run(data.as_ptr(), data.len());
+		msg_closing_sig_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_closing_signed_target.rs b/fuzz/src/bin/msg_closing_signed_target.rs
index 1634b109da9..68ed7239693 100644
--- a/fuzz/src/bin/msg_closing_signed_target.rs
+++ b/fuzz/src/bin/msg_closing_signed_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_closing_signed::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_closing_signed_run(data.as_ptr(), data.len());
+		msg_closing_signed_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_closing_signed_run(data.as_ptr(), data.len());
+			msg_closing_signed_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_closing_signed_run(data.as_ptr(), data.len());
+	msg_closing_signed_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_closing_signed_run(data.as_ptr(), data.len());
+	msg_closing_signed_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_closing_signed_run(data.as_ptr(), data.len());
+		msg_closing_signed_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_commitment_signed_target.rs b/fuzz/src/bin/msg_commitment_signed_target.rs
index 0c00a4ceb5a..bac1912c616 100644
--- a/fuzz/src/bin/msg_commitment_signed_target.rs
+++ b/fuzz/src/bin/msg_commitment_signed_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_commitment_signed::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_commitment_signed_run(data.as_ptr(), data.len());
+		msg_commitment_signed_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_commitment_signed_run(data.as_ptr(), data.len());
+			msg_commitment_signed_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_commitment_signed_run(data.as_ptr(), data.len());
+	msg_commitment_signed_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_commitment_signed_run(data.as_ptr(), data.len());
+	msg_commitment_signed_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_commitment_signed_run(data.as_ptr(), data.len());
+		msg_commitment_signed_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_decoded_onion_error_packet_target.rs b/fuzz/src/bin/msg_decoded_onion_error_packet_target.rs
index 93f3c66b207..546acafd089 100644
--- a/fuzz/src/bin/msg_decoded_onion_error_packet_target.rs
+++ b/fuzz/src/bin/msg_decoded_onion_error_packet_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_decoded_onion_error_packet::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_decoded_onion_error_packet_run(data.as_ptr(), data.len());
+		msg_decoded_onion_error_packet_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_decoded_onion_error_packet_run(data.as_ptr(), data.len());
+			msg_decoded_onion_error_packet_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_decoded_onion_error_packet_run(data.as_ptr(), data.len());
+	msg_decoded_onion_error_packet_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_decoded_onion_error_packet_run(data.as_ptr(), data.len());
+	msg_decoded_onion_error_packet_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_decoded_onion_error_packet_run(data.as_ptr(), data.len());
+		msg_decoded_onion_error_packet_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_error_message_target.rs b/fuzz/src/bin/msg_error_message_target.rs
index 4840e2bdfe9..f020c4532b3 100644
--- a/fuzz/src/bin/msg_error_message_target.rs
+++ b/fuzz/src/bin/msg_error_message_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_error_message::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_error_message_run(data.as_ptr(), data.len());
+		msg_error_message_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_error_message_run(data.as_ptr(), data.len());
+			msg_error_message_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_error_message_run(data.as_ptr(), data.len());
+	msg_error_message_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_error_message_run(data.as_ptr(), data.len());
+	msg_error_message_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_error_message_run(data.as_ptr(), data.len());
+		msg_error_message_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_funding_created_target.rs b/fuzz/src/bin/msg_funding_created_target.rs
index f8884116710..cfa74aca486 100644
--- a/fuzz/src/bin/msg_funding_created_target.rs
+++ b/fuzz/src/bin/msg_funding_created_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_funding_created::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_funding_created_run(data.as_ptr(), data.len());
+		msg_funding_created_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_funding_created_run(data.as_ptr(), data.len());
+			msg_funding_created_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_funding_created_run(data.as_ptr(), data.len());
+	msg_funding_created_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_funding_created_run(data.as_ptr(), data.len());
+	msg_funding_created_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_funding_created_run(data.as_ptr(), data.len());
+		msg_funding_created_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_funding_signed_target.rs b/fuzz/src/bin/msg_funding_signed_target.rs
index 42d0316dc9a..de5f3b22300 100644
--- a/fuzz/src/bin/msg_funding_signed_target.rs
+++ b/fuzz/src/bin/msg_funding_signed_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_funding_signed::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_funding_signed_run(data.as_ptr(), data.len());
+		msg_funding_signed_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_funding_signed_run(data.as_ptr(), data.len());
+			msg_funding_signed_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_funding_signed_run(data.as_ptr(), data.len());
+	msg_funding_signed_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_funding_signed_run(data.as_ptr(), data.len());
+	msg_funding_signed_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_funding_signed_run(data.as_ptr(), data.len());
+		msg_funding_signed_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_gossip_timestamp_filter_target.rs b/fuzz/src/bin/msg_gossip_timestamp_filter_target.rs
index 0a47f773114..4fd905b3edd 100644
--- a/fuzz/src/bin/msg_gossip_timestamp_filter_target.rs
+++ b/fuzz/src/bin/msg_gossip_timestamp_filter_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_gossip_timestamp_filter::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_gossip_timestamp_filter_run(data.as_ptr(), data.len());
+		msg_gossip_timestamp_filter_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_gossip_timestamp_filter_run(data.as_ptr(), data.len());
+			msg_gossip_timestamp_filter_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_gossip_timestamp_filter_run(data.as_ptr(), data.len());
+	msg_gossip_timestamp_filter_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_gossip_timestamp_filter_run(data.as_ptr(), data.len());
+	msg_gossip_timestamp_filter_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_gossip_timestamp_filter_run(data.as_ptr(), data.len());
+		msg_gossip_timestamp_filter_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_init_target.rs b/fuzz/src/bin/msg_init_target.rs
index db0c8a8894f..9d2bc346304 100644
--- a/fuzz/src/bin/msg_init_target.rs
+++ b/fuzz/src/bin/msg_init_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_init::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_init_run(data.as_ptr(), data.len());
+		msg_init_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_init_run(data.as_ptr(), data.len());
+			msg_init_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_init_run(data.as_ptr(), data.len());
+	msg_init_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_init_run(data.as_ptr(), data.len());
+	msg_init_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_init_run(data.as_ptr(), data.len());
+		msg_init_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_node_announcement_target.rs b/fuzz/src/bin/msg_node_announcement_target.rs
index 1c20a999aaa..820fea1adca 100644
--- a/fuzz/src/bin/msg_node_announcement_target.rs
+++ b/fuzz/src/bin/msg_node_announcement_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_node_announcement::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_node_announcement_run(data.as_ptr(), data.len());
+		msg_node_announcement_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_node_announcement_run(data.as_ptr(), data.len());
+			msg_node_announcement_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_node_announcement_run(data.as_ptr(), data.len());
+	msg_node_announcement_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_node_announcement_run(data.as_ptr(), data.len());
+	msg_node_announcement_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_node_announcement_run(data.as_ptr(), data.len());
+		msg_node_announcement_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_open_channel_target.rs b/fuzz/src/bin/msg_open_channel_target.rs
index fc6df814dd1..fbfd0938924 100644
--- a/fuzz/src/bin/msg_open_channel_target.rs
+++ b/fuzz/src/bin/msg_open_channel_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_open_channel::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_open_channel_run(data.as_ptr(), data.len());
+		msg_open_channel_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_open_channel_run(data.as_ptr(), data.len());
+			msg_open_channel_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_open_channel_run(data.as_ptr(), data.len());
+	msg_open_channel_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_open_channel_run(data.as_ptr(), data.len());
+	msg_open_channel_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_open_channel_run(data.as_ptr(), data.len());
+		msg_open_channel_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_open_channel_v2_target.rs b/fuzz/src/bin/msg_open_channel_v2_target.rs
index 732daed18c3..8c46c4c09df 100644
--- a/fuzz/src/bin/msg_open_channel_v2_target.rs
+++ b/fuzz/src/bin/msg_open_channel_v2_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_open_channel_v2::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_open_channel_v2_run(data.as_ptr(), data.len());
+		msg_open_channel_v2_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_open_channel_v2_run(data.as_ptr(), data.len());
+			msg_open_channel_v2_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_open_channel_v2_run(data.as_ptr(), data.len());
+	msg_open_channel_v2_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_open_channel_v2_run(data.as_ptr(), data.len());
+	msg_open_channel_v2_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_open_channel_v2_run(data.as_ptr(), data.len());
+		msg_open_channel_v2_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_ping_target.rs b/fuzz/src/bin/msg_ping_target.rs
index bb1a59b9bad..52cd3d941ab 100644
--- a/fuzz/src/bin/msg_ping_target.rs
+++ b/fuzz/src/bin/msg_ping_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_ping::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_ping_run(data.as_ptr(), data.len());
+		msg_ping_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_ping_run(data.as_ptr(), data.len());
+			msg_ping_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_ping_run(data.as_ptr(), data.len());
+	msg_ping_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_ping_run(data.as_ptr(), data.len());
+	msg_ping_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_ping_run(data.as_ptr(), data.len());
+		msg_ping_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_pong_target.rs b/fuzz/src/bin/msg_pong_target.rs
index 7a97d93e785..da9e9cc2b89 100644
--- a/fuzz/src/bin/msg_pong_target.rs
+++ b/fuzz/src/bin/msg_pong_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_pong::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_pong_run(data.as_ptr(), data.len());
+		msg_pong_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_pong_run(data.as_ptr(), data.len());
+			msg_pong_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_pong_run(data.as_ptr(), data.len());
+	msg_pong_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_pong_run(data.as_ptr(), data.len());
+	msg_pong_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_pong_run(data.as_ptr(), data.len());
+		msg_pong_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_query_channel_range_target.rs b/fuzz/src/bin/msg_query_channel_range_target.rs
index 4fd3260db0a..e177b23072f 100644
--- a/fuzz/src/bin/msg_query_channel_range_target.rs
+++ b/fuzz/src/bin/msg_query_channel_range_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_query_channel_range::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_query_channel_range_run(data.as_ptr(), data.len());
+		msg_query_channel_range_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_query_channel_range_run(data.as_ptr(), data.len());
+			msg_query_channel_range_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_query_channel_range_run(data.as_ptr(), data.len());
+	msg_query_channel_range_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_query_channel_range_run(data.as_ptr(), data.len());
+	msg_query_channel_range_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_query_channel_range_run(data.as_ptr(), data.len());
+		msg_query_channel_range_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_query_short_channel_ids_target.rs b/fuzz/src/bin/msg_query_short_channel_ids_target.rs
index 63f8c48fb3b..53ca822bb21 100644
--- a/fuzz/src/bin/msg_query_short_channel_ids_target.rs
+++ b/fuzz/src/bin/msg_query_short_channel_ids_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_query_short_channel_ids::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_query_short_channel_ids_run(data.as_ptr(), data.len());
+		msg_query_short_channel_ids_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_query_short_channel_ids_run(data.as_ptr(), data.len());
+			msg_query_short_channel_ids_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_query_short_channel_ids_run(data.as_ptr(), data.len());
+	msg_query_short_channel_ids_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_query_short_channel_ids_run(data.as_ptr(), data.len());
+	msg_query_short_channel_ids_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_query_short_channel_ids_run(data.as_ptr(), data.len());
+		msg_query_short_channel_ids_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_reply_channel_range_target.rs b/fuzz/src/bin/msg_reply_channel_range_target.rs
index 8e5ce619fa4..2a776eaabf7 100644
--- a/fuzz/src/bin/msg_reply_channel_range_target.rs
+++ b/fuzz/src/bin/msg_reply_channel_range_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_reply_channel_range::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_reply_channel_range_run(data.as_ptr(), data.len());
+		msg_reply_channel_range_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_reply_channel_range_run(data.as_ptr(), data.len());
+			msg_reply_channel_range_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_reply_channel_range_run(data.as_ptr(), data.len());
+	msg_reply_channel_range_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_reply_channel_range_run(data.as_ptr(), data.len());
+	msg_reply_channel_range_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_reply_channel_range_run(data.as_ptr(), data.len());
+		msg_reply_channel_range_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_reply_short_channel_ids_end_target.rs b/fuzz/src/bin/msg_reply_short_channel_ids_end_target.rs
index 9b9b528abe5..02ffd90ebcb 100644
--- a/fuzz/src/bin/msg_reply_short_channel_ids_end_target.rs
+++ b/fuzz/src/bin/msg_reply_short_channel_ids_end_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_reply_short_channel_ids_end::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_reply_short_channel_ids_end_run(data.as_ptr(), data.len());
+		msg_reply_short_channel_ids_end_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_reply_short_channel_ids_end_run(data.as_ptr(), data.len());
+			msg_reply_short_channel_ids_end_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_reply_short_channel_ids_end_run(data.as_ptr(), data.len());
+	msg_reply_short_channel_ids_end_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_reply_short_channel_ids_end_run(data.as_ptr(), data.len());
+	msg_reply_short_channel_ids_end_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_reply_short_channel_ids_end_run(data.as_ptr(), data.len());
+		msg_reply_short_channel_ids_end_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_revoke_and_ack_target.rs b/fuzz/src/bin/msg_revoke_and_ack_target.rs
index 1f401dae773..0a20ea7586c 100644
--- a/fuzz/src/bin/msg_revoke_and_ack_target.rs
+++ b/fuzz/src/bin/msg_revoke_and_ack_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_revoke_and_ack::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_revoke_and_ack_run(data.as_ptr(), data.len());
+		msg_revoke_and_ack_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_revoke_and_ack_run(data.as_ptr(), data.len());
+			msg_revoke_and_ack_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_revoke_and_ack_run(data.as_ptr(), data.len());
+	msg_revoke_and_ack_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_revoke_and_ack_run(data.as_ptr(), data.len());
+	msg_revoke_and_ack_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_revoke_and_ack_run(data.as_ptr(), data.len());
+		msg_revoke_and_ack_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_shutdown_target.rs b/fuzz/src/bin/msg_shutdown_target.rs
index c29bb93bb0b..ed26a25949c 100644
--- a/fuzz/src/bin/msg_shutdown_target.rs
+++ b/fuzz/src/bin/msg_shutdown_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_shutdown::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_shutdown_run(data.as_ptr(), data.len());
+		msg_shutdown_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_shutdown_run(data.as_ptr(), data.len());
+			msg_shutdown_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_shutdown_run(data.as_ptr(), data.len());
+	msg_shutdown_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_shutdown_run(data.as_ptr(), data.len());
+	msg_shutdown_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_shutdown_run(data.as_ptr(), data.len());
+		msg_shutdown_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_splice_ack_target.rs b/fuzz/src/bin/msg_splice_ack_target.rs
index 9957a85552f..0a1f13b7e08 100644
--- a/fuzz/src/bin/msg_splice_ack_target.rs
+++ b/fuzz/src/bin/msg_splice_ack_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_splice_ack::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_splice_ack_run(data.as_ptr(), data.len());
+		msg_splice_ack_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_splice_ack_run(data.as_ptr(), data.len());
+			msg_splice_ack_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_splice_ack_run(data.as_ptr(), data.len());
+	msg_splice_ack_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_splice_ack_run(data.as_ptr(), data.len());
+	msg_splice_ack_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_splice_ack_run(data.as_ptr(), data.len());
+		msg_splice_ack_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_splice_init_target.rs b/fuzz/src/bin/msg_splice_init_target.rs
index 83df6454623..9a7bc60ebda 100644
--- a/fuzz/src/bin/msg_splice_init_target.rs
+++ b/fuzz/src/bin/msg_splice_init_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_splice_init::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_splice_init_run(data.as_ptr(), data.len());
+		msg_splice_init_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_splice_init_run(data.as_ptr(), data.len());
+			msg_splice_init_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_splice_init_run(data.as_ptr(), data.len());
+	msg_splice_init_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_splice_init_run(data.as_ptr(), data.len());
+	msg_splice_init_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_splice_init_run(data.as_ptr(), data.len());
+		msg_splice_init_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_splice_locked_target.rs b/fuzz/src/bin/msg_splice_locked_target.rs
index d9dfcf956be..0f9b0a2ed60 100644
--- a/fuzz/src/bin/msg_splice_locked_target.rs
+++ b/fuzz/src/bin/msg_splice_locked_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_splice_locked::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_splice_locked_run(data.as_ptr(), data.len());
+		msg_splice_locked_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_splice_locked_run(data.as_ptr(), data.len());
+			msg_splice_locked_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_splice_locked_run(data.as_ptr(), data.len());
+	msg_splice_locked_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_splice_locked_run(data.as_ptr(), data.len());
+	msg_splice_locked_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_splice_locked_run(data.as_ptr(), data.len());
+		msg_splice_locked_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_stfu_target.rs b/fuzz/src/bin/msg_stfu_target.rs
index bdef12d4c32..d6b898ba11b 100644
--- a/fuzz/src/bin/msg_stfu_target.rs
+++ b/fuzz/src/bin/msg_stfu_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_stfu::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_stfu_run(data.as_ptr(), data.len());
+		msg_stfu_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_stfu_run(data.as_ptr(), data.len());
+			msg_stfu_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_stfu_run(data.as_ptr(), data.len());
+	msg_stfu_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_stfu_run(data.as_ptr(), data.len());
+	msg_stfu_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_stfu_run(data.as_ptr(), data.len());
+		msg_stfu_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_tx_abort_target.rs b/fuzz/src/bin/msg_tx_abort_target.rs
index 76f098b1e2c..3b824095062 100644
--- a/fuzz/src/bin/msg_tx_abort_target.rs
+++ b/fuzz/src/bin/msg_tx_abort_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_tx_abort::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_tx_abort_run(data.as_ptr(), data.len());
+		msg_tx_abort_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_tx_abort_run(data.as_ptr(), data.len());
+			msg_tx_abort_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_tx_abort_run(data.as_ptr(), data.len());
+	msg_tx_abort_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_tx_abort_run(data.as_ptr(), data.len());
+	msg_tx_abort_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_tx_abort_run(data.as_ptr(), data.len());
+		msg_tx_abort_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_tx_ack_rbf_target.rs b/fuzz/src/bin/msg_tx_ack_rbf_target.rs
index 1f549a5703f..d4905a5ce14 100644
--- a/fuzz/src/bin/msg_tx_ack_rbf_target.rs
+++ b/fuzz/src/bin/msg_tx_ack_rbf_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_tx_ack_rbf::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_tx_ack_rbf_run(data.as_ptr(), data.len());
+		msg_tx_ack_rbf_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_tx_ack_rbf_run(data.as_ptr(), data.len());
+			msg_tx_ack_rbf_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_tx_ack_rbf_run(data.as_ptr(), data.len());
+	msg_tx_ack_rbf_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_tx_ack_rbf_run(data.as_ptr(), data.len());
+	msg_tx_ack_rbf_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_tx_ack_rbf_run(data.as_ptr(), data.len());
+		msg_tx_ack_rbf_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_tx_add_input_target.rs b/fuzz/src/bin/msg_tx_add_input_target.rs
index 9b7e1cfe7e6..627797fdc6f 100644
--- a/fuzz/src/bin/msg_tx_add_input_target.rs
+++ b/fuzz/src/bin/msg_tx_add_input_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_tx_add_input::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_tx_add_input_run(data.as_ptr(), data.len());
+		msg_tx_add_input_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_tx_add_input_run(data.as_ptr(), data.len());
+			msg_tx_add_input_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_tx_add_input_run(data.as_ptr(), data.len());
+	msg_tx_add_input_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_tx_add_input_run(data.as_ptr(), data.len());
+	msg_tx_add_input_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_tx_add_input_run(data.as_ptr(), data.len());
+		msg_tx_add_input_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_tx_add_output_target.rs b/fuzz/src/bin/msg_tx_add_output_target.rs
index b8ad29581bc..be301558f6f 100644
--- a/fuzz/src/bin/msg_tx_add_output_target.rs
+++ b/fuzz/src/bin/msg_tx_add_output_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_tx_add_output::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_tx_add_output_run(data.as_ptr(), data.len());
+		msg_tx_add_output_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_tx_add_output_run(data.as_ptr(), data.len());
+			msg_tx_add_output_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_tx_add_output_run(data.as_ptr(), data.len());
+	msg_tx_add_output_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_tx_add_output_run(data.as_ptr(), data.len());
+	msg_tx_add_output_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_tx_add_output_run(data.as_ptr(), data.len());
+		msg_tx_add_output_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_tx_complete_target.rs b/fuzz/src/bin/msg_tx_complete_target.rs
index 28b295b0d25..12abb32e020 100644
--- a/fuzz/src/bin/msg_tx_complete_target.rs
+++ b/fuzz/src/bin/msg_tx_complete_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_tx_complete::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_tx_complete_run(data.as_ptr(), data.len());
+		msg_tx_complete_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_tx_complete_run(data.as_ptr(), data.len());
+			msg_tx_complete_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_tx_complete_run(data.as_ptr(), data.len());
+	msg_tx_complete_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_tx_complete_run(data.as_ptr(), data.len());
+	msg_tx_complete_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_tx_complete_run(data.as_ptr(), data.len());
+		msg_tx_complete_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_tx_init_rbf_target.rs b/fuzz/src/bin/msg_tx_init_rbf_target.rs
index 24fa793315d..6ede611b2ae 100644
--- a/fuzz/src/bin/msg_tx_init_rbf_target.rs
+++ b/fuzz/src/bin/msg_tx_init_rbf_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_tx_init_rbf::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_tx_init_rbf_run(data.as_ptr(), data.len());
+		msg_tx_init_rbf_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_tx_init_rbf_run(data.as_ptr(), data.len());
+			msg_tx_init_rbf_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_tx_init_rbf_run(data.as_ptr(), data.len());
+	msg_tx_init_rbf_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_tx_init_rbf_run(data.as_ptr(), data.len());
+	msg_tx_init_rbf_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_tx_init_rbf_run(data.as_ptr(), data.len());
+		msg_tx_init_rbf_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_tx_remove_input_target.rs b/fuzz/src/bin/msg_tx_remove_input_target.rs
index abe4190a354..a508497e151 100644
--- a/fuzz/src/bin/msg_tx_remove_input_target.rs
+++ b/fuzz/src/bin/msg_tx_remove_input_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_tx_remove_input::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_tx_remove_input_run(data.as_ptr(), data.len());
+		msg_tx_remove_input_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_tx_remove_input_run(data.as_ptr(), data.len());
+			msg_tx_remove_input_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_tx_remove_input_run(data.as_ptr(), data.len());
+	msg_tx_remove_input_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_tx_remove_input_run(data.as_ptr(), data.len());
+	msg_tx_remove_input_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_tx_remove_input_run(data.as_ptr(), data.len());
+		msg_tx_remove_input_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_tx_remove_output_target.rs b/fuzz/src/bin/msg_tx_remove_output_target.rs
index 3d084e0048d..993ddb044b2 100644
--- a/fuzz/src/bin/msg_tx_remove_output_target.rs
+++ b/fuzz/src/bin/msg_tx_remove_output_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_tx_remove_output::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_tx_remove_output_run(data.as_ptr(), data.len());
+		msg_tx_remove_output_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_tx_remove_output_run(data.as_ptr(), data.len());
+			msg_tx_remove_output_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_tx_remove_output_run(data.as_ptr(), data.len());
+	msg_tx_remove_output_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_tx_remove_output_run(data.as_ptr(), data.len());
+	msg_tx_remove_output_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_tx_remove_output_run(data.as_ptr(), data.len());
+		msg_tx_remove_output_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_tx_signatures_target.rs b/fuzz/src/bin/msg_tx_signatures_target.rs
index fa3b966b478..8054d4241ee 100644
--- a/fuzz/src/bin/msg_tx_signatures_target.rs
+++ b/fuzz/src/bin/msg_tx_signatures_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_tx_signatures::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_tx_signatures_run(data.as_ptr(), data.len());
+		msg_tx_signatures_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_tx_signatures_run(data.as_ptr(), data.len());
+			msg_tx_signatures_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_tx_signatures_run(data.as_ptr(), data.len());
+	msg_tx_signatures_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_tx_signatures_run(data.as_ptr(), data.len());
+	msg_tx_signatures_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_tx_signatures_run(data.as_ptr(), data.len());
+		msg_tx_signatures_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_update_add_htlc_target.rs b/fuzz/src/bin/msg_update_add_htlc_target.rs
index f3c25a37524..258dd2445f2 100644
--- a/fuzz/src/bin/msg_update_add_htlc_target.rs
+++ b/fuzz/src/bin/msg_update_add_htlc_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_update_add_htlc::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_update_add_htlc_run(data.as_ptr(), data.len());
+		msg_update_add_htlc_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_update_add_htlc_run(data.as_ptr(), data.len());
+			msg_update_add_htlc_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_update_add_htlc_run(data.as_ptr(), data.len());
+	msg_update_add_htlc_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	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());
+	msg_update_add_htlc_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_update_add_htlc_run(data.as_ptr(), data.len());
+		msg_update_add_htlc_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_update_fail_htlc_target.rs b/fuzz/src/bin/msg_update_fail_htlc_target.rs
index 9698ae92cfe..b4ae4e52e1e 100644
--- a/fuzz/src/bin/msg_update_fail_htlc_target.rs
+++ b/fuzz/src/bin/msg_update_fail_htlc_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_update_fail_htlc::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_update_fail_htlc_run(data.as_ptr(), data.len());
+		msg_update_fail_htlc_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_update_fail_htlc_run(data.as_ptr(), data.len());
+			msg_update_fail_htlc_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_update_fail_htlc_run(data.as_ptr(), data.len());
+	msg_update_fail_htlc_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_update_fail_htlc_run(data.as_ptr(), data.len());
+	msg_update_fail_htlc_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_update_fail_htlc_run(data.as_ptr(), data.len());
+		msg_update_fail_htlc_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_update_fail_malformed_htlc_target.rs b/fuzz/src/bin/msg_update_fail_malformed_htlc_target.rs
index b7f511c5ff5..fb5325d54f7 100644
--- a/fuzz/src/bin/msg_update_fail_malformed_htlc_target.rs
+++ b/fuzz/src/bin/msg_update_fail_malformed_htlc_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_update_fail_malformed_htlc::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_update_fail_malformed_htlc_run(data.as_ptr(), data.len());
+		msg_update_fail_malformed_htlc_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_update_fail_malformed_htlc_run(data.as_ptr(), data.len());
+			msg_update_fail_malformed_htlc_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_update_fail_malformed_htlc_run(data.as_ptr(), data.len());
+	msg_update_fail_malformed_htlc_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_update_fail_malformed_htlc_run(data.as_ptr(), data.len());
+	msg_update_fail_malformed_htlc_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_update_fail_malformed_htlc_run(data.as_ptr(), data.len());
+		msg_update_fail_malformed_htlc_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_update_fee_target.rs b/fuzz/src/bin/msg_update_fee_target.rs
index b021107f150..d8e9a26dc08 100644
--- a/fuzz/src/bin/msg_update_fee_target.rs
+++ b/fuzz/src/bin/msg_update_fee_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_update_fee::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_update_fee_run(data.as_ptr(), data.len());
+		msg_update_fee_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_update_fee_run(data.as_ptr(), data.len());
+			msg_update_fee_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_update_fee_run(data.as_ptr(), data.len());
+	msg_update_fee_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_update_fee_run(data.as_ptr(), data.len());
+	msg_update_fee_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_update_fee_run(data.as_ptr(), data.len());
+		msg_update_fee_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/msg_update_fulfill_htlc_target.rs b/fuzz/src/bin/msg_update_fulfill_htlc_target.rs
index d87cd5bd490..cec5ccfc1fe 100644
--- a/fuzz/src/bin/msg_update_fulfill_htlc_target.rs
+++ b/fuzz/src/bin/msg_update_fulfill_htlc_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::msg_targets::msg_update_fulfill_htlc::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		msg_update_fulfill_htlc_run(data.as_ptr(), data.len());
+		msg_update_fulfill_htlc_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			msg_update_fulfill_htlc_run(data.as_ptr(), data.len());
+			msg_update_fulfill_htlc_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	msg_update_fulfill_htlc_run(data.as_ptr(), data.len());
+	msg_update_fulfill_htlc_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	msg_update_fulfill_htlc_run(data.as_ptr(), data.len());
+	msg_update_fulfill_htlc_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		msg_update_fulfill_htlc_run(data.as_ptr(), data.len());
+		msg_update_fulfill_htlc_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/offer_deser_target.rs b/fuzz/src/bin/offer_deser_target.rs
index 51cdb09adec..d788a8b04c9 100644
--- a/fuzz/src/bin/offer_deser_target.rs
+++ b/fuzz/src/bin/offer_deser_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::offer_deser::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		offer_deser_run(data.as_ptr(), data.len());
+		offer_deser_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			offer_deser_run(data.as_ptr(), data.len());
+			offer_deser_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	offer_deser_run(data.as_ptr(), data.len());
+	offer_deser_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	offer_deser_run(data.as_ptr(), data.len());
+	offer_deser_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		offer_deser_run(data.as_ptr(), data.len());
+		offer_deser_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/onion_hop_data_target.rs b/fuzz/src/bin/onion_hop_data_target.rs
index 50d98043d05..1677d075ebd 100644
--- a/fuzz/src/bin/onion_hop_data_target.rs
+++ b/fuzz/src/bin/onion_hop_data_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::onion_hop_data::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		onion_hop_data_run(data.as_ptr(), data.len());
+		onion_hop_data_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			onion_hop_data_run(data.as_ptr(), data.len());
+			onion_hop_data_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	onion_hop_data_run(data.as_ptr(), data.len());
+	onion_hop_data_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	onion_hop_data_run(data.as_ptr(), data.len());
+	onion_hop_data_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		onion_hop_data_run(data.as_ptr(), data.len());
+		onion_hop_data_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/onion_message_target.rs b/fuzz/src/bin/onion_message_target.rs
index 7bb09477ec5..ff5feec3fb4 100644
--- a/fuzz/src/bin/onion_message_target.rs
+++ b/fuzz/src/bin/onion_message_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::onion_message::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		onion_message_run(data.as_ptr(), data.len());
+		onion_message_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			onion_message_run(data.as_ptr(), data.len());
+			onion_message_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	onion_message_run(data.as_ptr(), data.len());
+	onion_message_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	onion_message_run(data.as_ptr(), data.len());
+	onion_message_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		onion_message_run(data.as_ptr(), data.len());
+		onion_message_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/peer_crypt_target.rs b/fuzz/src/bin/peer_crypt_target.rs
index 0ba0252c963..6b21d8e6e5a 100644
--- a/fuzz/src/bin/peer_crypt_target.rs
+++ b/fuzz/src/bin/peer_crypt_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::peer_crypt::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		peer_crypt_run(data.as_ptr(), data.len());
+		peer_crypt_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			peer_crypt_run(data.as_ptr(), data.len());
+			peer_crypt_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	peer_crypt_run(data.as_ptr(), data.len());
+	peer_crypt_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	peer_crypt_run(data.as_ptr(), data.len());
+	peer_crypt_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		peer_crypt_run(data.as_ptr(), data.len());
+		peer_crypt_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/process_network_graph_target.rs b/fuzz/src/bin/process_network_graph_target.rs
index 4ce10e6d4df..26306648151 100644
--- a/fuzz/src/bin/process_network_graph_target.rs
+++ b/fuzz/src/bin/process_network_graph_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::process_network_graph::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		process_network_graph_run(data.as_ptr(), data.len());
+		process_network_graph_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			process_network_graph_run(data.as_ptr(), data.len());
+			process_network_graph_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	process_network_graph_run(data.as_ptr(), data.len());
+	process_network_graph_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	process_network_graph_run(data.as_ptr(), data.len());
+	process_network_graph_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		process_network_graph_run(data.as_ptr(), data.len());
+		process_network_graph_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/process_onion_failure_target.rs b/fuzz/src/bin/process_onion_failure_target.rs
index 1d2cdb28593..4c613a055b1 100644
--- a/fuzz/src/bin/process_onion_failure_target.rs
+++ b/fuzz/src/bin/process_onion_failure_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::process_onion_failure::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		process_onion_failure_run(data.as_ptr(), data.len());
+		process_onion_failure_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			process_onion_failure_run(data.as_ptr(), data.len());
+			process_onion_failure_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	process_onion_failure_run(data.as_ptr(), data.len());
+	process_onion_failure_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	process_onion_failure_run(data.as_ptr(), data.len());
+	process_onion_failure_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		process_onion_failure_run(data.as_ptr(), data.len());
+		process_onion_failure_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/refund_deser_target.rs b/fuzz/src/bin/refund_deser_target.rs
index fea8a9c4c6d..c61c4f7a5d9 100644
--- a/fuzz/src/bin/refund_deser_target.rs
+++ b/fuzz/src/bin/refund_deser_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::refund_deser::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		refund_deser_run(data.as_ptr(), data.len());
+		refund_deser_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			refund_deser_run(data.as_ptr(), data.len());
+			refund_deser_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	refund_deser_run(data.as_ptr(), data.len());
+	refund_deser_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	refund_deser_run(data.as_ptr(), data.len());
+	refund_deser_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		refund_deser_run(data.as_ptr(), data.len());
+		refund_deser_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/router_target.rs b/fuzz/src/bin/router_target.rs
index 0ebec549455..73d6d1b3f7b 100644
--- a/fuzz/src/bin/router_target.rs
+++ b/fuzz/src/bin/router_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::router::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		router_run(data.as_ptr(), data.len());
+		router_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			router_run(data.as_ptr(), data.len());
+			router_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	router_run(data.as_ptr(), data.len());
+	router_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	router_run(data.as_ptr(), data.len());
+	router_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		router_run(data.as_ptr(), data.len());
+		router_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/static_invoice_deser_target.rs b/fuzz/src/bin/static_invoice_deser_target.rs
index 573f0aa0b22..59b854486ac 100644
--- a/fuzz/src/bin/static_invoice_deser_target.rs
+++ b/fuzz/src/bin/static_invoice_deser_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::static_invoice_deser::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		static_invoice_deser_run(data.as_ptr(), data.len());
+		static_invoice_deser_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			static_invoice_deser_run(data.as_ptr(), data.len());
+			static_invoice_deser_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	static_invoice_deser_run(data.as_ptr(), data.len());
+	static_invoice_deser_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	static_invoice_deser_run(data.as_ptr(), data.len());
+	static_invoice_deser_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		static_invoice_deser_run(data.as_ptr(), data.len());
+		static_invoice_deser_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/target_template.txt b/fuzz/src/bin/target_template.txt
index e828aa998b1..b085ae7ad7b 100644
--- a/fuzz/src/bin/target_template.txt
+++ b/fuzz/src/bin/target_template.txt
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::TARGET_MOD::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		TARGET_NAME_run(data.as_ptr(), data.len());
+		TARGET_NAME_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			TARGET_NAME_run(data.as_ptr(), data.len());
+			TARGET_NAME_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	TARGET_NAME_run(data.as_ptr(), data.len());
+	TARGET_NAME_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	TARGET_NAME_run(data.as_ptr(), data.len());
+	TARGET_NAME_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		TARGET_NAME_run(data.as_ptr(), data.len());
+		TARGET_NAME_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/bin/zbase32_target.rs b/fuzz/src/bin/zbase32_target.rs
index 35aa53d1fff..c17ea0ae8b5 100644
--- a/fuzz/src/bin/zbase32_target.rs
+++ b/fuzz/src/bin/zbase32_target.rs
@@ -24,13 +24,14 @@ compile_error!("Fuzz targets need cfg=secp256k1_fuzz");
 
 extern crate lightning_fuzz;
 use lightning_fuzz::zbase32::*;
+use lightning_fuzz::utils::test_logger;
 
 #[cfg(feature = "afl")]
 #[macro_use] extern crate afl;
 #[cfg(feature = "afl")]
 fn main() {
 	fuzz!(|data| {
-		zbase32_run(data.as_ptr(), data.len());
+		zbase32_test(&data, test_logger::DevNull {});
 	});
 }
 
@@ -40,7 +41,7 @@ fn main() {
 fn main() {
 	loop {
 		fuzz!(|data| {
-			zbase32_run(data.as_ptr(), data.len());
+			zbase32_test(&data, test_logger::DevNull {});
 		});
 	}
 }
@@ -49,7 +50,7 @@ fn main() {
 #[macro_use] extern crate libfuzzer_sys;
 #[cfg(feature = "libfuzzer_fuzz")]
 fuzz_target!(|data: &[u8]| {
-	zbase32_run(data.as_ptr(), data.len());
+	zbase32_test(data, test_logger::DevNull {});
 });
 
 #[cfg(feature = "stdin_fuzz")]
@@ -58,7 +59,7 @@ fn main() {
 
 	let mut data = Vec::with_capacity(8192);
 	std::io::stdin().read_to_end(&mut data).unwrap();
-	zbase32_run(data.as_ptr(), data.len());
+	zbase32_test(&data, lightning_fuzz::utils::test_logger::Stdout {});
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn run_test_cases() {
 	use std::sync::{atomic, Arc};
 	{
 		let data: Vec<u8> = vec![0];
-		zbase32_run(data.as_ptr(), data.len());
+		zbase32_test(&data, test_logger::DevNull {});
 	}
 	let mut threads = Vec::new();
 	let threads_running = Arc::new(atomic::AtomicUsize::new(0));
diff --git a/fuzz/src/utils/test_logger.rs b/fuzz/src/utils/test_logger.rs
index 8f38d08a035..193ccc06a54 100644
--- a/fuzz/src/utils/test_logger.rs
+++ b/fuzz/src/utils/test_logger.rs
@@ -21,6 +21,13 @@ impl Output for DevNull {
 	fn locked_write(&self, _data: &[u8]) {}
 }
 #[derive(Clone)]
+pub struct Stdout {}
+impl Output for Stdout {
+	fn locked_write(&self, data: &[u8]) {
+		std::io::stdout().write_all(data).unwrap();
+	}
+}
+#[derive(Clone)]
 pub struct StringBuffer(Arc<Mutex<String>>);
 impl Output for StringBuffer {
 	fn locked_write(&self, data: &[u8]) {