gemba 0.1.0

data/test/test_core.rb

@@ -0,0 +1,401 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba"
+require "tempfile"
+require "tmpdir"
+
+class TestMGBACore < Minitest::Test
+  # Generated by: ruby gemba/scripts/generate_test_rom.rb
+  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)
+    @core = Gemba::Core.new(TEST_ROM)
+  end
+
+  def teardown
+    @core&.destroy unless @core.nil? || @core.destroyed?
+  end
+
+  # -- Dimensions --------------------------------------------------------------
+
+  def test_width
+    assert_equal 240, @core.width
+  end
+
+  def test_height
+    assert_equal 160, @core.height
+  end
+
+  # -- Title -------------------------------------------------------------------
+
+  def test_title
+    assert_equal "GEMBATEST", @core.title
+  end
+
+  # -- ROM metadata ------------------------------------------------------------
+
+  def test_game_code
+    code = @core.game_code
+    # mGBA prefixes with platform: "AGB-" for GBA
+    assert_equal "AGB-BGBE", code
+    refute_includes code, "\0", "game_code must not contain null bytes"
+  end
+
+  def test_maker_code
+    maker = @core.maker_code
+    assert_equal "01", maker
+    refute_includes maker, "\0", "maker_code must not contain null bytes"
+  end
+
+  def test_title_no_null_bytes
+    title = @core.title
+    assert_equal "GEMBATEST", title
+    refute_includes title, "\0", "title must not contain null bytes"
+  end
+
+  def test_checksum
+    crc = @core.checksum
+    assert_kind_of Integer, crc
+    assert crc > 0
+  end
+
+  def test_platform
+    assert_equal "GBA", @core.platform
+  end
+
+  def test_rom_size
+    size = @core.rom_size
+    assert_kind_of Integer, size
+    assert size > 0
+  end
+
+  # -- Lifecycle ---------------------------------------------------------------
+
+  def test_not_destroyed_initially
+    refute @core.destroyed?
+  end
+
+  def test_destroy
+    @core.destroy
+    assert @core.destroyed?
+  end
+
+  def test_double_destroy_is_safe
+    @core.destroy
+    @core.destroy
+    assert @core.destroyed?
+  end
+
+  def test_methods_raise_after_destroy
+    @core.destroy
+    assert_raises(RuntimeError) { @core.run_frame }
+    assert_raises(RuntimeError) { @core.video_buffer }
+    assert_raises(RuntimeError) { @core.video_buffer_argb }
+    assert_raises(RuntimeError) { @core.audio_buffer }
+    assert_raises(RuntimeError) { @core.set_keys(0) }
+    assert_raises(RuntimeError) { @core.width }
+    assert_raises(RuntimeError) { @core.height }
+    assert_raises(RuntimeError) { @core.title }
+    assert_raises(RuntimeError) { @core.game_code }
+    assert_raises(RuntimeError) { @core.maker_code }
+    assert_raises(RuntimeError) { @core.checksum }
+    assert_raises(RuntimeError) { @core.platform }
+    assert_raises(RuntimeError) { @core.rom_size }
+    assert_raises(RuntimeError) { @core.save_state_to_file("/tmp/x.ss") }
+    assert_raises(RuntimeError) { @core.load_state_from_file("/tmp/x.ss") }
+  end
+
+  # -- Frame emulation ---------------------------------------------------------
+
+  def test_run_frame
+    @core.run_frame
+  end
+
+  def test_video_buffer_size
+    @core.run_frame
+    buf = @core.video_buffer
+    assert_kind_of String, buf
+    assert_equal 240 * 160 * 4, buf.bytesize
+  end
+
+  def test_video_buffer_argb_size
+    @core.run_frame
+    buf = @core.video_buffer_argb
+    assert_kind_of String, buf
+    assert_equal 240 * 160 * 4, buf.bytesize
+  end
+
+  def test_video_buffer_argb_swaps_r_and_b
+    @core.run_frame
+    raw  = @core.video_buffer.unpack('V*')
+    argb = @core.video_buffer_argb.unpack('V*')
+    assert_equal raw.size, argb.size
+    # Verify R↔B swap + forced opaque alpha for first non-zero pixel
+    idx = raw.index { |px| px != 0 } || 0
+    px = raw[idx]
+    expected = 0xFF000000 |
+               ((px & 0x000000FF) << 16) |
+               (px & 0x0000FF00) |
+               ((px & 0x00FF0000) >> 16)
+    assert_equal expected, argb[idx]
+  end
+
+  def test_audio_buffer_is_stereo_int16
+    @core.run_frame
+    buf = @core.audio_buffer
+    assert_kind_of String, buf
+    assert_equal 0, buf.bytesize % 4, "should be stereo int16 (4 bytes per frame)"
+  end
+
+  def test_multiple_frames
+    10.times { @core.run_frame }
+    assert_equal 240 * 160 * 4, @core.video_buffer.bytesize
+  end
+
+  # -- Input -------------------------------------------------------------------
+
+  def test_set_keys
+    @core.set_keys(Gemba::KEY_A | Gemba::KEY_START)
+    @core.run_frame
+    @core.set_keys(0)
+    @core.run_frame
+  end
+
+  # -- Save files --------------------------------------------------------------
+
+  def test_save_dir_creates_sav_file
+    Dir.mktmpdir("gemba-saves") do |dir|
+      core = Gemba::Core.new(TEST_ROM, dir)
+      core.run_frame
+      core.destroy
+      sav = Dir.glob(File.join(dir, "*.sav"))
+      assert_equal 1, sav.size, "Expected a .sav file in #{dir}"
+    end
+  end
+
+  def test_save_dir_nil_uses_rom_directory
+    # When save_dir is nil, saves go alongside the ROM — just verify no crash
+    core = Gemba::Core.new(TEST_ROM)
+    core.run_frame
+    core.destroy
+  end
+
+  # -- Save states -------------------------------------------------------------
+
+  def test_save_state_to_file
+    @core.run_frame
+    Dir.mktmpdir("gemba-states") do |dir|
+      path = File.join(dir, "test.ss1")
+      assert @core.save_state_to_file(path), "save_state_to_file should return true"
+      assert File.exist?(path), "State file should exist"
+      assert File.size(path) > 0, "State file should not be empty"
+    end
+  end
+
+  def test_load_state_from_file
+    # Run several frames to reach a known state
+    10.times { @core.run_frame }
+
+    Dir.mktmpdir("gemba-states") do |dir|
+      path = File.join(dir, "test.ss1")
+
+      # Save state at frame 10
+      assert @core.save_state_to_file(path)
+
+      # Run more frames to advance past the saved state
+      10.times { @core.run_frame }
+
+      # Load state — should succeed and restore core to a valid state
+      assert @core.load_state_from_file(path), "load_state_from_file should return true"
+
+      # Core should be functional after loading: run a frame without crashing
+      @core.run_frame
+      buf = @core.video_buffer
+      assert_equal 240 * 160 * 4, buf.bytesize, "Video buffer should be valid after state load"
+    end
+  end
+
+  def test_load_state_nonexistent_returns_false
+    result = @core.load_state_from_file("/no/such/state.ss1")
+    refute result, "load_state_from_file should return false for missing file"
+  end
+
+  def test_save_state_raises_on_bad_path
+    @core.run_frame
+    assert_raises(RuntimeError) { @core.save_state_to_file("/no/such/dir/state.ss1") }
+  end
+
+  def test_save_state_round_trip_preserves_state
+    # Run to frame 10, save, continue to frame 20, load, run 1 frame.
+    # If state was truly restored, the frame after load should match
+    # frame 11 from a fresh run.
+    10.times { @core.run_frame }
+
+    Dir.mktmpdir("gemba-states") do |dir|
+      path = File.join(dir, "test.ss1")
+      assert @core.save_state_to_file(path)
+
+      # Capture frame 11 from saved state
+      @core.run_frame
+      buf_frame_11 = @core.video_buffer
+
+      # Reload state (back to frame 10)
+      assert @core.load_state_from_file(path)
+
+      # Run 1 frame from restored state (should be frame 11 again)
+      @core.run_frame
+      buf_restored_11 = @core.video_buffer
+
+      assert_equal buf_frame_11, buf_restored_11,
+        "Frame after load should match frame after save point"
+    end
+  end
+
+  # -- Color correction --------------------------------------------------------
+
+  def test_color_correction_defaults_to_false
+    refute @core.color_correction?
+  end
+
+  def test_color_correction_toggle
+    @core.color_correction = true
+    assert @core.color_correction?
+    @core.color_correction = false
+    refute @core.color_correction?
+  end
+
+  def test_color_correction_modifies_argb_output
+    @core.run_frame
+    buf_normal = @core.video_buffer_argb
+
+    @core.color_correction = true
+    buf_corrected = @core.video_buffer_argb
+
+    # The corrected buffer should differ (color values are transformed)
+    refute_equal buf_normal, buf_corrected,
+      "Color-corrected ARGB output should differ from uncorrected"
+  end
+
+  # -- Frame blending -----------------------------------------------------------
+
+  def test_frame_blending_defaults_to_false
+    refute @core.frame_blending?
+  end
+
+  def test_frame_blending_toggle
+    @core.frame_blending = true
+    assert @core.frame_blending?
+    @core.frame_blending = false
+    refute @core.frame_blending?
+  end
+
+  def test_frame_blending_modifies_argb_output
+    @core.run_frame
+    buf_normal = @core.video_buffer_argb
+
+    @core.frame_blending = true
+    # First call with blending on blends current frame with zeroed prev_frame
+    buf_blended = @core.video_buffer_argb
+
+    refute_equal buf_normal, buf_blended,
+      "Frame-blended ARGB output should differ from unblended"
+  end
+
+  def test_frame_blending_stabilizes_on_static_content
+    @core.frame_blending = true
+    @core.run_frame
+    @core.video_buffer_argb  # prime prev_frame buffer
+    @core.run_frame
+    buf_a = @core.video_buffer_argb
+    @core.run_frame
+    buf_b = @core.video_buffer_argb
+
+    # Static content (test ROM draws nothing) should produce identical blended
+    # output once prev_frame is primed
+    assert_equal buf_a, buf_b,
+      "Frame blending on static content should stabilize"
+  end
+
+  # -- Rewind ----------------------------------------------------------------
+
+  def test_rewind_init_and_count
+    @core.rewind_init(3)
+    assert_equal 0, @core.rewind_count
+    @core.run_frame
+    @core.rewind_push
+    assert_equal 1, @core.rewind_count
+    @core.run_frame
+    @core.rewind_push
+    assert_equal 2, @core.rewind_count
+  end
+
+  def test_rewind_pop_restores_state
+    @core.rewind_init(5)
+    10.times { @core.run_frame }
+
+    # Save snapshot at frame 10
+    @core.rewind_push
+    @core.run_frame
+    buf_11 = @core.video_buffer
+
+    # Advance to frame 20
+    9.times { @core.run_frame }
+
+    # Rewind to frame 10
+    assert_equal true, @core.rewind_pop
+
+    # Run one frame from restored state → should match frame 11
+    @core.run_frame
+    buf_restored = @core.video_buffer
+    assert_equal buf_11, buf_restored
+  end
+
+  def test_rewind_pop_empty_returns_false
+    @core.rewind_init(3)
+    assert_equal false, @core.rewind_pop
+  end
+
+  def test_rewind_pop_without_init_returns_false
+    assert_equal false, @core.rewind_pop
+  end
+
+  def test_rewind_circular_buffer
+    @core.rewind_init(3)
+    5.times do
+      @core.run_frame
+      @core.rewind_push
+    end
+    # Ring buffer capacity is 3, so count stays at 3
+    assert_equal 3, @core.rewind_count
+  end
+
+  def test_rewind_deinit_clears_buffer
+    @core.rewind_init(3)
+    @core.run_frame
+    @core.rewind_push
+    @core.rewind_deinit
+    assert_equal 0, @core.rewind_count
+    assert_equal false, @core.rewind_pop
+  end
+
+  def test_rewind_init_raises_on_invalid_capacity
+    assert_raises(ArgumentError) { @core.rewind_init(0) }
+    assert_raises(ArgumentError) { @core.rewind_init(-1) }
+  end
+
+  # -- Error handling ----------------------------------------------------------
+
+  def test_nonexistent_file
+    assert_raises(ArgumentError) { Gemba::Core.new("/no/such/game.gba") }
+  end
+
+  def test_invalid_extension
+    Tempfile.create(["bad", ".txt"]) do |f|
+      f.write("not a rom")
+      f.flush
+      assert_raises(ArgumentError) { Gemba::Core.new(f.path) }
+    end
+  end
+end

