Skip to main content

test_buffer/
lib.rs

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