Add files using upload-large-folder tool

projects/ui/serena-new/test/solidlsp/erlang/test_erlang_symbol_retrieval.py

@@ -0,0 +1,445 @@
+"""
+Tests for the Erlang language server symbol-related functionality.
+
+These tests focus on the following methods:
+- request_containing_symbol
+- request_referencing_symbols
+- request_defining_symbol
+"""
+
+import os
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_types import SymbolKind
+
+from . import ERLANG_LS_UNAVAILABLE, ERLANG_LS_UNAVAILABLE_REASON
+
+# These marks will be applied to all tests in this module
+pytestmark = [
+    pytest.mark.erlang,
+    pytest.mark.skipif(ERLANG_LS_UNAVAILABLE, reason=f"Erlang LS not available: {ERLANG_LS_UNAVAILABLE_REASON}"),
+]
+
+
+class TestErlangLanguageServerSymbols:
+    """Test the Erlang language server's symbol-related functionality."""
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_request_containing_symbol_function(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a function."""
+        # Test for a position inside the create_user function
+        file_path = os.path.join("src", "models.erl")
+
+        # Find the create_user function in the file
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        create_user_line = None
+        for i, line in enumerate(lines):
+            if "create_user(" in line and "-spec" not in line:
+                create_user_line = i + 1  # Go inside the function body
+                break
+
+        if create_user_line is None:
+            pytest.skip("Could not find create_user function")
+
+        containing_symbol = language_server.request_containing_symbol(file_path, create_user_line, 10, include_body=True)
+
+        # Verify that we found the containing symbol
+        if containing_symbol:
+            assert "create_user" in containing_symbol["name"]
+            assert containing_symbol["kind"] == SymbolKind.Method or containing_symbol["kind"] == SymbolKind.Function
+            if "body" in containing_symbol:
+                assert "create_user" in containing_symbol["body"]
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_request_containing_symbol_module(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a module."""
+        # Test for a position inside the models module but outside any function
+        file_path = os.path.join("src", "models.erl")
+
+        # Find the module definition
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        module_line = None
+        for i, line in enumerate(lines):
+            if "-module(models)" in line:
+                module_line = i + 2  # Go inside the module
+                break
+
+        if module_line is None:
+            pytest.skip("Could not find models module")
+
+        containing_symbol = language_server.request_containing_symbol(file_path, module_line, 5)
+
+        # Verify that we found the containing symbol
+        if containing_symbol:
+            assert "models" in containing_symbol["name"] or "module" in containing_symbol["name"].lower()
+            assert containing_symbol["kind"] == SymbolKind.Module or containing_symbol["kind"] == SymbolKind.Class
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_request_containing_symbol_nested(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol with nested scopes."""
+        # Test for a position inside a function which is inside a module
+        file_path = os.path.join("src", "models.erl")
+
+        # Find a function inside models module
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        function_body_line = None
+        for i, line in enumerate(lines):
+            if "create_user(" in line and "-spec" not in line:
+                # Go deeper into the function body where there might be case expressions
+                for j in range(i + 1, min(i + 10, len(lines))):
+                    if lines[j].strip() and not lines[j].strip().startswith("%"):
+                        function_body_line = j
+                        break
+                break
+
+        if function_body_line is None:
+            pytest.skip("Could not find function body")
+
+        containing_symbol = language_server.request_containing_symbol(file_path, function_body_line, 15)
+
+        # Verify that we found the innermost containing symbol (the function)
+        if containing_symbol:
+            expected_names = ["create_user", "models"]
+            assert any(name in containing_symbol["name"] for name in expected_names)
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_request_containing_symbol_none(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a position with no containing symbol."""
+        # Test for a position outside any function/module (e.g., in comments)
+        file_path = os.path.join("src", "models.erl")
+        # Line 1-2 are likely module declaration or comments
+        containing_symbol = language_server.request_containing_symbol(file_path, 2, 10)
+
+        # Should return None or an empty dictionary, or the top-level module
+        # This is acceptable behavior for module-level positions
+        assert containing_symbol is None or containing_symbol == {} or "models" in str(containing_symbol)
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_request_referencing_symbols_record(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a record."""
+        # Test referencing symbols for user record
+        file_path = os.path.join("include", "records.hrl")
+
+        symbols = language_server.request_document_symbols(file_path)
+        user_symbol = None
+        for symbol_group in symbols:
+            user_symbol = next((s for s in symbol_group if "user" in s.get("name", "")), None)
+            if user_symbol:
+                break
+
+        if not user_symbol or "selectionRange" not in user_symbol:
+            pytest.skip("User record symbol or its selectionRange not found")
+
+        sel_start = user_symbol["selectionRange"]["start"]
+        ref_symbols = [
+            ref.symbol for ref in language_server.request_referencing_symbols(file_path, sel_start["line"], sel_start["character"])
+        ]
+
+        if ref_symbols:
+            models_references = [
+                symbol
+                for symbol in ref_symbols
+                if "location" in symbol and "uri" in symbol["location"] and "models.erl" in symbol["location"]["uri"]
+            ]
+            # We expect some references from models.erl
+            assert len(models_references) >= 0  # At least attempt to find references
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_request_referencing_symbols_function(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a function."""
+        # Test referencing symbols for create_user function
+        file_path = os.path.join("src", "models.erl")
+
+        symbols = language_server.request_document_symbols(file_path)
+        create_user_symbol = None
+        for symbol_group in symbols:
+            create_user_symbol = next((s for s in symbol_group if "create_user" in s.get("name", "")), None)
+            if create_user_symbol:
+                break
+
+        if not create_user_symbol or "selectionRange" not in create_user_symbol:
+            pytest.skip("create_user function symbol or its selectionRange not found")
+
+        sel_start = create_user_symbol["selectionRange"]["start"]
+        ref_symbols = [
+            ref.symbol for ref in language_server.request_referencing_symbols(file_path, sel_start["line"], sel_start["character"])
+        ]
+
+        if ref_symbols:
+            # We might find references from services.erl or test files
+            service_references = [
+                symbol
+                for symbol in ref_symbols
+                if "location" in symbol
+                and "uri" in symbol["location"]
+                and ("services.erl" in symbol["location"]["uri"] or "test" in symbol["location"]["uri"])
+            ]
+            assert len(service_references) >= 0  # At least attempt to find references
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_request_referencing_symbols_none(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a position with no symbol."""
+        file_path = os.path.join("src", "models.erl")
+        # Line 3 is likely a blank line or comment
+        try:
+            ref_symbols = [ref.symbol for ref in language_server.request_referencing_symbols(file_path, 3, 0)]
+            # If we get here, make sure we got an empty result
+            assert ref_symbols == [] or ref_symbols is None
+        except Exception:
+            # The method might raise an exception for invalid positions
+            # which is acceptable behavior
+            pass
+
+    # Tests for request_defining_symbol
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_request_defining_symbol_function_call(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a function call."""
+        # Find a place where models:create_user is called in services.erl
+        file_path = os.path.join("src", "services.erl")
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        models_call_line = None
+        for i, line in enumerate(lines):
+            if "models:create_user(" in line:
+                models_call_line = i
+                break
+
+        if models_call_line is None:
+            pytest.skip("Could not find models:create_user call")
+
+        # Try to find the definition of models:create_user
+        defining_symbol = language_server.request_defining_symbol(file_path, models_call_line, 20)
+
+        if defining_symbol:
+            assert "create_user" in defining_symbol.get("name", "") or "models" in defining_symbol.get("name", "")
+            if "location" in defining_symbol and "uri" in defining_symbol["location"]:
+                assert "models.erl" in defining_symbol["location"]["uri"]
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_request_defining_symbol_record_usage(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a record usage."""
+        # Find a place where #user{} record is used in models.erl
+        file_path = os.path.join("src", "models.erl")
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        record_usage_line = None
+        for i, line in enumerate(lines):
+            if "#user{" in line:
+                record_usage_line = i
+                break
+
+        if record_usage_line is None:
+            pytest.skip("Could not find #user{} record usage")
+
+        defining_symbol = language_server.request_defining_symbol(file_path, record_usage_line, 10)
+
+        if defining_symbol:
+            assert "user" in defining_symbol.get("name", "").lower()
+            if "location" in defining_symbol and "uri" in defining_symbol["location"]:
+                assert "records.hrl" in defining_symbol["location"]["uri"]
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_request_defining_symbol_module_call(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a module function call."""
+        # Find a place where utils:validate_input is called
+        file_path = os.path.join("src", "models.erl")
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        utils_call_line = None
+        for i, line in enumerate(lines):
+            if "validate_email(" in line:
+                utils_call_line = i
+                break
+
+        if utils_call_line is None:
+            pytest.skip("Could not find function call in models.erl")
+
+        defining_symbol = language_server.request_defining_symbol(file_path, utils_call_line, 15)
+
+        if defining_symbol:
+            assert "validate" in defining_symbol.get("name", "") or "email" in defining_symbol.get("name", "")
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_request_defining_symbol_none(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a position with no symbol."""
+        # Test for a position with no symbol (e.g., whitespace or comment)
+        file_path = os.path.join("src", "models.erl")
+        # Line 3 is likely a blank line or comment
+        defining_symbol = language_server.request_defining_symbol(file_path, 3, 0)
+
+        # Should return None or empty
+        assert defining_symbol is None or defining_symbol == {}
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_symbol_methods_integration(self, language_server: SolidLanguageServer) -> None:
+        """Test integration between different symbol methods."""
+        file_path = os.path.join("src", "models.erl")
+
+        # Find create_user function definition
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        create_user_line = None
+        for i, line in enumerate(lines):
+            if "create_user(" in line and "-spec" not in line:
+                create_user_line = i
+                break
+
+        if create_user_line is None:
+            pytest.skip("Could not find create_user function")
+
+        # Test containing symbol
+        containing = language_server.request_containing_symbol(file_path, create_user_line + 2, 10)
+
+        if containing:
+            # Test that we can find references to this symbol
+            if "location" in containing and "range" in containing["location"]:
+                start_pos = containing["location"]["range"]["start"]
+                refs = [
+                    ref.symbol for ref in language_server.request_referencing_symbols(file_path, start_pos["line"], start_pos["character"])
+                ]
+                # We should find some references or none (both are valid outcomes)
+                assert isinstance(refs, list)
+
+    @pytest.mark.timeout(120)  # Add explicit timeout for this complex test
+    @pytest.mark.xfail(
+        reason="Known intermittent timeout issue in Erlang LS in CI environments. "
+        "May pass locally but can timeout on slower CI systems.",
+        strict=False,
+    )
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_symbol_tree_structure(self, language_server: SolidLanguageServer) -> None:
+        """Test that symbol tree structure is correctly built."""
+        symbol_tree = language_server.request_full_symbol_tree()
+
+        # Should get a tree structure
+        assert len(symbol_tree) > 0
+
+        # Should have our test repository structure
+        root = symbol_tree[0]
+        assert "children" in root
+
+        # Look for src directory
+        src_dir = None
+        for child in root["children"]:
+            if child["name"] == "src":
+                src_dir = child
+                break
+
+        if src_dir:
+            # Check for our Erlang modules
+            file_names = [child["name"] for child in src_dir.get("children", [])]
+            expected_modules = ["models", "services", "utils", "app"]
+            found_modules = [name for name in expected_modules if any(name in fname for fname in file_names)]
+            assert len(found_modules) > 0, f"Expected to find some modules from {expected_modules}, but got {file_names}"
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_request_dir_overview(self, language_server: SolidLanguageServer) -> None:
+        """Test request_dir_overview functionality."""
+        src_overview = language_server.request_dir_overview("src")
+
+        # Should get an overview of the src directory
+        assert src_overview is not None
+        overview_keys = list(src_overview.keys()) if hasattr(src_overview, "keys") else []
+        src_files = [key for key in overview_keys if key.startswith("src/") or "src" in key]
+        assert len(src_files) > 0, f"Expected to find src/ files in overview keys: {overview_keys}"
+
+        # Should contain information about our modules
+        overview_text = str(src_overview).lower()
+        expected_terms = ["models", "services", "user", "create_user", "gen_server"]
+        found_terms = [term for term in expected_terms if term in overview_text]
+        assert len(found_terms) > 0, f"Expected to find some terms from {expected_terms} in overview"
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_containing_symbol_of_record_field(self, language_server: SolidLanguageServer) -> None:
+        """Test containing symbol for record field access."""
+        file_path = os.path.join("src", "models.erl")
+
+        # Find a record field access like User#user.name
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        record_field_line = None
+        for i, line in enumerate(lines):
+            if "#user{" in line and ("name" in line or "email" in line or "id" in line):
+                record_field_line = i
+                break
+
+        if record_field_line is None:
+            pytest.skip("Could not find record field access")
+
+        containing_symbol = language_server.request_containing_symbol(file_path, record_field_line, 10)
+
+        if containing_symbol:
+            # Should be contained within a function
+            assert "name" in containing_symbol
+            expected_names = ["create_user", "update_user", "format_user_info"]
+            assert any(name in containing_symbol["name"] for name in expected_names)
+
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_containing_symbol_of_spec(self, language_server: SolidLanguageServer) -> None:
+        """Test containing symbol for function specs."""
+        file_path = os.path.join("src", "models.erl")
+
+        # Find a -spec directive
+        content = language_server.retrieve_full_file_content(file_path)
+        lines = content.split("\n")
+        spec_line = None
+        for i, line in enumerate(lines):
+            if line.strip().startswith("-spec") and "create_user" in line:
+                spec_line = i
+                break
+
+        if spec_line is None:
+            pytest.skip("Could not find -spec directive")
+
+        containing_symbol = language_server.request_containing_symbol(file_path, spec_line, 5)
+
+        if containing_symbol:
+            # Should be contained within the module or the function it specifies
+            assert "name" in containing_symbol
+            expected_names = ["models", "create_user"]
+            assert any(name in containing_symbol["name"] for name in expected_names)
+
+    @pytest.mark.timeout(90)  # Add explicit timeout
+    @pytest.mark.xfail(
+        reason="Known intermittent timeout issue in Erlang LS in CI environments. "
+        "May pass locally but can timeout on slower CI systems, especially macOS. "
+        "Similar to known Next LS timeout issues.",
+        strict=False,
+    )
+    @pytest.mark.parametrize("language_server", [Language.ERLANG], indirect=True)
+    def test_referencing_symbols_across_files(self, language_server: SolidLanguageServer) -> None:
+        """Test finding references across different files."""
+        # Test that we can find references to models module functions in services.erl
+        file_path = os.path.join("src", "models.erl")
+
+        symbols = language_server.request_document_symbols(file_path)
+        create_user_symbol = None
+        for symbol_group in symbols:
+            create_user_symbol = next((s for s in symbol_group if "create_user" in s.get("name", "")), None)
+            if create_user_symbol:
+                break
+
+        if not create_user_symbol or "selectionRange" not in create_user_symbol:
+            pytest.skip("create_user function symbol not found")
+
+        sel_start = create_user_symbol["selectionRange"]["start"]
+        ref_symbols = [
+            ref.symbol for ref in language_server.request_referencing_symbols(file_path, sel_start["line"], sel_start["character"])
+        ]
+
+        # Look for cross-file references
+        cross_file_refs = [
+            symbol
+            for symbol in ref_symbols
+            if "location" in symbol and "uri" in symbol["location"] and not symbol["location"]["uri"].endswith("models.erl")
+        ]
+
+        # We might find references in services.erl or test files
+        if cross_file_refs:
+            assert len(cross_file_refs) > 0, "Should find some cross-file references"

projects/ui/serena-new/test/solidlsp/go/test_go_basic.py

@@ -0,0 +1,33 @@
+import os
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_utils import SymbolUtils
+
+
+@pytest.mark.go
+class TestGoLanguageServer:
+    @pytest.mark.parametrize("language_server", [Language.GO], indirect=True)
+    def test_find_symbol(self, language_server: SolidLanguageServer) -> None:
+        symbols = language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "main"), "main function not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Helper"), "Helper function not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "DemoStruct"), "DemoStruct not found in symbol tree"
+
+    @pytest.mark.parametrize("language_server", [Language.GO], indirect=True)
+    def test_find_referencing_symbols(self, language_server: SolidLanguageServer) -> None:
+        file_path = os.path.join("main.go")
+        symbols = language_server.request_document_symbols(file_path)
+        helper_symbol = None
+        for sym in symbols[0]:
+            if sym.get("name") == "Helper":
+                helper_symbol = sym
+                break
+        assert helper_symbol is not None, "Could not find 'Helper' function symbol in main.go"
+        sel_start = helper_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert any(
+            "main.go" in ref.get("relativePath", "") for ref in refs
+        ), "main.go should reference Helper (tried all positions in selectionRange)"

projects/ui/serena-new/test/solidlsp/java/test_java_basic.py

@@ -0,0 +1,50 @@
+import os
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_utils import SymbolUtils
+
+
+@pytest.mark.java
+class TestJavaLanguageServer:
+    @pytest.mark.parametrize("language_server", [Language.JAVA], indirect=True)
+    def test_find_symbol(self, language_server: SolidLanguageServer) -> None:
+        symbols = language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Main"), "Main class not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Utils"), "Utils class not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Model"), "Model class not found in symbol tree"
+
+    @pytest.mark.parametrize("language_server", [Language.JAVA], indirect=True)
+    def test_find_referencing_symbols(self, language_server: SolidLanguageServer) -> None:
+        # Use correct Maven/Java file paths
+        file_path = os.path.join("src", "main", "java", "test_repo", "Utils.java")
+        refs = language_server.request_references(file_path, 4, 20)
+        assert any("Main.java" in ref.get("relativePath", "") for ref in refs), "Main should reference Utils.printHello"
+
+        # Dynamically determine the correct line/column for the 'Model' class name
+        file_path = os.path.join("src", "main", "java", "test_repo", "Model.java")
+        symbols = language_server.request_document_symbols(file_path)
+        model_symbol = None
+        for sym in symbols[0]:
+            if sym.get("name") == "Model" and sym.get("kind") == 5:  # 5 = Class
+                model_symbol = sym
+                break
+        assert model_symbol is not None, "Could not find 'Model' class symbol in Model.java"
+        # Use selectionRange if present, otherwise fall back to range
+        if "selectionRange" in model_symbol:
+            sel_start = model_symbol["selectionRange"]["start"]
+        else:
+            sel_start = model_symbol["range"]["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert any(
+            "Main.java" in ref.get("relativePath", "") for ref in refs
+        ), "Main should reference Model (tried all positions in selectionRange)"
+
+    @pytest.mark.parametrize("language_server", [Language.JAVA], indirect=True)
+    def test_overview_methods(self, language_server: SolidLanguageServer) -> None:
+        symbols = language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Main"), "Main missing from overview"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Utils"), "Utils missing from overview"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Model"), "Model missing from overview"

projects/ui/serena-new/test/solidlsp/kotlin/test_kotlin_basic.py

@@ -0,0 +1,52 @@
+import os
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_utils import SymbolUtils
+
+
+@pytest.mark.kotlin
+class TestKotlinLanguageServer:
+    @pytest.mark.parametrize("language_server", [Language.KOTLIN], indirect=True)
+    def test_find_symbol(self, language_server: SolidLanguageServer) -> None:
+        symbols = language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Main"), "Main class not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Utils"), "Utils class not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Model"), "Model class not found in symbol tree"
+
+    @pytest.mark.parametrize("language_server", [Language.KOTLIN], indirect=True)
+    def test_find_referencing_symbols(self, language_server: SolidLanguageServer) -> None:
+        # Use correct Kotlin file paths
+        file_path = os.path.join("src", "main", "kotlin", "test_repo", "Utils.kt")
+        refs = language_server.request_references(file_path, 3, 12)
+        assert any("Main.kt" in ref.get("relativePath", "") for ref in refs), "Main should reference Utils.printHello"
+
+        # Dynamically determine the correct line/column for the 'Model' class name
+        file_path = os.path.join("src", "main", "kotlin", "test_repo", "Model.kt")
+        symbols = language_server.request_document_symbols(file_path)
+        model_symbol = None
+        for sym in symbols[0]:
+            print(sym)
+            print("\n")
+            if sym.get("name") == "Model" and sym.get("kind") == 23:  # 23 = Class
+                model_symbol = sym
+                break
+        assert model_symbol is not None, "Could not find 'Model' class symbol in Model.kt"
+        # Use selectionRange if present, otherwise fall back to range
+        if "selectionRange" in model_symbol:
+            sel_start = model_symbol["selectionRange"]["start"]
+        else:
+            sel_start = model_symbol["range"]["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert any(
+            "Main.kt" in ref.get("relativePath", "") for ref in refs
+        ), "Main should reference Model (tried all positions in selectionRange)"
+
+    @pytest.mark.parametrize("language_server", [Language.KOTLIN], indirect=True)
+    def test_overview_methods(self, language_server: SolidLanguageServer) -> None:
+        symbols = language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Main"), "Main missing from overview"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Utils"), "Utils missing from overview"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Model"), "Model missing from overview"

projects/ui/serena-new/test/solidlsp/lua/test_lua_basic.py

@@ -0,0 +1,255 @@
+"""
+Tests for the Lua language server implementation.
+
+These tests validate symbol finding and cross-file reference capabilities
+for Lua modules and functions.
+"""
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_types import SymbolKind
+
+
+@pytest.mark.lua
+class TestLuaLanguageServer:
+    """Test Lua language server symbol finding and cross-file references."""
+
+    @pytest.mark.parametrize("language_server", [Language.LUA], indirect=True)
+    def test_find_symbols_in_calculator(self, language_server: SolidLanguageServer) -> None:
+        """Test finding specific functions in calculator.lua."""
+        symbols = language_server.request_document_symbols("src/calculator.lua")
+
+        assert symbols is not None
+        assert len(symbols) > 0
+
+        # Extract function names from the returned structure
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+        function_names = set()
+        for symbol in symbol_list:
+            if isinstance(symbol, dict):
+                name = symbol.get("name", "")
+                # Handle both plain names and module-prefixed names
+                if "." in name:
+                    name = name.split(".")[-1]
+                if symbol.get("kind") == SymbolKind.Function:
+                    function_names.add(name)
+
+        # Verify exact calculator functions exist
+        expected_functions = {"add", "subtract", "multiply", "divide", "factorial"}
+        found_functions = function_names & expected_functions
+        assert found_functions == expected_functions, f"Expected exactly {expected_functions}, found {found_functions}"
+
+        # Verify specific functions
+        assert "add" in function_names, "add function not found"
+        assert "multiply" in function_names, "multiply function not found"
+        assert "factorial" in function_names, "factorial function not found"
+
+    @pytest.mark.parametrize("language_server", [Language.LUA], indirect=True)
+    def test_find_symbols_in_utils(self, language_server: SolidLanguageServer) -> None:
+        """Test finding specific functions in utils.lua."""
+        symbols = language_server.request_document_symbols("src/utils.lua")
+
+        assert symbols is not None
+        assert len(symbols) > 0
+
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+        function_names = set()
+        all_symbols = set()
+
+        for symbol in symbol_list:
+            if isinstance(symbol, dict):
+                name = symbol.get("name", "")
+                all_symbols.add(name)
+                # Handle both plain names and module-prefixed names
+                if "." in name:
+                    name = name.split(".")[-1]
+                if symbol.get("kind") == SymbolKind.Function:
+                    function_names.add(name)
+
+        # Verify exact string utility functions
+        expected_utils = {"trim", "split", "starts_with", "ends_with"}
+        found_utils = function_names & expected_utils
+        assert found_utils == expected_utils, f"Expected exactly {expected_utils}, found {found_utils}"
+
+        # Verify exact table utility functions
+        table_utils = {"deep_copy", "table_contains", "table_merge"}
+        found_table_utils = function_names & table_utils
+        assert found_table_utils == table_utils, f"Expected exactly {table_utils}, found {found_table_utils}"
+
+        # Check for Logger class/table
+        assert "Logger" in all_symbols or any("Logger" in s for s in all_symbols), "Logger not found in symbols"
+
+    @pytest.mark.parametrize("language_server", [Language.LUA], indirect=True)
+    def test_find_symbols_in_main(self, language_server: SolidLanguageServer) -> None:
+        """Test finding functions in main.lua."""
+        symbols = language_server.request_document_symbols("main.lua")
+
+        assert symbols is not None
+        assert len(symbols) > 0
+
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+        function_names = set()
+
+        for symbol in symbol_list:
+            if isinstance(symbol, dict) and symbol.get("kind") == SymbolKind.Function:
+                function_names.add(symbol.get("name", ""))
+
+        # Verify exact main functions exist
+        expected_funcs = {"print_banner", "test_calculator", "test_utils"}
+        found_funcs = function_names & expected_funcs
+        assert found_funcs == expected_funcs, f"Expected exactly {expected_funcs}, found {found_funcs}"
+
+        assert "test_calculator" in function_names, "test_calculator function not found"
+        assert "test_utils" in function_names, "test_utils function not found"
+
+    @pytest.mark.parametrize("language_server", [Language.LUA], indirect=True)
+    def test_cross_file_references_calculator_add(self, language_server: SolidLanguageServer) -> None:
+        """Test finding cross-file references to calculator.add function."""
+        symbols = language_server.request_document_symbols("src/calculator.lua")
+
+        assert symbols is not None
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+
+        # Find the add function
+        add_symbol = None
+        for sym in symbol_list:
+            if isinstance(sym, dict):
+                name = sym.get("name", "")
+                if "add" in name or name == "add":
+                    add_symbol = sym
+                    break
+
+        assert add_symbol is not None, "add function not found in calculator.lua"
+
+        # Get references to the add function
+        range_info = add_symbol.get("selectionRange", add_symbol.get("range"))
+        assert range_info is not None, "add function has no range information"
+
+        range_start = range_info["start"]
+        refs = language_server.request_references("src/calculator.lua", range_start["line"], range_start["character"])
+
+        assert refs is not None
+        assert isinstance(refs, list)
+        # add function appears in: main.lua (lines 16, 71), test_calculator.lua (lines 22, 23, 24)
+        # Note: The declaration itself may or may not be included as a reference
+        assert len(refs) >= 5, f"Should find at least 5 references to calculator.add, found {len(refs)}"
+
+        # Verify exact reference locations
+        ref_files = {}
+        for ref in refs:
+            filename = ref.get("uri", "").split("/")[-1]
+            if filename not in ref_files:
+                ref_files[filename] = []
+            ref_files[filename].append(ref["range"]["start"]["line"])
+
+        # The declaration may or may not be included
+        if "calculator.lua" in ref_files:
+            assert (
+                5 in ref_files["calculator.lua"]
+            ), f"If declaration is included, it should be at line 6 (0-indexed: 5), found at {ref_files['calculator.lua']}"
+
+        # Check main.lua has usages
+        assert "main.lua" in ref_files, "Should find add usages in main.lua"
+        assert (
+            15 in ref_files["main.lua"] or 70 in ref_files["main.lua"]
+        ), f"Should find add usage in main.lua, found at lines {ref_files.get('main.lua', [])}"
+
+        # Check for cross-file references from main.lua
+        main_refs = [ref for ref in refs if "main.lua" in ref.get("uri", "")]
+        assert len(main_refs) > 0, "calculator.add should be called in main.lua"
+
+    @pytest.mark.parametrize("language_server", [Language.LUA], indirect=True)
+    def test_cross_file_references_utils_trim(self, language_server: SolidLanguageServer) -> None:
+        """Test finding cross-file references to utils.trim function."""
+        symbols = language_server.request_document_symbols("src/utils.lua")
+
+        assert symbols is not None
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+
+        # Find the trim function
+        trim_symbol = None
+        for sym in symbol_list:
+            if isinstance(sym, dict):
+                name = sym.get("name", "")
+                if "trim" in name or name == "trim":
+                    trim_symbol = sym
+                    break
+
+        assert trim_symbol is not None, "trim function not found in utils.lua"
+
+        # Get references to the trim function
+        range_info = trim_symbol.get("selectionRange", trim_symbol.get("range"))
+        assert range_info is not None, "trim function has no range information"
+
+        range_start = range_info["start"]
+        refs = language_server.request_references("src/utils.lua", range_start["line"], range_start["character"])
+
+        assert refs is not None
+        assert isinstance(refs, list)
+        # trim function appears in: usage (line 32 in main.lua)
+        # Note: The declaration itself may or may not be included as a reference
+        assert len(refs) >= 1, f"Should find at least 1 reference to utils.trim, found {len(refs)}"
+
+        # Verify exact reference locations
+        ref_files = {}
+        for ref in refs:
+            filename = ref.get("uri", "").split("/")[-1]
+            if filename not in ref_files:
+                ref_files[filename] = []
+            ref_files[filename].append(ref["range"]["start"]["line"])
+
+        # The declaration may or may not be included
+        if "utils.lua" in ref_files:
+            assert (
+                5 in ref_files["utils.lua"]
+            ), f"If declaration is included, it should be at line 6 (0-indexed: 5), found at {ref_files['utils.lua']}"
+
+        # Check main.lua has usage
+        assert "main.lua" in ref_files, "Should find trim usage in main.lua"
+        assert (
+            31 in ref_files["main.lua"]
+        ), f"Should find trim usage at line 32 (0-indexed: 31) in main.lua, found at lines {ref_files.get('main.lua', [])}"
+
+        # Check for cross-file references from main.lua
+        main_refs = [ref for ref in refs if "main.lua" in ref.get("uri", "")]
+        assert len(main_refs) > 0, "utils.trim should be called in main.lua"
+
+    @pytest.mark.parametrize("language_server", [Language.LUA], indirect=True)
+    def test_hover_information(self, language_server: SolidLanguageServer) -> None:
+        """Test hover information for symbols."""
+        # Get hover info for a function
+        hover_info = language_server.request_hover("src/calculator.lua", 5, 10)  # Position near add function
+
+        assert hover_info is not None, "Should provide hover information"
+
+        # Hover info could be a dict with 'contents' or a string
+        if isinstance(hover_info, dict):
+            assert "contents" in hover_info or "value" in hover_info, "Hover should have contents"
+
+    @pytest.mark.parametrize("language_server", [Language.LUA], indirect=True)
+    def test_full_symbol_tree(self, language_server: SolidLanguageServer) -> None:
+        """Test that full symbol tree is not empty."""
+        symbols = language_server.request_full_symbol_tree()
+
+        assert symbols is not None
+        assert len(symbols) > 0, "Symbol tree should not be empty"
+
+        # The tree should have at least one root node
+        root = symbols[0]
+        assert isinstance(root, dict), "Root should be a dict"
+        assert "name" in root, "Root should have a name"
+
+    @pytest.mark.parametrize("language_server", [Language.LUA], indirect=True)
+    def test_references_between_test_and_source(self, language_server: SolidLanguageServer) -> None:
+        """Test finding references from test files to source files."""
+        # Check if test_calculator.lua references calculator module
+        test_symbols = language_server.request_document_symbols("tests/test_calculator.lua")
+
+        assert test_symbols is not None
+        assert len(test_symbols) > 0
+
+        # The test file should have some content that references calculator
+        symbol_list = test_symbols[0] if isinstance(test_symbols, tuple) else test_symbols
+        assert len(symbol_list) > 0, "test_calculator.lua should have symbols"

projects/ui/serena-new/test/solidlsp/nix/test_nix_basic.py

@@ -0,0 +1,218 @@
+"""
+Tests for the Nix language server implementation using nixd.
+
+These tests validate symbol finding and cross-file reference capabilities for Nix expressions.
+"""
+
+import platform
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+
+# Skip all Nix tests on Windows as Nix doesn't support Windows
+pytestmark = pytest.mark.skipif(platform.system() == "Windows", reason="Nix and nil are not available on Windows")
+
+
+@pytest.mark.nix
+class TestNixLanguageServer:
+    """Test Nix language server symbol finding capabilities."""
+
+    @pytest.mark.parametrize("language_server", [Language.NIX], indirect=True)
+    def test_find_symbols_in_default_nix(self, language_server: SolidLanguageServer) -> None:
+        """Test finding specific symbols in default.nix."""
+        symbols = language_server.request_document_symbols("default.nix")
+
+        assert symbols is not None
+        assert len(symbols) > 0
+
+        # Extract symbol names from the returned structure
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+        symbol_names = {sym.get("name") for sym in symbol_list if isinstance(sym, dict)}
+
+        # Verify specific function exists
+        assert "makeGreeting" in symbol_names, "makeGreeting function not found"
+
+        # Verify exact attribute sets are found
+        expected_attrs = {"listUtils", "stringUtils"}
+        found_attrs = symbol_names & expected_attrs
+        assert found_attrs == expected_attrs, f"Expected exactly {expected_attrs}, found {found_attrs}"
+
+    @pytest.mark.parametrize("language_server", [Language.NIX], indirect=True)
+    def test_find_symbols_in_utils(self, language_server: SolidLanguageServer) -> None:
+        """Test finding symbols in lib/utils.nix."""
+        symbols = language_server.request_document_symbols("lib/utils.nix")
+
+        assert symbols is not None
+        assert len(symbols) > 0
+
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+        symbol_names = {sym.get("name") for sym in symbol_list if isinstance(sym, dict)}
+
+        # Verify exact utility modules are found
+        expected_modules = {"math", "strings", "lists", "attrs"}
+        found_modules = symbol_names & expected_modules
+        assert found_modules == expected_modules, f"Expected exactly {expected_modules}, found {found_modules}"
+
+    @pytest.mark.parametrize("language_server", [Language.NIX], indirect=True)
+    def test_find_symbols_in_flake(self, language_server: SolidLanguageServer) -> None:
+        """Test finding symbols in flake.nix."""
+        symbols = language_server.request_document_symbols("flake.nix")
+
+        assert symbols is not None
+        assert len(symbols) > 0
+
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+        symbol_names = {sym.get("name") for sym in symbol_list if isinstance(sym, dict)}
+
+        # Flakes must have either inputs or outputs
+        assert "inputs" in symbol_names or "outputs" in symbol_names, "Flake must have inputs or outputs"
+
+    @pytest.mark.parametrize("language_server", [Language.NIX], indirect=True)
+    def test_find_symbols_in_module(self, language_server: SolidLanguageServer) -> None:
+        """Test finding symbols in a NixOS module."""
+        symbols = language_server.request_document_symbols("modules/example.nix")
+
+        assert symbols is not None
+        assert len(symbols) > 0
+
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+        symbol_names = {sym.get("name") for sym in symbol_list if isinstance(sym, dict)}
+
+        # NixOS modules must have either options or config
+        assert "options" in symbol_names or "config" in symbol_names, "Module must have options or config"
+
+    @pytest.mark.parametrize("language_server", [Language.NIX], indirect=True)
+    def test_find_references_within_file(self, language_server: SolidLanguageServer) -> None:
+        """Test finding references within the same file."""
+        symbols = language_server.request_document_symbols("default.nix")
+
+        assert symbols is not None
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+
+        # Find makeGreeting function
+        greeting_symbol = None
+        for sym in symbol_list:
+            if sym.get("name") == "makeGreeting":
+                greeting_symbol = sym
+                break
+
+        assert greeting_symbol is not None, "makeGreeting function not found"
+        assert "range" in greeting_symbol, "Symbol must have range information"
+
+        range_start = greeting_symbol["range"]["start"]
+        refs = language_server.request_references("default.nix", range_start["line"], range_start["character"])
+
+        assert refs is not None
+        assert isinstance(refs, list)
+        # nixd finds at least the inherit statement (line 67)
+        assert len(refs) >= 1, f"Should find at least 1 reference to makeGreeting, found {len(refs)}"
+
+        # Verify makeGreeting is referenced at expected locations
+        if refs:
+            ref_lines = sorted([ref["range"]["start"]["line"] for ref in refs])
+            # Check if we found the inherit (line 67, 0-indexed: 66)
+            assert 66 in ref_lines, f"Should find makeGreeting inherit at line 67, found at lines {[l+1 for l in ref_lines]}"
+
+    @pytest.mark.parametrize("language_server", [Language.NIX], indirect=True)
+    def test_hover_information(self, language_server: SolidLanguageServer) -> None:
+        """Test hover information for symbols."""
+        # Get hover info for makeGreeting function
+        hover_info = language_server.request_hover("default.nix", 9, 5)  # Position near makeGreeting
+
+        assert hover_info is not None, "Should provide hover information"
+
+        if isinstance(hover_info, dict) and len(hover_info) > 0:
+            # If hover info is provided, it should have proper structure
+            assert "contents" in hover_info or "value" in hover_info, "Hover should have contents or value"
+
+    @pytest.mark.parametrize("language_server", [Language.NIX], indirect=True)
+    def test_cross_file_references_utils_import(self, language_server: SolidLanguageServer) -> None:
+        """Test finding cross-file references for imported utils."""
+        # Find references to 'utils' which is imported in default.nix from lib/utils.nix
+        # Line 10 in default.nix: utils = import ./lib/utils.nix { inherit lib; };
+        refs = language_server.request_references("default.nix", 9, 2)  # Position of 'utils'
+
+        assert refs is not None
+        assert isinstance(refs, list)
+
+        # Should find references within default.nix where utils is used
+        default_refs = [ref for ref in refs if "default.nix" in ref.get("uri", "")]
+        # utils is: imported (line 10), used in listUtils.unique (line 24), inherited in exports (line 69)
+        assert len(default_refs) >= 2, f"Should find at least 2 references to utils in default.nix, found {len(default_refs)}"
+
+        # Verify utils is referenced at expected locations (0-indexed)
+        if default_refs:
+            ref_lines = sorted([ref["range"]["start"]["line"] for ref in default_refs])
+            # Check for key references - at least the import (line 10) or usage (line 24)
+            assert (
+                9 in ref_lines or 23 in ref_lines
+            ), f"Should find utils import or usage, found references at lines {[l+1 for l in ref_lines]}"
+
+    @pytest.mark.parametrize("language_server", [Language.NIX], indirect=True)
+    def test_verify_imports_exist(self, language_server: SolidLanguageServer) -> None:
+        """Verify that our test files have proper imports set up."""
+        # Verify that default.nix imports utils from lib/utils.nix
+        symbols = language_server.request_document_symbols("default.nix")
+
+        assert symbols is not None
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+
+        # Check that makeGreeting exists (defined in default.nix)
+        symbol_names = {sym.get("name") for sym in symbol_list if isinstance(sym, dict)}
+        assert "makeGreeting" in symbol_names, "makeGreeting should be found in default.nix"
+
+        # Verify lib/utils.nix has the expected structure
+        utils_symbols = language_server.request_document_symbols("lib/utils.nix")
+        assert utils_symbols is not None
+        utils_list = utils_symbols[0] if isinstance(utils_symbols, tuple) else utils_symbols
+        utils_names = {sym.get("name") for sym in utils_list if isinstance(sym, dict)}
+
+        # Verify key functions exist in utils
+        assert "math" in utils_names, "math should be found in lib/utils.nix"
+        assert "strings" in utils_names, "strings should be found in lib/utils.nix"
+
+    @pytest.mark.parametrize("language_server", [Language.NIX], indirect=True)
+    def test_go_to_definition_cross_file(self, language_server: SolidLanguageServer) -> None:
+        """Test go-to-definition from default.nix to lib/utils.nix."""
+        # Line 24 in default.nix: unique = utils.lists.unique;
+        # Test go-to-definition for 'utils'
+        definitions = language_server.request_definition("default.nix", 23, 14)  # Position of 'utils'
+
+        assert definitions is not None
+        assert isinstance(definitions, list)
+
+        if len(definitions) > 0:
+            # Should point to the import statement or utils.nix
+            assert any(
+                "utils" in def_item.get("uri", "") or "default.nix" in def_item.get("uri", "") for def_item in definitions
+            ), "Definition should relate to utils import or utils.nix file"
+
+    @pytest.mark.parametrize("language_server", [Language.NIX], indirect=True)
+    def test_definition_navigation_in_flake(self, language_server: SolidLanguageServer) -> None:
+        """Test definition navigation in flake.nix."""
+        # Test that we can navigate to definitions within flake.nix
+        # Line 69: default = hello-custom;
+        definitions = language_server.request_definition("flake.nix", 68, 20)  # Position of 'hello-custom'
+
+        assert definitions is not None
+        assert isinstance(definitions, list)
+        # nixd should find the definition of hello-custom in the same file
+        if len(definitions) > 0:
+            assert any(
+                "flake.nix" in def_item.get("uri", "") for def_item in definitions
+            ), "Should find hello-custom definition in flake.nix"
+
+    @pytest.mark.parametrize("language_server", [Language.NIX], indirect=True)
+    def test_full_symbol_tree(self, language_server: SolidLanguageServer) -> None:
+        """Test that full symbol tree is not empty."""
+        symbols = language_server.request_full_symbol_tree()
+
+        assert symbols is not None
+        assert len(symbols) > 0, "Symbol tree should not be empty"
+
+        # The tree should have at least one root node
+        root = symbols[0]
+        assert isinstance(root, dict), "Root should be a dict"
+        assert "name" in root, "Root should have a name"

projects/ui/serena-new/test/solidlsp/php/test_php_basic.py

@@ -0,0 +1,135 @@
+from pathlib import Path
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+
+
+@pytest.mark.php
+class TestPhpLanguageServer:
+    @pytest.mark.parametrize("language_server", [Language.PHP], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.PHP], indirect=True)
+    def test_ls_is_running(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        """Test that the language server starts and stops successfully."""
+        # The fixture already handles start and stop
+        assert language_server.is_running()
+        assert Path(language_server.language_server.repository_root_path).resolve() == repo_path.resolve()
+
+    @pytest.mark.parametrize("language_server", [Language.PHP], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.PHP], indirect=True)
+    def test_find_definition_within_file(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+
+        # In index.php:
+        # Line 9 (1-indexed): $greeting = greet($userName);
+        # Line 11 (1-indexed): echo $greeting;
+        # We want to find the definition of $greeting (defined on line 9)
+        # from its usage in echo $greeting; on line 11.
+        # LSP is 0-indexed: definition on line 8, usage on line 10.
+        # $greeting in echo $greeting; is at char 5 on line 11 (0-indexed: line 10, char 5)
+        # e c h o   $ g r e e t i n g
+        #           ^ char 5
+        definition_location_list = language_server.request_definition(str(repo_path / "index.php"), 10, 6)  # cursor on 'g' in $greeting
+
+        assert definition_location_list, f"Expected non-empty definition_location_list but got {definition_location_list=}"
+        assert len(definition_location_list) == 1
+        definition_location = definition_location_list[0]
+        assert definition_location["uri"].endswith("index.php")
+        # Definition of $greeting is on line 10 (1-indexed) / line 9 (0-indexed), char 0
+        assert definition_location["range"]["start"]["line"] == 9
+        assert definition_location["range"]["start"]["character"] == 0
+
+    @pytest.mark.parametrize("language_server", [Language.PHP], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.PHP], indirect=True)
+    def test_find_definition_across_files(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        definition_location_list = language_server.request_definition(str(repo_path / "index.php"), 12, 5)  # helperFunction
+
+        assert definition_location_list, f"Expected non-empty definition_location_list but got {definition_location_list=}"
+        assert len(definition_location_list) == 1
+        definition_location = definition_location_list[0]
+        assert definition_location["uri"].endswith("helper.php")
+        assert definition_location["range"]["start"]["line"] == 2
+        assert definition_location["range"]["start"]["character"] == 0
+
+    @pytest.mark.parametrize("language_server", [Language.PHP], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.PHP], indirect=True)
+    def test_find_definition_simple_variable(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        file_path = str(repo_path / "simple_var.php")
+
+        # In simple_var.php:
+        # Line 2 (1-indexed): $localVar = "test";
+        # Line 3 (1-indexed): echo $localVar;
+        # LSP is 0-indexed: definition on line 1, usage on line 2
+        # Find definition of $localVar (char 5 on line 3 / 0-indexed: line 2, char 5)
+        # $localVar in echo $localVar;  (e c h o   $ l o c a l V a r)
+        #                           ^ char 5
+        definition_location_list = language_server.request_definition(file_path, 2, 6)  # cursor on 'l' in $localVar
+
+        assert definition_location_list, f"Expected non-empty definition_location_list but got {definition_location_list=}"
+        assert len(definition_location_list) == 1
+        definition_location = definition_location_list[0]
+        assert definition_location["uri"].endswith("simple_var.php")
+        assert definition_location["range"]["start"]["line"] == 1  # Definition of $localVar (0-indexed)
+        assert definition_location["range"]["start"]["character"] == 0  # $localVar (0-indexed)
+
+    @pytest.mark.parametrize("language_server", [Language.PHP], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.PHP], indirect=True)
+    def test_find_references_within_file(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        index_php_path = str(repo_path / "index.php")
+
+        # In index.php (0-indexed lines):
+        # Line 9: $greeting = greet($userName); // Definition of $greeting
+        # Line 11: echo $greeting;            // Usage of $greeting
+        # Find references for $greeting from its usage in "echo $greeting;" (line 11, char 6 for 'g')
+        references = language_server.request_references(index_php_path, 11, 6)
+
+        assert references
+        # Intelephense, when asked for references from usage, seems to only return the usage itself.
+        assert len(references) == 1, "Expected to find 1 reference for $greeting (the usage itself)"
+
+        expected_locations = [{"uri_suffix": "index.php", "line": 11, "character": 5}]  # Usage: echo $greeting (points to $)
+
+        # Convert actual references to a comparable format and sort
+        actual_locations = sorted(
+            [
+                {
+                    "uri_suffix": loc["uri"].split("/")[-1],
+                    "line": loc["range"]["start"]["line"],
+                    "character": loc["range"]["start"]["character"],
+                }
+                for loc in references
+            ],
+            key=lambda x: (x["uri_suffix"], x["line"], x["character"]),
+        )
+
+        expected_locations = sorted(expected_locations, key=lambda x: (x["uri_suffix"], x["line"], x["character"]))
+
+        assert actual_locations == expected_locations
+
+    @pytest.mark.parametrize("language_server", [Language.PHP], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.PHP], indirect=True)
+    def test_find_references_across_files(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        helper_php_path = str(repo_path / "helper.php")
+        # In index.php (0-indexed lines):
+        # Line 13: helperFunction(); // Usage of helperFunction
+        # Find references for helperFunction from its definition
+        references = language_server.request_references(helper_php_path, 2, len("function "))
+
+        assert references, f"Expected non-empty references for helperFunction but got {references=}"
+        # Intelephense might return 1 (usage) or 2 (usage + definition) references.
+        # Let's check for at least the usage in index.php
+        # Definition is in helper.php, line 2, char 0 (based on previous findings)
+        # Usage is in index.php, line 13, char 0
+
+        actual_locations_comparable = []
+        for loc in references:
+            actual_locations_comparable.append(
+                {
+                    "uri_suffix": loc["uri"].split("/")[-1],
+                    "line": loc["range"]["start"]["line"],
+                    "character": loc["range"]["start"]["character"],
+                }
+            )
+
+        usage_in_index_php = {"uri_suffix": "index.php", "line": 13, "character": 0}
+        assert usage_in_index_php in actual_locations_comparable, "Usage of helperFunction in index.php not found"

projects/ui/serena-new/test/solidlsp/python/test_python_basic.py

@@ -0,0 +1,235 @@
+"""
+Basic integration tests for the language server functionality.
+
+These tests validate the functionality of the language server APIs
+like request_references using the test repository.
+"""
+
+import os
+
+import pytest
+
+from serena.project import Project
+from serena.text_utils import LineType
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+
+
+@pytest.mark.python
+class TestLanguageServerBasics:
+    """Test basic functionality of the language server."""
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_references_user_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_references on the User class."""
+        # Get references to the User class in models.py
+        file_path = os.path.join("test_repo", "models.py")
+        # Line 31 contains the User class definition
+        # Use selectionRange only
+        symbols = language_server.request_document_symbols(file_path)
+        user_symbol = next((s for s in symbols[0] if s.get("name") == "User"), None)
+        if not user_symbol or "selectionRange" not in user_symbol:
+            raise AssertionError("User symbol or its selectionRange not found")
+        sel_start = user_symbol["selectionRange"]["start"]
+        references = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert len(references) > 1, "User class should be referenced in multiple files (using selectionRange if present)"
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_references_item_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_references on the Item class."""
+        # Get references to the Item class in models.py
+        file_path = os.path.join("test_repo", "models.py")
+        # Line 56 contains the Item class definition
+        # Use selectionRange only
+        symbols = language_server.request_document_symbols(file_path)
+        item_symbol = next((s for s in symbols[0] if s.get("name") == "Item"), None)
+        if not item_symbol or "selectionRange" not in item_symbol:
+            raise AssertionError("Item symbol or its selectionRange not found")
+        sel_start = item_symbol["selectionRange"]["start"]
+        references = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        services_references = [ref for ref in references if "services.py" in ref["uri"]]
+        assert len(services_references) > 0, "At least one reference should be in services.py (using selectionRange if present)"
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_references_function_parameter(self, language_server: SolidLanguageServer) -> None:
+        """Test request_references on a function parameter."""
+        # Get references to the id parameter in get_user method
+        file_path = os.path.join("test_repo", "services.py")
+        # Line 24 contains the get_user method with id parameter
+        # Use selectionRange only
+        symbols = language_server.request_document_symbols(file_path)
+        get_user_symbol = next((s for s in symbols[0] if s.get("name") == "get_user"), None)
+        if not get_user_symbol or "selectionRange" not in get_user_symbol:
+            raise AssertionError("get_user symbol or its selectionRange not found")
+        sel_start = get_user_symbol["selectionRange"]["start"]
+        references = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert len(references) > 0, "id parameter should be referenced within the method (using selectionRange if present)"
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_references_create_user_method(self, language_server: SolidLanguageServer) -> None:
+        # Get references to the create_user method in UserService
+        file_path = os.path.join("test_repo", "services.py")
+        # Line 15 contains the create_user method definition
+        # Use selectionRange only
+        symbols = language_server.request_document_symbols(file_path)
+        create_user_symbol = next((s for s in symbols[0] if s.get("name") == "create_user"), None)
+        if not create_user_symbol or "selectionRange" not in create_user_symbol:
+            raise AssertionError("create_user symbol or its selectionRange not found")
+        sel_start = create_user_symbol["selectionRange"]["start"]
+        references = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert len(references) > 1, "Should get valid references for create_user (using selectionRange if present)"
+
+
+class TestProjectBasics:
+    @pytest.mark.parametrize("project", [Language.PYTHON], indirect=True)
+    def test_retrieve_content_around_line(self, project: Project) -> None:
+        """Test retrieve_content_around_line functionality with various scenarios."""
+        file_path = os.path.join("test_repo", "models.py")
+
+        # Scenario 1: Just a single line (User class definition)
+        line_31 = project.retrieve_content_around_line(file_path, 31)
+        assert len(line_31.lines) == 1
+        assert "class User(BaseModel):" in line_31.lines[0].line_content
+        assert line_31.lines[0].line_number == 31
+        assert line_31.lines[0].match_type == LineType.MATCH
+
+        # Scenario 2: Context above and below
+        with_context_around_user = project.retrieve_content_around_line(file_path, 31, 2, 2)
+        assert len(with_context_around_user.lines) == 5
+        # Check line content
+        assert "class User(BaseModel):" in with_context_around_user.matched_lines[0].line_content
+        assert with_context_around_user.num_matched_lines == 1
+        assert "    User model representing a system user." in with_context_around_user.lines[4].line_content
+        # Check line numbers
+        assert with_context_around_user.lines[0].line_number == 29
+        assert with_context_around_user.lines[1].line_number == 30
+        assert with_context_around_user.lines[2].line_number == 31
+        assert with_context_around_user.lines[3].line_number == 32
+        assert with_context_around_user.lines[4].line_number == 33
+        # Check match types
+        assert with_context_around_user.lines[0].match_type == LineType.BEFORE_MATCH
+        assert with_context_around_user.lines[1].match_type == LineType.BEFORE_MATCH
+        assert with_context_around_user.lines[2].match_type == LineType.MATCH
+        assert with_context_around_user.lines[3].match_type == LineType.AFTER_MATCH
+        assert with_context_around_user.lines[4].match_type == LineType.AFTER_MATCH
+
+        # Scenario 3a: Only context above
+        with_context_above = project.retrieve_content_around_line(file_path, 31, 3, 0)
+        assert len(with_context_above.lines) == 4
+        assert "return cls(id=id, name=name)" in with_context_above.lines[0].line_content
+        assert "class User(BaseModel):" in with_context_above.matched_lines[0].line_content
+        assert with_context_above.num_matched_lines == 1
+        # Check line numbers
+        assert with_context_above.lines[0].line_number == 28
+        assert with_context_above.lines[1].line_number == 29
+        assert with_context_above.lines[2].line_number == 30
+        assert with_context_above.lines[3].line_number == 31
+        # Check match types
+        assert with_context_above.lines[0].match_type == LineType.BEFORE_MATCH
+        assert with_context_above.lines[1].match_type == LineType.BEFORE_MATCH
+        assert with_context_above.lines[2].match_type == LineType.BEFORE_MATCH
+        assert with_context_above.lines[3].match_type == LineType.MATCH
+
+        # Scenario 3b: Only context below
+        with_context_below = project.retrieve_content_around_line(file_path, 31, 0, 3)
+        assert len(with_context_below.lines) == 4
+        assert "class User(BaseModel):" in with_context_below.matched_lines[0].line_content
+        assert with_context_below.num_matched_lines == 1
+        assert with_context_below.lines[0].line_number == 31
+        assert with_context_below.lines[1].line_number == 32
+        assert with_context_below.lines[2].line_number == 33
+        assert with_context_below.lines[3].line_number == 34
+        # Check match types
+        assert with_context_below.lines[0].match_type == LineType.MATCH
+        assert with_context_below.lines[1].match_type == LineType.AFTER_MATCH
+        assert with_context_below.lines[2].match_type == LineType.AFTER_MATCH
+        assert with_context_below.lines[3].match_type == LineType.AFTER_MATCH
+
+        # Scenario 4a: Edge case - context above but line is at 0
+        first_line_with_context_around = project.retrieve_content_around_line(file_path, 0, 2, 1)
+        assert len(first_line_with_context_around.lines) <= 4  # Should have at most 4 lines (line 0 + 1 below + up to 2 above)
+        assert first_line_with_context_around.lines[0].line_number <= 2  # First line should be at most line 2
+        # Check match type for the target line
+        for line in first_line_with_context_around.lines:
+            if line.line_number == 0:
+                assert line.match_type == LineType.MATCH
+            elif line.line_number < 0:
+                assert line.match_type == LineType.BEFORE_MATCH
+            else:
+                assert line.match_type == LineType.AFTER_MATCH
+
+        # Scenario 4b: Edge case - context above but line is at 1
+        second_line_with_context_above = project.retrieve_content_around_line(file_path, 1, 3, 1)
+        assert len(second_line_with_context_above.lines) <= 5  # Should have at most 5 lines (line 1 + 1 below + up to 3 above)
+        assert second_line_with_context_above.lines[0].line_number <= 1  # First line should be at most line 1
+        # Check match type for the target line
+        for line in second_line_with_context_above.lines:
+            if line.line_number == 1:
+                assert line.match_type == LineType.MATCH
+            elif line.line_number < 1:
+                assert line.match_type == LineType.BEFORE_MATCH
+            else:
+                assert line.match_type == LineType.AFTER_MATCH
+
+        # Scenario 4c: Edge case - context below but line is at the end of file
+        # First get the total number of lines in the file
+        all_content = project.read_file(file_path)
+        total_lines = len(all_content.split("\n"))
+
+        last_line_with_context_around = project.retrieve_content_around_line(file_path, total_lines - 1, 1, 3)
+        assert len(last_line_with_context_around.lines) <= 5  # Should have at most 5 lines (last line + 1 above + up to 3 below)
+        assert last_line_with_context_around.lines[-1].line_number >= total_lines - 4  # Last line should be at least total_lines - 4
+        # Check match type for the target line
+        for line in last_line_with_context_around.lines:
+            if line.line_number == total_lines - 1:
+                assert line.match_type == LineType.MATCH
+            elif line.line_number < total_lines - 1:
+                assert line.match_type == LineType.BEFORE_MATCH
+            else:
+                assert line.match_type == LineType.AFTER_MATCH
+
+    @pytest.mark.parametrize("project", [Language.PYTHON], indirect=True)
+    def test_search_files_for_pattern(self, project: Project) -> None:
+        """Test search_files_for_pattern with various patterns and glob filters."""
+        # Test 1: Search for class definitions across all files
+        class_pattern = r"class\s+\w+\s*(?:\([^{]*\)|:)"
+        matches = project.search_source_files_for_pattern(class_pattern)
+        assert len(matches) > 0
+        # Should find multiple classes like User, Item, BaseModel, etc.
+        assert len(matches) >= 5
+
+        # Test 2: Search for specific class with include glob
+        user_class_pattern = r"class\s+User\s*(?:\([^{]*\)|:)"
+        matches = project.search_source_files_for_pattern(user_class_pattern, paths_include_glob="**/models.py")
+        assert len(matches) == 1  # Should only find User class in models.py
+        assert matches[0].source_file_path is not None
+        assert "models.py" in matches[0].source_file_path
+
+        # Test 3: Search for method definitions with exclude glob
+        method_pattern = r"def\s+\w+\s*\([^)]*\):"
+        matches = project.search_source_files_for_pattern(method_pattern, paths_exclude_glob="**/models.py")
+        assert len(matches) > 0
+        # Should find methods in services.py but not in models.py
+        assert all(match.source_file_path is not None and "models.py" not in match.source_file_path for match in matches)
+
+        # Test 4: Search for specific method with both include and exclude globs
+        create_user_pattern = r"def\s+create_user\s*\([^)]*\)(?:\s*->[^:]+)?:"
+        matches = project.search_source_files_for_pattern(
+            create_user_pattern, paths_include_glob="**/*.py", paths_exclude_glob="**/models.py"
+        )
+        assert len(matches) == 1  # Should only find create_user in services.py
+        assert matches[0].source_file_path is not None
+        assert "services.py" in matches[0].source_file_path
+
+        # Test 5: Search for a pattern that should appear in multiple files
+        init_pattern = r"def\s+__init__\s*\([^)]*\):"
+        matches = project.search_source_files_for_pattern(init_pattern)
+        assert len(matches) > 1  # Should find __init__ in multiple classes
+        # Should find __init__ in both models.py and services.py
+        assert any(match.source_file_path is not None and "models.py" in match.source_file_path for match in matches)
+        assert any(match.source_file_path is not None and "services.py" in match.source_file_path for match in matches)
+
+        # Test 6: Search with a pattern that should have no matches
+        no_match_pattern = r"def\s+this_method_does_not_exist\s*\([^)]*\):"
+        matches = project.search_source_files_for_pattern(no_match_pattern)
+        assert len(matches) == 0

projects/ui/serena-new/test/solidlsp/python/test_retrieval_with_ignored_dirs.py

@@ -0,0 +1,67 @@
+from collections.abc import Generator
+from pathlib import Path
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from test.conftest import create_ls
+
+# This mark will be applied to all tests in this module
+pytestmark = pytest.mark.python
+
+
+@pytest.fixture(scope="module")
+def ls_with_ignored_dirs() -> Generator[SolidLanguageServer, None, None]:
+    """Fixture to set up an LS for the python test repo with the 'scripts' directory ignored."""
+    ignored_paths = ["scripts", "custom_test"]
+    ls = create_ls(ignored_paths=ignored_paths, language=Language.PYTHON)
+    ls.start()
+    try:
+        yield ls
+    finally:
+        ls.stop()
+
+
+@pytest.mark.parametrize("ls_with_ignored_dirs", [Language.PYTHON], indirect=True)
+def test_symbol_tree_ignores_dir(ls_with_ignored_dirs: SolidLanguageServer):
+    """Tests that request_full_symbol_tree ignores the configured directory."""
+    root = ls_with_ignored_dirs.request_full_symbol_tree()[0]
+    root_children = root["children"]
+    children_names = {child["name"] for child in root_children}
+    assert children_names == {"test_repo", "examples"}
+
+
+@pytest.mark.parametrize("ls_with_ignored_dirs", [Language.PYTHON], indirect=True)
+def test_find_references_ignores_dir(ls_with_ignored_dirs: SolidLanguageServer):
+    """Tests that find_references ignores the configured directory."""
+    # Location of Item, which is referenced in scripts
+    definition_file = "test_repo/models.py"
+    definition_line = 56
+    definition_col = 6
+
+    references = ls_with_ignored_dirs.request_references(definition_file, definition_line, definition_col)
+
+    # assert that scripts does not appear in the references
+    assert not any("scripts" in ref["relativePath"] for ref in references)
+
+
+@pytest.mark.parametrize("repo_path", [Language.PYTHON], indirect=True)
+def test_refs_and_symbols_with_glob_patterns(repo_path: Path) -> None:
+    """Tests that refs and symbols with glob patterns are ignored."""
+    ignored_paths = ["*ipts", "custom_t*"]
+    ls = create_ls(ignored_paths=ignored_paths, repo_path=str(repo_path), language=Language.PYTHON)
+    ls.start()
+    # same as in the above tests
+    root = ls.request_full_symbol_tree()[0]
+    root_children = root["children"]
+    children_names = {child["name"] for child in root_children}
+    assert children_names == {"test_repo", "examples"}
+
+    # test that the refs and symbols with glob patterns are ignored
+    definition_file = "test_repo/models.py"
+    definition_line = 56
+    definition_col = 6
+
+    references = ls.request_references(definition_file, definition_line, definition_col)
+    assert not any("scripts" in ref["relativePath"] for ref in references)

projects/ui/serena-new/test/solidlsp/python/test_symbol_retrieval.py

@@ -0,0 +1,472 @@
+"""
+Tests for the language server symbol-related functionality.
+
+These tests focus on the following methods:
+- request_containing_symbol
+- request_referencing_symbols
+"""
+
+import os
+
+import pytest
+
+from serena.symbol import LanguageServerSymbol
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_types import SymbolKind
+
+pytestmark = pytest.mark.python
+
+
+class TestLanguageServerSymbols:
+    """Test the language server's symbol-related functionality."""
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_containing_symbol_function(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a function."""
+        # Test for a position inside the create_user method
+        file_path = os.path.join("test_repo", "services.py")
+        # Line 17 is inside the create_user method body
+        containing_symbol = language_server.request_containing_symbol(file_path, 17, 20, include_body=True)
+
+        # Verify that we found the containing symbol
+        assert containing_symbol is not None
+        assert containing_symbol["name"] == "create_user"
+        assert containing_symbol["kind"] == SymbolKind.Method
+        if "body" in containing_symbol:
+            assert containing_symbol["body"].strip().startswith("def create_user(self")
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_references_to_variables(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a variable."""
+        file_path = os.path.join("test_repo", "variables.py")
+        # Line 75 contains the field status that is later modified
+        ref_symbols = [ref.symbol for ref in language_server.request_referencing_symbols(file_path, 74, 4)]
+
+        assert len(ref_symbols) > 0
+        ref_lines = [ref["location"]["range"]["start"]["line"] for ref in ref_symbols if "location" in ref and "range" in ref["location"]]
+        ref_names = [ref["name"] for ref in ref_symbols]
+        assert 87 in ref_lines
+        assert 95 in ref_lines
+        assert "dataclass_instance" in ref_names
+        assert "second_dataclass" in ref_names
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_containing_symbol_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a class."""
+        # Test for a position inside the UserService class but outside any method
+        file_path = os.path.join("test_repo", "services.py")
+        # Line 9 is the class definition line for UserService
+        containing_symbol = language_server.request_containing_symbol(file_path, 9, 7)
+
+        # Verify that we found the containing symbol
+        assert containing_symbol is not None
+        assert containing_symbol["name"] == "UserService"
+        assert containing_symbol["kind"] == SymbolKind.Class
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_containing_symbol_nested(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol with nested scopes."""
+        # Test for a position inside a method which is inside a class
+        file_path = os.path.join("test_repo", "services.py")
+        # Line 18 is inside the create_user method inside UserService class
+        containing_symbol = language_server.request_containing_symbol(file_path, 18, 25)
+
+        # Verify that we found the innermost containing symbol (the method)
+        assert containing_symbol is not None
+        assert containing_symbol["name"] == "create_user"
+        assert containing_symbol["kind"] == SymbolKind.Method
+
+        # Get the parent containing symbol
+        if "location" in containing_symbol and "range" in containing_symbol["location"]:
+            parent_symbol = language_server.request_containing_symbol(
+                file_path,
+                containing_symbol["location"]["range"]["start"]["line"],
+                containing_symbol["location"]["range"]["start"]["character"] - 1,
+            )
+
+            # Verify that the parent is the class
+            assert parent_symbol is not None
+            assert parent_symbol["name"] == "UserService"
+            assert parent_symbol["kind"] == SymbolKind.Class
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_containing_symbol_none(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a position with no containing symbol."""
+        # Test for a position outside any function/class (e.g., in imports)
+        file_path = os.path.join("test_repo", "services.py")
+        # Line 1 is in imports, not inside any function or class
+        containing_symbol = language_server.request_containing_symbol(file_path, 1, 10)
+
+        # Should return None or an empty dictionary
+        assert containing_symbol is None or containing_symbol == {}
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_referencing_symbols_function(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a function."""
+        # Test referencing symbols for create_user function
+        file_path = os.path.join("test_repo", "services.py")
+        # Line 15 contains the create_user function definition
+        symbols = language_server.request_document_symbols(file_path)
+        create_user_symbol = next((s for s in symbols[0] if s.get("name") == "create_user"), None)
+        if not create_user_symbol or "selectionRange" not in create_user_symbol:
+            raise AssertionError("create_user symbol or its selectionRange not found")
+        sel_start = create_user_symbol["selectionRange"]["start"]
+        ref_symbols = [
+            ref.symbol for ref in language_server.request_referencing_symbols(file_path, sel_start["line"], sel_start["character"])
+        ]
+        assert len(ref_symbols) > 0, "No referencing symbols found for create_user (selectionRange)"
+
+        # Verify the structure of referencing symbols
+        for symbol in ref_symbols:
+            assert "name" in symbol
+            assert "kind" in symbol
+            if "location" in symbol and "range" in symbol["location"]:
+                assert "start" in symbol["location"]["range"]
+                assert "end" in symbol["location"]["range"]
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_referencing_symbols_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a class."""
+        # Test referencing symbols for User class
+        file_path = os.path.join("test_repo", "models.py")
+        # Line 31 contains the User class definition
+        symbols = language_server.request_document_symbols(file_path)
+        user_symbol = next((s for s in symbols[0] if s.get("name") == "User"), None)
+        if not user_symbol or "selectionRange" not in user_symbol:
+            raise AssertionError("User symbol or its selectionRange not found")
+        sel_start = user_symbol["selectionRange"]["start"]
+        ref_symbols = [
+            ref.symbol for ref in language_server.request_referencing_symbols(file_path, sel_start["line"], sel_start["character"])
+        ]
+        services_references = [
+            symbol
+            for symbol in ref_symbols
+            if "location" in symbol and "uri" in symbol["location"] and "services.py" in symbol["location"]["uri"]
+        ]
+        assert len(services_references) > 0, "No referencing symbols from services.py for User (selectionRange)"
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_referencing_symbols_parameter(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a function parameter."""
+        # Test referencing symbols for id parameter in get_user
+        file_path = os.path.join("test_repo", "services.py")
+        # Line 24 contains the get_user method with id parameter
+        symbols = language_server.request_document_symbols(file_path)
+        get_user_symbol = next((s for s in symbols[0] if s.get("name") == "get_user"), None)
+        if not get_user_symbol or "selectionRange" not in get_user_symbol:
+            raise AssertionError("get_user symbol or its selectionRange not found")
+        sel_start = get_user_symbol["selectionRange"]["start"]
+        ref_symbols = [
+            ref.symbol for ref in language_server.request_referencing_symbols(file_path, sel_start["line"], sel_start["character"])
+        ]
+        method_refs = [
+            symbol
+            for symbol in ref_symbols
+            if "location" in symbol and "range" in symbol["location"] and symbol["location"]["range"]["start"]["line"] > sel_start["line"]
+        ]
+        assert len(method_refs) > 0, "No referencing symbols within method body for get_user (selectionRange)"
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_referencing_symbols_none(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a position with no symbol."""
+        # For positions with no symbol, the method might throw an error or return None/empty list
+        # We'll modify our test to handle this by using a try-except block
+
+        file_path = os.path.join("test_repo", "services.py")
+        # Line 3 is a blank line or comment
+        try:
+            ref_symbols = [ref.symbol for ref in language_server.request_referencing_symbols(file_path, 3, 0)]
+            # If we get here, make sure we got an empty result
+            assert ref_symbols == [] or ref_symbols is None
+        except Exception:
+            # The method might raise an exception for invalid positions
+            # which is acceptable behavior
+            pass
+
+    # Tests for request_defining_symbol
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_defining_symbol_variable(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a variable usage."""
+        # Test finding the definition of a symbol in the create_user method
+        file_path = os.path.join("test_repo", "services.py")
+        # Line 21 contains self.users[id] = user
+        defining_symbol = language_server.request_defining_symbol(file_path, 21, 10)
+
+        # Verify that we found the defining symbol
+        # The defining symbol method returns a dictionary with information about the defining symbol
+        assert defining_symbol is not None
+        assert defining_symbol.get("name") == "create_user"
+
+        # Verify the location and kind of the symbol
+        # SymbolKind.Method = 6 for a method
+        assert defining_symbol.get("kind") == SymbolKind.Method.value
+        if "location" in defining_symbol and "uri" in defining_symbol["location"]:
+            assert "services.py" in defining_symbol["location"]["uri"]
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_defining_symbol_imported_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for an imported class."""
+        # Test finding the definition of the 'User' class used in the UserService.create_user method
+        file_path = os.path.join("test_repo", "services.py")
+        # Line 20 references 'User' which was imported from models
+        defining_symbol = language_server.request_defining_symbol(file_path, 20, 15)
+
+        # Verify that we found the defining symbol - this should be the User class from models
+        assert defining_symbol is not None
+        assert defining_symbol.get("name") == "User"
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_defining_symbol_method_call(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a method call."""
+        # Create an example file path for a file that calls UserService.create_user
+        examples_file_path = os.path.join("examples", "user_management.py")
+
+        # Find the line number where create_user is called
+        # This could vary, so we'll use a relative position that makes sense
+        defining_symbol = language_server.request_defining_symbol(examples_file_path, 10, 30)
+
+        # Verify that we found the defining symbol - should be the create_user method
+        # Because this might fail if the structure isn't exactly as expected, we'll use try-except
+        try:
+            assert defining_symbol is not None
+            assert defining_symbol.get("name") == "create_user"
+            # The defining symbol should be in the services.py file
+            if "location" in defining_symbol and "uri" in defining_symbol["location"]:
+                assert "services.py" in defining_symbol["location"]["uri"]
+        except AssertionError:
+            # If the file structure doesn't match what we expect, we can't guarantee this test
+            # will pass, so we'll consider it a warning rather than a failure
+            import warnings
+
+            warnings.warn("Could not verify method call definition - file structure may differ from expected")
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_defining_symbol_none(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a position with no symbol."""
+        # Test for a position with no symbol (e.g., whitespace or comment)
+        file_path = os.path.join("test_repo", "services.py")
+        # Line 3 is a blank line
+        defining_symbol = language_server.request_defining_symbol(file_path, 3, 0)
+
+        # Should return None for positions with no symbol
+        assert defining_symbol is None
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_containing_symbol_variable(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol where the symbol is a variable."""
+        # Test for a position inside a variable definition
+        file_path = os.path.join("test_repo", "services.py")
+        # Line 74 defines the 'user' variable
+        containing_symbol = language_server.request_containing_symbol(file_path, 73, 1)
+
+        # Verify that we found the containing symbol
+        assert containing_symbol is not None
+        assert containing_symbol["name"] == "user_var_str"
+        assert containing_symbol["kind"] == SymbolKind.Variable
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_defining_symbol_nested_function(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a nested function or closure."""
+        # Use the existing nested.py file which contains nested classes and methods
+        file_path = os.path.join("test_repo", "nested.py")
+
+        # Test 1: Find definition of nested method - line with 'b = OuterClass().NestedClass().find_me()'
+        defining_symbol = language_server.request_defining_symbol(file_path, 15, 35)  # Position of find_me() call
+
+        # This should resolve to the find_me method in the NestedClass
+        assert defining_symbol is not None
+        assert defining_symbol.get("name") == "find_me"
+        assert defining_symbol.get("kind") == SymbolKind.Method.value
+
+        # Test 2: Find definition of the nested class
+        defining_symbol = language_server.request_defining_symbol(file_path, 15, 18)  # Position of NestedClass
+
+        # This should resolve to the NestedClass
+        assert defining_symbol is not None
+        assert defining_symbol.get("name") == "NestedClass"
+        assert defining_symbol.get("kind") == SymbolKind.Class.value
+
+        # Test 3: Find definition of a method-local function
+        defining_symbol = language_server.request_defining_symbol(file_path, 9, 15)  # Position inside func_within_func
+
+        # This is challenging for many language servers and may fail
+        try:
+            assert defining_symbol is not None
+            assert defining_symbol.get("name") == "func_within_func"
+        except (AssertionError, TypeError, KeyError):
+            # This is expected to potentially fail in many implementations
+            import warnings
+
+            warnings.warn("Could not resolve nested class method definition - implementation limitation")
+
+        # Test 2: Find definition of the nested class
+        defining_symbol = language_server.request_defining_symbol(file_path, 15, 18)  # Position of NestedClass
+
+        # This should resolve to the NestedClass
+        assert defining_symbol is not None
+        assert defining_symbol.get("name") == "NestedClass"
+        assert defining_symbol.get("kind") == SymbolKind.Class.value
+
+        # Test 3: Find definition of a method-local function
+        defining_symbol = language_server.request_defining_symbol(file_path, 9, 15)  # Position inside func_within_func
+
+        # This is challenging for many language servers and may fail
+        assert defining_symbol is not None
+        assert defining_symbol.get("name") == "func_within_func"
+        assert defining_symbol.get("kind") == SymbolKind.Function.value
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_symbol_methods_integration(self, language_server: SolidLanguageServer) -> None:
+        """Test the integration between different symbol-related methods."""
+        # This test demonstrates using the various symbol methods together
+        # by finding a symbol and then checking its definition
+
+        file_path = os.path.join("test_repo", "services.py")
+
+        # First approach: Use a method from the UserService class
+        # Step 1: Find a method we know exists
+        containing_symbol = language_server.request_containing_symbol(file_path, 15, 8)  # create_user method
+        assert containing_symbol is not None
+        assert containing_symbol["name"] == "create_user"
+
+        # Step 2: Get the defining symbol for the same position
+        # This should be the same method
+        defining_symbol = language_server.request_defining_symbol(file_path, 15, 8)
+        assert defining_symbol is not None
+        assert defining_symbol["name"] == "create_user"
+
+        # Step 3: Verify that they refer to the same symbol
+        assert defining_symbol["kind"] == containing_symbol["kind"]
+        if "location" in defining_symbol and "location" in containing_symbol:
+            assert defining_symbol["location"]["uri"] == containing_symbol["location"]["uri"]
+
+        # The integration test is successful if we've gotten this far,
+        # as it demonstrates the integration between request_containing_symbol and request_defining_symbol
+
+        # Try to get the container information for our method, but be flexible
+        # since implementations may vary
+        container_name = defining_symbol.get("containerName", None)
+        if container_name and "UserService" in container_name:
+            # If containerName contains UserService, that's a valid implementation
+            pass
+        else:
+            # Try an alternative approach - looking for the containing class
+            try:
+                # Look for the class symbol in the file
+                for line in range(5, 12):  # Approximate range where UserService class should be defined
+                    symbol = language_server.request_containing_symbol(file_path, line, 5)  # column 5 should be within class definition
+                    if symbol and symbol.get("name") == "UserService" and symbol.get("kind") == SymbolKind.Class.value:
+                        # Found the class - this is also a valid implementation
+                        break
+            except Exception:
+                # Just log a warning - this is an alternative verification and not essential
+                import warnings
+
+                warnings.warn("Could not verify container hierarchy - implementation detail")
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_symbol_tree_structure(self, language_server: SolidLanguageServer) -> None:
+        """Test that the symbol tree structure is correctly built."""
+        # Get all symbols in the test file
+        repo_structure = language_server.request_full_symbol_tree()
+        assert len(repo_structure) == 1
+        # Assert that the root symbol is the test_repo directory
+        assert repo_structure[0]["name"] == "test_repo"
+        assert repo_structure[0]["kind"] == SymbolKind.Package
+        assert "children" in repo_structure[0]
+        # Assert that the children are the top-level packages
+        child_names = {child["name"] for child in repo_structure[0]["children"]}
+        child_kinds = {child["kind"] for child in repo_structure[0]["children"]}
+        assert child_names == {"test_repo", "custom_test", "examples", "scripts"}
+        assert child_kinds == {SymbolKind.Package}
+        examples_package = next(child for child in repo_structure[0]["children"] if child["name"] == "examples")
+        # assert that children are __init__ and user_management
+        assert {child["name"] for child in examples_package["children"]} == {"__init__", "user_management"}
+        assert {child["kind"] for child in examples_package["children"]} == {SymbolKind.File}
+
+        # assert that tree of user_management node is same as retrieved directly
+        user_management_node = next(child for child in examples_package["children"] if child["name"] == "user_management")
+        if "location" in user_management_node and "relativePath" in user_management_node["location"]:
+            user_management_rel_path = user_management_node["location"]["relativePath"]
+            assert user_management_rel_path == os.path.join("examples", "user_management.py")
+            _, user_management_roots = language_server.request_document_symbols(os.path.join("examples", "user_management.py"))
+            assert user_management_roots == user_management_node["children"]
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_symbol_tree_structure_subdir(self, language_server: SolidLanguageServer) -> None:
+        """Test that the symbol tree structure is correctly built."""
+        # Get all symbols in the test file
+        examples_package_roots = language_server.request_full_symbol_tree(within_relative_path="examples")
+        assert len(examples_package_roots) == 1
+        examples_package = examples_package_roots[0]
+        assert examples_package["name"] == "examples"
+        assert examples_package["kind"] == SymbolKind.Package
+        # assert that children are __init__ and user_management
+        assert {child["name"] for child in examples_package["children"]} == {"__init__", "user_management"}
+        assert {child["kind"] for child in examples_package["children"]} == {SymbolKind.File}
+
+        # assert that tree of user_management node is same as retrieved directly
+        user_management_node = next(child for child in examples_package["children"] if child["name"] == "user_management")
+        if "location" in user_management_node and "relativePath" in user_management_node["location"]:
+            user_management_rel_path = user_management_node["location"]["relativePath"]
+            assert user_management_rel_path == os.path.join("examples", "user_management.py")
+            _, user_management_roots = language_server.request_document_symbols(os.path.join("examples", "user_management.py"))
+            assert user_management_roots == user_management_node["children"]
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_dir_overview(self, language_server: SolidLanguageServer) -> None:
+        """Test that request_dir_overview returns correct symbol information for files in a directory."""
+        # Get overview of the examples directory
+        overview = language_server.request_dir_overview("test_repo")
+
+        # Verify that we have entries for both files
+        assert os.path.join("test_repo", "nested.py") in overview
+
+        # Get the symbols for user_management.py
+        services_symbols = overview[os.path.join("test_repo", "services.py")]
+        assert len(services_symbols) > 0
+
+        # Check for specific symbols from services.py
+        expected_symbols = {
+            "UserService",
+            "ItemService",
+            "create_service_container",
+            "user_var_str",
+            "user_service",
+        }
+        retrieved_symbols = {symbol["name"] for symbol in services_symbols if "name" in symbol}
+        assert expected_symbols.issubset(retrieved_symbols)
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_request_document_overview(self, language_server: SolidLanguageServer) -> None:
+        """Test that request_document_overview returns correct symbol information for a file."""
+        # Get overview of the user_management.py file
+        overview = language_server.request_document_overview(os.path.join("examples", "user_management.py"))
+
+        # Verify that we have entries for both files
+        symbol_names = {LanguageServerSymbol(s_info).name for s_info in overview}
+        assert {"UserStats", "UserManager", "process_user_data", "main"}.issubset(symbol_names)
+
+    @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True)
+    def test_containing_symbol_of_var_is_file(self, language_server: SolidLanguageServer) -> None:
+        """Test that the containing symbol of a variable is the file itself."""
+        # Get the containing symbol of a variable in a file
+        file_path = os.path.join("test_repo", "services.py")
+        # import of typing
+        references_to_typing = [
+            ref.symbol
+            for ref in language_server.request_referencing_symbols(file_path, 4, 6, include_imports=False, include_file_symbols=True)
+        ]
+        assert {ref["kind"] for ref in references_to_typing} == {SymbolKind.File}
+        assert {ref["body"] for ref in references_to_typing} == {""}
+
+        # now include bodies
+        references_to_typing = [
+            ref.symbol
+            for ref in language_server.request_referencing_symbols(
+                file_path, 4, 6, include_imports=False, include_file_symbols=True, include_body=True
+            )
+        ]
+        assert {ref["kind"] for ref in references_to_typing} == {SymbolKind.File}
+        assert references_to_typing[0]["body"]

projects/ui/serena-new/test/solidlsp/r/__init__.py

@@ -0,0 +1 @@
+# Empty init file for R tests

projects/ui/serena-new/test/solidlsp/r/test_r_basic.py

@@ -0,0 +1,97 @@
+"""
+Basic tests for R Language Server integration
+"""
+
+import os
+from pathlib import Path
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+
+
+@pytest.mark.r
+class TestRLanguageServer:
+    """Test basic functionality of the R language server."""
+
+    @pytest.mark.parametrize("language_server", [Language.R], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.R], indirect=True)
+    def test_server_initialization(self, language_server: SolidLanguageServer, repo_path: Path):
+        """Test that the R language server initializes properly."""
+        assert language_server is not None
+        assert language_server.language_id == "r"
+        assert language_server.is_running()
+        assert Path(language_server.language_server.repository_root_path).resolve() == repo_path.resolve()
+
+    @pytest.mark.parametrize("language_server", [Language.R], indirect=True)
+    def test_symbol_retrieval(self, language_server: SolidLanguageServer):
+        """Test R document symbol extraction."""
+        all_symbols, root_symbols = language_server.request_document_symbols(os.path.join("R", "utils.R"))
+
+        # Should find the three exported functions
+        function_symbols = [s for s in all_symbols if s.get("kind") == 12]  # Function kind
+        assert len(function_symbols) >= 3
+
+        # Check that we found the expected functions
+        function_names = {s.get("name") for s in function_symbols}
+        expected_functions = {"calculate_mean", "process_data", "create_data_frame"}
+        assert expected_functions.issubset(function_names), f"Expected functions {expected_functions} but found {function_names}"
+
+    @pytest.mark.parametrize("language_server", [Language.R], indirect=True)
+    def test_find_definition_across_files(self, language_server: SolidLanguageServer):
+        """Test finding function definitions across files."""
+        analysis_file = os.path.join("examples", "analysis.R")
+
+        # In analysis.R line 7: create_data_frame(n = 50)
+        # The function create_data_frame is defined in R/utils.R
+        # Find definition of create_data_frame function call (0-indexed: line 6)
+        definition_location_list = language_server.request_definition(analysis_file, 6, 17)  # cursor on 'create_data_frame'
+
+        assert definition_location_list, f"Expected non-empty definition_location_list but got {definition_location_list=}"
+        assert len(definition_location_list) >= 1
+        definition_location = definition_location_list[0]
+        assert definition_location["uri"].endswith("utils.R")
+        # Definition should be around line 37 (0-indexed: 36) where create_data_frame is defined
+        assert definition_location["range"]["start"]["line"] >= 35
+
+    @pytest.mark.parametrize("language_server", [Language.R], indirect=True)
+    def test_find_references_across_files(self, language_server: SolidLanguageServer):
+        """Test finding function references across files."""
+        analysis_file = os.path.join("examples", "analysis.R")
+
+        # Test from usage side: find references to calculate_mean from its usage in analysis.R
+        # In analysis.R line 13: calculate_mean(clean_data$value)
+        # calculate_mean function call is at line 13 (0-indexed: line 12)
+        references = language_server.request_references(analysis_file, 12, 15)  # cursor on 'calculate_mean'
+
+        assert references, f"Expected non-empty references for calculate_mean but got {references=}"
+
+        # Must find the definition in utils.R (cross-file reference)
+        reference_files = [ref["uri"] for ref in references]
+        assert any(uri.endswith("utils.R") for uri in reference_files), "Cross-file reference to definition in utils.R not found"
+
+        # Verify we actually found the right location in utils.R
+        utils_refs = [ref for ref in references if ref["uri"].endswith("utils.R")]
+        assert len(utils_refs) >= 1, "Should find at least one reference in utils.R"
+        utils_ref = utils_refs[0]
+        # Should be around line 6 where calculate_mean is defined (0-indexed: line 5)
+        assert (
+            utils_ref["range"]["start"]["line"] == 5
+        ), f"Expected reference at line 5 in utils.R, got line {utils_ref['range']['start']['line']}"
+
+    def test_file_matching(self):
+        """Test that R files are properly matched."""
+        from solidlsp.ls_config import Language
+
+        matcher = Language.R.get_source_fn_matcher()
+
+        assert matcher.is_relevant_filename("script.R")
+        assert matcher.is_relevant_filename("analysis.r")
+        assert not matcher.is_relevant_filename("script.py")
+        assert not matcher.is_relevant_filename("README.md")
+
+    def test_r_language_enum(self):
+        """Test R language enum value."""
+        assert Language.R == "r"
+        assert str(Language.R) == "r"

projects/ui/serena-new/test/solidlsp/ruby/test_ruby_basic.py

@@ -0,0 +1,44 @@
+import os
+from pathlib import Path
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_utils import SymbolUtils
+
+
+@pytest.mark.ruby
+class TestRubyLanguageServer:
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_find_symbol(self, language_server: SolidLanguageServer) -> None:
+        symbols = language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "DemoClass"), "DemoClass not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "helper_function"), "helper_function not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "print_value"), "print_value not found in symbol tree"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_find_referencing_symbols(self, language_server: SolidLanguageServer) -> None:
+        file_path = os.path.join("main.rb")
+        symbols = language_server.request_document_symbols(file_path)
+        helper_symbol = None
+        for sym in symbols[0]:
+            if sym.get("name") == "helper_function":
+                helper_symbol = sym
+                break
+        print(helper_symbol)
+        assert helper_symbol is not None, "Could not find 'helper_function' symbol in main.rb"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    @pytest.mark.parametrize("repo_path", [Language.RUBY], indirect=True)
+    def test_find_definition_across_files(self, language_server: SolidLanguageServer, repo_path: Path) -> None:
+        # Test finding Calculator.add method definition from line 17: Calculator.new.add(demo.value, 10)
+        definition_location_list = language_server.request_definition(
+            str(repo_path / "main.rb"), 16, 17
+        )  # add method at line 17 (0-indexed 16), position 17
+
+        assert len(definition_location_list) == 1
+        definition_location = definition_location_list[0]
+        print(f"Found definition: {definition_location}")
+        assert definition_location["uri"].endswith("lib.rb")
+        assert definition_location["range"]["start"]["line"] == 1  # add method on line 2 (0-indexed 1)

projects/ui/serena-new/test/solidlsp/ruby/test_ruby_symbol_retrieval.py

@@ -0,0 +1,625 @@
+"""
+Tests for the Ruby language server symbol-related functionality.
+
+These tests focus on the following methods:
+- request_containing_symbol
+- request_referencing_symbols
+- request_defining_symbol
+- request_document_symbols integration
+"""
+
+import os
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_types import SymbolKind
+
+pytestmark = pytest.mark.ruby
+
+
+class TestRubyLanguageServerSymbols:
+    """Test the Ruby language server's symbol-related functionality."""
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_containing_symbol_method(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a method."""
+        # Test for a position inside the create_user method
+        file_path = os.path.join("services.rb")
+        # Look for a position inside the create_user method body
+        containing_symbol = language_server.request_containing_symbol(file_path, 11, 10, include_body=True)
+
+        # Verify that we found the containing symbol
+        assert containing_symbol is not None, "Should find containing symbol for method position"
+        assert containing_symbol["name"] == "create_user", f"Expected 'create_user', got '{containing_symbol['name']}'"
+        assert (
+            containing_symbol["kind"] == SymbolKind.Method.value
+        ), f"Expected Method kind ({SymbolKind.Method.value}), got {containing_symbol['kind']}"
+
+        # Verify location information
+        assert "location" in containing_symbol, "Containing symbol should have location information"
+        location = containing_symbol["location"]
+        assert "range" in location, "Location should contain range information"
+        assert "start" in location["range"], "Range should have start position"
+        assert "end" in location["range"], "Range should have end position"
+
+        # Verify container information
+        if "containerName" in containing_symbol:
+            assert containing_symbol["containerName"] in [
+                "Services::UserService",
+                "UserService",
+            ], f"Expected UserService container, got '{containing_symbol['containerName']}'"
+
+        # Verify body content if available
+        if "body" in containing_symbol:
+            body = containing_symbol["body"]
+            assert "def create_user" in body, "Method body should contain method definition"
+            assert len(body.strip()) > 0, "Method body should not be empty"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_containing_symbol_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a class."""
+        # Test for a position inside the UserService class but outside any method
+        file_path = os.path.join("services.rb")
+        # Line around the class definition
+        containing_symbol = language_server.request_containing_symbol(file_path, 5, 5)
+
+        # Verify that we found the containing symbol
+        assert containing_symbol is not None, "Should find containing symbol for class position"
+        assert containing_symbol["name"] == "UserService", f"Expected 'UserService', got '{containing_symbol['name']}'"
+        assert (
+            containing_symbol["kind"] == SymbolKind.Class.value
+        ), f"Expected Class kind ({SymbolKind.Class.value}), got {containing_symbol['kind']}"
+
+        # Verify location information exists
+        assert "location" in containing_symbol, "Class symbol should have location information"
+        location = containing_symbol["location"]
+        assert "range" in location, "Location should contain range"
+        assert "start" in location["range"] and "end" in location["range"], "Range should have start and end positions"
+
+        # Verify the class is properly nested in the Services module
+        if "containerName" in containing_symbol:
+            assert (
+                containing_symbol["containerName"] == "Services"
+            ), f"Expected 'Services' as container, got '{containing_symbol['containerName']}'"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_containing_symbol_module(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a module context."""
+        # Test that we can find the Services module in document symbols
+        file_path = os.path.join("services.rb")
+        symbols, roots = language_server.request_document_symbols(file_path)
+
+        # Verify Services module appears in document symbols
+        services_module = None
+        for symbol in symbols:
+            if symbol.get("name") == "Services" and symbol.get("kind") == SymbolKind.Module:
+                services_module = symbol
+                break
+
+        assert services_module is not None, "Services module not found in document symbols"
+
+        # Test that UserService class has Services as container
+        # Position inside UserService class
+        containing_symbol = language_server.request_containing_symbol(file_path, 4, 8)
+        assert containing_symbol is not None
+        assert containing_symbol["name"] == "UserService"
+        assert containing_symbol["kind"] == SymbolKind.Class
+        # Verify the module context is preserved in containerName (if supported by the language server)
+        # ruby-lsp doesn't provide containerName, but Solargraph does
+        if "containerName" in containing_symbol:
+            assert containing_symbol.get("containerName") == "Services"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_containing_symbol_nested_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol with nested classes."""
+        # Test for a position inside a nested class method
+        file_path = os.path.join("nested.rb")
+        # Position inside NestedClass.find_me method
+        containing_symbol = language_server.request_containing_symbol(file_path, 20, 10)
+
+        # Verify that we found the innermost containing symbol
+        assert containing_symbol is not None
+        assert containing_symbol["name"] == "find_me"
+        assert containing_symbol["kind"] == SymbolKind.Method
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_containing_symbol_none(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a position with no containing symbol."""
+        # Test for a position outside any class/method (e.g., in requires)
+        file_path = os.path.join("services.rb")
+        # Line 1 is a require statement, not inside any class or method
+        containing_symbol = language_server.request_containing_symbol(file_path, 1, 5)
+
+        # Should return None or an empty dictionary
+        assert containing_symbol is None or containing_symbol == {}
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_referencing_symbols_method(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a method."""
+        # Test referencing symbols for create_user method
+        file_path = os.path.join("services.rb")
+        # Line containing the create_user method definition
+        symbols, roots = language_server.request_document_symbols(file_path)
+        create_user_symbol = None
+
+        # Find create_user method in the document symbols (Ruby returns flat list)
+        for symbol in symbols:
+            if symbol.get("name") == "create_user":
+                create_user_symbol = symbol
+                break
+
+        if not create_user_symbol or "selectionRange" not in create_user_symbol:
+            pytest.skip("create_user symbol or its selectionRange not found")
+
+        sel_start = create_user_symbol["selectionRange"]["start"]
+        ref_symbols = [
+            ref.symbol for ref in language_server.request_referencing_symbols(file_path, sel_start["line"], sel_start["character"])
+        ]
+
+        # We might not have references in our simple test setup, so just verify structure
+        for symbol in ref_symbols:
+            assert "name" in symbol
+            assert "kind" in symbol
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_referencing_symbols_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a class."""
+        # Test referencing symbols for User class
+        file_path = os.path.join("models.rb")
+        # Find User class in document symbols
+        symbols, roots = language_server.request_document_symbols(file_path)
+        user_symbol = None
+
+        for symbol in symbols:
+            if symbol.get("name") == "User":
+                user_symbol = symbol
+                break
+
+        if not user_symbol or "selectionRange" not in user_symbol:
+            pytest.skip("User symbol or its selectionRange not found")
+
+        sel_start = user_symbol["selectionRange"]["start"]
+        ref_symbols = [
+            ref.symbol for ref in language_server.request_referencing_symbols(file_path, sel_start["line"], sel_start["character"])
+        ]
+
+        # Verify structure of referencing symbols
+        for symbol in ref_symbols:
+            assert "name" in symbol
+            assert "kind" in symbol
+            if "location" in symbol and "range" in symbol["location"]:
+                assert "start" in symbol["location"]["range"]
+                assert "end" in symbol["location"]["range"]
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_defining_symbol_variable(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a variable usage."""
+        # Test finding the definition of a variable in a method
+        file_path = os.path.join("services.rb")
+        # Look for @users variable usage
+        defining_symbol = language_server.request_defining_symbol(file_path, 12, 10)
+
+        # This test might fail if the language server doesn't support it well
+        if defining_symbol is not None:
+            assert "name" in defining_symbol
+            assert "kind" in defining_symbol
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_defining_symbol_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a class reference."""
+        # Test finding the definition of the User class used in services
+        file_path = os.path.join("services.rb")
+        # Line that references User class
+        defining_symbol = language_server.request_defining_symbol(file_path, 11, 15)
+
+        # This might not work perfectly in all Ruby language servers
+        if defining_symbol is not None:
+            assert "name" in defining_symbol
+            # The name might be "User" or the method that contains it
+            assert defining_symbol.get("name") is not None
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_defining_symbol_none(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a position with no symbol."""
+        # Test for a position with no symbol (e.g., whitespace or comment)
+        file_path = os.path.join("services.rb")
+        # Line 3 is likely a blank line or comment
+        defining_symbol = language_server.request_defining_symbol(file_path, 3, 0)
+
+        # Should return None for positions with no symbol
+        assert defining_symbol is None or defining_symbol == {}
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_defining_symbol_nested_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for nested class access."""
+        # Test finding definition of NestedClass
+        file_path = os.path.join("nested.rb")
+        # Position where NestedClass is referenced
+        defining_symbol = language_server.request_defining_symbol(file_path, 44, 25)
+
+        # This is challenging for many language servers
+        if defining_symbol is not None:
+            assert "name" in defining_symbol
+            assert defining_symbol.get("name") in ["NestedClass", "OuterClass"]
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_symbol_methods_integration(self, language_server: SolidLanguageServer) -> None:
+        """Test the integration between different symbol-related methods."""
+        file_path = os.path.join("models.rb")
+
+        # Step 1: Find a method we know exists
+        containing_symbol = language_server.request_containing_symbol(file_path, 8, 5)  # inside initialize method
+        if containing_symbol is not None:
+            assert containing_symbol["name"] == "initialize"
+
+            # Step 2: Get the defining symbol for the same position
+            defining_symbol = language_server.request_defining_symbol(file_path, 8, 5)
+            if defining_symbol is not None:
+                assert defining_symbol["name"] == "initialize"
+
+                # Step 3: Verify that they refer to the same symbol type
+                assert defining_symbol["kind"] == containing_symbol["kind"]
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_symbol_tree_structure_basic(self, language_server: SolidLanguageServer) -> None:
+        """Test that the symbol tree structure includes Ruby symbols."""
+        # Get all symbols in the test repository
+        repo_structure = language_server.request_full_symbol_tree()
+        assert len(repo_structure) >= 1
+
+        # Look for our Ruby files in the structure
+        found_ruby_files = False
+        for root in repo_structure:
+            if "children" in root:
+                for child in root["children"]:
+                    if child.get("name") in ["models", "services", "nested"]:
+                        found_ruby_files = True
+                        break
+
+        # We should find at least some Ruby files in the symbol tree
+        assert found_ruby_files, "Ruby files not found in symbol tree"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_document_symbols_detailed(self, language_server: SolidLanguageServer) -> None:
+        """Test document symbols for detailed Ruby file structure."""
+        file_path = os.path.join("models.rb")
+        symbols, roots = language_server.request_document_symbols(file_path)
+
+        # Verify we have symbols
+        assert len(symbols) > 0 or len(roots) > 0
+
+        # Look for expected class names
+        symbol_names = set()
+        all_symbols = symbols if symbols else roots
+
+        for symbol in all_symbols:
+            symbol_names.add(symbol.get("name"))
+            # Add children names too
+            if "children" in symbol:
+                for child in symbol["children"]:
+                    symbol_names.add(child.get("name"))
+
+        # We should find at least some of our defined classes/methods
+        expected_symbols = {"User", "Item", "Order", "ItemHelpers"}
+        found_symbols = symbol_names.intersection(expected_symbols)
+        assert len(found_symbols) > 0, f"Expected symbols not found. Found: {symbol_names}"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_module_and_class_hierarchy(self, language_server: SolidLanguageServer) -> None:
+        """Test symbol detection for modules and nested class hierarchies."""
+        file_path = os.path.join("nested.rb")
+        symbols, roots = language_server.request_document_symbols(file_path)
+
+        # Verify we can detect the nested structure
+        assert len(symbols) > 0 or len(roots) > 0
+
+        # Look for OuterClass and its nested elements
+        symbol_names = set()
+        all_symbols = symbols if symbols else roots
+
+        for symbol in all_symbols:
+            symbol_names.add(symbol.get("name"))
+            if "children" in symbol:
+                for child in symbol["children"]:
+                    symbol_names.add(child.get("name"))
+                    # Check deeply nested too
+                    if "children" in child:
+                        for grandchild in child["children"]:
+                            symbol_names.add(grandchild.get("name"))
+
+        # Should find the outer class at minimum
+        assert "OuterClass" in symbol_names, f"OuterClass not found in symbols: {symbol_names}"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_references_to_variables(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a variable with detailed verification."""
+        file_path = os.path.join("variables.rb")
+        # Test references to @status variable in DataContainer class (around line 9)
+        ref_symbols = [ref.symbol for ref in language_server.request_referencing_symbols(file_path, 8, 4)]
+
+        if len(ref_symbols) > 0:
+            # Verify we have references
+            assert len(ref_symbols) > 0, "Should find references to @status variable"
+
+            # Check that we have location information
+            ref_with_locations = [ref for ref in ref_symbols if "location" in ref and "range" in ref["location"]]
+            assert len(ref_with_locations) > 0, "References should include location information"
+
+            # Verify line numbers are reasonable (should be within the file)
+            ref_lines = [ref["location"]["range"]["start"]["line"] for ref in ref_with_locations]
+            assert all(line >= 0 for line in ref_lines), "Reference lines should be valid"
+
+            # Check for specific reference locations we expect
+            # Lines where @status is modified/accessed
+            expected_line_ranges = [(20, 40), (45, 70)]  # Approximate ranges
+            found_in_expected_range = any(any(start <= line <= end for start, end in expected_line_ranges) for line in ref_lines)
+            assert found_in_expected_range, f"Expected references in ranges {expected_line_ranges}, found lines: {ref_lines}"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_referencing_symbols_parameter(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a method parameter."""
+        # Test referencing symbols for a method parameter in get_user method
+        file_path = os.path.join("services.rb")
+        # Find get_user method and test parameter references
+        symbols, roots = language_server.request_document_symbols(file_path)
+        get_user_symbol = None
+
+        for symbol in symbols:
+            if symbol.get("name") == "get_user":
+                get_user_symbol = symbol
+                break
+
+        if not get_user_symbol or "selectionRange" not in get_user_symbol:
+            pytest.skip("get_user symbol or its selectionRange not found")
+
+        # Test parameter reference within method body
+        method_start_line = get_user_symbol["selectionRange"]["start"]["line"]
+        ref_symbols = [
+            ref.symbol
+            for ref in language_server.request_referencing_symbols(file_path, method_start_line + 1, 10)  # Position within method body
+        ]
+
+        # Verify structure of referencing symbols
+        for symbol in ref_symbols:
+            assert "name" in symbol, "Symbol should have name"
+            assert "kind" in symbol, "Symbol should have kind"
+            if "location" in symbol and "range" in symbol["location"]:
+                range_info = symbol["location"]["range"]
+                assert "start" in range_info, "Range should have start"
+                assert "end" in range_info, "Range should have end"
+                # Verify line number is valid (references can be before method definition too)
+                assert range_info["start"]["line"] >= 0, "Reference line should be valid"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_referencing_symbols_none(self, language_server: SolidLanguageServer) -> None:
+        """Test request_referencing_symbols for a position with no symbol."""
+        # Test for a position with no symbol (comment or blank line)
+        file_path = os.path.join("services.rb")
+
+        # Try multiple positions that should have no symbols
+        test_positions = [(1, 0), (2, 0)]  # Comment/require lines
+
+        for line, char in test_positions:
+            try:
+                ref_symbols = [ref.symbol for ref in language_server.request_referencing_symbols(file_path, line, char)]
+                # If we get here, make sure we got an empty result or minimal results
+                if ref_symbols:
+                    # Some language servers might return minimal info, verify it's reasonable
+                    assert len(ref_symbols) <= 3, f"Expected few/no references at line {line}, got {len(ref_symbols)}"
+
+            except Exception as e:
+                # Some language servers throw exceptions for invalid positions, which is acceptable
+                assert (
+                    "symbol" in str(e).lower() or "position" in str(e).lower() or "reference" in str(e).lower()
+                ), f"Exception should be related to symbol/position/reference issues, got: {e}"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_dir_overview(self, language_server: SolidLanguageServer) -> None:
+        """Test that request_dir_overview returns correct symbol information for files in a directory."""
+        # Get overview of the test repo directory
+        overview = language_server.request_dir_overview(".")
+
+        # Verify that we have entries for our main files
+        expected_files = ["services.rb", "models.rb", "variables.rb", "nested.rb"]
+        found_files = []
+
+        for file_path in overview.keys():
+            for expected in expected_files:
+                if expected in file_path:
+                    found_files.append(expected)
+                    break
+
+        assert len(found_files) >= 2, f"Should find at least 2 expected files, found: {found_files}"
+
+        # Test specific symbols from services.rb if it exists
+        services_file_key = None
+        for file_path in overview.keys():
+            if "services.rb" in file_path:
+                services_file_key = file_path
+                break
+
+        if services_file_key:
+            services_symbols = overview[services_file_key]
+            assert len(services_symbols) > 0, "services.rb should have symbols"
+
+            # Check for expected symbols with detailed verification
+            symbol_names = [s[0] for s in services_symbols if isinstance(s, tuple) and len(s) > 0]
+            if not symbol_names:  # If not tuples, try different format
+                symbol_names = [s.get("name") for s in services_symbols if hasattr(s, "get")]
+
+            expected_symbols = ["Services", "UserService", "ItemService"]
+            found_expected = [name for name in expected_symbols if name in symbol_names]
+            assert len(found_expected) >= 1, f"Should find at least one expected symbol, found: {found_expected} in {symbol_names}"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_document_overview(self, language_server: SolidLanguageServer) -> None:
+        """Test that request_document_overview returns correct symbol information for a file."""
+        # Get overview of the user_management.rb file
+        file_path = os.path.join("examples", "user_management.rb")
+        overview = language_server.request_document_overview(file_path)
+
+        # Verify that we have symbol information
+        assert len(overview) > 0, "Document overview should contain symbols"
+
+        # Look for expected symbols from the file
+        symbol_names = set()
+        for s_info in overview:
+            if isinstance(s_info, tuple) and len(s_info) > 0:
+                symbol_names.add(s_info[0])
+            elif hasattr(s_info, "get"):
+                symbol_names.add(s_info.get("name"))
+            elif isinstance(s_info, str):
+                symbol_names.add(s_info)
+
+        # We should find some of our defined classes/methods
+        expected_symbols = {"UserStats", "UserManager", "process_user_data", "main"}
+        found_symbols = symbol_names.intersection(expected_symbols)
+        assert len(found_symbols) > 0, f"Expected to find some symbols from {expected_symbols}, found: {symbol_names}"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_containing_symbol_variable(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol where the target is a variable."""
+        # Test for a position inside a variable definition or usage
+        file_path = os.path.join("variables.rb")
+        # Position around a variable assignment (e.g., @status = "pending")
+        containing_symbol = language_server.request_containing_symbol(file_path, 10, 5)
+
+        # Verify that we found a containing symbol (likely the method or class)
+        if containing_symbol is not None:
+            assert "name" in containing_symbol, "Containing symbol should have a name"
+            assert "kind" in containing_symbol, "Containing symbol should have a kind"
+            # The containing symbol should be a method, class, or similar construct
+            expected_kinds = [SymbolKind.Method, SymbolKind.Class, SymbolKind.Function, SymbolKind.Constructor]
+            assert containing_symbol["kind"] in [
+                k.value for k in expected_kinds
+            ], f"Expected containing symbol to be method/class/function, got kind: {containing_symbol['kind']}"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_containing_symbol_function(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol for a function (not method)."""
+        # Test for a position inside a standalone function
+        file_path = os.path.join("variables.rb")
+        # Position inside the demonstrate_variable_usage function
+        containing_symbol = language_server.request_containing_symbol(file_path, 100, 10)
+
+        if containing_symbol is not None:
+            assert containing_symbol["name"] in [
+                "demonstrate_variable_usage",
+                "main",
+            ], f"Expected function name, got: {containing_symbol['name']}"
+            assert containing_symbol["kind"] in [
+                SymbolKind.Function.value,
+                SymbolKind.Method.value,
+            ], f"Expected function or method kind, got: {containing_symbol['kind']}"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_containing_symbol_nested(self, language_server: SolidLanguageServer) -> None:
+        """Test request_containing_symbol with nested scopes."""
+        # Test for a position inside a method which is inside a class
+        file_path = os.path.join("services.rb")
+        # Position inside create_user method within UserService class
+        containing_symbol = language_server.request_containing_symbol(file_path, 12, 15)
+
+        # Verify that we found the innermost containing symbol (the method)
+        assert containing_symbol is not None
+        assert containing_symbol["name"] == "create_user"
+        assert containing_symbol["kind"] == SymbolKind.Method
+
+        # Verify the container context is preserved
+        if "containerName" in containing_symbol:
+            assert "UserService" in containing_symbol["containerName"]
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_symbol_tree_structure_subdir(self, language_server: SolidLanguageServer) -> None:
+        """Test that the symbol tree structure correctly handles subdirectories."""
+        # Get symbols within the examples subdirectory
+        examples_structure = language_server.request_full_symbol_tree(within_relative_path="examples")
+
+        if len(examples_structure) > 0:
+            # Should find the examples directory structure
+            assert len(examples_structure) >= 1, "Should find examples directory structure"
+
+            # Look for the user_management file in the structure
+            found_user_management = False
+            for root in examples_structure:
+                if "children" in root:
+                    for child in root["children"]:
+                        if "user_management" in child.get("name", ""):
+                            found_user_management = True
+                            # Verify the structure includes symbol information
+                            if "children" in child:
+                                child_names = [c.get("name") for c in child["children"]]
+                                expected_names = ["UserStats", "UserManager", "process_user_data"]
+                                found_expected = [name for name in expected_names if name in child_names]
+                                assert (
+                                    len(found_expected) > 0
+                                ), f"Should find symbols in user_management, expected {expected_names}, found {child_names}"
+                            break
+
+            if not found_user_management:
+                pytest.skip("user_management file not found in examples subdirectory structure")
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_defining_symbol_imported_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for an imported/required class."""
+        # Test finding the definition of a class used from another file
+        file_path = os.path.join("examples", "user_management.rb")
+        # Position where Services::UserService is referenced
+        defining_symbol = language_server.request_defining_symbol(file_path, 25, 20)
+
+        # This might not work perfectly in all Ruby language servers due to require complexity
+        if defining_symbol is not None:
+            assert "name" in defining_symbol
+            # The defining symbol should relate to UserService or Services
+            # The defining symbol should relate to UserService, Services, or the containing class
+            # Different language servers may resolve this differently
+            expected_names = ["UserService", "Services", "new", "UserManager"]
+            assert defining_symbol.get("name") in expected_names, f"Expected one of {expected_names}, got: {defining_symbol.get('name')}"
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_defining_symbol_method_call(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a method call."""
+        # Test finding the definition of a method being called
+        file_path = os.path.join("examples", "user_management.rb")
+        # Position at a method call like create_user
+        defining_symbol = language_server.request_defining_symbol(file_path, 30, 15)
+
+        # Verify that we can find method definitions
+        if defining_symbol is not None:
+            assert "name" in defining_symbol
+            assert "kind" in defining_symbol
+            # Should be a method or constructor
+            assert defining_symbol.get("kind") in [SymbolKind.Method.value, SymbolKind.Constructor.value, SymbolKind.Function.value]
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_request_defining_symbol_nested_function(self, language_server: SolidLanguageServer) -> None:
+        """Test request_defining_symbol for a nested function or block."""
+        # Test finding definition within nested contexts
+        file_path = os.path.join("nested.rb")
+        # Position inside or referencing nested functionality
+        defining_symbol = language_server.request_defining_symbol(file_path, 15, 10)
+
+        # This is challenging for many language servers
+        if defining_symbol is not None:
+            assert "name" in defining_symbol
+            assert "kind" in defining_symbol
+            # Could be method, function, or variable depending on implementation
+            valid_kinds = [SymbolKind.Method.value, SymbolKind.Function.value, SymbolKind.Variable.value, SymbolKind.Class.value]
+            assert defining_symbol.get("kind") in valid_kinds
+
+    @pytest.mark.parametrize("language_server", [Language.RUBY], indirect=True)
+    def test_containing_symbol_of_var_is_file(self, language_server: SolidLanguageServer) -> None:
+        """Test that the containing symbol of a file-level variable is handled appropriately."""
+        # Test behavior with file-level variables or constants
+        file_path = os.path.join("variables.rb")
+        # Position at file-level variable/constant
+        containing_symbol = language_server.request_containing_symbol(file_path, 5, 5)
+
+        # Different language servers handle file-level symbols differently
+        # Some return None, others return file-level containers
+        if containing_symbol is not None:
+            # If we get a symbol, verify its structure
+            assert "name" in containing_symbol
+            assert "kind" in containing_symbol

projects/ui/serena-new/test/solidlsp/rust/test_rust_2024_edition.py

@@ -0,0 +1,112 @@
+import os
+from pathlib import Path
+
+import pytest
+
+from solidlsp.ls_config import Language
+from solidlsp.ls_utils import SymbolUtils
+from test.conftest import create_ls
+
+
+@pytest.mark.rust
+class TestRust2024EditionLanguageServer:
+    @classmethod
+    def setup_class(cls):
+        """Set up the test class with the Rust 2024 edition test repository."""
+        cls.test_repo_2024_path = Path(__file__).parent.parent.parent / "resources" / "repos" / "rust" / "test_repo_2024"
+
+        if not cls.test_repo_2024_path.exists():
+            pytest.skip("Rust 2024 edition test repository not found")
+
+        # Create and start the language server for the 2024 edition repo
+        cls.language_server = create_ls(Language.RUST, str(cls.test_repo_2024_path))
+        cls.language_server.start()
+
+    @classmethod
+    def teardown_class(cls):
+        """Clean up the language server."""
+        if hasattr(cls, "language_server"):
+            cls.language_server.stop()
+
+    def test_find_references_raw(self) -> None:
+        # Test finding references to the 'add' function defined in main.rs
+        file_path = os.path.join("src", "main.rs")
+        symbols = self.language_server.request_document_symbols(file_path)
+        add_symbol = None
+        for sym in symbols[0]:
+            if sym.get("name") == "add":
+                add_symbol = sym
+                break
+        assert add_symbol is not None, "Could not find 'add' function symbol in main.rs"
+        sel_start = add_symbol["selectionRange"]["start"]
+        refs = self.language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        # The add function should be referenced within main.rs itself (in the main function)
+        assert any("main.rs" in ref.get("relativePath", "") for ref in refs), "main.rs should reference add function"
+
+    def test_find_symbol(self) -> None:
+        symbols = self.language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "main"), "main function not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "add"), "add function not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "multiply"), "multiply function not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Calculator"), "Calculator struct not found in symbol tree"
+
+    def test_find_referencing_symbols_multiply(self) -> None:
+        # Find references to 'multiply' function defined in lib.rs
+        file_path = os.path.join("src", "lib.rs")
+        symbols = self.language_server.request_document_symbols(file_path)
+        multiply_symbol = None
+        for sym in symbols[0]:
+            if sym.get("name") == "multiply":
+                multiply_symbol = sym
+                break
+        assert multiply_symbol is not None, "Could not find 'multiply' function symbol in lib.rs"
+        sel_start = multiply_symbol["selectionRange"]["start"]
+        refs = self.language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        # The multiply function exists but may not be referenced anywhere, which is fine
+        # This test just verifies we can find the symbol and request references without error
+        assert isinstance(refs, list), "Should return a list of references (even if empty)"
+
+    def test_find_calculator_struct_and_impl(self) -> None:
+        # Test finding the Calculator struct and its impl block
+        file_path = os.path.join("src", "lib.rs")
+        symbols = self.language_server.request_document_symbols(file_path)
+
+        # Find the Calculator struct
+        calculator_struct = None
+        calculator_impl = None
+        for sym in symbols[0]:
+            if sym.get("name") == "Calculator" and sym.get("kind") == 23:  # Struct kind
+                calculator_struct = sym
+            elif sym.get("name") == "Calculator" and sym.get("kind") == 11:  # Interface/Impl kind
+                calculator_impl = sym
+
+        assert calculator_struct is not None, "Could not find 'Calculator' struct symbol in lib.rs"
+
+        # The struct should have the 'result' field
+        struct_children = calculator_struct.get("children", [])
+        field_names = [child.get("name") for child in struct_children]
+        assert "result" in field_names, "Calculator struct should have 'result' field"
+
+        # Find the impl block and check its methods
+        if calculator_impl is not None:
+            impl_children = calculator_impl.get("children", [])
+            method_names = [child.get("name") for child in impl_children]
+            assert "new" in method_names, "Calculator impl should have 'new' method"
+            assert "add" in method_names, "Calculator impl should have 'add' method"
+            assert "get_result" in method_names, "Calculator impl should have 'get_result' method"
+
+    def test_overview_methods(self) -> None:
+        symbols = self.language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "main"), "main missing from overview"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "add"), "add missing from overview"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "multiply"), "multiply missing from overview"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Calculator"), "Calculator missing from overview"
+
+    def test_rust_2024_edition_specific(self) -> None:
+        # Verify we're actually working with the 2024 edition repository
+        cargo_toml_path = self.test_repo_2024_path / "Cargo.toml"
+        assert cargo_toml_path.exists(), "Cargo.toml should exist in test repository"
+
+        with open(cargo_toml_path) as f:
+            content = f.read()
+            assert 'edition = "2024"' in content, "Should be using Rust 2024 edition"

projects/ui/serena-new/test/solidlsp/rust/test_rust_basic.py

@@ -0,0 +1,57 @@
+import os
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_utils import SymbolUtils
+
+
+@pytest.mark.rust
+class TestRustLanguageServer:
+    @pytest.mark.parametrize("language_server", [Language.RUST], indirect=True)
+    def test_find_references_raw(self, language_server: SolidLanguageServer) -> None:
+        # Directly test the request_references method for the add function
+        file_path = os.path.join("src", "lib.rs")
+        symbols = language_server.request_document_symbols(file_path)
+        add_symbol = None
+        for sym in symbols[0]:
+            if sym.get("name") == "add":
+                add_symbol = sym
+                break
+        assert add_symbol is not None, "Could not find 'add' function symbol in lib.rs"
+        sel_start = add_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert any(
+            "main.rs" in ref.get("relativePath", "") for ref in refs
+        ), "main.rs should reference add (raw, tried all positions in selectionRange)"
+
+    @pytest.mark.parametrize("language_server", [Language.RUST], indirect=True)
+    def test_find_symbol(self, language_server: SolidLanguageServer) -> None:
+        symbols = language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "main"), "main function not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "add"), "add function not found in symbol tree"
+        # Add more as needed based on test_repo
+
+    @pytest.mark.parametrize("language_server", [Language.RUST], indirect=True)
+    def test_find_referencing_symbols(self, language_server: SolidLanguageServer) -> None:
+        # Find references to 'add' defined in lib.rs, should be referenced from main.rs
+        file_path = os.path.join("src", "lib.rs")
+        symbols = language_server.request_document_symbols(file_path)
+        add_symbol = None
+        for sym in symbols[0]:
+            if sym.get("name") == "add":
+                add_symbol = sym
+                break
+        assert add_symbol is not None, "Could not find 'add' function symbol in lib.rs"
+        sel_start = add_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert any(
+            "main.rs" in ref.get("relativePath", "") for ref in refs
+        ), "main.rs should reference add (tried all positions in selectionRange)"
+
+    @pytest.mark.parametrize("language_server", [Language.RUST], indirect=True)
+    def test_overview_methods(self, language_server: SolidLanguageServer) -> None:
+        symbols = language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "main"), "main missing from overview"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "add"), "add missing from overview"

projects/ui/serena-new/test/solidlsp/swift/test_swift_basic.py

@@ -0,0 +1,222 @@
+"""
+Basic integration tests for the Swift language server functionality.
+
+These tests validate the functionality of the language server APIs
+like request_references using the Swift test repository.
+"""
+
+import os
+import platform
+
+import pytest
+
+from serena.project import Project
+from serena.text_utils import LineType
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+
+# Skip Swift tests on Windows due to complex GitHub Actions configuration
+WINDOWS_SKIP = platform.system() == "Windows"
+WINDOWS_SKIP_REASON = "GitHub Actions configuration for Swift on Windows is complex, skipping for now."
+
+pytestmark = [pytest.mark.swift, pytest.mark.skipif(WINDOWS_SKIP, reason=WINDOWS_SKIP_REASON)]
+
+
+class TestSwiftLanguageServerBasics:
+    """Test basic functionality of the Swift language server."""
+
+    @pytest.mark.parametrize("language_server", [Language.SWIFT], indirect=True)
+    def test_goto_definition_calculator_class(self, language_server: SolidLanguageServer) -> None:
+        """Test goto_definition on Calculator class usage."""
+        file_path = os.path.join("src", "main.swift")
+
+        # Find the Calculator usage at line 5: let calculator = Calculator()
+        # Position should be at the "Calculator()" call
+        definitions = language_server.request_definition(file_path, 4, 23)  # Position at Calculator() call
+        assert isinstance(definitions, list), "Definitions should be a list"
+        assert len(definitions) > 0, "Should find definition for Calculator class"
+
+        # Verify the definition points to the Calculator class definition
+        calculator_def = definitions[0]
+        assert calculator_def.get("uri", "").endswith("main.swift"), "Definition should be in main.swift"
+
+        # The Calculator class is defined starting at line 16
+        start_line = calculator_def.get("range", {}).get("start", {}).get("line")
+        assert start_line == 15, f"Calculator class definition should be at line 16, got {start_line + 1}"
+
+    @pytest.mark.parametrize("language_server", [Language.SWIFT], indirect=True)
+    def test_goto_definition_user_struct(self, language_server: SolidLanguageServer) -> None:
+        """Test goto_definition on User struct usage."""
+        file_path = os.path.join("src", "main.swift")
+
+        # Find the User usage at line 9: let user = User(name: "Alice", age: 30)
+        # Position should be at the "User(...)" call
+        definitions = language_server.request_definition(file_path, 8, 18)  # Position at User(...) call
+        assert isinstance(definitions, list), "Definitions should be a list"
+        assert len(definitions) > 0, "Should find definition for User struct"
+
+        # Verify the definition points to the User struct definition
+        user_def = definitions[0]
+        assert user_def.get("uri", "").endswith("main.swift"), "Definition should be in main.swift"
+
+        # The User struct is defined starting at line 26
+        start_line = user_def.get("range", {}).get("start", {}).get("line")
+        assert start_line == 25, f"User struct definition should be at line 26, got {start_line + 1}"
+
+    @pytest.mark.parametrize("language_server", [Language.SWIFT], indirect=True)
+    def test_goto_definition_calculator_method(self, language_server: SolidLanguageServer) -> None:
+        """Test goto_definition on Calculator method usage."""
+        file_path = os.path.join("src", "main.swift")
+
+        # Find the add method usage at line 6: let result = calculator.add(5, 3)
+        # Position should be at the "add" method call
+        definitions = language_server.request_definition(file_path, 5, 28)  # Position at add method call
+        assert isinstance(definitions, list), "Definitions should be a list"
+
+        # Verify the definition points to the add method definition
+        add_def = definitions[0]
+        assert add_def.get("uri", "").endswith("main.swift"), "Definition should be in main.swift"
+
+        # The add method is defined starting at line 17
+        start_line = add_def.get("range", {}).get("start", {}).get("line")
+        assert start_line == 16, f"add method definition should be at line 17, got {start_line + 1}"
+
+    @pytest.mark.parametrize("language_server", [Language.SWIFT], indirect=True)
+    def test_goto_definition_cross_file(self, language_server: SolidLanguageServer) -> None:
+        """Test goto_definition across files - Utils struct."""
+        utils_file = os.path.join("src", "utils.swift")
+
+        # First, let's check if Utils is used anywhere (it might not be in this simple test)
+        # We'll test goto_definition on Utils struct itself
+        symbols = language_server.request_document_symbols(utils_file)
+        utils_symbol = next((s for s in symbols[0] if s.get("name") == "Utils"), None)
+
+        sel_start = utils_symbol["selectionRange"]["start"]
+        definitions = language_server.request_definition(utils_file, sel_start["line"], sel_start["character"])
+        assert isinstance(definitions, list), "Definitions should be a list"
+
+        # Should find the Utils struct definition itself
+        utils_def = definitions[0]
+        assert utils_def.get("uri", "").endswith("utils.swift"), "Definition should be in utils.swift"
+
+    @pytest.mark.parametrize("language_server", [Language.SWIFT], indirect=True)
+    def test_request_references_calculator_class(self, language_server: SolidLanguageServer) -> None:
+        """Test request_references on the Calculator class."""
+        # Get references to the Calculator class in main.swift
+        file_path = os.path.join("src", "main.swift")
+        symbols = language_server.request_document_symbols(file_path)
+
+        calculator_symbol = next((s for s in symbols[0] if s.get("name") == "Calculator"), None)
+
+        sel_start = calculator_symbol["selectionRange"]["start"]
+        references = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert isinstance(references, list), "References should be a list"
+        assert len(references) > 0, "Calculator class should be referenced"
+
+        # Validate that Calculator is referenced in the main function
+        calculator_refs = [ref for ref in references if ref.get("uri", "").endswith("main.swift")]
+        assert len(calculator_refs) > 0, "Calculator class should be referenced in main.swift"
+
+        # Check that one reference is at line 5 (let calculator = Calculator())
+        line_5_refs = [ref for ref in calculator_refs if ref.get("range", {}).get("start", {}).get("line") == 4]
+        assert len(line_5_refs) > 0, "Calculator should be referenced at line 5"
+
+    @pytest.mark.parametrize("language_server", [Language.SWIFT], indirect=True)
+    def test_request_references_user_struct(self, language_server: SolidLanguageServer) -> None:
+        """Test request_references on the User struct."""
+        # Get references to the User struct in main.swift
+        file_path = os.path.join("src", "main.swift")
+        symbols = language_server.request_document_symbols(file_path)
+
+        user_symbol = next((s for s in symbols[0] if s.get("name") == "User"), None)
+
+        sel_start = user_symbol["selectionRange"]["start"]
+        references = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert isinstance(references, list), "References should be a list"
+
+        # Validate that User is referenced in the main function
+        user_refs = [ref for ref in references if ref.get("uri", "").endswith("main.swift")]
+        assert len(user_refs) > 0, "User struct should be referenced in main.swift"
+
+        # Check that one reference is at line 9 (let user = User(...))
+        line_9_refs = [ref for ref in user_refs if ref.get("range", {}).get("start", {}).get("line") == 8]
+        assert len(line_9_refs) > 0, "User should be referenced at line 9"
+
+    @pytest.mark.parametrize("language_server", [Language.SWIFT], indirect=True)
+    def test_request_references_utils_struct(self, language_server: SolidLanguageServer) -> None:
+        """Test request_references on the Utils struct."""
+        # Get references to the Utils struct in utils.swift
+        file_path = os.path.join("src", "utils.swift")
+        symbols = language_server.request_document_symbols(file_path)
+        utils_symbol = next((s for s in symbols[0] if s.get("name") == "Utils"), None)
+        if not utils_symbol or "selectionRange" not in utils_symbol:
+            raise AssertionError("Utils symbol or its selectionRange not found")
+        sel_start = utils_symbol["selectionRange"]["start"]
+        references = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert isinstance(references, list), "References should be a list"
+        assert len(references) > 0, "Utils struct should be referenced"
+
+        # Validate that Utils is referenced in main.swift
+        utils_refs = [ref for ref in references if ref.get("uri", "").endswith("main.swift")]
+        assert len(utils_refs) > 0, "Utils struct should be referenced in main.swift"
+
+        # Check that one reference is at line 12 (Utils.calculateArea call)
+        line_12_refs = [ref for ref in utils_refs if ref.get("range", {}).get("start", {}).get("line") == 11]
+        assert len(line_12_refs) > 0, "Utils should be referenced at line 12"
+
+
+class TestSwiftProjectBasics:
+    @pytest.mark.parametrize("project", [Language.SWIFT], indirect=True)
+    def test_retrieve_content_around_line(self, project: Project) -> None:
+        """Test retrieve_content_around_line functionality with various scenarios."""
+        file_path = os.path.join("src", "main.swift")
+
+        # Scenario 1: Find Calculator class definition
+        calculator_line = None
+        for line_num in range(1, 50):  # Search first 50 lines
+            try:
+                line_content = project.retrieve_content_around_line(file_path, line_num)
+                if line_content.lines and "class Calculator" in line_content.lines[0].line_content:
+                    calculator_line = line_num
+                    break
+            except:
+                continue
+
+        assert calculator_line is not None, "Calculator class not found"
+        line_calc = project.retrieve_content_around_line(file_path, calculator_line)
+        assert len(line_calc.lines) == 1
+        assert "class Calculator" in line_calc.lines[0].line_content
+        assert line_calc.lines[0].line_number == calculator_line
+        assert line_calc.lines[0].match_type == LineType.MATCH
+
+        # Scenario 2: Context above and below Calculator class
+        with_context_around_calculator = project.retrieve_content_around_line(file_path, calculator_line, 2, 2)
+        assert len(with_context_around_calculator.lines) == 5
+        assert "class Calculator" in with_context_around_calculator.matched_lines[0].line_content
+        assert with_context_around_calculator.num_matched_lines == 1
+
+        # Scenario 3: Search for struct definitions
+        struct_pattern = r"struct\s+\w+"
+        matches = project.search_source_files_for_pattern(struct_pattern)
+        assert len(matches) > 0, "Should find struct definitions"
+        # Should find User struct
+        user_matches = [m for m in matches if "User" in str(m)]
+        assert len(user_matches) > 0, "Should find User struct"
+
+        # Scenario 4: Search for class definitions
+        class_pattern = r"class\s+\w+"
+        matches = project.search_source_files_for_pattern(class_pattern)
+        assert len(matches) > 0, "Should find class definitions"
+        # Should find Calculator and Circle classes
+        calculator_matches = [m for m in matches if "Calculator" in str(m)]
+        circle_matches = [m for m in matches if "Circle" in str(m)]
+        assert len(calculator_matches) > 0, "Should find Calculator class"
+        assert len(circle_matches) > 0, "Should find Circle class"
+
+        # Scenario 5: Search for enum definitions
+        enum_pattern = r"enum\s+\w+"
+        matches = project.search_source_files_for_pattern(enum_pattern)
+        assert len(matches) > 0, "Should find enum definitions"
+        # Should find Status enum
+        status_matches = [m for m in matches if "Status" in str(m)]
+        assert len(status_matches) > 0, "Should find Status enum"

projects/ui/serena-new/test/solidlsp/terraform/test_terraform_basic.py

@@ -0,0 +1,53 @@
+"""
+Basic integration tests for the Terraform language server functionality.
+
+These tests validate the functionality of the language server APIs
+like request_references using the test repository.
+"""
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+
+
+@pytest.mark.terraform
+class TestLanguageServerBasics:
+    """Test basic functionality of the Terraform language server."""
+
+    @pytest.mark.parametrize("language_server", [Language.TERRAFORM], indirect=True)
+    def test_basic_definition(self, language_server: SolidLanguageServer) -> None:
+        """Test basic definition lookup functionality."""
+        # Simple test to verify the language server is working
+        file_path = "main.tf"
+        # Just try to get document symbols - this should work without hanging
+        symbols = language_server.request_document_symbols(file_path)
+        assert len(symbols) > 0, "Should find at least some symbols in main.tf"
+
+    @pytest.mark.parametrize("language_server", [Language.TERRAFORM], indirect=True)
+    def test_request_references_aws_instance(self, language_server: SolidLanguageServer) -> None:
+        """Test request_references on an aws_instance resource."""
+        # Get references to an aws_instance resource in main.tf
+        file_path = "main.tf"
+        # Find aws_instance resources
+        symbols = language_server.request_document_symbols(file_path)
+        aws_instance_symbol = next((s for s in symbols[0] if s.get("name") == 'resource "aws_instance" "web_server"'), None)
+        if not aws_instance_symbol or "selectionRange" not in aws_instance_symbol:
+            raise AssertionError("aws_instance symbol or its selectionRange not found")
+        sel_start = aws_instance_symbol["selectionRange"]["start"]
+        references = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert len(references) >= 1, "aws_instance should be referenced at least once"
+
+    @pytest.mark.parametrize("language_server", [Language.TERRAFORM], indirect=True)
+    def test_request_references_variable(self, language_server: SolidLanguageServer) -> None:
+        """Test request_references on a variable."""
+        # Get references to a variable in variables.tf
+        file_path = "variables.tf"
+        # Find variable definitions
+        symbols = language_server.request_document_symbols(file_path)
+        var_symbol = next((s for s in symbols[0] if s.get("name") == 'variable "instance_type"'), None)
+        if not var_symbol or "selectionRange" not in var_symbol:
+            raise AssertionError("variable symbol or its selectionRange not found")
+        sel_start = var_symbol["selectionRange"]["start"]
+        references = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert len(references) >= 1, "variable should be referenced at least once"

projects/ui/serena-new/test/solidlsp/typescript/test_typescript_basic.py

@@ -0,0 +1,33 @@
+import os
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_utils import SymbolUtils
+
+
+@pytest.mark.typescript
+class TestTypescriptLanguageServer:
+    @pytest.mark.parametrize("language_server", [Language.TYPESCRIPT], indirect=True)
+    def test_find_symbol(self, language_server: SolidLanguageServer) -> None:
+        symbols = language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "DemoClass"), "DemoClass not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "helperFunction"), "helperFunction not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "printValue"), "printValue method not found in symbol tree"
+
+    @pytest.mark.parametrize("language_server", [Language.TYPESCRIPT], indirect=True)
+    def test_find_referencing_symbols(self, language_server: SolidLanguageServer) -> None:
+        file_path = os.path.join("index.ts")
+        symbols = language_server.request_document_symbols(file_path)
+        helper_symbol = None
+        for sym in symbols[0]:
+            if sym.get("name") == "helperFunction":
+                helper_symbol = sym
+                break
+        assert helper_symbol is not None, "Could not find 'helperFunction' symbol in index.ts"
+        sel_start = helper_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+        assert any(
+            "index.ts" in ref.get("relativePath", "") for ref in refs
+        ), "index.ts should reference helperFunction (tried all positions in selectionRange)"

projects/ui/serena-new/test/solidlsp/util/test_zip.py

@@ -0,0 +1,99 @@
+import sys
+import zipfile
+from pathlib import Path
+
+import pytest
+
+from solidlsp.util.zip import SafeZipExtractor
+
+
+@pytest.fixture
+def temp_zip_file(tmp_path: Path) -> Path:
+    """Create a temporary ZIP file for testing."""
+    zip_path = tmp_path / "test.zip"
+    with zipfile.ZipFile(zip_path, "w") as zipf:
+        zipf.writestr("file1.txt", "Hello World 1")
+        zipf.writestr("file2.txt", "Hello World 2")
+        zipf.writestr("folder/file3.txt", "Hello World 3")
+    return zip_path
+
+
+def test_extract_all_success(temp_zip_file: Path, tmp_path: Path) -> None:
+    """All files should extract without error."""
+    dest_dir = tmp_path / "extracted"
+    extractor = SafeZipExtractor(temp_zip_file, dest_dir, verbose=False)
+    extractor.extract_all()
+
+    assert (dest_dir / "file1.txt").read_text() == "Hello World 1"
+    assert (dest_dir / "file2.txt").read_text() == "Hello World 2"
+    assert (dest_dir / "folder" / "file3.txt").read_text() == "Hello World 3"
+
+
+def test_include_patterns(temp_zip_file: Path, tmp_path: Path) -> None:
+    """Only files matching include_patterns should be extracted."""
+    dest_dir = tmp_path / "extracted"
+    extractor = SafeZipExtractor(temp_zip_file, dest_dir, verbose=False, include_patterns=["*.txt"])
+    extractor.extract_all()
+
+    assert (dest_dir / "file1.txt").exists()
+    assert (dest_dir / "file2.txt").exists()
+    assert (dest_dir / "folder" / "file3.txt").exists()
+
+
+def test_exclude_patterns(temp_zip_file: Path, tmp_path: Path) -> None:
+    """Files matching exclude_patterns should be skipped."""
+    dest_dir = tmp_path / "extracted"
+    extractor = SafeZipExtractor(temp_zip_file, dest_dir, verbose=False, exclude_patterns=["file2.txt"])
+    extractor.extract_all()
+
+    assert (dest_dir / "file1.txt").exists()
+    assert not (dest_dir / "file2.txt").exists()
+    assert (dest_dir / "folder" / "file3.txt").exists()
+
+
+def test_include_and_exclude_patterns(temp_zip_file: Path, tmp_path: Path) -> None:
+    """Exclude should override include if both match."""
+    dest_dir = tmp_path / "extracted"
+    extractor = SafeZipExtractor(
+        temp_zip_file,
+        dest_dir,
+        verbose=False,
+        include_patterns=["*.txt"],
+        exclude_patterns=["file1.txt"],
+    )
+    extractor.extract_all()
+
+    assert not (dest_dir / "file1.txt").exists()
+    assert (dest_dir / "file2.txt").exists()
+    assert (dest_dir / "folder" / "file3.txt").exists()
+
+
+def test_skip_on_error(monkeypatch, temp_zip_file: Path, tmp_path: Path) -> None:
+    """Should skip a file that raises an error and continue extracting others."""
+    dest_dir = tmp_path / "extracted"
+
+    original_open = zipfile.ZipFile.open
+
+    def failing_open(self, member, *args, **kwargs):
+        if member.filename == "file2.txt":
+            raise OSError("Simulated failure")
+        return original_open(self, member, *args, **kwargs)
+
+    # Patch the method on the class, not on an instance
+    monkeypatch.setattr(zipfile.ZipFile, "open", failing_open)
+
+    extractor = SafeZipExtractor(temp_zip_file, dest_dir, verbose=False)
+    extractor.extract_all()
+
+    assert (dest_dir / "file1.txt").exists()
+    assert not (dest_dir / "file2.txt").exists()
+    assert (dest_dir / "folder" / "file3.txt").exists()
+
+
+@pytest.mark.skipif(not sys.platform.startswith("win"), reason="Windows-only test")
+def test_long_path_normalization(temp_zip_file: Path, tmp_path: Path) -> None:
+    r"""Ensure _normalize_path adds \\?\\ prefix on Windows."""
+    dest_dir = tmp_path / ("a" * 250)  # Simulate long path
+    extractor = SafeZipExtractor(temp_zip_file, dest_dir, verbose=False)
+    norm_path = extractor._normalize_path(dest_dir / "file.txt")
+    assert str(norm_path).startswith("\\\\?\\")