cli-test-framework 0.1.0__py3-none-any.whl

cli_test_framework-0.1.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: cli-test-framework
+Version: 0.1.0
+Summary: A small command line testing framework in Python.
+Author: Xiaotong Wang
+Author-email: xiaotongwang98@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: requires-python
+Dynamic: summary

cli_test_framework-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+core/__init__.py,sha256=hSG3J7CT59-weORalShDrpIs8YT0CdNSTdksbLQpQvY,146
+core/assertions.py,sha256=cX76Hz0NyHjXiZgTdUk1qModGFvzVSiOXV_vMWlnnfI,1225
+core/base_runner.py,sha256=idcFPY2-SEMZmWydBZ93VuNvuVTvSAxkoMqUAVoQb2s,2152
+core/parallel_runner.py,sha256=3HlxKWiv1vooV20IMyKpDSOR4KzcOeKxPV5MyciRDy8,5092
+core/process_worker.py,sha256=-d_mSPI4Izgn2d8G_28TxjmY6TIbHtXzzyoff2z_DUE,2996
+core/test_case.py,sha256=wdcOGwHCwhte6HcaFrWtuq1-2Dg2GYoGJdWGJ7_GQFQ,569
+runners/__init__.py,sha256=tNjEfDgSnc2xmgYqcKm8f8dAbq5IqAPaXs0LfbdnTsc,124
+runners/json_runner.py,sha256=i6h9G7tTIhY9uT-i-Jm50qvnn6myw3cXCdwrwsYCTJE,3911
+runners/parallel_json_runner.py,sha256=XUHOljkpEADuNSCtnrbUcGgZo7sdbLGbUVyRa2GmH5k,4607
+runners/yaml_runner.py,sha256=KhQimcGsq-qnfdTq5EfQp6H4efr5r6iVmM9-LFFSgoY,3622
+utils/__init__.py,sha256=1K8HjFkHzJ8Q9rNNVpIheb2sXQuARtZhkYSJEWHW-_8,116
+utils/path_resolver.py,sha256=gkICP-qP_18f2nsH9ekOg21jP7Yrf3hBcQuJ8cOxf4Y,8670
+utils/report_generator.py,sha256=wREmV9nPODP96-OuKyF_AruZEt4NDpcaQml-_dsOKoo,2857
+cli_test_framework-0.1.0.dist-info/METADATA,sha256=Mhzr6EC2fp5m7wZ1ksj5OdZEBHUn2dDBcYHqBli6kSE,466
+cli_test_framework-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cli_test_framework-0.1.0.dist-info/top_level.txt,sha256=DowRqhMNKADEnL9FTGS6N_r_saE0obbpmwTUUmbtcLI,19
+cli_test_framework-0.1.0.dist-info/RECORD,,

cli_test_framework-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cli_test_framework-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+core
+runners
+utils

core/__init__.py

@@ -0,0 +1,4 @@
+from .base_runner import BaseRunner
+from .parallel_runner import ParallelRunner
+from .test_case import TestCase
+from .assertions import Assertions

core/assertions.py

@@ -0,0 +1,32 @@
+import re
+from typing import Any, Pattern
+
+class Assertions:
+    @staticmethod
+    def equals(actual: Any, expected: Any, message: str = "") -> bool:
+        if actual != expected:
+            raise AssertionError(f"{message} Expected: {expected}, but got: {actual}")
+        return True
+
+    @staticmethod
+    def contains(container: str, item: str, message: str = "") -> bool:
+        """
+        Check if the item is contained within the container string.
+        This method returns True if the item is found anywhere within the container,
+        even if the container contains other information.
+        """
+        if item not in container:
+            raise AssertionError(f"{message} Expected to contain: {item}")
+        return True
+
+    @staticmethod
+    def matches(text: str, pattern: str, message: str = "") -> bool:
+        if not re.search(pattern, text):
+            raise AssertionError(f"{message} Text does not match pattern: {pattern}")
+        return True
+
+    @staticmethod
+    def return_code_equals(actual: int, expected: int, message: str = "") -> bool:
+        if actual != expected:
+            raise AssertionError(f"{message} Expected return code: {expected}, got: {actual}")
+        return True

core/base_runner.py

