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 program of the root crate with provided system.

It looks up the wasm binary of the root crate that contains the current test, upload it to the testing system, then, returns the program instance.

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

Get 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 current_opt_with_id<I: Into<ProgramIdWrapper> + Clone + Debug>( system: &'a System, id: I ) -> Self

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

See also Program::current_with_id.

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<T: WasmProgram + 'static, I: Into<ProgramIdWrapper> + Clone + Debug>( system: &'a System, id: I, mock: T ) -> Self

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

See also Program::mock.

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_file_with_id<P: AsRef<Path>, I: Into<ProgramIdWrapper> + Clone + Debug>( system: &'a System, id: I, path: P ) -> Self

Create a program from file and initialize it with provided path and id.

id may be built from:

• u64
• [u8; 32]
• String
• &str
• ProgramId (from gear_core one’s, not from gstd).

Examples

From numeric id:

let prog = Program::from_file_with_id(
    &sys,
    105,
    "./target/wasm32-unknown-unknown/release/demo_ping.wasm",
);

From hex string starting with 0x:

let prog = Program::from_file_with_id(
    &sys,
    "0xe659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e",
    "./target/wasm32-unknown-unknown/release/demo_ping.wasm",
);

From hex string starting without 0x:

let prog = Program::from_file_with_id(
    &sys,
    "e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df5e",
    "./target/wasm32-unknown-unknown/release/demo_ping.wasm",
);

From array of bytes (e.g. filled with 5):

let prog = Program::from_file_with_id(
    &sys,
    [5; 32],
    "./target/wasm32-unknown-unknown/release/demo_ping.wasm",
);

See also

• Program::from_file for creating a program from file with default id.

pub fn from_opt_and_meta<P: AsRef<Path>>( system: &'a System, optimized: P, metadata: P ) -> Self

Create a program from optimized and metadata files.

See also Program::from_file.

pub fn from_opt_and_meta_with_id<P: AsRef<Path>, I: Into<ProgramIdWrapper> + Clone + Debug>( system: &'a System, id: I, optimized: P, metadata: P ) -> Self

Create a program from optimized and metadata files and initialize it with given id.

See also Program::from_file.

pub fn from_opt_and_meta_code_with_id<I: Into<ProgramIdWrapper> + Clone + Debug>( system: &'a System, id: I, optimized: Vec<u8>, metadata: Option<Vec<u8>> ) -> Self

Create a program from optimized and metadata code and initialize it with given id.

See also Program::from_file.

pub fn send<ID: Into<ProgramIdWrapper>, C: Codec>( &self, from: ID, payload: C ) -> RunResult

Send message to the program.

pub fn send_with_value<ID: Into<ProgramIdWrapper>, C: Codec>( &self, from: ID, payload: C, value: u128 ) -> RunResult

Send message to the program with value.

pub fn send_bytes<ID: Into<ProgramIdWrapper>, T: AsRef<[u8]>>( &self, from: ID, payload: T ) -> RunResult

Send message to the program with bytes payload.

pub fn send_bytes_with_value<ID: Into<ProgramIdWrapper>, T: AsRef<[u8]>>( &self, from: ID, payload: T, value: u128 ) -> RunResult

Send message to the program with bytes payload and value.

pub fn send_signal<ID: Into<ProgramIdWrapper>>( &self, from: ID, code: SignalCode ) -> RunResult

Send signal to the program.

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 mint(&mut self, value: u128)

Mint balance to the account.

pub fn balance(&self) -> u128

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.