graph TD
    A[数据层] --> A1(测试日志数据库)
    A --> A2(UI元素特征库)
    A --> A3(历史测试用例库)

    B[AI引擎层] --> B1(YOLO元素识别模型)
    B --> B2(LLM用例生成模型)
    B --> B3(LSTM异常预测模型)

    C[核心功能层] --> C1(智能元素定位)
    C --> C2(自动断言生成)
    C --> C3(场景自适应)

    D[应用层] --> D1(Web测试)
    D --> D2(App测试)
    D --> D3(接口测试)

    A --> B
    B --> C
    C --> D

import cv2
import torch
import numpy as np
from fastapi import FastAPI, UploadFile, File
from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
import uvicorn

# 1. 加载预训练的UI元素识别模型
model = torch.hub.load('ultralytics/yolov5', 'custom', path='ui_element_model.pt')
model.conf = 0.7  # 置信度阈值

app = FastAPI(title="AI Test Framework - Smart Element Locator")

# 2. 元素识别API
@app.post("/locate_element")
async def locate_element(file: UploadFile = File(...), element_type: str = "button"):
    # 读取上传的截图
    contents = await file.read()
    nparr = np.frombuffer(contents, np.uint8)
    img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)

    # 模型预测
    results = model(img)
    predictions = results.pandas().xyxy[0]

    # 筛选目标元素类型
    target_elements = predictions[predictions['name'] == element_type]
    if len(target_elements) == 0:
        return {"status": "error", "message": "Element not found"}

    # 计算元素中心坐标
    element = target_elements.iloc[0]
    x_center = (element['xmin'] + element['xmax']) / 2
    y_center = (element['ymin'] + element['ymax']) / 2

    return {
        "status": "success",
        "element": {
            "type": element_type,
            "coordinates": {"x": x_center, "y": y_center},
            "confidence": float(element['confidence'])
        }
    }

# 3. 测试执行器
class AITestExecutor:
    def __init__(self):
        self.driver = webdriver.Chrome()
        self.action = ActionChains(self.driver)

    def navigate(self, url: str):
        self.driver.get(url)
        self.driver.maximize_window()

    def click_element(self, x: float, y: float):
        self.action.move_by_offset(x, y).click().perform()
        self.action.reset_actions()

    def capture_screenshot(self, path: str = "current_screen.png"):
        self.driver.save_screenshot(path)
        return path

    def close(self):
        self.driver.quit()

# 4. 测试用例示例
if __name__ == "__main__":
    # 启动API服务
    import threading
    threading.Thread(target=lambda: uvicorn.run(app, host="0.0.0.0", port=8000)).start()

    # 执行测试流程
    test_executor = AITestExecutor()
    try:
        # 1. 访问测试页面
        test_executor.navigate("https://example.com/login")

        # 2. 捕获当前截图
        screenshot_path = test_executor.capture_screenshot()

        # 3. 调用AI定位用户名输入框
        import requests
        with open(screenshot_path, 'rb') as f:
            response = requests.post(
                "http://localhost:8000/locate_element",
                files={"file": f},
                data={"element_type": "input_username"}
            )

        if response.json()["status"] == "success":
            coords = response.json()["element"]["coordinates"]

            # 4. 点击并输入用户名
            test_executor.click_element(coords["x"], coords["y"])
            test_executor.driver.switch_to.active_element.send_keys("test_user")

            # 同理定位密码框和登录按钮...
            print("Test step completed successfully")
    finally:
        test_executor.close()

系统角色：
你是一位资深软件测试工程师，精通黑盒测试、白盒测试与自动化测试。请根据需求文档生成完整的测试用例，包含用例ID、测试模块、测试目的、前置条件、测试步骤、预期结果、优先级等字段。

用户需求：
用户登录模块需求：
1. 支持手机号/邮箱两种登录方式
2. 密码输入需显示隐藏切换功能
3. 连续3次登录失败锁定账号10分钟
4. 支持"忘记密码"功能，通过验证码重置

生成要求：
1. 覆盖功能测试、边界测试、异常测试场景
2. 每个测试场景至少包含3个测试用例
3. 用例优先级分为P0（最高）、P1、P2
4. 输出格式为Markdown表格

flowchart LR
    A[数据采集] --> A1(代码仓库接入)
    A --> A2(测试日志采集)
    A --> A3(崩溃日志上传)

    B[预处理] --> B1(代码语法解析)
    B --> B2(日志结构化处理)
    B --> B3(特征提取)

    C[AI检测] --> C1(静态代码分析模型)
    C --> C2(日志异常检测模型)
    C --> C3(图像缺陷识别模型)

    D[缺陷处理] --> D1(自动分类)
    D --> D2(根因定位)
    D --> D3(修复建议生成)

    E[反馈优化] --> E1(模型迭代训练)
    E --> E2(规则库更新)

    A --> B
    B --> C
    C --> D
    D --> E
    E --> A

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

