Thread fuzz test cases

[rust-lightning] / fuzz / src / utils / test_logger.rs

diff --git a/fuzz/src/utils/test_logger.rs b/fuzz/src/utils/test_logger.rs
index 097d001dbb25f80e0049a6c1526c379365a0f49f..cd037ad8187d8c42895b1a92abd3a37dfe2b5c8f 100644 (file)
--- a/fuzz/src/utils/test_logger.rs
+++ b/fuzz/src/utils/test_logger.rs
@@ -1,23 +1,55 @@
 use lightning::util::logger::{Logger, Record};
-pub struct TestLogger {
-       #[cfg(test)]
+use std::sync::{Arc, Mutex};
+use std::io::Write;
+
+pub trait Output : Clone + Sync + Send + 'static {
+       fn locked_write(&self, data: &[u8]);
+}
+
+#[derive(Clone)]
+pub struct DevNull {}
+impl Output for DevNull {
+       fn locked_write(&self, _data: &[u8]) {}
+}
+#[derive(Clone)]
+pub struct StringBuffer(Arc<Mutex<String>>);
+impl Output for StringBuffer {
+       fn locked_write(&self, data: &[u8]) {
+               self.0.lock().unwrap().push_str(&String::from_utf8(data.to_vec()).unwrap());
+       }
+}
+impl StringBuffer {
+       pub fn new() -> Self {
+               Self(Arc::new(Mutex::new(String::new())))
+       }
+       pub fn into_string(self) -> String {
+               Arc::try_unwrap(self.0).unwrap().into_inner().unwrap()
+       }
+}
+
+pub struct TestLogger<Out : Output> {
        id: String,
+       out: Out,
+}
+impl<Out: Output> TestLogger<Out> {
+       pub fn new(id: String, out: Out) -> TestLogger<Out> {
+               TestLogger { id, out }
+       }
 }
 
-impl TestLogger {
-       pub fn new(_id: String) -> TestLogger {
-               TestLogger {
-                       #[cfg(test)]
-                       id: _id
-               }
+struct LockedWriteAdapter<'a, Out: Output>(&'a Out);
+impl<'a, Out: Output> Write for LockedWriteAdapter<'a, Out> {
+       fn write(&mut self, data: &[u8]) -> Result<usize, std::io::Error> {
+               self.0.locked_write(data);
+               Ok(data.len())
        }
+       fn flush(&mut self) -> Result<(), std::io::Error> { Ok(()) }
 }
 
-impl Logger for TestLogger {
+impl<Out: Output> Logger for TestLogger<Out> {
        fn log(&self, record: &Record) {
-               #[cfg(test)]
-               println!("{:<5} {} [{} : {}, {}] {}", record.level.to_string(), self.id, record.module_path, record.file, record.line, record.args);
-               #[cfg(not(test))]
-               let _ = format!("{}", record.args);
+               write!(LockedWriteAdapter(&self.out),
+                       "{:<5} {} [{} : {}, {}] {}\n", record.level.to_string(), self.id, record.module_path, record.file, record.line, record.args)
+                       .unwrap();
        }
 }