@@ -0,0 +1,56 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from .test_case import TestCase
+from .assertions import Assertions
+
+class BaseRunner(ABC):
+    def __init__(self, config_file: str, workspace: Optional[str] = None):
+        if workspace:
+            self.workspace = Path(workspace)
+        else:
+            self.workspace = Path(__file__).parent.parent.parent
+        self.config_path = self.workspace / config_file
+        self.test_cases: List[TestCase] = []
+        self.results: Dict[str, Any] = {
+            "total": 0,
+            "passed": 0,
+            "failed": 0,
+            "details": []
+        }
+        self.assertions = Assertions()
+
+    @abstractmethod
+    def load_test_cases(self) -> None:
+        """Load test cases from configuration file"""
+        pass
+
+    def run_tests(self) -> bool:
+        """Run all test cases and return whether all tests passed"""
+        self.load_test_cases()
+        self.results["total"] = len(self.test_cases)
+        
+        print(f"\nStarting test execution... Total tests: {self.results['total']}")
+        print("=" * 50)
+        
+        for i, case in enumerate(self.test_cases, 1):
+            print(f"\nRunning test {i}/{self.results['total']}: {case.name}")
+            result = self.run_single_test(case)
+            self.results["details"].append(result)
+            if result["status"] == "passed":
+                self.results["passed"] += 1
+                print(f"✓ Test passed: {case.name}")
+            else:
+                self.results["failed"] += 1
+                print(f"✗ Test failed: {case.name}")
+                if result["message"]:
+                    print(f"  Error: {result['message']}")
+                
+        print("\n" + "=" * 50)
+        print(f"Test execution completed. Passed: {self.results['passed']}, Failed: {self.results['failed']}")
+        return self.results["failed"] == 0
+
+    @abstractmethod
+    def run_single_test(self, case: TestCase) -> Dict[str, str]:
+        """Run a single test case and return the result"""
+        pass

core/parallel_runner.py

@@ -0,0 +1,118 @@
+from abc import ABC
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
+from typing import List, Dict, Any, Optional, Union
+import time
+import threading
+from .base_runner import BaseRunner
+from .test_case import TestCase
+from .process_worker import run_test_in_process
+
+class ParallelRunner(BaseRunner):
+    """并行测试运行器基类，支持多线程和多进程执行"""
+    
+    def __init__(self, config_file: str, workspace: Optional[str] = None, 
+                 max_workers: Optional[int] = None, 
+                 execution_mode: str = "thread"):
+        """
+        初始化并行运行器
+        
+        Args:
+            config_file: 配置文件路径
+            workspace: 工作目录
+            max_workers: 最大并发数，默认为CPU核心数
+            execution_mode: 执行模式，'thread'(线程) 或 'process'(进程)
+        """
+        super().__init__(config_file, workspace)
+        self.max_workers = max_workers
+        self.execution_mode = execution_mode
+        self.lock = threading.Lock()  # 用于线程安全的结果更新
+        
+    def run_tests(self) -> bool:
+        """并行运行所有测试用例"""
+        self.load_test_cases()
+        self.results["total"] = len(self.test_cases)
+        
+        print(f"\nStarting parallel test execution... Total tests: {self.results['total']}")
+        print(f"Execution mode: {self.execution_mode}, Max workers: {self.max_workers or 'auto'}")
+        print("=" * 50)
+        
+        start_time = time.time()
+        
+        if self.execution_mode == "process":
+            executor_class = ProcessPoolExecutor
+        else:
+            executor_class = ThreadPoolExecutor
+            
+        with executor_class(max_workers=self.max_workers) as executor:
+            # 提交所有测试任务
+            if self.execution_mode == "process":
+                # 进程模式：使用独立的工作器函数
+                future_to_case = {
+                    executor.submit(
+                        run_test_in_process, 
+                        i, 
+                        {
+                            "name": case.name,
+                            "command": case.command,
+                            "args": case.args,
+                            "expected": case.expected
+                        },
+                        str(self.workspace) if self.workspace else None
+                    ): (i, case) 
+                    for i, case in enumerate(self.test_cases, 1)
+                }
+            else:
+                # 线程模式：使用实例方法
+                future_to_case = {
+                    executor.submit(self._run_test_with_index, i, case): (i, case) 
+                    for i, case in enumerate(self.test_cases, 1)
+                }
+            
+            # 收集结果
+            for future in as_completed(future_to_case):
+                test_index, case = future_to_case[future]
+                try:
+                    result = future.result()
+                    self._update_results(result, test_index, case)
+                except Exception as exc:
+                    error_result = {
+                        "name": case.name,
+                        "status": "failed",
+                        "message": f"Test execution failed: {str(exc)}",
+                        "output": "",
+                        "command": "",
+                        "return_code": None
+                    }
+                    self._update_results(error_result, test_index, case)
+        
+        end_time = time.time()
+        execution_time = end_time - start_time
+        
+        print("\n" + "=" * 50)
+        print(f"Parallel test execution completed in {execution_time:.2f} seconds")
+        print(f"Passed: {self.results['passed']}, Failed: {self.results['failed']}")
+        return self.results["failed"] == 0
+    
+    def _run_test_with_index(self, test_index: int, case: TestCase) -> Dict[str, Any]:
+        """运行单个测试并返回结果（包含索引信息）"""
+        print(f"[Worker] Running test {test_index}: {case.name}")
+        result = self.run_single_test(case)
+        return result
+    
+    def _update_results(self, result: Dict[str, Any], test_index: int, case: TestCase) -> None:
+        """线程安全地更新测试结果"""
+        with self.lock:
+            self.results["details"].append(result)
+            if result["status"] == "passed":
+                self.results["passed"] += 1
+                print(f"✓ Test {test_index} passed: {case.name}")
+            else:
+                self.results["failed"] += 1
+                print(f"✗ Test {test_index} failed: {case.name}")
+                if result["message"]:
+                    print(f"  Error: {result['message']}")
+    
+    def run_tests_sequential(self) -> bool:
+        """回退到顺序执行模式"""
+        print("Falling back to sequential execution...")
+        return super().run_tests() 

