gdlint fixes

tests/test_tile.gd

@@ -4,7 +4,7 @@ extends SceneTree
 ##
 ## Tests tile initialization, texture management, and gem types.
 
-const TestHelper = preload("res://tests/helpers/TestHelper.gd")
+const TestHelperClass = preload("res://tests/helpers/TestHelper.gd")
 
 var tile_scene: PackedScene
 var tile_instance: Node2D
@@ -23,7 +23,7 @@ func _initialize():
 
 
 func run_tests():
-	TestHelper.print_test_header("Tile Component")
+	TestHelperClass.print_test_header("Tile Component")
 
 	# Setup test environment
 	setup_test_environment()
@@ -43,15 +43,15 @@ func run_tests():
 	# Cleanup
 	cleanup_tests()
 
-	TestHelper.print_test_footer("Tile Component")
+	TestHelperClass.print_test_footer("Tile Component")
 
 
 func setup_test_environment():
-	TestHelper.print_step("Test Environment Setup")
+	TestHelperClass.print_step("Test Environment Setup")
 
 	# Load Tile scene
 	tile_scene = load("res://scenes/game/gameplays/tile.tscn")
-	TestHelper.assert_not_null(tile_scene, "Tile scene loads successfully")
+	TestHelperClass.assert_not_null(tile_scene, "Tile scene loads successfully")
 
 	# Create test viewport for isolated testing
 	test_viewport = SubViewport.new()
@@ -62,7 +62,7 @@ func setup_test_environment():
 	if tile_scene:
 		tile_instance = tile_scene.instantiate()
 		test_viewport.add_child(tile_instance)
-		TestHelper.assert_not_null(tile_instance, "Tile instance created successfully")
+		TestHelperClass.assert_not_null(tile_instance, "Tile 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 tile_instance:
-		TestHelper.assert_true(false, "Tile instance not available for testing")
+		TestHelperClass.assert_true(false, "Tile instance not available for testing")
 		return
 
 	# Test that Tile has expected properties
@@ -86,7 +86,7 @@ func test_basic_functionality():
 		"active_gem_types"
 	]
 	for prop in expected_properties:
-		TestHelper.assert_true(prop in tile_instance, "Tile has property: " + prop)
+		TestHelperClass.assert_true(prop in tile_instance, "Tile has property: " + prop)
 
 	# Test that Tile has expected methods
 	var expected_methods = [
@@ -96,58 +96,58 @@ func test_basic_functionality():
 		"remove_gem_type",
 		"force_reset_visual_state"
 	]
-	TestHelper.assert_has_methods(tile_instance, expected_methods, "Tile component methods")
+	TestHelperClass.assert_has_methods(tile_instance, expected_methods, "Tile component methods")
 
 	# Test signals
