Struct Test 

pub struct Test {
    pub source_manager: Arc<dyn SourceManager>,
    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 add_modules: Vec<(LibraryPath, 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<dyn SourceManager>

source: Arc<SourceFile>

kernel_source: Option<Arc<SourceFile>>

stack_inputs: StackInputs

advice_inputs: AdviceInputs

in_debug_mode: bool

libraries: Vec<Library>

add_modules: Vec<(LibraryPath, 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 add_module(&mut self, path: LibraryPath, source: impl ToString)

Add an extra module to link in during assembly

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_process(&self) -> Result<(Process, TestHost), ExecutionError>

Compiles the test’s source to a Program and executes it with the tests inputs. Returns the process once execution is finished.

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 proof of execution using the given public inputs and the specified number of stack outputs. When test_fail is true, this function will force a failure by modifying the first output.

pub fn execute_iter(&self) -> VmStateIterator

Compiles the test’s source to a Program and executes it with the tests inputs. Returns a VmStateIterator that allows us to iterate through each clock cycle and inspect the process state.

pub fn get_last_stack_state(&self) -> StackOutputs

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