Struct ResultList 

pub struct ResultList { /* private fields */ }

An execution’s recorded results (ResultList).

A thin reader over the array the engine builds as a sequence runs. Only steps whose recording is enabled appear here, so the list is routinely shorter than the sequence, and a step that failed early can end a run before later steps record anything. See ResultRecordingOption.

Implementations

impl ResultList

pub fn from_result_object(result_object: &PropertyObject) -> Result<Self, Error>

Reads results from anything that exposes a ResultList property.

Accepts the results tree from Execution::result_object, which is where a headless caller finds them.

Errors

Error if the object holds no ResultList, or a COM call fails.

pub fn len(&self) -> Result<i32, Error>

How many results were recorded.

Errors

Error if the COM call fails.

pub fn is_empty(&self) -> Result<bool, Error>

Whether nothing was recorded.

Errors

Error if the COM call fails.

pub fn parse(&self) -> Result<Vec<StepResult>, Error>

Reads every result into plain data.

Each field is optional in the tree, and a missing one is normal rather than an error: an action step records no measurement, and a result written by a custom step type may carry neither name nor type. Missing text becomes empty, a missing measurement becomes None.

Errors

Error if the list cannot be walked.

Examples found in repository

examples/result_list_parse.rs (line 140)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let engine = Engine::new()?;
    engine.set_ui_message_polling_enabled(true)?;

    let sequence_file = engine.new_sequence_file()?;
    let main_sequence = sequence_file.get_sequence_by_name("MainSequence")?;

    add_pass_fail(&engine, &main_sequence, "Verify Power Rail", "True")?;
    add_unrecorded_filler(&engine, &main_sequence, "Filler (not recorded)")?;
    add_numeric(
        &engine,
        &main_sequence,
        "Verify Current Draw",
        "1.5",
        1.0,
        2.0,
    )?;
    add_pass_fail(&engine, &main_sequence, "Verify Ground Bond", "True")?;

    let step_count = main_sequence.get_num_steps(StepGroup::Main)?;
    println!("Running {step_count} steps...");
    let execution = engine.new_execution(&sequence_file, "MainSequence", None, false, 0)?;

    if !wait_for_end(&engine, RUN_DEADLINE)? {
        println!("The run did not finish within {RUN_DEADLINE:?}; terminating.");
        execution.terminate()?;
        return Ok(());
    }
    println!("Finished with status: {}\n", execution.result_status()?);

    let results = execution.result_list()?;
    let parsed = results.parse()?;

    println!("{} of {step_count} steps recorded a result:", parsed.len());
    for (index, result) in parsed.iter().enumerate() {
        let measurement = match &result.value {
            Some(ResultValue::Number(number)) => format!("measured {number}"),
            Some(ResultValue::Text(text)) => format!("measured {text:?}"),
            None => "no measurement".to_owned(),
        };
        println!(
            "  [{index}] {} ({}) -> {}, {measurement}",
            result.name, result.step_type, result.status
        );
    }

    // The step whose recording was switched off is absent, by design.
    println!(
        "\nThe unrecorded step left no entry, which is why {} < {step_count}.",
        parsed.len()
    );

    // The parsed results are plain data, so they outlive the run and can be
    // handed to anything: a report writer, a database, a serde format.
    let failures: Vec<&str> = parsed
        .iter()
        .filter(|result| result.status == "Failed")
        .map(|result| result.name.as_str())
        .collect();
    if failures.is_empty() {
        println!("No failures.");
    } else {
        println!("Failed steps: {}", failures.join(", "));
    }

    engine.release_sequence_file_ex(sequence_file, none())?;
    Ok(())
}

pub const fn as_property_object(&self) -> &PropertyObject

The underlying array, for a caller that wants to walk it itself.

Trait Implementations

impl Debug for ResultList

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

Formats the value using the given formatter.