gemba 0.1.0

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+if ENV['COVERAGE']
+  require 'simplecov'
+  require_relative 'shared/simplecov_config'
+
+  coverage_name = ENV['COVERAGE_NAME'] || 'gemba'
+  SimpleCov.coverage_dir "#{SimpleCovConfig::PROJECT_ROOT}/coverage/results/#{coverage_name}"
+  SimpleCov.command_name "gemba:#{coverage_name}"
+  SimpleCov.print_error_status = false
+  SimpleCov.formatter SimpleCov::Formatter::SimpleFormatter
+
+  SimpleCov.start do
+    SimpleCovConfig.apply_filters(self)
+    track_files "#{SimpleCovConfig::PROJECT_ROOT}/lib/**/*.rb"
+  end
+end
+
+require "minitest/autorun"

data/test/test_hotkey_map.rb

@@ -0,0 +1,396 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "tmpdir"
+require "json"
+require "set"
+
+# Minimal config stub for unit testing HotkeyMap without Tk or SDL2.
+class MockHotkeyConfig
+  attr_reader :hotkey_data, :saved_hotkeys
+
+  def initialize(hotkey_data = {})
+    @hotkey_data = hotkey_data
+    @saved_hotkeys = {}
+  end
+
+  def hotkeys
+    @hotkey_data
+  end
+
+  def set_hotkey(action, hk)
+    @saved_hotkeys[action.to_s] = hk
+  end
+
+  def reload!
+    # no-op for unit tests
+  end
+end
+
+class TestHotkeyMap < Minitest::Test
+  def setup
+    require "gemba/hotkey_map"
+  end
+
+  def make_map(hotkey_data = {})
+    config = MockHotkeyConfig.new(hotkey_data)
+    [Gemba::HotkeyMap.new(config), config]
+  end
+
+  # -- Defaults -------------------------------------------------------------
+
+  def test_defaults_match_expected_keysyms
+    map, = make_map
+    assert_equal 'q', map.key_for(:quit)
+    assert_equal 'p', map.key_for(:pause)
+    assert_equal 'Tab', map.key_for(:fast_forward)
+    assert_equal 'F11', map.key_for(:fullscreen)
+    assert_equal 'F3', map.key_for(:show_fps)
+    assert_equal 'F5', map.key_for(:quick_save)
+    assert_equal 'F8', map.key_for(:quick_load)
+    assert_equal 'F6', map.key_for(:save_states)
+    assert_equal 'F9', map.key_for(:screenshot)
+  end
+
+  def test_all_actions_have_defaults
+    map, = make_map
+    Gemba::HotkeyMap::ACTIONS.each do |action|
+      refute_nil map.key_for(action), "Missing default for #{action}"
+    end
+  end
+
+  # -- Reverse lookup -------------------------------------------------------
+
+  def test_action_for_returns_correct_action
+    map, = make_map
+    assert_equal :quit, map.action_for('q')
+    assert_equal :pause, map.action_for('p')
+    assert_equal :fast_forward, map.action_for('Tab')
+    assert_equal :quick_save, map.action_for('F5')
+  end
+
+  def test_action_for_returns_nil_for_unknown_key
+    map, = make_map
+    assert_nil map.action_for('z')
+    assert_nil map.action_for('unknown')
+  end
+
+  # -- Rebinding ------------------------------------------------------------
+
+  def test_set_rebinds_action
+    map, = make_map
+    map.set(:quit, 'Escape')
+    assert_equal 'Escape', map.key_for(:quit)
+    assert_equal :quit, map.action_for('Escape')
+  end
+
+  def test_set_clears_conflict
+    map, = make_map
+    # 'p' is currently bound to :pause — rebind :quit to 'p'
+    map.set(:quit, 'p')
+    assert_equal 'p', map.key_for(:quit)
+    assert_nil map.key_for(:pause), "Old action should be unbound"
+  end
+
+  def test_set_does_not_affect_other_bindings
+    map, = make_map
+    map.set(:quit, 'Escape')
+    assert_equal 'p', map.key_for(:pause)
+    assert_equal 'F5', map.key_for(:quick_save)
+  end
+
+  # -- Reset ----------------------------------------------------------------
+
+  def test_reset_restores_defaults
+    map, = make_map
+    map.set(:quit, 'Escape')
+    map.set(:pause, 'F12')
+    map.reset!
+    assert_equal 'q', map.key_for(:quit)
+    assert_equal 'p', map.key_for(:pause)
+  end
+
+  # -- Config loading -------------------------------------------------------
+
+  def test_load_config_applies_saved_bindings
+    map, = make_map({ 'quit' => 'Escape', 'pause' => 'F12' })
+    assert_equal 'Escape', map.key_for(:quit)
+    assert_equal 'F12', map.key_for(:pause)
+    # Unsaved actions keep defaults
+    assert_equal 'Tab', map.key_for(:fast_forward)
+  end
+
+  def test_load_config_ignores_unknown_actions
+    map, = make_map({ 'bogus' => 'F1' })
+    assert_nil map.action_for('F1')
+    assert_equal 'q', map.key_for(:quit)
+  end
+
+  def test_load_config_empty_uses_defaults
+    map, = make_map({})
+    assert_equal 'q', map.key_for(:quit)
+  end
+
+  # -- Save to config -------------------------------------------------------
+
+  def test_save_to_config_writes_all_bindings
+    map, config = make_map
+    map.set(:quit, 'Escape')
+    map.save_to_config
+    assert_equal 'Escape', config.saved_hotkeys['quit']
+    assert_equal 'p', config.saved_hotkeys['pause']
+  end
+
+  def test_save_to_config_preserves_combo_arrays
+    map, config = make_map
+    map.set(:quit, ['Control', 'q'])
+    map.save_to_config
+    assert_equal ['Control', 'q'], config.saved_hotkeys['quit']
+  end
+
+  # -- Labels ---------------------------------------------------------------
+
+  def test_labels_returns_copy
+    map, = make_map
+    labels = map.labels
+    labels[:quit] = 'CHANGED'
+    assert_equal 'q', map.key_for(:quit), "Modifying labels hash should not affect map"
+  end
+
+  def test_labels_reflects_current_state
+    map, = make_map
+    map.set(:quit, 'Escape')
+    labels = map.labels
+    assert_equal 'Escape', labels[:quit]
+  end
+
+  # -- Modifier combo support -----------------------------------------------
+
+  def test_set_combo_hotkey
+    map, = make_map
+    map.set(:quit, ['Control', 'q'])
+    assert_equal ['Control', 'q'], map.key_for(:quit)
+  end
+
+  def test_action_for_combo_with_modifiers
+    map, = make_map
+    map.set(:quit, ['Control', 'q'])
+    result = map.action_for('q', modifiers: Set.new(['Control']))
+    assert_equal :quit, result
+  end
+
+  def test_action_for_combo_wrong_modifiers
+    map, = make_map
+    map.set(:quit, ['Control', 'q'])
+    assert_nil map.action_for('q', modifiers: Set.new(['Shift']))
+  end
+
+  def test_action_for_combo_no_modifiers
+    map, = make_map
+    map.set(:quit, ['Control', 'q'])
+    assert_nil map.action_for('q'), "Combo should not match without modifiers"
+  end
+
+  def test_action_for_plain_key_ignores_active_modifiers
+    map, = make_map
+    # 'p' (pause) is a plain key — should only match without modifiers
+    assert_nil map.action_for('p', modifiers: Set.new(['Control']))
+    assert_equal :pause, map.action_for('p')
+  end
+
+  def test_action_for_multi_modifier_combo
+    map, = make_map
+    map.set(:screenshot, ['Control', 'Shift', 's'])
+    result = map.action_for('s', modifiers: Set.new(['Control', 'Shift']))
+    assert_equal :screenshot, result
+  end
+
+  def test_action_for_multi_modifier_partial_match_fails
+    map, = make_map
+    map.set(:screenshot, ['Control', 'Shift', 's'])
+    assert_nil map.action_for('s', modifiers: Set.new(['Control']))
+  end
+
+  def test_set_combo_clears_conflicting_combo
+    map, = make_map
+    map.set(:quit, ['Control', 'q'])
+    map.set(:pause, ['Control', 'q'])
+    assert_nil map.key_for(:quit), "Old combo should be unbound"
+    assert_equal ['Control', 'q'], map.key_for(:pause)
+  end
+
+  def test_load_config_with_combo_array
+    map, = make_map({ 'quit' => ['Control', 'q'] })
+    assert_equal ['Control', 'q'], map.key_for(:quit)
+    result = map.action_for('q', modifiers: Set.new(['Control']))
+    assert_equal :quit, result
+  end
+
+  # -- normalize (class method) ---------------------------------------------
+
+  def test_normalize_plain_string
+    assert_equal 'F5', Gemba::HotkeyMap.normalize('F5')
+  end
+
+  def test_normalize_single_element_array
+    assert_equal 'q', Gemba::HotkeyMap.normalize(['q'])
+  end
+
+  def test_normalize_sorts_modifiers_canonically
+    result = Gemba::HotkeyMap.normalize(['Shift', 'Control', 's'])
+    assert_equal ['Control', 'Shift', 's'], result
+  end
+
+  def test_normalize_preserves_correct_order
+    result = Gemba::HotkeyMap.normalize(['Control', 'Shift', 's'])
+    assert_equal ['Control', 'Shift', 's'], result
+  end
+
+  # -- display_name (class method) ------------------------------------------
+
+  def test_display_name_plain_string
+    assert_equal 'F5', Gemba::HotkeyMap.display_name('F5')
+  end
+
+  def test_display_name_combo
+    result = Gemba::HotkeyMap.display_name(['Control', 'q'])
+    assert_equal 'Ctrl+Q', result
+  end
+
+  def test_display_name_multi_modifier
+    result = Gemba::HotkeyMap.display_name(['Control', 'Shift', 's'])
+    assert_equal 'Ctrl+Shift+S', result
+  end
+
+  # -- modifier helpers (class methods) -------------------------------------
+
+  def test_modifier_key_recognizes_modifiers
+    assert Gemba::HotkeyMap.modifier_key?('Control_L')
+    assert Gemba::HotkeyMap.modifier_key?('Shift_R')
+    assert Gemba::HotkeyMap.modifier_key?('Alt_L')
+    assert Gemba::HotkeyMap.modifier_key?('Meta_L')
+    assert Gemba::HotkeyMap.modifier_key?('Super_R')
+  end
+
+  def test_modifier_key_rejects_non_modifiers
+    refute Gemba::HotkeyMap.modifier_key?('a')
+    refute Gemba::HotkeyMap.modifier_key?('F5')
+    refute Gemba::HotkeyMap.modifier_key?('Return')
+  end
+
+  def test_normalize_modifier
+    assert_equal 'Control', Gemba::HotkeyMap.normalize_modifier('Control_L')
+    assert_equal 'Control', Gemba::HotkeyMap.normalize_modifier('Control_R')
+    assert_equal 'Shift', Gemba::HotkeyMap.normalize_modifier('Shift_L')
+    assert_equal 'Alt', Gemba::HotkeyMap.normalize_modifier('Alt_L')
+    assert_equal 'Alt', Gemba::HotkeyMap.normalize_modifier('Meta_L')
+    assert_nil Gemba::HotkeyMap.normalize_modifier('a')
+  end
+
+  def test_modifiers_from_state_empty
+    result = Gemba::HotkeyMap.modifiers_from_state(0)
+    assert_empty result
+  end
+
+  def test_modifiers_from_state_shift
+    result = Gemba::HotkeyMap.modifiers_from_state(1)
+    assert_equal Set.new(['Shift']), result
+  end
+
+  def test_modifiers_from_state_control
+    result = Gemba::HotkeyMap.modifiers_from_state(4)
+    assert_equal Set.new(['Control']), result
+  end
+
+  def test_modifiers_from_state_alt
+    result = Gemba::HotkeyMap.modifiers_from_state(8)
+    assert_equal Set.new(['Alt']), result
+  end
+
+  def test_modifiers_from_state_control_shift
+    result = Gemba::HotkeyMap.modifiers_from_state(5) # 4|1
+    assert_equal Set.new(['Control', 'Shift']), result
+  end
+
+  def test_action_for_empty_modifiers_set_matches_plain
+    map, = make_map
+    # Empty set should behave same as nil (match plain keys)
+    assert_equal :pause, map.action_for('p', modifiers: Set.new)
+  end
+
+  # -- Rewind action ---------------------------------------------------------
+
+  def test_rewind_in_actions
+    assert_includes Gemba::HotkeyMap::ACTIONS, :rewind
+  end
+
+  def test_rewind_default_is_shift_tab
+    map, = make_map
+    assert_equal ['Shift', 'Tab'], map.key_for(:rewind)
+  end
+
+  def test_rewind_action_for_shift_tab
+    map, = make_map
+    result = map.action_for('Tab', modifiers: Set.new(['Shift']))
+    assert_equal :rewind, result
+  end
+
+  def test_rewind_does_not_match_plain_tab
+    map, = make_map
+    # Plain Tab is fast_forward, not rewind
+    assert_equal :fast_forward, map.action_for('Tab')
+  end
+
+  def test_iso_left_tab_normalized_to_rewind
+    map, = make_map
+    # Shift+Tab produces ISO_Left_Tab on many platforms
+    result = map.action_for('ISO_Left_Tab', modifiers: Set.new(['Shift']))
+    assert_equal :rewind, result
+  end
+
+  def test_normalize_keysym_iso_left_tab
+    assert_equal 'Tab', Gemba::HotkeyMap.normalize_keysym('ISO_Left_Tab')
+  end
+
+  def test_normalize_keysym_uppercase_letter
+    assert_equal 'q', Gemba::HotkeyMap.normalize_keysym('Q')
+    assert_equal 's', Gemba::HotkeyMap.normalize_keysym('S')
+    assert_equal 'a', Gemba::HotkeyMap.normalize_keysym('A')
+  end
+
+  def test_normalize_keysym_shifted_numbers
+    assert_equal '1', Gemba::HotkeyMap.normalize_keysym('exclam')
+    assert_equal '2', Gemba::HotkeyMap.normalize_keysym('at')
+    assert_equal '0', Gemba::HotkeyMap.normalize_keysym('parenright')
+  end
+
+  def test_normalize_keysym_passthrough
+    assert_equal 'q', Gemba::HotkeyMap.normalize_keysym('q')
+    assert_equal 'F5', Gemba::HotkeyMap.normalize_keysym('F5')
+    assert_equal 'Tab', Gemba::HotkeyMap.normalize_keysym('Tab')
+  end
+
+  def test_action_for_shift_uppercase_matches_plain_combo
+    map, = make_map
+    map.set(:screenshot, ['Shift', 's'])
+    # Tk sends 'S' (uppercase) when Shift+s is pressed
+    result = map.action_for('S', modifiers: Set.new(['Shift']))
+    assert_equal :screenshot, result
+  end
+
+  # -- Record action ---------------------------------------------------------
+
+  def test_record_in_actions
+    assert_includes Gemba::HotkeyMap::ACTIONS, :record
+  end
+
+  def test_record_default_is_f10
+    map, = make_map
+    assert_equal 'F10', map.key_for(:record)
+  end
+
+  def test_record_dispatches_on_f10
+    map, = make_map
+    assert_equal :record, map.action_for('F10')
+  end
+end

