Sylpheed/crates/sylpheed-formats/tests/ui_surfaces_disc.rs

//! Disc-wide guards for the 2D surface formats, locking in what was measured on
//! 2026-08-11. Skipped (as no-ops) when the extracted disc is absent.
//!
//! These assert *disc-wide invariants* rather than one hand-picked file, because
//! each of the findings they guard was originally missed by reasoning from a
//! sample: T8aD's "~15 % unsupported variants" were a wrong model, and LSTA's
//! "a few entries disagree with the count" was a miscount.

use std::path::{Path, PathBuf};

use sylpheed_formats::{lsta, pak::PakArchive, ratc, t8ad};

mod common;
use common::skip_without_disc;

/// Every entry of every pak, plus every RATC child, as raw bytes.
fn for_each_blob(root: &Path, mut f: impl FnMut(&str, &str, &[u8])) {
    let mut paks: Vec<PathBuf> = std::fs::read_dir(root.join("dat"))
        .expect("dat/")
        .flatten()
        .map(|e| e.path())
        .filter(|p| p.extension().and_then(|s| s.to_str()) == Some("pak"))
        .collect();
    paks.sort();
    for p in &paks {
        let pak_name = p.file_name().unwrap().to_string_lossy().to_string();
        let Ok(arc) = PakArchive::open(p) else {
            continue;
        };
        for e in arc.entries() {
            let Ok(bytes) = arc.read(e) else { continue };
            f(&pak_name, &format!("{:08x}", e.name_hash), &bytes);
            if ratc::is_ratc(&bytes) {
                if let Some(kids) = ratc::parse(&bytes) {
                    for k in &kids {
                        if k.offset + k.size <= bytes.len() {
                            f(&pak_name, &k.name, &bytes[k.offset..k.offset + k.size]);
                        }
                    }
                }
            }
        }
    }
}

/// A T8aD surface is a list of sub-rectangles, and on this disc **every** one
/// decodes. Regressing the rectangle model would show up here as a decode gap,
/// which is exactly how the old 256-grid reading looked (96 %, not 100 %).
#[test]
fn every_t8ad_on_the_disc_decodes() {
    skip_without_disc!(root);
    let (mut total, mut ok) = (0usize, 0usize);
    let mut first_failure = None;
    for_each_blob(&root, |pak, name, b| {
        if !t8ad::is_t8ad(b) || b.len() < 0x40 {
            return;
        }
        total += 1;
        if t8ad::parse(b).is_some() {
            ok += 1;
        } else if first_failure.is_none() {
            first_failure = Some(format!("{pak}:{name}"));
        }
    });
    assert!(
        total > 19_000,
        "expected the disc's ~19 216 surfaces, saw {total}"
    );
    assert_eq!(ok, total, "first failure: {first_failure:?}");
}

/// An LSTA's header count is exact and counts **both** kinds of element: T8aD
/// sprites and `PRMD` primitives. (It was long read as unreliable because the
/// comparison ignored primitives.)
#[test]
fn lsta_count_equals_sprites_plus_primitives() {
    skip_without_disc!(root);
    let count_magic = |b: &[u8], magic: &[u8; 4]| {
        let (mut n, mut i) = (0usize, 4usize);
        while i + 4 <= b.len() {
            if &b[i..i + 4] == magic {
                n += 1;
                i += 4;
            } else {
                i += 1;
            }
        }
        n
    };
    let (mut lists, mut exact) = (0usize, 0usize);
    let mut bad = Vec::new();
    for_each_blob(&root, |pak, name, b| {
        if !lsta::is_lsta(b) || b.len() < 8 {
            return;
        }
        lists += 1;
        let declared = u32::from_be_bytes([b[4], b[5], b[6], b[7]]) as usize;
        let sprites = count_magic(b, b"T8aD");
        let prims = count_magic(b, b"PRMD");
        if declared == sprites + prims {
            exact += 1;
        } else if bad.len() < 4 {
            bad.push(format!(
                "{pak}:{name} declared {declared} != {sprites}+{prims}"
            ));
        }
    });
    assert!(
        lists >= 60,
        "expected the disc's 64 LSTA lists, saw {lists}"
    );
    assert_eq!(exact, lists, "mismatches: {bad:?}");
}

/// Nested RATC records are **leaves**: they carry no child list of their own.
/// "One level deep" describes the data, not a parser limit.
#[test]
fn ratc_nesting_is_exactly_one_level() {
    skip_without_disc!(root);
    let mut grandchildren = 0usize;
    let mut bundles = 0usize;
    for_each_blob(&root, |_, _, b| {
        if !ratc::is_ratc(b) {
            return;
        }
        let Some(kids) = ratc::parse(b) else { return };
        bundles += 1;
        for k in &kids {
            if k.offset + k.size > b.len() {
                continue;
            }
            let sub = &b[k.offset..k.offset + k.size];
            if ratc::is_ratc(sub) {
                grandchildren += ratc::parse(sub).map(|g| g.len()).unwrap_or(0);
            }
        }
    });
    assert!(
        bundles > 2_000,
        "expected thousands of RATC bundles, saw {bundles}"
    );
    assert_eq!(grandchildren, 0, "a nested RATC record listed children");
}