gemba 0.1.1 → 0.2.1

data/test/test_rom_patcher.rb

@@ -0,0 +1,383 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "zlib"
+require "stringio"
+
+# Bootstrap Zeitwerk autoloading without Tk/SDL2.
+require_relative "../lib/gemba/headless"
+
+class TestRomPatcher < Minitest::Test
+
+  # ---------------------------------------------------------------------------
+  # Fixture helpers — build valid binary patch data in-memory
+  # ---------------------------------------------------------------------------
+
+  # Build a minimal IPS patch that applies the given records.
+  # records: [{offset:, data:}] or [{offset:, rle_count:, rle_val:}]
+  def build_ips(records)
+    io = StringIO.new.tap { |s| s.binmode }
+    io.write("PATCH")
+    records.each do |rec|
+      off = rec[:offset]
+      io.write([off >> 16, (off >> 8) & 0xFF, off & 0xFF].pack("CCC"))
+      if rec[:rle_count]
+        io.write([0, rec[:rle_count]].pack("nn"))
+        io.write([rec[:rle_val]].pack("C"))
+      else
+        io.write([rec[:data].bytesize].pack("n"))
+        io.write(rec[:data].b)
+      end
+    end
+    io.write("EOF")
+    io.string.b
+  end
+
+  # Encode a BPS varint (byuu's additive-shift encoding).
+  def bps_varint(n)
+    out = "".b
+    loop do
+      x = n & 0x7f
+      n >>= 7
+      if n == 0
+        out << (0x80 | x).chr
+        break
+      end
+      out << x.chr
+      n -= 1
+    end
+    out
+  end
+
+  # Build a BPS patch using only TargetRead records (writes literal target data).
+  # Simplest valid BPS: ignores source entirely, just emits target bytes.
+  def build_bps(source, target)
+    source = source.b
+    target = target.b
+    body = StringIO.new.tap { |s| s.binmode }
+    body.write("BPS1")
+    body.write(bps_varint(source.bytesize))
+    body.write(bps_varint(target.bytesize))
+    body.write(bps_varint(0))           # metadata_size = 0
+    # One TargetRead record covering the entire target
+    word = ((target.bytesize - 1) << 2) | 1
+    body.write(bps_varint(word))
+    body.write(target)
+    payload = body.string.b
+    src_crc   = Zlib.crc32(source)
+    tgt_crc   = Zlib.crc32(target)
+    patch_crc = Zlib.crc32(payload)
+    payload + [src_crc, tgt_crc, patch_crc].pack("VVV")
+  end
+
+  # Encode a UPS varint (additive-shift encoding with continuation bias).
+  def ups_varint(n)
+    out = "".b
+    loop do
+      x = n & 0x7f
+      n >>= 7
+      if n == 0
+        out << (0x80 | x).chr
+        break
+      end
+      out << x.chr
+      n -= 1
+    end
+    out
+  end
+
+  # Build a UPS patch from source → target.
+  def build_ups(source, target)
+    source = source.b
+    target = target.b
+    max_size = [source.bytesize, target.bytesize].max
+
+    # Collect diff hunks: each is {start:, xor_bytes:}
+    hunks = []
+    i = 0
+    while i < max_size
+      s = source.getbyte(i) || 0
+      t = target.getbyte(i) || 0
+      if s != t
+        hunk_start = i
+        xor_bytes  = "".b
+        while i < max_size
+          s = source.getbyte(i) || 0
+          t = target.getbyte(i) || 0
+          break if s == t
+          xor_bytes << (s ^ t).chr
+          i += 1
+        end
+        hunks << { start: hunk_start, xor_bytes: xor_bytes }
+      else
+        i += 1
+      end
+    end
+
+    # Build body
+    body = StringIO.new.tap { |s| s.binmode }
+    body.write("UPS1")
+    body.write(ups_varint(source.bytesize))
+    body.write(ups_varint(target.bytesize))
+
+    pos = 0
+    hunks.each do |h|
+      skip = h[:start] - pos
+      body.write(ups_varint(skip))
+      body.write(h[:xor_bytes])
+      body.write("\x00")
+      pos = h[:start] + h[:xor_bytes].bytesize + 1
+    end
+
+    payload = body.string.b
+    src_crc   = Zlib.crc32(source)
+    tgt_crc   = Zlib.crc32(target)
+    patch_crc = Zlib.crc32(payload)
+    payload + [src_crc, tgt_crc, patch_crc].pack("VVV")
+  end
+
+  # A small fake ROM — 64 zero bytes, like a blank cartridge header area.
+  def blank_rom(size = 64)
+    "\x00".b * size
+  end
+
+  # ---------------------------------------------------------------------------
+  # RomPatcher (dispatcher)
+  # ---------------------------------------------------------------------------
+
+  def test_detect_format_ips
+    patch = "PATCH" + "EOF"
+    assert_equal :ips, Gemba::RomPatcher.detect_format(patch)
+  end
+
+  def test_detect_format_bps
+    patch = "BPS1\x00"
+    assert_equal :bps, Gemba::RomPatcher.detect_format(patch)
+  end
+
+  def test_detect_format_ups
+    patch = "UPS1\x00"
+    assert_equal :ups, Gemba::RomPatcher.detect_format(patch)
+  end
+
+  def test_detect_format_unknown
+    assert_nil Gemba::RomPatcher.detect_format("JUNK")
+  end
+
+  def test_safe_out_path_no_collision
+    path = "/tmp/nonexistent_gemba_test_#{Process.pid}.gba"
+    assert_equal path, Gemba::RomPatcher.safe_out_path(path)
+  end
+
+  def test_safe_out_path_collision
+    Dir.mktmpdir do |dir|
+      base = File.join(dir, "game.gba")
+      File.write(base, "x")
+      result = Gemba::RomPatcher.safe_out_path(base)
+      assert_equal File.join(dir, "game-(2).gba"), result
+    end
+  end
+
+  def test_safe_out_path_multiple_collisions
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "game.gba"),     "x")
+      File.write(File.join(dir, "game-(2).gba"), "x")
+      result = Gemba::RomPatcher.safe_out_path(File.join(dir, "game.gba"))
+      assert_equal File.join(dir, "game-(3).gba"), result
+    end
+  end
+
+  def test_patch_dispatches_to_ips
+    Dir.mktmpdir do |dir|
+      rom_path   = File.join(dir, "rom.gba")
+      patch_path = File.join(dir, "fix.ips")
+      out_path   = File.join(dir, "rom-patched.gba")
+
+      source = blank_rom
+      File.binwrite(rom_path, source)
+      File.binwrite(patch_path, build_ips([{ offset: 0, data: "\xFF\xFE\xFD\xFC" }]))
+
+      Gemba::RomPatcher.patch(rom_path: rom_path, patch_path: patch_path, out_path: out_path)
+      result = File.binread(out_path)
+      assert_equal "\xFF".b, result[0, 1]
+      assert_equal "\xFE".b, result[1, 1]
+    end
+  end
+
+  def test_patch_raises_on_unknown_format
+    Dir.mktmpdir do |dir|
+      File.binwrite(File.join(dir, "rom.gba"),   "X" * 16)
+      File.binwrite(File.join(dir, "bad.xyz"),   "JUNK")
+      assert_raises(RuntimeError) do
+        Gemba::RomPatcher.patch(
+          rom_path:   File.join(dir, "rom.gba"),
+          patch_path: File.join(dir, "bad.xyz"),
+          out_path:   File.join(dir, "out.gba")
+        )
+      end
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # IPS
+  # ---------------------------------------------------------------------------
+
+  def test_ips_overwrites_bytes_at_offset
+    source = blank_rom
+    patch  = build_ips([{ offset: 4, data: "\xFF\xFE\xFD" }])
+    result = Gemba::RomPatcher::IPS.apply(source, patch)
+    assert_equal "\x00".b * 4, result[0, 4], "bytes before offset unchanged"
+    assert_equal "\xFF\xFE\xFD".b, result[4, 3], "patch bytes applied"
+    assert_equal "\x00".b, result[7, 1], "bytes after patch unchanged"
+  end
+
+  def test_ips_rle_record_fills_region
+    source = blank_rom
+    patch  = build_ips([{ offset: 8, rle_count: 4, rle_val: 0xAB }])
+    result = Gemba::RomPatcher::IPS.apply(source, patch)
+    assert_equal "\xAB".b * 4, result[8, 4]
+    assert_equal "\x00".b, result[7, 1], "byte before RLE unchanged"
+    assert_equal "\x00".b, result[12, 1], "byte after RLE unchanged"
+  end
+
+  def test_ips_multiple_records
+    source = blank_rom
+    patch  = build_ips([
+      { offset: 0,  data: "\x01\x02" },
+      { offset: 10, data: "\x03\x04" },
+    ])
+    result = Gemba::RomPatcher::IPS.apply(source, patch)
+    assert_equal "\x01\x02".b, result[0, 2]
+    assert_equal "\x03\x04".b, result[10, 2]
+  end
+
+  def test_ips_extends_rom_if_patch_exceeds_size
+    source = "\x00".b * 4
+    patch  = build_ips([{ offset: 8, data: "\xFF\xFF" }])
+    result = Gemba::RomPatcher::IPS.apply(source, patch)
+    assert result.bytesize >= 10, "ROM extended to fit patch"
+    assert_equal "\xFF\xFF".b, result[8, 2]
+  end
+
+  def test_ips_empty_patch_returns_rom_unchanged
+    source = "HELLO".b
+    patch  = build_ips([])
+    result = Gemba::RomPatcher::IPS.apply(source, patch)
+    assert_equal source, result
+  end
+
+  # ---------------------------------------------------------------------------
+  # BPS
+  # ---------------------------------------------------------------------------
+
+  def test_bps_target_read_produces_correct_output
+    source = blank_rom(8)
+    target = "\x11\x22\x33\x44\x55\x66\x77\x88".b
+    patch  = build_bps(source, target)
+    result = Gemba::RomPatcher::BPS.apply(source, patch)
+    assert_equal target, result
+  end
+
+  def test_bps_crc_mismatch_raises
+    source = blank_rom(8)
+    target = "\xDE\xAD\xBE\xEF\x00\x00\x00\x00".b
+    patch  = build_bps(source, target)
+    # Corrupt the source CRC (bytes -12..-9)
+    bad_patch = patch.dup.b
+    bad_patch[-12] = "\xFF".b
+    err = assert_raises(RuntimeError) { Gemba::RomPatcher::BPS.apply(source, bad_patch) }
+    assert_match(/CRC32/, err.message)
+  end
+
+  def test_bps_identical_source_and_target
+    source = "GEMBA".b
+    target = "GEMBA".b
+    patch  = build_bps(source, target)
+    result = Gemba::RomPatcher::BPS.apply(source, patch)
+    assert_equal target, result
+  end
+
+  # ---------------------------------------------------------------------------
+  # UPS
+  # ---------------------------------------------------------------------------
+
+  def test_ups_xors_differing_bytes
+    source = "\x00\x00\x00\x00".b
+    target = "\xFF\x00\xFF\x00".b
+    patch  = build_ups(source, target)
+    result = Gemba::RomPatcher::UPS.apply(source, patch)
+    assert_equal target, result
+  end
+
+  def test_ups_multiple_hunks
+    source = "\x00" * 16
+    target = source.dup.b
+    target.setbyte(0,  0xAA)
+    target.setbyte(8,  0xBB)
+    target.setbyte(15, 0xCC)
+    patch  = build_ups(source.b, target)
+    result = Gemba::RomPatcher::UPS.apply(source.b, patch)
+    assert_equal target, result
+  end
+
+  def test_ups_crc_mismatch_raises
+    source = blank_rom(8)
+    target = "\xCA\xFE\xBA\xBE\x00\x00\x00\x00".b
+    patch  = build_ups(source, target)
+    bad_patch = patch.dup.b
+    bad_patch[-12] = "\x00".b
+    bad_patch[-11] = "\x00".b
+    err = assert_raises(RuntimeError) { Gemba::RomPatcher::UPS.apply(source, bad_patch) }
+    assert_match(/CRC32/, err.message)
+  end
+
+  def test_ups_identical_source_and_target
+    source = "GEMBA\x00\x00\x00".b
+    target = source.dup
+    patch  = build_ups(source, target)
+    result = Gemba::RomPatcher::UPS.apply(source, patch)
+    assert_equal target, result
+  end
+
+  def test_ups_pads_target_when_source_is_shorter
+    # target_size > source_size — result zero-pads to target_size
+    source = "\x01\x02".b
+    target = "\x01\x03\x00\x00".b  # byte 1 differs; bytes 2-3 are 0 (matching padding)
+    patch  = build_ups(source, target)
+    result = Gemba::RomPatcher::UPS.apply(source, patch)
+    assert_equal target, result
+  end
+
+  # ---------------------------------------------------------------------------
+  # ZIP ROM input
+  # ---------------------------------------------------------------------------
+
+  def test_patch_with_zip_rom_produces_gba_output
+    require 'zip'
+    dir = Dir.mktmpdir
+    begin
+      # Build a tiny ROM and wrap it in a zip
+      rom_data   = blank_rom
+      zip_path   = File.join(dir, "game.zip")
+      patch_path = File.join(dir, "fix.ips")
+      out_path   = File.join(dir, "game-patched.gba")
+
+      Zip::OutputStream.open(zip_path) do |zos|
+        zos.put_next_entry("game.gba")
+        zos.write(rom_data)
+      end
+
+      File.binwrite(patch_path, build_ips([{ offset: 0, data: "\xFF\xFE" }]))
+
+      resolved = Gemba::RomResolver.resolve(zip_path)
+      Gemba::RomPatcher.patch(rom_path: resolved, patch_path: patch_path, out_path: out_path)
+
+      assert File.exist?(out_path), "expected output at #{out_path}"
+      assert_equal ".gba", File.extname(out_path)
+      assert_equal "\xFF".b, File.binread(out_path, 1)
+    ensure
+      # Windows may still hold the zip file handle until GC — ignore EACCES on cleanup
+      FileUtils.remove_entry(dir) rescue nil
+    end
+  end
+end

