Skip to main content

test_buffer/
lib.rs

1#![doc = include_str!("../README.md")]
2
3#[cfg(feature = "expect-test")]
4pub mod test_utils {
5    pub use expect_test::{
6        expect,
7        expect_file,
8    };
9}
10
11/// Buffer used for testing, output buffer name and content during panic
12#[derive(Clone, Default, Debug)]
13pub struct TestBuffer {
14    name: Option<String>,
15    buffer: String,
16}
17
18impl Drop for TestBuffer {
19    fn drop(&mut self) {
20        if std::thread::panicking() {
21            println!("{}", self.desc())
22        }
23    }
24}
25
26impl std::fmt::Display for TestBuffer {
27    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
28        self.buffer.fmt(f)
29    }
30}
31
32macro_rules! impl_eqs {
33    ($($ty:ty),*) => {
34        $(
35            impl PartialEq<$ty> for TestBuffer {
36                fn eq(&self, other: &$ty) -> bool {
37                    self.buffer == *other
38                }
39            }
40            impl PartialEq<TestBuffer> for $ty {
41                fn eq(&self, other: &TestBuffer) -> bool {
42                    other.buffer == *self
43                }
44            }
45        )*
46    };
47}
48impl_eqs!(str, &str, String);
49
50impl TestBuffer {
51    /// Creates a unnamed new [`TestBuffer`].
52    pub fn new() -> Self {
53        Self::default()
54    }
55
56    /// Creates a named new [`TestBuffer`].
57    pub fn with_name(name: impl ToString) -> Self {
58        TestBuffer { name: Some(name.to_string()), buffer: String::new() }
59    }
60
61    pub fn name(&self) -> Option<&str> {
62        self.name.as_deref()
63    }
64
65    pub fn as_str(&self) -> &str {
66        &self.buffer
67    }
68
69    /// Returns the description of this [`TestBuffer`].
70    ///
71    /// When panic, this struct output description in drop
72    pub fn desc(&self) -> String {
73        let name = self.name().unwrap_or("<unnamed>");
74        let kind = if std::thread::panicking() { " in panicking" } else { "" };
75        format!("===> TestBuffer {name} content preview{kind} <===\n{}", self.buffer)
76    }
77
78    #[cfg(feature = "expect-test")]
79    /// Quick method, uses for [`expect_test`]
80    pub fn expect(&self, expect: expect_test::Expect) {
81        expect.assert_eq(self.as_str());
82    }
83
84    #[cfg(feature = "expect-test")]
85    /// Quick method, uses for [`expect_test`]
86    pub fn expect_file(&self, expect: expect_test::ExpectFile) {
87        expect.assert_eq(self.as_str());
88    }
89
90    /// Use `write!` call this method.
91    ///
92    /// # Panics
93    ///
94    /// Panics if `args.fmt()` panic.
95    ///
96    /// # Examples
97    ///
98    /// ```
99    /// use test_buffer::TestBuffer;
100    ///
101    /// let mut test_buffer = TestBuffer::new();
102    /// write!(test_buffer, "foo");
103    /// write!(test_buffer, "bar");
104    /// assert_eq!(test_buffer, "foobar");
105    /// ```
106    pub fn write_fmt(&mut self, args: std::fmt::Arguments<'_>) {
107        std::fmt::Write::write_fmt(&mut self.buffer, args).unwrap()
108    }
109}
110
111impl std::ops::DerefMut for TestBuffer {
112    fn deref_mut(&mut self) -> &mut Self::Target {
113        &mut self.buffer
114    }
115}
116
117impl std::ops::Deref for TestBuffer {
118    type Target = String;
119
120    fn deref(&self) -> &Self::Target {
121        &self.buffer
122    }
123}