Struct requestty_ui::backend::TestBackend

source · [−]
pub struct TestBackend { /* private fields */ }
Expand description

A backend that can be used for tests.

When asserting equality, it is recommended to use TestBackend::assert_eq or assert_backend_snapshot instead of assert_eq.

Implementations

Creates a new TestBackend

Creates a new TestBackend with the cursor starting at the offsets given by the layout.

Creates a new TestBackend from the lines. There must be <= size.height lines, and <= size.width chars per line.

It is not necessary to fill the lines so that it matches the dimensions of size exactly. Padding will be added to the end as required.

Panics

It panics if there are more than size.height lines or more than size.width chars per line.

Clears all the cells and moves the cursor to the offsets given by the layout.

Asserts that two TestBackends are equal to each other, otherwise it panics printing what the backend would look like.

Writes all the cells of the TestBackend to the given backend.

A screenshot of what the printed output looks like:

Available on crate features crossterm or termion only.

Writes all the cells of the TestBackend with the default backend (see get_backend).

A screenshot of what the printed output looks like:

Trait Implementations

Enables raw mode.

Disables raw mode.

Hides the cursor.

Shows the cursor.

Gets the cursor position as (col, row). The top-left cell is (0, 0).

Moves the cursor to given position. The top-left cell is (0, 0).

Moves the cursor relative to the current position as per the direction.

Scrolls the terminal the given number of rows. Read more

Sets the given attributes removing ones which were previous applied.

Sets the foreground color.

Sets the background color.

Clears the cells given by clear_type

Gets the size of the terminal in rows and columns.

Write a styled object to the backend. Read more

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Writes all the cells of the TestBackend using write_to_buf.

A screenshot of what the printed output looks like:

Visual equality to another backend. This means that if the cells of both backends were rendered on a terminal, they would look the same. It however does not mean, that the hidden scrollback buffer is the same, or the current attributes are the same, or event the cursor position if it is hidden.

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

Write a buffer into this writer, returning how many bytes were written. Read more

Flush this output stream, ensuring that all intermediately buffered contents reach their destination. Read more

Like write, except that it writes from a slice of buffers. Read more

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation. Read more

Attempts to write an entire buffer into this writer. Read more

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer. Read more

Writes a formatted string into this writer, returning any error encountered. Read more

Creates a “by reference” adapter for this instance of Write. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

How many ANSI colors are supported (from 8 to 256)? Read more

Get the (1,1)-based cursor position from the terminal.

Executes the given command directly.

The given command its ANSI escape code will be written and flushed onto Self.

Arguments

  • Command

    The command that you want to execute directly.

Example
use std::io::{Write, stdout};

use crossterm::{Result, ExecutableCommand, style::Print};

 fn main() -> Result<()> {
     // will be executed directly
      stdout()
        .execute(Print("sum:\n".to_string()))?
        .execute(Print(format!("1 + 1= {} ", 1 + 1)))?;

      Ok(())

     // ==== Output ====
     // sum:
     // 1 + 1 = 2
 }

Have a look over at the Command API for more details.

Notes
  • In the case of UNIX and Windows 10, ANSI codes are written to the given ‘writer’.
  • In case of Windows versions lower than 10, a direct WinAPI call will be made. The reason for this is that Windows versions lower than 10 do not support ANSI codes, and can therefore not be written to the given writer. Therefore, there is no difference between execute and queue for those old Windows versions.

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Switch to raw mode. Read more

Queues the given command for further execution.

Queued commands will be executed in the following cases:

  • When flush is called manually on the given type implementing io::Write.
  • The terminal will flush automatically if the buffer is full.
  • Each line is flushed in case of stdout, because it is line buffered.
Arguments

  • Command

    The command that you want to queue for later execution.

Examples
use std::io::{Write, stdout};

use crossterm::{Result, QueueableCommand, style::Print};

 fn main() -> Result<()> {
    let mut stdout = stdout();

    // `Print` will executed executed when `flush` is called.
    stdout
        .queue(Print("foo 1\n".to_string()))?
        .queue(Print("foo 2".to_string()))?;

    // some other code (no execution happening here) ...

    // when calling `flush` on `stdout`, all commands will be written to the stdout and therefore executed.
    stdout.flush()?;

    Ok(())

    // ==== Output ====
    // foo 1
    // foo 2
}

Have a look over at the Command API for more details.

Notes
  • In the case of UNIX and Windows 10, ANSI codes are written to the given ‘writer’.
  • In case of Windows versions lower than 10, a direct WinAPI call will be made. The reason for this is that Windows versions lower than 10 do not support ANSI codes, and can therefore not be written to the given writer. Therefore, there is no difference between execute and queue for those old Windows versions.

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

Uses borrowed data to replace owned data, usually by cloning. Read more

Converts the given value to a String. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.