Enum TestStep 

pub enum TestStep {
    Command {
        command: String,
        expect: Option<CommandExpectation>,
    },
    Await {
        timeout: Option<u64>,
        expect: Option<StopExpectation>,
    },
    InspectLocals {
        asserts: Vec<VariableAssertion>,
    },
    InspectStack {
        asserts: Vec<FrameAssertion>,
    },
    CheckOutput {
        contains: Option<String>,
        equals: Option<String>,
    },
    Evaluate {
        expression: String,
        expect: Option<EvaluateExpectation>,
    },
}

A single test step in the execution flow

Variants

Command

Execute a debugger command

Fields

command: String

The command to execute (e.g., “break add main”, “continue”)

expect: Option<CommandExpectation>

Optional expectations for the command result

Await

Wait for a stop event (breakpoint, step completion, etc.)

Fields

timeout: Option<u64>

Timeout in seconds (default: 30)

expect: Option<StopExpectation>

Expected stop event properties

InspectLocals

Inspect local variables and make assertions

Fields

asserts: Vec<VariableAssertion>

Variable assertions to check

InspectStack

Inspect the call stack

Fields

asserts: Vec<FrameAssertion>

Frame assertions to check

CheckOutput

Check program output

Fields

contains: Option<String>

Expected substring in output

equals: Option<String>

Expected exact output

Evaluate

Evaluate an expression

Fields

expression: String

Expression to evaluate

expect: Option<EvaluateExpectation>

Expected result

Trait Implementations

impl Debug for TestStep

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TestStep

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.