1039 lines
35 KiB
Python
1039 lines
35 KiB
Python
"""
|
||
Description : Quality Evaluation Layer (Layer 3)
|
||
- Diversity Evaluator (4-dimension)
|
||
- Semantic Coverage Calculator
|
||
- Test Case Quality Scorer
|
||
Author : CGA Enhancement Project
|
||
Time : 2026/03/16
|
||
"""
|
||
|
||
import re
|
||
import logging
|
||
import hashlib
|
||
import json
|
||
from typing import List, Dict, Optional, Any, Tuple, Set
|
||
from dataclasses import dataclass, field
|
||
from enum import Enum
|
||
from collections import defaultdict
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
# ============================================================================
|
||
# 配置常量
|
||
# ============================================================================
|
||
|
||
class QualityConfig:
|
||
"""质量评估配置"""
|
||
|
||
# 多样性评估权重
|
||
SEQUENCE_DIVERSITY_WEIGHT = 0.30 # 输入序列多样性权重
|
||
SEMANTIC_VECTOR_WEIGHT = 0.25 # 语义向量多样性权重
|
||
EXECUTION_PATH_WEIGHT = 0.25 # 执行路径多样性权重
|
||
FUNCTION_COVERAGE_WEIGHT = 0.20 # 功能覆盖多样性权重
|
||
|
||
# 多样性阈值
|
||
MIN_DIVERSITY_THRESHOLD = 0.1 # 最低多样性阈值
|
||
HIGH_DIVERSITY_THRESHOLD = 0.7 # 高多样性阈值
|
||
|
||
# 语义覆盖率阈值
|
||
SEMANTIC_COVERAGE_TARGET = 0.85 # 目标语义覆盖率
|
||
|
||
# 编辑距离配置
|
||
MIN_EDIT_DISTANCE = 3 # 最小编辑距离要求
|
||
|
||
# 相似度阈值
|
||
SIMILARITY_THRESHOLD = 0.8 # 相似度阈值（超过此值认为相似）
|
||
|
||
|
||
# ============================================================================
|
||
# 数据结构定义
|
||
# ============================================================================
|
||
|
||
class DiversityDimension(Enum):
|
||
"""多样性维度枚举"""
|
||
SEQUENCE = "sequence" # 输入序列多样性
|
||
SEMANTIC_VECTOR = "semantic" # 语义向量多样性
|
||
EXECUTION_PATH = "path" # 执行路径多样性
|
||
FUNCTION_COVERAGE = "function" # 功能覆盖多样性
|
||
|
||
|
||
@dataclass
|
||
class DiversityScore:
|
||
"""
|
||
多样性评分
|
||
|
||
Attributes:
|
||
sequence_diversity: 输入序列多样性得分
|
||
semantic_diversity: 语义向量多样性得分
|
||
path_diversity: 执行路径多样性得分
|
||
function_diversity: 功能覆盖多样性得分
|
||
overall_score: 综合多样性得分
|
||
details: 详细信息
|
||
"""
|
||
sequence_diversity: float = 0.0
|
||
semantic_diversity: float = 0.0
|
||
path_diversity: float = 0.0
|
||
function_diversity: float = 0.0
|
||
overall_score: float = 0.0
|
||
details: Dict[str, Any] = field(default_factory=dict)
|
||
|
||
def calculate_overall(self) -> float:
|
||
"""计算综合多样性得分"""
|
||
self.overall_score = (
|
||
QualityConfig.SEQUENCE_DIVERSITY_WEIGHT * self.sequence_diversity +
|
||
QualityConfig.SEMANTIC_VECTOR_WEIGHT * self.semantic_diversity +
|
||
QualityConfig.EXECUTION_PATH_WEIGHT * self.path_diversity +
|
||
QualityConfig.FUNCTION_COVERAGE_WEIGHT * self.function_diversity
|
||
)
|
||
return self.overall_score
|
||
|
||
def to_dict(self) -> Dict[str, Any]:
|
||
"""转换为字典"""
|
||
return {
|
||
'sequence_diversity': round(self.sequence_diversity, 4),
|
||
'semantic_diversity': round(self.semantic_diversity, 4),
|
||
'path_diversity': round(self.path_diversity, 4),
|
||
'function_diversity': round(self.function_diversity, 4),
|
||
'overall_score': round(self.overall_score, 4),
|
||
'details': self.details
|
||
}
|
||
|
||
|
||
@dataclass
|
||
class SemanticCoverageResult:
|
||
"""
|
||
语义覆盖率结果
|
||
|
||
Attributes:
|
||
total_function_points: 总功能点数
|
||
covered_function_points: 已覆盖功能点数
|
||
semantic_coverage: 语义覆盖率
|
||
coverage_by_type: 按类型统计的覆盖率
|
||
uncovered_important: 未覆盖的高重要性功能点
|
||
"""
|
||
total_function_points: int = 0
|
||
covered_function_points: int = 0
|
||
semantic_coverage: float = 0.0
|
||
coverage_by_type: Dict[str, float] = field(default_factory=dict)
|
||
uncovered_important: List[Dict[str, Any]] = field(default_factory=list)
|
||
|
||
def to_dict(self) -> Dict[str, Any]:
|
||
"""转换为字典"""
|
||
return {
|
||
'total_function_points': self.total_function_points,
|
||
'covered_function_points': self.covered_function_points,
|
||
'semantic_coverage': round(self.semantic_coverage, 4),
|
||
'coverage_by_type': self.coverage_by_type,
|
||
'uncovered_important': self.uncovered_important
|
||
}
|
||
|
||
|
||
@dataclass
|
||
class FunctionCoverageState:
|
||
"""
|
||
功能点覆盖状态
|
||
|
||
Attributes:
|
||
name: 功能点名称
|
||
fp_type: 功能点类型
|
||
importance: 重要性评分
|
||
covered: 是否已覆盖
|
||
covered_by: 覆盖该功能点的测试用例ID列表
|
||
last_check_iteration: 最后检查的迭代次数
|
||
"""
|
||
name: str
|
||
fp_type: str
|
||
importance: float
|
||
covered: bool = False
|
||
covered_by: List[str] = field(default_factory=list)
|
||
last_check_iteration: int = 0
|
||
|
||
|
||
# ============================================================================
|
||
# 编辑距离计算器
|
||
# ============================================================================
|
||
|
||
class EditDistanceCalculator:
|
||
"""编辑距离计算器"""
|
||
|
||
@staticmethod
|
||
def levenshtein_distance(s1: str, s2: str) -> int:
|
||
"""
|
||
计算Levenshtein编辑距离
|
||
|
||
Args:
|
||
s1: 字符串1
|
||
s2: 字符串2
|
||
|
||
Returns:
|
||
编辑距离
|
||
"""
|
||
if len(s1) < len(s2):
|
||
return EditDistanceCalculator.levenshtein_distance(s2, s1)
|
||
|
||
if len(s2) == 0:
|
||
return len(s1)
|
||
|
||
previous_row = range(len(s2) + 1)
|
||
for i, c1 in enumerate(s1):
|
||
current_row = [i + 1]
|
||
for j, c2 in enumerate(s2):
|
||
# 插入、删除、替换
|
||
insertions = previous_row[j + 1] + 1
|
||
deletions = current_row[j] + 1
|
||
substitutions = previous_row[j] + (c1 != c2)
|
||
current_row.append(min(insertions, deletions, substitutions))
|
||
previous_row = current_row
|
||
|
||
return previous_row[-1]
|
||
|
||
@staticmethod
|
||
def normalized_distance(s1: str, s2: str) -> float:
|
||
"""
|
||
计算归一化的编辑距离 (0-1范围)
|
||
|
||
Args:
|
||
s1: 字符串1
|
||
s2: 字符串2
|
||
|
||
Returns:
|
||
归一化编辑距离 (0表示相同，1表示完全不同)
|
||
"""
|
||
if not s1 and not s2:
|
||
return 0.0
|
||
max_len = max(len(s1), len(s2))
|
||
if max_len == 0:
|
||
return 0.0
|
||
distance = EditDistanceCalculator.levenshtein_distance(s1, s2)
|
||
return distance / max_len
|
||
|
||
@staticmethod
|
||
def similarity(s1: str, s2: str) -> float:
|
||
"""
|
||
计算相似度 (1 - 归一化编辑距离)
|
||
|
||
Args:
|
||
s1: 字符串1
|
||
s2: 字符串2
|
||
|
||
Returns:
|
||
相似度 (1表示相同，0表示完全不同)
|
||
"""
|
||
return 1.0 - EditDistanceCalculator.normalized_distance(s1, s2)
|
||
|
||
|
||
# ============================================================================
|
||
# 序列特征提取器
|
||
# ============================================================================
|
||
|
||
class SequenceFeatureExtractor:
|
||
"""序列特征提取器"""
|
||
|
||
@staticmethod
|
||
def extract_features(code: str) -> Dict[str, Any]:
|
||
"""
|
||
从代码中提取序列特征
|
||
|
||
Args:
|
||
code: 测试代码
|
||
|
||
Returns:
|
||
特征字典
|
||
"""
|
||
features = {
|
||
'signal_assignments': [], # 信号赋值序列
|
||
'delay_patterns': [], # 延时模式
|
||
'control_structures': [], # 控制结构
|
||
'signal_values': {}, # 信号值映射
|
||
'operation_sequence': [], # 操作序列
|
||
'code_hash': '' # 代码哈希
|
||
}
|
||
|
||
# 提取信号赋值
|
||
assign_pattern = r'(\w+)\s*=\s*([^;]+);'
|
||
for match in re.finditer(assign_pattern, code):
|
||
signal = match.group(1)
|
||
value = match.group(2).strip()
|
||
features['signal_assignments'].append((signal, value))
|
||
if signal not in features['signal_values']:
|
||
features['signal_values'][signal] = []
|
||
features['signal_values'][signal].append(value)
|
||
|
||
# 提取延时模式
|
||
delay_pattern = r'#(\d+)'
|
||
delays = [int(d) for d in re.findall(delay_pattern, code)]
|
||
features['delay_patterns'] = delays
|
||
|
||
# 提取repeat循环
|
||
repeat_pattern = r'repeat\s*\(\s*(\d+)\s*\)'
|
||
repeats = [int(r) for r in re.findall(repeat_pattern, code)]
|
||
features['control_structures'].extend([('repeat', r) for r in repeats])
|
||
|
||
# 提取posedge/negedge
|
||
edge_pattern = r'@(?:posedge|negedge)\s+(\w+)'
|
||
edges = re.findall(edge_pattern, code)
|
||
features['control_structures'].extend([('edge', e) for e in edges])
|
||
|
||
# 构建操作序列
|
||
all_operations = []
|
||
|
||
# 按位置排序的所有操作
|
||
for match in re.finditer(r'((?:\w+\s*=\s*[^;]+;)|(?:#\d+;)|(?:repeat\s*\(\d+\)[^;]+;)|(?:@\([^)]+\)))', code):
|
||
all_operations.append(match.group(1).strip())
|
||
|
||
features['operation_sequence'] = all_operations
|
||
|
||
# 计算代码哈希
|
||
normalized_code = re.sub(r'\s+', ' ', code).strip()
|
||
features['code_hash'] = hashlib.md5(normalized_code.encode()).hexdigest()[:16]
|
||
|
||
return features
|
||
|
||
@staticmethod
|
||
def extract_signal_sequence(code: str, signals: List[str] = None) -> List[Tuple[str, str, str]]:
|
||
"""
|
||
提取信号赋值序列
|
||
|
||
Args:
|
||
code: 测试代码
|
||
signals: 关注的信号列表（可选）
|
||
|
||
Returns:
|
||
(信号名, 值, 上下文) 元组列表
|
||
"""
|
||
sequences = []
|
||
|
||
# 按行处理，保持上下文
|
||
lines = code.split('\n')
|
||
context = ""
|
||
|
||
for line in lines:
|
||
stripped = line.strip()
|
||
|
||
# 更新上下文
|
||
if stripped.startswith('//'):
|
||
context = stripped
|
||
continue
|
||
|
||
# 提取赋值
|
||
assign_match = re.match(r'(\w+)\s*=\s*([^;]+);', stripped)
|
||
if assign_match:
|
||
signal = assign_match.group(1)
|
||
value = assign_match.group(2).strip()
|
||
|
||
# 如果指定了信号列表，只提取关注的信号
|
||
if signals is None or signal in signals:
|
||
sequences.append((signal, value, context))
|
||
|
||
return sequences
|
||
|
||
|
||
# ============================================================================
|
||
# 多样性评估器
|
||
# ============================================================================
|
||
|
||
class DiversityEvaluator:
|
||
"""
|
||
多样性评估器
|
||
|
||
四维度多样性评估：
|
||
1. 输入序列多样性：计算与已有序列的编辑距离
|
||
2. 语义向量多样性：计算代码特征向量的相似度
|
||
3. 执行路径多样性：计算新覆盖代码行的比例
|
||
4. 功能覆盖多样性：计算新覆盖功能点的比例
|
||
"""
|
||
|
||
def __init__(self):
|
||
"""初始化多样性评估器"""
|
||
self.history: List[Dict[str, Any]] = []
|
||
self.feature_extractor = SequenceFeatureExtractor()
|
||
self.edit_distance_calc = EditDistanceCalculator()
|
||
|
||
def add_to_history(self,
|
||
code: str,
|
||
covered_lines: Set[int] = None,
|
||
covered_functions: List[str] = None,
|
||
test_id: str = ""):
|
||
"""
|
||
添加测试用例到历史记录
|
||
|
||
Args:
|
||
code: 测试代码
|
||
covered_lines: 覆盖的代码行
|
||
covered_functions: 覆盖的功能点列表
|
||
test_id: 测试用例ID
|
||
"""
|
||
features = self.feature_extractor.extract_features(code)
|
||
|
||
record = {
|
||
'test_id': test_id,
|
||
'code': code,
|
||
'features': features,
|
||
'covered_lines': covered_lines or set(),
|
||
'covered_functions': covered_functions or [],
|
||
'code_hash': features['code_hash']
|
||
}
|
||
|
||
self.history.append(record)
|
||
|
||
def evaluate(self,
|
||
new_code: str,
|
||
new_covered_lines: Set[int] = None,
|
||
new_covered_functions: List[str] = None) -> DiversityScore:
|
||
"""
|
||
评估新测试用例的多样性
|
||
|
||
Args:
|
||
new_code: 新测试代码
|
||
new_covered_lines: 新覆盖的代码行
|
||
new_covered_functions: 新覆盖的功能点列表
|
||
|
||
Returns:
|
||
多样性评分
|
||
"""
|
||
score = DiversityScore()
|
||
|
||
if not self.history:
|
||
# 第一个测试用例，给予最高多样性
|
||
score.sequence_diversity = 1.0
|
||
score.semantic_diversity = 1.0
|
||
score.path_diversity = 1.0
|
||
score.function_diversity = 1.0
|
||
score.calculate_overall()
|
||
score.details = {'reason': 'first_test_case'}
|
||
return score
|
||
|
||
# 提取新代码特征
|
||
new_features = self.feature_extractor.extract_features(new_code)
|
||
new_covered_lines = new_covered_lines or set()
|
||
new_covered_functions = new_covered_functions or []
|
||
|
||
# 1. 计算输入序列多样性
|
||
score.sequence_diversity = self._evaluate_sequence_diversity(new_code, new_features)
|
||
|
||
# 2. 计算语义向量多样性
|
||
score.semantic_diversity = self._evaluate_semantic_diversity(new_features)
|
||
|
||
# 3. 计算执行路径多样性
|
||
score.path_diversity = self._evaluate_path_diversity(new_covered_lines)
|
||
|
||
# 4. 计算功能覆盖多样性
|
||
score.function_diversity = self._evaluate_function_diversity(new_covered_functions)
|
||
|
||
# 计算综合得分
|
||
score.calculate_overall()
|
||
|
||
# 添加详细信息
|
||
score.details = {
|
||
'history_size': len(self.history),
|
||
'new_code_hash': new_features['code_hash'],
|
||
'signal_count': len(new_features['signal_values']),
|
||
'operation_count': len(new_features['operation_sequence'])
|
||
}
|
||
|
||
return score
|
||
|
||
def _evaluate_sequence_diversity(self, new_code: str, new_features: Dict) -> float:
|
||
"""评估输入序列多样性"""
|
||
if not self.history:
|
||
return 1.0
|
||
|
||
# 提取操作序列
|
||
new_ops = new_features['operation_sequence']
|
||
|
||
# 计算与历史中所有测试的最小相似度（即最大差异）
|
||
max_distance = 0.0
|
||
|
||
for record in self.history[-10:]: # 只比较最近10个
|
||
hist_ops = record['features']['operation_sequence']
|
||
|
||
# 将操作序列转换为字符串计算编辑距离
|
||
new_ops_str = ' '.join(new_ops)
|
||
hist_ops_str = ' '.join(hist_ops)
|
||
|
||
similarity = self.edit_distance_calc.similarity(new_ops_str, hist_ops_str)
|
||
distance = 1.0 - similarity
|
||
max_distance = max(max_distance, distance)
|
||
|
||
return max_distance
|
||
|
||
def _evaluate_semantic_diversity(self, new_features: Dict) -> float:
|
||
"""评估语义向量多样性"""
|
||
if not self.history:
|
||
return 1.0
|
||
|
||
# 构建特征向量
|
||
new_vector = self._build_feature_vector(new_features)
|
||
|
||
# 计算与历史特征向量的最小相似度
|
||
max_distance = 0.0
|
||
|
||
for record in self.history[-10:]:
|
||
hist_vector = self._build_feature_vector(record['features'])
|
||
similarity = self._cosine_similarity(new_vector, hist_vector)
|
||
distance = 1.0 - similarity
|
||
max_distance = max(max_distance, distance)
|
||
|
||
return max_distance
|
||
|
||
def _evaluate_path_diversity(self, new_covered_lines: Set[int]) -> float:
|
||
"""评估执行路径多样性"""
|
||
if not self.history:
|
||
return 1.0
|
||
|
||
if not new_covered_lines:
|
||
return 0.0
|
||
|
||
# 计算历史覆盖的并集
|
||
all_covered = set()
|
||
for record in self.history:
|
||
all_covered.update(record['covered_lines'])
|
||
|
||
# 计算新覆盖的行
|
||
new_lines = new_covered_lines - all_covered
|
||
|
||
if not new_covered_lines:
|
||
return 0.0
|
||
|
||
# 新覆盖比例
|
||
novelty_ratio = len(new_lines) / len(new_covered_lines)
|
||
return novelty_ratio
|
||
|
||
def _evaluate_function_diversity(self, new_covered_functions: List[str]) -> float:
|
||
"""评估功能覆盖多样性"""
|
||
if not self.history:
|
||
return 1.0
|
||
|
||
if not new_covered_functions:
|
||
return 0.0
|
||
|
||
# 计算历史覆盖的功能点并集
|
||
all_covered = set()
|
||
for record in self.history:
|
||
all_covered.update(record['covered_functions'])
|
||
|
||
# 计算新覆盖的功能点
|
||
new_functions = set(new_covered_functions) - all_covered
|
||
|
||
if not new_covered_functions:
|
||
return 0.0
|
||
|
||
# 新覆盖比例
|
||
novelty_ratio = len(new_functions) / len(new_covered_functions)
|
||
return novelty_ratio
|
||
|
||
def _build_feature_vector(self, features: Dict) -> Dict[str, float]:
|
||
"""构建特征向量"""
|
||
vector = {}
|
||
|
||
# 信号数量
|
||
vector['signal_count'] = len(features['signal_values'])
|
||
|
||
# 操作数量
|
||
vector['operation_count'] = len(features['operation_sequence'])
|
||
|
||
# 延时数量
|
||
vector['delay_count'] = len(features['delay_patterns'])
|
||
|
||
# 延时总和
|
||
vector['delay_sum'] = sum(features['delay_patterns'])
|
||
|
||
# 控制结构数量
|
||
vector['control_count'] = len(features['control_structures'])
|
||
|
||
# repeat循环数量
|
||
repeat_count = sum(1 for c in features['control_structures'] if c[0] == 'repeat')
|
||
vector['repeat_count'] = repeat_count
|
||
|
||
# 边沿等待数量
|
||
edge_count = sum(1 for c in features['control_structures'] if c[0] == 'edge')
|
||
vector['edge_count'] = edge_count
|
||
|
||
# 赋值数量
|
||
vector['assignment_count'] = len(features['signal_assignments'])
|
||
|
||
return vector
|
||
|
||
def _cosine_similarity(self, v1: Dict[str, float], v2: Dict[str, float]) -> float:
|
||
"""计算余弦相似度"""
|
||
# 获取所有键
|
||
all_keys = set(v1.keys()) | set(v2.keys())
|
||
|
||
if not all_keys:
|
||
return 0.0
|
||
|
||
# 计算点积和模
|
||
dot_product = 0.0
|
||
norm1 = 0.0
|
||
norm2 = 0.0
|
||
|
||
for key in all_keys:
|
||
val1 = v1.get(key, 0.0)
|
||
val2 = v2.get(key, 0.0)
|
||
dot_product += val1 * val2
|
||
norm1 += val1 * val1
|
||
norm2 += val2 * val2
|
||
|
||
if norm1 == 0 or norm2 == 0:
|
||
return 0.0
|
||
|
||
return dot_product / (norm1 ** 0.5 * norm2 ** 0.5)
|
||
|
||
def get_diversity_statistics(self) -> Dict[str, Any]:
|
||
"""获取多样性统计信息"""
|
||
# if not self.history:
|
||
# return {
|
||
# 'total_tests': 0,
|
||
# 'unique_hashes': 0,
|
||
# 'avg_diversity': 0.0
|
||
# }
|
||
if not self.history:
|
||
return {
|
||
'total_tests': 0,
|
||
'unique_hashes': 0,
|
||
'avg_diversity': 0.0,
|
||
'duplicate_ratio': 0.0 # ✅ 添加缺失的键
|
||
}
|
||
|
||
unique_hashes = len(set(r['code_hash'] for r in self.history))
|
||
|
||
return {
|
||
'total_tests': len(self.history),
|
||
'unique_hashes': unique_hashes,
|
||
'duplicate_ratio': 1.0 - (unique_hashes / len(self.history)) if self.history else 0.0
|
||
}
|
||
|
||
|
||
# ============================================================================
|
||
# 语义覆盖率计算器
|
||
# ============================================================================
|
||
|
||
class SemanticCoverageCalculator:
|
||
"""
|
||
语义覆盖率计算器
|
||
|
||
计算基于功能点重要性的语义覆盖率：
|
||
语义覆盖率 = Σ(已覆盖功能点重要性) / Σ(所有功能点重要性)
|
||
"""
|
||
|
||
def __init__(self, function_points: List[Dict[str, Any]] = None):
|
||
"""
|
||
初始化语义覆盖率计算器
|
||
|
||
Args:
|
||
function_points: 功能点列表
|
||
"""
|
||
self.function_points: Dict[str, FunctionCoverageState] = {}
|
||
self.total_importance = 0.0
|
||
self.covered_importance = 0.0
|
||
|
||
if function_points:
|
||
self.initialize(function_points)
|
||
|
||
def initialize(self, function_points: List[Dict[str, Any]]) -> Dict[str, Any]:
|
||
"""
|
||
初始化功能点覆盖状态
|
||
|
||
Args:
|
||
function_points: 功能点列表
|
||
|
||
Returns:
|
||
初始化结果
|
||
"""
|
||
self.function_points.clear()
|
||
self.total_importance = 0.0
|
||
self.covered_importance = 0.0
|
||
|
||
for fp in function_points:
|
||
name = fp.get('name', '')
|
||
fp_type = fp.get('type', 'unknown')
|
||
importance = fp.get('importance', 0.0)
|
||
|
||
self.function_points[name] = FunctionCoverageState(
|
||
name=name,
|
||
fp_type=fp_type,
|
||
importance=importance,
|
||
covered=False,
|
||
covered_by=[],
|
||
last_check_iteration=0
|
||
)
|
||
|
||
self.total_importance += importance
|
||
|
||
return {
|
||
'total_function_points': len(self.function_points),
|
||
'total_importance': self.total_importance
|
||
}
|
||
|
||
def update_coverage(self,
|
||
covered_lines: Set[int] = None,
|
||
covered_functions: List[str] = None,
|
||
test_id: str = "",
|
||
iteration: int = 0) -> SemanticCoverageResult:
|
||
"""
|
||
更新功能点覆盖状态
|
||
|
||
Args:
|
||
covered_lines: 覆盖的代码行
|
||
covered_functions: 覆盖的功能点名称列表
|
||
test_id: 测试用例ID
|
||
iteration: 当前迭代次数
|
||
|
||
Returns:
|
||
语义覆盖率结果
|
||
"""
|
||
# 更新覆盖状态
|
||
if covered_functions:
|
||
for func_name in covered_functions:
|
||
if func_name in self.function_points:
|
||
fp = self.function_points[func_name]
|
||
if not fp.covered:
|
||
fp.covered = True
|
||
fp.covered_by.append(test_id)
|
||
fp.last_check_iteration = iteration
|
||
self.covered_importance += fp.importance
|
||
|
||
return self.calculate_coverage()
|
||
|
||
def calculate_coverage(self) -> SemanticCoverageResult:
|
||
"""
|
||
计算当前语义覆盖率
|
||
|
||
Returns:
|
||
语义覆盖率结果
|
||
"""
|
||
result = SemanticCoverageResult()
|
||
|
||
result.total_function_points = len(self.function_points)
|
||
result.covered_function_points = sum(1 for fp in self.function_points.values() if fp.covered)
|
||
|
||
# 计算语义覆盖率
|
||
if self.total_importance > 0:
|
||
result.semantic_coverage = self.covered_importance / self.total_importance
|
||
|
||
# 按类型统计
|
||
type_stats = defaultdict(lambda: {'total': 0, 'covered': 0, 'importance': 0.0, 'covered_importance': 0.0})
|
||
|
||
for fp in self.function_points.values():
|
||
type_stats[fp.fp_type]['total'] += 1
|
||
type_stats[fp.fp_type]['importance'] += fp.importance
|
||
if fp.covered:
|
||
type_stats[fp.fp_type]['covered'] += 1
|
||
type_stats[fp.fp_type]['covered_importance'] += fp.importance
|
||
|
||
for fp_type, stats in type_stats.items():
|
||
if stats['importance'] > 0:
|
||
result.coverage_by_type[fp_type] = stats['covered_importance'] / stats['importance']
|
||
else:
|
||
result.coverage_by_type[fp_type] = 0.0
|
||
|
||
# 找出未覆盖的高重要性功能点
|
||
uncovered_important = [
|
||
{
|
||
'name': fp.name,
|
||
'type': fp.fp_type,
|
||
'importance': fp.importance
|
||
}
|
||
for fp in self.function_points.values()
|
||
if not fp.covered and fp.importance >= 0.5
|
||
]
|
||
uncovered_important.sort(key=lambda x: x['importance'], reverse=True)
|
||
result.uncovered_important = uncovered_important[:5] # 只返回前5个
|
||
|
||
return result
|
||
|
||
def get_function_point_status(self, name: str) -> Optional[FunctionCoverageState]:
|
||
"""获取指定功能点的覆盖状态"""
|
||
return self.function_points.get(name)
|
||
|
||
def get_uncovered_function_points(self,
|
||
min_importance: float = 0.0,
|
||
fp_type: str = None) -> List[FunctionCoverageState]:
|
||
"""
|
||
获取未覆盖的功能点
|
||
|
||
Args:
|
||
min_importance: 最小重要性阈值
|
||
fp_type: 功能点类型过滤（可选）
|
||
|
||
Returns:
|
||
未覆盖的功能点列表
|
||
"""
|
||
uncovered = []
|
||
|
||
for fp in self.function_points.values():
|
||
if fp.covered:
|
||
continue
|
||
if fp.importance < min_importance:
|
||
continue
|
||
if fp_type and fp.fp_type != fp_type:
|
||
continue
|
||
uncovered.append(fp)
|
||
|
||
# 按重要性排序
|
||
uncovered.sort(key=lambda x: x.importance, reverse=True)
|
||
return uncovered
|
||
|
||
def get_coverage_report(self) -> str:
|
||
"""生成覆盖率报告"""
|
||
result = self.calculate_coverage()
|
||
|
||
lines = []
|
||
lines.append("=" * 60)
|
||
lines.append("SEMANTIC COVERAGE REPORT")
|
||
lines.append("=" * 60)
|
||
lines.append("")
|
||
lines.append(f"Total Function Points: {result.total_function_points}")
|
||
lines.append(f"Covered Function Points: {result.covered_function_points}")
|
||
lines.append(f"Semantic Coverage: {result.semantic_coverage:.2%}")
|
||
lines.append("")
|
||
lines.append("Coverage by Type:")
|
||
for fp_type, coverage in result.coverage_by_type.items():
|
||
lines.append(f" - {fp_type}: {coverage:.2%}")
|
||
lines.append("")
|
||
|
||
if result.uncovered_important:
|
||
lines.append("Uncovered High-Importance Function Points:")
|
||
for fp in result.uncovered_important:
|
||
lines.append(f" - {fp['name']} ({fp['type']}): importance={fp['importance']:.2f}")
|
||
|
||
lines.append("")
|
||
lines.append("=" * 60)
|
||
|
||
return "\n".join(lines)
|
||
|
||
def to_dict(self) -> Dict[str, Any]:
|
||
"""转换为字典"""
|
||
return {
|
||
'total_importance': self.total_importance,
|
||
'covered_importance': self.covered_importance,
|
||
'function_points': {
|
||
name: {
|
||
'type': fp.fp_type,
|
||
'importance': fp.importance,
|
||
'covered': fp.covered,
|
||
'covered_by': fp.covered_by
|
||
}
|
||
for name, fp in self.function_points.items()
|
||
}
|
||
}
|
||
|
||
|
||
# ============================================================================
|
||
# 质量评估器（主入口）
|
||
# ============================================================================
|
||
|
||
class QualityEvaluator:
|
||
"""
|
||
质量评估器 - 第3层主入口
|
||
|
||
整合多样性评估和语义覆盖率计算，提供统一的质量评估接口
|
||
"""
|
||
|
||
def __init__(self, function_points: List[Dict[str, Any]] = None):
|
||
"""
|
||
初始化质量评估器
|
||
|
||
Args:
|
||
function_points: 功能点列表
|
||
"""
|
||
self.diversity_evaluator = DiversityEvaluator()
|
||
self.semantic_coverage = SemanticCoverageCalculator(function_points)
|
||
self.evaluation_history: List[Dict[str, Any]] = []
|
||
|
||
def initialize(self, function_points: List[Dict[str, Any]]) -> Dict[str, Any]:
|
||
"""
|
||
初始化质量评估器
|
||
|
||
Args:
|
||
function_points: 功能点列表
|
||
|
||
Returns:
|
||
初始化结果
|
||
"""
|
||
result = self.semantic_coverage.initialize(function_points)
|
||
self.evaluation_history.clear()
|
||
return result
|
||
|
||
def evaluate_test_case(self,
|
||
code: str,
|
||
covered_lines: Set[int] = None,
|
||
covered_functions: List[str] = None,
|
||
test_id: str = "",
|
||
iteration: int = 0) -> Dict[str, Any]:
|
||
"""
|
||
评估测试用例质量
|
||
|
||
Args:
|
||
code: 测试代码
|
||
covered_lines: 覆盖的代码行
|
||
covered_functions: 覆盖的功能点列表
|
||
test_id: 测试用例ID
|
||
iteration: 当前迭代次数
|
||
|
||
Returns:
|
||
评估结果字典
|
||
"""
|
||
# 1. 多样性评估
|
||
diversity_score = self.diversity_evaluator.evaluate(
|
||
new_code=code,
|
||
new_covered_lines=covered_lines,
|
||
new_covered_functions=covered_functions
|
||
)
|
||
|
||
# 2. 更新语义覆盖率
|
||
coverage_result = self.semantic_coverage.update_coverage(
|
||
covered_lines=covered_lines,
|
||
covered_functions=covered_functions,
|
||
test_id=test_id,
|
||
iteration=iteration
|
||
)
|
||
|
||
# 3. 计算质量得分
|
||
quality_score = self._calculate_quality_score(diversity_score, coverage_result)
|
||
|
||
# 4. 记录评估历史
|
||
evaluation_result = {
|
||
'test_id': test_id,
|
||
'iteration': iteration,
|
||
'diversity': diversity_score.to_dict(),
|
||
'coverage': coverage_result.to_dict(),
|
||
'quality_score': quality_score
|
||
}
|
||
self.evaluation_history.append(evaluation_result)
|
||
|
||
# 5. 添加到多样性历史
|
||
self.diversity_evaluator.add_to_history(
|
||
code=code,
|
||
covered_lines=covered_lines,
|
||
covered_functions=covered_functions,
|
||
test_id=test_id
|
||
)
|
||
|
||
return evaluation_result
|
||
|
||
def _calculate_quality_score(self,
|
||
diversity: DiversityScore,
|
||
coverage: SemanticCoverageResult) -> float:
|
||
"""
|
||
计算综合质量得分
|
||
|
||
Args:
|
||
diversity: 多样性评分
|
||
coverage: 语义覆盖率结果
|
||
|
||
Returns:
|
||
质量得分 (0-1)
|
||
"""
|
||
# 多样性权重
|
||
diversity_weight = 0.4
|
||
|
||
# 覆盖率增量权重
|
||
coverage_weight = 0.6
|
||
|
||
# 综合得分
|
||
score = (
|
||
diversity_weight * diversity.overall_score +
|
||
coverage_weight * coverage.semantic_coverage
|
||
)
|
||
|
||
return min(1.0, max(0.0, score))
|
||
|
||
def should_accept(self,
|
||
evaluation_result: Dict[str, Any],
|
||
min_diversity: float = QualityConfig.MIN_DIVERSITY_THRESHOLD) -> Tuple[bool, str]:
|
||
"""
|
||
判断是否应该接受该测试用例
|
||
|
||
Args:
|
||
evaluation_result: 评估结果
|
||
min_diversity: 最低多样性阈值
|
||
|
||
Returns:
|
||
(是否接受, 原因)
|
||
"""
|
||
diversity = evaluation_result.get('diversity', {})
|
||
overall_diversity = diversity.get('overall_score', 0.0)
|
||
|
||
if overall_diversity < min_diversity:
|
||
return False, f"Diversity too low: {overall_diversity:.2f} < {min_diversity}"
|
||
|
||
return True, "Passed quality check"
|
||
|
||
def get_statistics(self) -> Dict[str, Any]:
|
||
"""获取统计信息"""
|
||
diversity_stats = self.diversity_evaluator.get_diversity_statistics()
|
||
coverage_result = self.semantic_coverage.calculate_coverage()
|
||
|
||
return {
|
||
'diversity': diversity_stats,
|
||
'coverage': coverage_result.to_dict(),
|
||
'total_evaluations': len(self.evaluation_history)
|
||
}
|
||
|
||
def generate_report(self) -> str:
|
||
"""生成完整报告"""
|
||
lines = []
|
||
lines.append("=" * 70)
|
||
lines.append("QUALITY EVALUATION REPORT - LAYER 3")
|
||
lines.append("=" * 70)
|
||
lines.append("")
|
||
|
||
# 多样性统计
|
||
stats = self.get_statistics()
|
||
lines.append("[DIVERSITY STATISTICS]")
|
||
lines.append(f"Total Tests: {stats['diversity']['total_tests']}")
|
||
lines.append(f"Unique Tests: {stats['diversity']['unique_hashes']}")
|
||
lines.append(f"Duplicate Ratio: {stats['diversity']['duplicate_ratio']:.2%}")
|
||
lines.append("")
|
||
|
||
# 语义覆盖率
|
||
lines.append("[SEMANTIC COVERAGE]")
|
||
lines.append(self.semantic_coverage.get_coverage_report())
|
||
lines.append("")
|
||
|
||
# 质量趋势
|
||
if self.evaluation_history:
|
||
lines.append("[QUALITY TREND]")
|
||
avg_quality = sum(e['quality_score'] for e in self.evaluation_history) / len(self.evaluation_history)
|
||
avg_diversity = sum(e['diversity']['overall_score'] for e in self.evaluation_history) / len(self.evaluation_history)
|
||
lines.append(f"Average Quality Score: {avg_quality:.2f}")
|
||
lines.append(f"Average Diversity Score: {avg_diversity:.2f}")
|
||
lines.append("")
|
||
|
||
lines.append("=" * 70)
|
||
|
||
return "\n".join(lines)
|
||
|
||
|
||
# ============================================================================
|
||
# 便捷函数
|
||
# ============================================================================
|
||
|
||
def create_quality_evaluator(function_points: List[Dict[str, Any]] = None) -> QualityEvaluator:
|
||
"""
|
||
创建质量评估器
|
||
|
||
Args:
|
||
function_points: 功能点列表
|
||
|
||
Returns:
|
||
初始化完成的质量评估器
|
||
"""
|
||
return QualityEvaluator(function_points=function_points)
|
||
|
||
|
||
def evaluate_diversity(code1: str, code2: str) -> float:
|
||
"""
|
||
快速评估两个代码的多样性
|
||
|
||
Args:
|
||
code1: 代码1
|
||
code2: 代码2
|
||
|
||
Returns:
|
||
多样性得分 (0-1, 1表示完全不同)
|
||
"""
|
||
calc = EditDistanceCalculator()
|
||
return calc.normalized_distance(code1, code2) |