use saturnus_core::Model;
use serde_json::{Value, json};
use crate::sha256;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct KnownRom {
pub sha256: &'static str,
pub models: &'static [Model],
pub revision: &'static str,
pub file: &'static str,
pub size: usize,
pub url: &'static str,
pub page: &'static str,
}
pub const KNOWN: [KnownRom; 6] = [
KnownRom {
sha256: "e5eb3af020e4910f35a7580a705cf0a46f3ba9d7ba5516582d98010c93af7c74",
models: &[Model::Hp48sx],
revision: "48SX J",
file: "sxrom-j",
size: 256 * 1024,
url: "https://www.hpcalc.org/hp48/pc/emulators/sxrom-j.zip",
page: "https://www.hpcalc.org/details/4371",
},
KnownRom {
sha256: "de3a5a07b0f00640f4ba3599ea4092e9473113aad75c04bd03d3e37c059b5b33",
models: &[Model::Hp48gx],
revision: "48GX R",
file: "gxrom-r",
size: 512 * 1024,
url: "https://www.hpcalc.org/hp48/pc/emulators/gxrom-r.zip",
page: "https://www.hpcalc.org/details/4368",
},
KnownRom {
sha256: "3c9f747f637757d3adc414ed14d7f3636033f34f0a72e6e453ee197987f16be7",
models: &[Model::Hp38g],
revision: "38G A1.67",
file: "38G_A167.ROM",
size: 512 * 1024,
url: "https://www.hpcalc.org/hp38/pc/38grom.zip",
page: "https://www.hpcalc.org/details/4775",
},
KnownRom {
sha256: "b01c13e24a692f35e6087106d58ec205b4696d5b5e35d57f8f94015f8bb1f1ca",
models: &[Model::Hp49g],
revision: "49G 2.15",
file: "rom.49g",
size: 2 * 1024 * 1024,
url: "https://www.hpcalc.org/hp49/pc/rom/hp4950emurom.zip",
page: "https://www.hpcalc.org/details/6744",
},
KnownRom {
sha256: "58c3de6b7fc75a0ba65fca7437c4d49d8f26ca9e334a57e4d3bc4f8fb2dc8c11",
models: &[Model::Hp49g],
revision: "49G 2.10",
file: "rom.49g",
size: 2 * 1024 * 1024,
url: "https://www.hpcalc.org/hp49/pc/rom/hp4950v210.zip",
page: "https://www.hpcalc.org/details/8888",
},
KnownRom {
sha256: "69220f42d5e90dd8825e7d1596d9eaca490ee6a7a52a3b8b96469a5f3d3f627f",
models: &[Model::Hp39g, Model::Hp40g],
revision: "39G/40G (hpcalc rom3940)",
file: "rom.39g",
size: 2 * 1024 * 1024,
url: "https://www.hpcalc.org/hp39/pc/rom3940.zip",
page: "https://www.hpcalc.org/details/6739",
},
];
pub fn revision(sha256: &str) -> Option<&'static str> {
KNOWN
.iter()
.find(|k| k.sha256 == sha256)
.map(|k| k.revision)
}
pub fn download(model: Model) -> Option<&'static KnownRom> {
KNOWN.iter().find(|k| k.models.contains(&model))
}
pub fn download_json(model: Model) -> Value {
download(model).map_or(Value::Null, |k| {
json!({"file": k.file, "size": k.size, "url": k.url, "page": k.page, "revision": k.revision})
})
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Identity {
Exact {
models: Vec<Model>,
revision: &'static str,
},
Fits(Vec<Model>),
Unknown,
}
impl Identity {
pub fn models(&self) -> &[Model] {
match self {
Identity::Exact { models, .. } | Identity::Fits(models) => models,
Identity::Unknown => &[],
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct RomId {
pub sha256: String,
pub identity: Identity,
}
impl RomId {
pub fn revision(&self) -> Option<&'static str> {
match self.identity {
Identity::Exact { revision, .. } => Some(revision),
_ => None,
}
}
}
pub const SIGNATURES: [(Model, &str); 6] = [
(Model::Hp42s, "OK-42S-"),
(Model::Hp27s, "OK-27S-"),
(Model::Hp17bii, "17B II-"),
(Model::Hp17b, "OK-17B-E"),
(Model::Hp28s, "OK-28S"),
(Model::Hp19bii, "OK-19B II"),
];
fn holds_text(rom: &[u8], shifted: &[u8], text: &str) -> bool {
let t = text.as_bytes();
rom.windows(t.len()).any(|w| w == t) || shifted.windows(t.len()).any(|w| w == t)
}
pub fn fitting_models(rom: &[u8]) -> Vec<Model> {
const TWO_MB: usize = 2 * 1024 * 1024;
let nibbles = || rom.iter().all(|&b| b < 16);
let unpacked_2mb = rom.len() == TWO_MB && nibbles();
let fits: Vec<Model> = Model::ALL
.into_iter()
.filter(|&m| m.accepts_rom_len(rom.len()))
.filter(|&m| match m {
Model::Hp49g if rom.len() == TWO_MB => !unpacked_2mb,
Model::Hp49g => nibbles(),
Model::Hp39g | Model::Hp40g if rom.len() == TWO_MB => unpacked_2mb,
_ => true,
})
.collect();
let clamshell = !fits.is_empty() && fits.iter().all(|m| m.is_lewis() && !m.is_pioneer());
if (fits.len() > 1 && fits.iter().all(|m| m.is_pioneer())) || clamshell {
let rom = saturnus_core::pioneer_address_order(rom);
let shifted: Vec<u8> = rom.windows(2).map(|w| (w[0] >> 4) | (w[1] << 4)).collect();
let signed: Vec<Model> = SIGNATURES
.iter()
.filter(|(m, text)| fits.contains(m) && holds_text(&rom, &shifted, text))
.map(|&(m, _)| m)
.collect();
if let [one] = signed.as_slice() {
return vec![*one];
}
if clamshell {
return Vec::new();
}
}
fits
}
pub fn identify(rom: &[u8]) -> RomId {
let sha256 = sha256::hex_digest(rom);
let identity = match KNOWN.iter().find(|k| k.sha256 == sha256) {
Some(k) => Identity::Exact {
models: k.models.to_vec(),
revision: k.revision,
},
None => match fitting_models(rom) {
m if m.is_empty() => Identity::Unknown,
m => Identity::Fits(m),
},
};
RomId { sha256, identity }
}
#[derive(Clone, Debug)]
pub struct Candidate {
pub name: String,
pub identity: Identity,
pub chosen: bool,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Plan {
pub assign: Vec<(Model, usize)>,
pub offer: Vec<(Vec<Model>, usize)>,
pub boot: Option<Model>,
pub notice: String,
}
fn title(m: Model) -> String {
m.name().to_uppercase()
}
fn titles(models: &[Model], conjunction: &str) -> String {
let t: Vec<String> = models.iter().map(|&m| title(m)).collect();
match t.as_slice() {
[] => String::new(),
[one] => one.clone(),
[init @ .., last] => format!("{} {conjunction} {last}", init.join(", ")),
}
}
fn hosted_only(c: &Candidate) -> Candidate {
let keep = |ms: &[Model]| -> Vec<Model> {
ms.iter()
.copied()
.filter(|&m| crate::skins::skin(m).is_some())
.collect()
};
let identity = match &c.identity {
Identity::Unknown => Identity::Unknown,
Identity::Fits(ms) => match keep(ms) {
k if k.is_empty() => Identity::Unknown,
k => Identity::Fits(k),
},
Identity::Exact { models, revision } => match keep(models) {
k if k.is_empty() => Identity::Unknown,
k => Identity::Exact {
models: k,
revision,
},
},
};
Candidate {
identity,
..c.clone()
}
}
pub fn plan(selected: Model, files: &[Candidate], filled: &[Model]) -> Plan {
let files: Vec<Candidate> = files.iter().map(hosted_only).collect();
let files = files.as_slice();
let mut plan = Plan::default();
let taken = |plan: &Plan, m: Model| plan.assign.iter().any(|&(a, _)| a == m);
let mut refused = Vec::new();
let mut found = Vec::new();
let order = files
.iter()
.enumerate()
.filter(|(_, f)| f.chosen)
.chain(files.iter().enumerate().filter(|(_, f)| !f.chosen));
for (n, f) in order {
let empty: Vec<Model> = f
.identity
.models()
.iter()
.copied()
.filter(|&m| !taken(&plan, m) && (f.chosen || !filled.contains(&m)))
.collect();
match (&f.identity, f.chosen) {
(Identity::Unknown, true) => refused.push(format!(
"{} is not a ROM for any model Saturnus supports",
f.name
)),
(Identity::Unknown, false) => {}
(Identity::Exact { models, .. }, _) => {
if !f.chosen && !empty.is_empty() {
found.push(format!("{} for the {}", f.name, titles(&empty, "and")));
}
if f.chosen && empty.is_empty() {
refused.push(format!(
"{} was not used: another file in the batch is the {} ROM",
f.name,
titles(models, "and")
));
}
plan.assign.extend(empty.iter().map(|&m| (m, n)));
}
(Identity::Fits(models), true) => {
let target = if models.contains(&selected) {
Some(selected)
} else if let [one] = models.as_slice() {
Some(*one)
} else {
None
};
match target {
Some(m) if !taken(&plan, m) => plan.assign.push((m, n)),
Some(m) => refused.push(format!(
"{} was not used: another file in the batch is the {} ROM",
f.name,
title(m)
)),
None => plan.offer.push((models.clone(), n)),
}
}
(Identity::Fits(_), false) => {
if !empty.is_empty() {
plan.offer.push((empty, n));
}
}
}
}
let chosen_models = || {
plan.assign
.iter()
.filter(|&&(_, n)| files[n].chosen)
.map(|&(m, _)| m)
};
plan.boot = if chosen_models().any(|m| m == selected) {
Some(selected)
} else {
chosen_models().next()
};
let mut parts = Vec::new();
if !found.is_empty() {
parts.push(format!("Also found: {}.", found.join(", ")));
}
for (models, n) in &plan.offer {
parts.push(format!(
"{} could be the {} ROM.",
files[*n].name,
titles(models, "or")
));
}
for r in refused {
parts.push(format!("{r}."));
}
plan.notice = parts.join(" ");
plan
}
pub fn rom_id_json(id: &RomId) -> Value {
let kind = match id.identity {
Identity::Exact { .. } => "exact",
Identity::Fits(_) => "fits",
Identity::Unknown => "unknown",
};
let models: Vec<&str> = id.identity.models().iter().map(|m| m.name()).collect();
json!({"sha256": id.sha256, "kind": kind, "models": models, "revision": id.revision()})
}
fn identity_from_json(v: &Value) -> crate::Result<Identity> {
let models = v
.get("models")
.and_then(Value::as_array)
.map(|a| {
a.iter()
.map(|m| m.as_str().unwrap_or_default().parse::<Model>())
.collect::<Result<Vec<_>, _>>()
})
.transpose()?
.unwrap_or_default();
Ok(match v.get("kind").and_then(Value::as_str) {
Some("exact") => {
let sha = v.get("sha256").and_then(Value::as_str).unwrap_or_default();
let revision = revision(sha).ok_or("an exact image of no known revision")?;
Identity::Exact { models, revision }
}
Some("fits") => Identity::Fits(models),
_ => Identity::Unknown,
})
}
pub fn plan_json(input: &Value) -> crate::Result<Value> {
let selected = input
.get("selected")
.and_then(Value::as_str)
.unwrap_or_default()
.parse::<Model>()?;
let filled = input
.get("filled")
.and_then(Value::as_array)
.map(|a| {
a.iter()
.map(|m| m.as_str().unwrap_or_default().parse::<Model>())
.collect::<Result<Vec<_>, _>>()
})
.transpose()?
.unwrap_or_default();
let files = input
.get("files")
.and_then(Value::as_array)
.ok_or("\"files\" is missing")?
.iter()
.map(|f| {
Ok(Candidate {
name: f
.get("name")
.and_then(Value::as_str)
.unwrap_or_default()
.to_string(),
chosen: f.get("chosen").and_then(Value::as_bool).unwrap_or(false),
identity: identity_from_json(f.get("id").unwrap_or(&Value::Null))?,
})
})
.collect::<crate::Result<Vec<_>>>()?;
let p = plan(selected, &files, &filled);
Ok(json!({
"assign": p.assign.iter().map(|&(m, n)| json!({"model": m.name(), "file": n})).collect::<Vec<_>>(),
"offer": p.offer.iter().map(|(ms, n)| json!({
"models": ms.iter().map(|m| m.name()).collect::<Vec<_>>(),
"file": n,
})).collect::<Vec<_>>(),
"boot": p.boot.map(Model::name),
"notice": p.notice,
}))
}
#[cfg(test)]
mod tests {
use super::*;
use Model::*;
const KB: usize = 1024;
fn fits(rom: &[u8]) -> Identity {
identify(rom).identity
}
#[test]
fn synthetic_images_fit_by_size_and_form() {
assert_eq!(
fits(&[0; 64 * KB]),
Identity::Fits(vec![Hp42s, Hp27s, Hp17bii, Hp17b])
);
assert_eq!(fits(&[0; 96 * KB]), Identity::Fits(vec![Hp17bii, Hp17b]));
assert_eq!(fits(&[0; 256 * KB]), Identity::Fits(vec![Hp48sx]));
assert_eq!(fits(&[0; 512 * KB]), Identity::Fits(vec![Hp48gx, Hp38g]));
assert_eq!(fits(&[0; 1024 * KB]), Identity::Fits(vec![Hp39g, Hp40g]));
let mut two = vec![0x0f; 2048 * KB];
assert_eq!(fits(&two), Identity::Fits(vec![Hp39g, Hp40g]));
two[7] = 0x10;
assert_eq!(fits(&two), Identity::Fits(vec![Hp49g]));
let mut four = vec![0u8; 4096 * KB];
assert_eq!(fits(&four), Identity::Fits(vec![Hp49g]));
four[0] = 0xff;
assert_eq!(fits(&four), Identity::Unknown);
assert_eq!(fits(&[0; 1000]), Identity::Unknown);
assert_eq!(fits(&[]), Identity::Unknown);
}
#[test]
fn signatures_name_a_64_kb_image() {
let pioneers = vec![Hp42s, Hp27s, Hp17bii, Hp17b];
for &(model, text) in SIGNATURES.iter().filter(|(m, _)| m.is_pioneer()) {
let mut rom = vec![0u8; 64 * KB];
rom[0x7000..0x7000 + text.len()].copy_from_slice(text.as_bytes());
assert_eq!(fits(&rom), Identity::Fits(vec![model]), "{text}");
let mut shifted = vec![0u8; 64 * KB];
for (i, b) in text.bytes().enumerate() {
shifted[0x7000 + i] |= b << 4;
shifted[0x7001 + i] |= b >> 4;
}
assert_eq!(fits(&shifted), Identity::Fits(vec![model]), "{text}");
let mut big = rom.clone();
big.resize(96 * KB, 0);
let want = if matches!(model, Hp17b | Hp17bii) {
vec![model]
} else {
vec![Hp17bii, Hp17b]
};
assert_eq!(fits(&big), Identity::Fits(want), "{text}");
}
let mut both = vec![0u8; 64 * KB];
let mut at = 0x100;
for &(_, text) in &SIGNATURES {
both[at..at + text.len()].copy_from_slice(text.as_bytes());
at += 0x100;
}
assert_eq!(
fits(&both),
Identity::Fits(pioneers.clone()),
"several signatures name no one"
);
assert_eq!(fits(&vec![0x5a; 64 * KB]), Identity::Fits(pioneers));
}
#[test]
fn a_28s_image_fills_its_slot() {
let id = Identity::Fits(vec![Hp28s]);
let p = plan(Hp48sx, &[file("hp28s.rom", id.clone(), true)], &[]);
assert_eq!(p.boot, Some(Hp28s));
assert_eq!(p.assign, [(Hp28s, 0)]);
assert!(p.offer.is_empty());
let p = plan(Hp48sx, &[file("hp28s.rom", id, false)], &[]);
assert_eq!(p.offer, [(vec![Hp28s], 0)]);
assert!(p.assign.is_empty() && p.boot.is_none());
}
#[test]
fn a_128_kb_image_needs_the_28s_text() {
let text = b"OK-28S";
assert_eq!(fits(&vec![0u8; 128 * KB]), Identity::Unknown);
let mut rom = vec![0u8; 128 * KB];
for (i, &b) in text.iter().enumerate() {
rom[0x1F04F + i] |= b << 4;
rom[0x1F050 + i] |= b >> 4;
}
assert_eq!(fits(&rom), Identity::Fits(vec![Hp28s]));
let mut aligned = vec![0u8; 128 * KB];
aligned[0x100..0x100 + text.len()].copy_from_slice(text);
assert_eq!(fits(&aligned), Identity::Fits(vec![Hp28s]));
let mut bii = vec![0u8; 128 * KB];
bii[0x1FFF3..0x1FFF3 + 6].copy_from_slice(b"OK-19B");
assert_eq!(fits(&bii), Identity::Unknown, "a 19B's text is not enough");
bii[0x16F50..0x16F50 + 9].copy_from_slice(b"OK-19B II");
assert_eq!(fits(&bii), Identity::Fits(vec![Hp19bii]));
let mut both = aligned.clone();
both[0x16F50..0x16F50 + 9].copy_from_slice(b"OK-19B II");
assert_eq!(fits(&both), Identity::Unknown, "two texts name no one");
let mut small = vec![0u8; 64 * KB];
small[0x100..0x100 + text.len()].copy_from_slice(text);
assert_eq!(
fits(&small),
Identity::Fits(vec![Hp42s, Hp27s, Hp17bii, Hp17b])
);
}
#[test]
fn an_unsigned_pioneer_image_is_offered() {
let all = Identity::Fits(vec![Hp42s, Hp27s, Hp17bii, Hp17b]);
let p = plan(Hp27s, &[file("dump.rom", all.clone(), true)], &[]);
assert_eq!(p.boot, Some(Hp27s));
let p = plan(Hp48sx, &[file("dump.rom", all, true)], &[]);
assert_eq!(p.boot, None);
assert_eq!(p.offer, [(vec![Hp42s, Hp27s, Hp17bii, Hp17b], 0)]);
assert_eq!(
p.notice,
"dump.rom could be the 42S, 27S, 17BII or 17B ROM."
);
}
#[test]
fn known_images_are_exact_and_fit_their_models() {
for k in KNOWN {
assert_eq!(k.sha256.len(), 64);
assert_eq!(revision(k.sha256), Some(k.revision));
assert!(!k.models.is_empty());
for &m in k.models {
assert!(m.accepts_rom_len(k.size), "{}", k.revision);
}
assert!(k.url.starts_with("https://www.hpcalc.org/") && k.url.ends_with(".zip"));
assert!(k.page.starts_with("https://www.hpcalc.org/details/"));
}
assert_eq!(revision(&"0".repeat(64)), None);
let id = identify(b"abc");
assert_eq!(
id.sha256,
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
);
assert_eq!(id.revision(), None);
}
fn exact(models: &[Model]) -> Identity {
Identity::Exact {
models: models.to_vec(),
revision: "test",
}
}
fn file(name: &str, identity: Identity, chosen: bool) -> Candidate {
Candidate {
name: name.into(),
identity,
chosen,
}
}
#[test]
fn a_chosen_rom_and_its_folder() {
let files = [
file("sxrom-j", exact(&[Hp48sx]), true),
file("38G_A167.ROM", exact(&[Hp38g]), false),
file("gxrom-r", exact(&[Hp48gx]), false),
file("hp42s-c.rom", Identity::Fits(vec![Hp42s]), false),
file("notes.bin", Identity::Unknown, false),
file("rom-2.10.49g", exact(&[Hp49g]), false),
file("rom.39g", exact(&[Hp39g, Hp40g]), false),
file("rom.49g", exact(&[Hp49g]), false),
];
let p = plan(Hp48sx, &files, &[Hp38g]);
assert_eq!(
p.assign,
[(Hp48sx, 0), (Hp48gx, 2), (Hp49g, 5), (Hp39g, 6), (Hp40g, 6)]
);
assert_eq!(p.offer, [(vec![Hp42s], 3)]);
assert_eq!(p.boot, Some(Hp48sx));
assert_eq!(
p.notice,
"Also found: gxrom-r for the 48GX, rom-2.10.49g for the 49G, rom.39g for the 39G and \
40G. hp42s-c.rom could be the 42S ROM."
);
let all: Vec<Model> = Model::ALL.to_vec();
let p = plan(Hp48sx, &files, &all);
assert_eq!(p.assign, [(Hp48sx, 0)]);
assert!(p.offer.is_empty());
assert_eq!(p.notice, "");
}
#[test]
fn chosen_files_by_identity() {
let gx_or_38 = || file("x.rom", Identity::Fits(vec![Hp48gx, Hp38g]), true);
let p = plan(Hp48gx, &[gx_or_38()], &[]);
assert_eq!(
(p.assign.as_slice(), p.boot),
(&[(Hp48gx, 0)][..], Some(Hp48gx))
);
let p = plan(Hp48sx, &[gx_or_38()], &[]);
assert!(p.assign.is_empty());
assert_eq!(p.offer, [(vec![Hp48gx, Hp38g], 0)]);
assert_eq!(p.boot, None);
assert_eq!(p.notice, "x.rom could be the 48GX or 38G ROM.");
let p = plan(Hp48sx, &[file("g", exact(&[Hp48gx]), true)], &[Hp48gx]);
assert_eq!(
(p.assign.as_slice(), p.boot),
(&[(Hp48gx, 0)][..], Some(Hp48gx))
);
let p = plan(Hp48sx, &[file("d", Identity::Fits(vec![Hp42s]), true)], &[]);
assert_eq!(p.boot, Some(Hp42s));
let p = plan(Hp48sx, &[file("a.txt", Identity::Unknown, true)], &[]);
assert!(p.assign.is_empty() && p.boot.is_none());
assert_eq!(
p.notice,
"a.txt is not a ROM for any model Saturnus supports."
);
let files = [
file("a", exact(&[Hp48gx]), true),
file("b", exact(&[Hp48sx]), true),
file("c", Identity::Fits(vec![Hp48sx]), true),
];
let p = plan(Hp48sx, &files, &[]);
assert_eq!(p.assign, [(Hp48gx, 0), (Hp48sx, 1)]);
assert_eq!(p.boot, Some(Hp48sx));
assert_eq!(
p.notice,
"c was not used: another file in the batch is the 48SX ROM."
);
let files = [
file("rom.49g", exact(&[Hp49g]), true),
file("rom-2.10.49g", exact(&[Hp49g]), true),
];
let p = plan(Hp49g, &files, &[]);
assert_eq!(p.assign, [(Hp49g, 0)]);
assert_eq!(
p.notice,
"rom-2.10.49g was not used: another file in the batch is the 49G ROM."
);
}
#[test]
fn plan_over_json() {
let id = rom_id_json(&identify(&[0; 256 * KB]));
assert_eq!(id["kind"], "fits");
assert_eq!(id["models"], json!(["48sx"]));
assert_eq!(id["revision"], Value::Null);
let out = plan_json(&json!({
"selected": "48sx",
"filled": [],
"files": [{"name": "a", "chosen": true, "id": id}],
}))
.unwrap();
assert_eq!(out["assign"], json!([{"model": "48sx", "file": 0}]));
assert_eq!(out["boot"], "48sx");
assert!(plan_json(&json!({"selected": "99x", "files": []})).is_err());
}
#[test]
fn downloads_per_model() {
for m in Model::ALL {
match download(m) {
None => assert!(m.is_lewis(), "{}", m.name()),
Some(k) => assert!(k.models.contains(&m)),
}
}
assert_eq!(download(Hp49g).map(|k| k.revision), Some("49G 2.15"));
assert_eq!(download(Hp39g), download(Hp40g));
assert_eq!(download_json(Hp42s), Value::Null);
assert_eq!(
download_json(Hp48sx),
json!({
"file": "sxrom-j",
"size": 262_144,
"url": "https://www.hpcalc.org/hp48/pc/emulators/sxrom-j.zip",
"page": "https://www.hpcalc.org/details/4371",
"revision": "48SX J",
})
);
}
#[test]
fn rom_dir_images() {
let Some(dir) = std::env::var_os("SATURNUS_ROM_DIR") else {
return;
};
let dir = std::path::PathBuf::from(dir);
let want: [(&str, Identity); 13] = [
("sxrom-j", exact(&[Hp48sx])),
("gxrom-r", exact(&[Hp48gx])),
("38G_A167.ROM", exact(&[Hp38g])),
("rom.49g", exact(&[Hp49g])),
("rom-2.10.49g", exact(&[Hp49g])),
("rom.39g", exact(&[Hp39g, Hp40g])),
("hp42s-c.rom", Identity::Fits(vec![Hp42s])),
("hp27s.rom", Identity::Fits(vec![Hp27s])),
("hp17bii.rom", Identity::Fits(vec![Hp17bii])),
("hp17b.rom", Identity::Fits(vec![Hp17b])),
("hp28s.rom", Identity::Fits(vec![Hp28s])),
("hp28c.rom", Identity::Unknown),
("hp19bii.rom", Identity::Fits(vec![Hp19bii])),
];
for (name, identity) in want {
let Ok(rom) = std::fs::read(dir.join(name)) else {
eprintln!("{name} not in SATURNUS_ROM_DIR, skipped");
continue;
};
let got = identify(&rom).identity;
match (&got, &identity) {
(Identity::Exact { models: a, .. }, Identity::Exact { models: b, .. }) => {
assert_eq!(a, b, "{name}")
}
_ => assert_eq!(got, identity, "{name}"),
}
}
}
}