Struct TestAppWindow 

pub struct TestAppWindow<V> { /* private fields */ }

A window opened by TestApp::open_window.

Use it to read and update the root view and to send input to the window. Clones refer to the same window.

Each method that sends input or updates the view runs pending tasks before it returns, so the next line can assert on the result. The simulated input methods use the window’s last painted frame to find elements, so call TestAppWindow::draw after building or changing the view.

Implementations

impl<V: 'static + Render> TestAppWindow<V>

pub fn handle(&self) -> WindowHandle<V>

Returns the window’s handle, for APIs that take a WindowHandle.

pub fn root(&self) -> Entity<V>

Returns the root view’s entity.

Panics

Panics if the window has been closed.

pub fn update<R>( &mut self, f: impl FnOnce(&mut V, &mut Window, &mut Context<'_, V>) -> R, ) -> R

Runs f with the root view, its Window and a Context, then runs pending tasks until parked.

Panics

Panics if the window has been closed.

pub fn read<R>(&self, f: impl FnOnce(&V, &App) -> R) -> R

Runs f with the root view and the App, without running pending tasks.

Panics

Panics if the window has been closed.

pub fn title(&self) -> Option<String>

Always returns None. The window title isn’t available through this type yet.

Don’t use this to check a title. Tests that open windows with TestAppContext::add_window_view can read the title with VisualTestContext::window_title.

Panics

Panics if the window has been closed.

Example

let mut app = TestApp::new();
let window = app.open_window(|_, _| Empty);
assert_eq!(window.title(), None);

pub fn simulate_keystroke(&mut self, keystroke: &str)

Sends one keystroke, such as "ctrl-s" or "space", to the focused element, then runs pending tasks.

Use the key name "space" for the space bar. A space character in the string isn’t a separator here; TestAppWindow::simulate_keystrokes splits on spaces.

Panics

Panics if keystroke isn’t a valid keystroke. See keyboard input for the syntax.

Example

window.simulate_keystroke("space");
window.read(|keys, _| assert_eq!(keys.last.as_deref(), Some("space")));

pub fn simulate_keystrokes(&mut self, keystrokes: &str)

Sends each keystroke in a space-separated list, in order, then runs pending tasks after each one.

Each part is parsed as in TestAppWindow::simulate_keystroke. A space character in the list is a separator, so use simulate_keystroke("space") to press the space bar. Two spaces in a row send an empty keystroke.

Panics

Panics if any part isn’t a valid keystroke.

Example

window.simulate_keystrokes("a b");
window.read(|keys, _| assert_eq!(keys.last.as_deref(), Some("b")));

pub fn simulate_input(&mut self, input: &str)

Types input by sending one keystroke per character, then runs pending tasks.

Each character is sent as a keystroke whose key is that character, so text inputs receive the text. Uppercase letters are sent with shift held. A space is sent with the key " ", not "space", so a binding for space doesn’t match it. Use TestAppWindow::simulate_keystroke for named keys.

Example

window.simulate_input("xy");
window.read(|keys, _| assert_eq!(keys.last.as_deref(), Some("y")));

pub fn simulate_mouse_move(&mut self, position: Point<Pixels>)

Moves the pointer to position with no button held, then runs pending tasks.

pub fn simulate_mouse_down( &mut self, position: Point<Pixels>, button: MouseButton, )

Presses button at position, then runs pending tasks.

The click count is always 1, so this never sends a double click.

pub fn simulate_mouse_up( &mut self, position: Point<Pixels>, button: MouseButton, )

Releases button at position, then runs pending tasks.

The click count is always 1.

pub fn simulate_click(&mut self, position: Point<Pixels>, button: MouseButton)

Presses and releases button at position, then runs pending tasks.

Both events have a click count of 1, so calling this twice in a row sends two single clicks, never a double click. Call TestAppWindow::draw first, so the click hits the element you expect. See the example on TestApp.

pub fn simulate_scroll(&mut self, position: Point<Pixels>, delta: Point<Pixels>)

Scrolls by delta, in pixels, with the pointer at position, then runs pending tasks.

No modifier keys are held.

pub fn simulate_event<E: InputEvent>(&mut self, event: E)

Dispatches event to the window as platform input, then runs pending tasks.

Use this for input events that have no dedicated method on TestAppWindow.

pub fn simulate_resize(&mut self, size: Size<Pixels>)

Sets the window’s size to size, then runs pending tasks.

This runs the window’s resize callback, if it has one, and updates the viewport that Window::viewport_size reports. It doesn’t paint the window: call TestAppWindow::draw to paint at the new size.

pub fn activate(&mut self)

Makes this the active window, as if the user had clicked it, then runs pending tasks.

Windows that TestApp opens start inactive. Focus listeners such as Context::on_focus only run in the active window, so activate it before testing them.

pub fn simulate_scale_factor_change(&mut self, scale_factor: f32)

Simulate the window moving to a display with a different scale factor.

pub fn draw(&mut self)

Paints the window now, so that later input and hit tests use the current layout.

Call this after building the view and after anything changes its layout, before simulating a click at a position. It doesn’t run pending tasks. See the example on TestApp.

Trait Implementations

impl<V> Clone for TestAppWindow<V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.