coverage-tool 1.0.0__py3-none-any.whl

coverage_tool/test_removers/c_remover.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""
+C测试删除器
+使用正则表达式解析C测试文件
+"""
+
+import re
+from typing import List, Optional, Tuple
+from pathlib import Path
+
+from coverage_tool.test_removers.base import BaseSmartTestRemover, TestFunction
+from coverage_tool.parsers import TestCase
+
+
+class CSmartTestRemover(BaseSmartTestRemover):
+    """C智能测试删除器"""
+    
+    # C语言测试文件匹配模式
+    C_TEST_PATTERNS = [
+        "test_*.c",
+        "*_test.c",
+        "*test*.c",
+        "check_*.c",
+        "tests/*.c",
+        "*_tests.c",
+        "tests_*.c",
+    ]
+    
+    # 预编译正则表达式
+    TEST_FUNC_PATTERNS = [
+        re.compile(r'^(void|int|bool)\s+(test_\w+)\s*\([^)]*\)\s*\{', re.MULTILINE),
+        re.compile(r'^(void|int|bool)\s+(check_\w+)\s*\([^)]*\)\s*\{', re.MULTILINE),
+        re.compile(r'^(void|int|bool)\s+(\w+_test)\s*\([^)]*\)\s*\{', re.MULTILINE),
+    ]
+    
+    def _is_build_failure(self, test_name: str) -> bool:
+        """检查是否是C构建失败的特殊测试名称"""
+        build_failure_patterns = [
+            '[build failed]',
+            '[compilation failed]',
+            'error:',
+            'undefined reference',
+            'linker error',
+            'compilation error',
+            'syntax error',
+        ]
+        return any(pattern in test_name for pattern in build_failure_patterns)
+    
+    def remove_all_tests_in_package(self, package_path: str) -> Tuple[int, List[str]]:
+        """
+        删除指定包/目录内的所有测试文件（C使用目录方式）
+        用于处理目录级编译错误
+        """
+        return self.remove_all_tests_in_directory(package_path)
+    
+    def remove_all_tests_in_directory(self, directory_path: str) -> Tuple[int, List[str]]:
+        """
+        删除指定目录内的所有测试文件
+        用于处理C/C++目录级编译错误
+        """
+        deleted_count = 0
+        deleted_files = []
+        
+        # 按完整路径搜索
+        dir_path = Path(self.project_dir) / directory_path
+        
+        if dir_path.exists() and dir_path.is_dir():
+            test_files = []
+            for pattern in self.C_TEST_PATTERNS:
+                test_files.extend(dir_path.glob(pattern))
+            # 去重
+            test_files = list(set(test_files))
+            
+            if test_files:
+                self.logger.info(f"[编译错误] 在目录 {dir_path} 发现 {len(test_files)} 个C测试文件")
+                
+                for test_file in test_files:
+                    try:
+                        # 备份文件
+                        self.backup_manager.backup_file(str(test_file))
+                        # 删除文件
+                        test_file.unlink()
+                        deleted_count += 1
+                        deleted_files.append(str(test_file))
+                        self.logger.info(f"[编译错误] ✓ 已删除C测试文件: {test_file}")
+                    except Exception as e:
+                        self.logger.error(f"[编译错误] 删除文件失败: {test_file}: {e}")
+                
+                return deleted_count, deleted_files
+        
+        # 如果没找到，尝试将classname作为子目录搜索
+        parts = directory_path.replace('.', '/').split('/')
+        for i in range(len(parts)):
+            subdir = '/'.join(parts[i:])
+            search_dir = Path(self.project_dir) / subdir
+            if search_dir.exists() and search_dir.is_dir():
+                test_files = []
+                for pattern in self.C_TEST_PATTERNS:
+                    test_files.extend(search_dir.glob(pattern))
+                test_files = list(set(test_files))
+                
+                if test_files:
+                    self.logger.info(f"[编译错误] 在目录 {search_dir} 发现 {len(test_files)} 个C测试文件")
+                    
+                    for test_file in test_files:
+                        try:
+                            self.backup_manager.backup_file(str(test_file))
+                            test_file.unlink()
+                            deleted_count += 1
+                            deleted_files.append(str(test_file))
+                            self.logger.info(f"[编译错误] ✓ 已删除C测试文件: {test_file}")
+                        except Exception as e:
+                            self.logger.error(f"[编译错误] 删除文件失败: {test_file}: {e}")
+                    
+                    return deleted_count, deleted_files
+        
+        return deleted_count, deleted_files
+    
+    def find_test_functions(self, file_path: str) -> List[TestFunction]:
+        """查找C测试函数"""
+        test_functions = []
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            for pattern in self.TEST_FUNC_PATTERNS:
+                for match in pattern.finditer(content):
+                    func_name = match.group(2)
+                    start_pos = match.start()
+                    start_line = content[:start_pos].count('\n') + 1
+                    
+                    # 找到函数结束
+                    brace_count = 0
+                    end_pos = match.end()
+                    for i, char in enumerate(content[match.end():]):
+                        if char == '{':
+                            brace_count += 1
+                        elif char == '}':
+                            if brace_count == 0:
+                                end_pos = match.end() + i + 1
+                                break
+                            brace_count -= 1
+                    
+                    end_line = content[:end_pos].count('\n') + 1
+                    
+                    test_func = TestFunction(
+                        name=func_name,
+                        file_path=file_path,
+                        start_line=start_line,
+                        end_line=end_line
+                    )
+                    test_functions.append(test_func)
+        
+        except Exception as e:
+            self.logger.error(f"解析C文件失败 {file_path}: {e}")
+        
+        return test_functions
+    
+    def find_test_file(self, test_case: TestCase) -> Optional[str]:
+        """查找C测试文件"""
+        classname = test_case.classname
+        test_name = test_case.name
+        
+        # 处理特殊的构建失败错误
+        if self._is_build_failure(test_name):
+            self.logger.info(f"[编译错误] 检测到C编译失败: {test_name}")
+            # 尝试从classname推断目录
+            search_dirs = [classname]
+            
+            # 也尝试将点分隔的包名转换为路径
+            if '.' in classname:
+                search_dirs.append(classname.replace('.', '/'))
+            
+            for search_dir in search_dirs:
+                # 尝试不同的目录组合
+                parts = search_dir.replace('.', '/').split('/')
+                for i in range(len(parts)):
+                    subdir = '/'.join(parts[i:])
+                    test_dir = Path(self.project_dir) / subdir
+                    
+                    if test_dir.exists() and test_dir.is_dir():
+                        # 查找该目录下的测试文件
+                        for pattern in self.C_TEST_PATTERNS:
+                            for test_file in test_dir.glob(pattern):
+                                if test_file.exists():
+                                    self.logger.info(f"[编译错误] 找到目录 {search_dir} 的C测试文件: {test_file}")
+                                    return str(test_file)
+        
+        # 标准测试文件查找
+        patterns = [
+            f"{classname}_test.c",
+            f"test_{classname}.c",
+            f"tests/{classname}_test.c",
+            f"check_{classname}.c",
+        ]
+        
+        for pattern in patterns:
+            file_path = Path(self.project_dir) / pattern
+            if file_path.exists():
+                return str(file_path)
+        
+        # 使用glob查找
+        for pattern in self.C_TEST_PATTERNS:
+            if '*' in pattern:
+                for file_path in Path(self.project_dir).rglob(pattern):
+                    if file_path.exists():
+                        return str(file_path)
+        
+        return None

coverage_tool/test_removers/cpp_remover.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""
+C++测试删除器
+支持Google Test和普通C++测试
+"""
+
+import re
+from typing import List, Optional, Tuple
+from pathlib import Path
+
+from coverage_tool.test_removers.base import BaseSmartTestRemover, TestFunction
+from coverage_tool.parsers import TestCase
+
+
+class CPPSmartTestRemover(BaseSmartTestRemover):
+    """C++智能测试删除器 - 支持Google Test"""
+    
+    # C++语言测试文件匹配模式
+    CPP_TEST_PATTERNS = [
+        "test_*.cpp",
+        "*_test.cpp",
+        "*test*.cpp",
+        "Test*.cpp",
+        "*.test.cpp",
+        "test_*.cc",
+        "*_test.cc",
+        "*test*.cc",
+        "Test*.cc",
+        "*.test.cc",
+        "tests/*.cpp",
+        "tests/*.cc",
+        "*_tests.cpp",
+        "*_tests.cc",
+        "tests_*.cpp",
+        "tests_*.cc",
+    ]
+    
+    # 预编译正则表达式
+    GTEST_PATTERN = re.compile(
+        r'TEST\s*\(\s*(\w+)\s*,\s*(\w+)\s*\)\s*\{',
+        re.MULTILINE
+    )
+    
+    FUNC_PATTERN = re.compile(
+        r'^(void|int|bool)\s+(test_\w+)\s*\([^)]*\)\s*\{',
+        re.MULTILINE
+    )
+    
+    def _is_build_failure(self, test_name: str) -> bool:
+        """检查是否是C++构建失败的特殊测试名称"""
+        build_failure_patterns = [
+            '[build failed]',
+            '[compilation failed]',
+            'error:',
+            'undefined reference',
+            'linker error',
+            'compilation error',
+            'syntax error',
+        ]
+        return any(pattern in test_name for pattern in build_failure_patterns)
+    
+    def remove_all_tests_in_package(self, package_path: str) -> Tuple[int, List[str]]:
+        """
+        删除指定包/目录内的所有测试文件（C++使用目录方式）
+        用于处理目录级编译错误
+        """
+        return self.remove_all_tests_in_directory(package_path)
+    
+    def remove_all_tests_in_directory(self, directory_path: str) -> Tuple[int, List[str]]:
+        """
+        删除指定目录内的所有测试文件
+        用于处理C/C++目录级编译错误
+        """
+        deleted_count = 0
+        deleted_files = []
+        
+        # 按完整路径搜索
+        dir_path = Path(self.project_dir) / directory_path
+        
+        if dir_path.exists() and dir_path.is_dir():
+            test_files = []
+            for pattern in self.CPP_TEST_PATTERNS:
+                test_files.extend(dir_path.glob(pattern))
+            # 去重
+            test_files = list(set(test_files))
+            
+            if test_files:
+                self.logger.info(f"[编译错误] 在目录 {dir_path} 发现 {len(test_files)} 个C++测试文件")
+                
+                for test_file in test_files:
+                    try:
+                        # 备份文件
+                        self.backup_manager.backup_file(str(test_file))
+                        # 删除文件
+                        test_file.unlink()
+                        deleted_count += 1
+                        deleted_files.append(str(test_file))
+                        self.logger.info(f"[编译错误] ✓ 已删除C++测试文件: {test_file}")
+                    except Exception as e:
+                        self.logger.error(f"[编译错误] 删除文件失败: {test_file}: {e}")
+                
+                return deleted_count, deleted_files
+        
+        # 如果没找到，尝试将classname作为子目录搜索
+        parts = directory_path.replace('.', '/').split('/')
+        for i in range(len(parts)):
+            subdir = '/'.join(parts[i:])
+            search_dir = Path(self.project_dir) / subdir
+            if search_dir.exists() and search_dir.is_dir():
+                test_files = []
+                for pattern in self.CPP_TEST_PATTERNS:
+                    test_files.extend(search_dir.glob(pattern))
+                test_files = list(set(test_files))
+                
+                if test_files:
+                    self.logger.info(f"[编译错误] 在目录 {search_dir} 发现 {len(test_files)} 个C++测试文件")
+                    
+                    for test_file in test_files:
+                        try:
+                            self.backup_manager.backup_file(str(test_file))
+                            test_file.unlink()
+                            deleted_count += 1
+                            deleted_files.append(str(test_file))
+                            self.logger.info(f"[编译错误] ✓ 已删除C++测试文件: {test_file}")
+                        except Exception as e:
+                            self.logger.error(f"[编译错误] 删除文件失败: {test_file}: {e}")
+                    
+                    return deleted_count, deleted_files
+        
+        return deleted_count, deleted_files
+    
+    def find_test_functions(self, file_path: str) -> List[TestFunction]:
+        """查找C++测试函数（Google Test格式）"""
+        test_functions = []
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            # 匹配Google Test的TEST宏
+            for match in self.GTEST_PATTERN.finditer(content):
+                suite_name = match.group(1)
+                test_name = match.group(2)
+                full_name = f"{suite_name}.{test_name}"
+                
+                start_pos = match.start()
+                start_line = content[:start_pos].count('\n') + 1
+                
+                # 找到测试结束
+                brace_count = 0
+                end_pos = match.end()
+                for i, char in enumerate(content[match.end():]):
+                    if char == '{':
+                        brace_count += 1
+                    elif char == '}':
+                        if brace_count == 0:
+                            end_pos = match.end() + i + 1
+                            break
+                        brace_count -= 1
+                
+                end_line = content[:end_pos].count('\n') + 1
+                
+                test_func = TestFunction(
+                    name=full_name,
+                    file_path=file_path,
+                    start_line=start_line,
+                    end_line=end_line
+                )
+                test_functions.append(test_func)
+            
+            # 也匹配普通测试函数
+            for match in self.FUNC_PATTERN.finditer(content):
+                func_name = match.group(2)
+                start_pos = match.start()
+                start_line = content[:start_pos].count('\n') + 1
+                
+                brace_count = 0
+                end_pos = match.end()
+                for i, char in enumerate(content[match.end():]):
+                    if char == '{':
+                        brace_count += 1
+                    elif char == '}':
+                        if brace_count == 0:
+                            end_pos = match.end() + i + 1
+                            break
+                        brace_count -= 1
+                
+                end_line = content[:end_pos].count('\n') + 1
+                
+                test_func = TestFunction(
+                    name=func_name,
+                    file_path=file_path,
+                    start_line=start_line,
+                    end_line=end_line
+                )
+                test_functions.append(test_func)
+        
+        except Exception as e:
+            self.logger.error(f"解析C++文件失败 {file_path}: {e}")
+        
+        return test_functions
+    
+    def find_test_file(self, test_case: TestCase) -> Optional[str]:
+        """查找C++测试文件"""
+        classname = test_case.classname
+        test_name = test_case.name
+        
+        # 处理特殊的构建失败错误
+        if self._is_build_failure(test_name):
+            self.logger.info(f"[编译错误] 检测到C++编译失败: {test_name}")
+            # 尝试从classname推断目录
+            search_dirs = [classname]
+            
+            # 也尝试将点分隔的包名转换为路径
+            if '.' in classname:
+                search_dirs.append(classname.replace('.', '/'))
+            
+            for search_dir in search_dirs:
+                # 尝试不同的目录组合
+                parts = search_dir.replace('.', '/').split('/')
+                for i in range(len(parts)):
+                    subdir = '/'.join(parts[i:])
+                    test_dir = Path(self.project_dir) / subdir
+                    
+                    if test_dir.exists() and test_dir.is_dir():
+                        # 查找该目录下的测试文件
+                        for pattern in self.CPP_TEST_PATTERNS:
+                            for test_file in test_dir.glob(pattern):
+                                if test_file.exists():
+                                    self.logger.info(f"[编译错误] 找到目录 {search_dir} 的C++测试文件: {test_file}")
+                                    return str(test_file)
+        
+        # 处理 Google Test 的 suite.name 格式
+        if '.' in test_name:
+            suite_name = test_name.split('.')[0]
+            patterns = [
+                f"{classname}_test.cpp",
+                f"test_{classname}.cpp",
+                f"tests/{classname}_test.cpp",
+                f"Test{classname}.cpp",
+                f"{classname}.test.cpp",
+                f"{classname}_test.cc",
+                f"test_{classname}.cc",
+                f"Test{classname}.cc",
+                f"{classname}.test.cc",
+            ]
+        else:
+            patterns = [
+                f"{classname}_test.cpp",
+                f"test_{classname}.cpp",
+                f"tests/{classname}_test.cpp",
+                f"Test{classname}.cpp",
+                f"{classname}.test.cpp",
+                f"{classname}_test.cc",
+                f"test_{classname}.cc",
+                f"Test{classname}.cc",
+                f"{classname}.test.cc",
+            ]
+        
+        for pattern in patterns:
+            file_path = Path(self.project_dir) / pattern
+            if file_path.exists():
+                return str(file_path)
+        
+        # 使用glob查找
+        for pattern in self.CPP_TEST_PATTERNS:
+            if '*' in pattern:
+                for file_path in Path(self.project_dir).rglob(pattern):
+                    if file_path.exists():
+                        return str(file_path)
+        
+        return None

