| // Licensed under the Apache-2.0 license | |
| // SPDX-License-Identifier: Apache-2.0 | |
| //! The real `I3cClient` driven against the real `dispatch`, with no kernel. | |
| //! | |
| //! `LoopbackTransport` stands in for the IPC channel, so these tests exercise | |
| //! the same encoders, the same `dispatch`, and the same latch semantics the | |
| //! on-target build uses — the point of the transport seam. | |
| use i3c_api::{I3cStatus, MAX_PAYLOAD, MAX_SEND}; | |
| use i3c_client::{ClientError, I3cClient}; | |
| use i3c_server::{Inbound, LoopbackTransport, Server}; | |
| use openprot_hal_blocking::i3c_hardware::{DynamicAddress, I3cTarget, TargetEvent}; | |
| /// A target whose inbound queue and outbound record are both visible to tests. | |
| struct FakeTarget { | |
| addr: Option<u8>, | |
| inbound: Option<([u8; MAX_PAYLOAD], usize)>, | |
| sent: [u8; MAX_PAYLOAD], | |
| sent_len: usize, | |
| } | |
| impl FakeTarget { | |
| fn new(addr: Option<u8>) -> Self { | |
| Self { | |
| addr, | |
| inbound: None, | |
| sent: [0u8; MAX_PAYLOAD], | |
| sent_len: 0, | |
| } | |
| } | |
| fn queue(&mut self, frame: &[u8]) { | |
| let mut buf = [0u8; MAX_PAYLOAD]; | |
| let n = frame.len().min(MAX_PAYLOAD); | |
| buf[..n].copy_from_slice(&frame[..n]); | |
| self.inbound = Some((buf, n)); | |
| } | |
| } | |
| #[derive(Debug, PartialEq, Eq)] | |
| struct FakeError; | |
| impl I3cTarget for FakeTarget { | |
| type Error = FakeError; | |
| fn enable(&mut self) -> Result<(), Self::Error> { | |
| Ok(()) | |
| } | |
| fn on_interrupt(&mut self) -> Result<TargetEvent, Self::Error> { | |
| if self.inbound.is_some() { | |
| Ok(TargetEvent::InboundReady) | |
| } else { | |
| Ok(TargetEvent::None) | |
| } | |
| } | |
| fn read_frame(&mut self, buf: &mut [u8]) -> Result<Option<usize>, Self::Error> { | |
| match self.inbound.take() { | |
| Some((frame, n)) if n <= buf.len() => { | |
| buf[..n].copy_from_slice(&frame[..n]); | |
| Ok(Some(n)) | |
| } | |
| Some(_) => Err(FakeError), | |
| None => Ok(None), | |
| } | |
| } | |
| fn send(&mut self, data: &[u8]) -> Result<(), Self::Error> { | |
| let n = data.len().min(MAX_PAYLOAD); | |
| self.sent[..n].copy_from_slice(&data[..n]); | |
| self.sent_len = n; | |
| Ok(()) | |
| } | |
| fn cancel_response(&mut self) -> Result<(), Self::Error> { | |
| self.sent_len = 0; | |
| Ok(()) | |
| } | |
| fn dynamic_address(&self) -> Option<DynamicAddress> { | |
| self.addr.and_then(|a| DynamicAddress::try_from(a).ok()) | |
| } | |
| fn max_send_len(&self) -> usize { | |
| MAX_PAYLOAD | |
| } | |
| fn static_address(&self) -> Option<DynamicAddress> { | |
| None | |
| } | |
| fn max_recv_len(&self) -> usize { | |
| MAX_PAYLOAD | |
| } | |
| fn disable(&mut self) -> Result<(), Self::Error> { | |
| Ok(()) | |
| } | |
| } | |
| fn client(addr: Option<u8>) -> I3cClient<LoopbackTransport<FakeTarget>> { | |
| I3cClient::new(LoopbackTransport::new(Server::new( | |
| 1, | |
| 2, | |
| FakeTarget::new(addr), | |
| ))) | |
| } | |
| #[test] | |
| fn send_reaches_the_target() { | |
| let mut c = client(Some(0x08)); | |
| c.send(b"pong").expect("send"); | |
| let target = &c.transport().server().target; | |
| assert_eq!(&target.sent[..target.sent_len], b"pong"); | |
| } | |
| #[test] | |
| fn second_send_is_busy_until_the_controller_reads_the_first() { | |
| let mut c = client(Some(0x08)); | |
| c.send(b"first").expect("send"); | |
| // Only one response is staged at a time. Nothing of the second reaches the | |
| // target while the first is unread. | |
| assert_eq!(c.send(b"second"), Err(ClientError::Busy)); | |
| let target = &c.transport().server().target; | |
| assert_eq!(&target.sent[..target.sent_len], b"first"); | |
| // The controller reads the first (the runtime reports ResponseRead). | |
| c.transport().server().notify_response_read(); | |
| c.send(b"second").expect("send after the read"); | |
| let target = &c.transport().server().target; | |
| assert_eq!(&target.sent[..target.sent_len], b"second"); | |
| } | |
| #[test] | |
| fn device_info_reports_the_target() { | |
| let mut c = client(Some(0x08)); | |
| let info = c.device_info().expect("device_info"); | |
| assert_eq!(info.dynamic_address, Some(0x08)); | |
| assert_eq!(info.static_address, None); | |
| assert_eq!(info.max_send_len as usize, MAX_SEND); | |
| assert_eq!(info.max_recv_len as usize, MAX_PAYLOAD); | |
| } | |
| #[test] | |
| fn device_info_before_assignment_has_no_dynamic_address() { | |
| let mut c = client(None); | |
| let info = c.device_info().expect("device_info"); | |
| assert_eq!(info.dynamic_address, None); | |
| } | |
| #[test] | |
| fn recv_on_an_idle_bus_is_none() { | |
| let mut c = client(Some(0x08)); | |
| let mut buf = [0u8; MAX_PAYLOAD]; | |
| assert_eq!(c.recv(&mut buf).expect("recv"), None); | |
| } | |
| #[test] | |
| fn recv_returns_the_latched_frame_once() { | |
| let mut c = client(Some(0x08)); | |
| c.transport() | |
| .server() | |
| .target | |
| .queue(&[0x01, 0x02, 0x03, 0x04]); | |
| assert_eq!( | |
| c.transport().server().latch_inbound().expect("latch"), | |
| Inbound::Latched | |
| ); | |
| let mut buf = [0u8; MAX_PAYLOAD]; | |
| assert_eq!(c.recv(&mut buf).expect("recv"), Some(4)); | |
| assert_eq!(&buf[..4], &[0x01, 0x02, 0x03, 0x04]); | |
| // The latch is consumed: a second read sees an idle bus. | |
| assert_eq!(c.recv(&mut buf).expect("recv"), None); | |
| } | |
| #[test] | |
| fn dynamic_address_reads_back() { | |
| let mut c = client(Some(0x08)); | |
| assert_eq!(c.dynamic_address().expect("addr"), Some(0x08)); | |
| } | |
| #[test] | |
| fn dynamic_address_before_entdaa_is_none() { | |
| let mut c = client(None); | |
| assert_eq!(c.dynamic_address().expect("addr"), None); | |
| } | |
| #[test] | |
| fn oversize_send_is_rejected_client_side() { | |
| let mut c = client(Some(0x08)); | |
| let big = [0u8; MAX_SEND + 1]; | |
| assert_eq!(c.send(&big), Err(ClientError::BufferTooSmall)); | |
| // Rejected before the transport ran, so the target saw nothing. | |
| assert_eq!(c.transport().server().target.sent_len, 0); | |
| } | |
| #[test] | |
| fn recv_into_a_short_buffer_is_rejected_without_losing_the_frame() { | |
| let mut c = client(Some(0x08)); | |
| c.transport().server().target.queue(&[0xaa; 16]); | |
| assert_eq!( | |
| c.transport().server().latch_inbound().expect("latch"), | |
| Inbound::Latched | |
| ); | |
| // A buffer too small to hold the frame is rejected before the round-trip. | |
| let mut small = [0u8; 4]; | |
| assert_eq!(c.recv(&mut small), Err(ClientError::BufferTooSmall)); | |
| // Crucially, the latch was not consumed: a proper read still gets the frame. | |
| let mut buf = [0u8; MAX_PAYLOAD]; | |
| assert_eq!(c.recv(&mut buf).expect("recv"), Some(16)); | |
| assert_eq!(&buf[..16], &[0xaa; 16]); | |
| } | |
| #[test] | |
| fn a_full_payload_round_trips() { | |
| let mut c = client(Some(0x08)); | |
| let payload = [0x5au8; MAX_SEND]; | |
| c.send(&payload).expect("send"); | |
| let target = &c.transport().server().target; | |
| assert_eq!(target.sent_len, MAX_SEND); | |
| assert_eq!(&target.sent[..target.sent_len], &payload[..]); | |
| } | |
| #[test] | |
| fn server_status_surfaces_as_an_error() { | |
| // `dispatch` answers an unknown opcode with InvalidOp; the client reports | |
| // it rather than silently treating it as success. | |
| struct BadOp; | |
| impl i3c_api::Transport for BadOp { | |
| fn transact( | |
| &mut self, | |
| _req: &[u8], | |
| resp: &mut [u8], | |
| ) -> Result<usize, i3c_api::TransportError> { | |
| resp[0] = I3cStatus::Internal as u8; | |
| Ok(1) | |
| } | |
| } | |
| let mut c = I3cClient::new(BadOp); | |
| assert_eq!(c.send(b"x"), Err(ClientError::Server(I3cStatus::Internal))); | |
| } | |
| #[test] | |
| fn send_for_is_staged_when_the_address_matches() { | |
| let mut c = client(Some(0x08)); | |
| c.send_for(0x08, b"framed").expect("send_for"); | |
| let target = &c.transport().server().target; | |
| assert_eq!( | |
| &target.sent[..target.sent_len], | |
| b"framed", | |
| "no address byte leaks through" | |
| ); | |
| } | |
| #[test] | |
| fn send_for_a_stale_address_is_refused_and_stages_nothing() { | |
| let mut c = client(Some(0x1d)); | |
| assert_eq!(c.send_for(0x08, b"stale"), Err(ClientError::AddressChanged)); | |
| assert_eq!(c.transport().server().target.sent_len, 0); | |
| // Rebuilt for the current address, it goes through. | |
| c.send_for(0x1d, b"fresh").expect("send_for"); | |
| } | |
| #[test] | |
| fn send_for_cannot_name_the_no_address_value() { | |
| let mut c = client(Some(0x08)); | |
| assert_eq!( | |
| c.send_for(0, b"x"), | |
| Err(ClientError::Server(I3cStatus::InvalidOp)) | |
| ); | |
| assert_eq!(c.transport().server().target.sent_len, 0); | |
| } |