gemba 0.1.1 → 0.2.0

data/test/test_help_window.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "shared/tk_test_helper"
+
+class TestHelpWindow < Minitest::Test
+  include TeekTestHelper
+
+  # HelpWindow is wm transient to '.'. The TestWorker withdraws '.' after each
+  # test, so a transient child can't be shown unless we deiconify '.' first.
+  # app.show deiconifies the root window for tests that check visibility.
+
+  def test_visible_after_show
+    assert_tk_app("help window is visible after show") do
+      require "gemba/headless"
+
+      hotkeys = Struct.new(:m) { def key_for(a) = Gemba::HotkeyMap::DEFAULTS[a] }.new(nil)
+      win = Gemba::HelpWindow.new(app: app, hotkeys: hotkeys)
+      app.show
+      win.show
+      app.update  # flush pending Tk map events before checking visibility
+
+      assert win.visible?, "help window should be visible after show"
+
+      win.hide
+      app.command(:destroy, Gemba::HelpWindow::TOP) rescue nil
+    end
+  end
+
+  def test_hidden_after_hide
+    assert_tk_app("help window is hidden after hide") do
+      require "gemba/headless"
+
+      hotkeys = Struct.new(:m) { def key_for(a) = Gemba::HotkeyMap::DEFAULTS[a] }.new(nil)
+      win = Gemba::HelpWindow.new(app: app, hotkeys: hotkeys)
+      app.show
+      win.show
+      win.hide
+
+      refute win.visible?, "help window should not be visible after hide"
+
+      app.command(:destroy, Gemba::HelpWindow::TOP) rescue nil
+    end
+  end
+
+  def test_rows_show_action_labels
+    assert_tk_app("help window rows show translated action labels") do
+      require "gemba/headless"
+
+      hotkeys = Struct.new(:m) { def key_for(a) = Gemba::HotkeyMap::DEFAULTS[a] }.new(nil)
+      win = Gemba::HelpWindow.new(app: app, hotkeys: hotkeys)
+      win.show
+
+      text = app.command("#{Gemba::HelpWindow::TOP}.f.row_pause.act", :cget, '-text')
+      assert_equal 'Pause', text, "pause row should show 'Pause' label"
+
+      win.hide
+      app.command(:destroy, Gemba::HelpWindow::TOP) rescue nil
+    end
+  end
+
+  def test_rows_show_key_display
+    assert_tk_app("help window rows show formatted key names") do
+      require "gemba/headless"
+
+      hotkeys = Struct.new(:m) { def key_for(a) = Gemba::HotkeyMap::DEFAULTS[a] }.new(nil)
+      win = Gemba::HelpWindow.new(app: app, hotkeys: hotkeys)
+      win.show
+
+      # pause default is 'p'
+      text = app.command("#{Gemba::HelpWindow::TOP}.f.row_pause.key", :cget, '-text')
+      assert_equal 'p', text, "pause row key should show 'p'"
+
+      # quick_save default is 'F5'
+      text = app.command("#{Gemba::HelpWindow::TOP}.f.row_quick_save.key", :cget, '-text')
+      assert_equal 'F5', text, "quick_save row key should show 'F5'"
+
+      win.hide
+      app.command(:destroy, Gemba::HelpWindow::TOP) rescue nil
+    end
+  end
+end

data/test/test_hotkey_map.rb

@@ -29,7 +29,7 @@ end
 
 class TestHotkeyMap < Minitest::Test
   def setup
-    require "gemba/hotkey_map"
+    require "gemba/headless"
   end
 
   def make_map(hotkey_data = {})
@@ -393,4 +393,25 @@ class TestHotkeyMap < Minitest::Test
     map, = make_map
     assert_equal :record, map.action_for('F10')
   end
