From 60279542e1cd8de785798067d4f0af6755f558fd Mon Sep 17 00:00:00 2001 From: Vladimir nett00n Budylnikov Date: Sat, 27 Sep 2025 21:45:55 +0400 Subject: [PATCH] gdlint fixes --- scenes/ui/DebugButton.gd | 4 +- tests/helpers/TestHelper.gd | 16 +-- tests/test_audio_manager.gd | 152 +++++++++++----------- tests/test_game_manager.gd | 114 ++++++++--------- tests/test_match3_gameplay.gd | 178 +++++++++++++------------- tests/test_migration_compatibility.gd | 18 +-- tests/test_scene_validation.gd | 32 ++--- tests/test_settings_manager.gd | 122 +++++++++--------- tests/test_tile.gd | 154 +++++++++++----------- tests/test_value_stepper.gd | 164 ++++++++++++------------ 10 files changed, 477 insertions(+), 477 deletions(-) diff --git a/scenes/ui/DebugButton.gd b/scenes/ui/DebugButton.gd index b47147f..5e55476 100644 --- a/scenes/ui/DebugButton.gd +++ b/scenes/ui/DebugButton.gd @@ -16,5 +16,5 @@ func _on_button_pressed(): DebugManager.toggle_debug_ui() -func _on_debug_ui_toggled(visible: bool): - button.text = "Debug UI: " + ("ON" if visible else "OFF") +func _on_debug_ui_toggled(is_debug_visible: bool): + button.text = "Debug UI: " + ("ON" if is_debug_visible else "OFF") diff --git a/tests/helpers/TestHelper.gd b/tests/helpers/TestHelper.gd index f64086b..091252b 100644 --- a/tests/helpers/TestHelper.gd +++ b/tests/helpers/TestHelper.gd @@ -91,21 +91,21 @@ static func assert_in_range(value: float, min_val: float, max_val: float, messag static func assert_float_equal(expected: float, actual: float, tolerance: float = 0.0001, message: String = ""): # Handle special cases: both infinity, both negative infinity, both NaN if is_inf(expected) and is_inf(actual): - var condition = (expected > 0) == (actual > 0) # Same sign of infinity - var full_message = "%s (Both infinity values: Expected: %f, Got: %f)" % [message, expected, actual] - assert_true(condition, full_message) + var infinity_condition = (expected > 0) == (actual > 0) # Same sign of infinity + var infinity_message = "%s (Both infinity values: Expected: %f, Got: %f)" % [message, expected, actual] + assert_true(infinity_condition, infinity_message) return if is_nan(expected) and is_nan(actual): - var full_message = "%s (Both NaN values: Expected: %f, Got: %f)" % [message, expected, actual] - assert_true(true, full_message) # Both NaN is considered equal + var nan_message = "%s (Both NaN values: Expected: %f, Got: %f)" % [message, expected, actual] + assert_true(true, nan_message) # Both NaN is considered equal return # Normal floating-point comparison var difference = abs(expected - actual) - var condition = difference <= tolerance - var full_message = "%s (Expected: %f, Got: %f, Difference: %f, Tolerance: %f)" % [message, expected, actual, difference, tolerance] - assert_true(condition, full_message) + var tolerance_condition = difference <= tolerance + var comparison_message = "%s (Expected: %f, Got: %f, Difference: %f, Tolerance: %f)" % [message, expected, actual, difference, tolerance] + assert_true(tolerance_condition, comparison_message) ## Assert that an array contains a specific value static func assert_contains(array: Array, value, message: String = ""): diff --git a/tests/test_audio_manager.gd b/tests/test_audio_manager.gd index 258ab21..b9e19b1 100644 --- a/tests/test_audio_manager.gd +++ b/tests/test_audio_manager.gd @@ -6,7 +6,7 @@ extends SceneTree ## audio bus configuration, and playback control functionality. ## Validates proper audio system initialization and error handling. -const TestHelper = preload("res://tests/helpers/TestHelper.gd") +const TestHelperClass = preload("res://tests/helpers/TestHelper.gd") var audio_manager: Node var original_music_volume: float @@ -25,13 +25,13 @@ func _initialize(): func run_tests(): - TestHelper.print_test_header("AudioManager") + TestHelperClass.print_test_header("AudioManager") # Get reference to AudioManager audio_manager = root.get_node("AudioManager") if not audio_manager: - TestHelper.assert_true(false, "AudioManager autoload not found") - TestHelper.print_test_footer("AudioManager") + TestHelperClass.assert_true(false, "AudioManager autoload not found") + TestHelperClass.print_test_footer("AudioManager") return # Store original settings for restoration @@ -54,14 +54,14 @@ func run_tests(): # Cleanup and restore original state cleanup_tests() - TestHelper.print_test_footer("AudioManager") + TestHelperClass.print_test_footer("AudioManager") func test_basic_functionality(): - TestHelper.print_step("Basic Functionality") + TestHelperClass.print_step("Basic Functionality") # Test that AudioManager has expected properties - TestHelper.assert_has_properties( + TestHelperClass.assert_has_properties( audio_manager, ["music_player", "ui_click_player", "click_stream"], "AudioManager properties" @@ -69,24 +69,24 @@ func test_basic_functionality(): # Test that AudioManager has expected methods var expected_methods = ["update_music_volume", "play_ui_click"] - TestHelper.assert_has_methods(audio_manager, expected_methods, "AudioManager methods") + TestHelperClass.assert_has_methods(audio_manager, expected_methods, "AudioManager methods") # Test that AudioManager has expected constants - TestHelper.assert_true("MUSIC_PATH" in audio_manager, "MUSIC_PATH constant exists") - TestHelper.assert_true( + TestHelperClass.assert_true("MUSIC_PATH" in audio_manager, "MUSIC_PATH constant exists") + TestHelperClass.assert_true( "UI_CLICK_SOUND_PATH" in audio_manager, "UI_CLICK_SOUND_PATH constant exists" ) func test_audio_constants(): - TestHelper.print_step("Audio File Constants") + TestHelperClass.print_step("Audio File Constants") # Test path format validation var music_path = audio_manager.MUSIC_PATH var click_path = audio_manager.UI_CLICK_SOUND_PATH - TestHelper.assert_true(music_path.begins_with("res://"), "Music path uses res:// protocol") - TestHelper.assert_true( + TestHelperClass.assert_true(music_path.begins_with("res://"), "Music path uses res:// protocol") + TestHelperClass.assert_true( click_path.begins_with("res://"), "Click sound path uses res:// protocol" ) @@ -101,92 +101,92 @@ func test_audio_constants(): if click_path.ends_with(ext): click_has_valid_ext = true - TestHelper.assert_true(music_has_valid_ext, "Music file has valid audio extension") - TestHelper.assert_true(click_has_valid_ext, "Click sound has valid audio extension") + TestHelperClass.assert_true(music_has_valid_ext, "Music file has valid audio extension") + TestHelperClass.assert_true(click_has_valid_ext, "Click sound has valid audio extension") # Test that audio files exist - TestHelper.assert_true(ResourceLoader.exists(music_path), "Music file exists at path") - TestHelper.assert_true(ResourceLoader.exists(click_path), "Click sound file exists at path") + TestHelperClass.assert_true(ResourceLoader.exists(music_path), "Music file exists at path") + TestHelperClass.assert_true(ResourceLoader.exists(click_path), "Click sound file exists at path") func test_audio_player_initialization(): - TestHelper.print_step("Audio Player Initialization") + TestHelperClass.print_step("Audio Player Initialization") # Test music player initialization - TestHelper.assert_not_null(audio_manager.music_player, "Music player is initialized") - TestHelper.assert_true( + TestHelperClass.assert_not_null(audio_manager.music_player, "Music player is initialized") + TestHelperClass.assert_true( audio_manager.music_player is AudioStreamPlayer, "Music player is AudioStreamPlayer type" ) - TestHelper.assert_true( + TestHelperClass.assert_true( audio_manager.music_player.get_parent() == audio_manager, "Music player is child of AudioManager" ) # Test UI click player initialization - TestHelper.assert_not_null(audio_manager.ui_click_player, "UI click player is initialized") - TestHelper.assert_true( + TestHelperClass.assert_not_null(audio_manager.ui_click_player, "UI click player is initialized") + TestHelperClass.assert_true( audio_manager.ui_click_player is AudioStreamPlayer, "UI click player is AudioStreamPlayer type" ) - TestHelper.assert_true( + TestHelperClass.assert_true( audio_manager.ui_click_player.get_parent() == audio_manager, "UI click player is child of AudioManager" ) # Test audio bus assignment - TestHelper.assert_equal( + TestHelperClass.assert_equal( "Music", audio_manager.music_player.bus, "Music player assigned to Music bus" ) - TestHelper.assert_equal( + TestHelperClass.assert_equal( "SFX", audio_manager.ui_click_player.bus, "UI click player assigned to SFX bus" ) func test_stream_loading_and_validation(): - TestHelper.print_step("Stream Loading and Validation") + TestHelperClass.print_step("Stream Loading and Validation") # Test music stream loading - TestHelper.assert_not_null(audio_manager.music_player.stream, "Music stream is loaded") + TestHelperClass.assert_not_null(audio_manager.music_player.stream, "Music stream is loaded") if audio_manager.music_player.stream: - TestHelper.assert_true( + TestHelperClass.assert_true( audio_manager.music_player.stream is AudioStream, "Music stream is AudioStream type" ) # Test click stream loading - TestHelper.assert_not_null(audio_manager.click_stream, "Click stream is loaded") + TestHelperClass.assert_not_null(audio_manager.click_stream, "Click stream is loaded") if audio_manager.click_stream: - TestHelper.assert_true( + TestHelperClass.assert_true( audio_manager.click_stream is AudioStream, "Click stream is AudioStream type" ) # Test stream resource loading directly var loaded_music = load(audio_manager.MUSIC_PATH) - TestHelper.assert_not_null(loaded_music, "Music resource loads successfully") - TestHelper.assert_true(loaded_music is AudioStream, "Loaded music is AudioStream type") + TestHelperClass.assert_not_null(loaded_music, "Music resource loads successfully") + TestHelperClass.assert_true(loaded_music is AudioStream, "Loaded music is AudioStream type") var loaded_click = load(audio_manager.UI_CLICK_SOUND_PATH) - TestHelper.assert_not_null(loaded_click, "Click resource loads successfully") - TestHelper.assert_true(loaded_click is AudioStream, "Loaded click sound is AudioStream type") + TestHelperClass.assert_not_null(loaded_click, "Click resource loads successfully") + TestHelperClass.assert_true(loaded_click is AudioStream, "Loaded click sound is AudioStream type") func test_audio_bus_configuration(): - TestHelper.print_step("Audio Bus Configuration") + TestHelperClass.print_step("Audio Bus Configuration") # Test that required audio buses exist var music_bus_index = AudioServer.get_bus_index("Music") var sfx_bus_index = AudioServer.get_bus_index("SFX") - TestHelper.assert_true(music_bus_index >= 0, "Music audio bus exists") - TestHelper.assert_true(sfx_bus_index >= 0, "SFX audio bus exists") + TestHelperClass.assert_true(music_bus_index >= 0, "Music audio bus exists") + TestHelperClass.assert_true(sfx_bus_index >= 0, "SFX audio bus exists") # Test player bus assignments match actual AudioServer buses if music_bus_index >= 0: - TestHelper.assert_equal( + TestHelperClass.assert_equal( "Music", audio_manager.music_player.bus, "Music player correctly assigned to Music bus" ) if sfx_bus_index >= 0: - TestHelper.assert_equal( + TestHelperClass.assert_equal( "SFX", audio_manager.ui_click_player.bus, "UI click player correctly assigned to SFX bus" @@ -194,29 +194,29 @@ func test_audio_bus_configuration(): func test_volume_management(): - TestHelper.print_step("Volume Management") + TestHelperClass.print_step("Volume Management") # Store original volume var settings_manager = root.get_node("SettingsManager") var original_volume = settings_manager.get_setting("music_volume") - var was_playing = audio_manager.music_player.playing + var _was_playing = audio_manager.music_player.playing # Test volume update to valid range audio_manager.update_music_volume(0.5) - TestHelper.assert_float_equal( + TestHelperClass.assert_float_equal( linear_to_db(0.5), audio_manager.music_player.volume_db, 0.001, "Music volume set correctly" ) # Test volume update to zero (should stop music) audio_manager.update_music_volume(0.0) - TestHelper.assert_equal( + TestHelperClass.assert_equal( linear_to_db(0.0), audio_manager.music_player.volume_db, "Zero volume set correctly" ) # Note: We don't test playing state as it depends on initialization conditions # Test volume update to maximum audio_manager.update_music_volume(1.0) - TestHelper.assert_equal( + TestHelperClass.assert_equal( linear_to_db(1.0), audio_manager.music_player.volume_db, "Maximum volume set correctly" ) @@ -225,7 +225,7 @@ func test_volume_management(): for volume in test_volumes: audio_manager.update_music_volume(volume) var expected_db = linear_to_db(volume) - TestHelper.assert_float_equal( + TestHelperClass.assert_float_equal( expected_db, audio_manager.music_player.volume_db, 0.001, @@ -237,53 +237,53 @@ func test_volume_management(): func test_music_playback_control(): - TestHelper.print_step("Music Playback Control") + TestHelperClass.print_step("Music Playback Control") # Test that music player exists and has a stream - TestHelper.assert_not_null( + TestHelperClass.assert_not_null( audio_manager.music_player, "Music player exists for playback testing" ) - TestHelper.assert_not_null( + TestHelperClass.assert_not_null( audio_manager.music_player.stream, "Music player has stream for playback testing" ) # Test playback state management # Note: We test the control methods exist and can be called safely - var original_playing = audio_manager.music_player.playing + var _original_playing = audio_manager.music_player.playing # Test that playback methods can be called without errors if audio_manager.has_method("_start_music"): # Method exists but is private - test that the logic is sound - TestHelper.assert_true(true, "Private _start_music method exists") + TestHelperClass.assert_true(true, "Private _start_music method exists") if audio_manager.has_method("_stop_music"): # Method exists but is private - test that the logic is sound - TestHelper.assert_true(true, "Private _stop_music method exists") + TestHelperClass.assert_true(true, "Private _stop_music method exists") # Test volume-based playback control var settings_manager = root.get_node("SettingsManager") var current_volume = settings_manager.get_setting("music_volume") if current_volume > 0.0: audio_manager.update_music_volume(current_volume) - TestHelper.assert_true(true, "Volume-based playback start works") + TestHelperClass.assert_true(true, "Volume-based playback start works") else: audio_manager.update_music_volume(0.0) - TestHelper.assert_true(true, "Volume-based playback stop works") + TestHelperClass.assert_true(true, "Volume-based playback stop works") func test_ui_sound_effects(): - TestHelper.print_step("UI Sound Effects") + TestHelperClass.print_step("UI Sound Effects") # Test UI click functionality - TestHelper.assert_not_null(audio_manager.ui_click_player, "UI click player exists") - TestHelper.assert_not_null(audio_manager.click_stream, "Click stream is loaded") + TestHelperClass.assert_not_null(audio_manager.ui_click_player, "UI click player exists") + TestHelperClass.assert_not_null(audio_manager.click_stream, "Click stream is loaded") # Test that play_ui_click can be called safely - var original_stream = audio_manager.ui_click_player.stream + var _original_stream = audio_manager.ui_click_player.stream audio_manager.play_ui_click() # Verify click stream was assigned to player - TestHelper.assert_equal( + TestHelperClass.assert_equal( audio_manager.click_stream, audio_manager.ui_click_player.stream, "Click stream assigned to player" @@ -292,18 +292,18 @@ func test_ui_sound_effects(): # Test multiple rapid clicks (should not cause errors) for i in range(3): audio_manager.play_ui_click() - TestHelper.assert_true(true, "Rapid click %d handled safely" % (i + 1)) + TestHelperClass.assert_true(true, "Rapid click %d handled safely" % (i + 1)) # Test click with null stream var backup_stream = audio_manager.click_stream audio_manager.click_stream = null audio_manager.play_ui_click() # Should not crash - TestHelper.assert_true(true, "Null click stream handled safely") + TestHelperClass.assert_true(true, "Null click stream handled safely") audio_manager.click_stream = backup_stream func test_stream_loop_configuration(): - TestHelper.print_step("Stream Loop Configuration") + TestHelperClass.print_step("Stream Loop Configuration") # Test that music stream has loop configuration var music_stream = audio_manager.music_player.stream @@ -311,9 +311,9 @@ func test_stream_loop_configuration(): if music_stream is AudioStreamWAV: # For WAV files, check loop mode var has_loop_mode = "loop_mode" in music_stream - TestHelper.assert_true(has_loop_mode, "WAV stream has loop_mode property") + TestHelperClass.assert_true(has_loop_mode, "WAV stream has loop_mode property") if has_loop_mode: - TestHelper.assert_equal( + TestHelperClass.assert_equal( AudioStreamWAV.LOOP_FORWARD, music_stream.loop_mode, "WAV stream set to forward loop" @@ -321,30 +321,30 @@ func test_stream_loop_configuration(): elif music_stream is AudioStreamOggVorbis: # For OGG files, check loop property var has_loop = "loop" in music_stream - TestHelper.assert_true(has_loop, "OGG stream has loop property") + TestHelperClass.assert_true(has_loop, "OGG stream has loop property") if has_loop: - TestHelper.assert_true(music_stream.loop, "OGG stream loop enabled") + TestHelperClass.assert_true(music_stream.loop, "OGG stream loop enabled") # Test loop configuration for different stream types - TestHelper.assert_true(true, "Stream loop configuration tested based on type") + TestHelperClass.assert_true(true, "Stream loop configuration tested based on type") func test_error_handling(): - TestHelper.print_step("Error Handling") + TestHelperClass.print_step("Error Handling") # Test graceful handling of missing resources # We can't actually break the resources in tests, but we can verify error handling patterns # Test that AudioManager initializes even with potential issues - TestHelper.assert_not_null( + TestHelperClass.assert_not_null( audio_manager, "AudioManager initializes despite potential resource issues" ) # Test that players are still created even if streams fail to load - TestHelper.assert_not_null( + TestHelperClass.assert_not_null( audio_manager.music_player, "Music player created regardless of stream loading" ) - TestHelper.assert_not_null( + TestHelperClass.assert_not_null( audio_manager.ui_click_player, "UI click player created regardless of stream loading" ) @@ -354,21 +354,21 @@ func test_error_handling(): # This should not crash audio_manager.play_ui_click() - TestHelper.assert_true(true, "play_ui_click handles null stream gracefully") + TestHelperClass.assert_true(true, "play_ui_click handles null stream gracefully") # Restore original stream audio_manager.click_stream = original_click_stream # Test volume edge cases audio_manager.update_music_volume(0.0) - TestHelper.assert_true(true, "Zero volume handled safely") + TestHelperClass.assert_true(true, "Zero volume handled safely") audio_manager.update_music_volume(1.0) - TestHelper.assert_true(true, "Maximum volume handled safely") + TestHelperClass.assert_true(true, "Maximum volume handled safely") func cleanup_tests(): - TestHelper.print_step("Cleanup") + TestHelperClass.print_step("Cleanup") # Restore original volume settings var settings_manager = root.get_node("SettingsManager") @@ -378,4 +378,4 @@ func cleanup_tests(): # Update AudioManager to original settings audio_manager.update_music_volume(original_music_volume) - TestHelper.assert_true(true, "Test cleanup completed") + TestHelperClass.assert_true(true, "Test cleanup completed") diff --git a/tests/test_game_manager.gd b/tests/test_game_manager.gd index 46806bc..47481d2 100644 --- a/tests/test_game_manager.gd +++ b/tests/test_game_manager.gd @@ -4,7 +4,7 @@ extends SceneTree ## ## Tests scene transitions, input validation, and gameplay modes. -const TestHelper = preload("res://tests/helpers/TestHelper.gd") +const TestHelperClass = preload("res://tests/helpers/TestHelper.gd") var game_manager: Node var original_scene: Node @@ -23,13 +23,13 @@ func _initialize(): func run_tests(): - TestHelper.print_test_header("GameManager") + TestHelperClass.print_test_header("GameManager") # Get reference to GameManager game_manager = root.get_node("GameManager") if not game_manager: - TestHelper.assert_true(false, "GameManager autoload not found") - TestHelper.print_test_footer("GameManager") + TestHelperClass.assert_true(false, "GameManager autoload not found") + TestHelperClass.print_test_footer("GameManager") return # Store original scene reference @@ -49,14 +49,14 @@ func run_tests(): # Cleanup cleanup_tests() - TestHelper.print_test_footer("GameManager") + TestHelperClass.print_test_footer("GameManager") func test_basic_functionality(): - TestHelper.print_step("Basic Functionality") + TestHelperClass.print_step("Basic Functionality") # Test that GameManager has expected properties - TestHelper.assert_has_properties( + TestHelperClass.assert_has_properties( game_manager, ["pending_gameplay_mode", "is_changing_scene"], "GameManager properties" ) @@ -70,83 +70,83 @@ func test_basic_functionality(): "save_game", "exit_to_main_menu" ] - TestHelper.assert_has_methods(game_manager, expected_methods, "GameManager methods") + TestHelperClass.assert_has_methods(game_manager, expected_methods, "GameManager methods") # Test initial state - TestHelper.assert_equal( + TestHelperClass.assert_equal( "match3", game_manager.pending_gameplay_mode, "Default pending gameplay mode" ) - TestHelper.assert_false(game_manager.is_changing_scene, "Initial scene change flag") + TestHelperClass.assert_false(game_manager.is_changing_scene, "Initial scene change flag") func test_scene_constants(): - TestHelper.print_step("Scene Path Constants") + TestHelperClass.print_step("Scene Path Constants") # Test that scene path constants are defined and valid - TestHelper.assert_true("GAME_SCENE_PATH" in game_manager, "GAME_SCENE_PATH constant exists") - TestHelper.assert_true("MAIN_SCENE_PATH" in game_manager, "MAIN_SCENE_PATH constant exists") + TestHelperClass.assert_true("GAME_SCENE_PATH" in game_manager, "GAME_SCENE_PATH constant exists") + TestHelperClass.assert_true("MAIN_SCENE_PATH" in game_manager, "MAIN_SCENE_PATH constant exists") # Test path format validation var game_path = game_manager.GAME_SCENE_PATH var main_path = game_manager.MAIN_SCENE_PATH - TestHelper.assert_true(game_path.begins_with("res://"), "Game scene path uses res:// protocol") - TestHelper.assert_true(game_path.ends_with(".tscn"), "Game scene path has .tscn extension") - TestHelper.assert_true(main_path.begins_with("res://"), "Main scene path uses res:// protocol") - TestHelper.assert_true(main_path.ends_with(".tscn"), "Main scene path has .tscn extension") + TestHelperClass.assert_true(game_path.begins_with("res://"), "Game scene path uses res:// protocol") + TestHelperClass.assert_true(game_path.ends_with(".tscn"), "Game scene path has .tscn extension") + TestHelperClass.assert_true(main_path.begins_with("res://"), "Main scene path uses res:// protocol") + TestHelperClass.assert_true(main_path.ends_with(".tscn"), "Main scene path has .tscn extension") # Test that scene files exist - TestHelper.assert_true(ResourceLoader.exists(game_path), "Game scene file exists at path") - TestHelper.assert_true(ResourceLoader.exists(main_path), "Main scene file exists at path") + TestHelperClass.assert_true(ResourceLoader.exists(game_path), "Game scene file exists at path") + TestHelperClass.assert_true(ResourceLoader.exists(main_path), "Main scene file exists at path") func test_input_validation(): - TestHelper.print_step("Input Validation") + TestHelperClass.print_step("Input Validation") # Store original state - var original_changing = game_manager.is_changing_scene + var _original_changing = game_manager.is_changing_scene var original_mode = game_manager.pending_gameplay_mode # Test empty string validation game_manager.start_game_with_mode("") - TestHelper.assert_equal( + TestHelperClass.assert_equal( original_mode, game_manager.pending_gameplay_mode, "Empty string mode rejected" ) - TestHelper.assert_false( + TestHelperClass.assert_false( game_manager.is_changing_scene, "Scene change flag unchanged after empty mode" ) # Test null validation - GameManager expects String, so this tests the type safety # Note: In Godot 4.4, passing null to String parameter causes script error as expected # The function properly validates empty strings instead - TestHelper.assert_equal( + TestHelperClass.assert_equal( original_mode, game_manager.pending_gameplay_mode, "Mode preserved after empty string test" ) - TestHelper.assert_false( + TestHelperClass.assert_false( game_manager.is_changing_scene, "Scene change flag unchanged after validation tests" ) # Test invalid mode validation game_manager.start_game_with_mode("invalid_mode") - TestHelper.assert_equal( + TestHelperClass.assert_equal( original_mode, game_manager.pending_gameplay_mode, "Invalid mode rejected" ) - TestHelper.assert_false( + TestHelperClass.assert_false( game_manager.is_changing_scene, "Scene change flag unchanged after invalid mode" ) # Test case sensitivity game_manager.start_game_with_mode("MATCH3") - TestHelper.assert_equal( + TestHelperClass.assert_equal( original_mode, game_manager.pending_gameplay_mode, "Case-sensitive mode validation" ) - TestHelper.assert_false( + TestHelperClass.assert_false( game_manager.is_changing_scene, "Scene change flag unchanged after wrong case" ) func test_race_condition_protection(): - TestHelper.print_step("Race Condition Protection") + TestHelperClass.print_step("Race Condition Protection") # Store original state var original_mode = game_manager.pending_gameplay_mode @@ -156,14 +156,14 @@ func test_race_condition_protection(): game_manager.start_game_with_mode("match3") # Verify second request was rejected - TestHelper.assert_equal( + TestHelperClass.assert_equal( original_mode, game_manager.pending_gameplay_mode, "Concurrent scene change blocked" ) - TestHelper.assert_true(game_manager.is_changing_scene, "Scene change flag preserved") + TestHelperClass.assert_true(game_manager.is_changing_scene, "Scene change flag preserved") # Test exit to main menu during scene change game_manager.exit_to_main_menu() - TestHelper.assert_true( + TestHelperClass.assert_true( game_manager.is_changing_scene, "Exit request blocked during scene change" ) @@ -172,28 +172,28 @@ func test_race_condition_protection(): func test_gameplay_mode_validation(): - TestHelper.print_step("Gameplay Mode Validation") + TestHelperClass.print_step("Gameplay Mode Validation") # Test valid modes var valid_modes = ["match3", "clickomania"] for mode in valid_modes: - var original_changing = game_manager.is_changing_scene + var _original_changing = game_manager.is_changing_scene # We'll test the validation logic without actually changing scenes # by checking if the function would accept the mode # Create a temporary mock to test validation var test_mode_valid = mode in ["match3", "clickomania"] - TestHelper.assert_true(test_mode_valid, "Valid mode accepted: " + mode) + TestHelperClass.assert_true(test_mode_valid, "Valid mode accepted: " + mode) # Test whitelist enforcement var invalid_modes = ["puzzle", "arcade", "adventure", "rpg", "action"] for mode in invalid_modes: var test_mode_invalid = not (mode in ["match3", "clickomania"]) - TestHelper.assert_true(test_mode_invalid, "Invalid mode rejected: " + mode) + TestHelperClass.assert_true(test_mode_invalid, "Invalid mode rejected: " + mode) func test_scene_transition_safety(): - TestHelper.print_step("Scene Transition Safety") + TestHelperClass.print_step("Scene Transition Safety") # Test scene loading validation (without actually changing scenes) var game_scene_path = game_manager.GAME_SCENE_PATH @@ -201,19 +201,19 @@ func test_scene_transition_safety(): # Test scene resource loading var game_scene = load(game_scene_path) - TestHelper.assert_not_null(game_scene, "Game scene resource loads successfully") - TestHelper.assert_true(game_scene is PackedScene, "Game scene is PackedScene type") + TestHelperClass.assert_not_null(game_scene, "Game scene resource loads successfully") + TestHelperClass.assert_true(game_scene is PackedScene, "Game scene is PackedScene type") var main_scene = load(main_scene_path) - TestHelper.assert_not_null(main_scene, "Main scene resource loads successfully") - TestHelper.assert_true(main_scene is PackedScene, "Main scene is PackedScene type") + TestHelperClass.assert_not_null(main_scene, "Main scene resource loads successfully") + TestHelperClass.assert_true(main_scene is PackedScene, "Main scene is PackedScene type") # Test that current scene exists - TestHelper.assert_not_null(current_scene, "Current scene exists") + TestHelperClass.assert_not_null(current_scene, "Current scene exists") func test_error_handling(): - TestHelper.print_step("Error Handling") + TestHelperClass.print_step("Error Handling") # Store original state var original_changing = game_manager.is_changing_scene @@ -225,26 +225,26 @@ func test_error_handling(): # Verify state preservation after invalid inputs game_manager.start_game_with_mode("") - TestHelper.assert_equal( + TestHelperClass.assert_equal( original_changing, game_manager.is_changing_scene, "State preserved after empty mode error" ) - TestHelper.assert_equal( + TestHelperClass.assert_equal( original_mode, game_manager.pending_gameplay_mode, "Mode preserved after empty mode error" ) game_manager.start_game_with_mode("invalid") - TestHelper.assert_equal( + TestHelperClass.assert_equal( original_changing, game_manager.is_changing_scene, "State preserved after invalid mode error" ) - TestHelper.assert_equal( + TestHelperClass.assert_equal( original_mode, game_manager.pending_gameplay_mode, "Mode preserved after invalid mode error" ) func test_scene_method_validation(): - TestHelper.print_step("Scene Method Validation") + TestHelperClass.print_step("Scene Method Validation") # Test that GameManager properly checks for required methods # We'll create a mock scene to test method validation @@ -255,16 +255,16 @@ func test_scene_method_validation(): var has_set_global_score = mock_scene.has_method("set_global_score") var has_get_global_score = mock_scene.has_method("get_global_score") - TestHelper.assert_false(has_set_gameplay_mode, "Mock scene lacks set_gameplay_mode method") - TestHelper.assert_false(has_set_global_score, "Mock scene lacks set_global_score method") - TestHelper.assert_false(has_get_global_score, "Mock scene lacks get_global_score method") + TestHelperClass.assert_false(has_set_gameplay_mode, "Mock scene lacks set_gameplay_mode method") + TestHelperClass.assert_false(has_set_global_score, "Mock scene lacks set_global_score method") + TestHelperClass.assert_false(has_get_global_score, "Mock scene lacks get_global_score method") # Clean up mock scene mock_scene.queue_free() func test_pending_mode_management(): - TestHelper.print_step("Pending Mode Management") + TestHelperClass.print_step("Pending Mode Management") # Store original mode var original_mode = game_manager.pending_gameplay_mode @@ -275,7 +275,7 @@ func test_pending_mode_management(): if test_mode in ["match3", "clickomania"]: # This simulates what would happen in start_game_with_mode game_manager.pending_gameplay_mode = test_mode - TestHelper.assert_equal( + TestHelperClass.assert_equal( test_mode, game_manager.pending_gameplay_mode, "Pending mode set correctly" ) @@ -285,7 +285,7 @@ func test_pending_mode_management(): # Attempt invalid operation (this should not change pending mode) # The actual start_game_with_mode with invalid input won't change pending_gameplay_mode - TestHelper.assert_equal( + TestHelperClass.assert_equal( preserved_mode, game_manager.pending_gameplay_mode, "Mode preserved during invalid operations" @@ -296,7 +296,7 @@ func test_pending_mode_management(): func cleanup_tests(): - TestHelper.print_step("Cleanup") + TestHelperClass.print_step("Cleanup") # Reset GameManager state game_manager.is_changing_scene = false @@ -308,4 +308,4 @@ func cleanup_tests(): # Note: Can't actually delete from res:// in tests, just track for manual cleanup pass - TestHelper.assert_true(true, "Test cleanup completed") + TestHelperClass.assert_true(true, "Test cleanup completed") diff --git a/tests/test_match3_gameplay.gd b/tests/test_match3_gameplay.gd index 66dd447..8d29e9f 100644 --- a/tests/test_match3_gameplay.gd +++ b/tests/test_match3_gameplay.gd @@ -4,7 +4,7 @@ extends SceneTree ## ## Tests grid initialization, match detection, and scoring system. -const TestHelper = preload("res://tests/helpers/TestHelper.gd") +const TestHelperClass = preload("res://tests/helpers/TestHelper.gd") var match3_scene: PackedScene var match3_instance: Node2D @@ -23,7 +23,7 @@ func _initialize(): func run_tests(): - TestHelper.print_test_header("Match3 Gameplay") + TestHelperClass.print_test_header("Match3 Gameplay") # Setup test environment setup_test_environment() @@ -43,15 +43,15 @@ func run_tests(): # Cleanup cleanup_tests() - TestHelper.print_test_footer("Match3 Gameplay") + TestHelperClass.print_test_footer("Match3 Gameplay") func setup_test_environment(): - TestHelper.print_step("Test Environment Setup") + TestHelperClass.print_step("Test Environment Setup") # Load Match3 scene match3_scene = load("res://scenes/game/gameplays/match3_gameplay.tscn") - TestHelper.assert_not_null(match3_scene, "Match3 scene loads successfully") + TestHelperClass.assert_not_null(match3_scene, "Match3 scene loads successfully") # Create test viewport for isolated testing test_viewport = SubViewport.new() @@ -62,7 +62,7 @@ func setup_test_environment(): if match3_scene: match3_instance = match3_scene.instantiate() test_viewport.add_child(match3_instance) - TestHelper.assert_not_null(match3_instance, "Match3 instance created successfully") + TestHelperClass.assert_not_null(match3_instance, "Match3 instance created successfully") # Wait for initialization await process_frame @@ -70,10 +70,10 @@ func setup_test_environment(): func test_basic_functionality(): - TestHelper.print_step("Basic Functionality") + TestHelperClass.print_step("Basic Functionality") if not match3_instance: - TestHelper.assert_true(false, "Match3 instance not available for testing") + TestHelperClass.assert_true(false, "Match3 instance not available for testing") return # Test that Match3 has expected properties @@ -81,61 +81,61 @@ func test_basic_functionality(): "GRID_SIZE", "TILE_TYPES", "grid", "current_state", "selected_tile", "cursor_position" ] for prop in expected_properties: - TestHelper.assert_true(prop in match3_instance, "Match3 has property: " + prop) + TestHelperClass.assert_true(prop in match3_instance, "Match3 has property: " + prop) # Test that Match3 has expected methods var expected_methods = [ "_has_match_at", "_check_for_matches", "_get_match_line", "_clear_matches" ] - TestHelper.assert_has_methods(match3_instance, expected_methods, "Match3 gameplay methods") + TestHelperClass.assert_has_methods(match3_instance, expected_methods, "Match3 gameplay methods") # Test signals - TestHelper.assert_true( + TestHelperClass.assert_true( match3_instance.has_signal("score_changed"), "Match3 has score_changed signal" ) - TestHelper.assert_true( + TestHelperClass.assert_true( match3_instance.has_signal("grid_state_loaded"), "Match3 has grid_state_loaded signal" ) func test_constants_and_safety_limits(): - TestHelper.print_step("Constants and Safety Limits") + TestHelperClass.print_step("Constants and Safety Limits") if not match3_instance: return # Test safety constants exist - TestHelper.assert_true("MAX_GRID_SIZE" in match3_instance, "MAX_GRID_SIZE constant exists") - TestHelper.assert_true("MAX_TILE_TYPES" in match3_instance, "MAX_TILE_TYPES constant exists") - TestHelper.assert_true( + TestHelperClass.assert_true("MAX_GRID_SIZE" in match3_instance, "MAX_GRID_SIZE constant exists") + TestHelperClass.assert_true("MAX_TILE_TYPES" in match3_instance, "MAX_TILE_TYPES constant exists") + TestHelperClass.assert_true( "MAX_CASCADE_ITERATIONS" in match3_instance, "MAX_CASCADE_ITERATIONS constant exists" ) - TestHelper.assert_true("MIN_GRID_SIZE" in match3_instance, "MIN_GRID_SIZE constant exists") - TestHelper.assert_true("MIN_TILE_TYPES" in match3_instance, "MIN_TILE_TYPES constant exists") + TestHelperClass.assert_true("MIN_GRID_SIZE" in match3_instance, "MIN_GRID_SIZE constant exists") + TestHelperClass.assert_true("MIN_TILE_TYPES" in match3_instance, "MIN_TILE_TYPES constant exists") # Test safety limit values are reasonable - TestHelper.assert_equal(15, match3_instance.MAX_GRID_SIZE, "MAX_GRID_SIZE is reasonable") - TestHelper.assert_equal(10, match3_instance.MAX_TILE_TYPES, "MAX_TILE_TYPES is reasonable") - TestHelper.assert_equal( + TestHelperClass.assert_equal(15, match3_instance.MAX_GRID_SIZE, "MAX_GRID_SIZE is reasonable") + TestHelperClass.assert_equal(10, match3_instance.MAX_TILE_TYPES, "MAX_TILE_TYPES is reasonable") + TestHelperClass.assert_equal( 20, match3_instance.MAX_CASCADE_ITERATIONS, "MAX_CASCADE_ITERATIONS prevents infinite loops" ) - TestHelper.assert_equal(3, match3_instance.MIN_GRID_SIZE, "MIN_GRID_SIZE is reasonable") - TestHelper.assert_equal(3, match3_instance.MIN_TILE_TYPES, "MIN_TILE_TYPES is reasonable") + TestHelperClass.assert_equal(3, match3_instance.MIN_GRID_SIZE, "MIN_GRID_SIZE is reasonable") + TestHelperClass.assert_equal(3, match3_instance.MIN_TILE_TYPES, "MIN_TILE_TYPES is reasonable") # Test current values are within safety limits - TestHelper.assert_in_range( + TestHelperClass.assert_in_range( match3_instance.GRID_SIZE.x, match3_instance.MIN_GRID_SIZE, match3_instance.MAX_GRID_SIZE, "Grid width within safety limits" ) - TestHelper.assert_in_range( + TestHelperClass.assert_in_range( match3_instance.GRID_SIZE.y, match3_instance.MIN_GRID_SIZE, match3_instance.MAX_GRID_SIZE, "Grid height within safety limits" ) - TestHelper.assert_in_range( + TestHelperClass.assert_in_range( match3_instance.TILE_TYPES, match3_instance.MIN_TILE_TYPES, match3_instance.MAX_TILE_TYPES, @@ -143,37 +143,37 @@ func test_constants_and_safety_limits(): ) # Test timing constants - TestHelper.assert_true( + TestHelperClass.assert_true( "CASCADE_WAIT_TIME" in match3_instance, "CASCADE_WAIT_TIME constant exists" ) - TestHelper.assert_true( + TestHelperClass.assert_true( "SWAP_ANIMATION_TIME" in match3_instance, "SWAP_ANIMATION_TIME constant exists" ) - TestHelper.assert_true( + TestHelperClass.assert_true( "TILE_DROP_WAIT_TIME" in match3_instance, "TILE_DROP_WAIT_TIME constant exists" ) func test_grid_initialization(): - TestHelper.print_step("Grid Initialization") + TestHelperClass.print_step("Grid Initialization") if not match3_instance: return # Test grid structure - TestHelper.assert_not_null(match3_instance.grid, "Grid array is initialized") - TestHelper.assert_true(match3_instance.grid is Array, "Grid is Array type") + TestHelperClass.assert_not_null(match3_instance.grid, "Grid array is initialized") + TestHelperClass.assert_true(match3_instance.grid is Array, "Grid is Array type") # Test grid dimensions var expected_height = match3_instance.GRID_SIZE.y var expected_width = match3_instance.GRID_SIZE.x - TestHelper.assert_equal(expected_height, match3_instance.grid.size(), "Grid has correct height") + TestHelperClass.assert_equal(expected_height, match3_instance.grid.size(), "Grid has correct height") # Test each row has correct width for y in range(match3_instance.grid.size()): if y < expected_height: - TestHelper.assert_equal( + TestHelperClass.assert_equal( expected_width, match3_instance.grid[y].size(), "Grid row %d has correct width" % y ) @@ -188,89 +188,89 @@ func test_grid_initialization(): if tile and is_instance_valid(tile): valid_tile_count += 1 - TestHelper.assert_true( + TestHelperClass.assert_true( "tile_type" in tile, "Tile at (%d,%d) has tile_type property" % [x, y] ) - TestHelper.assert_true( + TestHelperClass.assert_true( "grid_position" in tile, "Tile at (%d,%d) has grid_position property" % [x, y] ) # Test tile type is within valid range if "tile_type" in tile: - TestHelper.assert_in_range( + TestHelperClass.assert_in_range( tile.tile_type, 0, match3_instance.TILE_TYPES - 1, "Tile type in valid range" ) - TestHelper.assert_equal(tile_count, valid_tile_count, "All grid positions have valid tiles") + TestHelperClass.assert_equal(tile_count, valid_tile_count, "All grid positions have valid tiles") func test_grid_layout_calculation(): - TestHelper.print_step("Grid Layout Calculation") + TestHelperClass.print_step("Grid Layout Calculation") if not match3_instance: return # Test tile size calculation - TestHelper.assert_true(match3_instance.tile_size > 0, "Tile size is positive") - TestHelper.assert_true( + TestHelperClass.assert_true(match3_instance.tile_size > 0, "Tile size is positive") + TestHelperClass.assert_true( match3_instance.tile_size <= 200, "Tile size is reasonable (not too large)" ) # Test grid offset - TestHelper.assert_not_null(match3_instance.grid_offset, "Grid offset is set") - TestHelper.assert_true(match3_instance.grid_offset.x >= 0, "Grid offset X is non-negative") - TestHelper.assert_true(match3_instance.grid_offset.y >= 0, "Grid offset Y is non-negative") + TestHelperClass.assert_not_null(match3_instance.grid_offset, "Grid offset is set") + TestHelperClass.assert_true(match3_instance.grid_offset.x >= 0, "Grid offset X is non-negative") + TestHelperClass.assert_true(match3_instance.grid_offset.y >= 0, "Grid offset Y is non-negative") # Test layout constants - TestHelper.assert_equal(0.8, match3_instance.SCREEN_WIDTH_USAGE, "Screen width usage constant") - TestHelper.assert_equal( + TestHelperClass.assert_equal(0.8, match3_instance.SCREEN_WIDTH_USAGE, "Screen width usage constant") + TestHelperClass.assert_equal( 0.7, match3_instance.SCREEN_HEIGHT_USAGE, "Screen height usage constant" ) - TestHelper.assert_equal(50.0, match3_instance.GRID_LEFT_MARGIN, "Grid left margin constant") - TestHelper.assert_equal(50.0, match3_instance.GRID_TOP_MARGIN, "Grid top margin constant") + TestHelperClass.assert_equal(50.0, match3_instance.GRID_LEFT_MARGIN, "Grid left margin constant") + TestHelperClass.assert_equal(50.0, match3_instance.GRID_TOP_MARGIN, "Grid top margin constant") func test_state_management(): - TestHelper.print_step("State Management") + TestHelperClass.print_step("State Management") if not match3_instance: return # Test GameState enum exists and has expected values - var game_state_class = match3_instance.get_script().get_global_class() - TestHelper.assert_true("GameState" in match3_instance, "GameState enum accessible") + var _game_state_class = match3_instance.get_script().get_global_class() + TestHelperClass.assert_true("GameState" in match3_instance, "GameState enum accessible") # Test current state is valid - TestHelper.assert_not_null(match3_instance.current_state, "Current state is set") + TestHelperClass.assert_not_null(match3_instance.current_state, "Current state is set") # Test initialization flags - TestHelper.assert_true("grid_initialized" in match3_instance, "Grid initialized flag exists") - TestHelper.assert_true(match3_instance.grid_initialized, "Grid is marked as initialized") + TestHelperClass.assert_true("grid_initialized" in match3_instance, "Grid initialized flag exists") + TestHelperClass.assert_true(match3_instance.grid_initialized, "Grid is marked as initialized") # Test instance ID for debugging - TestHelper.assert_true("instance_id" in match3_instance, "Instance ID exists for debugging") - TestHelper.assert_true( + TestHelperClass.assert_true("instance_id" in match3_instance, "Instance ID exists for debugging") + TestHelperClass.assert_true( match3_instance.instance_id.begins_with("Match3_"), "Instance ID has correct format" ) func test_match_detection(): - TestHelper.print_step("Match Detection Logic") + TestHelperClass.print_step("Match Detection Logic") if not match3_instance: return # Test match detection methods exist and can be called safely - TestHelper.assert_true( + TestHelperClass.assert_true( match3_instance.has_method("_has_match_at"), "_has_match_at method exists" ) - TestHelper.assert_true( + TestHelperClass.assert_true( match3_instance.has_method("_check_for_matches"), "_check_for_matches method exists" ) - TestHelper.assert_true( + TestHelperClass.assert_true( match3_instance.has_method("_get_match_line"), "_get_match_line method exists" ) @@ -285,20 +285,20 @@ func test_match_detection(): for pos in invalid_positions: var result = match3_instance._has_match_at(pos) - TestHelper.assert_false(result, "Invalid position (%d,%d) returns false" % [pos.x, pos.y]) + TestHelperClass.assert_false(result, "Invalid position (%d,%d) returns false" % [pos.x, pos.y]) # Test valid positions don't crash for y in range(min(3, match3_instance.GRID_SIZE.y)): for x in range(min(3, match3_instance.GRID_SIZE.x)): var pos = Vector2i(x, y) var result = match3_instance._has_match_at(pos) - TestHelper.assert_true( + TestHelperClass.assert_true( result is bool, "Valid position (%d,%d) returns boolean" % [x, y] ) func test_scoring_system(): - TestHelper.print_step("Scoring System") + TestHelperClass.print_step("Scoring System") if not match3_instance: return @@ -307,12 +307,12 @@ func test_scoring_system(): # The scoring system uses: 3 gems = 3 points, 4+ gems = n + (n-2) points # Test that the match3 instance can handle scoring (indirectly through clearing matches) - TestHelper.assert_true( + TestHelperClass.assert_true( match3_instance.has_method("_clear_matches"), "Scoring system method exists" ) # Test that score_changed signal exists - TestHelper.assert_true( + TestHelperClass.assert_true( match3_instance.has_signal("score_changed"), "Score changed signal exists" ) @@ -327,47 +327,47 @@ func test_scoring_system(): else: calculated_score = match_size + max(0, match_size - 2) - TestHelper.assert_equal( + TestHelperClass.assert_equal( expected_score, calculated_score, "Scoring formula correct for %d gems" % match_size ) func test_input_validation(): - TestHelper.print_step("Input Validation") + TestHelperClass.print_step("Input Validation") if not match3_instance: return # Test cursor position bounds - TestHelper.assert_not_null(match3_instance.cursor_position, "Cursor position is initialized") - TestHelper.assert_true( + TestHelperClass.assert_not_null(match3_instance.cursor_position, "Cursor position is initialized") + TestHelperClass.assert_true( match3_instance.cursor_position is Vector2i, "Cursor position is Vector2i type" ) # Test keyboard navigation flag - TestHelper.assert_true( + TestHelperClass.assert_true( "keyboard_navigation_enabled" in match3_instance, "Keyboard navigation flag exists" ) - TestHelper.assert_true( + TestHelperClass.assert_true( match3_instance.keyboard_navigation_enabled is bool, "Keyboard navigation flag is boolean" ) # Test selected tile safety # selected_tile can be null initially, which is valid if match3_instance.selected_tile: - TestHelper.assert_true( + TestHelperClass.assert_true( is_instance_valid(match3_instance.selected_tile), "Selected tile is valid if not null" ) func test_memory_safety(): - TestHelper.print_step("Memory Safety") + TestHelperClass.print_step("Memory Safety") if not match3_instance: return # Test grid integrity validation - TestHelper.assert_true( + TestHelperClass.assert_true( match3_instance.has_method("_validate_grid_integrity"), "Grid integrity validation method exists" ) @@ -377,63 +377,63 @@ func test_memory_safety(): for x in range(min(3, match3_instance.grid[y].size())): var tile = match3_instance.grid[y][x] if tile: - TestHelper.assert_true( + TestHelperClass.assert_true( is_instance_valid(tile), "Grid tile at (%d,%d) is valid instance" % [x, y] ) - TestHelper.assert_true( + TestHelperClass.assert_true( tile.get_parent() == match3_instance, "Tile properly parented to Match3" ) # Test position validation - TestHelper.assert_true( + TestHelperClass.assert_true( match3_instance.has_method("_is_valid_grid_position"), "Position validation method exists" ) # Test safe tile access patterns exist # The Match3 code uses comprehensive bounds checking and null validation - TestHelper.assert_true(true, "Memory safety patterns implemented in Match3 code") + TestHelperClass.assert_true(true, "Memory safety patterns implemented in Match3 code") func test_performance_requirements(): - TestHelper.print_step("Performance Requirements") + TestHelperClass.print_step("Performance Requirements") if not match3_instance: return # Test grid size is within performance limits var total_tiles = match3_instance.GRID_SIZE.x * match3_instance.GRID_SIZE.y - TestHelper.assert_true(total_tiles <= 225, "Total tiles within performance limit (15x15=225)") + TestHelperClass.assert_true(total_tiles <= 225, "Total tiles within performance limit (15x15=225)") # Test cascade iteration limit prevents infinite loops - TestHelper.assert_equal( + TestHelperClass.assert_equal( 20, match3_instance.MAX_CASCADE_ITERATIONS, "Cascade iteration limit prevents infinite loops" ) # Test timing constants are reasonable for 60fps gameplay - TestHelper.assert_true( + TestHelperClass.assert_true( match3_instance.CASCADE_WAIT_TIME >= 0.05, "Cascade wait time allows for smooth animation" ) - TestHelper.assert_true( + TestHelperClass.assert_true( match3_instance.SWAP_ANIMATION_TIME <= 0.5, "Swap animation time is responsive" ) - TestHelper.assert_true( + TestHelperClass.assert_true( match3_instance.TILE_DROP_WAIT_TIME <= 0.3, "Tile drop wait time is responsive" ) # Test grid initialization performance - TestHelper.start_performance_test("grid_access") + TestHelperClass.start_performance_test("grid_access") for y in range(min(5, match3_instance.grid.size())): for x in range(min(5, match3_instance.grid[y].size())): var tile = match3_instance.grid[y][x] if tile and "tile_type" in tile: - var tile_type = tile.tile_type - TestHelper.end_performance_test("grid_access", 10.0, "Grid access performance within limits") + var _tile_type = tile.tile_type + TestHelperClass.end_performance_test("grid_access", 10.0, "Grid access performance within limits") func cleanup_tests(): - TestHelper.print_step("Cleanup") + TestHelperClass.print_step("Cleanup") # Clean up Match3 instance if match3_instance and is_instance_valid(match3_instance): @@ -446,4 +446,4 @@ func cleanup_tests(): # Wait for cleanup await process_frame - TestHelper.assert_true(true, "Test cleanup completed") + TestHelperClass.assert_true(true, "Test cleanup completed") diff --git a/tests/test_migration_compatibility.gd b/tests/test_migration_compatibility.gd index 82180dd..c8c7096 100644 --- a/tests/test_migration_compatibility.gd +++ b/tests/test_migration_compatibility.gd @@ -3,7 +3,7 @@ extends SceneTree # Test to verify that existing save files with old checksum format can be migrated # This ensures backward compatibility with the checksum fix -const TestHelper = preload("res://tests/helpers/TestHelper.gd") +const TestHelperClass = preload("res://tests/helpers/TestHelper.gd") func _initialize(): @@ -18,13 +18,13 @@ func _initialize(): func run_tests(): - TestHelper.print_test_header("Migration Compatibility") + TestHelperClass.print_test_header("Migration Compatibility") test_migration_compatibility() - TestHelper.print_test_footer("Migration Compatibility") + TestHelperClass.print_test_footer("Migration Compatibility") func test_migration_compatibility(): - TestHelper.print_step("Old Save File Compatibility") + TestHelperClass.print_step("Old Save File Compatibility") var old_save_data = { "_version": 1, "high_score": 150, @@ -57,13 +57,13 @@ func test_migration_compatibility(): print("New checksum format: %s" % new_checksum) # The checksums should be different (old system broken) - TestHelper.assert_not_equal( + TestHelperClass.assert_not_equal( old_checksum, new_checksum, "Old and new checksum formats should be different" ) print("Old checksum: %s" % old_checksum) print("New checksum: %s" % new_checksum) - TestHelper.print_step("New System Self-Consistency") + TestHelperClass.print_step("New System Self-Consistency") # Remove old checksum and recalculate loaded_data.erase("_checksum") var first_checksum = _calculate_new_checksum(loaded_data) @@ -77,15 +77,15 @@ func test_migration_compatibility(): var second_checksum = _calculate_new_checksum(reloaded_data) - TestHelper.assert_equal( + TestHelperClass.assert_equal( first_checksum, second_checksum, "New system should be self-consistent across save/load cycles" ) print("Consistent checksum: %s" % first_checksum) - TestHelper.print_step("Migration Strategy Verification") - TestHelper.assert_true(true, "Version-based checksum handling implemented") + TestHelperClass.print_step("Migration Strategy Verification") + TestHelperClass.assert_true(true, "Version-based checksum handling implemented") print("✓ Files without _checksum: Allow (backward compatibility)") print("✓ Files with version < current: Recalculate checksum after migration") print("✓ Files with current version: Use new checksum validation") diff --git a/tests/test_scene_validation.gd b/tests/test_scene_validation.gd index fa168f4..87ec5d9 100644 --- a/tests/test_scene_validation.gd +++ b/tests/test_scene_validation.gd @@ -5,7 +5,7 @@ extends SceneTree ## Validates all .tscn files in the project for loading and instantiation errors. ## Provides comprehensive scene validation to catch issues before runtime. -const TestHelper = preload("res://tests/helpers/TestHelper.gd") +const TestHelperClass = preload("res://tests/helpers/TestHelper.gd") var discovered_scenes: Array[String] = [] var validation_results: Dictionary = {} @@ -23,7 +23,7 @@ func _initialize(): func run_tests(): - TestHelper.print_test_header("Scene Validation") + TestHelperClass.print_test_header("Scene Validation") # Run test suites test_scene_discovery() @@ -34,11 +34,11 @@ func run_tests(): # Print final summary print_validation_summary() - TestHelper.print_test_footer("Scene Validation") + TestHelperClass.print_test_footer("Scene Validation") func test_scene_discovery(): - TestHelper.print_step("Scene Discovery") + TestHelperClass.print_step("Scene Discovery") # Discover scenes in key directories var scene_directories = ["res://scenes/", "res://examples/"] @@ -46,7 +46,7 @@ func test_scene_discovery(): for directory in scene_directories: discover_scenes_in_directory(directory) - TestHelper.assert_true(discovered_scenes.size() > 0, "Found scenes in project") + TestHelperClass.assert_true(discovered_scenes.size() > 0, "Found scenes in project") print("Discovered %d scene files" % discovered_scenes.size()) # List discovered scenes for reference @@ -77,7 +77,7 @@ func discover_scenes_in_directory(directory_path: String): func test_scene_loading(): - TestHelper.print_step("Scene Loading Validation") + TestHelperClass.print_step("Scene Loading Validation") for scene_path in discovered_scenes: validate_scene_loading(scene_path) @@ -89,27 +89,27 @@ func validate_scene_loading(scene_path: String): # Check if resource exists if not ResourceLoader.exists(scene_path): validation_results[scene_path] = "Resource does not exist" - TestHelper.assert_false(true, "%s - Resource does not exist" % scene_name) + TestHelperClass.assert_false(true, "%s - Resource does not exist" % scene_name) return # Attempt to load the scene var packed_scene = load(scene_path) if not packed_scene: validation_results[scene_path] = "Failed to load scene" - TestHelper.assert_false(true, "%s - Failed to load scene" % scene_name) + TestHelperClass.assert_false(true, "%s - Failed to load scene" % scene_name) return if not packed_scene is PackedScene: validation_results[scene_path] = "Resource is not a PackedScene" - TestHelper.assert_false(true, "%s - Resource is not a PackedScene" % scene_name) + TestHelperClass.assert_false(true, "%s - Resource is not a PackedScene" % scene_name) return validation_results[scene_path] = "Loading successful" - TestHelper.assert_true(true, "%s - Scene loads successfully" % scene_name) + TestHelperClass.assert_true(true, "%s - Scene loads successfully" % scene_name) func test_scene_instantiation(): - TestHelper.print_step("Scene Instantiation Testing") + TestHelperClass.print_step("Scene Instantiation Testing") for scene_path in discovered_scenes: # Only test instantiation for scenes that loaded successfully @@ -127,11 +127,11 @@ func validate_scene_instantiation(scene_path: String): var scene_instance = packed_scene.instantiate() if not scene_instance: validation_results[scene_path] = "Failed to instantiate scene" - TestHelper.assert_false(true, "%s - Failed to instantiate scene" % scene_name) + TestHelperClass.assert_false(true, "%s - Failed to instantiate scene" % scene_name) return # Validate the instance - TestHelper.assert_not_null( + TestHelperClass.assert_not_null( scene_instance, "%s - Scene instantiation creates valid node" % scene_name ) @@ -144,7 +144,7 @@ func validate_scene_instantiation(scene_path: String): func test_critical_scenes(): - TestHelper.print_step("Critical Scene Validation") + TestHelperClass.print_step("Critical Scene Validation") # Define critical scenes that must work var critical_scenes = [ @@ -157,13 +157,13 @@ func test_critical_scenes(): for scene_path in critical_scenes: if scene_path in discovered_scenes: var status = validation_results.get(scene_path, "Unknown") - TestHelper.assert_equal( + TestHelperClass.assert_equal( "Full validation successful", status, "Critical scene %s must pass all validation" % scene_path.get_file() ) else: - TestHelper.assert_false(true, "Critical scene missing: %s" % scene_path) + TestHelperClass.assert_false(true, "Critical scene missing: %s" % scene_path) func print_validation_summary(): diff --git a/tests/test_settings_manager.gd b/tests/test_settings_manager.gd index 298f709..535b722 100644 --- a/tests/test_settings_manager.gd +++ b/tests/test_settings_manager.gd @@ -4,7 +4,7 @@ extends SceneTree ## ## Tests input validation, file I/O, and error handling. -const TestHelper = preload("res://tests/helpers/TestHelper.gd") +const TestHelperClass = preload("res://tests/helpers/TestHelper.gd") var settings_manager: Node var original_settings: Dictionary @@ -23,13 +23,13 @@ func _initialize(): func run_tests(): - TestHelper.print_test_header("SettingsManager") + TestHelperClass.print_test_header("SettingsManager") # Get reference to SettingsManager settings_manager = root.get_node("SettingsManager") if not settings_manager: - TestHelper.assert_true(false, "SettingsManager autoload not found") - TestHelper.print_test_footer("SettingsManager") + TestHelperClass.assert_true(false, "SettingsManager autoload not found") + TestHelperClass.print_test_footer("SettingsManager") return # Store original settings for restoration @@ -49,14 +49,14 @@ func run_tests(): # Cleanup and restore original state cleanup_tests() - TestHelper.print_test_footer("SettingsManager") + TestHelperClass.print_test_footer("SettingsManager") func test_basic_functionality(): - TestHelper.print_step("Basic Functionality") + TestHelperClass.print_step("Basic Functionality") # Test that SettingsManager has expected properties - TestHelper.assert_has_properties( + TestHelperClass.assert_has_properties( settings_manager, ["settings", "default_settings", "languages_data"], "SettingsManager properties" @@ -66,66 +66,66 @@ func test_basic_functionality(): var expected_methods = [ "get_setting", "set_setting", "save_settings", "load_settings", "reset_settings_to_defaults" ] - TestHelper.assert_has_methods(settings_manager, expected_methods, "SettingsManager methods") + TestHelperClass.assert_has_methods(settings_manager, expected_methods, "SettingsManager methods") # Test default settings structure var expected_defaults = ["master_volume", "music_volume", "sfx_volume", "language"] for key in expected_defaults: - TestHelper.assert_has_key( + TestHelperClass.assert_has_key( settings_manager.default_settings, key, "Default setting key: " + key ) # Test getting settings var master_volume = settings_manager.get_setting("master_volume") - TestHelper.assert_not_null(master_volume, "Can get master_volume setting") - TestHelper.assert_true(master_volume is float, "master_volume is float type") + TestHelperClass.assert_not_null(master_volume, "Can get master_volume setting") + TestHelperClass.assert_true(master_volume is float, "master_volume is float type") func test_input_validation_security(): - TestHelper.print_step("Input Validation Security") + TestHelperClass.print_step("Input Validation Security") # Test NaN validation var nan_result = settings_manager.set_setting("master_volume", NAN) - TestHelper.assert_false(nan_result, "NaN values rejected for volume settings") + TestHelperClass.assert_false(nan_result, "NaN values rejected for volume settings") # Test Infinity validation var inf_result = settings_manager.set_setting("master_volume", INF) - TestHelper.assert_false(inf_result, "Infinity values rejected for volume settings") + TestHelperClass.assert_false(inf_result, "Infinity values rejected for volume settings") # Test negative infinity validation var neg_inf_result = settings_manager.set_setting("master_volume", -INF) - TestHelper.assert_false(neg_inf_result, "Negative infinity values rejected") + TestHelperClass.assert_false(neg_inf_result, "Negative infinity values rejected") # Test range validation for volumes var negative_volume = settings_manager.set_setting("master_volume", -0.5) - TestHelper.assert_false(negative_volume, "Negative volume values rejected") + TestHelperClass.assert_false(negative_volume, "Negative volume values rejected") var excessive_volume = settings_manager.set_setting("master_volume", 1.5) - TestHelper.assert_false(excessive_volume, "Volume values > 1.0 rejected") + TestHelperClass.assert_false(excessive_volume, "Volume values > 1.0 rejected") # Test valid volume range var valid_volume = settings_manager.set_setting("master_volume", 0.5) - TestHelper.assert_true(valid_volume, "Valid volume values accepted") - TestHelper.assert_equal( + TestHelperClass.assert_true(valid_volume, "Valid volume values accepted") + TestHelperClass.assert_equal( 0.5, settings_manager.get_setting("master_volume"), "Volume value set correctly" ) # Test string length validation for language var long_language = "a".repeat(20) # Exceeds MAX_SETTING_STRING_LENGTH var long_lang_result = settings_manager.set_setting("language", long_language) - TestHelper.assert_false(long_lang_result, "Excessively long language codes rejected") + TestHelperClass.assert_false(long_lang_result, "Excessively long language codes rejected") # Test invalid characters in language code var invalid_chars = settings_manager.set_setting("language", "en