Struct MockCaDevice 

pub struct MockCaDevice {
    pub inbound: VecDeque<Vec<u8>>,
    pub ops: Vec<DeviceOp>,
    pub slot: SlotInfo,
}

In-memory CaDevice for tests and the differential harness.

• inbound is a scripted queue of frames the “module” (mock CAM) sends up; each read pops one.
• every host-side operation is appended to ops so a test (or a differential comparison against an external reference) can assert the exact emitted write/ioctl sequence.

Fields

inbound: VecDeque<Vec<u8>>

Scripted frames the module sends to the host (FIFO).

ops: Vec<DeviceOp>

Recorded host-side operations, in order.

slot: SlotInfo

Slot status returned by slot_info.

Implementations

impl MockCaDevice

pub fn new(inbound: impl IntoIterator<Item = Vec<u8>>) -> Self

New mock with a ready module in slot 0 and the given inbound script.

Examples found in repository

examples/mock_cam_session.rs (line 17)

fn main() -> std::io::Result<()> {
    // Script a module that accepts the transport connection (C_T_C_Reply).
    let dev = MockCaDevice::new([vec![tags::C_T_C_REPLY, 0x01, 0x01]]);
    let mut driver = Driver::new(dev);

    // Bring the interface up: reset + open the transport connection.
    driver.init()?;
    println!("init: sent {} device op(s)", driver.device().ops.len());

    // Pump the device. When readable it reads a frame and feeds the stack;
    // otherwise it advances the EN 50221 poll cadence by the timeout.
    for step in 0..5 {
        let read = driver.pump(Duration::from_millis(100))?;
        println!("pump {step}: processed_frame={read}");
    }

    // Anything the host application needs to act on surfaces as a Notification.
    for note in driver.take_notifications() {
        match note {
            Notification::CamReady => println!("note: CAM ready — safe to send ca_pmt"),
            Notification::ApplicationInfo { menu, .. } => {
                println!("note: application_information menu={menu:?}")
            }
            Notification::CaInfo { ca_system_ids } => {
                println!("note: ca_info system_ids={ca_system_ids:?}")
            }
            other => println!("note: {other:?}"),
        }
    }

    // The mock records every device op (writes/ioctls) — handy for assertions.
    println!("total recorded device ops: {}", driver.device().ops.len());
    Ok(())
}

pub fn written(&self) -> Vec<u8>

The bytes written by the host so far, concatenated (convenience for byte-exact differential comparison against the C reference).

Trait Implementations

impl CaDevice for MockCaDevice

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Read one link-layer TPDU frame into buf; returns the byte count. Ok(0) means no data available (non-blocking).

fn write(&mut self, buf: &[u8]) -> Result<()>

Write one link-layer TPDU frame.

fn reset(&mut self) -> Result<()>

Reset the interface / slot (ioctl CA_RESET).

fn slot_info(&mut self) -> Result<SlotInfo>

Query slot status (ioctl CA_GET_SLOT_INFO).

fn poll(&mut self, _timeout: Duration) -> Result<bool>

Wait up to timeout for the device to become readable; Ok(true) if readable. The runtime’s poll loop calls this between reads.

impl Debug for MockCaDevice

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MockCaDevice

fn default() -> MockCaDevice

Returns the “default value” for a type.