import asyncio
import time
import logging
from dataclasses import dataclass, field
from typing import Any, Callable, Optional
from enum import Enum

logger = logging.getLogger(__name__)


class TestStatus(Enum):
    PASS = "pass"
    FAIL = "fail"
    SKIP = "skip"
    ERROR = "error"


@dataclass(frozen=True)
class TestCase:
    name: str
    input_data: Any
    expected_output: Any
    description: str = ""
    tags: tuple[str, ...] = ()
    timeout: float = 30.0


@dataclass
class TestResult:
    test_case: TestCase
    status: TestStatus
    actual_output: Any = None
    error: Optional[str] = None
    execution_time: float = 0.0
    assertions_passed: int = 0
    assertions_total: int = 0


class AgentTestSuite:
    def __init__(self, name: str) -> None:
        self.name = name
        self._cases: list[TestCase] = []
        self._results: list[TestResult] = []
        self._setup: Optional[Callable] = None
        self._teardown: Optional[Callable] = None

    def add(self, case: TestCase) -> None:
        self._cases.append(case)

    def setup(self, func: Callable) -> Callable:
        self._setup = func
        return func

    def teardown(self, func: Callable) -> Callable:
        self._teardown = func
        return func

    async def run_one(self, case: TestCase, test_fn: Callable) -> TestResult:
        start = time.monotonic()
        try:
            if self._setup:
                await self._setup()
            actual = await asyncio.wait_for(
                test_fn(case.input_data), timeout=case.timeout,
            )
            passed, total = self._check(actual, case.expected_output)
            status = TestStatus.PASS if passed == total else TestStatus.FAIL
            return TestResult(
                test_case=case, status=status, actual_output=actual,
                execution_time=time.monotonic() - start,
                assertions_passed=passed, assertions_total=total,
            )
        except asyncio.TimeoutError:
            return TestResult(test_case=case, status=TestStatus.ERROR,
                              error="Timeout", execution_time=time.monotonic() - start)
        except Exception as exc:
            return TestResult(test_case=case, status=TestStatus.ERROR,
                              error=str(exc), execution_time=time.monotonic() - start)
        finally:
            if self._teardown:
                await self._teardown()

    async def run_all(self, test_fn: Callable) -> list[TestResult]:
        self._results = []
        for case in self._cases:
            result = await self.run_one(case, test_fn)
            self._results.append(result)
            logger.info("[%s] %s: %s (%.3fs)",
                        self.name, case.name, result.status.value, result.execution_time)
        return self._results

    def summary(self) -> dict[str, Any]:
        total = len(self._results)
        passed = sum(1 for r in self._results if r.status == TestStatus.PASS)
        failed = sum(1 for r in self._results if r.status == TestStatus.FAIL)
        errors = sum(1 for r in self._results if r.status == TestStatus.ERROR)
        return {
            "total": total, "passed": passed, "failed": failed, "errors": errors,
            "pass_rate": passed / total if total else 0.0,
            "avg_time": sum(r.execution_time for r in self._results) / total if total else 0.0,
        }

    @staticmethod
    def _check(actual: Any, expected: Any) -> tuple[int, int]:
        if isinstance(expected, dict) and "__assertions__" in expected:
            assertions = expected["__assertions__"]
            passed = sum(
                1 for a in assertions
                if (a["type"] == "equals" and actual == a["value"])
                or (a["type"] == "contains" and a["value"] in str(actual))
                or (a["type"] == "type" and type(actual).__name__ == a["value"])
            )
            return passed, len(assertions)
        return (1, 1) if actual == expected else (0, 1)

import asyncio
import logging
from dataclasses import dataclass, field
from typing import Any, Optional
from enum import Enum

logger = logging.getLogger(__name__)


class MockBehavior(Enum):
    FIXED = "fixed"
    SEQUENTIAL = "sequential"
    CONDITIONAL = "conditional"


class MockLLMClient:
    def __init__(self, behavior: MockBehavior = MockBehavior.FIXED) -> None:
        self._behavior = behavior
        self._responses: list[str] = []
        self._conditions: dict[str, str] = {}
        self._index = 0
        self.call_count = 0
        self.call_history: list[dict[str, Any]] = []
        self.total_tokens = 0
        self.latency = 0.05

    def set_fixed(self, response: str) -> None:
        self._responses = [response]
        self._behavior = MockBehavior.FIXED

    def set_sequential(self, responses: list[str]) -> None:
        self._responses = responses
        self._behavior = MockBehavior.SEQUENTIAL

    def set_conditional(self, conditions: dict[str, str]) -> None:
        self._conditions = conditions
        self._behavior = MockBehavior.CONDITIONAL

    async def complete(self, prompt: str, **kwargs: Any) -> str:
        self.call_count += 1
        self.call_history.append({"prompt": prompt, **kwargs})
        await asyncio.sleep(self.latency)

        if self._behavior == MockBehavior.FIXED:
            return self._responses[0]
        elif self._behavior == MockBehavior.SEQUENTIAL:
            resp = self._responses[self._index % len(self._responses)]
            self._index += 1
            return resp
        else:
            for cond, resp in self._conditions.items():
                if cond.lower() in prompt.lower():
                    return resp
            return "default response"

    def stats(self) -> dict[str, Any]:
        return {
            "calls": self.call_count,
            "tokens": self.total_tokens,
            "avg_tokens": self.total_tokens / self.call_count if self.call_count else 0,
        }

    def reset(self) -> None:
        self.call_count = 0
        self.call_history.clear()
        self.total_tokens = 0
        self._index = 0

