_ Git - rust-lightning/blob - fuzz/src/utils/test_logger.rs

   1 // This file is Copyright its original authors, visible in version control
   2 // history.
   3 //
   4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
   5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
   7 // You may not use this file except in accordance with one or both of these
   8 // licenses.
   9
  10 use lightning::util::logger::{Logger, Record};
  11 use std::sync::{Arc, Mutex};
  12 use std::io::Write;
  13
  14 pub trait Output : Clone  + 'static {
  15         fn locked_write(&self, data: &[u8]);
  16         fn locked_contains(&self, pattern: &str) -> bool;
  17 }
  18
  19 #[derive(Clone)]
  20 pub struct DevNull {}
  21 impl Output for DevNull {
  22         fn locked_write(&self, _data: &[u8]) {}
  23         fn locked_contains(&self, _pattern: &str) -> bool {
  24                 false
  25         }
  26 }
  27 #[derive(Clone)]
  28 pub struct StringBuffer(Arc<Mutex<String>>);
  29 impl Output for StringBuffer {
  30         fn locked_write(&self, data: &[u8]) {
  31                 self.0.lock().unwrap().push_str(&String::from_utf8(data.to_vec()).unwrap());
  32         }
  33         fn locked_contains(&self, pattern: &str) -> bool {
  34                 self.0.lock().unwrap().contains(pattern)
  35         }
  36 }
  37 impl StringBuffer {
  38         pub fn new() -> Self {
  39                 Self(Arc::new(Mutex::new(String::new())))
  40         }
  41         pub fn into_string(self) -> String {
  42                 Arc::try_unwrap(self.0).unwrap().into_inner().unwrap()
  43         }
  44 }
  45
  46 pub struct TestLogger<Out : Output> {
  47         id: String,
  48         out: Out,
  49 }
  50 impl<Out: Output> TestLogger<Out> {
  51         pub fn new(id: String, out: Out) -> TestLogger<Out> {
  52                 TestLogger { id, out }
  53         }
  54 }
  55
  56 struct LockedWriteAdapter<'a, Out: Output>(&'a Out);
  57 impl<'a, Out: Output> Write for LockedWriteAdapter<'a, Out> {
  58         fn write(&mut self, data: &[u8]) -> Result<usize, std::io::Error> {
  59                 self.0.locked_write(data);
  60                 Ok(data.len())
  61         }
  62         fn flush(&mut self) -> Result<(), std::io::Error> { Ok(()) }
  63 }
  64
  65 impl<Out: Output> Logger for TestLogger<Out> {
  66         fn log(&self, record: &Record) {
  67                 write!(LockedWriteAdapter(&self.out),
  68                         "{:<5} {} [{} : {}] {}\n", record.level.to_string(), self.id, record.module_path, record.line, record.args)
  69                         .unwrap();
  70         }
  71 }