data/test/{test_rom_loader.rb → test_rom_resolver.rb}

@@ -5,40 +5,39 @@ require "gemba"
 require "tmpdir"
 require "zip"
 
-class TestRomLoader < Minitest::Test
+class TestRomResolver < Minitest::Test
   TEST_ROM = File.expand_path("fixtures/test.gba", __dir__)
 
   def setup
-    skip "Run: ruby gemba/scripts/generate_test_rom.rb" unless File.exist?(TEST_ROM)
     @tmpdir = Dir.mktmpdir("rom_loader_test")
   end
 
   def teardown
     FileUtils.rm_rf(@tmpdir) if @tmpdir && File.directory?(@tmpdir)
-    Gemba::RomLoader.cleanup_temp
+    Gemba::RomResolver.cleanup_temp
   end
 
   # -- resolve passthrough --
 
   def test_resolve_gba_returns_path_unchanged
-    assert_equal TEST_ROM, Gemba::RomLoader.resolve(TEST_ROM)
+    assert_equal TEST_ROM, Gemba::RomResolver.resolve(TEST_ROM)
   end
 
   def test_resolve_gb_returns_path_unchanged
     path = "/some/game.gb"
-    assert_equal path, Gemba::RomLoader.resolve(path)
+    assert_equal path, Gemba::RomResolver.resolve(path)
   end
 
   def test_resolve_gbc_returns_path_unchanged
     path = "/some/game.gbc"