import asyncio
import time
import logging
from dataclasses import dataclass, field
from typing import Any, Callable, Optional

logger = logging.getLogger(__name__)


@dataclass(frozen=True)
class EvalMetric:
    name: str
    compute_fn: Callable[[Any, Any], float]
    weight: float = 1.0


@dataclass
class EvalResult:
    metric_name: str
    score: float
    details: dict
    computation_time: float


class AgentEvaluator:
    def __init__(self) -> None:
        self._metrics: list[EvalMetric] = []
        self._results: list[EvalResult] = []

    def add_metric(self, metric: EvalMetric) -> None:
        self._metrics.append(metric)

    async def evaluate(
        self, agent_fn: Callable, test_data: list[dict[str, Any]],
    ) -> dict[str, Any]:
        self._results = []
        for metric in self._metrics:
            start = time.monotonic()
            scores = []
            for item in test_data:
                try:
                    prediction = await agent_fn(item["input"])
                    scores.append(metric.compute_fn(prediction, item["expected"]))
                except Exception:
                    scores.append(0.0)
            avg = sum(scores) / len(scores) if scores else 0.0
            self._results.append(EvalResult(
                metric_name=metric.name, score=avg,
                details={"samples": len(test_data), "scores": scores},
                computation_time=time.monotonic() - start,
            ))
        return self._aggregate()

    def _aggregate(self) -> dict[str, Any]:
        total_weight = sum(m.weight for m in self._metrics)
        weighted = sum(
            r.score * next(m.weight for m in self._metrics if m.name == r.metric_name)
            for r in self._results
        )
        return {
            "overall_score": weighted / total_weight if total_weight else 0.0,
            "metrics": {r.metric_name: {"score": r.score, "details": r.details} for r in self._results},
            "total_time": sum(r.computation_time for r in self._results),
        }


class MetricComputer:
    @staticmethod
    def accuracy(predictions: list[Any], expected: list[Any]) -> float:
        correct = sum(1 for p, e in zip(predictions, expected) if p == e)
        return correct / len(predictions) if predictions else 0.0

    @staticmethod
    def f1(predictions: list[str], expected: list[str], positive: str = "positive") -> float:
        tp = sum(1 for p, e in zip(predictions, expected) if p == positive and e == positive)
        fp = sum(1 for p, e in zip(predictions, expected) if p == positive and e != positive)
        fn = sum(1 for p, e in zip(predictions, expected) if p != positive and e == positive)
        precision = tp / (tp + fp) if (tp + fp) else 0.0
        recall = tp / (tp + fn) if (tp + fn) else 0.0
        return 2 * precision * recall / (precision + recall) if (precision + recall) else 0.0

    @staticmethod
    def semantic_similarity(text_a: str, text_b: str) -> float:
        words_a = set(text_a.lower().split())
        words_b = set(text_b.lower().split())
        intersection = words_a & words_b
        union = words_a | words_b
        return len(intersection) / len(union) if union else 0.0

import random
import string
from dataclasses import dataclass
from typing import Optional


@dataclass(frozen=True)
class TestDataGenerator:
    seed: Optional[int] = None

    def __post_init__(self) -> None:
        if self.seed is not None:
            random.seed(self.seed)

    def text_samples(self, n: int, min_len: int = 10, max_len: int = 500) -> list[str]:
        return [
            "".join(random.choices(string.ascii_letters + " ", k=random.randint(min_len, max_len)))
            for _ in range(n)
        ]

    def qa_pairs(self, n: int, questions: list[str], answers: list[str]) -> list[dict]:
        return [
            {"question": random.choice(questions), "expected_answer": random.choice(answers)}
            for _ in range(n)
        ]

    def edge_cases(self) -> list[dict[str, str]]:
        return [
            {"input": "", "type": "empty"},
            {"input": " " * 500, "type": "whitespace"},
            {"input": "a" * 10000, "type": "very_long"},
            {"input": "<script>alert('xss')</script>", "type": "xss"},
            {"input": "'; DROP TABLE users;--", "type": "sql_injection"},
            {"input": "测试中文", "type": "unicode"},
            {"input": "null", "type": "null_string"},
            {"input": "undefined", "type": "undefined_string"},
        ]