use crate::time::Duration;
use kermit_proto::{Command, OutgoingFile};
use crate::charset::{decode, encode, encode_command};
use crate::grob::Grob;
#[cfg(not(target_arch = "wasm32"))]
use crate::link::{self, Link};
use crate::object::{HEADER_LEN, KERMIT_PADDING_ALLOWANCE, ObjectType, inspect};
use crate::object::{object_size, strip_padding, unpack};
use crate::reply::{Iopar, Listing, StackReply, parse_list, parse_listing, parse_real};
use crate::reply::{parse_name, parse_stack, parse_string, parse_whole_string};
use crate::session::KermitCore;
#[cfg(not(target_arch = "wasm32"))]
use crate::session::Session;
use crate::transport::BAUD;
#[cfg(not(target_arch = "wasm32"))]
use crate::transport::Transport;
use crate::xmodem::{
XmodemDirection, XmodemPlan, eval_keys, program_text, server_again, stacked_program,
};
use crate::{Error, Result};
const IOPAR_ITEMS: &str = "RCLF STD IOPAR LIST\u{2192}";
const IOPAR_DROP: &str = "DROPN STOF";
const MEM_STD: &str = "RCLF STD MEM";
const CHUNK: usize = 10;
const VERSION_CHUNKS: &str =
"RCLF ROT ROT STD + 1 OVER SIZE FOR k DUP k k 9 + SUB SWAP 10 STEP SIZE";
const PICT_VAR: &str = "SATXTMP";
const BACKUP_VAR: &str = "SATXBK";
pub const RESTORE_VAR: &str = "SATXRS";
const RESTORE_TIMEOUT: Duration = Duration::from_secs(3);
const HOST_NAK_WINDOW: Duration = Duration::from_millis(250);
const HOST_NAK_GRACE: Duration = Duration::from_secs(3);
const HOST_BYTE_TIME: Duration = Duration::from_nanos(10_000_000_000 / BAUD as u64);
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Model {
Hp48Sx,
Hp48Gx,
Hp49G,
Hp38G,
Hp39G,
Unknown,
}
impl Model {
pub fn from_version(version: Option<&str>) -> Model {
let Some(v) = version else {
return Model::Hp48Sx;
};
let year = v
.rsplit(|c: char| !c.is_ascii_digit())
.find(|w| w.len() == 4)
.and_then(|w| w.parse::<u32>().ok());
if v.contains("HP49") || year.is_some_and(|y| y >= 1999) {
Model::Hp49G
} else if v.contains("HP48") {
Model::Hp48Gx
} else {
Model::Unknown
}
}
pub fn from_directory_file(name: &[u8]) -> Option<Model> {
let head = name.get(..8)?.to_ascii_uppercase();
match head.as_slice() {
b"HP38DIR." => Some(Model::Hp38G),
b"HP39DIR." => Some(Model::Hp39G),
_ => None,
}
}
pub fn name(self) -> &'static str {
match self {
Model::Hp48Sx => "HP 48S/SX",
Model::Hp48Gx => "HP 48G/GX",
Model::Hp49G => "HP 49G",
Model::Hp38G => "HP 38G",
Model::Hp39G => "HP 39G/40G",
Model::Unknown => "unknown",
}
}
pub fn has_xmodem(self) -> bool {
!matches!(self, Model::Hp48Sx | Model::Hp38G)
}
pub fn drives_transfers(self) -> bool {
matches!(self, Model::Hp38G | Model::Hp39G)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TransferMode {
Binary,
Ascii,
}
#[derive(Debug)]
pub(crate) struct CalcState {
pub(crate) mode: Option<TransferMode>,
rng: u64,
}
impl CalcState {
pub(crate) fn new(seed: u64) -> Self {
CalcState {
mode: None,
rng: seed,
}
}
fn marker(&mut self) -> String {
self.rng = self.rng.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = self.rng;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^= z >> 31;
format!("SATX-{:06x}", z & 0xFF_FFFF)
}
}
pub(crate) struct CalcOps<'a> {
pub(crate) k: &'a mut KermitCore,
pub(crate) st: &'a mut CalcState,
}
impl CalcOps<'_> {
pub(crate) async fn sync(&mut self) -> Result<()> {
let marker = self.st.marker();
self.sync_with(&marker).await
}
async fn sync_with(&mut self, marker: &str) -> Result<()> {
let command = format!("\"{marker}\"");
for attempt in 0..2 {
let result = if attempt == 0 {
self.host(&command).await
} else {
self.host_retrying(&command).await
};
let reply = match result {
Err(Error::Remote(_)) => continue,
Err(Error::NoReply { .. } | Error::Kermit(kermit_proto::Error::Timeout))
if attempt == 0 =>
{
continue;
}
reply => reply?,
};
let ours = reply
.levels
.iter()
.take_while(|level| parse_string(level).as_deref() == Some(marker))
.count();
if reply.error.is_none() && ours > 0 {
self.drop_levels(ours).await?;
return Ok(());
}
}
Err(Error::Reply(format!(
"not in step with the calculator: neither reply showed the sync marker {marker}"
)))
}
fn retry_link(&self) {
self.k.link.clear_error();
}
pub(crate) async fn run(&mut self, command: &str) -> Result<StackReply> {
self.st.mode = None;
self.host(command).await
}
async fn host(&mut self, command: &str) -> Result<StackReply> {
let timeout = self.k.config().timeout;
self.host_once(command, timeout).await
}
async fn host_once(&mut self, command: &str, timeout: Duration) -> Result<StackReply> {
let normal = self.k.config().clone();
let mut once = normal.clone();
once.timeout = timeout;
once.first_packet_retries = Some(0);
once.nak_grace = timeout;
once.first_packet_nak_window = Some(HOST_NAK_WINDOW);
once.first_packet_nak_grace = Some(HOST_NAK_GRACE.min(timeout));
once.first_packet_nak_byte_time = Some(HOST_BYTE_TIME);
self.k.set_config(once);
let result = self.host_retrying(command).await;
self.k.set_config(normal);
match result {
Err(Error::Kermit(kermit_proto::Error::Timeout)) if !self.k.answered() => {
Err(Error::NoReply {
command: command.to_string(),
})
}
other => other,
}
}
async fn host_retrying(&mut self, command: &str) -> Result<StackReply> {
let bytes = encode_command(command)?;
let transcript = self.k.transact(Command::Host(bytes)).await?;
Ok(parse_stack(&decode(&transcript.text)))
}
async fn exec(&mut self, parts: &[String]) -> Result<StackReply> {
match self.host(&parts.join(" ")).await {
Err(Error::CommandTooLong { .. }) if parts.len() > 1 => {
let mut last = StackReply::default();
for part in parts {
last = checked(self.host(part).await?)?;
}
Ok(last)
}
reply => checked(reply?),
}
}
async fn query(&mut self, command: &str, levels: usize) -> Result<Vec<String>> {
let reply = checked(self.host(command).await?)?;
if reply.levels.len() < levels {
return Err(Error::Reply(format!(
"{command}: expected {levels} stack level(s), got {:?}",
reply.levels
)));
}
let values = reply.levels[..levels].to_vec();
self.drop_levels(levels).await?;
Ok(values)
}
async fn drop_levels(&mut self, n: usize) -> Result<()> {
match drop_command(n) {
Some(command) => checked(self.host(&command).await?).map(|_| ()),
None => Ok(()),
}
}
async fn drop_and_restore_flags(&mut self, n: usize) -> Result<()> {
let command = match drop_command(n) {
Some(drop) => format!("{drop} STOF"),
None => "STOF".to_string(),
};
checked(self.host(&command).await?).map(|_| ())
}
pub(crate) async fn list(&mut self) -> Result<Listing> {
let transcript = self.k.transact(Command::Directory).await?;
parse_listing(&decode(&transcript.text))
}
pub(crate) async fn path(&mut self) -> Result<Vec<String>> {
if let Some(path) = self.list().await?.path {
return Ok(path);
}
let [value]: [String; 1] = self
.query("PATH", 1)
.await?
.try_into()
.map_err(|_| Error::Reply("PATH: no value".into()))?;
parse_list(&value).ok_or_else(|| Error::Reply(format!("PATH: not a list: {value:?}")))
}
pub(crate) async fn cd(&mut self, path: &[&str]) -> Result<()> {
let components = match path.split_first() {
Some((&"HOME", rest)) => rest,
_ => path,
};
for name in components {
validate_name(name)?;
}
self.exec(&["HOME".to_string()]).await?;
for name in components {
let listing = self.list().await?;
let is_dir = listing
.entries
.iter()
.any(|e| e.name == *name && e.is_directory());
if !is_dir {
return Err(Error::Reply(format!("{name}: no such directory")));
}
self.exec(&[(*name).to_string()]).await?;
}
Ok(())
}
pub(crate) async fn updir(&mut self) -> Result<()> {
self.exec(&["UPDIR".to_string()]).await.map(|_| ())
}
pub(crate) async fn mkdir(&mut self, name: &str) -> Result<()> {
self.exec(&[format!("{} CRDIR", quote(name)?)])
.await
.map(|_| ())
}
pub(crate) async fn remove(&mut self, name: &str) -> Result<()> {
let quoted = quote(name)?;
let is_dir = self
.list()
.await?
.entries
.iter()
.find(|e| e.name == name)
.map(|e| e.is_directory())
.ok_or_else(|| Error::Reply(format!("{name}: no such variable")))?;
let purge = if is_dir { "PGDIR" } else { "PURGE" };
self.exec(&[format!("{quoted} {purge}")]).await.map(|_| ())
}
pub(crate) async fn rename(&mut self, from: &str, to: &str) -> Result<()> {
let quoted_from = quote(from)?;
let quoted_to = quote(to)?;
let listing = self.list().await?;
let is_dir = listing
.entries
.iter()
.find(|e| e.name == from)
.map(|e| e.is_directory())
.ok_or_else(|| Error::Reply(format!("{from}: no such variable")))?;
if listing.entries.iter().any(|e| e.name == to) {
return Err(Error::Reply(format!("{to}: already exists")));
}
let purge = if is_dir { "PGDIR" } else { "PURGE" };
self.exec(&[
format!("{quoted_from} RCL"),
format!("{quoted_to} STO"),
format!("{quoted_from} {purge}"),
])
.await
.map(|_| ())
}
pub(crate) async fn mem(&mut self) -> Result<f64> {
let reply = checked(self.host(MEM_STD).await?)?;
let value = reply.level(1).unwrap_or_default().to_string();
self.drop_and_restore_flags(1).await?;
parse_real(&value).ok_or_else(|| Error::Reply(format!("MEM: not a number: {value:?}")))
}
pub(crate) async fn version(&mut self) -> Result<Option<String>> {
let reply = checked(self.host("VERSION").await?)?;
let level1 = reply.level(1).unwrap_or_default().trim();
if level1 == "VERSION" || parse_name(level1).as_deref() == Some("VERSION") {
self.drop_levels(1).await?;
return Ok(None);
}
let (Some(l2), Some(l1)) = (reply.level(2), reply.level(1)) else {
return Err(Error::Reply(format!(
"VERSION: expected two strings, got {:?}",
reply.levels
)));
};
let bad = |s: &str| Error::Reply(format!("VERSION: not a string: {s:?}"));
parse_string(l2).ok_or_else(|| bad(l2))?;
parse_string(l1).ok_or_else(|| bad(l1))?;
let (version, copyright) = match (parse_whole_string(l2), parse_whole_string(l1)) {
(Some(version), Some(copyright)) => {
self.drop_levels(2).await?;
(version, copyright)
}
(None, None) => {
self.drop_levels(2).await?;
return Err(Error::Reply(format!(
"VERSION: both strings arrived cut: {:?}",
reply.levels
)));
}
(version, copyright) => {
let below = reply.levels.len() - 2;
self.whole_version(version, copyright, below).await?
}
};
let version = version.split_whitespace().collect::<Vec<_>>().join(" ");
Ok(Some(format!("{version}, {copyright}")))
}
async fn whole_version(
&mut self,
version: Option<String>,
copyright: Option<String>,
below: usize,
) -> Result<(String, String)> {
let reply = match checked(self.host(VERSION_CHUNKS).await?) {
Err(e @ Error::Calculator { .. }) => {
self.drop_after_failed_chunks(&e, below).await?;
return Err(e);
}
reply => reply?,
};
let bad =
|reply: &StackReply| Error::Reply(format!("VERSION: bad chunks: {:?}", reply.levels));
let Some(flags) = (1..=reply.levels.len()).find(|&n| reply.level(n).is_some_and(is_flags))
else {
return Err(bad(&reply));
};
self.drop_and_restore_flags(flags - 1).await?;
let total = reply.level(1).and_then(parse_count);
let joined = (2..flags)
.rev()
.map(|n| reply.level(n).and_then(parse_whole_string))
.collect::<Option<String>>()
.unwrap_or_default();
let split = match (&version, ©right) {
(_, Some(copyright)) if joined.ends_with(copyright.as_str()) => {
Some(joined.len() - copyright.len())
}
(Some(version), None) if joined.starts_with(version.as_str()) => Some(version.len()),
_ => None,
};
match (total, split) {
(Some(total), Some(split))
if joined.chars().count() == total && flags - 2 == total.div_ceil(CHUNK) =>
{
let (version, copyright) = joined.split_at(split);
Ok((version.to_string(), copyright.to_string()))
}
_ => Err(bad(&reply)),
}
}
async fn drop_after_failed_chunks(&mut self, err: &Error, below: usize) -> Result<()> {
let Error::Calculator { stack, .. } = err else {
return Ok(());
};
let ours = stack.len().saturating_sub(below);
match ours.checked_sub(1).and_then(|deepest| stack.get(deepest)) {
Some(deepest) if is_flags(deepest) => self.drop_and_restore_flags(ours - 1).await,
_ => self.drop_levels(ours).await,
}
}
pub(crate) async fn iopar(&mut self) -> Result<Iopar> {
let reply = match checked(self.host(IOPAR_ITEMS).await?) {
Err(e @ Error::Calculator { .. }) => {
if let Error::Calculator { stack, .. } = &e
&& stack.get(1).is_some_and(|l| is_flags(l))
{
self.drop_and_restore_flags(1).await?;
}
return Err(e);
}
reply => reply?,
};
checked(self.host(IOPAR_DROP).await?)?;
let Some(n) = reply.level(1).and_then(parse_count) else {
return Err(Error::Reply(format!(
"IOPAR: no item count: {:?}",
reply.levels
)));
};
if reply.levels.len() < n + 2 {
return Err(Error::Reply(format!(
"IOPAR: expected {n} items, got {:?}",
reply.levels
)));
}
let items: Vec<&str> = (2..=n + 1)
.rev()
.map(|level| reply.level(level).unwrap_or_default())
.collect();
Iopar::from_items(&items)
.ok_or_else(|| Error::Reply(format!("IOPAR: bad list: {{ {} }}", items.join(" "))))
}
pub(crate) async fn set_iopar(&mut self, iopar: &Iopar) -> Result<()> {
self.exec(&[
"PATH HOME".to_string(),
format!("{} 'IOPAR' STO", iopar.to_rpl()),
"EVAL".to_string(),
])
.await
.map(|_| ())
}
pub(crate) async fn transfer_mode(&mut self) -> Result<TransferMode> {
let values = self.query("-35 FS?", 1).await?;
let value = values.first().map(String::as_str).unwrap_or_default();
let mode = match parse_real(value) {
Some(1.0) => TransferMode::Binary,
Some(0.0) => TransferMode::Ascii,
_ => return Err(Error::Reply(format!("-35 FS?: not a flag: {value:?}"))),
};
self.st.mode = Some(mode);
Ok(mode)
}
pub(crate) async fn set_transfer_mode(&mut self, mode: TransferMode) -> Result<()> {
if self.st.mode == Some(mode) {
return Ok(());
}
let command = match mode {
TransferMode::Binary => "-35 SF",
TransferMode::Ascii => "-35 CF",
};
self.exec(&[command.to_string()]).await?;
self.st.mode = Some(mode);
Ok(())
}
pub(crate) async fn get(&mut self, name: &str, mode: TransferMode) -> Result<Vec<u8>> {
validate_name(name)?;
self.set_transfer_mode(mode).await?;
let transcript = self.k.transact(Command::Get(encode(name)?)).await?;
let [file]: [_; 1] = transcript.files.try_into().map_err(|files: Vec<_>| {
Error::Reply(format!(
"GET {name}: expected one file, got {}",
files.len()
))
})?;
Ok(match mode {
TransferMode::Binary => strip_padding(&file.data, KERMIT_PADDING_ALLOWANCE).to_vec(),
TransferMode::Ascii => file.data,
})
}
pub(crate) async fn put(
&mut self,
name: &str,
data: &[u8],
mode: TransferMode,
) -> Result<String> {
validate_name(name)?;
self.set_transfer_mode(mode).await?;
let file = OutgoingFile {
name: encode(name)?,
data: data.to_vec(),
};
let transcript = self.k.transact(Command::Send(vec![file])).await?;
transcript
.stored_names
.into_iter()
.next()
.ok_or_else(|| Error::Reply(format!("SEND {name}: no file stored")))
}
pub(crate) async fn pict(&mut self) -> Result<Grob> {
Grob::from_file(&self.pict_file().await?)
}
pub(crate) async fn pict_file(&mut self) -> Result<Vec<u8>> {
self.refuse_existing(PICT_VAR).await?;
self.exec(&[format!("PICT RCL '{PICT_VAR}' STO")]).await?;
let data = self.get(PICT_VAR, TransferMode::Binary).await;
self.retry_link();
let purge = self.exec(&[format!("'{PICT_VAR}' PURGE")]).await;
let data = data?;
purge?;
Grob::from_file(&data)?;
Ok(data)
}
pub(crate) async fn backup(&mut self) -> Result<Vec<u8>> {
self.refuse_existing(BACKUP_VAR).await?;
self.exec(&[format!(":0:{BACKUP_VAR} ARCHIVE")]).await?;
let result = self.backup_steps().await;
if result.is_err() {
self.retry_link();
let _ = self.exec(&[format!(":0:{BACKUP_VAR} PURGE")]).await;
self.retry_link();
let _ = self.exec(&[format!("'{BACKUP_VAR}' PGDIR")]).await;
}
let data = result?;
let info = inspect(&data)?;
if info.object_type != Some(ObjectType::Directory) {
return Err(Error::Object(format!(
"backup is not a directory (prolog {:05X})",
info.prolog
)));
}
Ok(data)
}
async fn backup_steps(&mut self) -> Result<Vec<u8>> {
let copied = self
.exec(&[
format!(":0:{BACKUP_VAR} RCL"),
format!("'{BACKUP_VAR}' STO"),
format!(":0:{BACKUP_VAR} PURGE"),
])
.await;
if let Err(Error::Calculator { stack, .. }) = &copied
&& stack.first().is_some_and(|l| {
l.trim() == BACKUP_VAR || parse_name(l).as_deref() == Some(BACKUP_VAR)
})
{
self.retry_link();
let _ = self.drop_levels(2).await;
}
copied?;
let data = self.get(BACKUP_VAR, TransferMode::Binary).await?;
self.exec(&[format!("'{BACKUP_VAR}' PGDIR")]).await?;
Ok(data)
}
pub(crate) async fn restore(&mut self, data: &[u8]) -> Result<()> {
self.restore_leaving(data, None).await
}
pub(crate) async fn restore_leaving(
&mut self,
data: &[u8],
mode: Option<TransferMode>,
) -> Result<()> {
check_backup(data)?;
self.refuse_existing(RESTORE_VAR).await?;
let stored = self.put(RESTORE_VAR, data, TransferMode::Binary).await?;
if stored != RESTORE_VAR {
return Err(Error::Reply(format!(
"backup stored as {stored}, expected {RESTORE_VAR}"
)));
}
let copied = self
.exec(&[
format!("'{RESTORE_VAR}' RCL"),
format!(":0:{RESTORE_VAR} STO"),
format!("'{RESTORE_VAR}' PGDIR"),
])
.await;
if let Err(e) = copied {
self.retry_link();
let _ = self.exec(&[format!("'{RESTORE_VAR}' PGDIR")]).await;
return Err(e);
}
if let Some(mode) = mode {
self.set_transfer_mode(mode).await?;
}
self.restore_from_port().await
}
async fn restore_from_port(&mut self) -> Result<()> {
self.st.mode = None;
let timeout = self.k.config().timeout;
let restore = format!(":0:{RESTORE_VAR} RESTORE");
match self.host_once(&restore, RESTORE_TIMEOUT.min(timeout)).await {
Err(Error::NoReply { .. }) => {}
Err(e) => return Err(e),
Ok(reply) => {
checked(reply)?;
return Err(Error::Reply("calculator did not restart".into()));
}
}
let marker = self.st.marker();
let probe = self.host_once(&format!("\"{marker}\""), timeout).await;
let still_running = || {
Error::Reply(format!(
"the calculator answers again, so RESTORE's result is unknown: it may have \
run before the server was restarted; the backup stays in :0:{RESTORE_VAR}"
))
};
match probe {
Err(Error::NoReply { .. }) => Ok(()),
Err(Error::Remote(_)) => Err(still_running()),
Err(e) => Err(e),
Ok(reply) => {
if reply.error.is_none()
&& reply.level(1).and_then(parse_string).as_deref() == Some(marker.as_str())
{
let _ = self.drop_levels(1).await;
}
Err(still_running())
}
}
}
pub(crate) async fn purge_restore_leftover(&mut self) -> Result<()> {
self.exec(&[format!(":0:{RESTORE_VAR} PURGE")])
.await
.map(|_| ())
}
pub(crate) async fn finish(&mut self) -> Result<()> {
self.k.transact(Command::Finish).await.map(|_| ())
}
pub(crate) async fn model(&mut self) -> Result<Model> {
Ok(Model::from_version(self.version().await?.as_deref()))
}
pub(crate) async fn prepare_for_xmodem(
&mut self,
direction: XmodemDirection,
name: &str,
) -> Result<XmodemPlan> {
validate_name(name)?;
let model = self.model().await?;
if !model.has_xmodem() {
return Err(Error::Unsupported(format!(
"the {} has no XModem; use Kermit",
model.name()
)));
}
let exists = self.list().await?.entries.iter().any(|e| e.name == name);
if direction == XmodemDirection::FromCalculator && !exists {
return Err(Error::Reply(format!("{name}: no such variable")));
}
if direction == XmodemDirection::ToCalculator && exists && model == Model::Hp48Gx {
return Err(Error::Reply(format!("{name}: already exists")));
}
let mut switched_to_rpn = false;
if model == Model::Hp49G {
let flag = self.query("-95. FS?", 1).await?;
let alg = flag.first().and_then(|v| parse_real(v)) == Some(1.0);
if alg {
self.exec(&["-95. CF".to_string()]).await?;
switched_to_rpn = true;
}
}
if let Err(e) = self.exec(&[stacked_program(direction, name)]).await {
if switched_to_rpn {
let _ = self.exec(&["-95. SF".to_string()]).await;
}
return Err(e);
}
self.finish().await?;
self.st.mode = None;
let mut notes = Vec::new();
if direction == XmodemDirection::ToCalculator && exists {
notes.push(match model {
Model::Hp49G => format!(
"{name} exists: the 49G does not overwrite it but stores the object as {name}.1."
),
_ => format!(
"{name} exists: the 49G stores the object as {name}.1 and the 48G/GX \
refuses with \"Name Conflict\"; this model is unknown."
),
});
}
if direction == XmodemDirection::ToCalculator && model == Model::Hp48Gx {
notes.push(format!(
"If the transfer fails, {name} may be left holding an empty string."
));
}
if switched_to_rpn {
notes.push(
"The calculator was in algebraic mode and is now in RPN mode \
(flag -95 cleared); type -95 SF to switch back."
.to_string(),
);
}
notes.push(
"If you do not go on, press \u{2190} (backspace) instead: it drops the program, \
and the stack is as it was."
.to_string(),
);
notes.push(format!(
"The calculator has left server mode; {} after the transfer.",
server_again(model)
));
Ok(XmodemPlan {
model,
direction,
name: name.to_string(),
program: program_text(direction, name),
keys: eval_keys(model).iter().map(|k| k.to_string()).collect(),
switched_to_rpn,
exists,
notes,
})
}
async fn refuse_existing(&mut self, name: &str) -> Result<()> {
if self.list().await?.entries.iter().any(|e| e.name == name) {
return Err(Error::Reply(format!(
"{name} exists in the current directory; remove it first"
)));
}
Ok(())
}
}
#[derive(Debug)]
#[cfg(not(target_arch = "wasm32"))]
pub struct Calculator {
session: Session,
state: CalcState,
}
#[cfg(not(target_arch = "wasm32"))]
impl Calculator {
pub fn new(session: Session) -> Self {
Calculator {
session,
state: CalcState::new(entropy()),
}
}
pub fn open(addr: &str) -> Result<Self> {
let mut calc = Calculator::new(Session::open(addr)?);
calc.sync()?;
Ok(calc)
}
pub fn session(&mut self) -> &mut Session {
self.state.mode = None;
&mut self.session
}
pub fn into_session(self) -> Session {
self.session
}
pub fn into_transport(self) -> Box<dyn Transport> {
self.session.into_transport()
}
fn split(&mut self) -> (&mut dyn Transport, Link, CalcOps<'_>) {
let link = self.session.core.link.clone();
let ops = CalcOps {
k: &mut self.session.core,
st: &mut self.state,
};
(self.session.transport.as_mut(), link, ops)
}
#[cfg(test)]
fn sync_with(&mut self, marker: &str) -> Result<()> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.sync_with(marker), &mut |_| {})
}
#[cfg(test)]
fn restore_from_port(&mut self) -> Result<()> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.restore_from_port(), &mut |_| {})
}
pub fn sync(&mut self) -> Result<()> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.sync(), &mut |_| {})
}
pub fn run(&mut self, command: &str) -> Result<StackReply> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.run(command), &mut |_| {})
}
pub fn list(&mut self) -> Result<Listing> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.list(), &mut |_| {})
}
pub fn path(&mut self) -> Result<Vec<String>> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.path(), &mut |_| {})
}
pub fn cd(&mut self, path: &[&str]) -> Result<()> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.cd(path), &mut |_| {})
}
pub fn updir(&mut self) -> Result<()> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.updir(), &mut |_| {})
}
pub fn mkdir(&mut self, name: &str) -> Result<()> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.mkdir(name), &mut |_| {})
}
pub fn remove(&mut self, name: &str) -> Result<()> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.remove(name), &mut |_| {})
}
pub fn rename(&mut self, from: &str, to: &str) -> Result<()> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.rename(from, to), &mut |_| {})
}
pub fn mem(&mut self) -> Result<f64> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.mem(), &mut |_| {})
}
pub fn version(&mut self) -> Result<Option<String>> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.version(), &mut |_| {})
}
pub fn iopar(&mut self) -> Result<Iopar> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.iopar(), &mut |_| {})
}
pub fn set_iopar(&mut self, iopar: &Iopar) -> Result<()> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.set_iopar(iopar), &mut |_| {})
}
pub fn transfer_mode(&mut self) -> Result<TransferMode> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.transfer_mode(), &mut |_| {})
}
pub fn set_transfer_mode(&mut self, mode: TransferMode) -> Result<()> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.set_transfer_mode(mode), &mut |_| {})
}
pub fn get(&mut self, name: &str, mode: TransferMode) -> Result<Vec<u8>> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.get(name, mode), &mut |_| {})
}
pub fn put(&mut self, name: &str, data: &[u8], mode: TransferMode) -> Result<String> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.put(name, data, mode), &mut |_| {})
}
pub fn pict(&mut self) -> Result<Grob> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.pict(), &mut |_| {})
}
pub fn backup(&mut self) -> Result<Vec<u8>> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.backup(), &mut |_| {})
}
pub fn restore(&mut self, data: &[u8]) -> Result<()> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.restore(data), &mut |_| {})
}
pub fn purge_restore_leftover(&mut self) -> Result<()> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.purge_restore_leftover(), &mut |_| {})
}
pub fn finish(&mut self) -> Result<()> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.finish(), &mut |_| {})
}
pub fn model(&mut self) -> Result<Model> {
let (transport, link, mut c) = self.split();
link::drive(transport, &link, c.model(), &mut |_| {})
}
pub fn prepare_for_xmodem(
&mut self,
direction: XmodemDirection,
name: &str,
) -> Result<XmodemPlan> {
let (transport, link, mut c) = self.split();
link::drive(
transport,
&link,
c.prepare_for_xmodem(direction, name),
&mut |_| {},
)
}
}
fn entropy() -> u64 {
use std::hash::{BuildHasher, Hasher};
#[cfg(not(target_arch = "wasm32"))]
use std::time::{SystemTime, UNIX_EPOCH};
#[cfg(target_arch = "wasm32")]
use web_time::{SystemTime, UNIX_EPOCH};
let mut hasher = std::collections::hash_map::RandomState::new().build_hasher();
if let Ok(since) = SystemTime::now().duration_since(UNIX_EPOCH) {
hasher.write_u128(since.as_nanos());
}
hasher.finish()
}
pub fn sync_marker() -> String {
CalcState::new(entropy()).marker()
}
fn check_backup(data: &[u8]) -> Result<()> {
let info = inspect(data).map_err(|e| Error::Object(format!("not a backup: {e}")))?;
if info.object_type != Some(ObjectType::Directory) {
return Err(Error::Object(format!(
"not a backup: prolog {:05X} is not a directory",
info.prolog
)));
}
let nibbles = unpack(data.get(HEADER_LEN..).unwrap_or_default());
object_size(&nibbles, 0).map_err(|e| Error::Object(format!("not a backup: {e}")))?;
Ok(())
}
fn drop_command(n: usize) -> Option<String> {
match n {
0 => None,
1 => Some("DROP".to_string()),
2 => Some("DROP2".to_string()),
n => Some(format!("{n}. DROPN")),
}
}
fn is_flags(level: &str) -> bool {
level.trim_start().starts_with('{') && level.contains('#')
}
fn parse_count(level: &str) -> Option<usize> {
let x = parse_real(level)?;
(x.fract() == 0.0 && (0.0..1.0e6).contains(&x)).then_some(x as usize)
}
fn checked(reply: StackReply) -> Result<StackReply> {
match reply.error {
Some(message) => Err(Error::Calculator {
message,
stack: reply.levels,
}),
None => Ok(reply),
}
}
fn quote(name: &str) -> Result<String> {
validate_name(name)?;
Ok(format!("'{name}'"))
}
pub fn validate_name(name: &str) -> Result<()> {
if !saturnus_objects::transfer::is_plain_name(name) || is_windows_device(name) {
return Err(Error::Name(name.to_string()));
}
Ok(())
}
fn is_windows_device(name: &str) -> bool {
let stem = name
.split('.')
.next()
.unwrap_or_default()
.to_ascii_uppercase();
match stem.as_bytes() {
b"CON" | b"PRN" | b"AUX" | b"NUL" => true,
[b'C', b'O', b'M', d] | [b'L', b'P', b'T', d] => (b'1'..=b'9').contains(d),
_ => false,
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
pub(crate) mod tests {
use super::*;
use crate::session::Options;
use crate::transport::MemoryTransport;
use kermit_proto::codec::{BlockCheck, Deframer, Framing, Packet, parse_frame};
use kermit_proto::prefix::{self, Quoting};
use std::sync::{Arc, Mutex};
pub(crate) type Log = Arc<Mutex<Vec<String>>>;
pub(crate) fn fake_server(
log: Log,
mut reply: impl FnMut(&str) -> String + Send + 'static,
) -> impl FnMut(&[u8]) -> Vec<Vec<u8>> + Send {
let check = BlockCheck::Type1;
let mut deframer = Deframer::new();
let mut queue: Vec<Packet> = Vec::new();
move |bytes| {
let wire = |p: &Packet| p.encode(check, &Framing::default()).unwrap();
deframer.push(bytes);
let mut out = Vec::new();
while let Some(frame) = deframer.next_frame() {
let p = parse_frame(&frame, check).unwrap();
let data = prefix::decode(&p.data, &Quoting::default()).unwrap();
match p.kind {
b'G' if data == b"F" => {
log.lock().unwrap().push("G F".into());
out.push(wire(&Packet::new(p.seq, b'Y', Vec::new())));
}
b'C' | b'G' => {
let command = if p.kind == b'G' {
format!("G {}", decode(&data))
} else {
decode(&data)
};
log.lock().unwrap().push(command.clone());
let reply = reply(&command);
if reply == "SILENT" {
queue.clear();
continue;
}
if let Some(message) = reply.strip_prefix("E:") {
queue.clear();
out.push(wire(&Packet::new(0, b'E', message.as_bytes().to_vec())));
continue;
}
let text = encode(&reply).unwrap();
queue = vec![Packet::new(1, b'X', Vec::new())];
let mut rest = text.as_slice();
while !rest.is_empty() {
let (enc, used) = prefix::encode(rest, &Quoting::default(), 90);
let seq = u8::try_from(queue.len() + 1).unwrap();
queue.push(Packet::new(seq, b'D', enc));
rest = &rest[used..];
}
let seq = u8::try_from(queue.len() + 1).unwrap();
queue.push(Packet::new(seq, b'Z', Vec::new()));
queue.push(Packet::new(seq + 1, b'B', Vec::new()));
out.push(wire(&Packet::new(0, b'S', b"~* @-#Y1 ".to_vec())));
}
b'Y' => {
if let Some(next) = queue.iter().find(|q| q.seq == p.seq + 1) {
out.push(wire(next));
}
}
b'N' => {
if let Some(again) = queue.iter().find(|q| q.seq == p.seq) {
out.push(wire(again));
}
}
b'E' => queue.clear(),
kind => panic!("unexpected packet {}", char::from(kind)),
}
}
out
}
}
fn calc(reply: impl FnMut(&str) -> String + Send + 'static) -> (Calculator, Log) {
let log: Log = Arc::default();
let transport = MemoryTransport::new(fake_server(Arc::clone(&log), reply));
let mut kermit = Options::default().kermit;
kermit.timeout = Duration::from_millis(200);
kermit.linger = Duration::ZERO;
let options = Options {
kermit,
drain: Duration::ZERO,
turnaround: Duration::ZERO,
};
let session = Session::new(Box::new(transport), options).unwrap();
(Calculator::new(session), log)
}
fn sent(log: &Log) -> Vec<String> {
log.lock().unwrap().clone()
}
const EMPTY: &str = "Empty Stack\r\n";
const GX_DIR: &str =
"{ HOME D1 } 127847\r\nX 10.5 Real Number 1234\r\nSUB 5.5 Directory 4321\r\n";
const SX_DIR: &str = "X 10.5 Real Number 1234\r\nSUB 5.5 Directory 4321\r\n";
const SX_FLAGS: &str = "{ # 1008d # 0d }";
const G49_FLAGS: &str = "{# 2000204010FF0h,# 0h";
#[test]
fn mem_drops_its_value() {
let (mut c, log) = calc(|cmd| match cmd {
MEM_STD => format!("2: {SX_FLAGS}\r\n1: 12345\r\n"),
_ => EMPTY.into(),
});
assert_eq!(c.mem().unwrap(), 12345.0);
assert_eq!(sent(&log), [MEM_STD, "DROP STOF"]);
}
#[test]
fn path_from_listing_header() {
let (mut c, log) = calc(|cmd| match cmd {
"G D" => GX_DIR.into(),
_ => panic!("unexpected {cmd}"),
});
assert_eq!(c.path().unwrap(), ["HOME", "D1"]);
assert_eq!(sent(&log), ["G D"]);
}
const MARKER: &str = "SATX-0a1b2c";
const MARKER_CMD: &str = "\"SATX-0a1b2c\"";
fn sync_against(replies: Vec<&'static str>) -> Vec<String> {
let (result, log) = try_sync_against(replies);
result.unwrap();
log
}
fn try_sync_against(replies: Vec<&'static str>) -> (Result<()>, Vec<String>) {
let mut replies = replies.into_iter();
let (mut c, log) = calc(move |cmd| match cmd {
MARKER_CMD => replies.next().unwrap_or(EMPTY).into(),
"DROP" | "DROP2" => EMPTY.into(),
_ => panic!("unexpected {cmd}"),
});
let result = c.sync_with(MARKER);
(result, sent(&log))
}
fn assert_not_in_step(result: Result<()>) {
assert!(
matches!(&result, Err(Error::Reply(m)) if m.contains("not in step")),
"{result:?}"
);
}
#[test]
fn sync_marker_is_short_and_plain() {
let m = sync_marker();
assert_eq!(m.len(), 11, "{m}");
assert!(m.starts_with("SATX-"));
assert!(m[5..].chars().all(|c| c.is_ascii_hexdigit()), "{m}");
assert_ne!(sync_marker(), sync_marker());
}
#[test]
fn sync_in_step_costs_two_transactions() {
let one = "1: \"SATX-0a1b2c\"\r\n";
assert_eq!(sync_against(vec![one]), [MARKER_CMD, "DROP"]);
}
#[test]
fn sync_skips_a_stale_reply() {
let stale = "2: 1\r\n1: 2\r\n";
let ours = "3: 1\r\n2: 2\r\n1: \"SATX-0a1b2c\"\r\n";
assert_eq!(
sync_against(vec![stale, ours]),
[MARKER_CMD, MARKER_CMD, "DROP"]
);
}
#[test]
fn sync_skips_a_truncated_path_reply() {
let stale = "1: {HOME,SATXAAAA,SATXBB\r\n";
let ours = "2: {HOME,SATXAAAA,SATXBB\r\n1: \"SATX-0a1b2c\"\r\n";
assert_eq!(
sync_against(vec![stale, ours]),
[MARKER_CMD, MARKER_CMD, "DROP"]
);
}
#[test]
fn sync_keeps_a_path_shaped_stale_result() {
let stale = "1: { HOME }\r\n";
let ours = "2: { HOME }\r\n1: \"SATX-0a1b2c\"\r\n";
assert_eq!(
sync_against(vec![stale, ours]),
[MARKER_CMD, MARKER_CMD, "DROP"]
);
}
#[test]
fn sync_in_a_deep_49g_directory() {
let ours = "2: {D1,G,TG,B,C,A,P,L,S,R\r\n1: \"SATX-0a1b2c\"\r\n";
assert_eq!(sync_against(vec![ours]), [MARKER_CMD, "DROP"]);
}
#[test]
fn sync_drops_every_copy_of_its_marker() {
let stale = "Error: Bad Argument Type\r\n";
let ours =
"3: 7\r\n2: \"SATX-0a1b2c\"\r\n1: \"SATX-0a1b2c\"\r\n";
assert_eq!(
sync_against(vec![stale, ours]),
[MARKER_CMD, MARKER_CMD, "DROP2"]
);
}
#[test]
fn sync_survives_an_error_packet() {
let ours = "1: \"SATX-0a1b2c\"\r\n";
assert_eq!(
sync_against(vec!["E:Transfer Failed", ours]),
[MARKER_CMD, MARKER_CMD, "DROP"]
);
let (result, log) = try_sync_against(vec!["E:Transfer Failed", "E:Transfer Failed"]);
assert_eq!(log, [MARKER_CMD, MARKER_CMD]);
assert_not_in_step(result);
}
#[test]
fn sync_retries_once_after_a_timeout() {
let mut n = 0;
let (mut c, log) = calc(move |cmd| {
n += 1;
match (cmd, n) {
(MARKER_CMD, 1) => "SILENT".into(),
(MARKER_CMD, _) => {
"3: 7\r\n2: \"SATX-0a1b2c\"\r\n1: \"SATX-0a1b2c\"\r\n"
.into()
}
("DROP2", _) => EMPTY.into(),
_ => panic!("unexpected {cmd}"),
}
});
c.sync_with(MARKER).unwrap();
assert_eq!(sent(&log), [MARKER_CMD, MARKER_CMD, "DROP2"]);
assert_eq!(
c.session().config().retries,
Options::default().kermit.retries
);
let (mut c, log) = calc(|_| "SILENT".into());
let err = c.sync_with(MARKER).unwrap_err();
assert!(
matches!(err, Error::Kermit(kermit_proto::Error::Timeout)),
"{err:?}"
);
let log = sent(&log);
assert_eq!(log.len(), 1 + 6, "{log:?}");
assert!(log.iter().all(|c| c == MARKER_CMD), "{log:?}");
}
#[test]
fn sync_never_drops_what_it_did_not_push() {
let error = "Error: Bad Argument Type\r\n1: 1\r\n";
let (result, log) = try_sync_against(vec![error, EMPTY]);
assert_eq!(log, [MARKER_CMD, MARKER_CMD]);
assert_not_in_step(result);
let below = "2: \"SATX-0a1b2c\"\r\n1: 1\r\n";
let other = "1: \"SATX-ffffff\"\r\n";
let (result, log) = try_sync_against(vec![below, other]);
assert_eq!(log, [MARKER_CMD, MARKER_CMD]);
assert_not_in_step(result);
}
#[test]
fn host_command_is_never_resent() {
use crate::machine::{Machine, Op};
use crate::time::Instant;
for halves in [0, 1] {
let log: Log = Arc::default();
let mut server = fake_server(Arc::clone(&log), |_| "SILENT".into());
let check = BlockCheck::Type1;
let mut deframer = Deframer::new();
let timeout = Duration::from_millis(300);
let mut kermit = Options::default().kermit;
kermit.timeout = timeout;
let options = Options {
kermit,
drain: Duration::ZERO,
turnaround: Duration::ZERO,
};
let t0 = Instant::now();
let mut clock = t0;
let mut m = Machine::new(clock, options, 1);
m.set_events(false);
m.start(clock, Op::Run("1 'X' STO+".into())).unwrap();
let mut result = None;
for _ in 0..1000 {
while let Some(bytes) = m.poll_transmit() {
let mut out = server(&bytes);
deframer.push(&bytes);
while let Some(frame) = deframer.next_frame() {
if parse_frame(&frame, check).unwrap().kind == b'C' {
let nak = Packet::new(0, b'N', Vec::new());
out.push(nak.encode(check, &Framing::default()).unwrap());
let wire = HOST_BYTE_TIME * u32::try_from(bytes.len()).unwrap();
clock += wire * halves / 2;
}
}
for chunk in out {
m.handle_input(clock, &chunk);
}
}
result = m.poll_result();
if result.is_some() {
break;
}
let deadline = m.next_timeout().expect("waits without a deadline");
clock = clock.max(deadline);
m.handle_timeout(clock);
}
let err = result.expect("no result").unwrap_err();
assert!(
matches!(&err, Error::NoReply { command } if command == "1 'X' STO+"),
"{err:?}"
);
assert!(err.to_string().contains("may have run"), "{err}");
assert_eq!(sent(&log), ["1 'X' STO+"], "NAK after {halves}/2 wire time");
assert!(clock - t0 >= timeout, "{:?}", clock - t0);
}
}
#[test]
fn host_command_late_nak_is_not_resent() {
let log: Log = Arc::default();
let mut server = fake_server(Arc::clone(&log), |_| "SILENT".into());
let check = BlockCheck::Type1;
let mut deframer = Deframer::new();
let transport = MemoryTransport::new(move |bytes: &[u8]| {
let mut out = server(bytes);
deframer.push(bytes);
while let Some(frame) = deframer.next_frame() {
if parse_frame(&frame, check).unwrap().kind == b'C' {
std::thread::sleep(HOST_NAK_WINDOW + Duration::from_millis(50));
let nak = Packet::new(0, b'N', Vec::new());
out.push(nak.encode(check, &Framing::default()).unwrap());
}
}
out
});
let mut kermit = Options::default().kermit;
kermit.timeout = Duration::from_millis(600);
let options = Options {
kermit,
drain: Duration::ZERO,
turnaround: Duration::ZERO,
};
let mut c = Calculator::new(Session::new(Box::new(transport), options).unwrap());
let start = std::time::Instant::now();
let err = c.run("1 'X' STO+").unwrap_err();
assert!(
matches!(&err, Error::NoReply { command } if command == "1 'X' STO+"),
"{err:?}"
);
assert!(err.to_string().contains("may have run"), "{err}");
assert_eq!(sent(&log), ["1 'X' STO+"]);
assert!(start.elapsed() >= Duration::from_millis(600));
assert_eq!(
c.session().config().retries,
Options::default().kermit.retries
);
assert_eq!(c.session().config().first_packet_retries, None);
}
#[test]
fn host_command_rejected_at_once_is_resent() {
let log: Log = Arc::default();
let mut server = fake_server(Arc::clone(&log), |_| "1: 42\r\n".into());
let wire: Log = Arc::default();
let on_wire = Arc::clone(&wire);
let check = BlockCheck::Type1;
let mut deframer = Deframer::new();
let transport = MemoryTransport::new(move |bytes: &[u8]| {
deframer.push(bytes);
let mut first_c = false;
while let Some(frame) = deframer.next_frame() {
if parse_frame(&frame, check).unwrap().kind == b'C' {
let mut seen = on_wire.lock().unwrap();
seen.push("C".into());
first_c = seen.len() == 1;
}
}
if first_c {
std::thread::sleep(Duration::from_millis(30));
let nak = Packet::new(0, b'N', Vec::new());
return vec![nak.encode(check, &Framing::default()).unwrap()];
}
server(bytes)
});
let mut kermit = Options::default().kermit;
kermit.timeout = Duration::from_millis(300);
kermit.linger = Duration::ZERO;
let options = Options {
kermit,
drain: Duration::ZERO,
turnaround: Duration::ZERO,
};
let mut c = Calculator::new(Session::new(Box::new(transport), options).unwrap());
assert_eq!(c.run("6 7 *").unwrap().levels, ["42"]);
assert_eq!(sent(&wire), ["C", "C"]);
assert_eq!(sent(&log), ["6 7 *"]);
assert_eq!(c.session().config().first_packet_nak_window, None);
}
fn calc_dropping_data(
drop: usize,
reply: impl FnMut(&str) -> String + Send + 'static,
) -> (Calculator, Log) {
let log: Log = Arc::default();
let mut server = fake_server(Arc::clone(&log), reply);
let mut left = drop;
let mut deframer = Deframer::new();
let transport = MemoryTransport::new(move |bytes: &[u8]| {
let mut out = server(bytes);
out.retain(|chunk| {
deframer.push(chunk);
let data = deframer
.next_frame()
.is_some_and(|f| parse_frame(&f, BlockCheck::Type1).unwrap().kind == b'D');
if data && left > 0 {
left -= 1;
return false;
}
true
});
out
});
let mut kermit = Options::default().kermit;
kermit.timeout = Duration::from_millis(100);
kermit.linger = Duration::ZERO;
let options = Options {
kermit,
drain: Duration::ZERO,
turnaround: Duration::ZERO,
};
let session = Session::new(Box::new(transport), options).unwrap();
(Calculator::new(session), log)
}
#[test]
fn host_reply_packets_keep_their_retries() {
let reply = |_: &str| "1: 42\r\n".to_string();
let (mut c, log) = calc_dropping_data(1, reply);
assert_eq!(c.run("6 7 *").unwrap().levels, ["42"]);
assert_eq!(sent(&log), ["6 7 *"]);
let (mut c, log) = calc_dropping_data(usize::MAX, reply);
let err = c.run("6 7 *").unwrap_err();
assert!(
matches!(err, Error::Kermit(kermit_proto::Error::Timeout)),
"{err:?}"
);
assert_eq!(sent(&log), ["6 7 *"]);
}
struct GlitchOnGet {
inner: MemoryTransport,
fail_next_read: bool,
glitched: bool,
}
impl Transport for GlitchOnGet {
fn write_packet(&mut self, packet: &[u8]) -> std::io::Result<()> {
if !self.glitched && packet.get(3) == Some(&b'R') {
self.glitched = true;
self.fail_next_read = true;
return Ok(());
}
self.inner.write_packet(packet)
}
fn read(&mut self, buf: &mut [u8], timeout: Duration) -> std::io::Result<usize> {
if std::mem::take(&mut self.fail_next_read) {
return Err(std::io::Error::other("glitch"));
}
self.inner.read(buf, timeout)
}
}
#[test]
fn pict_cleanup_tries_the_link_after_a_link_error() {
let log: Log = Arc::default();
let server = fake_server(Arc::clone(&log), |cmd: &str| match cmd {
"G D" => SX_DIR.into(),
_ => EMPTY.into(),
});
let transport = GlitchOnGet {
inner: MemoryTransport::new(server),
fail_next_read: false,
glitched: false,
};
let mut kermit = Options::default().kermit;
kermit.timeout = Duration::from_millis(200);
kermit.linger = Duration::ZERO;
let options = Options {
kermit,
drain: Duration::ZERO,
turnaround: Duration::ZERO,
};
let mut c = Calculator::new(Session::new(Box::new(transport), options).unwrap());
let err = c.pict().unwrap_err();
assert!(
matches!(&err, Error::Io(e) if e.to_string() == "glitch"),
"{err:?}"
);
assert_eq!(
sent(&log),
["G D", "PICT RCL 'SATXTMP' STO", "-35 SF", "'SATXTMP' PURGE"]
);
}
#[test]
fn a_failed_backup_drops_what_keeps_the_port_object_in_use() {
for (level, dropped) in [("'SATXBK'", true), ("SATXBK", true), ("'OTHER'", false)] {
let (mut c, log) = calc(move |cmd| match cmd {
"G D" => "{ HOME } 1000\r\n".to_string(),
":0:SATXBK RCL 'SATXBK' STO :0:SATXBK PURGE" => {
format!("Error: Insufficient Memory\r\n2: Directory\r\n1: {level}\r\n")
}
_ => "Empty Stack\r\n".to_string(),
});
let err = c.backup().unwrap_err();
assert!(matches!(err, Error::Calculator { .. }), "{err:?}");
let sent = log.lock().unwrap().clone();
let purge = sent.iter().position(|s| s == ":0:SATXBK PURGE").unwrap();
let drop2 = sent.iter().position(|s| s == "DROP2");
if dropped {
assert!(drop2.is_some_and(|d| d < purge), "{sent:?}");
} else {
assert_eq!(drop2, None, "{sent:?}");
}
}
}
#[test]
fn restore_refuses_a_truncated_backup() {
let path = format!("{}/fixtures/48sx-D1.hp", env!("CARGO_MANIFEST_DIR"));
let full = std::fs::read(path).unwrap();
let cut = &full[..full.len() / 2];
assert_eq!(
inspect(cut).unwrap().object_type,
Some(ObjectType::Directory)
);
let (mut c, log) = calc(|cmd| panic!("unexpected {cmd}"));
let err = c.restore(cut).unwrap_err();
assert!(
matches!(&err, Error::Object(m) if m.starts_with("not a backup")),
"{err:?}"
);
assert!(sent(&log).is_empty());
}
#[test]
fn check_backup_accepts_an_attached_library() {
let nibbles = |lib: u32| -> Vec<u8> {
let mut n = Vec::new();
for (value, width) in [(0x02A96u32, 5), (lib, 3), (0, 5)] {
n.extend((0..width).map(|i| ((value >> (4 * i)) & 0xF) as u8));
}
n
};
for lib in [0x7FF, 0x123] {
let mut data = b"HPHP48-R".to_vec();
data.extend(crate::object::pack(&nibbles(lib)));
check_backup(&data).unwrap();
}
}
#[test]
fn restore_probe_after_the_silent_restore() {
const RESTORE: &str = ":0:SATXRS RESTORE";
let (mut c, log) = calc(|_| "SILENT".into());
c.restore_from_port().unwrap();
let log = sent(&log);
assert_eq!(log.len(), 2, "{log:?}");
assert_eq!(log[0], RESTORE);
assert!(log[1].starts_with("\"SATX-"), "{log:?}");
let (mut c, log) = calc(|cmd| match cmd {
RESTORE => "SILENT".into(),
"DROP" => EMPTY.into(),
probe => format!("1: {probe}\r\n"),
});
let err = c.restore_from_port().unwrap_err();
assert!(
matches!(&err, Error::Reply(m) if m.contains("RESTORE's result is unknown")),
"{err:?}"
);
let log = sent(&log);
assert_eq!(log.len(), 3, "{log:?}");
assert_eq!(log[2], "DROP", "the probe's marker is dropped");
}
#[test]
fn path_query_without_header() {
let (mut c, log) = calc(|cmd| match cmd {
"G D" => SX_DIR.into(),
"PATH" => "1: { HOME D1 }\r\n".into(),
_ => EMPTY.into(),
});
assert_eq!(c.path().unwrap(), ["HOME", "D1"]);
assert_eq!(sent(&log), ["G D", "PATH", "DROP"]);
}
#[test]
fn version_48sx() {
let (mut c, log) = calc(|cmd| match cmd {
"VERSION" => "1: 'VERSION'\r\n".into(),
_ => EMPTY.into(),
});
assert_eq!(c.version().unwrap(), None);
assert_eq!(sent(&log), ["VERSION", "DROP"]);
}
#[test]
fn version_48gx() {
let (mut c, log) = calc(|cmd| match cmd {
"VERSION" => "2: \"Version HP48-R\"\r\n1: \"Copyright HP 1993\"\r\n".into(),
_ => EMPTY.into(),
});
assert_eq!(
c.version().unwrap().as_deref(),
Some("Version HP48-R, Copyright HP 1993")
);
assert_eq!(sent(&log), ["VERSION", "DROP2"]);
}
#[test]
fn version_49g_two_line_string() {
let (mut c, _) = calc(|cmd| match cmd {
"VERSION" => {
"2: \"Version HP49-C\r\nRevision #1.19-6\"\r\n1: \"Copyright HP 2009\"\r\n".into()
}
_ => EMPTY.into(),
});
assert_eq!(
c.version().unwrap().as_deref(),
Some("Version HP49-C Revision #1.19-6, Copyright HP 2009")
);
}
fn chunk_reply(version: &str, copyright: &str, below: &[&str]) -> String {
let joined: Vec<char> = format!("{version}{copyright}").chars().collect();
let mut levels: Vec<String> = below.iter().map(|l| (*l).to_string()).collect();
levels.push(G49_FLAGS.to_string());
for chunk in joined.chunks(CHUNK) {
let chunk: String = chunk.iter().collect();
levels.push(format!("\"{}\"", chunk.replace('\n', "\r\n")));
}
levels.push(format!("{}.", joined.len()));
let depth = levels.len();
levels
.iter()
.enumerate()
.map(|(i, level)| format!("{}: {level}\r\n", depth - i))
.collect()
}
#[test]
fn version_49g_1_18_cut_at_the_display_width() {
let (mut c, log) = calc(|cmd| match cmd {
"VERSION" => {
"3: 4711.\r\n2: \"Version HP49-C\r\nRevi\r\n1: \"Copyright HP 2000\"\r\n".into()
}
VERSION_CHUNKS => chunk_reply(
"Version HP49-C\nRevision #1.18",
"Copyright HP 2000",
&["4711."],
),
_ => EMPTY.into(),
});
let version = c.version().unwrap();
assert_eq!(
version.as_deref(),
Some("Version HP49-C Revision #1.18, Copyright HP 2000")
);
assert_eq!(Model::from_version(version.as_deref()), Model::Hp49G);
assert_eq!(sent(&log), ["VERSION", VERSION_CHUNKS, "6. DROPN STOF"]);
}
#[test]
fn version_49g_2_15_cut_at_the_display_width() {
let (mut c, log) = calc(|cmd| match cmd {
"VERSION" => "2: \"Version HP48-C\r\nRevisi\r\n1: \"Copyright HP 2009\"\r\n".into(),
VERSION_CHUNKS => format!(
"7: {G49_FLAGS}\r\n6: \"Version HP\"\r\n5: \"48-C\r\nRevis\"\r\n\
4: \"ion #2.15C\"\r\n3: \"opyright H\"\r\n2: \"P 2009\"\r\n1: 46.\r\n"
),
_ => EMPTY.into(),
});
assert_eq!(
c.version().unwrap().as_deref(),
Some("Version HP48-C Revision #2.15, Copyright HP 2009")
);
assert_eq!(sent(&log), ["VERSION", VERSION_CHUNKS, "6. DROPN STOF"]);
}
#[test]
fn version_chunks_that_do_not_add_up() {
let (mut c, log) = calc(|cmd| match cmd {
"VERSION" => "2: \"Version HP49-C\r\nRevi\r\n1: \"Copyright HP 2000\"\r\n".into(),
VERSION_CHUNKS => format!(
"4: {G49_FLAGS}\r\n3: \"Version\"\r\n2: \"Copyright HP 2000\"\r\n1: 20.\r\n"
),
_ => EMPTY.into(),
});
let err = c.version().unwrap_err();
assert!(
matches!(&err, Error::Reply(m) if m.contains("bad chunks")),
"{err:?}"
);
assert_eq!(sent(&log), ["VERSION", VERSION_CHUNKS, "3. DROPN STOF"]);
}
#[test]
fn version_with_the_copyright_cut() {
let (mut c, log) = calc(|cmd| match cmd {
"VERSION" => "2: \"HP49-C\"\r\n1: \"Copyright HP 2000 and l\r\n".into(),
VERSION_CHUNKS => chunk_reply("HP49-C", "Copyright HP 2000 and later", &[]),
_ => EMPTY.into(),
});
assert_eq!(
c.version().unwrap().as_deref(),
Some("HP49-C, Copyright HP 2000 and later")
);
assert_eq!(sent(&log), ["VERSION", VERSION_CHUNKS, "5. DROPN STOF"]);
}
#[test]
fn version_with_both_strings_cut() {
let (mut c, log) = calc(|cmd| match cmd {
"VERSION" => "2: \"Version HP49-C\r\nRevi\r\n1: \"Copyright HP 2000 an\r\n".into(),
_ => EMPTY.into(),
});
let err = c.version().unwrap_err();
assert!(
matches!(&err, Error::Reply(m) if m.contains("both")),
"{err:?}"
);
assert_eq!(sent(&log), ["VERSION", "DROP2"]);
}
#[test]
fn version_chunks_that_fail() {
let cut = "3: 4711.\r\n2: \"Version HP49-C\r\nRevi\r\n1: \"Copyright HP 2000\"\r\n";
let after_rclf = format!(
"Error: Insufficient Memory\r\n5: 4711.\r\n4: {G49_FLAGS}\r\n\
3: \"Version HP\"\r\n2: \"49-C\r\nRevis\"\r\n1: \"Version HP49-C\r\nRevi\r\n"
);
let before_rclf = format!("Error: Insufficient Memory\r\n{cut}");
for (failed, cleanup) in [(after_rclf, "3. DROPN STOF"), (before_rclf, "DROP2")] {
let (mut c, log) = calc(move |cmd| match cmd {
"VERSION" => cut.into(),
VERSION_CHUNKS => failed.clone(),
_ => EMPTY.into(),
});
let err = c.version().unwrap_err();
assert!(
matches!(&err, Error::Calculator { message, .. } if message == "Insufficient Memory"),
"{err:?}"
);
assert_eq!(sent(&log), ["VERSION", VERSION_CHUNKS, cleanup]);
}
}
#[test]
fn iopar_item_by_item() {
let items_49g = format!(
"8: {G49_FLAGS}\r\n7: 9600.\r\n6: 0.\r\n5: 0.\r\n4: 0.\r\n3: 3.\r\n2: 1.\r\n1: 6.\r\n"
);
let items_48 = format!(
"9: 4711\r\n8: {SX_FLAGS}\r\n7: 9600\r\n6: 0\r\n5: 0\r\n4: 0\r\n3: 3\r\n2: 1\r\n\
1: 6\r\n"
);
let items_comma = format!(
"8: {G49_FLAGS}\r\n7: 2400,\r\n6: -2,\r\n5: 1,\r\n4: 0,\r\n3: 1,\r\n2: 3,\r\n1: 6,\r\n"
);
let other = Iopar {
baud: 2400,
parity: -2,
receive_pacing: true,
transmit_pacing: false,
checksum: 1,
translate: 3,
};
for (items, expected) in [
(items_49g, Iopar::default()),
(items_48, Iopar::default()),
(items_comma, other),
] {
let (mut c, log) = calc(move |cmd| match cmd {
"IOPAR" => "1: { 9600. 0. 0. 0. 3. \r\n".into(),
IOPAR_ITEMS => items.clone(),
_ => EMPTY.into(),
});
assert_eq!(c.iopar().unwrap(), expected);
assert_eq!(sent(&log), [IOPAR_ITEMS, IOPAR_DROP]);
}
}
#[test]
fn iopar_that_is_not_a_six_item_list() {
let (mut c, log) = calc(|cmd| match cmd {
IOPAR_ITEMS => format!("Error: Bad Argument Type\r\n2: {SX_FLAGS}\r\n1: 'IOPAR'\r\n"),
_ => EMPTY.into(),
});
let err = c.iopar().unwrap_err();
assert!(matches!(&err, Error::Calculator { .. }), "{err:?}");
assert_eq!(sent(&log), [IOPAR_ITEMS, "DROP STOF"]);
let (mut c, log) = calc(|cmd| match cmd {
IOPAR_ITEMS => "Error: Insufficient Memory\r\n1: 4711\r\n".into(),
_ => EMPTY.into(),
});
assert!(c.iopar().is_err());
assert_eq!(sent(&log), [IOPAR_ITEMS]);
let (mut c, log) = calc(|cmd| match cmd {
IOPAR_ITEMS => format!("4: {SX_FLAGS}\r\n3: 9600\r\n2: 0\r\n1: 2\r\n"),
_ => EMPTY.into(),
});
let err = c.iopar().unwrap_err();
assert!(
matches!(&err, Error::Reply(m) if m.contains("bad list")),
"{err:?}"
);
assert_eq!(sent(&log), [IOPAR_ITEMS, IOPAR_DROP]);
}
fn sci_0(x: f64) -> String {
if x == 0.0 {
return "0.E0".into();
}
let mut exp = x.abs().log10().floor() as i32;
let mut digit = (x / 10f64.powi(exp)).round();
if digit.abs() >= 10.0 {
digit /= 10.0;
exp += 1;
}
format!("{digit}.E{exp}")
}
#[test]
fn queries_in_0_sci() {
let std = Arc::new(Mutex::new(false));
let mode = Arc::clone(&std);
let (mut c, log) = calc(move |cmd| {
let mut std = mode.lock().unwrap();
if cmd.contains("STD") {
*std = true;
}
let real = |x: f64| if *std { format!("{x}.") } else { sci_0(x) };
let reply = match cmd {
"VERSION" => G49_VERSION.into(),
VERSION_CHUNKS => {
let joined = "Version HP48-C\nRevision #2.15Copyright HP 2009";
let mut levels = vec![G49_FLAGS.to_string()];
let chars: Vec<char> = joined.chars().collect();
for chunk in chars.chunks(CHUNK) {
let chunk: String = chunk.iter().collect();
levels.push(format!("\"{}\"", chunk.replace('\n', "\r\n")));
}
levels.push(real(chars.len() as f64));
let depth = levels.len();
levels
.iter()
.enumerate()
.map(|(i, l)| format!("{}: {l}\r\n", depth - i))
.collect()
}
IOPAR_ITEMS => {
let items = [9600.0, 0.0, 0.0, 0.0, 3.0, 1.0, 6.0];
let mut text = format!("8: {G49_FLAGS}\r\n");
for (i, x) in items.iter().enumerate() {
text.push_str(&format!("{}: {}\r\n", 7 - i, real(*x)));
}
text
}
MEM_STD => format!("2: {G49_FLAGS}\r\n1: {}\r\n", real(245_886.0)),
"-35 FS?" => format!("1: {}\r\n", real(1.0)),
_ => EMPTY.into(),
};
if cmd.ends_with("STOF") {
*std = false;
}
reply
});
assert_eq!(c.iopar().unwrap(), Iopar::default());
assert!(!*std.lock().unwrap(), "STD left on after IOPAR");
assert_eq!(c.mem().unwrap(), 245_886.0);
assert_eq!(
c.version().unwrap().as_deref(),
Some("Version HP48-C Revision #2.15, Copyright HP 2009")
);
assert!(!*std.lock().unwrap(), "STD left on after VERSION");
assert_eq!(c.transfer_mode().unwrap(), TransferMode::Binary);
assert_eq!(
sent(&log),
[
IOPAR_ITEMS,
IOPAR_DROP,
MEM_STD,
"DROP STOF",
"VERSION",
VERSION_CHUNKS,
"6. DROPN STOF",
"-35 FS?",
"DROP",
]
);
assert_eq!(sci_0(9600.0), "1.E4");
assert_eq!(sci_0(46.0), "5.E1");
}
#[test]
fn model_from_version() {
use Model::*;
assert_eq!(Model::from_version(None), Hp48Sx);
assert_eq!(
Model::from_version(Some("Version HP48-R, Copyright HP 1993")),
Hp48Gx
);
assert_eq!(
Model::from_version(Some("Version HP48-C Revision #2.15, Copyright HP 2009")),
Hp49G
);
assert_eq!(
Model::from_version(Some("Version HP49-C, Copyright HP 2000")),
Hp49G
);
assert_eq!(Model::from_version(Some("something else")), Unknown);
assert_eq!(Hp48Gx.name(), "HP 48G/GX");
assert!(!Hp48Sx.has_xmodem() && Hp48Gx.has_xmodem() && Hp49G.has_xmodem());
}
const G49_VERSION: &str = "2: \"Version HP48-C\r\nRevisi\r\n1: \"Copyright HP 2009\"\r\n";
const GX_VERSION: &str = "2: \"Version HP48-R\"\r\n1: \"Copyright HP 1993\"\r\n";
#[test]
fn prepare_xrecv_on_49g_in_alg_mode() {
let (mut c, log) = calc(|cmd| match cmd {
"VERSION" => G49_VERSION.into(),
VERSION_CHUNKS => {
chunk_reply("Version HP48-C\nRevision #2.15", "Copyright HP 2009", &[])
}
"G D" => "{ HOME } 2000.\r\nSATXX 10.5 String 1234.\r\n".into(),
"-95. FS?" => "1: 1.\r\n".into(),
_ => EMPTY.into(),
});
let plan = c
.prepare_for_xmodem(XmodemDirection::ToCalculator, "SATXX")
.unwrap();
assert_eq!(
sent(&log),
[
"VERSION",
VERSION_CHUNKS,
"6. DROPN STOF",
"G D",
"-95. FS?",
"DROP",
"-95. CF",
"\u{ab} 'SATXX' XRECV \u{bb}",
"G F"
]
);
assert_eq!(plan.model, Model::Hp49G);
assert_eq!(plan.program, "\u{ab} 'SATXX' XRECV \u{bb}");
assert_eq!(plan.keys, ["right-shift", "SYMB"]);
assert!(plan.exists && plan.switched_to_rpn);
let text = plan.instructions();
assert!(
text.starts_with(
"\u{ab} 'SATXX' XRECV \u{bb} is on the calculator's stack. On the calculator, \
press right-shift, then SYMB (EVAL) to run it."
),
"{text}"
);
assert!(text.contains("SATXX.1"), "{text}");
assert!(text.contains("-95 SF"), "{text}");
assert!(text.contains("drops the program"), "{text}");
assert!(
text.ends_with("type SERVER and press ENTER after the transfer."),
"{text}"
);
}
#[test]
fn prepare_xrecv_failed_push_restores_alg_mode() {
let (mut c, log) = calc(|cmd| match cmd {
"VERSION" => G49_VERSION.into(),
VERSION_CHUNKS => {
chunk_reply("Version HP48-C\nRevision #2.15", "Copyright HP 2009", &[])
}
"G D" => "{ HOME } 2000.\r\n".into(),
"-95. FS?" => "1: 1.\r\n".into(),
"\u{ab} 'SATXX' XRECV \u{bb}" => "Error: Insufficient Memory\r\n".into(),
_ => EMPTY.into(),
});
let err = c
.prepare_for_xmodem(XmodemDirection::ToCalculator, "SATXX")
.unwrap_err();
assert!(matches!(err, Error::Calculator { .. }), "{err:?}");
let sent = sent(&log);
assert_eq!(
&sent[sent.len() - 3..],
["-95. CF", "\u{ab} 'SATXX' XRECV \u{bb}", "-95. SF"]
);
}
#[test]
fn prepare_xsend_on_48gx() {
let (mut c, log) = calc(|cmd| match cmd {
"VERSION" => GX_VERSION.into(),
"G D" => "{ HOME } 2000\r\nSATXX 10.5 String 1234\r\n".into(),
_ => EMPTY.into(),
});
let plan = c
.prepare_for_xmodem(XmodemDirection::FromCalculator, "SATXX")
.unwrap();
assert_eq!(
sent(&log),
[
"VERSION",
"DROP2",
"G D",
"\u{ab} 'SATXX' XSEND \u{bb}",
"G F"
]
);
assert_eq!(plan.keys, ["EVAL"]);
assert!(!plan.switched_to_rpn);
assert_eq!(plan.notes.len(), 2);
let text = plan.instructions();
assert!(text.contains("press EVAL to run it."), "{text}");
assert!(text.ends_with("press right-shift, then \u{2192} (or type SERVER and press ENTER) after the transfer."), "{text}");
}
#[test]
fn prepare_refuses_existing_name_on_48gx() {
let (mut c, log) = calc(|cmd| match cmd {
"VERSION" => GX_VERSION.into(),
"G D" => "{ HOME } 2000\r\nSATXX 10.5 String 1234\r\n".into(),
_ => EMPTY.into(),
});
let err = c
.prepare_for_xmodem(XmodemDirection::ToCalculator, "SATXX")
.unwrap_err();
assert!(matches!(&err, Error::Reply(m) if m == "SATXX: already exists"));
assert_eq!(sent(&log), ["VERSION", "DROP2", "G D"]);
}
#[test]
fn prepare_refuses_before_finishing() {
let (mut c, log) = calc(|cmd| match cmd {
"VERSION" => GX_VERSION.into(),
"G D" => "{ HOME } 2000\r\n".into(),
_ => EMPTY.into(),
});
let err = c
.prepare_for_xmodem(XmodemDirection::FromCalculator, "NOSUCH")
.unwrap_err();
assert!(matches!(&err, Error::Reply(m) if m == "NOSUCH: no such variable"));
assert!(!sent(&log).contains(&"G F".to_string()));
assert!(matches!(
c.prepare_for_xmodem(XmodemDirection::ToCalculator, "A B"),
Err(Error::Name(_))
));
let (mut c, log) = calc(|cmd| match cmd {
"VERSION" => "1: 'VERSION'\r\n".into(),
_ => EMPTY.into(),
});
let err = c
.prepare_for_xmodem(XmodemDirection::ToCalculator, "X")
.unwrap_err();
assert!(matches!(err, Error::Unsupported(_)), "{err:?}");
assert_eq!(sent(&log), ["VERSION", "DROP"]);
}
#[test]
fn cd_checks_each_component() {
let (mut c, log) = calc(|cmd| match cmd {
"G D" => "D1 5.5 Directory 4321\r\nX 10.5 Real Number 1234\r\n".into(),
_ => EMPTY.into(),
});
c.cd(&["HOME", "D1"]).unwrap();
assert_eq!(sent(&log), ["HOME", "G D", "D1"]);
log.lock().unwrap().clear();
let err = c.cd(&["NOSUCH"]).unwrap_err();
assert!(matches!(&err, Error::Reply(m) if m.contains("no such directory")));
assert_eq!(sent(&log), ["HOME", "G D"]);
log.lock().unwrap().clear();
let err = c.cd(&["HOME", "X"]).unwrap_err();
assert!(matches!(&err, Error::Reply(m) if m.contains("no such directory")));
assert_eq!(sent(&log), ["HOME", "G D"]);
log.lock().unwrap().clear();
assert!(matches!(c.cd(&["A B"]), Err(Error::Name(_))));
assert!(sent(&log).is_empty());
}
#[test]
fn rename_joined_split_and_directory() {
let (mut c, log) = calc(|cmd| match cmd {
"G D" => format!(
"X 10.5 Real Number 1234\r\nSUB 5.5 Directory 4321\r\n{} 10.5 Real Number 1\r\n",
"L".repeat(40)
),
_ => EMPTY.into(),
});
c.rename("X", "Y").unwrap();
assert_eq!(sent(&log), ["G D", "'X' RCL 'Y' STO 'X' PURGE"]);
log.lock().unwrap().clear();
let long = "L".repeat(40);
let to = "M".repeat(40);
c.rename(&long, &to).unwrap();
assert_eq!(
sent(&log),
[
"G D".to_string(),
format!("'{long}' RCL"),
format!("'{to}' STO"),
format!("'{long}' PURGE"),
]
);
log.lock().unwrap().clear();
c.rename("SUB", "SUB2").unwrap();
assert_eq!(sent(&log), ["G D", "'SUB' RCL 'SUB2' STO 'SUB' PGDIR"]);
log.lock().unwrap().clear();
assert!(matches!(c.rename("NOSUCH", "Z"), Err(Error::Reply(_))));
assert!(matches!(c.rename("X", "SUB"), Err(Error::Reply(_))));
assert_eq!(sent(&log), ["G D", "G D"]);
}
#[test]
fn remove_checks_listing() {
let (mut c, log) = calc(|cmd| match cmd {
"G D" => SX_DIR.into(),
_ => EMPTY.into(),
});
let err = c.remove("NOSUCH").unwrap_err();
assert!(matches!(&err, Error::Reply(m) if m.contains("no such variable")));
assert_eq!(sent(&log), ["G D"]);
c.remove("SUB").unwrap();
c.remove("X").unwrap();
assert_eq!(
sent(&log),
["G D", "G D", "'SUB' PGDIR", "G D", "'X' PURGE"]
);
}
#[test]
fn calculator_error() {
let (mut c, _) = calc(|_| "Error: Undefined Name\r\n1: 'NOSUCH'\r\n".into());
let reply = c.run("'NOSUCH' RCL").unwrap();
assert_eq!(reply.error.as_deref(), Some("Undefined Name"));
let err = c.mkdir("NOSUCH").unwrap_err();
assert!(
matches!(&err, Error::Calculator { message, stack }
if message == "Undefined Name" && stack == &["'NOSUCH'"]),
"{err:?}"
);
}
#[test]
fn transfer_mode_is_cached() {
let (mut c, log) = calc(|_| EMPTY.into());
c.set_transfer_mode(TransferMode::Binary).unwrap();
c.set_transfer_mode(TransferMode::Binary).unwrap();
assert_eq!(sent(&log), ["-35 SF"]);
c.set_transfer_mode(TransferMode::Ascii).unwrap();
assert_eq!(sent(&log), ["-35 SF", "-35 CF"]);
c.run("1").unwrap();
c.set_transfer_mode(TransferMode::Ascii).unwrap();
assert_eq!(sent(&log), ["-35 SF", "-35 CF", "1", "-35 CF"]);
}
#[test]
fn transfer_mode_query() {
let (mut c, log) = calc(|cmd| match cmd {
"-35 FS?" => "1: 1.\r\n".into(),
_ => EMPTY.into(),
});
assert_eq!(c.transfer_mode().unwrap(), TransferMode::Binary);
c.set_transfer_mode(TransferMode::Binary).unwrap();
assert_eq!(sent(&log), ["-35 FS?", "DROP"]);
}
#[test]
fn set_iopar_stores_reals() {
let (mut c, log) = calc(|_| EMPTY.into());
let iopar = Iopar {
translate: 3,
..Iopar::default()
};
c.set_iopar(&iopar).unwrap();
assert_eq!(
sent(&log),
["PATH HOME { 9600. 0. 0. 0. 3. 3. } 'IOPAR' STO EVAL"]
);
log.lock().unwrap().clear();
let wide = Iopar {
baud: 115_200,
parity: -4,
receive_pacing: true,
transmit_pacing: true,
checksum: 3,
translate: 255,
};
c.set_iopar(&wide).unwrap();
assert_eq!(
sent(&log),
["PATH HOME { 115200. -4. 1. 1. 3. 255. } 'IOPAR' STO EVAL"]
);
}
#[test]
fn command_too_long() {
let (mut c, log) = calc(|_| EMPTY.into());
let err = c.run(&"1".repeat(200)).unwrap_err();
assert!(
matches!(err, Error::CommandTooLong { len: 200, .. }),
"{err:?}"
);
assert!(sent(&log).is_empty());
c.run("1").unwrap();
}
#[test]
fn names() {
for ok in [
"A",
"SATXE2E",
"IOPAR",
"x\u{0304}",
"Σ1",
"a.b",
"CONS",
"COM0",
"COM10",
"LPT",
"XNUL",
&"N".repeat(127),
] {
assert!(validate_name(ok).is_ok(), "{ok:?}");
}
for bad in [
"",
"1A",
".A",
"A B",
"A\tB",
"A'",
"A\"",
"«A",
"{A}",
"A[1]",
"F(X)",
"#A",
":0:A",
"A,B",
"A;B",
"A+B",
"A-B",
"A*B",
"A/B",
"A^B",
"A=B",
"A<B",
"A>B",
"A\u{1}",
"A\u{263A}",
"A\\B",
"CON",
"nul",
"Aux",
"PRN",
"COM1",
"lpt9",
"NUL.X",
"con.txt",
&"N".repeat(128),
] {
assert!(matches!(validate_name(bad), Err(Error::Name(_))), "{bad:?}");
}
}
}