use crate::error::CalError;
use crate::session::XcpTransport;
use std::collections::BTreeMap;
type Page = BTreeMap<u32, u8>;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Request {
Read {
addr: u32,
len: u8,
},
Write {
addr: u32,
len: u8,
},
SetPage(u32),
}
#[derive(Debug, Clone)]
pub struct MockTransport {
pages: BTreeMap<u32, Page>,
page: u32,
requests: Vec<Request>,
read_failure: Option<String>,
write_failure: Option<String>,
}
impl MockTransport {
#[must_use]
pub fn new() -> Self {
Self {
pages: BTreeMap::new(),
page: 0,
requests: Vec::new(),
read_failure: None,
write_failure: None,
}
}
#[must_use]
pub fn seeded(seeds: &[(u32, Vec<u8>)]) -> Self {
let mut transport = Self::new();
for (addr, bytes) in seeds {
transport.seed(*addr, bytes);
}
transport
}
#[must_use]
pub fn fail_reads(mut self, message: &str) -> Self {
self.read_failure = Some(message.to_string());
self
}
#[must_use]
pub fn fail_writes(mut self, message: &str) -> Self {
self.write_failure = Some(message.to_string());
self
}
#[must_use]
pub const fn page(&self) -> u32 {
self.page
}
#[must_use]
pub fn requests(&self) -> &[Request] {
&self.requests
}
pub fn seed(&mut self, addr: u32, bytes: &[u8]) {
let page = self.pages.entry(self.page).or_default();
for (offset, &byte) in bytes.iter().enumerate() {
let Some(address) = addr.checked_add(u32::try_from(offset).unwrap_or(u32::MAX)) else {
continue;
};
page.insert(address, byte);
}
}
#[must_use]
pub fn peek(&self, addr: u32, len: u8) -> Vec<u8> {
let empty = Page::new();
let page = self.pages.get(&self.page).unwrap_or(&empty);
let len = usize::from(len);
let mut out = Vec::with_capacity(len);
for offset in 0..len {
let Some(address) = addr.checked_add(u32::try_from(offset).unwrap_or(u32::MAX)) else {
out.push(0);
continue;
};
out.push(page.get(&address).copied().unwrap_or(0));
}
out
}
#[must_use]
pub fn byte(&self, addr: u32) -> u8 {
self.peek(addr, 1).first().copied().unwrap_or(0)
}
#[must_use]
pub fn byte_on(&self, page: u32, addr: u32) -> u8 {
self.pages
.get(&page)
.and_then(|p| p.get(&addr))
.copied()
.unwrap_or(0)
}
#[must_use]
pub fn from_transport(transport: &dyn XcpTransport) -> Option<&Self> {
transport.as_any()?.downcast_ref::<Self>()
}
}
impl Default for MockTransport {
fn default() -> Self {
Self::new()
}
}
impl XcpTransport for MockTransport {
fn read(&mut self, addr: u32, len: u8) -> Result<Vec<u8>, CalError> {
self.requests.push(Request::Read { addr, len });
if let Some(message) = &self.read_failure {
return Err(CalError::Transport(message.clone()));
}
Ok(self.peek(addr, len))
}
fn write(&mut self, addr: u32, data: &[u8]) -> Result<(), CalError> {
#[allow(clippy::cast_possible_truncation)]
self.requests.push(Request::Write {
addr,
len: data.len() as u8,
});
if let Some(message) = &self.write_failure {
return Err(CalError::Transport(message.clone()));
}
self.seed(addr, data);
Ok(())
}
fn set_page(&mut self, page: u32) -> Result<(), CalError> {
self.requests.push(Request::SetPage(page));
self.pages.entry(page).or_default();
self.page = page;
Ok(())
}
fn as_any(&self) -> Option<&dyn std::any::Any> {
Some(self)
}
}