#![allow(clippy::unwrap_used, clippy::expect_used)]
use crate::time::Instant;
use kermit_proto::trace::{self, Direction};
use crate::codec::{CAN, NAK};
use crate::{BlockSize, Check, Command, Config, Error, Event, Transfer};
const G49_XRECV: &str = include_str!("../traces/49g-xrecv.trace");
const G49_XRECV_1K: &str = include_str!("../traces/49g-xrecv-1k.trace");
const G49_XSEND: &str = include_str!("../traces/49g-xsend.trace");
const G49_XSEND_HPCRC: &str = include_str!("../traces/49g-xsend-hpcrc.trace");
const G49_XSEND_1K: &str = include_str!("../traces/49g-xsend-1k.trace");
const G49_SERVER_XRECV: &str = include_str!("../traces/49g-server-xrecv.trace");
const GX_XRECV: &str = include_str!("../traces/48gx-xrecv.trace");
const GX_XRECV_1K: &str = include_str!("../traces/48gx-xrecv-1k.trace");
const GX_XSEND: &str = include_str!("../traces/48gx-xsend.trace");
const GX_XSEND_HPCRC: &str = include_str!("../traces/48gx-xsend-hpcrc.trace");
const GX_SERVER_XSEND: &str = include_str!("../traces/48gx-server-xsend.trace");
struct Replay {
events: Vec<Event>,
xfer: Transfer,
now: Instant,
}
fn replay(cmd: Command, config: Config, text: &str) -> Replay {
let start = text
.find("# xmodem start")
.expect("trace has no `# xmodem start` line");
let mut now = Instant::now();
let mut xfer = Transfer::new(config);
xfer.start(now, cmd).unwrap();
let mut events = Vec::new();
for (i, (dir, bytes)) in trace::parse(&text[start..])
.unwrap()
.into_iter()
.enumerate()
{
match dir {
Direction::Out => {
let mut got = xfer.poll_output(now);
for _ in 0..100 {
if got.is_some() {
break;
}
let Some(due) = xfer.next_timeout() else {
break;
};
now = due;
xfer.handle_timeout(now);
got = xfer.poll_output(now);
}
assert_eq!(
got.as_deref().map(trace::escape),
Some(trace::escape(&bytes)),
"trace entry {i}: expected output > {}",
trace::escape(&bytes)
);
}
Direction::In => xfer.handle_input(now, &bytes),
}
events.extend(std::iter::from_fn(|| xfer.poll_event()));
}
let extra = xfer.poll_output(now);
assert_eq!(
extra.as_deref().map(trace::escape),
None,
"unexpected trailing output"
);
Replay { events, xfer, now }
}
fn hp_string(header: &[u8; 8], chars: &[u8]) -> Vec<u8> {
let len = 5 + 2 * chars.len();
let mut nibbles = vec![0xC, 0x2, 0xA, 0x2, 0x0];
nibbles.extend((0..5).map(|i| ((len >> (4 * i)) & 0xF) as u8));
let mut out = header.to_vec();
out.extend(nibbles.chunks(2).map(|p| p[0] | (p[1] << 4)));
out.extend_from_slice(chars);
out
}
fn all_bytes(header: &[u8; 8]) -> Vec<u8> {
hp_string(header, &(0..=255).collect::<Vec<u8>>())
}
fn big(header: &[u8; 8]) -> Vec<u8> {
hp_string(header, &(0..1811).map(|i| i as u8).collect::<Vec<u8>>())
}
const H49: &[u8; 8] = b"HPHP49-C";
const H48: &[u8; 8] = b"HPHP48-R";
fn file_end(events: &[Event]) -> (Vec<u8>, usize, usize) {
events
.iter()
.find_map(|e| match e {
Event::FileEnd {
data,
last_block,
padding,
} => Some((data.clone(), *last_block, *padding)),
_ => None,
})
.expect("no FileEnd")
}
fn started(events: &[Event]) -> Option<Check> {
events.iter().find_map(|e| match e {
Event::Started { check } => Some(*check),
_ => None,
})
}
fn cfg_1k() -> Config {
Config {
block_size: BlockSize::B1k,
..Config::default()
}
}
fn cfg_receive(check: Check) -> Config {
Config {
check,
..Config::default()
}
}
#[test]
fn g49_xrecv_asks_for_hp_crc() {
let r = replay(Command::Send(all_bytes(H49)), Config::default(), G49_XRECV);
assert_eq!(started(&r.events), Some(Check::HpCrc));
assert_eq!(r.events.last(), Some(&Event::Done));
}
#[test]
fn g49_xrecv_1k_with_short_tail() {
let r = replay(Command::Send(big(H49)), cfg_1k(), G49_XRECV_1K);
assert_eq!(started(&r.events), Some(Check::HpCrc));
assert!(r.events.contains(&Event::Progress {
bytes: 1024,
total: Some(1824)
}));
assert_eq!(r.events.last(), Some(&Event::Done));
}
#[test]
fn g49_xsend_ignores_c_and_falls_back_to_checksum() {
let r = replay(Command::Receive, cfg_receive(Check::Crc16), G49_XSEND);
assert_eq!(started(&r.events), Some(Check::Checksum));
let (data, last_block, padding) = file_end(&r.events);
let file = all_bytes(H49);
assert_eq!(data.len(), 384);
assert_eq!(&data[..file.len()], file.as_slice());
assert_eq!((last_block, padding), (128, 0));
assert!(data[file.len()..].iter().any(|&b| b != 0));
assert_eq!(r.events.last(), Some(&Event::Done));
}
#[test]
fn g49_xsend_hp_crc() {
let r = replay(Command::Receive, cfg_receive(Check::HpCrc), G49_XSEND_HPCRC);
assert_eq!(started(&r.events), Some(Check::HpCrc));
let (data, _, _) = file_end(&r.events);
let file = all_bytes(H49);
assert_eq!(&data[..file.len()], file.as_slice());
assert_eq!(r.events.last(), Some(&Event::Done));
}
#[test]
fn g49_xsend_1k_then_128_byte_tail() {
let r = replay(Command::Receive, cfg_receive(Check::HpCrc), G49_XSEND_1K);
assert_eq!(started(&r.events), Some(Check::HpCrc));
let (data, last_block, _) = file_end(&r.events);
let file = big(H49);
assert_eq!(data.len(), 1024 + 7 * 128);
assert_eq!(&data[..file.len()], file.as_slice());
assert_eq!(last_block, 128);
}
#[test]
fn g49_server_xrecv_never_starts() {
let mut r = replay(
Command::Send(all_bytes(H49)),
Config::default(),
G49_SERVER_XRECV,
);
assert_eq!(r.events, vec![]);
let due = r.xfer.next_timeout().expect("sender waits for a start");
r.xfer.handle_timeout(due.max(r.now));
assert_eq!(
std::iter::from_fn(|| r.xfer.poll_event()).collect::<Vec<_>>(),
vec![Event::Error(Error::Timeout)]
);
assert_eq!(r.xfer.poll_output(due), None);
}
#[test]
fn gx_xrecv_checksum() {
let r = replay(Command::Send(all_bytes(H48)), Config::default(), GX_XRECV);
assert_eq!(started(&r.events), Some(Check::Checksum));
assert_eq!(r.events.last(), Some(&Event::Done));
}
#[test]
fn gx_xrecv_rejects_1k_blocks() {
let cfg = Config {
checksum_1k: true,
..cfg_1k()
};
let r = replay(Command::Send(big(H48)), cfg, GX_XRECV_1K);
assert_eq!(r.events.last(), Some(&Event::Error(Error::RemoteCancelled)));
let blocks = trace::parse(GX_XRECV_1K)
.unwrap()
.iter()
.filter(|(d, b)| *d == Direction::Out && b.len() == 3 + 1024 + 1)
.count();
assert_eq!(blocks, 9);
}
#[test]
fn gx_xsend_falls_back_from_c() {
let r = replay(Command::Receive, cfg_receive(Check::Crc16), GX_XSEND);
assert_eq!(started(&r.events), Some(Check::Checksum));
let (data, last_block, padding) = file_end(&r.events);
let file = all_bytes(H48);
assert_eq!(&data[..file.len()], file.as_slice());
assert_eq!((last_block, padding), (128, 115));
}
#[test]
fn gx_xsend_falls_back_from_d() {
let r = replay(Command::Receive, cfg_receive(Check::HpCrc), GX_XSEND_HPCRC);
assert_eq!(started(&r.events), Some(Check::Checksum));
let (data, _, padding) = file_end(&r.events);
assert_eq!(&data[..13], hp_string(H48, b"").as_slice());
assert_eq!(padding, 128 - 11);
}
#[test]
fn gx_server_xsend_never_starts() {
let cfg = cfg_receive(Check::Checksum);
let r = replay(Command::Receive, cfg, GX_SERVER_XSEND);
assert_eq!(r.events, vec![Event::Error(Error::Timeout)]);
let outs: Vec<Vec<u8>> = trace::parse(GX_SERVER_XSEND)
.unwrap()
.into_iter()
.filter(|(d, _)| *d == Direction::Out)
.map(|(_, b)| b)
.collect();
assert_eq!(outs.iter().filter(|b| **b == [NAK]).count(), 10);
assert_eq!(outs.last(), Some(&vec![CAN, CAN, CAN]));
}