coverage_tool/test_removers/factory.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""
+测试删除器工厂
+提供统一的接口来获取不同语言的测试删除器
+"""
+
+from typing import Optional
+
+from coverage_tool.utils import Logger
+from coverage_tool.test_removers.base import BaseSmartTestRemover, TestFunction, TestRemovalStrategy
+from coverage_tool.test_removers.python_remover import PythonSmartTestRemover
+from coverage_tool.test_removers.java_remover import JavaSmartTestRemover
+from coverage_tool.test_removers.go_remover import GoSmartTestRemover
+from coverage_tool.test_removers.c_remover import CSmartTestRemover
+from coverage_tool.test_removers.cpp_remover import CPPSmartTestRemover
+
+
+class SmartTestRemoverFactory:
+    """智能测试删除器工厂"""
+    
+    _removers = {
+        'python': PythonSmartTestRemover,
+        'java': JavaSmartTestRemover,
+        'go': GoSmartTestRemover,
+        'c': CSmartTestRemover,
+        'cpp': CPPSmartTestRemover,
+    }
+    
+    @classmethod
+    def get_remover(cls, language: str, project_dir: str, logger: Optional[Logger] = None) -> BaseSmartTestRemover:
+        """获取对应语言的测试删除器"""
+        remover_class = cls._removers.get(language.lower())
+        if remover_class is None:
+            raise ValueError(f"不支持的语言: {language}")
+        return remover_class(project_dir, logger)
+    
+    @classmethod
+    def register_remover(cls, language: str, remover_class: type):
+        """注册新的测试删除器"""
+        cls._removers[language.lower()] = remover_class
+    
+    @classmethod
+    def supported_languages(cls) -> list:
+        """返回支持的语言列表"""
+        return list(cls._removers.keys())

coverage_tool/test_removers/go_remover.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+Go测试删除器
+使用正则表达式解析Go测试文件
+"""
+
+import re
+from typing import List, Optional
+from pathlib import Path
+
+from coverage_tool.test_removers.base import BaseSmartTestRemover, TestFunction
+from coverage_tool.parsers import TestCase
+
+
+class GoSmartTestRemover(BaseSmartTestRemover):
+    """Go智能测试删除器"""
+    
+    # 预编译正则表达式
+    TEST_FUNC_PATTERN = re.compile(
+        r'^func\s+(Test\w+)\s*\([^)]*\*testing\.T[^)]*\)\s*\{',
+        re.MULTILINE
+    )
+    
+    def find_test_functions(self, file_path: str) -> List[TestFunction]:
+        """查找Go测试函数"""
+        test_functions = []
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            for match in self.TEST_FUNC_PATTERN.finditer(content):
+                func_name = match.group(1)
+                start_pos = match.start()
+                start_line = content[:start_pos].count('\n') + 1
+                
+                # 找到函数结束
+                brace_count = 0
+                end_pos = match.end()
+                for i, char in enumerate(content[match.end():]):
+                    if char == '{':
+                        brace_count += 1
+                    elif char == '}':
+                        if brace_count == 0:
+                            end_pos = match.end() + i + 1
+                            break
+                        brace_count -= 1
+                
+                end_line = content[:end_pos].count('\n') + 1
+                
+                test_func = TestFunction(
+                    name=func_name,
+                    file_path=file_path,
+                    start_line=start_line,
+                    end_line=end_line
+                )
+                test_functions.append(test_func)
+        
+        except Exception as e:
+            self.logger.error(f"解析Go文件失败 {file_path}: {e}")
+        
+        return test_functions
+    
+    def find_test_file(self, test_case: TestCase) -> Optional[str]:
+        """查找Go测试文件"""
+        classname = test_case.classname
+        test_name = test_case.name
+        
+        # 处理特殊的构建失败错误: [build failed]
+        if '[build failed]' in test_name or '[no test files]' in test_name:
+            # classname 包含包路径，如 "github.com/FishGoddess/logit/rotate"
+            # 尝试从包名推断目录
+            package_parts = classname.split('/')
+            if len(package_parts) > 1:
+                # 尝试不同的包目录组合
+                for i in range(len(package_parts) - 1, 0, -1):
+                    subdir = '/'.join(package_parts[i:])
+                    # 查找该目录下的所有测试文件
+                    for test_file in Path(self.project_dir).rglob(f"{subdir}/*_test.go"):
+                        if test_file.exists():
+                            self.logger.info(f"[编译错误] 找到包 {classname} 的测试文件: {test_file}")
+                            return str(test_file)
+                    # 也尝试子目录本身
+                    dir_path = Path(self.project_dir) / subdir
+                    if dir_path.exists() and dir_path.is_dir():
+                        for test_file in dir_path.glob("*_test.go"):
+                            if test_file.exists():
+                                self.logger.info(f"[编译错误] 找到包 {classname} 的测试文件: {test_file}")
+                                return str(test_file)
+        
+        # 从包名推断文件路径
+        patterns = [
+            f"{classname.replace('.', '/')}_test.go",
+            f"{classname}_test.go",
+        ]
+        
+        for pattern in patterns:
+            file_path = Path(self.project_dir) / pattern
+            if file_path.exists():
+                return str(file_path)
+        
+        # 搜索包含测试函数的文件
+        for test_file in Path(self.project_dir).rglob("*_test.go"):
+            try:
+                with open(test_file, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                if f"func {test_name}(" in content:
+                    return str(test_file)
+            except:
+                continue
+        
+        return None