-    assert_equal path, Gemba::RomLoader.resolve(path)
+    assert_equal path, Gemba::RomResolver.resolve(path)
   end
 
   # -- resolve from zip --
 
   def test_resolve_zip_extracts_rom
     zip_path = create_zip("game.zip", "game.gba" => File.binread(TEST_ROM))
-    result = Gemba::RomLoader.resolve(zip_path)
+    result = Gemba::RomResolver.resolve(zip_path)
 
     assert File.exist?(result), "extracted ROM should exist"
     assert_equal ".gba", File.extname(result).downcase
@@ -47,7 +46,7 @@ class TestRomLoader < Minitest::Test
 
   def test_resolve_zip_loads_in_core
     zip_path = create_zip("game.zip", "game.gba" => File.binread(TEST_ROM))
-    rom_path = Gemba::RomLoader.resolve(zip_path)
+    rom_path = Gemba::RomResolver.resolve(zip_path)
 
     core = Gemba::Core.new(rom_path)
     assert_equal "GEMBATEST", core.title
@@ -60,8 +59,8 @@ class TestRomLoader < Minitest::Test
   def test_resolve_zip_no_rom_raises
     zip_path = create_zip("empty.zip", "readme.txt" => "hello")
 
-    err = assert_raises(Gemba::RomLoader::NoRomInZip) do
-      Gemba::RomLoader.resolve(zip_path)
+    err = assert_raises(Gemba::RomResolver::NoRomInZip) do
+      Gemba::RomResolver.resolve(zip_path)
     end
     assert_includes err.message, "empty.zip"
   end