data/test/test_keyboard_map.rb

@@ -0,0 +1,108 @@
+# 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 TestKeyboardMap < Minitest::Test
+  def setup
+    @config = MockInputConfig.new
+    @map = Gemba::KeyboardMap.new(@config)
+  end
+
+  def test_default_labels
+    labels = @map.labels
+    assert_equal 'z', labels[:a]
+    assert_equal 'x', labels[:b]
+    assert_equal 'Return', labels[:start]
+  end
+
+  def test_set_remap
+    @map.set(:a, 'q')
+    assert_equal 'q', @map.labels[:a]
+  end
+
+  def test_set_removes_old_binding
+    @map.set(:a, 'q')
+    refute @map.labels.values.include?('z')
+  end
+
+  def test_set_unknown_button
+    @map.set(:nonexistent, 'q')
+    assert_equal 'z', @map.labels[:a]
+  end
+
+  def test_reset
+    @map.set(:a, 'q')
+    @map.reset!
+    assert_equal 'z', @map.labels[:a]
+  end
+
+  def test_mask_no_device
+    assert_equal 0, @map.mask
+  end
+
+  def test_mask_with_device
+    kb = Gemba::VirtualKeyboard.new
+    @map.device = kb
+    kb.press('z')
+    mask = @map.mask
+    assert_equal Gemba::KEY_A, mask & Gemba::KEY_A
+  end
+
+  def test_mask_multiple_keys
+    kb = Gemba::VirtualKeyboard.new
+    @map.device = kb
+    kb.press('z')
+    kb.press('x')
+    mask = @map.mask
+    assert_equal Gemba::KEY_A, mask & Gemba::KEY_A
+    assert_equal Gemba::KEY_B, mask & Gemba::KEY_B
+  end
+
+  def test_mask_released_key_not_in_mask
+    kb = Gemba::VirtualKeyboard.new
+    @map.device = kb
+    kb.press('z')
+    kb.release('z')
+    assert_equal 0, @map.mask
+  end
+
+  def test_supports_deadzone
+    refute @map.supports_deadzone?
+  end
+
+  def test_dead_zone_pct
+    assert_equal 0, @map.dead_zone_pct
+  end
+
+  def test_set_dead_zone_raises
+    assert_raises(NotImplementedError) { @map.set_dead_zone(100) }
+  end
+
+  def test_load_config
+    cfg = MockInputConfig.new(keyboard_mappings: { 'a' => 'q', 'b' => 'w' })
+    map = Gemba::KeyboardMap.new(cfg)
+    assert_equal 'q', map.labels[:a]
+    assert_equal 'w', map.labels[:b]
+  end
+
+  def test_reload
+    @map.set(:a, 'q')
+    @map.reload!
+    assert @config.calls.any? { |c| c[0] == :reload! }
+    # After reload with empty config, defaults restored
+    assert_equal 'z', @map.labels[:a]
+  end
+
+  def test_save_to_config
+    @map.save_to_config
+    set_calls = @config.calls.select { |c| c[0] == :set_mapping }
+    assert_equal 10, set_calls.size
+    a_call = set_calls.find { |c| c[2] == :a }
+    assert_equal 'keyboard', a_call[1]
+    assert_equal 'z', a_call[3]
+  end
+end

