Struct ratatui::backend::TestBackend

pub struct TestBackend { /* private fields */ }

A Backend implementation used for integration testing that that renders to an in memory buffer.

Note: that although many of the integration and unit tests in ratatui are written using this backend, it is preferable to write unit tests for widgets directly against the buffer rather than using this backend. This backend is intended for integration tests that test the entire terminal UI.

Example

use ratatui::{backend::TestBackend, prelude::*};

let mut backend = TestBackend::new(10, 2);
backend.clear()?;
backend.assert_buffer(&Buffer::with_lines(vec!["          "; 2]));

Implementations

impl TestBackend

pub fn new(width: u16, height: u16) -> Self

Creates a new TestBackend with the specified width and height.

pub const fn buffer(&self) -> &Buffer

Returns a reference to the internal buffer of the TestBackend.

pub fn resize(&mut self, width: u16, height: u16)

Resizes the TestBackend to the specified width and height.

pub fn assert_buffer(&self, expected: &Buffer)

Asserts that the TestBackend’s buffer is equal to the expected buffer. If the buffers are not equal, a panic occurs with a detailed error message showing the differences between the expected and actual buffers.

Trait Implementations

impl Backend for TestBackend

fn append_lines(&mut self, n: u16) -> Result<()>

Inserts n line breaks at the current cursor position.

After the insertion, the cursor x position will be incremented by 1 (unless it’s already at the end of line). This is a common behaviour of terminals in raw mode.

If the number of lines to append is fewer than the number of lines in the buffer after the cursor y position then the cursor is moved down by n rows.

If the number of lines to append is greater than the number of lines in the buffer after the cursor y position then that number of empty lines (at most the buffer’s height in this case but this limit is instead replaced with scrolling in most backend implementations) will be added after the current position and the cursor will be moved to the last row.

fn draw<'a, I>(&mut self, content: I) -> Result<()>

where I: Iterator<Item = (u16, u16, &'a Cell)>,

Draw the given content to the terminal screen.

fn hide_cursor(&mut self) -> Result<()>

Hide the cursor on the terminal screen.

fn show_cursor(&mut self) -> Result<()>

Show the cursor on the terminal screen.

fn get_cursor(&mut self) -> Result<(u16, u16)>

Get the current cursor position on the terminal screen.

fn set_cursor(&mut self, x: u16, y: u16) -> Result<()>

Set the cursor position on the terminal screen to the given x and y coordinates.

fn clear(&mut self) -> Result<()>

Clears the whole terminal screen

fn clear_region(&mut self, clear_type: ClearType) -> Result<()>

Clears a specific region of the terminal specified by the ClearType parameter

fn size(&self) -> Result<Rect>

Get the size of the terminal screen in columns/rows as a Rect.

fn window_size(&mut self) -> Result<WindowSize>

Get the size of the terminal screen in columns/rows and pixels as a WindowSize.

fn flush(&mut self) -> Result<()>

Flush any buffered content to the terminal screen.

impl Clone for TestBackend

fn clone(&self) -> TestBackend

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TestBackend

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TestBackend

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TestBackend

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the TestBackend for display by calling the buffer_view function on its internal buffer.

impl Hash for TestBackend

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TestBackend

fn eq(&self, other: &TestBackend) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TestBackend

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TestBackend

impl StructuralPartialEq for TestBackend