use std::fmt;
use xmodem_proto::codec::{ACK, NAK};
use crate::calc::validate_name;
use crate::charset::{decode, encode, encode_command};
use crate::link::Link;
use crate::object::ObjectType;
use crate::reply::{Entry, parse_real};
use crate::time::Duration;
#[cfg(not(target_arch = "wasm32"))]
use crate::time::Instant;
#[cfg(not(target_arch = "wasm32"))]
use crate::transport::Transport;
use crate::xmodem::{self, XmodemOptions, XmodemReceived, XmodemReport};
use crate::{Error, Result};
pub const MAX_DATA: usize = 0xFFFF;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum FrameError {
TooLong(usize),
Truncated,
TrailingBytes(usize),
BadChecksum {
expected: u8,
got: u8,
},
}
impl fmt::Display for FrameError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
FrameError::TooLong(n) => write!(f, "{n} bytes do not fit one XSERV packet"),
FrameError::Truncated => f.write_str("XSERV packet or record ends early"),
FrameError::TrailingBytes(n) => write!(f, "{n} bytes after the XSERV packet"),
FrameError::BadChecksum { expected, got } => {
write!(f, "XSERV checksum {got:#04x}, expected {expected:#04x}")
}
}
}
}
impl std::error::Error for FrameError {}
pub fn checksum(data: &[u8]) -> u8 {
data.iter().fold(0u8, |acc, &b| acc.wrapping_add(b))
}
pub fn encode_packet(data: &[u8]) -> std::result::Result<Vec<u8>, FrameError> {
let len = u16::try_from(data.len()).map_err(|_| FrameError::TooLong(data.len()))?;
let mut out = Vec::with_capacity(data.len() + 3);
out.extend_from_slice(&len.to_be_bytes());
out.extend_from_slice(data);
out.push(checksum(data));
Ok(out)
}
pub fn decode_packet(frame: &[u8]) -> std::result::Result<Vec<u8>, FrameError> {
let mut deframer = Deframer::new();
deframer.push(frame);
let data = deframer.next_packet().ok_or(FrameError::Truncated)??;
match deframer.pending() {
0 => Ok(data),
n => Err(FrameError::TrailingBytes(n)),
}
}
#[derive(Clone, Debug, Default)]
pub struct Deframer {
buf: Vec<u8>,
}
impl Deframer {
pub fn new() -> Self {
Deframer::default()
}
pub fn push(&mut self, bytes: &[u8]) {
self.buf.extend_from_slice(bytes);
}
pub fn pending(&self) -> usize {
self.buf.len()
}
pub fn clear(&mut self) {
self.buf.clear();
}
pub fn next_packet(&mut self) -> Option<std::result::Result<Vec<u8>, FrameError>> {
let (&hi, &lo) = (self.buf.first()?, self.buf.get(1)?);
let len = usize::from(u16::from_be_bytes([hi, lo]));
let got = *self.buf.get(2 + len)?;
let frame: Vec<u8> = self.buf.drain(..3 + len).collect();
let data = frame.get(2..2 + len).unwrap_or_default().to_vec();
let expected = checksum(&data);
Some(if got == expected {
Ok(data)
} else {
Err(FrameError::BadChecksum { expected, got })
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum XservCommand {
Put(String),
Get(String),
Execute(String),
Memory,
List,
Quit,
}
impl XservCommand {
pub fn byte(&self) -> u8 {
match self {
XservCommand::Put(_) => b'P',
XservCommand::Get(_) => b'G',
XservCommand::Execute(_) => b'E',
XservCommand::Memory => b'M',
XservCommand::List => b'L',
XservCommand::Quit => b'Q',
}
}
pub fn packet(&self) -> Result<Option<Vec<u8>>> {
let data = match self {
XservCommand::Put(name) | XservCommand::Get(name) => {
validate_name(name)?;
encode(name)?
}
XservCommand::Execute(text) => encode_command(text)?,
XservCommand::Memory | XservCommand::List | XservCommand::Quit => return Ok(None),
};
encode_packet(&data)
.map(Some)
.map_err(|e| Error::Reply(e.to_string()))
}
pub fn has_reply(&self) -> bool {
matches!(self, XservCommand::Memory | XservCommand::List)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct DirRecord {
pub name: String,
pub prolog: u16,
pub size_nibbles: u32,
pub crc: u16,
}
impl DirRecord {
pub fn is_directory(&self) -> bool {
self.prolog == 0x2A96
}
pub fn kind(&self) -> String {
ObjectType::from_prolog(u32::from(self.prolog)).map_or_else(
|| format!("Object #{:04X}", self.prolog),
|t| t.name().to_string(),
)
}
pub fn size(&self) -> f64 {
let name = encode(&self.name).map_or(self.name.chars().count(), |b| b.len());
f64::from(self.size_nibbles) / 2.0 + 4.5 + name as f64
}
pub fn entry(&self) -> Entry {
Entry {
name: self.name.clone(),
size: self.size(),
kind: self.kind(),
checksum: self.crc,
}
}
}
pub fn parse_dir_list(data: &[u8]) -> std::result::Result<Vec<DirRecord>, FrameError> {
let mut records = Vec::new();
let mut rest = data;
while let Some((&len, tail)) = rest.split_first() {
let len = usize::from(len);
let record = tail.get(..len + 7).ok_or(FrameError::Truncated)?;
let (name, fields) = record.split_at(len);
let byte = |i: usize| fields.get(i).copied().unwrap_or_default();
records.push(DirRecord {
name: decode(name),
prolog: u16::from_le_bytes([byte(0), byte(1)]),
size_nibbles: u32::from_le_bytes([byte(2), byte(3), byte(4), 0]),
crc: u16::from_le_bytes([byte(5), byte(6)]),
});
rest = tail.get(len + 7..).unwrap_or_default();
}
Ok(records)
}
pub fn memory_reply(heard: &[u8]) -> Option<f64> {
(0..heard.len()).find_map(|at| {
let rest = heard.get(at..)?;
let (&hi, &lo) = (rest.first()?, rest.get(1)?);
let len = usize::from(u16::from_be_bytes([hi, lo]));
if !(1..=MEMORY_REPLY_MAX).contains(&len) {
return None;
}
let data = rest.get(2..2 + len)?;
if *rest.get(2 + len)? != checksum(data) {
return None;
}
parse_real(std::str::from_utf8(data).ok()?)
})
}
const MEMORY_REPLY_MAX: usize = 24;
const QUIT_SETTLE: Duration = Duration::from_secs(5);
const COMMAND_TRIES: u32 = 5;
const REPLY_FAILURES: u32 = 4;
#[derive(Clone, Debug)]
pub struct XservOptions {
pub quiet: Duration,
pub answer: Duration,
pub busy: Duration,
pub timeout: Duration,
}
impl Default for XservOptions {
fn default() -> Self {
XservOptions {
quiet: Duration::from_millis(200),
answer: Duration::from_millis(1500),
busy: Duration::from_secs(60),
timeout: Duration::from_secs(5),
}
}
}
#[derive(Clone, Debug)]
pub(crate) struct XservState {
pub(crate) options: XservOptions,
pub(crate) settle: bool,
}
impl XservState {
pub(crate) fn new(options: XservOptions) -> Self {
XservState {
options,
settle: true,
}
}
}
enum Answer {
Packet(Vec<u8>),
Silence,
}
async fn quiet(link: &Link, quiet: Duration) -> Result<()> {
link.drain(quiet).await?;
Ok(())
}
async fn read_reply(link: &Link, first: Duration, timeout: Duration) -> Result<Answer> {
let mut deframer = Deframer::new();
let mut failures = 0;
let mut heard = false;
let mut deadline = link.now() + first;
loop {
while let Some(packet) = deframer.next_packet() {
match packet {
Ok(data) => {
link.write(vec![ACK])?;
link.flush().await?;
return Ok(Answer::Packet(data));
}
Err(e) => {
failures += 1;
if failures >= REPLY_FAILURES {
return Err(Error::Reply(format!("XSERV reply: {e}")));
}
deframer.clear();
link.write(vec![NAK])?;
link.flush().await?;
deadline = link.now() + timeout;
}
}
}
let bytes = link.read(Some(deadline)).await?;
if bytes.is_empty() {
if !heard {
return Ok(Answer::Silence);
}
failures += 1;
if failures >= REPLY_FAILURES {
return Err(Error::Reply(format!(
"XSERV reply: nothing complete after {REPLY_FAILURES} tries"
)));
}
deframer.clear();
link.write(vec![NAK])?;
link.flush().await?;
deadline = link.now() + timeout;
continue;
}
heard = true;
deframer.push(&bytes);
deadline = link.now() + timeout;
}
}
async fn ask(link: &Link, options: &XservOptions, byte: u8) -> Result<Vec<u8>> {
let give_up = link.now() + options.busy;
loop {
quiet(link, options.quiet).await?;
link.write(vec![byte])?;
link.flush().await?;
if let Answer::Packet(data) = read_reply(link, options.answer, options.timeout).await? {
return Ok(data);
}
if link.now() >= give_up {
return Err(Error::Reply(format!(
"XSERV {}: no answer within {:.0} s; is XSERV running on the calculator?",
char::from(byte),
options.busy.as_secs_f64()
)));
}
}
}
async fn wait_ack(link: &Link, timeout: Duration) -> Result<bool> {
let deadline = link.now() + timeout;
loop {
let bytes = link.read(Some(deadline)).await?;
if bytes.is_empty() {
return Ok(false);
}
for b in bytes {
match b {
ACK => return Ok(true),
NAK => return Ok(false),
_ => {}
}
}
}
}
pub(crate) async fn command(
link: &Link,
state: &mut XservState,
command: &XservCommand,
) -> Result<Option<Vec<u8>>> {
let options = state.options.clone();
if command.has_reply() {
let data = ask(link, &options, command.byte()).await?;
state.settle = false;
return Ok(Some(data));
}
let packet = command.packet()?;
if state.settle {
if packet.is_some() {
ask(link, &options, b'M').await?;
} else {
let mut short = options.clone();
short.busy = short.busy.min(QUIT_SETTLE);
match ask(link, &short, b'M').await {
Ok(_) | Err(Error::Reply(_)) => {}
Err(e) => return Err(e),
}
}
state.settle = false;
}
let Some(packet) = packet else {
quiet(link, options.quiet).await?;
link.write(vec![command.byte()])?;
link.flush().await?;
state.settle = true;
return Ok(None);
};
quiet(link, options.quiet).await?;
link.write(vec![command.byte()])?;
link.flush().await?;
state.settle = true;
for _ in 0..COMMAND_TRIES {
link.write(packet.clone())?;
link.flush().await?;
if wait_ack(link, options.timeout).await? {
return Ok(None);
}
quiet(link, options.quiet).await?;
}
Err(Error::Reply(format!(
"XSERV {}: no ACK for the command packet after {COMMAND_TRIES} tries",
char::from(command.byte())
)))
}
pub(crate) async fn list(link: &Link, state: &mut XservState) -> Result<Vec<DirRecord>> {
let data = command(link, state, &XservCommand::List)
.await?
.unwrap_or_default();
parse_dir_list(&data).map_err(|e| Error::Reply(format!("XSERV L: {e}")))
}
pub(crate) async fn memory(link: &Link, state: &mut XservState) -> Result<f64> {
let data = command(link, state, &XservCommand::Memory)
.await?
.unwrap_or_default();
std::str::from_utf8(&data)
.ok()
.and_then(parse_real)
.ok_or_else(|| {
Error::Reply(format!(
"XSERV M: {:?} is no number",
String::from_utf8_lossy(&data)
))
})
}
pub(crate) async fn probe(
link: &Link,
state: &mut XservState,
wait: Duration,
) -> Result<Option<f64>> {
quiet(link, state.options.quiet).await?;
link.write(vec![b'M'])?;
link.flush().await?;
let deadline = link.now() + wait;
let mut heard = Vec::new();
loop {
if let Some(free) = memory_reply(&heard) {
link.write(vec![ACK])?;
link.flush().await?;
state.settle = false;
return Ok(Some(free));
}
let bytes = link.read(Some(deadline)).await?;
if bytes.is_empty() {
return Ok(None);
}
heard.extend_from_slice(&bytes);
}
}
pub(crate) async fn quit(link: &Link, state: &mut XservState) -> Result<bool> {
command(link, state, &XservCommand::Quit).await?;
let wait = state.options.answer;
Ok(probe(link, state, wait).await?.is_none())
}
pub(crate) async fn get(
link: &Link,
state: &mut XservState,
name: &str,
options: &XmodemOptions,
) -> Result<XmodemReceived> {
command(link, state, &XservCommand::Get(name.to_string())).await?;
xmodem::receive(link, options).await
}
pub(crate) async fn put(
link: &Link,
state: &mut XservState,
name: &str,
data: &[u8],
options: &XmodemOptions,
) -> Result<XmodemReport> {
command(link, state, &XservCommand::Put(name.to_string())).await?;
xmodem::send(link, options, data).await
}
pub fn transfer_options(start_timeout: Duration) -> XmodemOptions {
let mut options = XmodemOptions::for_model(crate::Model::Hp49G).unwrap_or_default();
options.start_timeout = start_timeout;
options
}
#[cfg(not(target_arch = "wasm32"))]
pub struct XservSession {
transport: Box<dyn Transport>,
link: Link,
state: XservState,
}
#[cfg(not(target_arch = "wasm32"))]
impl std::fmt::Debug for XservSession {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XservSession")
.field("options", &self.state.options)
.finish_non_exhaustive()
}
}
#[cfg(not(target_arch = "wasm32"))]
impl XservSession {
pub fn new(transport: Box<dyn Transport>, options: XservOptions) -> Self {
XservSession {
transport,
link: Link::new(Instant::now()),
state: XservState::new(options),
}
}
pub fn into_transport(self) -> Box<dyn Transport> {
self.transport
}
fn drive<T>(
&mut self,
f: impl AsyncFnOnce(&Link, &mut XservState) -> T,
progress: &mut dyn FnMut(&crate::link::Progress),
) -> T {
let link = self.link.clone();
let state = &mut self.state;
crate::link::drive(self.transport.as_mut(), &link, f(&link, state), progress)
}
pub fn probe(&mut self, wait: Duration) -> Result<Option<f64>> {
self.drive(async |l, s| probe(l, s, wait).await, &mut |_| {})
}
pub fn list(&mut self) -> Result<Vec<DirRecord>> {
self.drive(async |l, s| list(l, s).await, &mut |_| {})
}
pub fn memory(&mut self) -> Result<f64> {
self.drive(async |l, s| memory(l, s).await, &mut |_| {})
}
pub fn execute(&mut self, rpl: &str) -> Result<()> {
let cmd = XservCommand::Execute(rpl.to_string());
self.drive(
async |l, s| command(l, s, &cmd).await.map(|_| ()),
&mut |_| {},
)
}
pub fn quit(&mut self) -> Result<bool> {
self.drive(async |l, s| quit(l, s).await, &mut |_| {})
}
pub fn get(
&mut self,
name: &str,
options: &XmodemOptions,
progress: &mut dyn FnMut(&xmodem_proto::Event),
) -> Result<XmodemReceived> {
self.drive(async |l, s| get(l, s, name, options).await, &mut |p| {
if let crate::link::Progress::Xmodem(e) = p {
progress(e);
}
})
}
pub fn put(
&mut self,
name: &str,
data: &[u8],
options: &XmodemOptions,
progress: &mut dyn FnMut(&xmodem_proto::Event),
) -> Result<XmodemReport> {
self.drive(
async |l, s| put(l, s, name, data, options).await,
&mut |p| {
if let crate::link::Progress::Xmodem(e) = p {
progress(e);
}
},
)
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
#[test]
fn encode_by_hand() {
assert_eq!(
encode_packet(b"AB").unwrap(),
[0x00, 0x02, b'A', b'B', 0x83]
);
assert_eq!(encode_packet(b"").unwrap(), [0x00, 0x00, 0x00]);
let big = encode_packet(&[0xFF; 300]).unwrap();
assert_eq!(&big[..2], &[0x01, 0x2C]);
assert_eq!(big.len(), 303);
assert_eq!(big[302], 0xD4);
assert_eq!(
encode_packet(&vec![0; MAX_DATA + 1]),
Err(FrameError::TooLong(MAX_DATA + 1))
);
assert_eq!(
encode_packet(&vec![0; MAX_DATA]).unwrap().len(),
MAX_DATA + 3
);
}
#[test]
fn decode_by_hand() {
assert_eq!(
decode_packet(&[0x00, 0x02, b'A', b'B', 0x83]).unwrap(),
b"AB"
);
assert_eq!(
decode_packet(&[0x00, 0x02, b'A', b'B', 0x84]),
Err(FrameError::BadChecksum {
expected: 0x83,
got: 0x84
})
);
assert_eq!(
decode_packet(&[0x00, 0x02, b'A']),
Err(FrameError::Truncated)
);
assert_eq!(decode_packet(&[0x00]), Err(FrameError::Truncated));
assert_eq!(
decode_packet(&[0x00, 0x00, 0x00, 0x07]),
Err(FrameError::TrailingBytes(1))
);
}
#[test]
fn deframer_handles_any_chunking() {
let mut wire = encode_packet(b"HOME").unwrap();
wire.extend(encode_packet(&[0x10; 256]).unwrap());
let mut d = Deframer::new();
let mut got = Vec::new();
for byte in &wire {
d.push(&[*byte]);
while let Some(p) = d.next_packet() {
got.push(p.unwrap());
}
}
assert_eq!(got, vec![b"HOME".to_vec(), vec![0x10; 256]]);
assert_eq!(d.pending(), 0);
}
#[test]
fn deframer_consumes_a_bad_packet() {
let mut d = Deframer::new();
d.push(&[0x00, 0x01, b'x', 0x00]);
d.push(&encode_packet(b"y").unwrap());
assert!(matches!(
d.next_packet(),
Some(Err(FrameError::BadChecksum { .. }))
));
assert_eq!(d.next_packet(), Some(Ok(b"y".to_vec())));
d.push(&[0x00]);
d.clear();
assert_eq!(d.next_packet(), None);
}
#[test]
fn commands() {
let put = XservCommand::Put("ABC".into());
assert_eq!(put.byte(), b'P');
assert_eq!(
put.packet().unwrap(),
Some(vec![0x00, 0x03, b'A', b'B', b'C', 0xC6])
);
assert_eq!(XservCommand::Get("X".into()).byte(), b'G');
assert_eq!(
XservCommand::Get("X".into()).packet().unwrap(),
Some(vec![0x00, 0x01, b'X', b'X'])
);
assert!(XservCommand::Get("1X".into()).packet().is_err());
assert!(XservCommand::Put("A B".into()).packet().is_err());
let exec = XservCommand::Execute("\\->A".into());
assert_eq!(exec.byte(), b'E');
assert_eq!(
exec.packet().unwrap(),
Some(vec![0x00, 0x02, 0x8D, b'A', 0x8D + b'A'])
);
assert_eq!(XservCommand::Memory.byte(), b'M');
assert_eq!(XservCommand::List.byte(), b'L');
assert_eq!(XservCommand::Memory.packet().unwrap(), None);
assert_eq!(XservCommand::List.packet().unwrap(), None);
assert_eq!(XservCommand::Quit.byte(), b'Q');
assert_eq!(XservCommand::Quit.packet().unwrap(), None);
assert!(!XservCommand::Quit.has_reply());
assert!(XservCommand::List.has_reply() && XservCommand::Memory.has_reply());
assert!(!put.has_reply());
}
#[test]
fn dir_list_by_hand() {
let data = [
&[4][..],
b"DIR1",
&[0x96, 0x2A, 22, 0, 0, 0x34, 0x12],
&[1],
b"S",
&[0x2C, 0x2A, 0x45, 0x23, 0x01, 0xEF, 0xBE],
]
.concat();
let list = parse_dir_list(&data).unwrap();
assert_eq!(
list,
vec![
DirRecord {
name: "DIR1".into(),
prolog: 0x2A96,
size_nibbles: 22,
crc: 0x1234
},
DirRecord {
name: "S".into(),
prolog: 0x2A2C,
size_nibbles: 0x012345,
crc: 0xBEEF
},
]
);
assert!(list[0].is_directory() && !list[1].is_directory());
assert_eq!(parse_dir_list(&[]).unwrap(), vec![]);
assert_eq!(
parse_dir_list(&data[..data.len() - 1]),
Err(FrameError::Truncated)
);
let arrow = parse_dir_list(&[1, 0x8D, 0, 0, 0, 0, 0, 0, 0]).unwrap();
assert_eq!(arrow[0].name, "→");
}
#[test]
fn a_record_has_the_kermit_size_and_kind() {
let r = |name: &str, prolog: u16, nibbles: u32| DirRecord {
name: name.into(),
prolog,
size_nibbles: nibbles,
crc: 0x7847,
};
assert_eq!(r("A", 0x2933, 21).size(), 16.0);
assert_eq!(r("SUBD", 0x2A96, 45).size(), 31.0);
assert_eq!(r("ABCDEFGH", 0x2933, 21).size(), 23.0);
let e = r("SUBD", 0x2A96, 45).entry();
assert_eq!(e.kind, "Directory");
assert!(e.is_directory());
assert_eq!(e.checksum, 0x7847);
assert_eq!(r("X", 0x2A2C, 10).kind(), "String");
assert_eq!(r("X", 0x1234, 10).kind(), "Object #1234");
}
#[test]
fn the_memory_reply_is_found_in_what_was_heard() {
let reply = encode_packet(b"245478.").unwrap();
assert_eq!(memory_reply(&reply), Some(245_478.0));
let mut heard = b"\x01# N3\r".to_vec();
heard.extend(&reply);
heard.extend(b"xyz");
assert_eq!(memory_reply(&heard), Some(245_478.0));
assert_eq!(memory_reply(&reply[..reply.len() - 1]), None);
let mut bad = reply.clone();
*bad.last_mut().unwrap() ^= 1;
assert_eq!(memory_reply(&bad), None);
assert_eq!(memory_reply(&encode_packet(b"hello").unwrap()), None);
assert_eq!(memory_reply(b"\x01# N3\r"), None);
assert_eq!(memory_reply(&[]), None);
}
use crate::transport::MemoryTransport;
use std::sync::{Arc, Mutex};
type Log = Arc<Mutex<Vec<Vec<u8>>>>;
fn fast() -> XservOptions {
XservOptions {
quiet: Duration::from_millis(1),
answer: Duration::from_millis(30),
busy: Duration::from_millis(400),
timeout: Duration::from_millis(30),
}
}
fn session(
mut peer: impl FnMut(&[u8]) -> Vec<Vec<u8>> + Send + 'static,
) -> (XservSession, Log) {
let log: Log = Arc::default();
let seen = log.clone();
let t = MemoryTransport::new(move |w| {
seen.lock().unwrap().push(w.to_vec());
peer(w)
});
(XservSession::new(Box::new(t), fast()), log)
}
#[test]
fn a_probe_acks_the_answer_and_finds_nothing_in_silence() {
let (mut s, log) = session(|w| match w {
b"M" => vec![encode_packet(b"1000.").unwrap()],
_ => vec![],
});
assert_eq!(s.probe(Duration::from_millis(50)).unwrap(), Some(1000.0));
assert_eq!(*log.lock().unwrap(), [b"M".to_vec(), vec![ACK]]);
let (mut s, log) = session(|_| vec![]);
assert_eq!(s.probe(Duration::from_millis(50)).unwrap(), None);
assert_eq!(*log.lock().unwrap(), [b"M".to_vec()]);
}
#[test]
fn a_busy_calculator_gets_the_command_again() {
let records = [&[1][..], b"S", &[0x2C, 0x2A, 0x0A, 0, 0, 0xEF, 0xBE]].concat();
let reply = encode_packet(&records).unwrap();
let mut dropped = 2;
let (mut s, log) = session(move |w| match w {
b"L" if dropped > 0 => {
dropped -= 1;
vec![]
}
b"L" => vec![reply.clone()],
_ => vec![],
});
let list = s.list().unwrap();
assert_eq!(list[0].name, "S");
assert_eq!(
*log.lock().unwrap(),
[b"L".to_vec(), b"L".to_vec(), b"L".to_vec(), vec![ACK]]
);
}
#[test]
fn no_answer_gives_up() {
let (mut s, _) = session(|_| vec![]);
let err = s.memory().unwrap_err();
assert!(err.to_string().contains("is XSERV running"), "{err}");
}
#[test]
fn a_command_packet_waits_for_a_ready_calculator() {
let listing = encode_packet(&[]).unwrap();
let (mut s, log) = session(move |w| match w {
b"M" => vec![encode_packet(b"5.").unwrap()],
b"L" => vec![listing.clone()],
[b'E' | b'P' | b'G'] | [ACK] => vec![],
_ => vec![vec![ACK]],
});
s.execute("HOME").unwrap();
s.execute("'X' PURGE").unwrap();
assert!(s.list().unwrap().is_empty());
s.execute("1").unwrap();
let sent: Vec<Vec<u8>> = log.lock().unwrap().clone();
let bytes: Vec<&[u8]> = sent.iter().map(Vec::as_slice).collect();
let home = encode_packet(b"HOME").unwrap();
let purge = encode_packet(b"'X' PURGE").unwrap();
let one = encode_packet(b"1").unwrap();
assert_eq!(
bytes,
[
&b"M"[..],
&[ACK],
b"E",
&home,
b"M",
&[ACK],
b"E",
&purge,
b"L",
&[ACK],
b"E",
&one,
]
);
}
#[test]
fn quit_says_whether_xserv_ended() {
let mut ended = false;
let mut busy = 2;
let (mut s, log) = session(move |w| match w {
b"Q" => {
ended = true;
vec![]
}
b"M" if busy > 0 => {
busy -= 1;
vec![]
}
b"M" if !ended => vec![encode_packet(b"5.").unwrap()],
_ => vec![],
});
assert!(s.quit().unwrap());
let m = b"M".to_vec();
assert_eq!(
*log.lock().unwrap(),
[m.clone(), m.clone(), m.clone(), vec![ACK], b"Q".to_vec(), m]
);
let (mut s, _) = session(|w| match w {
b"M" => vec![encode_packet(b"5.").unwrap()],
_ => vec![],
});
assert!(!s.quit().unwrap());
let (mut s, log) = session(|_| vec![]);
assert!(s.quit().unwrap());
assert!(log.lock().unwrap().contains(&b"Q".to_vec()));
}
#[test]
fn naks_both_ways() {
let mut naks = 1;
let (mut s, log) = session(move |w| match w {
b"M" => vec![encode_packet(b"5.").unwrap()],
[b'E'] | [ACK] => vec![],
_ if naks > 0 => {
naks -= 1;
vec![vec![NAK]]
}
_ => vec![vec![ACK]],
});
s.execute("X").unwrap();
let packet = encode_packet(b"X").unwrap();
assert_eq!(
*log.lock().unwrap(),
[
b"M".to_vec(),
vec![ACK],
b"E".to_vec(),
packet.clone(),
packet
]
);
let good = encode_packet(b"42").unwrap();
let mut bad = good.clone();
*bad.last_mut().unwrap() ^= 0xFF;
let (mut s, log) = session(move |w| match w {
b"M" => vec![bad.clone()],
[NAK] => vec![good.clone()],
_ => vec![],
});
assert_eq!(s.memory().unwrap(), 42.0);
assert_eq!(*log.lock().unwrap(), [b"M".to_vec(), vec![NAK], vec![ACK]]);
}
}