use std::collections::VecDeque;
use saturnus_core::io::Key;
use saturnus_core::{LCD_WIDTH, Machine, Model};
use crate::layout;
use crate::skins::{self, Typing};
use crate::{AnnunciatorFlags, Emulator, Error};
pub const MIN_HOLD_MS: f64 = 60.0;
pub const GAP_MS: f64 = 30.0;
pub fn busy_gap_ms(model: Model) -> f64 {
match model {
Model::Hp48sx => 850.0,
Model::Hp48gx => 600.0,
Model::Hp49g => 550.0,
Model::Hp38g => 1100.0,
Model::Hp39g
| Model::Hp40g
| Model::Hp42s
| Model::Hp27s
| Model::Hp17bii
| Model::Hp17b => 300.0,
Model::Hp28s | Model::Hp19bii => 300.0,
}
}
pub fn repeat_gap_ms(model: Model) -> f64 {
match model {
Model::Hp39g | Model::Hp40g => 150.0,
_ => GAP_MS,
}
}
pub const LETTER_SETTLE_MS: f64 = 400.0;
pub const SLICE_MS: f64 = 10.0;
pub trait Keyboard {
fn now_ms(&self) -> f64;
fn idle(&self) -> bool;
fn alpha_on(&self) -> bool;
fn shift_on(&self, shift: &str) -> bool;
fn down(&mut self, name: &str) -> crate::Result<()>;
fn up(&mut self, name: &str);
}
impl Keyboard for Machine {
fn now_ms(&self) -> f64 {
self.cycles() as f64 * 1000.0 / f64::from(self.model().clock_hz())
}
fn idle(&self) -> bool {
self.is_shutdown()
}
fn alpha_on(&self) -> bool {
self.framebuffer().annunciators.alpha
}
fn shift_on(&self, shift: &str) -> bool {
let a = self.framebuffer().annunciators;
match shift {
"leftshift" => a.left_shift,
"rightshift" => a.right_shift,
_ => a.left_shift || a.right_shift,
}
}
fn down(&mut self, name: &str) -> crate::Result<()> {
let k = Key::from_name(name).ok_or_else(|| format!("unknown key {name:?}"))?;
Ok(self.key_down(k)?)
}
fn up(&mut self, name: &str) {
if let Some(k) = Key::from_name(name) {
let _ = self.key_up(k);
}
}
}
#[derive(Clone, Debug)]
struct Press {
name: &'static str,
up: bool,
down_at: f64,
typed: bool,
}
#[derive(Clone, Debug)]
enum Item {
Press(Press),
Letter {
letter: char,
lower: bool,
},
Shifted {
shift: &'static str,
press: Press,
},
}
const SHIFT_KEYS: [&str; 3] = ["leftshift", "rightshift", "shift"];
#[derive(Clone, Debug)]
pub struct KeyQueue {
names: Vec<&'static str>,
typing: Option<Typing>,
letters: Vec<(char, &'static str)>,
active: Vec<Press>,
pending: VecDeque<Item>,
last_release_ms: f64,
last_released: Option<&'static str>,
repeat_gap_ms: f64,
started: u64,
busy_gap_ms: f64,
settle_ms: f64,
alpha_spent: bool,
errors: Vec<Error>,
}
impl KeyQueue {
pub fn new(model: Model) -> Self {
Self {
names: layout::layout(model).iter().map(|k| k.name).collect(),
typing: skins::typing(model),
letters: skins::letters(model),
active: Vec::new(),
pending: VecDeque::new(),
last_release_ms: f64::NEG_INFINITY,
last_released: None,
repeat_gap_ms: repeat_gap_ms(model),
started: 0,
busy_gap_ms: busy_gap_ms(model),
settle_ms: busy_gap_ms(model).max(LETTER_SETTLE_MS),
alpha_spent: false,
errors: Vec::new(),
}
}
fn name(&self, name: &str) -> Option<&'static str> {
self.names.iter().copied().find(|&n| n == name)
}
pub fn has_key(&self, name: &str) -> bool {
self.name(name).is_some()
}
pub fn busy(&self) -> bool {
!self.active.is_empty() || !self.pending.is_empty()
}
pub fn held(&self) -> bool {
self.active.iter().any(|p| !p.up)
}
pub fn press(&mut self, name: &str) -> bool {
let Some(name) = self.name(name) else {
return false;
};
self.pending.push_back(Item::Press(Press {
name,
up: false,
down_at: 0.0,
typed: false,
}));
true
}
pub fn press_shifted(&mut self, name: &str, shift: &str) -> bool {
let (Some(name), Some(shift)) = (self.name(name), self.name(shift)) else {
return false;
};
if !SHIFT_KEYS.contains(&shift) {
return false;
}
self.pending.push_back(Item::Shifted {
shift,
press: Press {
name,
up: false,
down_at: 0.0,
typed: false,
},
});
true
}
pub fn type_letter(&mut self, ch: char) -> bool {
let upper = ch.to_ascii_uppercase();
if self.typing.is_none() || !self.letters.iter().any(|&(c, _)| c == upper) {
return false;
}
self.pending.push_back(Item::Letter {
letter: upper,
lower: ch != upper,
});
true
}
pub fn type_keys(&mut self, names: &[&str]) {
for n in names {
if let Some(name) = self.name(n) {
self.pending.push_back(Item::Press(Press {
name,
up: true,
down_at: 0.0,
typed: true,
}));
}
}
}
pub fn release(&mut self, name: &str) {
let queued = self.pending.iter_mut().rev().filter_map(|i| match i {
Item::Press(p) | Item::Shifted { press: p, .. } => Some(p),
Item::Letter { .. } => None,
});
if let Some(p) = queued
.chain(self.active.iter_mut().rev())
.find(|p| p.name == name && !p.up)
{
p.up = true;
}
}
pub fn release_held(&mut self) {
for p in &mut self.active {
p.up = true;
}
for i in &mut self.pending {
if let Item::Press(p) | Item::Shifted { press: p, .. } = i {
p.up = true;
}
}
}
pub fn clear(&mut self) {
self.active.clear();
self.pending.clear();
self.last_release_ms = f64::NEG_INFINITY;
self.last_released = None;
self.alpha_spent = false;
}
pub fn down(&self) -> Vec<&'static str> {
let mut v: Vec<&'static str> = self.active.iter().map(|p| p.name).collect();
v.dedup();
v
}
pub fn presses_started(&self) -> u64 {
self.started
}
pub fn take_errors(&mut self) -> Vec<Error> {
std::mem::take(&mut self.errors)
}
fn expand_letter(&mut self, kb: &impl Keyboard, letter: char, lower: bool) -> Vec<Item> {
let Some(t) = self.typing else {
return Vec::new();
};
let Some(&(_, key)) = self.letters.iter().find(|&&(c, _)| c == letter) else {
return Vec::new();
};
let mut seq = Vec::new();
if t.direct {
if lower {
seq.extend([t.lower_shift, key, t.lower_shift]);
} else {
seq.push(key);
}
return self.presses(seq);
}
let alpha_on = !self.alpha_spent && kb.alpha_on();
if t.shift_first && lower {
seq.push(t.lower_shift);
}
if !alpha_on {
seq.push(t.alpha);
}
if !t.shift_first && lower {
seq.push(t.lower_shift);
}
seq.push(key);
self.alpha_spent = !alpha_on;
self.presses(seq)
}
fn presses(&self, seq: Vec<&str>) -> Vec<Item> {
seq.into_iter()
.filter_map(|n| self.name(n))
.map(|name| {
Item::Press(Press {
name,
up: true,
down_at: 0.0,
typed: true,
})
})
.collect()
}
pub fn pump(&mut self, kb: &mut impl Keyboard) {
let now = kb.now_ms();
let mut released = false;
let mut last = self.last_released;
self.active.retain(|p| {
if p.up && now - p.down_at >= MIN_HOLD_MS {
kb.up(p.name);
last = Some(p.name);
released = true;
false
} else {
true
}
});
if released {
self.last_release_ms = now;
self.last_released = last;
}
let idle = kb.idle();
while let Some(head) = self.pending.front() {
if self.active.iter().any(|p| p.up) {
break;
}
let since = now - self.last_release_ms;
if since < GAP_MS || (!idle && since < self.busy_gap_ms) {
break;
}
if let &Item::Letter { letter, lower } = head {
if !self.active.is_empty() {
break;
}
if !self.alpha_spent && !idle && since < self.settle_ms {
break;
}
self.pending.pop_front();
for item in self.expand_letter(kb, letter, lower).into_iter().rev() {
self.pending.push_front(item);
}
continue;
}
if let &Item::Shifted { shift, .. } = head {
if !self.active.is_empty() || (!idle && since < self.settle_ms) {
break;
}
let Some(Item::Shifted { press, .. }) = self.pending.pop_front() else {
continue;
};
self.pending.push_front(Item::Press(press));
if !kb.shift_on(shift) {
self.pending.push_front(Item::Press(Press {
name: shift,
up: true,
down_at: 0.0,
typed: true,
}));
}
continue;
}
if let Item::Press(p) = head
&& Some(p.name) == self.last_released
&& since < self.repeat_gap_ms
{
break;
}
let Some(Item::Press(mut p)) = self.pending.pop_front() else {
continue;
};
if self.typing.is_some_and(|t| p.name == t.alpha) && !p.typed {
self.alpha_spent = false;
}
if let Some(o) = self.active.iter_mut().find(|o| o.name == p.name) {
if p.up {
o.up = true;
}
continue;
}
if let Err(e) = kb.down(p.name) {
self.errors.push(e);
continue;
}
p.down_at = now;
self.started += 1;
self.active.push(p);
}
}
}
pub fn packed_row_bytes(width: usize) -> usize {
width.div_ceil(8)
}
pub fn pack_bits(rows: &[Vec<bool>]) -> Vec<u8> {
let w = rows.first().map_or(LCD_WIDTH, Vec::len);
let mut out = vec![0u8; packed_row_bytes(w) * rows.len()];
for (y, row) in rows.iter().enumerate() {
for (x, &on) in row.iter().enumerate() {
if on {
out[y * packed_row_bytes(w) + x / 8] |= 0x80 >> (x % 8);
}
}
}
out
}
pub fn base64(bytes: &[u8]) -> String {
const ALPHABET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
let mut out = String::with_capacity(bytes.len().div_ceil(3) * 4);
for chunk in bytes.chunks(3) {
let b = [
chunk[0],
chunk.get(1).copied().unwrap_or(0),
chunk.get(2).copied().unwrap_or(0),
];
let n = (u32::from(b[0]) << 16) | (u32::from(b[1]) << 8) | u32::from(b[2]);
for i in 0..4 {
if i <= chunk.len() {
out.push(char::from(ALPHABET[(n >> (18 - 6 * i)) as usize & 63]));
} else {
out.push('=');
}
}
}
out
}
pub fn base64_decode(s: &str) -> crate::Result<Vec<u8>> {
fn value(c: u8) -> Option<u32> {
Some(u32::from(match c {
b'A'..=b'Z' => c - b'A',
b'a'..=b'z' => c - b'a' + 26,
b'0'..=b'9' => c - b'0' + 52,
b'+' => 62,
b'/' => 63,
_ => return None,
}))
}
let s = s.trim_end_matches('=').as_bytes();
if s.len() % 4 == 1 {
return Err("bad base64 length".into());
}
let mut out = Vec::with_capacity(s.len() * 3 / 4);
for chunk in s.chunks(4) {
let mut n = 0u32;
for (i, &c) in chunk.iter().enumerate() {
n |= value(c).ok_or("bad base64 character")? << (18 - 6 * i);
}
let bytes = n.to_be_bytes();
out.extend_from_slice(&bytes[1..chunk.len()]);
}
Ok(out)
}
pub(crate) fn as_base64<S: serde::Serializer>(bytes: &[u8], s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(&base64(bytes))
}
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(tag = "type", rename = "frame", rename_all = "camelCase")]
pub struct Frame {
pub width: usize,
pub height: usize,
#[serde(serialize_with = "as_base64")]
pub pixels: Vec<u8>,
pub annunciators: AnnunciatorFlags,
pub contrast: u8,
pub contrast_range: [u8; 2],
pub contrast_default: u8,
}
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(tag = "type", rename = "keys")]
pub struct KeysDown {
pub down: Vec<&'static str>,
}
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(tag = "type", rename = "menu")]
pub struct MenuKeys {
pub keys: Option<Vec<Option<saturnus_objects::softkeys::ShownKey>>>,
}
pub fn model_for_rom(rom: &[u8], preferred: Model) -> Model {
let fits = crate::romid::fitting_models(rom);
if fits.contains(&preferred) {
return preferred;
}
fits.first().copied().unwrap_or(preferred)
}
impl Emulator {
pub fn run_slice(&mut self, left_ms: f64, keys: bool) -> crate::Result<f64> {
if !left_ms.is_finite() || left_ms <= 0.0 {
return Ok(0.0);
}
let timed = keys && self.queue.busy();
let idle = if timed { None } else { self.idle_ms() };
let step = left_ms.min(idle.filter(|&i| i > SLICE_MS).unwrap_or(SLICE_MS));
self.run_ms(step)?;
if keys {
self.queue.pump(&mut self.machine);
}
Ok(step)
}
pub fn pump(&mut self) {
self.queue.pump(&mut self.machine);
}
pub fn queue(&mut self) -> &mut KeyQueue {
&mut self.queue
}
pub fn release_keys(&mut self) {
self.machine.release_all_keys();
self.queue.clear();
}
pub fn frame_if_changed(&mut self) -> Option<Frame> {
let fb = self.machine.framebuffer();
let model = self.machine.model();
let range = model.contrast_range();
let frame = Frame {
width: fb.pixels.width(),
height: fb.pixels.pixels.len(),
pixels: pack_bits(&fb.pixels.pixels),
annunciators: AnnunciatorFlags(fb.annunciators),
contrast: fb.contrast,
contrast_range: [*range.start(), *range.end()],
contrast_default: model.default_contrast(),
};
if self.shown.as_ref() == Some(&frame) {
return None;
}
self.shown = Some(frame.clone());
Some(frame)
}
pub fn reshow(&mut self) {
self.shown = None;
self.shown_keys = None;
self.menu_seen = None;
self.shown_menu = None;
self.menu_dirty = true;
self.menu_force = true;
}
pub fn keys_if_changed(&mut self) -> Option<KeysDown> {
let down = self.queue.down();
if self.shown_keys.as_deref() == Some(down.as_slice()) {
return None;
}
self.shown_keys = Some(down.clone());
Some(KeysDown { down })
}
}
impl Emulator {
pub fn press(&mut self, name: &str) -> bool {
self.queue.press(name)
}
pub fn press_shifted(&mut self, name: &str, shift: &str) -> bool {
self.queue.press_shifted(name, shift)
}
pub fn has_key(&self, name: &str) -> bool {
self.queue.has_key(name)
}
pub fn release(&mut self, name: &str) {
self.queue.release(name);
}
pub fn release_held(&mut self) {
self.queue.release_held();
}
pub fn type_letter(&mut self, ch: &str) -> bool {
ch.chars().next().is_some_and(|c| self.queue.type_letter(c))
}
pub fn type_keys(&mut self, names: &str) {
let names: Vec<&str> = names.split_whitespace().collect();
self.queue.type_keys(&names);
}
pub fn keys_busy(&self) -> bool {
self.queue.busy()
}
pub fn keys_held(&self) -> bool {
self.queue.held()
}
pub fn take_errors(&mut self) -> Vec<Error> {
self.queue.take_errors()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[derive(Default)]
struct Fake {
now: f64,
idle: bool,
busy_after_up: f64,
last_up: f64,
pressed_busy: Vec<String>,
down_at: Vec<f64>,
alpha: bool,
left: bool,
right: bool,
log: Vec<String>,
}
impl Keyboard for Fake {
fn now_ms(&self) -> f64 {
self.now
}
fn idle(&self) -> bool {
self.idle && self.now >= self.last_up + self.busy_after_up
}
fn alpha_on(&self) -> bool {
self.alpha
}
fn shift_on(&self, shift: &str) -> bool {
match shift {
"rightshift" => self.right,
"leftshift" => self.left,
_ => self.left || self.right,
}
}
fn down(&mut self, name: &str) -> crate::Result<()> {
self.log.push(format!("+{name}"));
self.down_at.push(self.now);
if !self.idle() {
self.pressed_busy.push(name.to_string());
}
match name {
"leftshift" | "shift" => (self.left, self.right) = (!self.left, false),
"rightshift" => (self.left, self.right) = (false, !self.right),
_ => (self.left, self.right) = (false, false),
}
Ok(())
}
fn up(&mut self, name: &str) {
self.log.push(format!("-{name}"));
self.last_up = self.now;
}
}
fn run(q: &mut KeyQueue, kb: &mut Fake, ms: f64) {
let end = kb.now + ms;
while kb.now < end {
kb.now += 10.0;
q.pump(kb);
}
}
#[test]
fn a_press_is_held_at_least_min_hold() {
let mut q = KeyQueue::new(Model::Hp48sx);
let mut kb = Fake {
idle: true,
..Fake::default()
};
assert!(q.press("enter"));
assert!(!q.press("apps"), "a 49G key on a 48SX");
q.pump(&mut kb);
assert_eq!(kb.log, ["+enter"]);
assert_eq!(q.down(), ["enter"]);
q.release("enter");
kb.now = 50.0;
q.pump(&mut kb);
assert_eq!(kb.log, ["+enter"], "released before 60 ms");
kb.now = 60.0;
q.pump(&mut kb);
assert_eq!(kb.log, ["+enter", "-enter"]);
assert!(!q.busy());
}
#[test]
fn queued_presses_wait_for_the_gap_and_a_busy_rom() {
let mut q = KeyQueue::new(Model::Hp48sx);
let mut kb = Fake::default();
q.type_keys(&["1", "2"]);
q.pump(&mut kb);
assert_eq!(kb.log, ["+1"]);
run(&mut q, &mut kb, 50.0 + busy_gap_ms(Model::Hp48sx));
assert_eq!(kb.log, ["+1", "-1"]);
run(&mut q, &mut kb, 20.0);
assert_eq!(kb.log, ["+1", "-1", "+2"]);
let mut q = KeyQueue::new(Model::Hp48sx);
let mut kb = Fake {
idle: true,
..Fake::default()
};
q.type_keys(&["1", "2"]);
run(&mut q, &mut kb, 100.0);
assert_eq!(kb.log, ["+1", "-1", "+2"]);
}
#[test]
fn a_busy_rom_takes_keys_at_its_models_rate() {
for (model, every) in [
(Model::Hp39g, 360.0),
(Model::Hp42s, 360.0),
(Model::Hp48sx, 910.0),
] {
let mut q = KeyQueue::new(model);
let mut kb = Fake::default();
q.type_keys(&["1", "2", "3", "4"]);
run(&mut q, &mut kb, 5000.0);
assert_eq!(downs(&kb), ["1", "2", "3", "4"], "{model:?}");
let gaps: Vec<f64> = kb.down_at.windows(2).map(|w| w[1] - w[0]).collect();
assert_eq!(gaps, [every; 3], "{model:?}");
}
}
fn downs(kb: &Fake) -> Vec<&str> {
kb.log.iter().filter_map(|s| s.strip_prefix('+')).collect()
}
#[test]
fn two_quick_shifted_presses_each_get_their_shift() {
let mut q = KeyQueue::new(Model::Hp48sx);
let mut kb = Fake {
idle: true,
..Fake::default()
};
assert!(q.press_shifted("sqrt", "leftshift"));
q.pump(&mut kb);
q.release("sqrt");
assert!(q.press_shifted("sqrt", "leftshift"));
q.release("sqrt");
run(&mut q, &mut kb, 1000.0);
assert_eq!(downs(&kb), ["leftshift", "sqrt", "leftshift", "sqrt"]);
assert!(!q.busy());
}
#[test]
fn quick_shifted_presses_wait_out_the_roms_long_key_wait() {
let mut q = KeyQueue::new(Model::Hp48sx);
let mut kb = Fake {
idle: true,
busy_after_up: 520.0,
last_up: f64::NEG_INFINITY,
..Fake::default()
};
assert!(q.press_shifted("sqrt", "leftshift"));
q.release("sqrt");
assert!(q.press_shifted("sqrt", "leftshift"));
q.release("sqrt");
run(&mut q, &mut kb, 5000.0);
assert_eq!(downs(&kb), ["leftshift", "sqrt", "leftshift", "sqrt"]);
assert_eq!(
kb.pressed_busy,
Vec::<String>::new(),
"no key pressed while the ROM was awake"
);
assert!(!q.busy());
}
#[test]
fn a_shifted_press_after_a_queued_shift_does_not_tap_it_again() {
let mut q = KeyQueue::new(Model::Hp48sx);
let mut kb = Fake {
idle: true,
..Fake::default()
};
assert!(q.press("leftshift"));
q.release("leftshift");
assert!(q.press_shifted("sqrt", "leftshift"));
q.release("sqrt");
run(&mut q, &mut kb, 1000.0);
assert_eq!(downs(&kb), ["leftshift", "sqrt"]);
let mut q = KeyQueue::new(Model::Hp48sx);
let mut kb = Fake {
idle: true,
right: true,
..Fake::default()
};
assert!(q.press_shifted("sqrt", "leftshift"));
q.release("sqrt");
run(&mut q, &mut kb, 1000.0);
assert_eq!(downs(&kb), ["leftshift", "sqrt"]);
}
#[test]
fn a_shifted_press_is_held_until_released_and_checks_its_names() {
let mut q = KeyQueue::new(Model::Hp39g);
let mut kb = Fake {
idle: true,
..Fake::default()
};
assert!(
!q.press_shifted("enter", "leftshift"),
"no left shift on a 39G"
);
assert!(!q.press_shifted("enter", "alpha"), "not a shift key");
assert!(!q.press_shifted("bogus", "shift"));
assert!(q.press_shifted("enter", "shift"));
run(&mut q, &mut kb, 500.0);
assert_eq!(downs(&kb), ["shift", "enter"]);
assert_eq!(q.down(), ["enter"], "held while the button is");
q.release("enter");
run(&mut q, &mut kb, 100.0);
assert!(!q.busy());
let mut q = KeyQueue::new(Model::Hp39g);
let mut kb = Fake {
idle: true,
right: true,
..Fake::default()
};
assert!(q.press_shifted("enter", "shift"));
q.release("enter");
run(&mut q, &mut kb, 500.0);
assert_eq!(downs(&kb), ["enter"]);
}
#[test]
fn letters_press_alpha_then_skip_it_while_spent() {
let mut q = KeyQueue::new(Model::Hp48sx);
let mut kb = Fake {
idle: true,
..Fake::default()
};
assert!(q.type_letter('A'));
assert!(q.type_letter('b'));
assert!(!q.type_letter('!'));
run(&mut q, &mut kb, 2000.0);
let downs: Vec<&str> = kb.log.iter().filter_map(|s| s.strip_prefix('+')).collect();
let a = skins::letters(Model::Hp48sx)
.into_iter()
.find(|&(c, _)| c == 'A')
.map(|(_, k)| k)
.unwrap();
let b = skins::letters(Model::Hp48sx)
.into_iter()
.find(|&(c, _)| c == 'B')
.map(|(_, k)| k)
.unwrap();
assert_eq!(downs, ["alpha", a, "alpha", "leftshift", b]);
assert!(!q.busy());
}
#[test]
fn hp28s_letters_are_keys_of_their_own() {
let mut q = KeyQueue::new(Model::Hp28s);
let mut kb = Fake {
idle: true,
alpha: true,
..Fake::default()
};
assert!(q.type_letter('A'));
assert!(q.type_letter('z'));
assert!(!q.type_letter('1'));
run(&mut q, &mut kb, 2000.0);
let downs: Vec<&str> = kb.log.iter().filter_map(|s| s.strip_prefix('+')).collect();
assert_eq!(downs, ["lettera", "lc", "letterz", "lc"]);
assert!(!q.busy());
}
#[test]
fn aplet_models_shift_before_alpha_and_respect_alpha_on() {
let mut q = KeyQueue::new(Model::Hp38g);
let mut kb = Fake {
idle: true,
alpha: true,
..Fake::default()
};
q.type_letter('c');
run(&mut q, &mut kb, 1000.0);
let downs: Vec<&str> = kb.log.iter().filter_map(|s| s.strip_prefix('+')).collect();
assert_eq!(downs.len(), 2);
assert_eq!(downs[0], "shift");
}
#[test]
fn release_held_lets_go_of_user_presses() {
let mut q = KeyQueue::new(Model::Hp48sx);
let mut kb = Fake {
idle: true,
..Fake::default()
};
q.press("on");
q.pump(&mut kb);
q.release_held();
run(&mut q, &mut kb, 100.0);
assert_eq!(kb.log, ["+on", "-on"]);
}
#[test]
fn packs_bits_msb_first_per_row() {
let mut rows = vec![vec![false; LCD_WIDTH]; 2];
rows[0][0] = true;
rows[0][9] = true;
rows[1][130] = true;
let p = pack_bits(&rows);
assert_eq!(p.len(), 2 * 17);
assert_eq!(p[0], 0x80);
assert_eq!(p[1], 0x40);
assert_eq!(p[17 + 16], 0x20);
assert_eq!(p.iter().map(|b| b.count_ones()).sum::<u32>(), 3);
}
#[test]
fn base64_matches_rfc4648() {
assert_eq!(base64(b""), "");
assert_eq!(base64(b"f"), "Zg==");
assert_eq!(base64(b"fo"), "Zm8=");
assert_eq!(base64(b"foo"), "Zm9v");
assert_eq!(base64(b"foobar"), "Zm9vYmFy");
assert_eq!(base64(&[0xff, 0xfe]), "//4=");
for n in 0..40 {
let bytes: Vec<u8> = (0..n).map(|i| (i * 37 + 11) as u8).collect();
assert_eq!(base64_decode(&base64(&bytes)).unwrap(), bytes);
}
assert_eq!(base64_decode("aGk").unwrap(), b"hi");
assert!(base64_decode("a").is_err());
assert!(base64_decode("a*bc").is_err());
}
#[test]
fn rom_picks_the_model() {
let two = 2 * 1024 * 1024;
assert_eq!(
model_for_rom(&vec![0u8; 256 * 1024], Model::Hp49g),
Model::Hp48sx
);
assert_eq!(
model_for_rom(&vec![0u8; 256 * 1024], Model::Hp48sx),
Model::Hp48sx
);
assert_eq!(model_for_rom(&vec![0u8; two], Model::Hp49g), Model::Hp39g);
assert_eq!(model_for_rom(&vec![0u8; two], Model::Hp40g), Model::Hp40g);
assert_eq!(
model_for_rom(&vec![0xffu8; two], Model::Hp39g),
Model::Hp49g
);
assert_eq!(model_for_rom(&[0u8; 1000], Model::Hp38g), Model::Hp38g);
}
#[test]
fn frames_and_keys_only_when_changed() {
let mut emu = Emulator::new(Model::Hp48sx, &vec![0u8; 256 * 1024]).unwrap();
let f = serde_json::to_string(&emu.frame_if_changed().unwrap()).unwrap();
assert!(
f.starts_with("{\"type\":\"frame\",\"width\":131,\"height\":64,\"pixels\":\"AAAA"),
"{f}"
);
assert!(f.contains(",\"annunciators\":{\"leftshift\":false,"), "{f}");
assert!(
f.ends_with(",\"contrastRange\":[3,19],\"contrastDefault\":11}"),
"{f}"
);
assert!(emu.frame_if_changed().is_none());
emu.reshow();
assert!(emu.frame_if_changed().is_some());
let keys = |emu: &mut Emulator| {
emu.keys_if_changed()
.map(|k| serde_json::to_string(&k).unwrap())
};
assert_eq!(
keys(&mut emu).as_deref(),
Some("{\"type\":\"keys\",\"down\":[]}")
);
assert!(emu.keys_if_changed().is_none());
emu.queue().press("enter");
emu.pump();
assert_eq!(
keys(&mut emu).as_deref(),
Some("{\"type\":\"keys\",\"down\":[\"enter\"]}")
);
}
}