core/process_worker.py

@@ -0,0 +1,93 @@
+"""
+进程工作器模块
+用于多进程并行测试执行，避免序列化问题
+"""
+
+import subprocess
+import sys
+from typing import Dict, Any
+from .test_case import TestCase
+from .assertions import Assertions
+
+def run_test_in_process(test_index: int, case_data: Dict[str, Any], workspace: str = None) -> Dict[str, Any]:
+    """
+    在独立进程中运行单个测试用例
+    
+    Args:
+        test_index: 测试索引
+        case_data: 测试用例数据字典
+        workspace: 工作目录
+    
+    Returns:
+        测试结果字典
+    """
+    # 重新创建TestCase对象（避免序列化问题）
+    case = TestCase(
+        name=case_data["name"],
+        command=case_data["command"],
+        args=case_data["args"],
+        expected=case_data["expected"]
+    )
+    
+    # 创建断言对象
+    assertions = Assertions()
+    
+    result = {
+        "name": case.name,
+        "status": "failed",
+        "message": "",
+        "output": "",
+        "command": "",
+        "return_code": None
+    }
+
+    try:
+        command = f"{case.command} {' '.join(case.args)}"
+        result["command"] = command
+        print(f"  [Process Worker {test_index}] Executing command: {command}")
+        
+        process = subprocess.run(
+            command,
+            cwd=workspace if workspace else None,
+            capture_output=True,
+            text=True,
+            check=False,
+            shell=True
+        )
+
+        output = process.stdout + process.stderr
+        result["output"] = output
+        result["return_code"] = process.returncode
+        
+        if output.strip():
+            print(f"  [Process Worker {test_index}] Command output for {case.name}:")
+            for line in output.splitlines():
+                print(f"    {line}")
+
+        # 检查返回码
+        if "return_code" in case.expected:
+            print(f"  [Process Worker {test_index}] Checking return code for {case.name}: {process.returncode} (expected: {case.expected['return_code']})")
+            assertions.return_code_equals(
+                process.returncode,
+                case.expected["return_code"]
+            )
+
+        # 检查输出包含
+        if "output_contains" in case.expected:
+            print(f"  [Process Worker {test_index}] Checking output contains for {case.name}...")
+            for expected_text in case.expected["output_contains"]:
+                assertions.contains(output, expected_text)
+
+        # 检查正则匹配
+        if "output_matches" in case.expected:
+            print(f"  [Process Worker {test_index}] Checking output matches regex for {case.name}...")
+            assertions.matches(output, case.expected["output_matches"])
+
+        result["status"] = "passed"
+        
+    except AssertionError as e:
+        result["message"] = str(e)
+    except Exception as e:
+        result["message"] = f"Execution error: {str(e)}"
+
+    return result 

