Struct Mocker 

pub struct Mocker<K: KernelInterface> { /* private fields */ }

Native test harness for running one block without a Runtime.

Mocker wraps a kernel in the same block wrapper used by the runtime, but drives init, work, message handlers, and deinit directly. It is useful for focused unit tests and microbenchmarks where constructing a full Flowgraph would add noise.

Implementations

impl<K: KernelInterface + Kernel + 'static> Mocker<K>

pub fn id(&self) -> BlockId

Get the block id.

pub fn parts_mut(&mut self) -> (&mut K, &mut MessageOutputs, &mut BlockMeta)

Get mutable access to the wrapped kernel state used by Kernel::work.

pub fn meta(&self) -> &BlockMeta

Get block metadata.

pub fn meta_mut(&mut self) -> &mut BlockMeta

Get mutable block metadata.

pub fn new(kernel: K) -> Self

Create a mocker around one kernel instance.

Message output ports declared by the block are connected to internal sinks so tests can inspect emitted PMTs with Mocker::messages or Mocker::take_messages.

pub fn post(&mut self, id: impl Into<PortId>, p: Pmt) -> Result<Pmt, Error>

Call one message handler of the block and return its PMT result.

This executes the generated handler dispatch directly. It does not run work() afterward; call Mocker::run if the handler only queued state that should be processed by the work loop.

pub fn run(&mut self)

Run the block’s work() loop synchronously.

The loop repeats while the block sets WorkIo::call_again. Message outputs produced during each call are captured before the next iteration.

pub fn init(&mut self)

Run the block’s init() method synchronously.

pub fn deinit(&mut self)

Run the block’s deinit() method synchronously.

pub fn messages(&self) -> Vec<Vec<Pmt>>

Get produced PMTs from output message ports.

pub fn take_messages(&mut self) -> Vec<Vec<Pmt>>

Take produced PMTs from output message ports.

pub async fn run_async(&mut self)

Run the block’s work() loop asynchronously.

Like Mocker::run, this repeats while WorkIo::call_again is set.

Trait Implementations

impl<K: KernelInterface + 'static> Deref for Mocker<K>

type Target = K

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<K: KernelInterface + 'static> DerefMut for Mocker<K>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.