make patch not use source file header, add tests to confirm patches work

Author: kirjavascript

tests/Cargo.lock

@@ -7,3 +7,8 @@ edition = "2021"
 gumdrop = "0.8.1"
 rusticnes-core = { git = "https://github.com/zeta0134/rusticnes-core.git", version = "0.2.0" }
 minifb = "0.25"
+
+# for patch testing
+flips = "0.2.1"
+flips-sys = "0.2.1"
+md5 = "0.7.0"

tests/Cargo.toml

@@ -20,6 +20,7 @@ mod tspins;
 mod hz_display;
 mod nmi;
 mod constants;
+mod patch;
 
 use gumdrop::Options;
 
@@ -50,7 +51,7 @@ struct TestOptions {
 fn main() {
     let options = TestOptions::parse_args_default_or_exit();
 
-    let tests: [(&str, fn()); 14] = [
+    let tests: [(&str, fn()); 15] = [
         ("garbage4", garbage::test_garbage4_crash),
         ("floor", floor::test),
         ("tspins", tspins::test),
@@ -65,6 +66,7 @@ fn main() {
         ("hz_display", hz_display::test),
         ("nmi", nmi::test),
         ("constants", constants::test),
+        ("patch", patch::test),
     ];
 
     // run tests

tests/src/main.rs

@@ -0,0 +1,45 @@
+pub fn test() {
+    let clean = include_bytes!("../../clean.nes");
+    let patch = include_bytes!("../../tetris.bps");
+
+    // check original file hasn't changed
+    assert_eq!("ec58574d96bee8c8927884ae6e7a2508", format!("{:x}", md5::compute(clean)));
+
+    // check patch produces the final ROM
+    let output = flips::BpsPatch::new(patch).apply(clean)
+        .expect("could not apply patch");
+
+    assert_eq!(output.as_bytes(), crate::util::ROM);
+
+    // check NES2.0 files work
+    let mut clean2 = Vec::new();
+    clean2.extend([0x4e,0x45,0x53,0x1a,0x02,0x02,0x10,0x08,0x50,0x00,0x00,0x07,0x00,0x00,0x00,0x00]);
+    clean2.extend(&clean[0x10..]);
+
+    assert_eq!("204c0f64d291737e23c0345b59cf1c05", format!("{:x}", md5::compute(clean2.clone())));
+
+    let result = {
+        let slice_p = patch.as_ref();
+        let slice_s: &[u8] = clean2.as_ref();
+        let mut mem_m = flips_sys::mem::default();
+        let mut mem_o = flips_sys::mem::default();
+
+        let _result = unsafe {
+            let mem_i = flips_sys::mem::new(slice_s.as_ptr() as *mut _, slice_s.len());
+            let mem_p = flips_sys::mem::new(slice_p.as_ptr() as *mut _, slice_p.len());
+            flips_sys::bps::bps_apply(mem_p, mem_i, &mut mem_o as *mut _, &mut mem_m as *mut _, true)
+        };
+
+        mem_o.to_owned()
+    };
+
+    let mut invalid_indices = Vec::new();
+
+    for (i, v) in result.as_ref().iter().enumerate() {
+        if v != &crate::util::ROM[i] {
+            invalid_indices.push(i);
+        }
+    }
+
+    assert_eq!(invalid_indices, Vec::new());
+}

tests/src/patch.rs

@@ -2,7 +2,7 @@ use rusticnes_core::nes::NesState;
 use rusticnes_core::{ cartridge, opcodes, opcode_info };
 use crate::{input, labels};
 
-static ROM: &'static [u8] = include_bytes!("../../tetris.nes");
+pub static ROM: &'static [u8] = include_bytes!("../../tetris.nes");
 
 pub fn rom_data() -> &'static [u8] {
     &ROM[0x10..]

tests/src/util.rs

@@ -1,26 +1,64 @@
-const { MarcFile, createBPSFromFiles, parseBPSFile } = require('./bps.js');
+const {
+    MarcFile,
+    createBPSFromFiles,
+    parseBPSFile,
+    crc32,
+} = require('./bps.js');
 const fs = require('fs');
 
 // https://github.com/blakesmith/rombp/blob/master/docs/bps_spec.md
 
 module.exports = function patch(original, modified, destination) {
-    const patch = createBPSFromFiles(
-        new MarcFile(original),
-        new MarcFile(modified),
-        true,
-    ).export('');
+    const originalFile = new MarcFile(original);
+    const modifiedFile = new MarcFile(modified);
+    const patch = createBPSFromFiles(originalFile, modifiedFile, true);
 
-    fs.writeFileSync(destination, patch._u8array);
+    // post-process BPS so that header bytes are ignored
+
+    let outputOffset = 0;
+
+    patch.actions.forEach((action) => {
+        if (action.type === 0) {
+            let { length } = action;
+
+            let usesHeader = false;
+            for (let i = 0; length--; i++) {
+                if (outputOffset + i < 0x10) {
+                    usesHeader = true;
+                    break;
+                }
+            }
+
+            if (usesHeader) {
+                action.type = 1;
+                action.bytes = Array.from(
+                    modifiedFile._u8array.slice(
+                        outputOffset,
+                        outputOffset + action.length,
+                    ),
+                );
+            }
+
+            outputOffset += action.length;
+        } else {
+            outputOffset += action.length;
+        }
+    });
+
+    // reapply the checksum
+    patch.patchChecksum = crc32(patch.export(), 0, true);
+
+    fs.writeFileSync(destination, patch.export()._u8array);
 
     const bps = parseBPSFile(new MarcFile('tetris.bps'));
 
     // count patch sizes
     let source = 0;
-    bps.actions.forEach(action => {
+    bps.actions.forEach((action) => {
         if ([0, 2].includes(action.type)) {
             source += action.length;
         }
     });
 
-    return (source / bps.sourceSize) * 100 | 0;
-}
+    return ((source / bps.sourceSize) * 100) | 0;
+};