diff --git a/crates/core/tests/common/mod.rs b/crates/core/tests/common/mod.rs index 2c7552ab..891b1165 100644 --- a/crates/core/tests/common/mod.rs +++ b/crates/core/tests/common/mod.rs @@ -6,6 +6,7 @@ clippy::expect_used )] +pub mod r4; pub mod svg_tree; use faunosteo_core::domain::js::{find_lone_surrogate, parse_json}; diff --git a/crates/core/tests/common/r4.rs b/crates/core/tests/common/r4.rs new file mode 100644 index 00000000..5b6d6469 --- /dev/null +++ b/crates/core/tests/common/r4.rs @@ -0,0 +1,90 @@ +//! R4 oracle plumbing shared by the reader suites: the frozen inputs under +//! `apps/app/tests/fixtures/pdf/r4/` (stored bytes, or a `.gen.json` description +//! expanded and checked against its length and digest) and the sha256 digests the TypeScript +//! generators recorded. +#![allow( + dead_code, + clippy::disallowed_methods, + clippy::unwrap_used, + clippy::expect_used +)] + +use std::path::PathBuf; + +use serde_json::Value; +use sha2::{Digest, Sha256}; + +/// Repository root (the workspace lives at `crates/core/../..`). +pub fn repo_root() -> PathBuf { + PathBuf::from(format!("{}/../..", env!("CARGO_MANIFEST_DIR"))) +} + +/// A frozen R4 oracle (`crates/core/tests/oracles/r4/`), as plain serde_json. +pub fn r4_oracle(name: &str) -> Value { + let path = repo_root().join("crates/core/tests/oracles/r4").join(name); + let text = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("{path:?}: {e}")); + serde_json::from_str(&text).unwrap_or_else(|e| panic!("{path:?}: {e}")) +} + +/// Lower-case hex sha256 of `data`, the form every oracle stores. +pub fn sha256_hex(data: &[u8]) -> String { + let digest = Sha256::digest(data); + digest.iter().map(|b| format!("{b:02x}")).collect() +} + +/// The bytes of input `file` of `dir` (`read`, `inflate`, `tolerance`): stored as is, or +/// expanded from `.gen.json` (`concat/1`: `latin1` text one byte per character, `fill` +/// a byte repeated, `slice` of another file of the directory), then checked against the +/// recorded `length` and `sha256`. +pub fn r4_input(dir: &str, file: &str) -> Vec { + let base = repo_root().join("apps/app/tests/fixtures/pdf/r4").join(dir); + let stored = base.join(file); + if stored.exists() { + return std::fs::read(&stored).unwrap_or_else(|e| panic!("{stored:?}: {e}")); + } + let slug = file.rsplit_once('.').map_or(file, |(stem, _)| stem); + let description = base.join(format!("{slug}.gen.json")); + let text = std::fs::read_to_string(&description) + .unwrap_or_else(|e| panic!("{description:?}: {e} (no stored bytes for {file})")); + let spec: Value = serde_json::from_str(&text).unwrap(); + assert_eq!(spec["generator"], "concat/1", "{file}: unknown generator"); + let bytes = expand_parts(spec["parts"].as_array().unwrap(), &base); + assert_eq!( + bytes.len() as u64, + spec["length"].as_u64().unwrap(), + "{file}: length" + ); + assert_eq!( + sha256_hex(&bytes), + spec["sha256"].as_str().unwrap(), + "{file}: digest" + ); + bytes +} + +fn expand_parts(parts: &[Value], dir: &std::path::Path) -> Vec { + let mut out = Vec::new(); + for part in parts { + if let Some(text) = part["latin1"].as_str() { + out.extend(text.chars().map(|c| u32::from(c) as u8)); + } else if let Some(byte) = part["fill"].as_u64() { + let count = part["count"].as_u64().unwrap() as usize; + out.resize(out.len() + count, byte as u8); + } else if let Some(source) = part["slice"].as_str() { + let bytes = std::fs::read(dir.join(source)).unwrap(); + let (start, end) = ( + part["start"].as_u64().unwrap(), + part["end"].as_u64().unwrap(), + ); + out.extend_from_slice(&bytes[start as usize..end as usize]); + } else { + panic!("unknown part {part}"); + } + } + out +} + +/// A Latin-1 string of the oracles (one character per byte) back to its bytes. +pub fn latin1_bytes(text: &str) -> Vec { + text.chars().map(|c| u32::from(c) as u8).collect() +} diff --git a/crates/core/tests/pdf_scan.rs b/crates/core/tests/pdf_scan.rs index 194024a4..1f1317b7 100644 --- a/crates/core/tests/pdf_scan.rs +++ b/crates/core/tests/pdf_scan.rs @@ -1 +1,10 @@ -//! R4.2: placeholder, written by its track. +//! R4.2a placeholder: the O7 scan suite, written by its track. +mod common; + +#[test] +fn placeholder_reads_an_oracle() { + let oracle = common::r4::r4_oracle("read.json"); + assert_eq!(oracle["oracle"], "O7"); + let bytes = common::r4::r4_input("read", "scan.demo-export.pdf"); + assert_eq!(bytes.len(), 78463); +}