-	TestHelper.assert_true(
+	TestHelperClass.assert_true(
 		tile_instance.has_signal("tile_selected"), "Tile has tile_selected signal"
 	)
 
 	# Test sprite reference
-	TestHelper.assert_not_null(tile_instance.sprite, "Sprite node is available")
-	TestHelper.assert_true(tile_instance.sprite is Sprite2D, "Sprite is Sprite2D type")
+	TestHelperClass.assert_not_null(tile_instance.sprite, "Sprite node is available")
+	TestHelperClass.assert_true(tile_instance.sprite is Sprite2D, "Sprite is Sprite2D type")
 
 	# Test group membership
-	TestHelper.assert_true(tile_instance.is_in_group("tiles"), "Tile is in 'tiles' group")
+	TestHelperClass.assert_true(tile_instance.is_in_group("tiles"), "Tile is in 'tiles' group")
 
 
 func test_tile_constants():
-	TestHelper.print_step("Tile Constants")
+	TestHelperClass.print_step("Tile Constants")
 
 	if not tile_instance:
 		return
 
 	# Test TILE_SIZE constant
-	TestHelper.assert_equal(48, tile_instance.TILE_SIZE, "TILE_SIZE constant is correct")
+	TestHelperClass.assert_equal(48, tile_instance.TILE_SIZE, "TILE_SIZE constant is correct")
 
 	# Test all_gem_textures array
-	TestHelper.assert_not_null(tile_instance.all_gem_textures, "All gem textures array exists")
-	TestHelper.assert_true(
+	TestHelperClass.assert_not_null(tile_instance.all_gem_textures, "All gem textures array exists")
+	TestHelperClass.assert_true(
 		tile_instance.all_gem_textures is Array, "All gem textures is Array type"
 	)
-	TestHelper.assert_equal(
+	TestHelperClass.assert_equal(
 		8, tile_instance.all_gem_textures.size(), "All gem textures has expected count"
 	)
 
 	# Test that all gem textures are valid
 	for i in range(tile_instance.all_gem_textures.size()):
 		var texture = tile_instance.all_gem_textures[i]
-		TestHelper.assert_not_null(texture, "Gem texture %d is not null" % i)
-		TestHelper.assert_true(texture is Texture2D, "Gem texture %d is Texture2D type" % i)
+		TestHelperClass.assert_not_null(texture, "Gem texture %d is not null" % i)
+		TestHelperClass.assert_true(texture is Texture2D, "Gem texture %d is Texture2D type" % i)
 
 
 func test_texture_management():
-	TestHelper.print_step("Texture Management")
+	TestHelperClass.print_step("Texture Management")
 
 	if not tile_instance:
 		return
 
 	# Test default gem types initialization
-	TestHelper.assert_not_null(tile_instance.active_gem_types, "Active gem types is initialized")
-	TestHelper.assert_true(
+	TestHelperClass.assert_not_null(tile_instance.active_gem_types, "Active gem types is initialized")
+	TestHelperClass.assert_true(
 		tile_instance.active_gem_types is Array, "Active gem types is Array type"
 	)
-	TestHelper.assert_true(
+	TestHelperClass.assert_true(
 		tile_instance.active_gem_types.size() > 0, "Active gem types has content"
 	)
 
@@ -156,10 +156,10 @@ func test_texture_management():
 
 	for i in range(min(3, tile_instance.active_gem_types.size())):
 		tile_instance.tile_type = i
-		TestHelper.assert_equal(i, tile_instance.tile_type, "Tile type set correctly to %d" % i)
+		TestHelperClass.assert_equal(i, tile_instance.tile_type, "Tile type set correctly to %d" % i)
 
 		if tile_instance.sprite:
-			TestHelper.assert_not_null(
+			TestHelperClass.assert_not_null(
 				tile_instance.sprite.texture, "Sprite texture assigned for type %d" % i
 			)
 
@@ -168,7 +168,7 @@ func test_texture_management():
 
 
 func test_gem_type_management():
-	TestHelper.print_step("Gem Type Management")
+	TestHelperClass.print_step("Gem Type Management")
 
 	if not tile_instance:
 		return
@@ -179,51 +179,51 @@ func test_gem_type_management():
 	# Test set_active_gem_types with valid array
 	var test_gems = [0, 1, 2]
 	tile_instance.set_active_gem_types(test_gems)
-	TestHelper.assert_equal(
+	TestHelperClass.assert_equal(
 		3, tile_instance.get_active_gem_count(), "Active gem count set correctly"
 	)
 
 	# Test add_gem_type
 	var add_result = tile_instance.add_gem_type(3)
-	TestHelper.assert_true(add_result, "Valid gem type added successfully")
-	TestHelper.assert_equal(
+	TestHelperClass.assert_true(add_result, "Valid gem type added successfully")
+	TestHelperClass.assert_equal(
 		4, tile_instance.get_active_gem_count(), "Gem count increased after addition"
 	)
 
 	# Test adding duplicate gem type
 	var duplicate_result = tile_instance.add_gem_type(3)
-	TestHelper.assert_false(duplicate_result, "Duplicate gem type addition rejected")
-	TestHelper.assert_equal(
+	TestHelperClass.assert_false(duplicate_result, "Duplicate gem type addition rejected")
+	TestHelperClass.assert_equal(
 		4, tile_instance.get_active_gem_count(), "Gem count unchanged after duplicate"
 	)
 
 	# Test add_gem_type with invalid index
 	var invalid_add = tile_instance.add_gem_type(99)
-	TestHelper.assert_false(invalid_add, "Invalid gem index addition rejected")
+	TestHelperClass.assert_false(invalid_add, "Invalid gem index addition rejected")
 
 	# Test remove_gem_type
 	var remove_result = tile_instance.remove_gem_type(3)
-	TestHelper.assert_true(remove_result, "Valid gem type removed successfully")
-	TestHelper.assert_equal(
+	TestHelperClass.assert_true(remove_result, "Valid gem type removed successfully")
+	TestHelperClass.assert_equal(
 		3, tile_instance.get_active_gem_count(), "Gem count decreased after removal"
 	)
 
 	# Test removing non-existent gem type
 	var nonexistent_remove = tile_instance.remove_gem_type(99)
-	TestHelper.assert_false(nonexistent_remove, "Non-existent gem type removal rejected")
+	TestHelperClass.assert_false(nonexistent_remove, "Non-existent gem type removal rejected")
 
 	# Test minimum gem types protection
 	tile_instance.set_active_gem_types([0, 1])  # Set to minimum
 	var protected_remove = tile_instance.remove_gem_type(0)
-	TestHelper.assert_false(protected_remove, "Minimum gem types protection active")
-	TestHelper.assert_equal(2, tile_instance.get_active_gem_count(), "Minimum gem count preserved")
+	TestHelperClass.assert_false(protected_remove, "Minimum gem types protection active")
+	TestHelperClass.assert_equal(2, tile_instance.get_active_gem_count(), "Minimum gem count preserved")
 
 	# Restore original state
 	tile_instance.set_active_gem_types(original_gem_types)
 
 
 func test_visual_feedback_system():
-	TestHelper.print_step("Visual Feedback System")
+	TestHelperClass.print_step("Visual Feedback System")
 
 	if not tile_instance:
 		return
@@ -234,7 +234,7 @@ func test_visual_feedback_system():
 
 	# Test selection visual feedback
 	tile_instance.is_selected = true
-	TestHelper.assert_true(tile_instance.is_selected, "Selection state set correctly")
+	TestHelperClass.assert_true(tile_instance.is_selected, "Selection state set correctly")
 
 	# Wait for potential animation
 	await process_frame
@@ -242,7 +242,7 @@ func test_visual_feedback_system():
 	if tile_instance.sprite:
 		# Test that modulate is brighter when selected
 		var modulate = tile_instance.sprite.modulate
-		TestHelper.assert_true(
+		TestHelperClass.assert_true(
 			modulate.r > 1.0 or modulate.g > 1.0 or modulate.b > 1.0,
 			"Selected tile has brighter modulate"
 		)
@@ -250,21 +250,21 @@ func test_visual_feedback_system():
 	# Test highlight visual feedback
 	tile_instance.is_selected = false
 	tile_instance.is_highlighted = true
-	TestHelper.assert_true(tile_instance.is_highlighted, "Highlight state set correctly")
+	TestHelperClass.assert_true(tile_instance.is_highlighted, "Highlight state set correctly")
 
 	# Wait for potential animation
 	await process_frame
 
 	# Test normal state
 	tile_instance.is_highlighted = false
-	TestHelper.assert_false(tile_instance.is_highlighted, "Normal state restored")
+	TestHelperClass.assert_false(tile_instance.is_highlighted, "Normal state restored")
 
 	# Test force reset
 	tile_instance.is_selected = true
 	tile_instance.is_highlighted = true
 	tile_instance.force_reset_visual_state()
-	TestHelper.assert_false(tile_instance.is_selected, "Force reset clears selection")
-	TestHelper.assert_false(tile_instance.is_highlighted, "Force reset clears highlight")
+	TestHelperClass.assert_false(tile_instance.is_selected, "Force reset clears selection")
+	TestHelperClass.assert_false(tile_instance.is_highlighted, "Force reset clears highlight")
 
 	# Restore original state
 	tile_instance.is_selected = original_selected
@@ -272,17 +272,17 @@ func test_visual_feedback_system():
 
 
 func test_state_management():
-	TestHelper.print_step("State Management")
+	TestHelperClass.print_step("State Management")
 
 	if not tile_instance:
 		return
 
 	# Test initial state
-	TestHelper.assert_true(tile_instance.tile_type >= 0, "Initial tile type is non-negative")
-	TestHelper.assert_true(
+	TestHelperClass.assert_true(tile_instance.tile_type >= 0, "Initial tile type is non-negative")
+	TestHelperClass.assert_true(
 		tile_instance.grid_position is Vector2i, "Grid position is Vector2i type"
 	)
-	TestHelper.assert_true(
+	TestHelperClass.assert_true(
 		tile_instance.original_scale is Vector2, "Original scale is Vector2 type"
 	)
 
@@ -293,10 +293,10 @@ func test_state_management():
 	# Test valid tile type
 	if max_valid_type >= 0:
 		tile_instance.tile_type = max_valid_type
-		TestHelper.assert_equal(max_valid_type, tile_instance.tile_type, "Valid tile type accepted")
+		TestHelperClass.assert_equal(max_valid_type, tile_instance.tile_type, "Valid tile type accepted")
 
 	# Test state consistency
-	TestHelper.assert_true(
+	TestHelperClass.assert_true(
 		tile_instance.tile_type < tile_instance.active_gem_types.size(),
 		"Tile type within active gems range"
 	)
@@ -306,7 +306,7 @@ func test_state_management():
 
 
 func test_input_validation():
-	TestHelper.print_step("Input Validation")
+	TestHelperClass.print_step("Input Validation")
 
 	if not tile_instance:
 		return
@@ -315,52 +315,52 @@ func test_input_validation():
 	var original_gems = tile_instance.active_gem_types.duplicate()
 	tile_instance.set_active_gem_types([])
 	# Should fall back to defaults or maintain previous state
-	TestHelper.assert_true(
+	TestHelperClass.assert_true(
 		tile_instance.get_active_gem_count() > 0, "Empty gem array handled gracefully"
 	)
 
 	# Test null gem types array
 	tile_instance.set_active_gem_types(null)
-	TestHelper.assert_true(
+	TestHelperClass.assert_true(
 		tile_instance.get_active_gem_count() > 0, "Null gem array handled gracefully"
 	)
 
 	# Test invalid gem indices in array
 	tile_instance.set_active_gem_types([0, 1, 99, 2])  # 99 is invalid
 	# Should use fallback or filter invalid indices
-	TestHelper.assert_true(
+	TestHelperClass.assert_true(
 		tile_instance.get_active_gem_count() > 0, "Invalid gem indices handled gracefully"
 	)
 
 	# Test negative gem indices
 	var negative_add = tile_instance.add_gem_type(-1)
-	TestHelper.assert_false(negative_add, "Negative gem index rejected")
+	TestHelperClass.assert_false(negative_add, "Negative gem index rejected")
 
 	# Test out-of-bounds gem indices
 	var oob_add = tile_instance.add_gem_type(tile_instance.all_gem_textures.size())
-	TestHelper.assert_false(oob_add, "Out-of-bounds gem index rejected")
+	TestHelperClass.assert_false(oob_add, "Out-of-bounds gem index rejected")
 
 	# Restore original state
 	tile_instance.set_active_gem_types(original_gems)
 
 
 func test_scaling_and_sizing():
-	TestHelper.print_step("Scaling and Sizing")
+	TestHelperClass.print_step("Scaling and Sizing")
 
 	if not tile_instance:
 		return
 
 	# Test original scale calculation
-	TestHelper.assert_not_null(tile_instance.original_scale, "Original scale is calculated")
-	TestHelper.assert_true(tile_instance.original_scale.x > 0, "Original scale X is positive")
-	TestHelper.assert_true(tile_instance.original_scale.y > 0, "Original scale Y is positive")
+	TestHelperClass.assert_not_null(tile_instance.original_scale, "Original scale is calculated")
+	TestHelperClass.assert_true(tile_instance.original_scale.x > 0, "Original scale X is positive")
+	TestHelperClass.assert_true(tile_instance.original_scale.y > 0, "Original scale Y is positive")
 
 	# Test that tile size is respected
 	if tile_instance.sprite and tile_instance.sprite.texture:
 		var texture_size = tile_instance.sprite.texture.get_size()
 		var scaled_size = texture_size * tile_instance.original_scale
 		var max_dimension = max(scaled_size.x, scaled_size.y)
-		TestHelper.assert_true(
+		TestHelperClass.assert_true(
 			max_dimension <= tile_instance.TILE_SIZE + 1, "Scaled tile fits within TILE_SIZE"
 		)
 
@@ -374,7 +374,7 @@ func test_scaling_and_sizing():
 
 	if tile_instance.sprite:
 		var selected_scale = tile_instance.sprite.scale
-		TestHelper.assert_true(
+		TestHelperClass.assert_true(
 			selected_scale.x >= original_scale.x, "Selected tile scale is larger or equal"
 		)
 
@@ -385,7 +385,7 @@ func test_scaling_and_sizing():
 
 
 func test_memory_safety():
-	TestHelper.print_step("Memory Safety")
+	TestHelperClass.print_step("Memory Safety")
 
 	if not tile_instance:
 		return
@@ -399,31 +399,31 @@ func test_memory_safety():
 	tile_instance._update_visual_feedback()
 	tile_instance.force_reset_visual_state()
 
-	TestHelper.assert_true(true, "Null sprite operations handled safely")
+	TestHelperClass.assert_true(true, "Null sprite operations handled safely")
 
 	# Restore sprite
 	tile_instance.sprite = original_sprite
 
 	# Test valid instance checking in visual updates
 	if tile_instance.sprite:
-		TestHelper.assert_true(is_instance_valid(tile_instance.sprite), "Sprite instance is valid")
+		TestHelperClass.assert_true(is_instance_valid(tile_instance.sprite), "Sprite instance is valid")
 
 	# Test gem types array integrity
-	TestHelper.assert_true(
+	TestHelperClass.assert_true(
 		tile_instance.active_gem_types is Array, "Active gem types maintains Array type"
 	)
 
 	# Test that gem indices are within bounds
 	for gem_index in tile_instance.active_gem_types:
-		TestHelper.assert_true(gem_index >= 0, "Gem index is non-negative")
-		TestHelper.assert_true(
+		TestHelperClass.assert_true(gem_index >= 0, "Gem index is non-negative")
+		TestHelperClass.assert_true(
 			gem_index < tile_instance.all_gem_textures.size(),
 			"Gem index within texture array bounds"
 		)
 
 
 func test_error_handling():
-	TestHelper.print_step("Error Handling")
+	TestHelperClass.print_step("Error Handling")
 
 	if not tile_instance:
 		return
@@ -434,11 +434,11 @@ func test_error_handling():
 
 	# Test that _set_tile_type handles null sprite gracefully
 	tile_instance._set_tile_type(0)
-	TestHelper.assert_true(true, "Tile type setting handles null sprite gracefully")
+	TestHelperClass.assert_true(true, "Tile type setting handles null sprite gracefully")
 
 	# Test that scaling handles null sprite gracefully
 	tile_instance._scale_sprite_to_fit()
-	TestHelper.assert_true(true, "Sprite scaling handles null sprite gracefully")
+	TestHelperClass.assert_true(true, "Sprite scaling handles null sprite gracefully")
 
 	# Restore sprite
 	tile_instance.sprite = backup_sprite
@@ -449,7 +449,7 @@ func test_error_handling():
 	tile_instance._set_tile_type(999)  # Invalid large type
 
 	# Should not crash and should maintain reasonable state
-	TestHelper.assert_true(true, "Invalid tile types handled gracefully")
+	TestHelperClass.assert_true(true, "Invalid tile types handled gracefully")
 
 	# Restore original type
 	tile_instance.tile_type = original_type
@@ -461,14 +461,14 @@ func test_error_handling():
 
 	tile_instance.set_active_gem_types(large_gem_types)
 	# Should fall back to safe defaults
-	TestHelper.assert_true(
+	TestHelperClass.assert_true(
 		tile_instance.get_active_gem_count() <= tile_instance.all_gem_textures.size(),
 		"Large gem array handled safely"
 	)
 
 
 func cleanup_tests():
-	TestHelper.print_step("Cleanup")
+	TestHelperClass.print_step("Cleanup")
 
 	# Clean up tile instance
 	if tile_instance and is_instance_valid(tile_instance):
@@ -481,4 +481,4 @@ func cleanup_tests():
 	# Wait for cleanup
 	await process_frame
 
-	TestHelper.assert_true(true, "Test cleanup completed")
+	TestHelperClass.assert_true(true, "Test cleanup completed")