自动化测试用例生成与优化_02

import os
import random
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
from sklearn.preprocessing import StandardScaler
import pickle
import networkx as nx
import re
from collections import defaultdict

# 设置中文字体
plt.rcParams["font.family"] = ["SimHei", "WenQuanYi Micro Hei", "Heiti TC"]
plt.rcParams["axes.unicode_minus"] = False  # 解决负号显示问题

def extract_code_features(code):
    """从代码中提取特征"""
    features = {
        'lines_of_code': len(code.split('\n')),
        'function_count': len(re.findall(r'def\s+\w+\s*\(', code)),
        'if_count': len(re.findall(r'if\s+', code)),
        'loop_count': len(re.findall(r'for\s+|while\s+', code)),
        'try_except_count': len(re.findall(r'try\s*:', code)),
        'import_count': len(re.findall(r'import\s+|from\s+.*import\s+', code)),
    }
    
    # 计算代码复杂度（简化版）
    complexity = features['function_count'] + features['if_count'] + features['loop_count'] + features['try_except_count']
    features['complexity'] = complexity
    
    return features

def generate_test_cases_from_code(code, num_cases=5):
    """从代码中生成测试用例"""
    test_cases = []
    
    # 提取函数名
    functions = re.findall(r'def\s+(\w+)\s*\((.*?)\):', code)
    
    for func_name, params_str in functions:
        # 解析参数
        params = [p.strip() for p in params_str.split(',') if p.strip()]
        
        # 为每个函数生成多个测试用例
        for i in range(num_cases):
            # 生成测试参数（这里使用随机值作为示例，实际应用中应根据参数类型和业务逻辑生成）
            test_params = {}
            for param in params:
                # 简单的类型推断和值生成
                if 'int' in param or 'number' in param:
                    test_params[param.split(':')[0].strip()] = random.randint(1, 100)
                elif 'str' in param or 'string' in param:
                    test_params[param.split(':')[0].strip()] = f"test_string_{i}"
                elif 'list' in param:
                    test_params[param.split(':')[0].strip()] = [random.randint(1, 100) for _ in range(3)]
                elif 'dict' in param:
                    test_params[param.split(':')[0].strip()] = {'key': f'value_{i}'}
                else:
                    # 默认生成整数
                    test_params[param.split(':')[0].strip()] = random.randint(1, 100)
            
            # 构建测试用例
            test_case = {
                'function_name': func_name,
                'parameters': test_params,
                'expected_result': '待验证',  # 在实际应用中，这里可以基于代码逻辑预测期望结果
                'priority': random.randint(1, 5),  # 1-低优先级，5-高优先级
                'complexity': random.uniform(1, 10)  # 测试用例复杂度
            }
            
            test_cases.append(test_case)
    
    return test_cases

def create_test_case_network(test_cases):
    """创建测试用例网络，用于分析测试用例之间的关系"""
    G = nx.Graph()
    
    # 添加节点
    for i, test_case in enumerate(test_cases):
        G.add_node(i, **test_case)
    
    # 添加边（基于函数名和参数相似度）
    for i in range(len(test_cases)):
        for j in range(i+1, len(test_cases)):
            tc1 = test_cases[i]
            tc2 = test_cases[j]
            
            # 如果测试同一个函数，添加边
            if tc1['function_name'] == tc2['function_name']:
                # 计算参数相似度（简化版）
                shared_params = set(tc1['parameters'].keys()) & set(tc2['parameters'].keys())
                param_similarity = len(shared_params) / max(len(tc1['parameters']), len(tc2['parameters']), 1)
                
                G.add_edge(i, j, weight=param_similarity)
    
    return G

def optimize_test_cases(test_cases, coverage_data, target_coverage=0.9, max_cases=None):
    """优化测试用例集"""
    # 计算每个测试用例的效能分数（发现缺陷数/执行时间）
    for i, test_case in enumerate(test_cases):
        if i < len(coverage_data):
            coverage = coverage_data[i].get('coverage', 0)
            execution_time = coverage_data[i].get('execution_time', 1)
            defects_found = coverage_data[i].get('defects_found', 0)
        else:
            coverage = 0.1  # 默认值
            execution_time = 1  # 默认值
            defects_found = 0  # 默认值
        
        # 计算效能分数
        effectiveness = (defects_found + 1) / (execution_time + 0.1) * coverage
        test_case['effectiveness'] = effectiveness
    
    # 按效能分数排序
    sorted_test_cases = sorted(test_cases, key=lambda x: x['effectiveness'], reverse=True)
    
    # 选择测试用例，直到达到目标覆盖率或最大数量
    selected_cases = []
    total_coverage = 0
    
    for test_case in sorted_test_cases:
        if max_cases and len(selected_cases) >= max_cases:
            break
        
        # 简化的覆盖率累加模型（实际应用中应使用更复杂的模型）
        selected_cases.append(test_case)
        
        # 假设每个测试用例覆盖不同的部分，覆盖率累加
        if max_cases is None:
            total_coverage += test_case.get('coverage', 0.1)
            if total_coverage >= target_coverage:
                break
    
    return selected_cases, total_coverage

