Struct gtest::Program

pub struct Program<'a> { /* private fields */ }

Gear program instance.

use gtest::{System, Program};

// Create a testing system.
let system = System::new();

// Get the current program of the testing system.
let program = Program::current(&system);

// Initialize the program from user 42 with message "init program".
let _result = program.send(42, "init program");

Implementations

impl<'a> Program<'a>

pub fn current(system: &'a System) -> Self

Get the program of the root crate with provided system.

See ProgramBuilder::current

pub fn current_with_id<I: Into<ProgramIdWrapper> + Clone + Debug>( system: &'a System, id: I, ) -> Self

Get the program of the root crate with provided system and initialize it with given id.

See also Program::current.

pub fn current_opt(system: &'a System) -> Self

Get optimized program of the root crate with provided system,

See also Program::current.

pub fn from_file<P: AsRef<Path>>(system: &'a System, path: P) -> Self

Create a program instance from wasm file.

See also Program::current.

pub fn from_binary_with_id<ID, B>(system: &'a System, id: ID, binary: B) -> Self

where ID: Into<ProgramIdWrapper> + Clone + Debug, B: Into<Vec<u8>>,

Create a program instance from wasm file with given ID.

See also Program::from_file.

pub fn mock<T: WasmProgram + 'static>(system: &'a System, mock: T) -> Self

Mock a program with provided system and mock.

See WasmProgram for more details.

pub fn mock_with_id<ID, T>(system: &'a System, id: ID, mock: T) -> Self

where T: WasmProgram + 'static, ID: Into<ProgramIdWrapper> + Clone + Debug,

Create a mock program with provided system and mock, and initialize it with provided id.

See also Program::mock.

pub fn send<ID, C>(&self, from: ID, payload: C) -> MessageId

where ID: Into<ProgramIdWrapper>, C: Codec,

Send message to the program.

pub fn send_with_value<ID, C>( &self, from: ID, payload: C, value: u128, ) -> MessageId

where ID: Into<ProgramIdWrapper>, C: Codec,

Send message to the program with value.

pub fn send_with_gas<ID, P>( &self, from: ID, payload: P, gas_limit: u64, value: u128, ) -> MessageId

where ID: Into<ProgramIdWrapper>, P: Encode,

Send message to the program with gas limit and value.

pub fn send_bytes<ID, T>(&self, from: ID, payload: T) -> MessageId

where ID: Into<ProgramIdWrapper>, T: Into<Vec<u8>>,

Send message to the program with bytes payload.

pub fn send_bytes_with_value<ID, T>( &self, from: ID, payload: T, value: u128, ) -> MessageId

where ID: Into<ProgramIdWrapper>, T: Into<Vec<u8>>,

Send the message to the program with bytes payload and value.

pub fn send_bytes_with_gas<ID, T>( &self, from: ID, payload: T, gas_limit: u64, value: u128, ) -> MessageId

where ID: Into<ProgramIdWrapper>, T: Into<Vec<u8>>,

Send the message to the program with bytes payload, gas limit and value.

pub fn id(&self) -> ProgramId

Get program id.

pub fn read_state_bytes(&self, payload: Vec<u8>) -> Result<Vec<u8>>

Reads the program’s state as a byte vector.

pub fn read_state_bytes_using_wasm( &self, payload: Vec<u8>, fn_name: &str, wasm: Vec<u8>, args: Option<Vec<u8>>, ) -> Result<Vec<u8>>

Reads the program’s transformed state as a byte vector. The transformed state is a result of applying the fn_name function from the wasm binary with the optional argument.

Usage

You can pass arguments as Option<(arg1, arg2, ...).encode()> or by using state_args_encoded macro.

Examples

//Read state bytes with no arguments passed to wasm.
let _ = program.read_state_bytes_using_wasm(Default::default(), "fn_name", WASM, Option::<Vec<u8>>::None)?;
let _ = program.read_state_bytes_using_wasm(Default::default(), "fn_name", WASM, state_args_encoded!())?;
// Read state bytes with one argument passed to wasm.
let _ = program.read_state_bytes_using_wasm(Default::default(), "fn_name", WASM, Some(ARG_1.encode()))?;
let _ = program.read_state_bytes_using_wasm(Default::default(), "fn_name", WASM, state_args_encoded!(ARG_1))?;
// Read state bytes with multiple arguments passed to wasm.
let _ = program.read_state_bytes_using_wasm(Default::default(), "fn_name", WASM, Some((ARG_1, ARG_2).encode()))?;
let _ = program.read_state_bytes_using_wasm(Default::default(), "fn_name", WASM, state_args_encoded!(ARG_1, ARG_2))?;

pub fn read_state<D: Decode, P: Encode>(&self, payload: P) -> Result<D>

Reads and decodes the program’s state .

pub fn read_state_using_wasm<E: Encode, P: Encode, D: Decode>( &self, payload: P, fn_name: &str, wasm: Vec<u8>, argument: Option<E>, ) -> Result<D>

Reads and decodes the program’s transformed state. The transformed state is a result of applying the fn_name function from the wasm binary with the optional argument.

Usage

You can pass arguments as Option<(arg1, arg2, ...)> or by using state_args macro.

Examples

//Read state bytes with no arguments passed to wasm.
let _ = program.read_state_using_wasm(Vec::<u8>::default(), "fn_name", WASM, Option::<()>::None)?;
let _ = program.read_state_using_wasm(Vec::<u8>::default(), "fn_name", WASM, state_args!())?;
// Read state bytes with one argument passed to wasm.
let _ = program.read_state_using_wasm(Vec::<u8>::default(), "fn_name", WASM, Some(ARG_1))?;
let _ = program.read_state_using_wasm(Vec::<u8>::default(), "fn_name", WASM, state_args!(ARG_1))?;
// Read state bytes with multiple arguments passed to wasm.
let _ = program.read_state_using_wasm(Vec::<u8>::default(), "fn_name", WASM, Some((ARG_1, ARG_2)))?;
let _ = program.read_state_using_wasm(Vec::<u8>::default(), "fn_name", WASM, state_args!(ARG_1, ARG_2))?;

pub fn balance(&self) -> Value

Returns the balance of the account.

pub fn save_memory_dump(&self, path: impl AsRef<Path>)

Save the program’s memory to path.

pub fn load_memory_dump(&mut self, path: impl AsRef<Path>)

Load the program’s memory from path.