data/test/test_locale.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "yaml"
+require_relative "../lib/gemba/locale"
+
+class TestMGBALocale < Minitest::Test
+  # -- Loading ---------------------------------------------------------------
+
+  def test_load_english
+    Gemba::Locale.load('en')
+    assert_equal 'en', Gemba::Locale.language
+  end
+
+  def test_load_japanese
+    Gemba::Locale.load('ja')
+    assert_equal 'ja', Gemba::Locale.language
+  end
+
+  def test_fallback_to_english_for_unknown_locale
+    Gemba::Locale.load('zz')
+    # Should still load (fell back to en.yml) and return translations
+    assert_equal 'File', Gemba::Locale.translate('menu.file')
+  end
+
+  def test_load_auto_detects_from_env
+    original = ENV['LANG']
+    ENV['LANG'] = 'ja_JP.UTF-8'
+    Gemba::Locale.load
+    assert_equal 'ja', Gemba::Locale.language
+  ensure
+    ENV['LANG'] = original
+    Gemba::Locale.load('en')
+  end
+
+  def test_load_auto_string_treated_as_auto_detect
+    original = ENV['LANG']
+    ENV['LANG'] = 'en_US.UTF-8'
+    Gemba::Locale.load('auto')
+    assert_equal 'en', Gemba::Locale.language
+  ensure
+    ENV['LANG'] = original
+    Gemba::Locale.load('en')
+  end
+
+  # -- Translation -----------------------------------------------------------
+
+  def test_translate_english_string
+    Gemba::Locale.load('en')
+    assert_equal 'File', Gemba::Locale.translate('menu.file')
+  end
+
+  def test_translate_japanese_string
+    Gemba::Locale.load('ja')
+    assert_equal 'ファイル', Gemba::Locale.translate('menu.file')
+  end
+
+  def test_translate_nested_key
+    Gemba::Locale.load('en')
+    assert_equal 'Video', Gemba::Locale.translate('settings.video')
+    assert_equal 'ROM Info', Gemba::Locale.translate('rom_info.title')
+  end
+
+  def test_translate_with_interpolation
+    Gemba::Locale.load('en')
+    result = Gemba::Locale.translate('toast.state_saved', slot: 3)
+    assert_equal 'State saved to slot 3', result
+  end
+
+  def test_translate_with_multiple_vars
+    Gemba::Locale.load('en')
+    # dialog.game_running_msg has {name}
+    result = Gemba::Locale.translate('dialog.game_running_msg', name: 'Zelda')
+    assert_equal 'Another game is running. Switch to Zelda?', result
+  end
+
+  def test_translate_japanese_with_interpolation
+    Gemba::Locale.load('ja')
+    result = Gemba::Locale.translate('toast.state_saved', slot: 5)
+    assert_includes result, '5'
+  end
+
+  def test_translate_missing_key_returns_key
+    Gemba::Locale.load('en')
+    assert_equal 'nonexistent.key', Gemba::Locale.translate('nonexistent.key')
+  end
+
+  def test_translate_partial_key_returns_key
+    Gemba::Locale.load('en')
+    # 'menu' exists but is a Hash, not a string
+    assert_equal 'menu', Gemba::Locale.translate('menu')
+  end
+
+  # -- Alias -----------------------------------------------------------------
+
+  def test_t_alias
+    Gemba::Locale.load('en')
+    assert_equal 'File', Gemba::Locale.t('menu.file')
+    assert_equal Gemba::Locale.translate('menu.file'),
+                 Gemba::Locale.t('menu.file')
+  end
+
+  # -- Available languages ---------------------------------------------------
+
+  def test_available_languages
+    langs = Gemba::Locale.available_languages
+    assert_includes langs, 'en'
+    assert_includes langs, 'ja'
+    assert_equal langs, langs.sort, 'should be sorted'
+  end
+
+  # -- Translatable mixin ----------------------------------------------------
+
+  def test_translatable_mixin
+    klass = Class.new { include Gemba::Locale::Translatable; public :translate, :t }
+    obj = klass.new
+    Gemba::Locale.load('en')
+    assert_equal 'File', obj.translate('menu.file')
+    assert_equal 'File', obj.t('menu.file')
+  end
+
+  def test_translatable_mixin_with_interpolation
+    klass = Class.new { include Gemba::Locale::Translatable; public :translate }
+    obj = klass.new
+    Gemba::Locale.load('en')
+    assert_equal 'State saved to slot 7', obj.translate('toast.state_saved', slot: 7)
+  end
+
+  # -- Completeness ----------------------------------------------------------
+
+  def test_en_and_ja_have_same_keys
+    en_path = File.expand_path('../lib/gemba/locales/en.yml', __dir__)
+    ja_path = File.expand_path('../lib/gemba/locales/ja.yml', __dir__)
+    en = YAML.safe_load_file(en_path)
+    ja = YAML.safe_load_file(ja_path)
+
+    en_keys = flatten_keys(en)
+    ja_keys = flatten_keys(ja)
+
+    missing_in_ja = en_keys - ja_keys
+    missing_in_en = ja_keys - en_keys
+
+    assert_empty missing_in_ja, "Keys in en.yml missing from ja.yml: #{missing_in_ja.join(', ')}"
+    assert_empty missing_in_en, "Keys in ja.yml missing from en.yml: #{missing_in_en.join(', ')}"
+  end
+
+  private
+
+  def flatten_keys(hash, prefix = nil)
+    hash.flat_map do |key, value|
+      full_key = prefix ? "#{prefix}.#{key}" : key.to_s
+      if value.is_a?(Hash)
+        flatten_keys(value, full_key)
+      else
+        [full_key]
+      end
+    end
+  end
+end

data/test/test_mgba.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba"
+
+class TestMGBA < Minitest::Test
+  def test_version_constant
+    assert_match(/\A\d+\.\d+\.\d+\z/, Gemba::VERSION)
+  end
+
+  def test_module_structure
+    assert_kind_of Module, Gemba
+    assert_equal Class, Gemba::Core.class
+  end
+
+  def test_key_constants_are_unique_powers_of_two
+    keys = %i[KEY_A KEY_B KEY_SELECT KEY_START
+              KEY_RIGHT KEY_LEFT KEY_UP KEY_DOWN KEY_R KEY_L]
+
+    values = keys.map { |k| Gemba.const_get(k) }
+    assert_equal values.size, values.uniq.size, "all key constants should be unique"
+    values.each do |v|
+      assert_equal 0, v & (v - 1), "#{v} should be a power of 2"
+    end
+  end
+end