blob: 94fe9c2ed9f8d3b1926dc65f67d5498db1225937 [file]
// Licensed under the Apache-2.0 license
// SPDX-License-Identifier: Apache-2.0
//! In-process loopback transport for host tests.
//!
//! Calls the server's `Dispatch` directly, no kernel. The response is
//! ready on the first `poll`, so this cannot test not-ready handling.
use crate::{AsyncTransport, Dispatch, Transport, TransportError};
/// In-process transport over an owned server.
///
/// `N` sizes the async response buffer held between `start` and `poll`.
/// The blocking path writes into the caller's buffer directly.
pub struct Loopback<D, const N: usize> {
server: D,
pending: Option<usize>,
held: [u8; N],
}
impl<D, const N: usize> Loopback<D, N> {
pub const fn new(server: D) -> Self {
Self {
server,
pending: None,
held: [0u8; N],
}
}
pub fn server(&self) -> &D {
&self.server
}
}
impl<D: Dispatch, const N: usize> Transport for Loopback<D, N> {
fn transact(&mut self, req: &[u8], resp: &mut [u8]) -> Result<usize, TransportError> {
if self.pending.is_some() {
return Err(TransportError::WrongState);
}
Ok(self.server.dispatch(req, resp)?)
}
}
impl<D: Dispatch, const N: usize> AsyncTransport for Loopback<D, N> {
fn start(&mut self, req: &[u8]) -> Result<(), TransportError> {
if self.pending.is_some() {
return Err(TransportError::WrongState);
}
let len = self.server.dispatch(req, &mut self.held)?;
self.pending = Some(len);
Ok(())
}
fn poll(&mut self, resp: &mut [u8]) -> Result<Option<usize>, TransportError> {
let Some(len) = self.pending else {
return Err(TransportError::WrongState);
};
if len > resp.len() {
// The held response is dropped, not kept for a retry: the
// round-trip is over and the next call is start.
self.pending = None;
return Err(TransportError::TooLarge);
}
self.pending = None;
resp[..len].copy_from_slice(&self.held[..len]);
Ok(Some(len))
}
fn cancel(&mut self) -> Result<(), TransportError> {
if self.pending.take().is_none() {
return Err(TransportError::WrongState);
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::DispatchError;
/// Increments the first byte of the request.
struct Increment {
seen: usize,
}
impl Dispatch for Increment {
fn dispatch(
&mut self,
request: &[u8],
response: &mut [u8],
) -> Result<usize, DispatchError> {
self.seen += 1;
if response.is_empty() {
return Err(DispatchError::ResponseTooSmall);
}
response[0] = request[0].wrapping_add(1);
Ok(1)
}
}
fn loopback() -> Loopback<Increment, 8> {
Loopback::new(Increment { seen: 0 })
}
#[test]
fn blocking_transact_answers_from_the_server() {
let mut lb = loopback();
let mut resp = [0u8; 4];
assert_eq!(lb.transact(&[0x10], &mut resp), Ok(1));
assert_eq!(resp[0], 0x11);
assert_eq!(lb.server().seen, 1);
}
#[test]
fn blocking_transact_reports_a_response_buffer_that_does_not_fit() {
let mut lb = loopback();
let mut resp = [0u8; 0];
assert_eq!(
lb.transact(&[0x10], &mut resp),
Err(TransportError::TooLarge)
);
}
#[test]
fn async_round_trip_is_ready_on_the_first_poll() {
let mut lb = loopback();
let mut resp = [0u8; 4];
assert_eq!(lb.start(&[0x20]), Ok(()));
assert_eq!(lb.poll(&mut resp), Ok(Some(1)));
assert_eq!(resp[0], 0x21);
}
#[test]
fn a_second_start_while_one_is_in_flight_is_refused() {
let mut lb = loopback();
assert_eq!(lb.start(&[0x20]), Ok(()));
assert_eq!(lb.start(&[0x20]), Err(TransportError::WrongState));
assert_eq!(lb.server().seen, 1);
}
#[test]
fn poll_with_nothing_in_flight_is_refused() {
let mut lb = loopback();
let mut resp = [0u8; 4];
assert_eq!(lb.poll(&mut resp), Err(TransportError::WrongState));
}
#[test]
fn a_response_that_does_not_fit_ends_the_round_trip() {
let mut lb = loopback();
let mut small = [0u8; 0];
let mut resp = [0u8; 4];
assert_eq!(lb.start(&[0x20]), Ok(()));
assert_eq!(lb.poll(&mut small), Err(TransportError::TooLarge));
assert_eq!(lb.start(&[0x30]), Ok(()));
assert_eq!(lb.poll(&mut resp), Ok(Some(1)));
assert_eq!(resp[0], 0x31);
}
#[test]
fn cancel_frees_the_transport_for_the_next_request() {
let mut lb = loopback();
let mut resp = [0u8; 4];
assert_eq!(lb.start(&[0x20]), Ok(()));
assert_eq!(lb.cancel(), Ok(()));
assert_eq!(lb.poll(&mut resp), Err(TransportError::WrongState));
assert_eq!(lb.start(&[0x40]), Ok(()));
assert_eq!(lb.poll(&mut resp), Ok(Some(1)));
assert_eq!(resp[0], 0x41);
}
#[test]
fn cancel_with_nothing_in_flight_is_refused() {
let mut lb = loopback();
assert_eq!(lb.cancel(), Err(TransportError::WrongState));
}
#[test]
fn transact_during_a_started_round_trip_is_refused() {
let mut lb = loopback();
let mut resp = [0u8; 4];
assert_eq!(lb.start(&[0x20]), Ok(()));
assert_eq!(
lb.transact(&[0x30], &mut resp),
Err(TransportError::WrongState)
);
assert_eq!(lb.poll(&mut resp), Ok(Some(1)));
assert_eq!(resp[0], 0x21);
}
#[test]
fn a_dispatch_that_cannot_answer_is_reported_at_start() {
let mut lb = Loopback::<Increment, 0>::new(Increment { seen: 0 });
assert_eq!(lb.start(&[0x20]), Err(TransportError::TooLarge));
// Failed start leaves nothing in flight.
assert_eq!(lb.cancel(), Err(TransportError::WrongState));
}
}