data/test/test_gamepad_map.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba"
+require_relative "../lib/gemba/config"
+require_relative "../lib/gemba/input_mappings"
+require_relative "support/input_mocks"
+
+class TestGamepadMap < Minitest::Test
+  def setup
+    @config = MockInputConfig.new
+    @map = Gemba::GamepadMap.new(@config)
+  end
+
+  def test_default_labels
+    labels = @map.labels
+    assert_equal 'a', labels[:a]
+    assert_equal 'b', labels[:b]
+    assert_equal 'start', labels[:start]
+  end
+
+  def test_set_remap
+    @map.set(:a, :y)
+    assert_equal 'y', @map.labels[:a]
+  end
+
+  def test_set_removes_old_binding
+    @map.set(:a, :y)
+    refute @map.labels.values.include?('a')
+  end
+
+  def test_reset
+    @map.set(:a, :y)
+    @map.set_dead_zone(12000)
+    @map.reset!
+    assert_equal 'a', @map.labels[:a]
+    assert_equal Gemba::GamepadMap::DEFAULT_DEAD_ZONE, @map.dead_zone
+  end
+
+  def test_mask_no_device
+    assert_equal 0, @map.mask
+  end
+
+  def test_mask_with_device
+    gp = MockGamepad.new
+    @map.device = gp
+    gp.buttons_pressed.add(:a)
+    mask = @map.mask
+    assert_equal Gemba::KEY_A, mask & Gemba::KEY_A
+  end
+
+  def test_mask_closed_device
+    gp = MockGamepad.new
+    @map.device = gp
+    gp.buttons_pressed.add(:a)
+    gp.close!
+    assert_equal 0, @map.mask
+  end
+
+  def test_supports_deadzone
+    assert @map.supports_deadzone?
+  end
+
+  def test_set_dead_zone
+    @map.set_dead_zone(12000)
+    assert_equal 12000, @map.dead_zone
+  end
+
+  def test_dead_zone_pct
+    @map.set_dead_zone(16384)
+    assert_equal 50, @map.dead_zone_pct
+  end
+
+  def test_load_config
+    gp = MockGamepad.new
+    @map.device = gp
+    @map.load_config
+    assert_equal 'x', @map.labels[:a]
+    assert_equal 'y', @map.labels[:b]
+    assert_equal (15 / 100.0 * 32767).round, @map.dead_zone
+  end
+
+  def test_load_config_no_device
+    @map.load_config
+    assert_equal 'a', @map.labels[:a]
+  end
+
+  def test_reload
+    gp = MockGamepad.new
+    @map.device = gp
+    @map.set(:a, :y)
+    @map.reload!
+    assert @config.calls.any? { |c| c[0] == :reload! }
+    assert_equal 'x', @map.labels[:a]
+  end
+
+  def test_save_to_config
+    gp = MockGamepad.new(guid: 'test-guid', name: 'Test Pad')
+    @map.device = gp
+    @map.save_to_config
+    gp_calls = @config.calls.select { |c| c[0] == :gamepad }
+    assert_equal 1, gp_calls.size
+    assert_equal 'test-guid', gp_calls[0][1]
+
+    dz_calls = @config.calls.select { |c| c[0] == :set_dead_zone }
+    assert_equal 1, dz_calls.size
+
+    set_calls = @config.calls.select { |c| c[0] == :set_mapping }
+    assert_equal 10, set_calls.size
+  end
+
+  def test_save_to_config_no_device
+    @map.save_to_config
+    assert_empty @config.calls.select { |c| c[0] == :set_mapping }
+  end
+end

