Struct re_viewer::external::egui_kittest::HarnessBuilder

pub struct HarnessBuilder<State = ()> {
    pub(crate) screen_rect: Rect,
    pub(crate) pixels_per_point: f32,
    pub(crate) max_steps: u64,
    pub(crate) step_dt: f32,
    pub(crate) state: PhantomData<State>,
    pub(crate) renderer: Box<dyn TestRenderer>,
}

Builder for Harness.

Fields

screen_rect: Rect

pixels_per_point: f32

max_steps: u64

step_dt: f32

state: PhantomData<State>

renderer: Box<dyn TestRenderer>

Implementations

impl<State> HarnessBuilder<State>

pub fn with_size(self, size: impl Into<Vec2>) -> HarnessBuilder<State>

Set the size of the window.

pub fn with_pixels_per_point( self, pixels_per_point: f32, ) -> HarnessBuilder<State>

Set the pixels_per_point of the window.

pub fn with_max_steps(self, max_steps: u64) -> HarnessBuilder<State>

Set the maximum number of steps to run when calling Harness::run.

Default is 4. With the default step_dt, this means 1 second of simulation.

pub fn with_step_dt(self, step_dt: f32) -> HarnessBuilder<State>

Set the time delta for a single Harness::step.

Default is 1.0 / 4.0 (4fps). The default is low so we don’t waste cpu waiting for animations.

pub fn renderer( self, renderer: impl TestRenderer + 'static, ) -> HarnessBuilder<State>

Set the TestRenderer to use for rendering.

By default, a LazyRenderer is used.

pub fn wgpu(self) -> HarnessBuilder<State>

Enable wgpu rendering with a default setup suitable for testing.

This sets up a crate::wgpu::WgpuTestRenderer with the default setup.

pub fn wgpu_setup(self, setup: WgpuSetup) -> HarnessBuilder<State>

Enable wgpu rendering with the given setup.

pub fn build_state<'a>( self, app: impl FnMut(&Context, &mut State) + 'a, state: State, ) -> Harness<'a, State>

Create a new Harness with the given app closure and a state.

The app closure will immediately be called once to create the initial ui.

If you don’t need to create Windows / Panels, you can use HarnessBuilder::build_ui instead.

Example

let checked = false;
let mut harness = Harness::builder()
    .with_size(egui::Vec2::new(300.0, 200.0))
    .build_state(|ctx, checked| {
        CentralPanel::default().show(ctx, |ui| {
            ui.checkbox(checked, "Check me!");
        });
    }, checked);

harness.get_by_label("Check me!").click();
harness.run();

assert_eq!(*harness.state(), true);

pub fn build_ui_state<'a>( self, app: impl FnMut(&mut Ui, &mut State) + 'a, state: State, ) -> Harness<'a, State>

Create a new Harness with the given ui closure and a state.

The ui closure will immediately be called once to create the initial ui.

If you need to create Windows / Panels, you can use HarnessBuilder::build instead.

Example

let mut checked = false;
let mut harness = Harness::builder()
    .with_size(egui::Vec2::new(300.0, 200.0))
    .build_ui_state(|ui, checked| {
       ui.checkbox(checked, "Check me!");
    }, checked);

harness.get_by_label("Check me!").click();
harness.run();

assert_eq!(*harness.state(), true);

pub fn build_eframe<'a>( self, build: impl FnOnce(&mut CreationContext<'a>) -> State, ) -> Harness<'a, State>

where State: App,

Create a new Harness from the given eframe creation closure. The app can be accessed via the Harness::state / Harness::state_mut methods.

impl HarnessBuilder

pub fn build<'a>(self, app: impl FnMut(&Context) + 'a) -> Harness<'a>

Create a new Harness with the given app closure.

The app closure will immediately be called once to create the initial ui.

If you don’t need to create Windows / Panels, you can use HarnessBuilder::build_ui instead.

Example

let mut harness = Harness::builder()
    .with_size(egui::Vec2::new(300.0, 200.0))
    .build(|ctx| {
        CentralPanel::default().show(ctx, |ui| {
            ui.label("Hello, world!");
        });
    });

pub fn build_ui<'a>(self, app: impl FnMut(&mut Ui) + 'a) -> Harness<'a>

Create a new Harness with the given ui closure.

The ui closure will immediately be called once to create the initial ui.

If you need to create Windows / Panels, you can use HarnessBuilder::build instead.

Example

let mut harness = Harness::builder()
    .with_size(egui::Vec2::new(300.0, 200.0))
    .build_ui(|ui| {
        ui.label("Hello, world!");
    });

Trait Implementations

impl<State> Default for HarnessBuilder<State>

fn default() -> HarnessBuilder<State>

Returns the “default value” for a type.