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)
|