+
+  # -- Open ROM action -------------------------------------------------------
+
+  def test_open_rom_in_actions
+    assert_includes Gemba::HotkeyMap::ACTIONS, :open_rom
+  end
+
+  def test_open_rom_default_is_ctrl_o
+    map, = make_map
+    assert_equal ['Control', 'o'], map.key_for(:open_rom)
+  end
+
+  def test_open_rom_dispatches_on_ctrl_o
+    map, = make_map
+    assert_equal :open_rom, map.action_for('o', modifiers: Set.new(['Control']))
+  end
+
+  def test_open_rom_plain_o_does_not_dispatch
+    map, = make_map
+    assert_nil map.action_for('o')
+  end
 end

data/test/test_input_recorder.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/headless"
+require "tmpdir"
+
+class TestInputRecorder < Minitest::Test
+  TEST_ROM = File.expand_path("fixtures/test.gba", __dir__)
+
+
+  # -- Lifecycle ---------------------------------------------------------------
+
+  def test_start_and_stop
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.gir")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        rec = Gemba::InputRecorder.new(path, core: player.core)
+        refute rec.recording?
+        rec.start
+        assert rec.recording?
+        rec.capture(0)
+        rec.stop
+        refute rec.recording?
+      end
+
+      assert File.exist?(path)
+    end
+  end
+
+  def test_double_start_raises
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.gir")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        rec = Gemba::InputRecorder.new(path, core: player.core)
+        rec.start
+        assert_raises(RuntimeError) { rec.start }
+        rec.stop
+      end
+    end
+  end
+
+  def test_stop_without_start_is_safe
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.gir")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        rec = Gemba::InputRecorder.new(path, core: player.core)
+        rec.stop # should not raise
+      end
+    end
+  end
+
+  # -- Anchor state ------------------------------------------------------------
+
+  def test_anchor_state_created
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.gir")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        player.step(10) # advance so state has content
+        rec = Gemba::InputRecorder.new(path, core: player.core)
+        rec.start
+        rec.capture(0)
+        rec.stop
+
+        state_path = path.sub(/\.gir\z/, '.state')
+        assert File.exist?(state_path), "anchor .state file should exist"
+        assert_operator File.size(state_path), :>, 0
+      end
+    end
+  end
+
+  # -- Header ------------------------------------------------------------------
+
+  def test_header_format
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.gir")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        core = player.core
+        rec = Gemba::InputRecorder.new(path, core: core)
+        rec.start
+        rec.capture(0)
+        rec.stop
+
+        lines = File.readlines(path)
+        assert_match(/^# GEMBA INPUT RECORDING v1$/, lines[0])
+        assert_match(/^# rom_checksum: \d+$/, lines[1])
+        assert_match(/^# game_code: .+$/, lines[2])
+        assert_match(/^# frame_count: \d+$/, lines[3])
+        assert_match(/^# anchor_state: .+\.state$/, lines[4])
+        assert_equal "---\n", lines[5]
+      end
+    end
+  end
+
+  def test_header_frame_count_updated_on_clean_stop
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.gir")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        rec = Gemba::InputRecorder.new(path, core: player.core)
+        rec.start
+        5.times { |i| rec.capture(i) }
+        rec.stop
+
+        lines = File.readlines(path)
+        assert_equal "# frame_count: 0000000005\n", lines[3]
+      end
+    end
+  end
+
+  # -- Bitmask data ------------------------------------------------------------
+
+  def test_captures_correct_bitmasks
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.gir")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        rec = Gemba::InputRecorder.new(path, core: player.core)
+        rec.start
+        rec.capture(0x000)                          # nothing
+        rec.capture(Gemba::KEY_A)                   # 0x001
+        rec.capture(Gemba::KEY_UP | Gemba::KEY_A)   # 0x041
+        rec.capture(0x3FF)                          # all buttons
+        rec.stop
+
+        lines = File.readlines(path)
+        bitmasks = lines[6..] # after header (6 lines: 5 header + ---)
+        assert_equal "000\n", bitmasks[0]
+        assert_equal "001\n", bitmasks[1]
+        assert_equal "041\n", bitmasks[2]
+        assert_equal "3ff\n", bitmasks[3]
+        assert_equal 4, rec.frame_count
+      end
+    end
+  end
+
+  def test_bitmask_masked_to_10_bits
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.gir")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        rec = Gemba::InputRecorder.new(path, core: player.core)
+        rec.start
+        rec.capture(0xFFFF) # upper bits should be masked off
+        rec.stop
+
+        lines = File.readlines(path)
+        assert_equal "3ff\n", lines[6]
+      end
+    end
+  end
+
+  # -- Flush behavior ----------------------------------------------------------
+
+  def test_periodic_flush_writes_data
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.gir")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        rec = Gemba::InputRecorder.new(path, core: player.core)
+        rec.start
+
+        # Write exactly FLUSH_INTERVAL frames to trigger a flush
+        Gemba::InputRecorder::FLUSH_INTERVAL.times { rec.capture(0) }
+
+        # File should have data on disk even before stop
+        size_before_stop = File.size(path)
+        assert_operator size_before_stop, :>, 0
+
+        rec.stop
+      end
+    end
+  end
+end

data/test/test_input_replay_determinism.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/headless"
+require "tmpdir"
+
+class TestInputReplayDeterminism < Minitest::Test
+  PONG_ROM = File.expand_path("fixtures/pong.gba", __dir__)
+  TEST_ROM = File.expand_path("fixtures/test.gba", __dir__)
+
+# Record inputs against pong, then replay from anchor state.
+  # Video buffer after replay must match the original recording frame-for-frame.
+  def test_deterministic_replay
+    Dir.mktmpdir do |dir|
+      gir_path = File.join(dir, "pong.gir")
+      frames = 120 # ~2 seconds of gameplay
+
+      # -- Phase 1: Record --
+      final_video = nil
+      Gemba::HeadlessPlayer.open(PONG_ROM) do |player|
+        # Let the game boot for a few frames
+        player.step(30)
+
+        core = player.core
+        rec = Gemba::InputRecorder.new(gir_path, core: core)
+        rec.start
+
+        # Play some inputs: Start to begin, then Up, A, idle, Down+B
+        inputs = []
+        inputs.concat([Gemba::KEY_START] * 30)
+        inputs.concat([Gemba::KEY_UP] * 30)
+        inputs.concat([Gemba::KEY_A] * 30)
+        inputs.concat([0] * 30)
+        inputs.concat([Gemba::KEY_DOWN | Gemba::KEY_B] * 30)
+
+        inputs.each do |mask|
+          rec.capture(mask)
+          core.set_keys(mask)
+          core.run_frame
+        end
+
+        rec.stop
+        final_video = core.video_buffer_argb.dup
+      end
+
+      assert File.exist?(gir_path), ".gir file should exist"
+      assert File.exist?(gir_path.sub(/\.gir\z/, '.state')), ".state file should exist"
+
+      # -- Phase 2: Replay --
+      replay_video = nil
+      Gemba::HeadlessPlayer.open(PONG_ROM) do |player|
+        player.replay(gir_path)
+        replay_video = player.video_buffer_argb.dup
+      end
+
+      # -- Phase 3: Compare --
+      assert_equal final_video.bytesize, replay_video.bytesize,
+        "video buffer sizes should match"
+      assert_equal final_video, replay_video,
+        "video buffer after replay should be identical to recording"
+    end
+  end
+
+  # Replay with the wrong ROM should raise ChecksumMismatch.
+  def test_replay_wrong_rom_raises
+    skip "test.gba fixture missing" unless File.exist?(TEST_ROM)
+
+    Dir.mktmpdir do |dir|
+      gir_path = File.join(dir, "pong.gir")
+
+      # Record against pong
+      Gemba::HeadlessPlayer.open(PONG_ROM) do |player|
+        player.step(5)
+        core = player.core
+        rec = Gemba::InputRecorder.new(gir_path, core: core)
+        rec.start
+        rec.capture(0)
+        rec.stop
+      end
+
+      # Try to replay against test.gba — wrong ROM
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        assert_raises(Gemba::InputReplayer::ChecksumMismatch) do
+          player.replay(gir_path)
+        end
+      end
+    end
+  end
+
+  # Replay with block yields each frame.
+  def test_replay_yields_frames
+    Dir.mktmpdir do |dir|
+      gir_path = File.join(dir, "pong.gir")
+
+      Gemba::HeadlessPlayer.open(PONG_ROM) do |player|
+        player.step(5)
+        core = player.core
+        rec = Gemba::InputRecorder.new(gir_path, core: core)
+        rec.start
+        [0x001, 0x041, 0x000].each { |m| rec.capture(m) }
+        rec.stop
+      end
+
+      collected = []
+      Gemba::HeadlessPlayer.open(PONG_ROM) do |player|
+        player.replay(gir_path) { |mask, idx| collected << [mask, idx] }
+      end
+
+      assert_equal [[0x001, 0], [0x041, 1], [0x000, 2]], collected
+    end
+  end
+end

data/test/test_input_replayer.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/headless"
+require "tmpdir"
+
+class TestInputReplayer < Minitest::Test
+  TEST_ROM = File.expand_path("fixtures/test.gba", __dir__)
+
+
+  # -- Round-trip: record then replay ------------------------------------------
+
+  def test_round_trip_frame_count
+    Dir.mktmpdir do |dir|
+      gir_path = File.join(dir, "test.gir")
+      record(gir_path, [0x000, 0x001, 0x041, 0x3FF])
+
+      replayer = Gemba::InputReplayer.new(gir_path)
+      assert_equal 4, replayer.frame_count
+    end
+  end
+
+  def test_round_trip_bitmasks
+    Dir.mktmpdir do |dir|
+      gir_path = File.join(dir, "test.gir")
+      inputs = [0x000, 0x001, 0x041, 0x3FF]
+      record(gir_path, inputs)
+
+      replayer = Gemba::InputReplayer.new(gir_path)
+      inputs.each_with_index do |expected, i|
+        assert_equal expected, replayer.bitmask_at(i), "frame #{i}"
+      end
+    end
+  end
+
+  def test_each_bitmask
+    Dir.mktmpdir do |dir|
+      gir_path = File.join(dir, "test.gir")
+      inputs = [0x001, 0x041, 0x000]
+      record(gir_path, inputs)
+
+      replayer = Gemba::InputReplayer.new(gir_path)
+      collected = []
+      replayer.each_bitmask { |mask, idx| collected << [mask, idx] }
+
+      assert_equal [[0x001, 0], [0x041, 1], [0x000, 2]], collected
+    end
+  end
+
+  # -- Header parsing ----------------------------------------------------------
+
+  def test_rom_checksum_parsed
+    Dir.mktmpdir do |dir|
+      gir_path = File.join(dir, "test.gir")
+      record(gir_path, [0])
+
+      replayer = Gemba::InputReplayer.new(gir_path)
+      assert_kind_of Integer, replayer.rom_checksum
+      assert_operator replayer.rom_checksum, :>, 0
+    end
+  end
+
+  def test_game_code_parsed
+    Dir.mktmpdir do |dir|
+      gir_path = File.join(dir, "test.gir")
+      record(gir_path, [0])
+
+      replayer = Gemba::InputReplayer.new(gir_path)
+      assert_equal "AGB-BGBE", replayer.game_code
+    end
+  end
+
+  def test_anchor_state_path
+    Dir.mktmpdir do |dir|
+      gir_path = File.join(dir, "test.gir")
+      record(gir_path, [0])
+
+      replayer = Gemba::InputReplayer.new(gir_path)
+      expected = File.join(dir, "test.state")
+      assert_equal expected, replayer.anchor_state_path
+      assert File.exist?(replayer.anchor_state_path)
+    end
+  end
+
+  # -- Validation --------------------------------------------------------------
+
+  def test_validate_passes_with_matching_rom
+    Dir.mktmpdir do |dir|
+      gir_path = File.join(dir, "test.gir")
+      record(gir_path, [0])
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        replayer = Gemba::InputReplayer.new(gir_path)
+        replayer.validate!(player.core)
+        # should not raise
+      end
+    end
+  end
+
+  def test_validate_raises_on_checksum_mismatch
+    Dir.mktmpdir do |dir|
+      gir_path = File.join(dir, "test.gir")
+      # Write a fake .gir with a bogus checksum
+      File.write(gir_path, <<~GIR)
+        # GEMBA INPUT RECORDING v1
+        # rom_checksum: 99999
+        # game_code: FAKE
+        # frame_count: 1
+        # anchor_state: test.state
+        ---
+        000
+      GIR
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        replayer = Gemba::InputReplayer.new(gir_path)
+        assert_raises(Gemba::InputReplayer::ChecksumMismatch) do
+          replayer.validate!(player.core)
+        end
+      end
+    end
+  end
+
+  # -- Crash resilience --------------------------------------------------------
+
+  def test_truncated_file_loads_available_frames
+    Dir.mktmpdir do |dir|
+      gir_path = File.join(dir, "test.gir")
+      # Simulate a crash: header says 0 frames but body has 3
+      File.write(gir_path, <<~GIR)
+        # GEMBA INPUT RECORDING v1
+        # rom_checksum: 12345
+        # game_code: TEST
+        # frame_count: 0
+        # anchor_state: test.state
+        ---
+        001
+        041
+        000
+      GIR
+
+      replayer = Gemba::InputReplayer.new(gir_path)
+      assert_equal 3, replayer.frame_count
+      assert_equal 0x001, replayer.bitmask_at(0)
+      assert_equal 0x041, replayer.bitmask_at(1)
+      assert_equal 0x000, replayer.bitmask_at(2)
+    end
+  end
+
+  private
+
+  def record(gir_path, bitmasks)
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      player.step(5) # advance a few frames for meaningful state
+      core = player.core
+      rec = Gemba::InputRecorder.new(gir_path, core: core)
+      rec.start
+      bitmasks.each { |m| rec.capture(m) }
+      rec.stop
+    end
+  end
+end

data/test/test_keyboard_map.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 require "minitest/autorun"
-require "gemba"
-require_relative "../lib/gemba/config"
-require_relative "../lib/gemba/input_mappings"
+require "gemba/headless"
 require_relative "support/input_mocks"
 
 class TestKeyboardMap < Minitest::Test

data/test/test_libretro_backend.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "gemba/headless"
+
+class TestLibretroBackend < Minitest::Test
+  def setup
+    Gemba::GameIndex.reset!
+    @backend = Gemba::BoxartFetcher::LibretroBackend.new
+  end
+
+  def test_url_for_known_gba_game
+    url = @backend.url_for("AGB-AXVE")
+    assert_match %r{thumbnails\.libretro\.com}, url
+    assert_match %r{Nintendo%20-%20Game%20Boy%20Advance}, url
+    assert_match %r{Named_Boxarts}, url
+    assert_match %r{Pokemon}, url
+    assert url.end_with?(".png")
+  end
+
+  def test_url_for_unknown_game_returns_nil
+    assert_nil @backend.url_for("AGB-ZZZZ")
+  end
+
+  def test_url_for_unknown_platform_returns_nil
+    assert_nil @backend.url_for("XYZ-AAAA")
+  end
+
+  def test_url_encodes_special_characters
+    # Games with special chars (parentheses, ampersands, etc.) should be encoded
+    url = @backend.url_for("AGB-AXVE")
+    refute_includes url, " "  # no raw spaces
+  end
+
+  def test_url_for_gb_game
+    url = @backend.url_for("DMG-APAU")
+    if url  # GB data is sparse
+      assert_match %r{Nintendo%20-%20Game%20Boy/}, url
+    end
+  end
+end

data/test/test_locale.rb

@@ -2,7 +2,7 @@
 
 require "minitest/autorun"
 require "yaml"
-require_relative "../lib/gemba/locale"
+require "gemba/headless"
 
 class TestMGBALocale < Minitest::Test
   # -- Loading ---------------------------------------------------------------