data/test/test_headless_player.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "tmpdir"
+
+class TestHeadlessPlayer < 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)
+  end
+
+  # -- Lifecycle ---------------------------------------------------------------
+
+  def test_open_and_close
+    player = Gemba::HeadlessPlayer.new(TEST_ROM)
+    refute player.closed?
+    player.close
+    assert player.closed?
+  end
+
+  def test_double_close_is_safe
+    player = Gemba::HeadlessPlayer.new(TEST_ROM)
+    player.close
+    player.close # should not raise
+    assert player.closed?
+  end
+
+  def test_block_form
+    result = Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      refute player.closed?
+      :ok
+    end
+    assert_equal :ok, result
+  end
+
+  def test_block_form_closes_on_exception
+    assert_raises(RuntimeError) do
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        @ref = player
+        raise "boom"
+      end
+    end
+    assert @ref.closed?
+  end
+
+  # -- Stepping ----------------------------------------------------------------
+
+  def test_step_single_frame
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      player.step # should not raise
+    end
+  end
+
+  def test_step_multiple_frames
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      player.step(60) # should not raise
+    end
+  end
+
+  def test_step_after_close_raises
+    player = Gemba::HeadlessPlayer.new(TEST_ROM)
+    player.close
+    assert_raises(RuntimeError) { player.step }
+  end
+
+  # -- Input -------------------------------------------------------------------
+
+  def test_press_and_release
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      player.press(Gemba::KEY_A | Gemba::KEY_START)
+      player.step
+      player.release_all
+      player.step
+    end
+  end
+
+  # -- Buffers -----------------------------------------------------------------
+
+  def test_video_buffer_argb_size
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      player.step
+      buf = player.video_buffer_argb
+      assert_equal 240 * 160 * 4, buf.bytesize
+    end
+  end
+
+  def test_audio_buffer_returns_data
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      player.step
+      buf = player.audio_buffer
+      assert_kind_of String, buf
+    end
+  end
+
+  # -- Dimensions --------------------------------------------------------------
+
+  def test_width_and_height
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      assert_equal 240, player.width
+      assert_equal 160, player.height
+    end
+  end
+
+  # -- ROM metadata ------------------------------------------------------------
+
+  def test_title
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      assert_equal "GEMBATEST", player.title
+    end
+  end
+
+  def test_game_code
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      assert_equal "AGB-BGBE", player.game_code
+    end
+  end
+
+  def test_maker_code
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      assert_equal "01", player.maker_code
+    end
+  end
+
+  def test_checksum
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      assert_kind_of Integer, player.checksum
+    end
+  end
+
+  def test_platform
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      assert_equal "GBA", player.platform
+    end
+  end
+
+  def test_rom_size
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      assert_operator player.rom_size, :>, 0
+    end
+  end
+
+  # -- Save states -------------------------------------------------------------
+
+  def test_save_and_load_state
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.ss1")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        player.step(10)
+        assert player.save_state(path)
+        assert File.exist?(path)
+
+        player.step(60)
+        assert player.load_state(path)
+      end
+    end
+  end
+
+  # -- Rewind ------------------------------------------------------------------
+
+  def test_rewind_init_and_count
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      player.rewind_init(3)
+      assert_equal 0, player.rewind_count
+
+      player.step
+      player.rewind_push
+      assert_equal 1, player.rewind_count
+
+      player.step
+      player.rewind_push
+      assert_equal 2, player.rewind_count
+    end
+  end
+
+  def test_rewind_pop
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      player.rewind_init(5)
+      player.step(10)
+      player.rewind_push
+      player.step(10)
+      assert player.rewind_pop
+      assert_equal 0, player.rewind_count
+    end
+  end
+
+  def test_rewind_pop_empty_returns_false
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      player.rewind_init(3)
+      refute player.rewind_pop
+    end
+  end
+
+  def test_rewind_deinit
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      player.rewind_init(3)
+      player.step
+      player.rewind_push
+      player.rewind_deinit
+      assert_equal 0, player.rewind_count
+    end
+  end
+end