def generate_coverage_data(num_cases):
    """生成模拟的覆盖率数据"""
    coverage_data = []
    
    for _ in range(num_cases):
        data = {
            'coverage': random.uniform(0.05, 0.3),  # 5%-30%的覆盖率
            'execution_time': random.uniform(0.1, 5.0),  # 0.1-5秒的执行时间
            'defects_found': random.randint(0, 5)  # 发现0-5个缺陷
        }
        coverage_data.append(data)
    
    return coverage_data

def analyze_test_case_distribution(test_cases):
    """分析测试用例分布情况"""
    # 按功能模块分组
    function_groups = defaultdict(list)
    for test_case in test_cases:
        function_groups[test_case['function_name']].append(test_case)
    
    # 计算每个功能模块的测试用例数量
    function_counts = {func: len(cases) for func, cases in function_groups.items()}
    
    # 绘制分布图
    plt.figure(figsize=(10, 6))
    plt.bar(function_counts.keys(), function_counts.values())
    plt.xlabel('功能模块')
    plt.ylabel('测试用例数量')
    plt.title('测试用例功能分布')
    plt.xticks(rotation=45)
    plt.tight_layout()
    plt.savefig('test_case_distribution.png')
    plt.close()
    
    # 按优先级分布
    priority_counts = defaultdict(int)
    for test_case in test_cases:
        priority_counts[test_case['priority']] += 1
    
    # 绘制优先级分布图
    plt.figure(figsize=(8, 6))
    plt.pie(priority_counts.values(), labels=priority_counts.keys(), autopct='%1.1f%%')
    plt.title('测试用例优先级分布')
    plt.savefig('test_case_priority_distribution.png')
    plt.close()
    
    return function_counts, priority_counts

def export_test_cases(test_cases, filename='test_cases.csv'):
    """导出测试用例到CSV文件"""
    # 转换测试用例格式为DataFrame
    data = []
    for i, test_case in enumerate(test_cases, 1):
        row = {
            'id': f'TC{i:03d}',
            'function_name': test_case['function_name'],
            'parameters': str(test_case['parameters']),
            'expected_result': test_case['expected_result'],
            'priority': test_case['priority'],
            'complexity': test_case.get('complexity', 0),
            'effectiveness': test_case.get('effectiveness', 0)
        }
        data.append(row)
    
    df = pd.DataFrame(data)
    df.to_csv(filename, index=False, encoding='utf-8-sig')
    print(f"测试用例已导出至: {filename}")

# 示例使用
if __name__ == "__main__":
    # 示例代码（用于演示）
    sample_code = """
import math

def calculate_area(shape, **kwargs):
    """计算不同形状的面积"""
    if shape == 'rectangle':
        width = kwargs.get('width', 0)
        height = kwargs.get('height', 0)
        return width * height
    elif shape == 'circle':
        radius = kwargs.get('radius', 0)
        return math.pi * radius * radius
    elif shape == 'triangle':
        base = kwargs.get('base', 0)
        height = kwargs.get('height', 0)
        return 0.5 * base * height
    else:
        raise ValueError(f"不支持的形状: {shape}")

def validate_user_input(username, password, email=None):
    """验证用户输入"""
    if not username or len(username) < 3:
        return False, "用户名长度至少为3个字符"
    
    if not password or len(password) < 8:
        return False, "密码长度至少为8个字符"
    
    if email and '@' not in email:
        return False, "无效的邮箱地址"
    
    return True, "验证通过"

def process_data(data_list, operation='sum'):
    """处理数据列表"""
    if not data_list:
        return 0
    
    if operation == 'sum':
        return sum(data_list)
    elif operation == 'average':
        return sum(data_list) / len(data_list)
    elif operation == 'max':
        return max(data_list)
    elif operation == 'min':
        return min(data_list)
    else:
        raise ValueError(f"不支持的操作: {operation}")
"""
    
    # 从代码中提取特征
    code_features = extract_code_features(sample_code)
    print("代码特征:")
    for key, value in code_features.items():
        print(f"  {key}: {value}")
    
    # 生成测试用例
    print("\n生成测试用例...")
    test_cases = generate_test_cases_from_code(sample_code, num_cases=5)
    print(f"生成了 {len(test_cases)} 个测试用例")
    
    # 生成模拟的覆盖率数据
    coverage_data = generate_coverage_data(len(test_cases))
    
    # 优化测试用例
    print("\n优化测试用例...")
    optimized_cases, total_coverage = optimize_test_cases(test_cases, coverage_data, target_coverage=0.9)
    print(f"优化后测试用例数量: {len(optimized_cases)}, 总覆盖率: {total_coverage:.2f}")
    
    # 分析测试用例分布
    print("\n分析测试用例分布...")
    function_counts, priority_counts = analyze_test_case_distribution(optimized_cases)
    print("按功能模块分布:")
    for func, count in function_counts.items():
        print(f"  {func}: {count}个测试用例")
    
    print("按优先级分布:")
    for priority, count in priority_counts.items():
        print(f"  优先级{priority}: {count}个测试用例")
    
    # 导出测试用例
    export_test_cases(optimized_cases)
    
    print("\n自动化测试用例生成与优化演示完成！")