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