class CodeDefectDetector:
    def __init__(self):
        # 加载预训练的代码缺陷检测模型
        self.model_name = "microsoft/codebert-base"
        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(
            self.model_name,
            num_labels=5  # 5类缺陷：语法错误、空指针、数组越界、内存泄漏、安全漏洞
        )
        self.defect_map = {
            0: "语法错误",
            1: "空指针异常",
            2: "数组越界",
            3: "内存泄漏",
            4: "安全漏洞"
        }

    def detect_defect(self, code: str) -> dict:
        # 代码预处理
        inputs = self.tokenizer(
            code,
            return_tensors="pt",
            truncation=True,
            max_length=512,
            padding="max_length"
        )

        # 模型预测
        with torch.no_grad():
            outputs = self.model(**inputs)
            logits = outputs.logits
            predicted_class_id = torch.argmax(logits, dim=1).item()
            confidence = torch.softmax(logits, dim=1)[0][predicted_class_id].item()

        # 生成检测报告
        return {
            "defect_type": self.defect_map[predicted_class_id],
            "confidence": round(confidence, 4),
            "code_snippet": code,
            "suggestion": self._get_fix_suggestion(predicted_class_id, code)
        }

    def _get_fix_suggestion(self, defect_type: int, code: str) -> str:
        """根据缺陷类型生成修复建议"""
        suggestions = {
            0: "请检查代码语法，重点关注括号匹配、分号使用与关键字拼写",
            1: "建议在使用指针前添加非空判断，例如：if (ptr != NULL) { ... }",
            2: "请确认数组索引范围，避免超出数组长度，建议使用动态边界检查",
            3: "C/C++中需确保malloc分配的内存已free，Java中避免静态集合持有对象引用",
            4: "敏感数据需加密传输，避免SQL注入（使用参数化查询）与XSS攻击（输入过滤）"
        }
        return suggestions.get(defect_type, "请根据代码逻辑进行针对性修复")

# 测试示例
if __name__ == "__main__":
    detector = CodeDefectDetector()

    # 存在空指针缺陷的C代码
    bad_code = """
    #include <stdio.h>
    #include <stdlib.h>

    int main() {
        int *ptr = NULL;
        *ptr = 10;  // 空指针解引用
        printf("Value: %d", *ptr);
        return 0;
    }
    """

    result = detector.detect_defect(bad_code)
    print("=== 代码缺陷检测报告 ===")
    print(f"缺陷类型：{result['defect_type']}")
    print(f"置信度：{result['confidence']}")
    print(f"问题代码：\n{result['code_snippet']}")
    print(f"修复建议：{result['suggestion']}")

=== 代码缺陷检测报告 ===
缺陷类型：空指针异常
置信度：0.9876
问题代码：

    #include <stdio.h>
    #include <stdlib.h>

    int main() {
        int *ptr = NULL;
        *ptr = 10;  // 空指针解引用
        printf("Value: %d", *ptr);
        return 0;
    }

修复建议：建议在使用指针前添加非空判断，例如：if (ptr != NULL) { ... }

import pandas as pd
import numpy as np
from sklearn.ensemble import IsolationForest
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.pipeline import Pipeline
import joblib

class LogAnomalyDetector:
    def __init__(self, contamination=0.05):
        """
        contamination: 异常样本比例（默认5%）
        """
        # 构建日志处理 pipeline
        self.pipeline = Pipeline([
            ("tfidf", TfidfVectorizer(ngram_range=(1, 3), max_features=1000)),
            ("isolation_forest", IsolationForest(
                contamination=contamination,
                random_state=42,
                n_estimators=100
            ))
        ])

    def train(self, log_data: list):
        """训练异常检测模型"""
        self.pipeline.fit(log_data)
        # 保存模型
        joblib.dump(self.pipeline, "log_anomaly_model.pkl")
        print("模型训练完成并保存")

    def detect(self, log_entry: str) -> dict:
        """检测单条日志是否异常"""
        # 加载模型
        model = joblib.load("log_anomaly_model.pkl")
        # 预测（-1表示异常，1表示正常）
        prediction = model.predict([log_entry])[0]
        # 计算异常分数（值越大越异常）
        anomaly_score = -model.decision_function([log_entry])[0]

        return {
            "log_entry": log_entry,
            "is_anomaly": prediction == -1,
            "anomaly_score": round(anomaly_score, 4),
            "confidence": round(1 - anomaly_score if prediction == 1 else anomaly_score, 4)
        }

    def batch_detect(self, log_entries: list) -> list:
        """批量检测日志"""
        return [self.detect(entry) for entry in log_entries]