@@ -72,15 +71,15 @@ class TestRomLoader < Minitest::Test
       "game1.gba" => rom_data,
       "game2.gba" => rom_data)
 
-    err = assert_raises(Gemba::RomLoader::MultipleRomsInZip) do
-      Gemba::RomLoader.resolve(zip_path)
+    err = assert_raises(Gemba::RomResolver::MultipleRomsInZip) do
+      Gemba::RomResolver.resolve(zip_path)
     end
     assert_includes err.message, "multi.zip"
   end
 
   def test_resolve_unsupported_extension_raises
-    assert_raises(Gemba::RomLoader::UnsupportedFormat) do
-      Gemba::RomLoader.resolve("/some/file.rar")
+    assert_raises(Gemba::RomResolver::UnsupportedFormat) do
+      Gemba::RomResolver.resolve("/some/file.rar")
     end
   end
 
@@ -88,8 +87,8 @@ class TestRomLoader < Minitest::Test
     corrupt = File.join(@tmpdir, "corrupt.zip")
     File.binwrite(corrupt, "this is not a zip file")
 
-    assert_raises(Gemba::RomLoader::ZipReadError) do
-      Gemba::RomLoader.resolve(corrupt)
+    assert_raises(Gemba::RomResolver::ZipReadError) do
+      Gemba::RomResolver.resolve(corrupt)
     end
   end
 
