py-teststand 0.2.3__tar.gz → 0.3.0__tar.gz

{py_teststand-0.2.3 → py_teststand-0.3.0}/CLAUDE.md

@@ -56,6 +56,11 @@ understanding the runtime environment:
   callbacks, code templates, adapter support files, and the Python helper scripts
   used by the Python adapter (`Bin\ni_teststand_python_*.py`).
 
+- **Sequence File Converter** — TestStand provides a command-line utility at
+  `C:\Program Files\National Instruments\TestStand 2026\Bin\SequenceFileConverter.exe`
+  to convert sequence files between binary and XML formats (e.g. using `-Format:XML` or
+  `-Format:Binary` options) to facilitate inspection.
+
 - **Station config dir** — `C:\ProgramData\National Instruments\TestStand 2026 (64-bit)\Cfg\`
   Per-station configuration: `SearchDirectories.cfg`, `Adapters.cfg`,
   `GeneralEngine.cfg`, `StationGlobals.ini`, `Users.ini`, `TypePalettes.cfg`,
@@ -217,6 +222,7 @@ Prefer extending this facade over deep imports in user-facing code and examples.
 - No cryptic abbreviations in code or tests: `property_object` not `po`,
   `sequence_file` not `sf`, `sequence` not `seq`, `engine` not `eng`,
   `execution` not `exe`, `sequence_context` not `ctx`.
+- Do not use "TestStand" prefixes in documentation, docstrings, or variables (e.g., say "live engine" instead of "live TestStand Engine", "ResultList array" instead of "TestStand ResultList array"). The user already knows this library wraps TestStand. Refer to the COM objects directly by their interface names.
 - Examples in `examples/` double as documentation and as inputs for other tools,
   so they must run end to end and import only from the top-level `py_teststand`.
 

{py_teststand-0.2.3 → py_teststand-0.3.0}/GEMINI.md

@@ -6,3 +6,6 @@ This file directs Gemini (Antigravity) and any other AI coding assistant working
 You must **always** read and strictly follow the guidelines, architectural rules, and project-specific memory stored in `CLAUDE.md`. 
 
 The `CLAUDE.md` file acts as the ultimate source of truth for repository conventions, TestStand COM interactions, typing rules (`ANN401`), and testing procedures. Treat the contents of `CLAUDE.md` as if they were written directly in this file.
+
+**DOCUMENTATION RULE:**
+Do not use "TestStand" prefixes in documentation, docstrings, or variables (e.g., say "live engine" instead of "live TestStand Engine", "ResultList array" instead of "TestStand ResultList array"). The user already knows this library wraps TestStand bindings. Refer to the COM objects directly by their interface names.

{py_teststand-0.2.3 → py_teststand-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-teststand
-Version: 0.2.3
+Version: 0.3.0
 Summary: Community object-oriented Python 3 bindings for the National Instruments TestStand™ COM API
 Project-URL: Repository, https://github.com/TheDomcio/py-teststand
 Project-URL: Issues, https://github.com/TheDomcio/py-teststand/issues
@@ -156,6 +156,7 @@ EXAMPLES: list[tuple[str, str]] = [
     ("users_manage", "Create users and set their privileges."),
     ("execution_run_test_headless", "Run real pass/fail tests and read their numeric results."),
     ("ui_messages_handle", "Receive UI messages from a running sequence without a GUI."),
+    ("result_list_parse", "Parse a sequence execution's ResultList array."),
     (
         "execution_run_subsequence",
         "Run a sequence and read its results. Last; it shuts the engine down.",
@@ -206,7 +207,7 @@ pip install py-teststand
 ## 🔗 Compatibility
 
 | Component                                              | Versions                                                                                      |
-|--------------------------------------------------------|-----------------------------------------------------------------------------------------------|
+| ------------------------------------------------------ | --------------------------------------------------------------------------------------------- |
 | **[Windows](https://www.microsoft.com/en-us/windows)** | 7 to 11                                                                                       |
 | **[Python](https://www.python.org/downloads/)**        | 3.8 to 3.14                                                                                   |
 | **[TestStand™][ni-teststand-api-reference]**           | [2016 to 2026](https://www.ni.com/docs/en-US/bundle/teststand/page/year-based-and-major.html) |
@@ -271,7 +272,7 @@ long-lived COM interfaces that exist across the supported range.
 ## 🧰 Technical Stack
 
 | Tool                                             | Purpose                                                     |
-|--------------------------------------------------|-------------------------------------------------------------|
+| ------------------------------------------------ | ----------------------------------------------------------- |
 | **[uv](https://github.com/astral-sh/uv)**        | Python package and project manager                          |
 | **[ty](https://github.com/astral-sh/ty)**        | Static type checker for interface validation                |
 | **[ruff](https://github.com/astral-sh/ruff)**    | Linter and code formatter (with strict rules)               |

{py_teststand-0.2.3 → py_teststand-0.3.0}/README.md

@@ -120,6 +120,7 @@ EXAMPLES: list[tuple[str, str]] = [
     ("users_manage", "Create users and set their privileges."),
     ("execution_run_test_headless", "Run real pass/fail tests and read their numeric results."),
     ("ui_messages_handle", "Receive UI messages from a running sequence without a GUI."),
+    ("result_list_parse", "Parse a sequence execution's ResultList array."),
     (
         "execution_run_subsequence",
         "Run a sequence and read its results. Last; it shuts the engine down.",
@@ -170,7 +171,7 @@ pip install py-teststand
 ## 🔗 Compatibility
 
 | Component                                              | Versions                                                                                      |
-|--------------------------------------------------------|-----------------------------------------------------------------------------------------------|
+| ------------------------------------------------------ | --------------------------------------------------------------------------------------------- |
 | **[Windows](https://www.microsoft.com/en-us/windows)** | 7 to 11                                                                                       |
 | **[Python](https://www.python.org/downloads/)**        | 3.8 to 3.14                                                                                   |
 | **[TestStand™][ni-teststand-api-reference]**           | [2016 to 2026](https://www.ni.com/docs/en-US/bundle/teststand/page/year-based-and-major.html) |
@@ -235,7 +236,7 @@ long-lived COM interfaces that exist across the supported range.
 ## 🧰 Technical Stack
 
 | Tool                                             | Purpose                                                     |
-|--------------------------------------------------|-------------------------------------------------------------|
+| ------------------------------------------------ | ----------------------------------------------------------- |
 | **[uv](https://github.com/astral-sh/uv)**        | Python package and project manager                          |
 | **[ty](https://github.com/astral-sh/ty)**        | Static type checker for interface validation                |
 | **[ruff](https://github.com/astral-sh/ruff)**    | Linter and code formatter (with strict rules)               |

{py_teststand-0.2.3 → py_teststand-0.3.0}/examples/execution_run_subsequence.py

@@ -12,7 +12,7 @@ engine without external dependencies.
 
 from __future__ import annotations
 
-from py_teststand import AdapterKeyName, Engine, StepGroup
+from py_teststand import AdapterKeyName, Engine, StepGroup, ResultList
 
 
 def main() -> None:
@@ -42,14 +42,9 @@ def main() -> None:
                 if result_list_obj is None:
                     return
 
-                with result_list_obj as result_list:
-                    for step_result in result_list:
-                        if step_result is None:
-                            continue
-                        with step_result as sr:
-                            name = sr.get_val_string("TS.StepName", 0)
-                            status = sr.get_val_string("Status", 0)
-                            print(f"{name}: {status}")
+                parsed_results = ResultList(result_list_obj._com_obj).parse()
+                for result in parsed_results:
+                    print(f"{result['name']}: {result['status']}")
 
 
 if __name__ == "__main__":

{py_teststand-0.2.3 → py_teststand-0.3.0}/examples/execution_run_test_headless.py

@@ -21,7 +21,7 @@ records Passed or Failed, which we read from each entry in the ResultList.
 
 from __future__ import annotations
 
-from py_teststand import AdapterKeyName, Engine, Sequence, StepGroup
+from py_teststand import AdapterKeyName, Engine, Sequence, StepGroup, ResultList
 
 # (name, measurement expression, low limit, high limit)
 TESTS: list[tuple[str, str, float, float]] = [
@@ -60,15 +60,15 @@ def main() -> None:
                 print("No results recorded.")
                 return
 
+            parsed_results = ResultList(result_list._com_obj).parse()
+
             all_passed = True
-            with result_list as results:
-                for step_result in results:
-                    with step_result as result:
-                        name = result.get_val_string("TS.StepName", 0)
-                        status = result.get_val_string("Status", 0)
-                        numeric = result.get_val_number("Numeric", 0)
-                        print(f"  {name}: {status} (measured {numeric})")
-                        all_passed = all_passed and status == "Passed"
+            for result in parsed_results:
+                name = result["name"]
+                status = result["status"]
+                numeric = result["value"]
+                print(f"  {name}: {status} (measured {numeric})")
+                all_passed = all_passed and status == "Passed"
 
         print(f"\nOverall: {'PASSED' if all_passed else 'FAILED'}")
 

{py_teststand-0.2.3 → py_teststand-0.3.0}/examples/launch_all_examples.py

@@ -21,6 +21,7 @@ EXAMPLES: list[tuple[str, str]] = [
     ("users_manage", "Create users and set their privileges."),
     ("execution_run_test_headless", "Run real pass/fail tests and read their numeric results."),
     ("ui_messages_handle", "Receive UI messages from a running sequence without a GUI."),
+    ("result_list_parse", "Parse a sequence execution's ResultList array."),
     (
         "execution_run_subsequence",
         "Run a sequence and read its results. Last; it shuts the engine down.",

py_teststand-0.3.0/examples/result_list_parse.py

@@ -0,0 +1,75 @@
+"""Walk and parse execution results into Python dictionaries.
+
+Builds a sequence with test steps, runs it, then shows two ways to
+retrieve the parsed ResultList:
+
+1. Object-oriented approach via execution.result_list.
+2. Passing a raw COM/PropertyObject ResultList directly to ResultList().
+"""
+
+from __future__ import annotations
+
+import json
+
+from py_teststand import (
+    AdapterKeyName,
+    Engine,
+    ResultList,
+    StepGroup,
+)
+
+
+def main() -> None:
+    with Engine() as engine:
+        sequence_file = engine.new_sequence_file()
+        main_sequence = sequence_file.get_sequence_by_name("MainSequence")
+
+        # Pass/Fail Test — forces pass
+        step1 = engine.new_step(AdapterKeyName.NoneAdapterKeyName, "PassFailTest")
+        step1.name = "Verify Power Rail"
+        step1.record_result = True
+        step1.as_property_object()["DataSource"] = "True"
+        main_sequence.insert_step(step1, 0, StepGroup.Main)
+
+        # Numeric Limit Test - forces 1.5 against 1.0-2.0 limits
+        step2 = engine.new_step(AdapterKeyName.NoneAdapterKeyName, "NumericLimitTest")
+        step2.name = "Verify Current Draw"
+        step2.record_result = True
+        step_properties = step2.as_property_object()
+        step_properties["DataSource"] = "1.5"
+        step_properties["Limits.Low"] = 1.0
+        step_properties["Limits.High"] = 2.0
+        main_sequence.insert_step(step2, 1, StepGroup.Main)
+
+        # Execute the sequence
+        print("Running sequence...")
+        with engine.new_execution(sequence_file, "MainSequence") as execution:
+            execution.wait_for_end_ex(-1)
+
+            # Approach 1: Object-oriented approach (directly on Execution object)
+            # The execution.result_list property automatically extracts and parses
+            # the ResultList array internally.
+            parsed_results = execution.result_list.parse()
+
+            print("\nApproach 1 - execution.result_list:")
+            for index, result in enumerate(parsed_results):
+                print(
+                    f"  [{index}] {result['name']} "
+                    f"({result['type']}) -> {result['status']}, "
+                    f"Value: {result['value']}"
+                )
+
+            # Approach 2: Universal helper class
+            # You can also pass an Execution or SequenceContext
+            # directly to ResultList().
+            result_list = ResultList(execution).parse()
+
+            print("\nApproach 2 - ResultList(execution).parse():")
+            for index, result in enumerate(result_list):
+                print(f"  [{index}] {result['name']} ({result['type']}) -> {result['status']}")
+            print("\nSerialized JSON Report:")
+            print(json.dumps(parsed_results, indent=4))
+
+
+if __name__ == "__main__":
+    main()

{py_teststand-0.2.3 → py_teststand-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "py-teststand"
-version = "0.2.3"
+version = "0.3.0"
 description = "Community object-oriented Python 3 bindings for the National Instruments TestStand™ COM API"
 readme = "README.md"
 # Last supported by uv 0.11.15 (3cffe97c2 2026-05-18 x86_64-pc-windows-msvc)
@@ -19,7 +19,7 @@ keywords = [
     "windows",
     "sugaring",
     "scripting",
-    "python"
+    "python",
 ]
 authors = [{ name = "Dominik Rajchel" }]
 license = { text = "MIT" }
@@ -68,8 +68,27 @@ target-version = "py38"
 
 [tool.ruff.lint]
 # Added "ANN" to enforce type annotations
-select = ["E", "F", "I", "N", "W", "B", "C4", "UP", "ARG", "PTH", "RUF", "FA", "PGH", "FLY", "ANN"]
-per-file-ignores = { "tests/**" = ["N801", "ANN"] } # Ignore typing enforcements in test files
+select = [
+    "E",
+    "F",
+    "I",
+    "N",
+    "W",
+    "B",
+    "C4",
+    "UP",
+    "ARG",
+    "PTH",
+    "RUF",
+    "FA",
+    "PGH",
+    "FLY",
+    "ANN",
+]
+per-file-ignores = { "tests/**" = [
+    "N801",
+    "ANN",
+] } # Ignore typing enforcements in test files
 unfixable = []
 fixable = ["ALL"]
 
@@ -81,7 +100,13 @@ suppress-dummy-args = true
 [tool.ruff.lint.isort]
 combine-as-imports = true
 known-first-party = ["py_teststand"]
-section-order = ["future", "standard-library", "third-party", "first-party", "local-folder"]
+section-order = [
+    "future",
+    "standard-library",
+    "third-party",
+    "first-party",
+    "local-folder",
+]
 
 [tool.ruff.format]
 quote-style = "double"
@@ -133,10 +158,7 @@ publish-url = "https://test.pypi.org/legacy/"
 explicit = true
 
 [tool.pyrefly]
-project-includes = [
-    "**/*.py*",
-    "**/*.ipynb",
-]
+project-includes = ["**/*.py*", "**/*.ipynb"]
 
 [[tool.uv.index]]
 name = "pypi"

{py_teststand-0.2.3 → py_teststand-0.3.0}/src/py_teststand/__init__.py

@@ -116,6 +116,9 @@ from .execution.edit_args import EditArgs
 from .execution.execution import Execution, ExecutionTypeMask
 from .execution.interactive_args import InteractiveArgs, InteractiveContext
 from .execution.report import Report, ReportConversion, Reports, ReportSection, ReportSections
+from .execution.result_list import (
+    ResultList,
+)
 from .execution.result_log import ResultLog, ResultLogger, ResultLogRecordType
 from .execution.sync_manager import (
     AutoReleaser,
@@ -286,6 +289,7 @@ __all__ = [
     "ReportSection",
     "ReportSections",
     "Reports",
+    "ResultList",
     "ResultLog",
     "ResultLogRecordType",
     "ResultLogger",

{py_teststand-0.2.3 → py_teststand-0.3.0}/src/py_teststand/execution/execution.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
     from py_teststand.adapters.sequence import NewThreadOption
     from py_teststand.core.engine import RTEOption
     from py_teststand.execution.output_record_stream import ExecutionOutputRecordStreams
+    from py_teststand.execution.result_list import ResultList
     from py_teststand.execution.thread import Thread
     from py_teststand.sequence.sequence import Sequence
     from py_teststand.sequence.sequence_file import SequenceFile
@@ -362,6 +363,13 @@ class Execution(COMWrapper):
     def result_object(self) -> PropertyObject:
         return PropertyObject(self._com_obj.ResultObject, self._engine_ref)
 
+    @property
+    @ts_interface
+    def result_list(self) -> ResultList:
+        from py_teststand.execution.result_list import ResultList
+
+        return ResultList(self)
+
     @property
     @ts_interface
     def result_status(self) -> str:

py_teststand-0.3.0/src/py_teststand/execution/result_list.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import typing
+
+from py_teststand.property.property_object import PropertyObject
+from py_teststand.sequence.sequence_context import SequenceContext
+
+if typing.TYPE_CHECKING:
+    pass
+
+
+class ResultList:
+    """Wrapper class for ResultList property, handling type casting automatically."""
+
+    def __init__(self, obj: typing.Any) -> None:  # noqa: ANN401
+        """Initialize with an Execution, SequenceContext, PropertyObject, or raw COM object."""
+        self._target = obj
+
+    def _walk(
+        self, result_list: PropertyObject, parent_sequence: str = ""
+    ) -> typing.Iterator[dict[str, typing.Any]]:
+        """Walks a ResultList array and yields each step result as a dict.
+
+        Args:
+            result_list: A PropertyObject wrapping the ResultList array.
+            parent_sequence: Name of the parent sequence for context.
+
+        Yields:
+            One dict per step result with name, type, status, value, limits, etc.
+        """
+        if not result_list.is_array:
+            return
+
+        num_elements = result_list.get_num_elements()
+        for i in range(num_elements):
+            step_result_object = result_list.get_property_object_by_offset(i, 0)
+            if step_result_object is None:
+                continue
+
+            with step_result_object as result:
+                try:
+                    # TS.* standard result properties
+                    name = (
+                        result.get_val_string("TS.StepName")
+                        if result.exists("TS.StepName")
+                        else "Unknown"
+                    )
+                    step_type = (
+                        result.get_val_string("TS.StepType") if result.exists("TS.StepType") else ""
+                    )
+                    status = result.get_val_string("Status") if result.exists("Status") else ""
+
+                    # Error subproperty
+                    error_msg = ""
+                    error_code = 0
+                    if result.exists("Error.Msg"):
+                        error_msg = result.get_val_string("Error.Msg")
+                    if result.exists("Error.Code"):
+                        error_code = int(result.get_val_number("Error.Code"))
+
+                    # Step-type-specific value (Numeric, String, or PassFail)
+                    value: typing.Any = None
+                    if result.exists("Numeric"):
+                        value = result.get_val_number("Numeric")
+                    elif result.exists("String"):
+                        value = result.get_val_string("String")
+                    elif result.exists("PassFail"):
+                        value = result.get_val_boolean("PassFail")
+
+                    # Limits subproperty
+                    limits: dict[str, typing.Any] = {}
+                    limits_path = ""
+                    if result.exists("Limits"):
+                        limits_path = "Limits"
+                    elif result.exists("RawLimits"):
+                        limits_path = "RawLimits"
+
+                    if limits_path:
+                        limits_object = result.get_property_object(limits_path)
+                        if limits_object is not None:
+                            with limits_object as limits_properties:
+                                if limits_properties.exists("Low"):
+                                    limits["low"] = limits_properties.get_val_number("Low")
+                                if limits_properties.exists("High"):
+                                    limits["high"] = limits_properties.get_val_number("High")
+                                if limits_properties.exists("String"):
+                                    limits["string"] = limits_properties.get_val_string("String")
+
+                    # Measurement array (MultipleNumericLimitTest)
+                    measurements: list[dict[str, typing.Any]] = []
+                    if result.exists("Measurement"):
+                        measurement_array = result.get_property_object("Measurement")
+                        if measurement_array is not None and measurement_array.is_array:
+                            for j in range(measurement_array.get_num_elements()):
+                                measurement_item = measurement_array.get_property_object_by_offset(
+                                    j
+                                )
+                                if measurement_item is not None:
+                                    with measurement_item as measurement_properties:
+                                        has_val = measurement_properties.exists("Measurement")
+                                        measurement_value = (
+                                            measurement_properties.get_val_number("Measurement")
+                                            if has_val
+                                            else None
+                                        )
+                                        has_status = measurement_properties.exists("Status")
+                                        measurement_status = (
+                                            measurement_properties.get_val_string("Status")
+                                            if has_status
+                                            else ""
+                                        )
+                                        measurements.append(
+                                            {
+                                                "value": measurement_value,
+                                                "status": measurement_status,
+                                            }
+                                        )
+
+                    # Nested subsequence ResultList
+                    has_nested = False
+                    nested_list = None
+                    nested_sequence_name = name
+
+                    if result.exists("TS.SequenceCall.ResultList"):
+                        has_nested = True
+                        nested_list = result.get_property_object("TS.SequenceCall.ResultList")
+                        if result.exists("TS.SequenceCall.Sequence"):
+                            nested_sequence_name = result.get_val_string("TS.SequenceCall.Sequence")
+                    elif result.exists("ResultList"):
+                        has_nested = True
+                        nested_list = result.get_property_object("ResultList")
+
+                except Exception as e:
+                    # Catch COM errors so a single bad element doesn't kill the loop
+                    name = "Unknown (Parser Error)"
+                    step_type = "Error"
+                    status = "Error"
+                    value = None
+                    limits = {}
+                    measurements = []
+                    has_nested = False
+                    nested_list = None
+                    nested_sequence_name = ""
+                    error_msg = f"Failed to parse result properties: {e}"
+                    error_code = -1
+
+                yield {
+                    "name": name,
+                    "type": step_type,
+                    "status": status,
+                    "value": value,
+                    "limits": limits if limits else None,
+                    "measurements": measurements if measurements else None,
+                    "error_msg": error_msg,
+                    "error_code": error_code,
+                    "parent_sequence": parent_sequence,
+                    "is_sequence_call": has_nested,
+                }
+
+                if has_nested and nested_list is not None:
+                    with nested_list as nested_results:
+                        yield from self._walk(nested_results, parent_sequence=nested_sequence_name)
+
+    def parse(self) -> list[dict[str, typing.Any]]:
+        """Parses a ResultList from the wrapped object.
+
+        Returns:
+            A list of dictionaries representing the parsed step results.
+        """
+        from py_teststand.execution.execution import Execution
+        from py_teststand.property.property_object import PropertyObject
+
+        obj = self._target
+
+        if isinstance(obj, Execution):
+            result_object = obj.result_object
+            if result_object is None or not result_object.exists("ResultList"):
+                return []
+            result_list = result_object.get_property_object("ResultList")
+            if result_list is None:
+                return []
+            with result_list as rl:
+                return list(self._walk(rl))
+
+        if isinstance(obj, SequenceContext):
+            result_list = None
+            if obj.locals.exists("ResultList"):
+                result_list = obj.locals.get_property_object("ResultList")
+            elif obj.parameters.exists("ResultList"):
+                result_list = obj.parameters.get_property_object("ResultList")
+
+            if result_list is None:
+                return []
+
+            sequence_name = ""
+            try:
+                if obj.sequence:
+                    sequence_name = obj.sequence.name
+            except Exception:
+                pass
+
+            with result_list as rl:
+                return list(self._walk(rl, parent_sequence=sequence_name))
+
+        if isinstance(obj, PropertyObject):
+            return list(self._walk(obj))
+
+        # Raw COM objects / Mocks
+        com_obj = obj
+        is_mock = "mock" in type(com_obj).__name__.lower() or hasattr(com_obj, "_mock_self")
+        if not is_mock:
+            if hasattr(com_obj, "ResultObject"):
+                return ResultList(Execution(com_obj)).parse()
+            if hasattr(com_obj, "Locals") and hasattr(com_obj, "Parameters"):
+                return ResultList(SequenceContext(com_obj)).parse()
+
+        with PropertyObject(com_obj) as po:
+            return list(self._walk(po))

{py_teststand-0.2.3 → py_teststand-0.3.0}/src/py_teststand/sequence/sequence_context.py

@@ -13,6 +13,7 @@ if TYPE_CHECKING:
     from py_teststand.core.engine import Engine
     from py_teststand.execution.execution import Execution
     from py_teststand.execution.report import Report
+    from py_teststand.execution.result_list import ResultList
     from py_teststand.execution.thread import Thread
     from py_teststand.sequence.step import Step
 
@@ -44,6 +45,13 @@ class SequenceContext(PropertyObject):
 
         return Execution(self._com_obj.Execution, self._engine_ref)
 
+    @property
+    @ts_interface
+    def result_list(self) -> ResultList:
+        from py_teststand.execution.result_list import ResultList
+
+        return ResultList(self)
+
     @property
     @ts_interface
     def call_stack_name(self) -> str:

{py_teststand-0.2.3 → py_teststand-0.3.0}/tests/integration/test_examples.py

@@ -126,6 +126,26 @@ def test_execution_run_test_headless_example_runs_on_live_engine():
     assert "Overall: FAILED" in completed.stdout, output
 
 
+@pytest.mark.teststand_engine
+@pytest.mark.integration
+def test_result_list_parse_example_runs_on_live_engine():
+    # Walks the ResultList and parses step result values.
+    # Subprocess-isolated for the same teardown reason as above.
+    import subprocess
+    import sys
+
+    completed = subprocess.run(
+        [sys.executable, str(EXAMPLES_DIR / "result_list_parse.py")],
+        capture_output=True,
+        text=True,
+        timeout=180,
+    )
+    output = completed.stdout + completed.stderr
+    assert "Verify Power Rail" in completed.stdout, output
+    assert "Verify Current Draw" in completed.stdout, output
+    assert "Serialized JSON Report:" in completed.stdout, output
+
+
 @pytest.mark.teststand_engine
 @pytest.mark.integration
 def test_ui_messages_handle_example_runs_on_live_engine():