core/test_case.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+@dataclass
+class TestCase:
+    name: str
+    command: str
+    args: List[str]
+    expected: Dict[str, Any]
+    description: str = ""
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert test case to dictionary format"""
+        print("Convert test case to dictionary format")
+        print(self.command)
+        return {
+            "name": self.name,
+            "command": self.command,
+            "args": self.args,
+            "expected": self.expected
+        }

runners/__init__.py

@@ -0,0 +1,3 @@
+from .json_runner import JSONRunner
+from .yaml_runner import YAMLRunner
+from .parallel_json_runner import ParallelJSONRunner

runners/json_runner.py

@@ -0,0 +1,96 @@
+from typing import Optional
+from ..core.base_runner import BaseRunner
+from ..core.test_case import TestCase
+from ..utils.path_resolver import PathResolver
+import json
+import subprocess
+import sys
+from typing import Dict, Any
+
+class JSONRunner(BaseRunner):
+    def __init__(self, config_file="test_cases.json", workspace: Optional[str] = None):
+        super().__init__(config_file, workspace)
+        self.path_resolver = PathResolver(self.workspace)
+
+    def load_test_cases(self) -> None:
+        """Load test cases from a JSON file."""
+        try:
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+
+            required_fields = ["name", "command", "args", "expected"]
+            for case in config["test_cases"]:
+                if not all(field in case for field in required_fields):
+                    raise ValueError(f"Test case {case.get('name', 'unnamed')} is missing required fields")
+
+                # 使用智能命令解析，正确处理包含空格的路径
+                case["command"] = self.path_resolver.parse_command_string(case["command"])
+                
+                case["args"] = self.path_resolver.resolve_paths(case["args"])
+                self.test_cases.append(TestCase(**case))
+
+            print(f"Successfully loaded {len(self.test_cases)} test cases")
+            # print(self.test_cases)
+        except Exception as e:
+            sys.exit(f"Failed to load configuration file: {str(e)}")
+
+    def run_single_test(self, case: TestCase) -> Dict[str, str]:
+        result = {
+            "name": case.name,
+            "status": "failed",
+            "message": "",
+            "output": "",  # 添加命令输出字段
+            "command": "",  # 添加执行的命令字段
+            "return_code": None  # 添加返回码字段
+        }
+
+        try:
+            command = f"{case.command} {' '.join(case.args)}"
+            result["command"] = command  # 保存执行的命令
+            print(f"  Executing command: {command}")
+            
+            process = subprocess.run(
+                command,
+                cwd=self.workspace if self.workspace else None,
+                capture_output=True,
+                text=True,
+                check=False,
+                shell=True
+            )
+
+            output = process.stdout + process.stderr
+            result["output"] = output  # 保存命令的完整输出
+            result["return_code"] = process.returncode  # 保存返回码
+            
+            if output.strip():
+                print("  Command output:")
+                for line in output.splitlines():
+                    print(f"    {line}")
+
+            # Check return code
+            if "return_code" in case.expected:
+                print(f"  Checking return code: {process.returncode} (expected: {case.expected['return_code']})")
+                self.assertions.return_code_equals(
+                    process.returncode,
+                    case.expected["return_code"]
+                )
+
+            # Check output contains
+            if "output_contains" in case.expected:
+                print("  Checking output contains expected text...")
+                for expected_text in case.expected["output_contains"]:
+                    self.assertions.contains(output, expected_text)
+
+            # Check regex patterns
+            if "output_matches" in case.expected:
+                print("  Checking output matches regex pattern...")
+                self.assertions.matches(output, case.expected["output_matches"])
+
+            result["status"] = "passed"
+            
+        except AssertionError as e:
+            result["message"] = str(e)
+        except Exception as e:
+            result["message"] = f"Execution error: {str(e)}"
+
+        return result

runners/parallel_json_runner.py

@@ -0,0 +1,115 @@
+from typing import Optional, Dict, Any
+from ..core.parallel_runner import ParallelRunner
+from ..core.test_case import TestCase
+from ..utils.path_resolver import PathResolver
+import json
+import subprocess
+import sys
+import threading
+
+class ParallelJSONRunner(ParallelRunner):
+    """并行JSON测试运行器"""
+    
+    def __init__(self, config_file="test_cases.json", workspace: Optional[str] = None,
+                 max_workers: Optional[int] = None, execution_mode: str = "thread"):
+        """
+        初始化并行JSON运行器
+        
+        Args:
+            config_file: JSON配置文件路径
+            workspace: 工作目录
+            max_workers: 最大并发数
+            execution_mode: 执行模式，'thread' 或 'process'
+        """
+        super().__init__(config_file, workspace, max_workers, execution_mode)
+        self.path_resolver = PathResolver(self.workspace)
+        self._print_lock = threading.Lock()  # 用于控制输出顺序
+
+    def load_test_cases(self) -> None:
+        """从JSON文件加载测试用例"""
+        try:
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+
+            required_fields = ["name", "command", "args", "expected"]
+            for case in config["test_cases"]:
+                if not all(field in case for field in required_fields):
+                    raise ValueError(f"Test case {case.get('name', 'unnamed')} is missing required fields")
+
+                case["command"] = self.path_resolver.parse_command_string(case["command"])
+                case["args"] = self.path_resolver.resolve_paths(case["args"])
+                self.test_cases.append(TestCase(**case))
+
+            print(f"Successfully loaded {len(self.test_cases)} test cases")
+        except Exception as e:
+            sys.exit(f"Failed to load configuration file: {str(e)}")
+
+    def run_single_test(self, case: TestCase) -> Dict[str, Any]:
+        """运行单个测试用例（线程安全版本）"""
+        result = {
+            "name": case.name,
+            "status": "failed",
+            "message": "",
+            "output": "",
+            "command": "",
+            "return_code": None
+        }
+
+        try:
+            command = f"{case.command} {' '.join(case.args)}"
+            result["command"] = command
+            
+            # 线程安全的输出
+            with self._print_lock:
+                print(f"  [Worker] Executing command: {command}")
+            
+            process = subprocess.run(
+                command,
+                cwd=self.workspace if self.workspace else None,
+                capture_output=True,
+                text=True,
+                check=False,
+                shell=True
+            )
+
+            output = process.stdout + process.stderr
+            result["output"] = output
+            result["return_code"] = process.returncode
+            
+            # 线程安全的输出
+            if output.strip():
+                with self._print_lock:
+                    print(f"  [Worker] Command output for {case.name}:")
+                    for line in output.splitlines():
+                        print(f"    {line}")
+
+            # 检查返回码
+            if "return_code" in case.expected:
+                with self._print_lock:
+                    print(f"  [Worker] Checking return code for {case.name}: {process.returncode} (expected: {case.expected['return_code']})")
+                self.assertions.return_code_equals(
+                    process.returncode,
+                    case.expected["return_code"]
+                )
+
+            # 检查输出包含
+            if "output_contains" in case.expected:
+                with self._print_lock:
+                    print(f"  [Worker] Checking output contains for {case.name}...")
+                for expected_text in case.expected["output_contains"]:
+                    self.assertions.contains(output, expected_text)
+
+            # 检查正则匹配
+            if "output_matches" in case.expected:
+                with self._print_lock:
+                    print(f"  [Worker] Checking output matches regex for {case.name}...")
+                self.assertions.matches(output, case.expected["output_matches"])
+
+            result["status"] = "passed"
+            
+        except AssertionError as e:
+            result["message"] = str(e)
+        except Exception as e:
+            result["message"] = f"Execution error: {str(e)}"
+
+        return result 

runners/yaml_runner.py

@@ -0,0 +1,93 @@
+from typing import Optional, Dict, Any
+from ..core.base_runner import BaseRunner
+from ..core.test_case import TestCase
+from ..utils.path_resolver import PathResolver
+import subprocess
+import sys
+
+class YAMLRunner(BaseRunner):
+    def __init__(self, config_file="test_cases.yaml", workspace: Optional[str] = None):
+        super().__init__(config_file, workspace)
+        self.path_resolver = PathResolver(self.workspace)
+
+    def load_test_cases(self):
+        """Load test cases from a YAML file."""
+        try:
+            import yaml
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                config = yaml.safe_load(f)
+                
+            required_fields = ["name", "command", "args", "expected"]
+            for case in config["test_cases"]:
+                if not all(field in case for field in required_fields):
+                    raise ValueError(f"Test case {case.get('name', 'unnamed')} is missing required fields")
+                
+                case["command"] = self.path_resolver.parse_command_string(case["command"])
+                case["args"] = self.path_resolver.resolve_paths(case["args"])
+                self.test_cases.append(TestCase(**case))
+                
+            print(f"Successfully loaded {len(self.test_cases)} test cases")
+        except Exception as e:
+            sys.exit(f"Failed to load configuration file: {str(e)}")
+
+    def run_single_test(self, case: TestCase) -> Dict[str, Any]:
+        """Run a single test case and return the result"""
+        result = {
+            "name": case.name,
+            "status": "failed",
+            "message": "",
+            "output": "",
+            "command": "",
+            "return_code": None
+        }
+
+        try:
+            command = f"{case.command} {' '.join(case.args)}"
+            result["command"] = command
+            print(f"  Executing command: {command}")
+            
+            process = subprocess.run(
+                command,
+                cwd=self.workspace if self.workspace else None,
+                capture_output=True,
+                text=True,
+                check=False,
+                shell=True
+            )
+
+            output = process.stdout + process.stderr
+            result["output"] = output
+            result["return_code"] = process.returncode
+            
+            if output.strip():
+                print("  Command output:")
+                for line in output.splitlines():
+                    print(f"    {line}")
+
+            # Check return code
+            if "return_code" in case.expected:
+                print(f"  Checking return code: {process.returncode} (expected: {case.expected['return_code']})")
+                self.assertions.return_code_equals(
+                    process.returncode,
+                    case.expected["return_code"]
+                )
+
+            # Check output contains
+            if "output_contains" in case.expected:
+                print("  Checking output contains expected text...")
+                for expected_text in case.expected["output_contains"]:
+                    self.assertions.contains(output, expected_text)
+
+            # Check regex patterns
+            if "output_matches" in case.expected:
+                print("  Checking output matches regex pattern...")
+                self.assertions.matches(output, case.expected["output_matches"])
+
+            result["status"] = "passed"
+            
+        except AssertionError as e:
+            result["message"] = str(e)
+        except Exception as e:
+            result["message"] = f"Execution error: {str(e)}"
+
+        return result

utils/__init__.py

@@ -0,0 +1,3 @@
+# File: /python-test-framework/python-test-framework/src/utils/__init__.py
+
+# This file is intentionally left blank.

utils/path_resolver.py

@@ -0,0 +1,195 @@
+from pathlib import Path
+from typing import List
+import shlex
+import os
+
+class PathResolver:
+    def __init__(self, workspace: Path):
+        self.workspace = workspace
+
+    def resolve_paths(self, args: List[str]) -> List[str]:
+        resolved_args = []
+        for arg in args:
+            if not arg.startswith("--"):
+                # Only prepend workspace if the path is relative
+                if not Path(arg).is_absolute():
+                    resolved_args.append(str(self.workspace / arg))
+                else:
+                    resolved_args.append(arg)
+            else:
+                resolved_args.append(arg)
+        return resolved_args
+
+    def resolve_command(self, command: str) -> str:
+        """
+        解析命令路径
+        - 系统命令（如echo, ping, dir等）保持原样
+        - 相对路径的可执行文件转换为绝对路径
+        """
+        # 常见的系统命令列表
+        system_commands = {
+            'echo', 'ping', 'dir', 'ls', 'cat', 'grep', 'find', 'sort', 
+            'head', 'tail', 'wc', 'curl', 'wget', 'git', 'python', 'node',
+            'npm', 'pip', 'java', 'javac', 'gcc', 'make', 'cmake', 'docker',
+            'kubectl', 'helm', 'terraform', 'ansible', 'ssh', 'scp', 'rsync'
+        }
+        
+        # 如果是系统命令或绝对路径，保持原样
+        if command in system_commands or Path(command).is_absolute():
+            return command
+        
+        # 否则当作相对路径处理
+        return str(self.workspace / command)
+
+    def parse_command_string(self, command_string: str) -> str:
+        """
+        智能解析命令字符串，正确处理包含空格的路径
+        
+        Args:
+            command_string: 原始命令字符串，如 "python ./script.py" 或 r"C:\\Program Files (x86)\\python.exe script.py"
+            
+        Returns:
+            解析后的完整命令字符串
+        """
+        # 特殊处理：如果命令字符串包含引号，使用shlex解析
+        if '"' in command_string or "'" in command_string:
+            try:
+                # 对于所有系统都使用posix=True来正确处理引号
+                # 这样可以去掉引号，但保留路径内容
+                parts = shlex.split(command_string, posix=True)
+                
+                if not parts:
+                    return command_string
+                
+                # 第一部分是命令，其余是参数
+                command_part = parts[0]
+                remaining_parts = parts[1:]
+                
+                # 解析命令部分（如果是绝对路径，保持原样；否则解析）
+                if Path(command_part).is_absolute():
+                    resolved_command = command_part
+                else:
+                    resolved_command = self.resolve_command(command_part)
+                
+                # 解析参数部分
+                resolved_parts = []
+                for part in remaining_parts:
+                    if part.startswith('-'):
+                        # 选项参数，保持原样
+                        resolved_parts.append(part)
+                    elif ('.' in part or '/' in part or '\\' in part) and not part.isdigit():
+                        # 看起来像文件路径
+                        if not Path(part).is_absolute():
+                            resolved_parts.append(str(self.workspace / part))
+                        else:
+                            resolved_parts.append(part)
+                    else:
+                        # 其他参数，保持原样
+                        resolved_parts.append(part)
+                
+                return f"{resolved_command} {' '.join(resolved_parts)}"
+                
+            except ValueError:
+                # shlex解析失败，回退到简单处理
+                pass
+        
+        # 简单情况：没有引号的命令字符串
+        # 先尝试识别是否以绝对路径开头
+        if self._starts_with_absolute_path(command_string):
+            # 处理以绝对路径开头的命令
+            return self._parse_absolute_path_command(command_string)
+        else:
+            # 普通命令处理
+            parts = command_string.split()
+            if not parts:
+                return command_string
+            
+            if len(parts) == 1:
+                return self.resolve_command(parts[0])
+            else:
+                command_part = parts[0]
+                remaining_parts = parts[1:]
+                
+                resolved_command = self.resolve_command(command_part)
+                resolved_parts = []
+                
+                for part in remaining_parts:
+                    if part.startswith('-'):
+                        resolved_parts.append(part)
+                    elif ('.' in part or '/' in part or '\\' in part) and not part.isdigit():
+                        if not Path(part).is_absolute():
+                            resolved_parts.append(str(self.workspace / part))
+                        else:
+                            resolved_parts.append(part)
+                    else:
+                        resolved_parts.append(part)
+                
+                return f"{resolved_command} {' '.join(resolved_parts)}"
+    
+    def _starts_with_absolute_path(self, command_string: str) -> bool:
+        """检查命令字符串是否以绝对路径开头"""
+        if os.name == 'nt':  # Windows
+            # Windows绝对路径模式：C:\... 或 \\server\...
+            return (len(command_string) >= 3 and 
+                    command_string[1:3] == ':\\') or command_string.startswith('\\\\')
+        else:  # Unix/Linux
+            return command_string.startswith('/')
+    
+    def _parse_absolute_path_command(self, command_string: str) -> str:
+        """解析以绝对路径开头的命令字符串"""
+        # 对于Windows路径，需要特殊处理空格
+        if os.name == 'nt':
+            # 尝试找到第一个.exe或.bat等可执行文件扩展名
+            exe_extensions = ['.exe', '.bat', '.cmd', '.com']
+            
+            for ext in exe_extensions:
+                if ext in command_string:
+                    # 找到可执行文件的结束位置
+                    ext_pos = command_string.find(ext)
+                    if ext_pos != -1:
+                        command_end = ext_pos + len(ext)
+                        command_part = command_string[:command_end]
+                        remaining = command_string[command_end:].strip()
+                        
+                        if remaining:
+                            # 解析剩余参数
+                            remaining_parts = remaining.split()
+                            resolved_parts = []
+                            
+                            for part in remaining_parts:
+                                if part.startswith('-'):
+                                    resolved_parts.append(part)
+                                elif ('.' in part or '/' in part or '\\' in part) and not part.isdigit():
+                                    if not Path(part).is_absolute():
+                                        resolved_parts.append(str(self.workspace / part))
+                                    else:
+                                        resolved_parts.append(part)
+                                else:
+                                    resolved_parts.append(part)
+                            
+                            return f"{command_part} {' '.join(resolved_parts)}"
+                        else:
+                            return command_part
+        
+        # 如果没有找到可执行文件扩展名，回退到简单分割
+        parts = command_string.split()
+        if not parts:
+            return command_string
+        
+        # 假设第一个部分是命令
+        command_part = parts[0]
+        remaining_parts = parts[1:]
+        
+        resolved_parts = []
+        for part in remaining_parts:
+            if part.startswith('-'):
+                resolved_parts.append(part)
+            elif ('.' in part or '/' in part or '\\' in part) and not part.isdigit():
+                if not Path(part).is_absolute():
+                    resolved_parts.append(str(self.workspace / part))
+                else:
+                    resolved_parts.append(part)
+            else:
+                resolved_parts.append(part)
+        
+        return f"{command_part} {' '.join(resolved_parts)}"

utils/report_generator.py

@@ -0,0 +1,68 @@
+class ReportGenerator:
+    def __init__(self, results: dict, file_path: str):
+        self.results = results
+        self.file_path = file_path
+
+    def generate_report(self) -> str:
+        report = "Test Results Summary:\n"
+        report += f"Total Tests: {self.results['total']}\n"
+        report += f"Passed: {self.results['passed']}\n"
+        report += f"Failed: {self.results['failed']}\n\n"
+        
+        report += "Detailed Results:\n"
+        for detail in self.results['details']:
+            status_icon = "✓" if detail['status'] == 'passed' else "✗"
+            report += f"{status_icon} {detail['name']}\n"
+            if detail.get('message'):
+                report += f"   -> {detail['message']}\n"
+        
+        # 添加失败案例的详细输出信息
+        failed_tests = [detail for detail in self.results['details'] if detail['status'] == 'failed']
+        if failed_tests:
+            report += "\n" + "="*50 + "\n"
+            report += "FAILED TEST CASES DETAILS:\n"
+            report += "="*50 + "\n\n"
+            
+            for i, failed_test in enumerate(failed_tests, 1):
+                report += f"{i}. Test: {failed_test['name']}\n"
+                report += "-" * 40 + "\n"
+                
+                # 添加执行的命令
+                if failed_test.get('command'):
+                    report += f"Command: {failed_test['command']}\n"
+                
+                # 添加返回码
+                if failed_test.get('return_code') is not None:
+                    report += f"Return Code: {failed_test['return_code']}\n"
+                
+                # 添加失败原因
+                if failed_test.get('message'):
+                    report += f"Error Message: {failed_test['message']}\n"
+                
+                # 添加命令的完整输出（这是最重要的部分）
+                if failed_test.get('output'):
+                    report += f"\nCommand Output:\n"
+                    report += "=" * 30 + "\n"
+                    report += f"{failed_test['output']}\n"
+                    report += "=" * 30 + "\n"
+                
+                # 添加错误堆栈信息（如果有的话）
+                if failed_test.get('error_trace'):
+                    report += f"Error Trace:\n{failed_test['error_trace']}\n"
+                
+                # 添加执行时间（如果有的话）
+                if failed_test.get('duration'):
+                    report += f"Duration: {failed_test['duration']}s\n"
+                
+                report += "\n"
+        
+        return report
+
+    def save_report(self) -> None:
+        report = self.generate_report()
+        with open(self.file_path, 'w', encoding='utf-8') as f:
+            f.write(report)
+
+    def print_report(self) -> None:
+        report = self.generate_report()
+        print(report)