@@ -102,32 +101,32 @@ class TestRomLoader < Minitest::Test
       zos.write(File.binread(TEST_ROM))
     end
 
-    assert_raises(Gemba::RomLoader::NoRomInZip) do
-      Gemba::RomLoader.resolve(zip_path)
+    assert_raises(Gemba::RomResolver::NoRomInZip) do
+      Gemba::RomResolver.resolve(zip_path)
     end
   end
 
   # -- constants --
 
   def test_rom_extensions
-    assert_includes Gemba::RomLoader::ROM_EXTENSIONS, ".gba"
-    assert_includes Gemba::RomLoader::ROM_EXTENSIONS, ".gb"
-    assert_includes Gemba::RomLoader::ROM_EXTENSIONS, ".gbc"
+    assert_includes Gemba::RomResolver::ROM_EXTENSIONS, ".gba"
+    assert_includes Gemba::RomResolver::ROM_EXTENSIONS, ".gb"
+    assert_includes Gemba::RomResolver::ROM_EXTENSIONS, ".gbc"
   end
 
   def test_supported_extensions_includes_zip
-    assert_includes Gemba::RomLoader::SUPPORTED_EXTENSIONS, ".zip"
+    assert_includes Gemba::RomResolver::SUPPORTED_EXTENSIONS, ".zip"
   end
 
   # -- cleanup --
 
   def test_cleanup_temp_removes_directory
     zip_path = create_zip("game.zip", "game.gba" => File.binread(TEST_ROM))
