tinyharness_ui/tui/
backend.rs1use std::io::{self, Write};
8
9use super::terminal::Size;
10
11pub trait Backend: Write {
19 fn size(&self) -> Size;
21
22 fn flush(&mut self) -> io::Result<()> {
24 Ok(())
25 }
26}
27
28pub struct StdioBackend {
32 stdout: io::Stdout,
33}
34
35impl StdioBackend {
36 pub fn new() -> io::Result<Self> {
38 Ok(Self {
39 stdout: io::stdout(),
40 })
41 }
42}
43
44impl Default for StdioBackend {
45 fn default() -> Self {
46 Self::new().expect("failed to create StdioBackend")
47 }
48}
49
50impl Write for StdioBackend {
51 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
52 self.stdout.write(buf)
53 }
54
55 fn flush(&mut self) -> io::Result<()> {
56 self.stdout.flush()
57 }
58}
59
60impl Backend for StdioBackend {
61 fn size(&self) -> Size {
62 Size::from_terminal()
63 .unwrap_or_else(|_| Size::from_env().unwrap_or_else(Size::default_size))
64 }
65}
66
67pub struct TestBackend {
71 buffer: Vec<u8>,
72 size: Size,
73}
74
75impl TestBackend {
76 pub fn new(size: Size) -> Self {
78 Self {
79 buffer: Vec::new(),
80 size,
81 }
82 }
83
84 pub fn buffer(&self) -> &[u8] {
86 &self.buffer
87 }
88
89 pub fn take_buffer(&mut self) -> Vec<u8> {
91 std::mem::take(&mut self.buffer)
92 }
93
94 pub fn contains(&self, needle: &[u8]) -> bool {
96 self.buffer.windows(needle.len()).any(|w| w == needle)
97 }
98}
99
100impl Write for TestBackend {
101 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
102 self.buffer.extend_from_slice(buf);
103 Ok(buf.len())
104 }
105
106 fn flush(&mut self) -> io::Result<()> {
107 Ok(())
108 }
109}
110
111impl Backend for TestBackend {
112 fn size(&self) -> Size {
113 self.size
114 }
115}
116
117#[cfg(test)]
118mod tests {
119 use super::*;
120
121 #[test]
122 fn test_test_backend_write() {
123 let mut backend = TestBackend::new(Size::new(80, 24));
124 backend.write_all(b"hello").unwrap();
125 assert!(backend.contains(b"hello"));
126 }
127
128 #[test]
129 fn test_test_backend_take_buffer() {
130 let mut backend = TestBackend::new(Size::new(80, 24));
131 backend.write_all(b"hello").unwrap();
132 let buf = backend.take_buffer();
133 assert_eq!(&buf, b"hello");
134 assert!(backend.buffer().is_empty());
135 }
136
137 #[test]
138 fn test_test_backend_size() {
139 let backend = TestBackend::new(Size::new(120, 40));
140 let size = backend.size();
141 assert_eq!(size.cols, 120);
142 assert_eq!(size.rows, 40);
143 }
144
145 #[test]
146 fn test_test_backend_contains() {
147 let mut backend = TestBackend::new(Size::new(80, 24));
148 backend.write_all(b"\x1b[?1049h\x1b[2J").unwrap();
149 assert!(backend.contains(b"\x1b[?1049h"));
150 assert!(backend.contains(b"\x1b[2J"));
151 assert!(!backend.contains(b"\x1b[?25l"));
152 }
153
154 #[test]
155 fn test_stdio_backend_new() {
156 let backend = StdioBackend::new();
158 assert!(backend.is_ok());
159 }
160
161 #[test]
162 fn test_stdio_backend_size() {
163 let backend = StdioBackend::new().unwrap();
164 let size = backend.size();
165 assert!(size.cols > 0);
167 assert!(size.rows > 0);
168 }
169}