Struct Test 

pub struct Test {
    pub source_manager: Arc<DefaultSourceManager>,
    pub source: Arc<SourceFile>,
    pub kernel_source: Option<Arc<SourceFile>>,
    pub stack_inputs: StackInputs,
    pub advice_inputs: AdviceInputs,
    pub in_debug_mode: bool,
    pub libraries: Vec<Library>,
    pub handlers: Vec<(EventName, Arc<dyn EventHandler>)>,
    pub add_modules: Vec<(Arc<Path>, String)>,
}

This is a container for the data required to run tests, which allows for running several different types of tests.

Types of valid result tests:

• Execution test: check that running a program compiled from the given source has the specified results for the given (optional) inputs.
• Proptest: run an execution test inside a proptest.

Types of failure tests:

• Assembly error test: check that attempting to compile the given source causes an AssemblyError which contains the specified substring.
• Execution error test: check that running a program compiled from the given source causes an ExecutionError which contains the specified substring.

Fields

source_manager: Arc<DefaultSourceManager>

source: Arc<SourceFile>

kernel_source: Option<Arc<SourceFile>>

stack_inputs: StackInputs

advice_inputs: AdviceInputs

in_debug_mode: bool

libraries: Vec<Library>

handlers: Vec<(EventName, Arc<dyn EventHandler>)>

add_modules: Vec<(Arc<Path>, String)>

Implementations

impl Test

pub fn new(name: &str, source: &str, in_debug_mode: bool) -> Self

Creates the simplest possible new test, with only a source string and no inputs.

pub fn with_kernel(self, kernel_source: impl ToString) -> Self

Adds kernel source to this test so it is assembled and linked during compilation.

pub fn with_kernel_source( self, kernel_name: impl Into<String>, kernel_source: impl ToString, ) -> Self

Adds kernel source to this test so it is assembled and linked during compilation.

pub fn add_module(&mut self, path: impl AsRef<Path>, source: impl ToString)

Add an extra module to link in during assembly

pub fn add_event_handler( &mut self, event: EventName, handler: impl EventHandler, )

Add a handler for a specific event when running the Host.

pub fn add_event_handlers( &mut self, handlers: Vec<(EventName, Arc<dyn EventHandler>)>, )

Add a handler for a specific event when running the Host.

pub fn expect_stack(&self, final_stack: &[u64])

Builds a final stack from the provided stack-ordered array and asserts that executing the test will result in the expected final stack state.

pub fn expect_stack_and_memory( &self, final_stack: &[u64], mem_start_addr: u32, expected_mem: &[u64], )

Executes the test and validates that the process memory has the elements of expected_mem at address mem_start_addr and that the end of the stack execution trace matches the final_stack.

pub fn prop_expect_stack( &self, final_stack: &[u64], ) -> Result<(), TestCaseError>

Asserts that executing the test inside a proptest results in the expected final stack state. The proptest will return a test failure instead of panicking if the assertion condition fails.

pub fn compile(&self) -> Result<(Program, Option<KernelLibrary>), Report>

Compiles a test’s source and returns the resulting Program together with the associated kernel library (when specified).

Errors

Returns an error if compilation of the program source or the kernel fails.

pub fn execute(&self) -> Result<ExecutionTrace, ExecutionError>

Compiles the test’s source to a Program and executes it with the tests inputs. Returns a resulting execution trace or error.

Internally, this also checks that the slow and fast processors agree on the stack outputs.

pub fn execute_for_output( &self, ) -> Result<(ExecutionOutput, DefaultHost), ExecutionError>

Compiles the test’s source to a Program and executes it with the tests inputs.

Returns the [ExecutionOutput] once execution is finished.

pub fn execute_with_debug_buffer( &self, ) -> Result<(StackOutputs, String), ExecutionError>

Compiles the test’s source to a Program and executes it with the tests inputs. Returns the StackOutputs and a String containing all debug output.

If the execution fails, the output is printed stderr.

pub fn prove_and_verify(&self, pub_inputs: Vec<u64>, test_fail: bool)

Compiles the test’s code into a program, then generates and verifies a STARK proof of execution. When test_fail is true, forces a failure by modifying the first output.

Prefer check_constraints for constraint validation — it is much faster and provides better error diagnostics. Use this method only when you need to exercise the full STARK prove/verify pipeline (e.g., testing proof serialization, verifier logic, or precompile request handling).

pub fn check_constraints(&self)

Executes the test program and checks all AIR constraints without generating a STARK proof.

This is the recommended way to validate constraints in tests. It delegates to ExecutionTrace::check_constraints, which is much faster than the full prove/verify pipeline and provides better error diagnostics. Use prove_and_verify only when you need to exercise the complete STARK proof generation and verification flow.

Panics

Panics if execution fails or if any AIR constraint evaluates to nonzero on any row.

pub fn get_last_stack_state(&self) -> StackOutputs

Returns the last state of the stack after executing a test.