fortrangoingonforty/afs-ld / 9c5dcc1

+//! Differential harness: compare afs-ld output against Apple `ld` output.

+//!

+//! Sprint 0 lands the diffing surface. The `link_both` function that actually

+//! shells out to both linkers arrives once afs-ld can produce a real binary

+//! (Sprint 18). Until then, tests exercise `diff_macho` directly against

+//! synthesized byte slices.

+

+#![allow(dead_code)]

+

+use std::path::PathBuf;

+

+pub struct LinkCase {

+    pub name: &'static str,

+    pub inputs: Vec<PathBuf>,

+    pub args: Vec<String>,

+}

+

+pub struct LinkOutputs {

+    pub ours: Vec<u8>,

+    pub theirs: Vec<u8>,

+}

+

+#[derive(Debug, Clone, PartialEq, Eq)]

+pub enum DiffCategory {

+    /// A diff we expect: UUID bytes, timestamps, hash-backed temp paths, etc.

+    Tolerated(&'static str),

+    /// Anything else. Fails the parity test.

+    Critical,

+}

+

+#[derive(Debug, Clone, PartialEq, Eq)]

+pub struct DiffChunk {

+    pub offset: usize,

+    pub len: usize,

+    pub reason: String,

+    pub category: DiffCategory,

+}

+

+#[derive(Debug, Default)]

+pub struct DiffReport {

+    pub tolerated: Vec<DiffChunk>,

+    pub critical: Vec<DiffChunk>,

+}

+

+impl DiffReport {

+    pub fn is_clean(&self) -> bool {

+        self.critical.is_empty()

+    }

+}

+

+/// Byte-level diff between two Mach-O images. Sprint 0 treats every byte diff

+/// as Critical; later sprints layer in the tolerated-diff predicates (UUID,

+/// timestamp, code-signature hashes, string-table suffix-dedup variance).

+pub fn diff_macho(ours: &[u8], theirs: &[u8]) -> DiffReport {

+    let mut report = DiffReport::default();

+

+    if ours.len() != theirs.len() {

+        report.critical.push(DiffChunk {

+            offset: 0,

+            len: ours.len().max(theirs.len()),

+            reason: format!(

+                "total size differs: ours = {}, theirs = {}",

+                ours.len(),

+                theirs.len()

+            ),

+            category: DiffCategory::Critical,

+        });

+        return report;

+    }

+

+    let mut i = 0;

+    while i < ours.len() {

+        if ours[i] != theirs[i] {

+            let start = i;

+            while i < ours.len() && ours[i] != theirs[i] {

+                i += 1;

+            }

+            report.critical.push(DiffChunk {

+                offset: start,

+                len: i - start,

+                reason: format!("{} byte(s) differ starting at 0x{start:x}", i - start),

+                category: DiffCategory::Critical,

+            });

+        } else {

+            i += 1;

+        }

+    }

+

+    report

+}

+

+/// Placeholder for the full linker-spawning contract. Sprint 18 wires this to

+/// real invocations of afs-ld and the system `ld` via `xcrun -f ld`.

+pub fn link_both(_case: &LinkCase) -> LinkOutputs {

+    panic!("link_both is not implemented until Sprint 18 (hello-world milestone)");

+}

+//! Shared test infrastructure. Integration tests that need the harness

+//! declare `mod common;` and then use `common::harness::*`.

+

+pub mod harness;

+//! Two byte slices that differ in a non-tolerated region must surface as

+//! critical diffs. Proves the harness actually notices regressions — otherwise

+//! every later differential test becomes a silent false-negative generator.

+

+mod common;

+

+use common::harness::diff_macho;

+

+#[test]

+fn differing_bytes_surface_as_critical() {

+    let ours = b"hello world".to_vec();

+    let mut theirs = ours.clone();

+    theirs[6] = b'W'; // capitalize the W in "world"

+

+    let report = diff_macho(&ours, &theirs);

+    assert!(!report.is_clean(), "harness missed a real byte difference");

+    assert_eq!(report.critical.len(), 1);

+    let chunk = &report.critical[0];

+    assert_eq!(chunk.offset, 6);

+    assert_eq!(chunk.len, 1);

+}

+

+#[test]

+fn size_mismatch_is_critical() {

+    let ours = b"short".to_vec();

+    let theirs = b"considerably longer bytes".to_vec();

+    let report = diff_macho(&ours, &theirs);

+    assert!(!report.is_clean());

+    assert!(report.critical[0].reason.contains("size differs"));

+}

+//! Two identical byte slices must produce zero critical diffs.

+

+mod common;

+

+use common::harness::diff_macho;

+

+#[test]

+fn identical_inputs_produce_zero_critical_diffs() {

+    let a = b"same bytes everywhere".to_vec();

+    let b = a.clone();

+    let report = diff_macho(&a, &b);

+    assert!(

+        report.is_clean(),

+        "identical inputs produced critical diffs: {:#?}",

+        report.critical

+    );

+    assert!(report.tolerated.is_empty());

+}

+//! Running afs-ld with no inputs must produce the exact diagnostic line

+//! `afs-ld: error: no input files` on stderr and exit with code 2.

+//!

+//! The CLI surface grows over the next sprints but this invariant is the

+//! baseline every later change must preserve.

+

+use std::process::Command;

+

+#[test]

+fn empty_invocation_produces_no_input_files_diagnostic() {

+    let exe = env!("CARGO_BIN_EXE_afs-ld");

+    let out = Command::new(exe)

+        .output()

+        .expect("afs-ld binary should exist and be executable");

+

+    assert!(!out.status.success(), "afs-ld should fail on empty input");

+    assert_eq!(

+        out.status.code(),

+        Some(2),

+        "empty-input exit code must be 2 (CLI misuse / missing input)"

+    );

+

+    let stderr = String::from_utf8_lossy(&out.stderr);

+    assert!(

+        stderr.contains("afs-ld: error: no input files"),

+        "expected the `no input files` diagnostic on stderr; got: {stderr}"

+    );

+}