#![allow(clippy::unwrap_used, clippy::expect_used)]
#[path = "e2e/lx.rs"]
mod lx;
use std::process::Command;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
use std::time::{Duration, Instant};
use satx_core::object::{self, Family, HEADER_LEN, ObjectType};
use satx_core::reply::{Iopar, looks_cut, parse_real};
use satx_core::xmodem::XmodemDirection;
use satx_core::xmodem_proto::{Check, Event};
use satx_core::{
Calculator, Error, Model, Options, Session, TransferMode, XmodemOptions, XmodemSession,
};
type TestResult = Result<(), Box<dyn std::error::Error>>;
static LOCK: Mutex<()> = Mutex::new(());
const LEFTOVERS: &[&str] = &[
"SATXE2E", "SATXE2F", "SATXRT", "SATXTMP", "SATXBK", "SATXXM",
];
fn scenario(body: impl FnOnce(&mut Calculator) -> TestResult) -> TestResult {
let Some(addr) = std::env::var("SATX_E2E_ADDR")
.ok()
.filter(|a| !a.is_empty())
else {
return Ok(());
};
let _guard = LOCK.lock().unwrap_or_else(|e| e.into_inner());
let mut calc = Calculator::open(&addr)?;
let result = body(&mut calc);
let cleanup = cleanup(&mut calc);
result?;
cleanup
}
fn cleanup(calc: &mut Calculator) -> TestResult {
calc.cd(&["HOME"])?;
let listing = calc.list()?;
for name in LEFTOVERS {
if listing.entries.iter().any(|e| e.name == *name) {
eprintln!("cleanup: removing {name}");
calc.remove(name)?;
}
}
calc.set_transfer_mode(TransferMode::Ascii)?;
Ok(())
}
fn names(calc: &mut Calculator) -> Result<Vec<String>, Error> {
Ok(calc.list()?.entries.into_iter().map(|e| e.name).collect())
}
#[test]
fn ls() -> TestResult {
scenario(|calc| {
calc.mkdir("SATXE2E")?;
calc.cd(&["HOME", "SATXE2E"])?;
assert_eq!(calc.path()?, ["HOME", "SATXE2E"]);
assert!(calc.list()?.entries.is_empty());
let stored = calc.put(
"SATXV",
b"%%HP: T(3)A(D)F(.);\r\n42\r\n",
TransferMode::Ascii,
)?;
assert_eq!(stored, "SATXV");
assert_eq!(names(calc)?, ["SATXV"]);
calc.cd(&["HOME"])?;
calc.rename("SATXE2E", "SATXE2F")?;
let listing = calc.list()?;
assert!(
listing
.entries
.iter()
.any(|e| e.name == "SATXE2F" && e.is_directory()),
"{listing:?}"
);
assert!(!listing.entries.iter().any(|e| e.name == "SATXE2E"));
calc.remove("SATXE2F")?;
assert!(!names(calc)?.iter().any(|n| n == "SATXE2F"));
Ok(())
})
}
#[test]
fn get() -> TestResult {
scenario(|calc| {
let ascii = calc.get("IOPAR", TransferMode::Ascii)?;
assert!(
ascii.starts_with(b"%%HP:"),
"{:?}",
String::from_utf8_lossy(&ascii)
);
let binary = calc.get("IOPAR", TransferMode::Binary)?;
let info = object::inspect(&binary)?;
assert_eq!(info.object_type, Some(ObjectType::List));
assert!(matches!(info.header.family, Family::Hp48 | Family::Hp49));
assert_eq!(calc.iopar()?, Iopar::default());
Ok(())
})
}
fn all_bytes_string(header: &[u8]) -> Vec<u8> {
fn field(nibbles: &mut Vec<u8>, value: u32, width: usize) {
for i in 0..width {
nibbles.push(((value >> (4 * i)) & 0xF) as u8);
}
}
let mut nibbles = Vec::new();
field(&mut nibbles, 0x02A2C, 5);
field(&mut nibbles, 5 + 2 * 256, 5);
for b in 0..=255u8 {
nibbles.extend([b & 0xF, b >> 4]);
}
let mut file = header.to_vec();
file.extend(object::pack(&nibbles));
file
}
#[test]
fn put_round_trip() -> TestResult {
scenario(|calc| {
let iopar = calc.get("IOPAR", TransferMode::Binary)?;
let file = all_bytes_string(&iopar[..HEADER_LEN]);
assert_eq!(
object::inspect(&file)?.object_type,
Some(ObjectType::String)
);
assert_eq!(calc.put("SATXRT", &file, TransferMode::Binary)?, "SATXRT");
let back = calc.get("SATXRT", TransferMode::Binary)?;
calc.remove("SATXRT")?;
assert_eq!(back, file);
Ok(())
})
}
#[test]
fn run() -> TestResult {
scenario(|calc| {
let reply = calc.run("6 7 *")?;
calc.run("DROP")?;
assert_eq!(reply.error, None);
assert_eq!(reply.level(1).and_then(parse_real), Some(42.0));
let reply = calc.run("'SATXNOSUCH' RCL")?;
calc.run("DROP")?;
assert_eq!(reply.error.as_deref(), Some("Undefined Name"));
assert!(calc.mem()? > 0.0);
if let Some(version) = calc.version()? {
assert!(!version.is_empty());
eprintln!("version: {version}");
}
let err = calc.run(&"1".repeat(80)).unwrap_err();
assert!(matches!(err, Error::CommandTooLong { .. }), "{err:?}");
let reply = calc.run("1 2 +")?;
calc.run("DROP")?;
assert_eq!(reply.level(1).and_then(parse_real), Some(3.0));
Ok(())
})
}
#[test]
fn queries_wider_than_the_display() -> TestResult {
scenario(|calc| {
let saved = calc.run("RCLF 4 FIX -51 SF")?;
assert_eq!(saved.error, None);
let flags = saved.level(1).unwrap_or_default().to_string();
let depth = saved.levels.len();
let queries =
|calc: &mut Calculator, mode: &str| -> Result<f64, Box<dyn std::error::Error>> {
let model = calc.model()?;
let wide = calc.run("IOPAR")?;
calc.run("DROP")?;
if model == Model::Hp49G {
let list = wide.level(1).unwrap_or_default();
assert!(looks_cut(list), "IOPAR in {mode} is not cut: {list:?}");
}
assert_eq!(calc.iopar()?, Iopar::default(), "IOPAR in {mode}");
if let Some(version) = calc.version()? {
eprintln!("version in {mode}: {version}");
if model == Model::Hp49G {
assert!(version.contains("Revision #"), "{version}");
}
}
assert_eq!(Model::from_version(calc.version()?.as_deref()), model);
let free = calc.mem()?;
assert!(free > 0.0);
calc.transfer_mode()?;
let shown = calc.run("IOPAR")?;
calc.run("DROP")?;
assert_eq!(shown.level(1), wide.level(1), "{mode} changed");
let after = calc.run("DEPTH")?;
calc.run("DROP")?;
assert_eq!(after.levels.len(), depth + 1, "{after:?}");
assert_eq!(after.level(2), Some(flags.as_str()), "{after:?}");
Ok(free)
};
let mut both = || -> TestResult {
let fix = queries(calc, "FIX 4")?;
calc.run("0 SCI")?;
let sci = queries(calc, "0 SCI")?;
assert!(
(fix - sci).abs() < 100.0,
"MEM {fix} in FIX 4, {sci} in 0 SCI"
);
Ok(())
};
let result = both();
let restored = calc.run("STOF")?;
result?;
assert_eq!(restored.error, None);
Ok(())
})
}
#[test]
fn pict() -> TestResult {
scenario(|calc| {
let reply = calc.run("ERASE { # 10d # 10d } PIXON")?;
assert_eq!(reply.error, None);
let grob = calc.pict()?;
assert_eq!((grob.width, grob.height), (131, 64));
assert!(grob.pixel(10, 10));
let lit = (0..64)
.flat_map(|y| (0..131).map(move |x| (x, y)))
.filter(|&(x, y)| grob.pixel(x, y))
.count();
assert_eq!(lit, 1);
assert!(!names(calc)?.iter().any(|n| n == "SATXTMP"));
calc.run("PICT PURGE")?;
Ok(())
})
}
#[test]
fn backup() -> TestResult {
scenario(|calc| {
let data = calc.backup()?;
let info = object::inspect(&data)?;
assert_eq!(info.object_type, Some(ObjectType::Directory));
assert!(info.size_nibbles.is_some_and(|n| n > 0));
assert!(!names(calc)?.iter().any(|n| n == "SATXBK"));
Ok(())
})
}
const XMODEM_VAR: &str = "SATXXM";
fn press(container: &str, keys: &[&str]) -> TestResult {
let status = Command::new("docker")
.args(["exec", container, "calc-keys"])
.args(keys)
.status()?;
if !status.success() {
return Err(format!("calc-keys {keys:?}: {status}").into());
}
Ok(())
}
fn type_word(container: &str, word: &str) -> TestResult {
let letters: Vec<String> = word.chars().map(|c| c.to_string()).collect();
let mut keys = vec!["\\", ";", ";"];
keys.extend(letters.iter().map(String::as_str));
keys.push("Enter");
press(container, &keys)
}
const RETYPE_AFTER: Duration = Duration::from_secs(15);
const TYPE_TRIES: u32 = 3;
fn type_later(
container: &str,
word: &str,
delay: Duration,
started: Arc<AtomicBool>,
) -> JoinHandle<Result<(), String>> {
let (container, word) = (container.to_string(), word.to_string());
thread::spawn(move || {
thread::sleep(delay);
for attempt in 1..=TYPE_TRIES {
if attempt > 1 {
eprintln!("xmodem: no start after {RETYPE_AFTER:?}; typing {word} again");
}
type_word(&container, &word).map_err(|e| e.to_string())?;
let typed = Instant::now();
while typed.elapsed() < RETYPE_AFTER {
if started.load(Ordering::SeqCst) {
return Ok(());
}
thread::sleep(Duration::from_millis(200));
}
}
Ok(())
})
}
fn progress(started: &Arc<AtomicBool>) -> impl FnMut(&Event) + '_ {
move |event| {
if matches!(event, Event::Started { .. }) {
started.store(true, Ordering::SeqCst);
}
print_progress(event);
}
}
fn restart_server(
container: &str,
xs: XmodemSession,
) -> Result<Calculator, Box<dyn std::error::Error>> {
thread::sleep(Duration::from_secs(2));
press(container, &["\\"])?;
thread::sleep(Duration::from_secs(1));
type_word(container, "server")?;
thread::sleep(Duration::from_secs(2));
Ok(Calculator::new(Session::new(
xs.into_transport(),
Options::default(),
)?))
}
fn print_progress(event: &Event) {
match event {
Event::Started { check } => eprintln!("xmodem: started, check {check:?}"),
Event::Done => eprintln!("xmodem: done"),
Event::Error(e) => eprintln!("xmodem: error {e}"),
_ => {}
}
}
#[test]
fn xmodem_round_trip() -> TestResult {
let Some(addr) = std::env::var("SATX_E2E_ADDR")
.ok()
.filter(|a| !a.is_empty())
else {
return Ok(());
};
let Some(container) = std::env::var("SATX_E2E_CONTAINER")
.ok()
.filter(|c| !c.is_empty())
else {
eprintln!("xmodem: SATX_E2E_CONTAINER not set, skipped");
return Ok(());
};
let _guard = LOCK.lock().unwrap_or_else(|e| e.into_inner());
let mut calc = Calculator::open(&addr)?;
let model = calc.model()?;
if !matches!(model, Model::Hp49G | Model::Hp48Gx) {
eprintln!("xmodem: {} has no XModem, skipped", model.name());
return Ok(());
}
cleanup(&mut calc)?;
let iopar = calc.get("IOPAR", TransferMode::Binary)?;
let file = all_bytes_string(&iopar[..HEADER_LEN]);
let options = XmodemOptions::for_model(model)?;
let want_check = match model {
Model::Hp49G => Check::HpCrc,
_ => Check::Checksum,
};
let plan = calc.prepare_for_xmodem(XmodemDirection::ToCalculator, XMODEM_VAR)?;
eprintln!("xmodem: {}", plan.instructions());
let switched_to_rpn = plan.switched_to_rpn;
let mut xs = XmodemSession::new(calc.into_transport(), options.clone());
let started = Arc::new(AtomicBool::new(false));
let typer = type_later(&container, "eval", Duration::from_secs(2), started.clone());
let start = Instant::now();
let sent = xs.send_with(&file, &mut progress(&started));
eprintln!("xmodem: XRECV took {:?}", start.elapsed());
let typed = typer.join().map_err(|_| "typing thread panicked")?;
let mut calc = restart_server(&container, xs)?;
let result = (|| -> TestResult {
typed?;
let report = sent?;
assert_eq!(report.check, want_check);
assert_eq!(report.bytes, file.len() as u64);
let back = calc.get(XMODEM_VAR, TransferMode::Binary)?;
assert_eq!(back, file, "XRECV stored something else");
Ok(())
})();
if let Err(e) = result {
let _ = cleanup(&mut calc);
return Err(e);
}
let plan = calc.prepare_for_xmodem(XmodemDirection::FromCalculator, XMODEM_VAR)?;
eprintln!("xmodem: {}", plan.instructions());
let mut xs = XmodemSession::new(calc.into_transport(), options);
let started = Arc::new(AtomicBool::new(false));
let typer = type_later(&container, "eval", Duration::from_secs(2), started.clone());
let start = Instant::now();
let received = xs.receive_with(&mut progress(&started));
eprintln!("xmodem: XSEND took {:?}", start.elapsed());
let typed = typer.join().map_err(|_| "typing thread panicked")?;
let mut calc = restart_server(&container, xs)?;
let result = (|| -> TestResult {
typed?;
let got = received?;
eprintln!(
"xmodem: received {} bytes, last block {}, cut {:?}",
got.received, got.last_block, got.stripped
);
assert_eq!(got.check, want_check);
assert_eq!(got.stripped, Some(got.received - file.len()));
assert_eq!(got.data, file, "XSEND sent something else");
Ok(())
})();
if switched_to_rpn {
calc.run("-95 SF")?;
}
let cleaned = cleanup(&mut calc);
result?;
cleaned
}