if __name__ == "__main__":
    # 1. 准备训练数据（正常日志 + 少量异常日志）
    normal_logs = [
        "2024-05-20 10:00:00 [INFO] User login success - UserID: 12345",
        "

import re
import torch
import numpy as np
import pandas as pd
from transformers import AutoTokenizer, AutoModelForSequenceClassification
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, accuracy_score

class IntelligentDefectDetector:
    """智能缺陷检测系统，能够识别代码中的常见缺陷"""

    def __init__(self):
        # 初始化代码缺陷类型映射
        self.defect_types = {
            0: "语法错误",
            1: "空指针异常",
            2: "数组越界",
            3: "内存泄漏",
            4: "安全漏洞",
            5: "逻辑错误"
        }

        # 加载预训练的代码分析模型
        self._load_code_model()

        # 初始化规则库
        self._init_rule_based_detector()

        # 初始化统计学习模型
        self._init_statistical_model()

    def _load_code_model(self):
        """加载基于CodeBERT的代码分类模型"""
        try:
            self.tokenizer = AutoTokenizer.from_pretrained("microsoft/codebert-base")
            self.model = AutoModelForSequenceClassification.from_pretrained(
                "microsoft/codebert-base",
                num_labels=len(self.defect_types)
            )
            print("CodeBERT模型加载成功")
        except Exception as e:
            print(f"模型加载警告: {str(e)}")
            print("将使用基础模型进行检测")
            self.use_fallback_model = True

    def _init_rule_based_detector(self):
        """初始化基于规则的缺陷检测器"""
        # 规则模式 - 针对不同缺陷类型的正则表达式模式
        self.patterns = {
            "空指针异常": [
                r'\*\s*\w+\s*=\s*NULL\s*;.*\*\s*\1\s*=',  # NULL指针赋值
                r'\w+\s*\*\s*\w+\s*;\s*.*\*\s*\2\s*='      # 未初始化指针使用
            ],
            "数组越界": [
                r'for\s*.*;\s*\w+\s*<=\s*\w+\.length\s*;',  # 数组长度比较错误
                r'\[\s*\w+\s*\+\s*\d+\s*\]'                  # 可能的越界访问
            ],
            "内存泄漏": [
                r'malloc\(.*\s*;',                           # malloc后无free
                r'new\s+\w+\s*.*\s*;'                        # new后无delete
            ],
            "安全漏洞": [
                r'SQLiteDatabase\.execSQL',                  # Android SQL注入风险
                r'request\.getParameter\(.*\s*\+'            # 字符串拼接SQL
            ]
        }

    def _init_statistical_model(self):
        """初始化基于统计学习的缺陷检测模型"""
        self.vectorizer = TfidfVectorizer(tokenizer=self._tokenize_code, max_features=1000)
        self.stat_model = RandomForestClassifier(n_estimators=100, random_state=42)

    def _tokenize_code(self, code):
        """代码分词器，将代码转换为适合模型处理的tokens"""
        # 移除注释
        code = re.sub(r'//.*?\n|/\*.*?\*/', '', code, flags=re.DOTALL)
        # 分割标识符和运算符
        tokens = re.findall(r'\w+|[^\w\s]', code)
        return tokens

    def train_statistical_model(self, code_samples, labels):
        """训练统计学习模型"""
        # 特征提取
        X = self.vectorizer.fit_transform(code_samples)
        # 分割训练集和测试集
        X_train, X_test, y_train, y_test = train_test_split(
            X, labels, test_size=0.2, random_state=42
        )
        # 训练模型
        self.stat_model.fit(X_train, y_train)
        # 评估模型
        y_pred = self.stat_model.predict(X_test)
        print("统计模型训练完成，评估结果:")
        print(f"准确率: {accuracy_score(y_test, y_pred):.4f}")
        print(classification_report(y_test, y_pred))
        return self.stat_model

    def _rule_based_detection(self, code):
        """基于规则的缺陷检测"""
        findings = []
        for defect_type, patterns in self.patterns.items():
            for pattern in patterns:
                if re.search(pattern, code, re.IGNORECASE | re.DOTALL):
                    findings.append({
                        "type": defect_type,
                        "method": "规则匹配",
                        "confidence": 0.85,
                        "line_number": self._find_pattern_line(code, pattern)
                    })
        return findings

    def _ml_based_detection(self, code):
        """基于机器学习的缺陷检测"""
        findings = []
        try:
            # 使用CodeBERT模型
            inputs = self.tokenizer(
                code,
                return_tensors="pt",
                truncation=True,
                max_length=512,
                padding="max_length"
            )

            with torch.no_grad():
                outputs = self.model(**inputs)
                logits = outputs.logits
                probs = torch.softmax(logits, dim=1).squeeze()

                # 获取置信度最高的前两种缺陷类型
                top_indices = probs.argsort(descending=True)[:2]

                for idx in top_indices:
                    confidence = probs[idx].item()
                    if confidence > 0.5:  # 只考虑高置信度结果
                        findings.append({
                            "type": self.defect_types[idx.item()],
                            "method": "CodeBERT模型",
                            "confidence": confidence,
                            "line_number": None  # 可通过进一步分析获取
                        })
        except:
            # fallback到统计模型
            code_vec = self.vectorizer.transform([code])
            pred = self.stat_model.predict(code_vec)[0]
            confidence = max(self.stat_model.predict_proba(code_vec)[0])

            findings.append({
                "type": self.defect_types[pred],
                "method": "统计模型",
                "confidence": confidence,
                "line_number": None
            })

        return findings

    def _find_pattern_line(self, code, pattern):
        """查找模式在代码中出现的行号"""
        lines = code.split('\n')
        for i, line in enumerate(lines, 1):
            if re.search(pattern, line, re.IGNORECASE):
                return i
        return None

    def detect_defects(self, code, code_language="java"):
        """综合检测代码中的缺陷"""
        # 1. 基于规则的检测
        rule_findings = self._rule_based_detection(code)

        # 2. 基于机器学习的检测
        ml_findings = self._ml_based_detection(code)

        # 3. 合并结果，去重并按置信度排序
        all_findings = rule_findings + ml_findings

        # 去重 - 同一类型同一行的缺陷只保留高置信度的
        unique_findings = {}
        for finding in all_findings:
            key = f"{finding['type']}_{finding['line_number'] or 'unknown'}"
            if key not in unique_findings or finding['confidence'] > unique_findings[key]['confidence']:
                unique_findings[key] = finding

        # 按置信度排序
        sorted_findings = sorted(unique_findings.values(), key=lambda x: x['confidence'], reverse=True)

        # 生成修复建议
        for finding in sorted_findings:
            finding['suggestion'] = self._generate_suggestion(finding['type'])

        return sorted_findings

    def _generate_suggestion(self, defect_type):
        """根据缺陷类型生成修复建议"""
        suggestions = {
            "语法错误": "请检查代码语法，确保关键字正确、括号匹配且标点符号使用正确。",
            "空指针异常": "在使用指针或对象前添加非空检查，例如: if (obj != null) { ... }",
            "数组越界": "确保数组访问索引在有效范围内，使用数组长度作为边界条件。",
            "内存泄漏": "对于动态分配的内存，确保在使用后正确释放资源，如C++中的delete或Java中的try-with-resources。",
            "安全漏洞": "避免直接拼接SQL语句，使用参数化查询；对用户输入进行严格验证和过滤。",
            "逻辑错误": "检查条件判断和循环逻辑，考虑边界情况和异常场景，添加必要的日志进行调试。"
        }
        return suggestions.get(defect_type, "需要进一步分析代码以确定修复方案。")

# 示例使用
if __name__ == "__main__":
    # 创建检测器实例
    detector = IntelligentDefectDetector()

    # 示例1: 含有空指针异常的代码
    problematic_code1 = """
    public class Example {
        public static void main(String[] args) {
            String data = null;
            System.out.println("Length: " + data.length());
        }
    }
    """

    # 示例2: 含有SQL注入风险的代码
    problematic_code2 = """
    public class UserDAO {
        public User getUser(String username) {
            String sql = "SELECT * FROM users WHERE username = '" + username + "'";
            // 执行SQL查询...
            return null;
        }
    }
    """

    # 示例3: 含有数组越界的C代码
    problematic_code3 = """
    #include <stdio.h>

    int main() {
        int arr[5] = {1, 2, 3, 4, 5};
        for (int i = 0; i <= 5; i++) {
            printf("%d\n", arr[i]);
        }
        return 0;
    }
    """

    # 检测代码缺陷
    print("=== 代码1检测结果 ===")
    results1 = detector.detect_defects(problematic_code1)
    for i, result in enumerate(results1, 1):
        print(f"{i}. 缺陷类型: {result['type']}")
        print(f"   检测方法: {result['method']}")
        print(f"   置信度: {result['confidence']:.4f}")
        if result['line_number']:
            print(f"   位置: 第{result['line_number']}行")
        print(f"   修复建议: {result['suggestion']}\n")

    print("=== 代码2检测结果 ===")
    results2 = detector.detect_defects(problematic_code2)
    for i, result in enumerate(results2, 1):
        print(f"{i}. 缺陷类型: {result['type']}")
        print(f"   检测方法: {result['method']}")
        print(f"   置信度: {result['confidence']:.4f}")
        if result['line_number']:
            print(f"   位置: 第{result['line_number']}行")
        print(f"   修复建议: {result['suggestion']}\n")