Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /ViperJuice_Code-Index-MCP /tests /test_cpp_plugin.py
| """Tests for the C++ language plugin.""" | |
| import tempfile | |
| from pathlib import Path | |
| import pytest | |
| from mcp_server.interfaces.plugin_interfaces import SymbolDefinition | |
| from mcp_server.plugins.cpp_plugin.plugin import Plugin | |
| from mcp_server.storage.sqlite_store import SQLiteStore | |
| def plugin(): | |
| """Create a C++ plugin instance.""" | |
| return Plugin() | |
| def plugin_with_sqlite(tmp_path): | |
| """Create a C++ plugin instance with SQLite storage.""" | |
| db_path = tmp_path / "test.db" | |
| store = SQLiteStore(str(db_path)) | |
| return Plugin(sqlite_store=store), store | |
| def temp_cpp_file(): | |
| """Create a temporary C++ file for testing.""" | |
| with tempfile.NamedTemporaryFile(mode="w", suffix=".cpp", delete=False) as f: | |
| f.write(""" | |
| #include <iostream> | |
| #include <vector> | |
| #include <string> | |
| namespace MyNamespace { | |
| // A simple class with various members | |
| class MyClass { | |
| public: | |
| MyClass() = default; | |
| MyClass(int value) : m_value(value) {} | |
| ~MyClass() = default; | |
| int getValue() const { return m_value; } | |
| void setValue(int value) { m_value = value; } | |
| virtual void virtualMethod() { std::cout << "Base" << std::endl; } | |
| static int staticMethod(int x, int y) { return x + y; } | |
| private: | |
| int m_value = 0; | |
| }; | |
| // Template class | |
| template<typename T> | |
| class Container { | |
| public: | |
| void add(const T& item) { items.push_back(item); } | |
| T& get(size_t index) { return items[index]; } | |
| private: | |
| std::vector<T> items; | |
| }; | |
| // Free function | |
| void freeFunction(const std::string& msg) { | |
| std::cout << msg << std::endl; | |
| } | |
| // Function template | |
| template<typename T> | |
| T max(T a, T b) { | |
| return (a > b) ? a : b; | |
| } | |
| // Enum | |
| enum Color { | |
| RED, | |
| GREEN, | |
| BLUE | |
| }; | |
| // Scoped enum | |
| enum class Status { | |
| OK, | |
| ERROR, | |
| PENDING | |
| }; | |
| // Type alias | |
| using StringVector = std::vector<std::string>; | |
| // Typedef | |
| typedef std::vector<int> IntVector; | |
| } | |
| // Global function | |
| int main(int argc, char* argv[]) { | |
| MyNamespace::MyClass obj(42); | |
| std::cout << obj.getValue() << std::endl; | |
| return 0; | |
| } | |
| // Operator overloading | |
| class Point { | |
| public: | |
| Point(double x, double y) : x_(x), y_(y) {} | |
| Point operator+(const Point& other) const { | |
| return Point(x_ + other.x_, y_ + other.y_); | |
| } | |
| friend std::ostream& operator<<(std::ostream& os, const Point& p) { | |
| os << "(" << p.x_ << ", " << p.y_ << ")"; | |
| return os; | |
| } | |
| private: | |
| double x_, y_; | |
| }; | |
| // Inheritance example | |
| class DerivedClass : public MyNamespace::MyClass { | |
| public: | |
| DerivedClass(int value) : MyClass(value) {} | |
| void virtualMethod() override { | |
| std::cout << "Derived" << std::endl; | |
| } | |
| }; | |
| """) | |
| path = f.name | |
| yield path | |
| if Path(path).exists(): | |
| Path(path).unlink() | |
| def temp_header_file(): | |
| """Create a temporary C++ header file for testing.""" | |
| with tempfile.NamedTemporaryFile(mode="w", suffix=".hpp", delete=False) as f: | |
| f.write(""" | |
| #pragma once | |
| /// @brief A simple interface for shapes | |
| class IShape { | |
| public: | |
| virtual ~IShape() = default; | |
| /// Calculate the area of the shape | |
| /// @return The area as a double | |
| virtual double area() const = 0; | |
| /// Calculate the perimeter of the shape | |
| /// @return The perimeter as a double | |
| virtual double perimeter() const = 0; | |
| }; | |
| /** | |
| * @brief A rectangle implementation of IShape | |
| * | |
| * This class represents a rectangle with width and height. | |
| */ | |
| class Rectangle : public IShape { | |
| public: | |
| Rectangle(double width, double height); | |
| double area() const override; | |
| double perimeter() const override; | |
| double getWidth() const { return width_; } | |
| double getHeight() const { return height_; } | |
| private: | |
| double width_; | |
| double height_; | |
| }; | |
| // Function declarations | |
| namespace Utils { | |
| /// Helper function to calculate distance | |
| double distance(double x1, double y1, double x2, double y2); | |
| /// Template function for swapping values | |
| template<typename T> | |
| void swap(T& a, T& b) { | |
| T temp = a; | |
| a = b; | |
| b = temp; | |
| } | |
| } | |
| // Macro definition (not a symbol, but should be handled gracefully) | |
| #define MAX(a, b) ((a) > (b) ? (a) : (b)) | |
| // Forward declarations | |
| class ForwardDeclared; | |
| struct ForwardStruct; | |
| // Complex template | |
| template<typename T, typename Allocator = std::allocator<T>> | |
| class CustomVector { | |
| public: | |
| using value_type = T; | |
| using allocator_type = Allocator; | |
| using size_type = std::size_t; | |
| CustomVector() = default; | |
| explicit CustomVector(size_type count); | |
| void push_back(const T& value); | |
| void push_back(T&& value); | |
| T& operator[](size_type index); | |
| const T& operator[](size_type index) const; | |
| private: | |
| T* data_ = nullptr; | |
| size_type size_ = 0; | |
| size_type capacity_ = 0; | |
| Allocator alloc_; | |
| }; | |
| """) | |
| path = f.name | |
| yield path | |
| if Path(path).exists(): | |
| Path(path).unlink() | |
| class TestCppPlugin: | |
| """Test cases for C++ plugin functionality.""" | |
| def test_plugin_creation(self, plugin): | |
| """Test that plugin is created correctly.""" | |
| assert plugin.lang == "cpp" | |
| assert hasattr(plugin, "_parser") | |
| assert hasattr(plugin, "_indexer") | |
| def test_supports_cpp_files(self, plugin): | |
| """Test file extension support.""" | |
| # Should support | |
| assert plugin.supports("test.cpp") | |
| assert plugin.supports("test.cc") | |
| assert plugin.supports("test.cxx") | |
| assert plugin.supports("test.c++") | |
| assert plugin.supports("test.hpp") | |
| assert plugin.supports("test.h") | |
| assert plugin.supports("test.hh") | |
| assert plugin.supports("test.h++") | |
| assert plugin.supports("test.hxx") | |
| assert plugin.supports(Path("test.CPP")) # case insensitive | |
| # Should not support | |
| assert not plugin.supports("test.py") | |
| assert not plugin.supports("test.js") | |
| assert not plugin.supports("test.txt") | |
| assert not plugin.supports("test.c") # Plain C | |
| def test_index_cpp_file(self, plugin, temp_cpp_file): | |
| """Test indexing a C++ file.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| shard = plugin.indexFile(temp_cpp_file, content) | |
| assert shard["file"] == temp_cpp_file | |
| assert shard["language"] == "cpp" | |
| assert len(shard["symbols"]) > 0 | |
| # Check for expected symbols | |
| symbol_names = [s["symbol"] for s in shard["symbols"]] | |
| # Namespace - check the actual symbol name that was found | |
| # The plugin might return it as MyNamespace::MyNamespace or just MyNamespace | |
| assert any("MyNamespace" in s for s in symbol_names) | |
| # Classes | |
| assert "MyNamespace::MyClass" in symbol_names | |
| assert "MyNamespace::Container" in symbol_names | |
| assert "Point" in symbol_names | |
| assert "DerivedClass" in symbol_names | |
| # Functions | |
| assert "MyNamespace::freeFunction" in symbol_names | |
| assert "MyNamespace::max" in symbol_names | |
| assert "main" in symbol_names | |
| # Methods | |
| assert any("getValue" in s for s in symbol_names) | |
| assert any("setValue" in s for s in symbol_names) | |
| assert any("virtualMethod" in s for s in symbol_names) | |
| assert any("staticMethod" in s for s in symbol_names) | |
| # Enums | |
| assert "MyNamespace::Color" in symbol_names | |
| assert "MyNamespace::Status" in symbol_names | |
| # Type aliases | |
| assert "MyNamespace::StringVector" in symbol_names | |
| assert "MyNamespace::IntVector" in symbol_names | |
| def test_index_header_file(self, plugin, temp_header_file): | |
| """Test indexing a C++ header file.""" | |
| with open(temp_header_file, "r") as f: | |
| content = f.read() | |
| shard = plugin.indexFile(temp_header_file, content) | |
| assert shard["file"] == temp_header_file | |
| assert shard["language"] == "cpp" | |
| # Check for expected symbols | |
| symbol_names = [s["symbol"] for s in shard["symbols"]] | |
| # Classes | |
| assert "IShape" in symbol_names | |
| assert "Rectangle" in symbol_names | |
| assert "CustomVector" in symbol_names | |
| # Namespace and functions - check for Utils namespace | |
| assert any("Utils" in s for s in symbol_names) | |
| assert "Utils::distance" in symbol_names | |
| assert "Utils::swap" in symbol_names | |
| def test_symbol_kinds(self, plugin, temp_cpp_file): | |
| """Test that symbol kinds are correctly identified.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| shard = plugin.indexFile(temp_cpp_file, content) | |
| symbols_by_kind = {} | |
| for symbol in shard["symbols"]: | |
| kind = symbol["kind"] | |
| if kind not in symbols_by_kind: | |
| symbols_by_kind[kind] = [] | |
| symbols_by_kind[kind].append(symbol["symbol"]) | |
| # Check various kinds | |
| assert "namespace" in symbols_by_kind | |
| assert "class" in symbols_by_kind | |
| assert "function" in symbols_by_kind | |
| assert "method" in symbols_by_kind | |
| assert "constructor" in symbols_by_kind | |
| assert "destructor" in symbols_by_kind | |
| assert "enum" in symbols_by_kind | |
| assert "typedef" in symbols_by_kind | |
| assert "type_alias" in symbols_by_kind | |
| def test_template_detection(self, plugin, temp_cpp_file): | |
| """Test that templates are correctly detected.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| shard = plugin.indexFile(temp_cpp_file, content) | |
| # Find template symbols | |
| template_symbols = [s for s in shard["symbols"] if s.get("is_template", False)] | |
| assert len(template_symbols) > 0 | |
| # Check for expected templates - they should contain these names | |
| template_names = [s["symbol"] for s in template_symbols] | |
| assert any("Container" in name for name in template_names) | |
| assert any("max" in name for name in template_names) | |
| def test_get_definition(self, plugin, temp_cpp_file): | |
| """Test getting symbol definitions.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| # Index the file first | |
| plugin.indexFile(temp_cpp_file, content) | |
| # Test various symbol lookups | |
| my_class_def = plugin.getDefinition("MyClass") | |
| assert my_class_def is not None | |
| assert my_class_def["kind"] == "class" | |
| assert my_class_def["language"] == "cpp" | |
| assert "MyClass" in my_class_def["signature"] | |
| main_def = plugin.getDefinition("main") | |
| assert main_def is not None | |
| assert main_def["kind"] == "function" | |
| assert "main" in main_def["signature"] | |
| assert "int" in main_def["signature"] | |
| # Test qualified name lookup | |
| free_func_def = plugin.getDefinition("freeFunction") | |
| assert free_func_def is not None | |
| assert free_func_def["kind"] == "function" | |
| def test_find_references(self, plugin, temp_cpp_file): | |
| """Test finding references to symbols.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| # Index the file first | |
| plugin.indexFile(temp_cpp_file, content) | |
| # Find references to MyClass | |
| refs = plugin.findReferences("MyClass") | |
| # The original symbol definition counts as a reference too | |
| assert len(refs) >= 0 # May have 0 if only finding usage references, not definitions | |
| # Try finding references to a more commonly used symbol | |
| refs = plugin.findReferences("getValue") | |
| assert len(refs) >= 0 | |
| def test_search(self, plugin, temp_cpp_file): | |
| """Test searching for symbols.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| # Index the file first | |
| plugin.indexFile(temp_cpp_file, content) | |
| # Search for various terms | |
| results = plugin.search("MyClass") | |
| assert len(results) > 0 | |
| results = plugin.search("getValue") | |
| assert len(results) > 0 | |
| # Test with limit | |
| results = plugin.search("a", {"limit": 5}) | |
| assert len(results) <= 5 | |
| def test_documentation_extraction(self, plugin, temp_header_file): | |
| """Test extracting documentation comments.""" | |
| with open(temp_header_file, "r") as f: | |
| content = f.read() | |
| # Index the file first | |
| plugin.indexFile(temp_header_file, content) | |
| # Get definition with documentation | |
| shape_def = plugin.getDefinition("IShape") | |
| assert shape_def is not None | |
| assert shape_def["doc"] is not None | |
| assert "simple interface for shapes" in shape_def["doc"] | |
| rect_def = plugin.getDefinition("Rectangle") | |
| assert rect_def is not None | |
| assert rect_def["doc"] is not None | |
| assert "rectangle implementation" in rect_def["doc"] | |
| def test_inheritance_handling(self, plugin, temp_cpp_file): | |
| """Test that inheritance is properly handled.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| shard = plugin.indexFile(temp_cpp_file, content) | |
| # Find DerivedClass | |
| derived_class = next((s for s in shard["symbols"] if s["symbol"] == "DerivedClass"), None) | |
| assert derived_class is not None | |
| # Check that it extends MyClass in some form | |
| assert ( | |
| "MyClass" in derived_class["signature"] | |
| or "MyNamespace::MyClass" in derived_class["signature"] | |
| ) | |
| def test_operator_overloading(self, plugin, temp_cpp_file): | |
| """Test that operator overloading is detected.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| shard = plugin.indexFile(temp_cpp_file, content) | |
| # Check for operator symbols | |
| operator_symbols = [s for s in shard["symbols"] if "operator" in s["symbol"]] | |
| assert len(operator_symbols) > 0 | |
| def test_sqlite_persistence(self, plugin_with_sqlite, temp_cpp_file): | |
| """Test that symbols are persisted to SQLite.""" | |
| plugin, store = plugin_with_sqlite | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| # Index the file | |
| shard = plugin.indexFile(temp_cpp_file, content) | |
| # Check that symbols were stored | |
| with store._get_connection() as conn: | |
| cursor = conn.execute("SELECT COUNT(*) FROM symbols") | |
| symbol_count = cursor.fetchone()[0] | |
| assert symbol_count > 0 | |
| # Check specific symbol | |
| cursor = conn.execute( | |
| "SELECT name, kind, signature FROM symbols WHERE name LIKE ?", | |
| ("%MyClass%",), | |
| ) | |
| results = cursor.fetchall() | |
| assert len(results) > 0 | |
| def test_const_method_detection(self, plugin, temp_cpp_file): | |
| """Test that const methods are properly detected.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| shard = plugin.indexFile(temp_cpp_file, content) | |
| # Find getValue method - it should be in the symbols list | |
| get_value_symbols = [s for s in shard["symbols"] if "getValue" in s["symbol"]] | |
| assert len(get_value_symbols) > 0 | |
| # At least one should be const | |
| assert any("const" in s["signature"] for s in get_value_symbols) | |
| def test_static_method_detection(self, plugin, temp_cpp_file): | |
| """Test that static methods are properly detected.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| shard = plugin.indexFile(temp_cpp_file, content) | |
| # Find staticMethod - it should be in the symbols list | |
| static_methods = [s for s in shard["symbols"] if "staticMethod" in s["symbol"]] | |
| assert len(static_methods) > 0 | |
| # At least one should be static | |
| assert any("static" in s["signature"] for s in static_methods) | |
| def test_virtual_method_detection(self, plugin, temp_cpp_file): | |
| """Test that virtual methods are properly detected.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| shard = plugin.indexFile(temp_cpp_file, content) | |
| # Find virtualMethod - it should be in the symbols list | |
| virtual_methods = [ | |
| s | |
| for s in shard["symbols"] | |
| if "virtualMethod" in s["symbol"] and "MyClass" in s["symbol"] | |
| ] | |
| assert len(virtual_methods) > 0 | |
| # At least one should be virtual | |
| assert any("virtual" in s["signature"] for s in virtual_methods) | |
| def test_enum_values(self, plugin, temp_cpp_file): | |
| """Test that enum values are extracted.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| shard = plugin.indexFile(temp_cpp_file, content) | |
| # Check for enum values | |
| symbol_names = [s["symbol"] for s in shard["symbols"]] | |
| assert "MyNamespace::Color::RED" in symbol_names | |
| assert "MyNamespace::Color::GREEN" in symbol_names | |
| assert "MyNamespace::Color::BLUE" in symbol_names | |
| assert "MyNamespace::Status::OK" in symbol_names | |
| assert "MyNamespace::Status::ERROR" in symbol_names | |
| assert "MyNamespace::Status::PENDING" in symbol_names | |
| def test_get_indexed_count(self, plugin, temp_cpp_file): | |
| """Test getting the count of indexed files.""" | |
| assert plugin.get_indexed_count() >= 0 | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| # Index a file | |
| plugin.indexFile(temp_cpp_file, content) | |
| # Count should increase | |
| assert plugin.get_indexed_count() > 0 | |
| class TestCppPluginNewInterface: | |
| """Test cases for the new ICppPlugin interface methods.""" | |
| def test_plugin_properties(self, plugin): | |
| """Test plugin properties from ICppPlugin interface.""" | |
| assert plugin.name == "C++ Plugin" | |
| assert ".cpp" in plugin.supported_extensions | |
| assert ".hpp" in plugin.supported_extensions | |
| assert "cpp" in plugin.supported_languages | |
| def test_can_handle(self, plugin): | |
| """Test can_handle method.""" | |
| assert plugin.can_handle("test.cpp") | |
| assert plugin.can_handle("test.hpp") | |
| assert not plugin.can_handle("test.py") | |
| def test_index_interface_method(self, plugin, temp_cpp_file): | |
| """Test the new index interface method.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| result = plugin.index(temp_cpp_file, content) | |
| assert result.success | |
| indexed_file = result.value | |
| assert indexed_file.file_path == temp_cpp_file | |
| assert indexed_file.language == "cpp" | |
| assert len(indexed_file.symbols) > 0 | |
| # Check symbol definitions | |
| symbol_names = [s.symbol for s in indexed_file.symbols] | |
| assert any("MyClass" in name for name in symbol_names) | |
| def test_get_definition_interface(self, plugin, temp_cpp_file): | |
| """Test get_definition from ICppPlugin interface.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| # Index first | |
| plugin.indexFile(temp_cpp_file, content) | |
| result = plugin.get_definition("MyClass", {}) | |
| assert result.success | |
| if result.value: | |
| definition = result.value | |
| assert isinstance(definition, SymbolDefinition) | |
| assert "MyClass" in definition.symbol | |
| assert definition.symbol_type == "class" | |
| def test_get_references_interface(self, plugin, temp_cpp_file): | |
| """Test get_references from ICppPlugin interface.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| # Index first | |
| plugin.indexFile(temp_cpp_file, content) | |
| result = plugin.get_references("MyClass", {}) | |
| assert result.success | |
| references = result.value | |
| assert isinstance(references, list) | |
| def test_search_interface(self, plugin, temp_cpp_file): | |
| """Test search from ICppPlugin interface.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| # Index first | |
| plugin.indexFile(temp_cpp_file, content) | |
| result = plugin.search_with_result("MyClass", {"limit": 10}) | |
| assert result.success | |
| search_results = result.value | |
| assert isinstance(search_results, list) | |
| def test_validate_syntax(self, plugin): | |
| """Test syntax validation.""" | |
| valid_code = "class Test { public: int x; };" | |
| result = plugin.validate_syntax(valid_code) | |
| assert result.success | |
| assert result.value is True | |
| # Test with invalid syntax | |
| invalid_code = "class Test { public int x; }" # Missing colon | |
| result = plugin.validate_syntax(invalid_code) | |
| assert result.success | |
| # Note: Tree-sitter is quite forgiving, so this might still parse | |
| def test_get_completions(self, plugin, temp_cpp_file): | |
| """Test code completions.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| # Index first | |
| plugin.indexFile(temp_cpp_file, content) | |
| result = plugin.get_completions(temp_cpp_file, 50, 10) | |
| assert result.success | |
| completions = result.value | |
| assert isinstance(completions, list) | |
| assert len(completions) > 0 | |
| # Should include C++ keywords | |
| assert any("class" in comp for comp in completions) | |
| def test_resolve_includes(self, plugin, temp_header_file): | |
| """Test include resolution.""" | |
| result = plugin.resolve_includes(temp_header_file) | |
| assert result.success | |
| includes = result.value | |
| assert isinstance(includes, list) | |
| # The header file should have no includes | |
| def test_parse_templates(self, plugin): | |
| """Test template parsing.""" | |
| template_code = """ | |
| template<typename T, int N> | |
| class Array { | |
| T data[N]; | |
| public: | |
| T& operator[](int index) { return data[index]; } | |
| }; | |
| template<typename T> | |
| T max(T a, T b) { | |
| return a > b ? a : b; | |
| } | |
| """ | |
| result = plugin.parse_templates(template_code) | |
| assert result.success | |
| templates = result.value | |
| assert len(templates) >= 2 # Array and max | |
| template_names = [t.symbol for t in templates] | |
| assert "Array" in template_names | |
| assert "max" in template_names | |
| def test_parse_imports(self, plugin): | |
| """Test import parsing (includes).""" | |
| code_with_includes = """ | |
| #include <iostream> | |
| #include <vector> | |
| #include "myheader.h" | |
| int main() { return 0; } | |
| """ | |
| result = plugin.parse_imports(code_with_includes) | |
| assert result.success | |
| imports = result.value | |
| assert "iostream" in imports | |
| assert "vector" in imports | |
| assert "myheader.h" in imports | |
| def test_extract_symbols_interface(self, plugin): | |
| """Test symbol extraction via interface.""" | |
| code = """ | |
| namespace NS { | |
| class MyClass { | |
| public: | |
| void method(); | |
| int field; | |
| }; | |
| } | |
| """ | |
| result = plugin.extract_symbols(code) | |
| assert result.success | |
| symbols = result.value | |
| assert len(symbols) > 0 | |
| symbol_names = [s.symbol for s in symbols] | |
| assert any("NS" in name for name in symbol_names) | |
| assert any("MyClass" in name for name in symbol_names) | |
| def test_resolve_type(self, plugin, temp_cpp_file): | |
| """Test type resolution.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| # Index first | |
| plugin.indexFile(temp_cpp_file, content) | |
| result = plugin.resolve_type("getValue", {}) | |
| assert result.success | |
| # Type resolution might return None if not found | |
| def test_get_call_hierarchy(self, plugin, temp_cpp_file): | |
| """Test call hierarchy.""" | |
| with open(temp_cpp_file, "r") as f: | |
| content = f.read() | |
| # Index first | |
| plugin.indexFile(temp_cpp_file, content) | |
| result = plugin.get_call_hierarchy("main", {}) | |
| assert result.success | |
| hierarchy = result.value | |
| assert "calls_to" in hierarchy | |
| assert "called_by" in hierarchy | |
| def test_error_handling(self, plugin): | |
| """Test error handling in interface methods.""" | |
| # Test with non-existent file | |
| result = plugin.resolve_includes("/non/existent/file.cpp") | |
| assert not result.success | |
| assert result.error is not None | |
| assert result.error.code == "CPP_INCLUDE_ERROR" | |
| # Test with invalid content | |
| result = plugin.validate_syntax(None) | |
| assert not result.success | |
| assert result.error is not None | |
Xet Storage Details
- Size:
- 25.2 kB
- Xet hash:
- 3d516edaf2e54804343b91896cb098d2cca385277bc5a2dbbc9ffc92de071a27
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.