-    Gemba::RomLoader.resolve(zip_path)
-    assert File.directory?(Gemba::RomLoader.tmp_dir)
+    Gemba::RomResolver.resolve(zip_path)
+    assert File.directory?(Gemba::RomResolver.tmp_dir)
 
-    Gemba::RomLoader.cleanup_temp
-    refute File.directory?(Gemba::RomLoader.tmp_dir)
+    Gemba::RomResolver.cleanup_temp
+    refute File.directory?(Gemba::RomResolver.tmp_dir)
   end
 
   private

data/test/test_save_state_manager.rb

@@ -3,9 +3,7 @@
 require "minitest/autorun"
 require "tmpdir"
 require "json"
-require_relative "../lib/gemba/config"
-require_relative "../lib/gemba/locale"
-require_relative "../lib/gemba/save_state_manager"
+require "gemba/headless"
 
 class TestSaveStateManager < Minitest::Test
   # Recording mock for the mGBA Core.
@@ -92,7 +90,7 @@ class TestSaveStateManager < Minitest::Test
   end
 
   def new_manager(core: @core, config: @config, app: @app)
-    mgr = Gemba::SaveStateManager.new(core: core, config: config, app: app)
+    mgr = Gemba::SaveStateManager.new(core: core, config: config, app: app, platform: Gemba::Platform.default)
     mgr.state_dir = mgr.state_dir_for_rom(core)
     mgr
   end

data/test/test_settings_audio.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "shared/tk_test_helper"
+
+class TestSettingsAudioTab < Minitest::Test
+  include TeekTestHelper
+
+  # -- Volume slider ------------------------------------------------------
+
+  def test_volume_defaults_to_100
+    assert_tk_app("volume defaults to 100") do
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      assert_equal '100', app.get_variable(Gemba::Settings::AudioTab::VAR_VOLUME)
+    end
+  end
+
+  def test_dragging_volume_to_50_fires_callback
+    assert_tk_app("dragging volume to 50 fires on_volume_change") do
+      require "gemba/headless"
+      received = nil
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:volume_changed) { |v| received = v }
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      # Simulate user dragging volume slider to 50
+      app.command(Gemba::Settings::AudioTab::VOLUME_SCALE, 'set', 50)
+      app.update
+
+      assert_in_delta 0.5, received, 0.01
+    end
+  end
+
+  def test_volume_at_zero
+    assert_tk_app("volume at zero") do
+      require "gemba/headless"
+      received = nil
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:volume_changed) { |v| received = v }
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      app.command(Gemba::Settings::AudioTab::VOLUME_SCALE, 'set', 0)
+      app.update
+
+      assert_in_delta 0.0, received, 0.01
+    end
+  end
+
+  # -- Mute checkbox ------------------------------------------------------
+
+  def test_mute_defaults_to_off
+    assert_tk_app("mute defaults to off") do
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      assert_equal '0', app.get_variable(Gemba::Settings::AudioTab::VAR_MUTE)
+    end
+  end
+
+  def test_clicking_mute_fires_callback
+    assert_tk_app("clicking mute fires on_mute_change") do
+      require "gemba/headless"
+      received = nil
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:mute_changed) { |m| received = m }
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      # Simulate user clicking the mute checkbox
+      app.command(Gemba::Settings::AudioTab::MUTE_CHECK, 'invoke')
+      app.update
+
+      assert_equal true, received
+    end
+  end
+
+  def test_clicking_mute_twice_unmutes
+    assert_tk_app("clicking mute twice unmutes") do
+      require "gemba/headless"
+      received = nil
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:mute_changed) { |m| received = m }
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      app.command(Gemba::Settings::AudioTab::MUTE_CHECK, 'invoke')
+      app.update
+      assert_equal true, received
+
+      app.command(Gemba::Settings::AudioTab::MUTE_CHECK, 'invoke')
+      app.update
+      assert_equal false, received
+    end
+  end
+end