use std::io::{self, Write};
use super::terminal::Size;
pub trait Backend: Write {
fn size(&self) -> Size;
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
pub struct StdioBackend {
stdout: io::Stdout,
}
impl StdioBackend {
pub fn new() -> io::Result<Self> {
Ok(Self {
stdout: io::stdout(),
})
}
}
impl Default for StdioBackend {
fn default() -> Self {
Self::new().expect("failed to create StdioBackend")
}
}
impl Write for StdioBackend {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.stdout.write(buf)
}
fn flush(&mut self) -> io::Result<()> {
self.stdout.flush()
}
}
impl Backend for StdioBackend {
fn size(&self) -> Size {
Size::from_terminal()
.unwrap_or_else(|_| Size::from_env().unwrap_or_else(Size::default_size))
}
}
pub struct TestBackend {
buffer: Vec<u8>,
size: Size,
}
impl TestBackend {
pub fn new(size: Size) -> Self {
Self {
buffer: Vec::new(),
size,
}
}
pub fn buffer(&self) -> &[u8] {
&self.buffer
}
pub fn take_buffer(&mut self) -> Vec<u8> {
std::mem::take(&mut self.buffer)
}
pub fn contains(&self, needle: &[u8]) -> bool {
self.buffer.windows(needle.len()).any(|w| w == needle)
}
}
impl Write for TestBackend {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.buffer.extend_from_slice(buf);
Ok(buf.len())
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
impl Backend for TestBackend {
fn size(&self) -> Size {
self.size
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_test_backend_write() {
let mut backend = TestBackend::new(Size::new(80, 24));
backend.write_all(b"hello").unwrap();
assert!(backend.contains(b"hello"));
}
#[test]
fn test_test_backend_take_buffer() {
let mut backend = TestBackend::new(Size::new(80, 24));
backend.write_all(b"hello").unwrap();
let buf = backend.take_buffer();
assert_eq!(&buf, b"hello");
assert!(backend.buffer().is_empty());
}
#[test]
fn test_test_backend_size() {
let backend = TestBackend::new(Size::new(120, 40));
let size = backend.size();
assert_eq!(size.cols, 120);
assert_eq!(size.rows, 40);
}
#[test]
fn test_test_backend_contains() {
let mut backend = TestBackend::new(Size::new(80, 24));
backend.write_all(b"\x1b[?1049h\x1b[2J").unwrap();
assert!(backend.contains(b"\x1b[?1049h"));
assert!(backend.contains(b"\x1b[2J"));
assert!(!backend.contains(b"\x1b[?25l"));
}
#[test]
fn test_stdio_backend_new() {
let backend = StdioBackend::new();
assert!(backend.is_ok());
}
#[test]
fn test_stdio_backend_size() {
let backend = StdioBackend::new().unwrap();
let size = backend.size();
assert!(size.cols > 0);
assert!(size.rows > 0);
}
}