|
|
"""
|
|
|
Mutate模块单元测试
|
|
|
|
|
|
本模块为mutate模块提供全面的单元测试覆盖，包括：
|
|
|
- CBMCMutationOperators测试
|
|
|
- SpecSelector测试
|
|
|
- QualityEvaluator测试
|
|
|
- MutationEngine测试
|
|
|
- 突变策略测试
|
|
|
- 质量评估测试
|
|
|
"""
|
|
|
|
|
|
import pytest
|
|
|
import asyncio
|
|
|
import tempfile
|
|
|
import json
|
|
|
from pathlib import Path
|
|
|
from unittest.mock import Mock, patch, MagicMock
|
|
|
from typing import Dict, List, Any, Optional, Tuple
|
|
|
import statistics
|
|
|
|
|
|
from src.mutate.operators import CBMCMutationOperators, MutationPattern
|
|
|
from src.mutate.selector import SpecSelector, SelectionWeights, SelectionStrategy
|
|
|
from src.mutate.evaluator import QualityEvaluator, EvaluationWeights
|
|
|
from src.mutate.engine import MutationEngine, MutationStrategy, MutationConfig
|
|
|
from src.mutate.mutation_types import (
|
|
|
MutationType, MutationCandidate, MutationOperation, MutationResult,
|
|
|
MutationSession, SelectionHistory, QualityMetrics, QualityDimension,
|
|
|
VerificationResult, VerificationStatus
|
|
|
)
|
|
|
from src.mutate.exceptions import (
|
|
|
OperatorError, ValidationError, SelectionError, EvaluationError,
|
|
|
MutationError, ResourceError
|
|
|
)
|
|
|
from src.utils.config import ConfigManager
|
|
|
|
|
|
|
|
|
class TestCBMCMutationOperators:
|
|
|
"""CBMCMutationOperators类测试"""
|
|
|
|
|
|
def setup_method(self):
|
|
|
"""测试方法设置"""
|
|
|
self.operators = CBMCMutationOperators()
|
|
|
|
|
|
def test_init(self):
|
|
|
"""测试初始化"""
|
|
|
assert self.operators.patterns is not None
|
|
|
assert len(self.operators.patterns) > 0
|
|
|
assert MutationType.PREDICATE in self.operators.patterns
|
|
|
|
|
|
def test_predicate_mutation_basic(self):
|
|
|
"""测试基本谓词突变"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
candidates = self.operators.generate_mutations(spec, [MutationType.PREDICATE])
|
|
|
|
|
|
assert len(candidates) > 0
|
|
|
for candidate in candidates:
|
|
|
assert candidate.mutation_type == MutationType.PREDICATE
|
|
|
assert candidate.original_spec == spec
|
|
|
assert candidate.mutated_spec != spec
|
|
|
assert candidate.confidence > 0
|
|
|
|
|
|
def test_boundary_mutation_basic(self):
|
|
|
"""测试基本边界突变"""
|
|
|
spec = "void test(int x) { if (x < 10) { /* code */ } }"
|
|
|
candidates = self.operators.generate_mutations(spec, [MutationType.BOUNDARY])
|
|
|
|
|
|
assert len(candidates) > 0
|
|
|
for candidate in candidates:
|
|
|
assert candidate.mutation_type == MutationType.BOUNDARY
|
|
|
assert "boundary" in candidate.description.lower()
|
|
|
|
|
|
def test_logical_mutation_basic(self):
|
|
|
"""测试基本逻辑突变"""
|
|
|
spec = "void test(int x, int y) { if (x > 0 && y < 10) { /* code */ } }"
|
|
|
candidates = self.operators.generate_mutations(spec, [MutationType.LOGICAL])
|
|
|
|
|
|
assert len(candidates) > 0
|
|
|
for candidate in candidates:
|
|
|
assert candidate.mutation_type == MutationType.LOGICAL
|
|
|
assert "logical" in candidate.description.lower()
|
|
|
|
|
|
def test_array_bounds_mutation_basic(self):
|
|
|
"""测试数组边界突变"""
|
|
|
spec = "void test(int arr[10]) { __CPROVER_assume(arr[5] == 0); }"
|
|
|
candidates = self.operators.generate_mutations(spec, [MutationType.ARRAY_BOUNDS])
|
|
|
|
|
|
assert len(candidates) > 0
|
|
|
for candidate in candidates:
|
|
|
assert candidate.mutation_type == MutationType.ARRAY_BOUNDS
|
|
|
assert "array" in candidate.description.lower()
|
|
|
|
|
|
def test_pointer_validity_mutation_basic(self):
|
|
|
"""测试指针有效性突变"""
|
|
|
spec = "void test(int *ptr) { __CPROVER_assert(ptr != NULL, \"valid pointer\"); }"
|
|
|
candidates = self.operators.generate_mutations(spec, [MutationType.POINTER_VALIDITY])
|
|
|
|
|
|
assert len(candidates) > 0
|
|
|
for candidate in candidates:
|
|
|
assert candidate.mutation_type == MutationType.POINTER_VALIDITY
|
|
|
assert "pointer" in candidate.description.lower()
|
|
|
|
|
|
def test_combined_mutation_types(self):
|
|
|
"""测试组合突变类型"""
|
|
|
spec = "void test(int x, int *ptr) { if (x > 0 && ptr != NULL) { /* code */ } }"
|
|
|
mutation_types = [
|
|
|
MutationType.PREDICATE,
|
|
|
MutationType.LOGICAL,
|
|
|
MutationType.POINTER_VALIDITY
|
|
|
]
|
|
|
|
|
|
candidates = self.operators.generate_mutations(spec, mutation_types)
|
|
|
|
|
|
assert len(candidates) > 0
|
|
|
found_types = {candidate.mutation_type for candidate in candidates}
|
|
|
assert found_types.issuperset(mutation_types)
|
|
|
|
|
|
def test_mutation_validation(self):
|
|
|
"""测试突变验证"""
|
|
|
valid_spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
candidates = self.operators.generate_mutations(valid_spec, [MutationType.PREDICATE])
|
|
|
|
|
|
for candidate in candidates:
|
|
|
is_valid = self.operators.validate_mutation(candidate)
|
|
|
assert is_valid is True
|
|
|
|
|
|
def test_mutation_conflict_detection(self):
|
|
|
"""测试突变冲突检测"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
candidates = self.operators.generate_mutations(spec, [MutationType.PREDICATE])
|
|
|
|
|
|
if len(candidates) > 1:
|
|
|
conflicts = self.operators.detect_conflicts(candidates)
|
|
|
# 某些突变可能会有冲突
|
|
|
assert isinstance(conflicts, list)
|
|
|
|
|
|
def test_batch_mutation_generation(self):
|
|
|
"""测试批量突变生成"""
|
|
|
specs = [
|
|
|
"void test1(int x) { __CPROVER_assume(x > 0); }",
|
|
|
"void test2(int y) { if (y < 10) { /* code */ } }"
|
|
|
]
|
|
|
|
|
|
batch_results = self.operators.generate_batch_mutations(specs, [MutationType.PREDICATE])
|
|
|
|
|
|
assert len(batch_results) == len(specs)
|
|
|
for spec, candidates in batch_results.items():
|
|
|
assert len(candidates) > 0
|
|
|
assert all(candidate.original_spec == spec for candidate in candidates)
|
|
|
|
|
|
def test_mutation_syntax_validation(self):
|
|
|
"""测试突变语法验证"""
|
|
|
valid_spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
invalid_spec = "void test(int x) { invalid_syntax }"
|
|
|
|
|
|
# 有效规范
|
|
|
valid_candidates = self.operators.generate_mutations(valid_spec, [MutationType.PREDICATE])
|
|
|
assert len(valid_candidates) > 0
|
|
|
|
|
|
# 无效规范应该抛出异常
|
|
|
with pytest.raises(ValidationError):
|
|
|
self.operators.generate_mutations(invalid_spec, [MutationType.PREDICATE])
|
|
|
|
|
|
def test_mutation_statistics(self):
|
|
|
"""测试突变统计"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
candidates = self.operators.generate_mutations(spec, [MutationType.PREDICATE])
|
|
|
|
|
|
stats = self.operators.get_mutation_statistics(candidates)
|
|
|
assert "total_mutations" in stats
|
|
|
assert "average_confidence" in stats
|
|
|
assert "mutation_type_distribution" in stats
|
|
|
assert stats["total_mutations"] == len(candidates)
|
|
|
|
|
|
def test_mutation_pattern_application(self):
|
|
|
"""测试突变模式应用"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
pattern = MutationPattern(
|
|
|
pattern=r"__CPROVER_assume\((.+?)\)",
|
|
|
replacement="__CPROVER_assert(\\1, \"assertion\")",
|
|
|
description="Assume to Assert"
|
|
|
)
|
|
|
|
|
|
result = self.operators.apply_mutation_pattern(spec, pattern)
|
|
|
assert "__CPROVER_assert" in result
|
|
|
assert "__CPROVER_assume" not in result
|
|
|
|
|
|
def test_context_aware_mutation(self):
|
|
|
"""测试上下文感知突变"""
|
|
|
spec = """
|
|
|
void complex_function(int *array, int size, int threshold) {
|
|
|
__CPROVER_assume(array != NULL);
|
|
|
__CPROVER_assume(size > 0 && size <= 100);
|
|
|
__CPROVER_assume(threshold > 0);
|
|
|
|
|
|
for (int i = 0; i < size; i++) {
|
|
|
if (array[i] > threshold) {
|
|
|
// Process element
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
"""
|
|
|
|
|
|
candidates = self.operators.generate_mutations(
|
|
|
spec,
|
|
|
[MutationType.ARRAY_BOUNDS, MutationType.POINTER_VALIDITY]
|
|
|
)
|
|
|
|
|
|
assert len(candidates) > 0
|
|
|
# 验证上下文被保留
|
|
|
for candidate in candidates:
|
|
|
assert "complex_function" in candidate.mutated_spec
|
|
|
assert "array" in candidate.mutated_spec
|
|
|
assert "size" in candidate.mutated_spec
|
|
|
|
|
|
|
|
|
class TestSpecSelector:
|
|
|
"""SpecSelector类测试"""
|
|
|
|
|
|
def setup_method(self):
|
|
|
"""测试方法设置"""
|
|
|
self.selector = SpecSelector()
|
|
|
|
|
|
def test_init(self):
|
|
|
"""测试初始化"""
|
|
|
assert isinstance(self.selector.weights, SelectionWeights)
|
|
|
assert self.selector.selection_history == []
|
|
|
|
|
|
def test_weighted_random_selection(self):
|
|
|
"""测试加权随机选择"""
|
|
|
candidates = [
|
|
|
MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.8,
|
|
|
description="Test mutation"
|
|
|
),
|
|
|
MutationCandidate(
|
|
|
id="2",
|
|
|
mutation_type=MutationType.BOUNDARY,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { if (x < 10) { } }",
|
|
|
confidence=0.6,
|
|
|
description="Boundary mutation"
|
|
|
)
|
|
|
]
|
|
|
|
|
|
selected = self.selector.select_candidates(
|
|
|
candidates,
|
|
|
strategy=SelectionStrategy.WEIGHTED_RANDOM,
|
|
|
count=1
|
|
|
)
|
|
|
|
|
|
assert len(selected) == 1
|
|
|
assert selected[0] in candidates
|
|
|
|
|
|
def test_tournament_selection(self):
|
|
|
"""测试锦标赛选择"""
|
|
|
candidates = [
|
|
|
MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.9,
|
|
|
description="High confidence"
|
|
|
),
|
|
|
MutationCandidate(
|
|
|
id="2",
|
|
|
mutation_type=MutationType.BOUNDARY,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { if (x < 10) { } }",
|
|
|
confidence=0.5,
|
|
|
description="Low confidence"
|
|
|
)
|
|
|
]
|
|
|
|
|
|
selected = self.selector.select_candidates(
|
|
|
candidates,
|
|
|
strategy=SelectionStrategy.TOURNAMENT,
|
|
|
count=1
|
|
|
)
|
|
|
|
|
|
assert len(selected) == 1
|
|
|
# 更高置信度的候选者应该更可能被选中
|
|
|
|
|
|
def test_elite_selection(self):
|
|
|
"""测试精英选择"""
|
|
|
candidates = [
|
|
|
MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.7,
|
|
|
description="Good mutation"
|
|
|
),
|
|
|
MutationCandidate(
|
|
|
id="2",
|
|
|
mutation_type=MutationType.BOUNDARY,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { if (x < 10) { } }",
|
|
|
confidence=0.9,
|
|
|
description="Better mutation"
|
|
|
),
|
|
|
MutationCandidate(
|
|
|
id="3",
|
|
|
mutation_type=MutationType.LOGICAL,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { if (x > 0 || x < 10) { } }",
|
|
|
confidence=0.6,
|
|
|
description="Worse mutation"
|
|
|
)
|
|
|
]
|
|
|
|
|
|
selected = self.selector.select_candidates(
|
|
|
candidates,
|
|
|
strategy=SelectionStrategy.ELITE,
|
|
|
count=2
|
|
|
)
|
|
|
|
|
|
assert len(selected) == 2
|
|
|
# 应该选择置信度最高的两个
|
|
|
selected_confidences = [c.confidence for c in selected]
|
|
|
assert sorted(selected_confidences, reverse=True) == selected_confidences
|
|
|
|
|
|
def test_adaptive_selection(self):
|
|
|
"""测试自适应选择"""
|
|
|
# 设置历史记录
|
|
|
self.selector.selection_history = [
|
|
|
SelectionHistory(
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
success_rate=0.8,
|
|
|
average_quality=0.7
|
|
|
),
|
|
|
SelectionHistory(
|
|
|
mutation_type=MutationType.BOUNDARY,
|
|
|
success_rate=0.4,
|
|
|
average_quality=0.5
|
|
|
)
|
|
|
]
|
|
|
|
|
|
candidates = [
|
|
|
MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.6,
|
|
|
description="Predicate mutation"
|
|
|
),
|
|
|
MutationCandidate(
|
|
|
id="2",
|
|
|
mutation_type=MutationType.BOUNDARY,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { if (x < 10) { } }",
|
|
|
confidence=0.6,
|
|
|
description="Boundary mutation"
|
|
|
)
|
|
|
]
|
|
|
|
|
|
selected = self.selector.select_candidates(
|
|
|
candidates,
|
|
|
strategy=SelectionStrategy.ADAPTIVE,
|
|
|
count=1
|
|
|
)
|
|
|
|
|
|
assert len(selected) == 1
|
|
|
# PREDICATE应该有更高概率被选中，因为历史成功率更高
|
|
|
|
|
|
def test_selection_with_constraints(self):
|
|
|
"""测试带约束的选择"""
|
|
|
candidates = [
|
|
|
MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.8,
|
|
|
description="Predicate mutation"
|
|
|
),
|
|
|
MutationCandidate(
|
|
|
id="2",
|
|
|
mutation_type=MutationType.BOUNDARY,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { if (x < 10) { } }",
|
|
|
confidence=0.8,
|
|
|
description="Boundary mutation"
|
|
|
)
|
|
|
]
|
|
|
|
|
|
# 设置最大数量约束
|
|
|
selected = self.selector.select_candidates(
|
|
|
candidates,
|
|
|
strategy=SelectionStrategy.WEIGHTED_RANDOM,
|
|
|
count=1,
|
|
|
max_count_per_type=1
|
|
|
)
|
|
|
|
|
|
assert len(selected) == 1
|
|
|
|
|
|
def test_diversity_optimization(self):
|
|
|
"""测试多样性优化"""
|
|
|
candidates = [
|
|
|
MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.8,
|
|
|
description="Predicate mutation 1"
|
|
|
),
|
|
|
MutationCandidate(
|
|
|
id="2",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x >= 0); }",
|
|
|
confidence=0.8,
|
|
|
description="Predicate mutation 2"
|
|
|
),
|
|
|
MutationCandidate(
|
|
|
id="3",
|
|
|
mutation_type=MutationType.BOUNDARY,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { if (x < 10) { } }",
|
|
|
confidence=0.8,
|
|
|
description="Boundary mutation"
|
|
|
)
|
|
|
]
|
|
|
|
|
|
# 选择2个候选者，应该倾向于多样性
|
|
|
selected = self.selector.select_candidates(
|
|
|
candidates,
|
|
|
strategy=SelectionStrategy.WEIGHTED_RANDOM,
|
|
|
count=2,
|
|
|
optimize_diversity=True
|
|
|
)
|
|
|
|
|
|
assert len(selected) == 2
|
|
|
selected_types = {c.mutation_type for c in selected}
|
|
|
# 应该包含不同类型以增加多样性
|
|
|
assert len(selected_types) >= 1
|
|
|
|
|
|
def test_update_selection_history(self):
|
|
|
"""测试更新选择历史"""
|
|
|
candidates = [
|
|
|
MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.8,
|
|
|
description="Predicate mutation"
|
|
|
)
|
|
|
]
|
|
|
|
|
|
# 模拟选择过程
|
|
|
self.selector.update_selection_history(candidates, success=True)
|
|
|
|
|
|
assert len(self.selector.selection_history) > 0
|
|
|
history = self.selector.selection_history[-1]
|
|
|
assert history.mutation_type == MutationType.PREDICATE
|
|
|
|
|
|
def test_get_selection_statistics(self):
|
|
|
"""测试获取选择统计"""
|
|
|
candidates = [
|
|
|
MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.8,
|
|
|
description="Predicate mutation"
|
|
|
),
|
|
|
MutationCandidate(
|
|
|
id="2",
|
|
|
mutation_type=MutationType.BOUNDARY,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { if (x < 10) { } }",
|
|
|
confidence=0.6,
|
|
|
description="Boundary mutation"
|
|
|
)
|
|
|
]
|
|
|
|
|
|
stats = self.selector.get_selection_statistics(candidates)
|
|
|
assert "total_candidates" in stats
|
|
|
assert "average_confidence" in stats
|
|
|
assert "type_distribution" in stats
|
|
|
assert stats["total_candidates"] == len(candidates)
|
|
|
|
|
|
|
|
|
class TestQualityEvaluator:
|
|
|
"""QualityEvaluator类测试"""
|
|
|
|
|
|
def setup_method(self):
|
|
|
"""测试方法设置"""
|
|
|
self.evaluator = QualityEvaluator()
|
|
|
|
|
|
def test_init(self):
|
|
|
"""测试初始化"""
|
|
|
assert isinstance(self.evaluator.weights, EvaluationWeights)
|
|
|
|
|
|
def test_accuracy_evaluation(self):
|
|
|
"""测试准确性评估"""
|
|
|
candidate = MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.8,
|
|
|
description="Predicate mutation"
|
|
|
)
|
|
|
|
|
|
accuracy_score = self.evaluator.evaluate_accuracy(candidate)
|
|
|
assert 0.0 <= accuracy_score <= 1.0
|
|
|
|
|
|
def test_completeness_evaluation(self):
|
|
|
"""测试完整性评估"""
|
|
|
candidate = MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); __CPROVER_assert(x < 100, \"bounds\"); }",
|
|
|
confidence=0.8,
|
|
|
description="Complete mutation"
|
|
|
)
|
|
|
|
|
|
completeness_score = self.evaluator.evaluate_completeness(candidate)
|
|
|
assert 0.0 <= completeness_score <= 1.0
|
|
|
|
|
|
def test_verifiability_evaluation(self):
|
|
|
"""测试可验证性评估"""
|
|
|
candidate = MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.8,
|
|
|
description="Verifiable mutation"
|
|
|
)
|
|
|
|
|
|
verifiability_score = self.evaluator.evaluate_verifiability(candidate)
|
|
|
assert 0.0 <= verifiability_score <= 1.0
|
|
|
|
|
|
def test_stability_evaluation(self):
|
|
|
"""测试稳定性评估"""
|
|
|
candidate = MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.8,
|
|
|
description="Stable mutation"
|
|
|
)
|
|
|
|
|
|
stability_score = self.evaluator.evaluate_stability(candidate)
|
|
|
assert 0.0 <= stability_score <= 1.0
|
|
|
|
|
|
def test_efficiency_evaluation(self):
|
|
|
"""测试效率评估"""
|
|
|
candidate = MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.8,
|
|
|
description="Efficient mutation"
|
|
|
)
|
|
|
|
|
|
efficiency_score = self.evaluator.evaluate_efficiency(candidate)
|
|
|
assert 0.0 <= efficiency_score <= 1.0
|
|
|
|
|
|
def test_comprehensive_quality_evaluation(self):
|
|
|
"""测试全面质量评估"""
|
|
|
candidate = MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.8,
|
|
|
description="Comprehensive mutation"
|
|
|
)
|
|
|
|
|
|
quality_metrics = self.evaluator.evaluate_comprehensive_quality(candidate)
|
|
|
assert isinstance(quality_metrics, QualityMetrics)
|
|
|
assert hasattr(quality_metrics, 'overall_score')
|
|
|
assert 0.0 <= quality_metrics.overall_score <= 1.0
|
|
|
|
|
|
def test_evaluation_with_verification_results(self):
|
|
|
"""测试带验证结果的评估"""
|
|
|
candidate = MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.8,
|
|
|
description="Tested mutation"
|
|
|
)
|
|
|
|
|
|
verification_result = VerificationResult(
|
|
|
status=VerificationStatus.SUCCESSFUL,
|
|
|
verification_time=5.0,
|
|
|
memory_usage=1024,
|
|
|
is_successful=True
|
|
|
)
|
|
|
|
|
|
quality_metrics = self.evaluator.evaluate_with_verification(candidate, verification_result)
|
|
|
assert isinstance(quality_metrics, QualityMetrics)
|
|
|
# 成功的验证应该提高质量分数
|
|
|
assert quality_metrics.overall_score > 0.5
|
|
|
|
|
|
def test_batch_evaluation(self):
|
|
|
"""测试批量评估"""
|
|
|
candidates = [
|
|
|
MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.8,
|
|
|
description="Mutation 1"
|
|
|
),
|
|
|
MutationCandidate(
|
|
|
id="2",
|
|
|
mutation_type=MutationType.BOUNDARY,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { if (x < 10) { } }",
|
|
|
confidence=0.6,
|
|
|
description="Mutation 2"
|
|
|
)
|
|
|
]
|
|
|
|
|
|
batch_results = self.evaluator.evaluate_batch(candidates)
|
|
|
assert len(batch_results) == len(candidates)
|
|
|
for candidate, metrics in batch_results.items():
|
|
|
assert isinstance(metrics, QualityMetrics)
|
|
|
|
|
|
def test_quality_threshold_filtering(self):
|
|
|
"""测试质量阈值过滤"""
|
|
|
candidates = [
|
|
|
MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.9,
|
|
|
description="High quality"
|
|
|
),
|
|
|
MutationCandidate(
|
|
|
id="2",
|
|
|
mutation_type=MutationType.BOUNDARY,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { if (x < 10) { } }",
|
|
|
confidence=0.3,
|
|
|
description="Low quality"
|
|
|
)
|
|
|
]
|
|
|
|
|
|
filtered = self.evaluator.filter_by_quality_threshold(candidates, threshold=0.7)
|
|
|
assert len(filtered) == 1
|
|
|
assert filtered[0].confidence == 0.9
|
|
|
|
|
|
def test_quality_comparison(self):
|
|
|
"""测试质量比较"""
|
|
|
candidate1 = MutationCandidate(
|
|
|
id="1",
|
|
|
mutation_type=MutationType.PREDICATE,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { __CPROVER_assume(x > 0); }",
|
|
|
confidence=0.9,
|
|
|
description="High quality"
|
|
|
)
|
|
|
candidate2 = MutationCandidate(
|
|
|
id="2",
|
|
|
mutation_type=MutationType.BOUNDARY,
|
|
|
original_spec="void test(int x) { }",
|
|
|
mutated_spec="void test(int x) { if (x < 10) { } }",
|
|
|
confidence=0.5,
|
|
|
description="Medium quality"
|
|
|
)
|
|
|
|
|
|
comparison = self.evaluator.compare_quality(candidate1, candidate2)
|
|
|
assert comparison > 0 # candidate1 应该比 candidate2 好
|
|
|
|
|
|
|
|
|
class TestMutationEngine:
|
|
|
"""MutationEngine类测试"""
|
|
|
|
|
|
def setup_method(self):
|
|
|
"""测试方法设置"""
|
|
|
self.config = MutationConfig(
|
|
|
max_candidates_per_function=20,
|
|
|
max_selected_candidates=5,
|
|
|
quality_threshold=0.6
|
|
|
)
|
|
|
self.engine = MutationEngine(self.config)
|
|
|
|
|
|
def test_init(self):
|
|
|
"""测试初始化"""
|
|
|
assert self.engine.config == self.config
|
|
|
assert isinstance(self.engine.operators, CBMCMutationOperators)
|
|
|
assert isinstance(self.engine.selector, SpecSelector)
|
|
|
assert isinstance(self.engine.evaluator, QualityEvaluator)
|
|
|
|
|
|
def test_create_mutation_session(self):
|
|
|
"""测试创建突变会话"""
|
|
|
spec = "void test(int x) { }"
|
|
|
function_metadata = {"name": "test", "parameters": [{"name": "x", "type": "int"}]}
|
|
|
|
|
|
session = self.engine.create_mutation_session(spec, function_metadata)
|
|
|
assert isinstance(session, MutationSession)
|
|
|
assert session.original_spec == spec
|
|
|
assert session.function_metadata == function_metadata
|
|
|
assert session.session_id is not None
|
|
|
|
|
|
def test_exhaustive_mutation_strategy(self):
|
|
|
"""测试穷举突变策略"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
function_metadata = {"name": "test", "parameters": [{"name": "x", "type": "int"}]}
|
|
|
|
|
|
result = self.engine.execute_mutation(
|
|
|
spec,
|
|
|
function_metadata,
|
|
|
strategy=MutationStrategy.EXHAUSTIVE
|
|
|
)
|
|
|
|
|
|
assert isinstance(result, MutationResult)
|
|
|
assert result.session_id is not None
|
|
|
assert len(result.selected_candidates) > 0
|
|
|
|
|
|
def test_heuristic_mutation_strategy(self):
|
|
|
"""测试启发式突变策略"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
function_metadata = {"name": "test", "parameters": [{"name": "x", "type": "int"}]}
|
|
|
|
|
|
result = self.engine.execute_mutation(
|
|
|
spec,
|
|
|
function_metadata,
|
|
|
strategy=MutationStrategy.HEURISTIC
|
|
|
)
|
|
|
|
|
|
assert isinstance(result, MutationResult)
|
|
|
assert result.strategy == MutationStrategy.HEURISTIC
|
|
|
assert len(result.selected_candidates) <= self.config.max_selected_candidates
|
|
|
|
|
|
def test_adaptive_mutation_strategy(self):
|
|
|
"""测试自适应突变策略"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
function_metadata = {"name": "test", "parameters": [{"name": "x", "type": "int"}]}
|
|
|
|
|
|
result = self.engine.execute_mutation(
|
|
|
spec,
|
|
|
function_metadata,
|
|
|
strategy=MutationStrategy.ADAPTIVE
|
|
|
)
|
|
|
|
|
|
assert isinstance(result, MutationResult)
|
|
|
assert result.strategy == MutationStrategy.ADAPTIVE
|
|
|
|
|
|
def test_targeted_mutation_strategy(self):
|
|
|
"""测试目标突变策略"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
function_metadata = {"name": "test", "parameters": [{"name": "x", "type": "int"}]}
|
|
|
target_types = [MutationType.PREDICATE]
|
|
|
|
|
|
result = self.engine.execute_mutation(
|
|
|
spec,
|
|
|
function_metadata,
|
|
|
strategy=MutationStrategy.TARGETED,
|
|
|
target_mutation_types=target_types
|
|
|
)
|
|
|
|
|
|
assert isinstance(result, MutationResult)
|
|
|
assert result.strategy == MutationStrategy.TARGETED
|
|
|
# 所有选中的候选者应该是目标类型
|
|
|
for candidate in result.selected_candidates:
|
|
|
assert candidate.mutation_type in target_types
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
|
async def test_async_mutation_execution(self):
|
|
|
"""测试异步突变执行"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
function_metadata = {"name": "test", "parameters": [{"name": "x", "type": "int"}]}
|
|
|
|
|
|
result = await self.engine.execute_mutation_async(
|
|
|
spec,
|
|
|
function_metadata,
|
|
|
strategy=MutationStrategy.HEURISTIC
|
|
|
)
|
|
|
|
|
|
assert isinstance(result, MutationResult)
|
|
|
|
|
|
def test_batch_mutation_execution(self):
|
|
|
"""测试批量突变执行"""
|
|
|
specs = [
|
|
|
("void test1(int x) { __CPROVER_assume(x > 0); }", {"name": "test1", "parameters": [{"name": "x", "type": "int"}]}),
|
|
|
("void test2(int y) { if (y < 10) { } }", {"name": "test2", "parameters": [{"name": "y", "type": "int"}]})
|
|
|
]
|
|
|
|
|
|
results = self.engine.execute_batch_mutations(specs, strategy=MutationStrategy.HEURISTIC)
|
|
|
|
|
|
assert len(results) == len(specs)
|
|
|
for result in results:
|
|
|
assert isinstance(result, MutationResult)
|
|
|
|
|
|
def test_mutation_progress_tracking(self):
|
|
|
"""测试突变进度跟踪"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
function_metadata = {"name": "test", "parameters": [{"name": "x", "type": "int"}]}
|
|
|
|
|
|
progress_updates = []
|
|
|
def progress_callback(session_id, stage, progress, message):
|
|
|
progress_updates.append((session_id, stage, progress, message))
|
|
|
|
|
|
result = self.engine.execute_mutation(
|
|
|
spec,
|
|
|
function_metadata,
|
|
|
strategy=MutationStrategy.HEURISTIC,
|
|
|
progress_callback=progress_callback
|
|
|
)
|
|
|
|
|
|
assert len(progress_updates) > 0
|
|
|
# 检查是否有不同阶段的进度更新
|
|
|
stages = [update[1] for update in progress_updates]
|
|
|
assert len(set(stages)) > 1
|
|
|
|
|
|
def test_mutation_error_handling(self):
|
|
|
"""测试突变错误处理"""
|
|
|
invalid_spec = "invalid syntax here"
|
|
|
|
|
|
with pytest.raises(MutationError):
|
|
|
self.engine.execute_mutation(
|
|
|
invalid_spec,
|
|
|
{"name": "test", "parameters": []},
|
|
|
strategy=MutationStrategy.HEURISTIC
|
|
|
)
|
|
|
|
|
|
def test_mutation_resource_constraints(self):
|
|
|
"""测试突变资源约束"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
function_metadata = {"name": "test", "parameters": [{"name": "x", "type": "int"}]}
|
|
|
|
|
|
# 设置严格的约束
|
|
|
constrained_config = MutationConfig(
|
|
|
max_candidates_per_function=2,
|
|
|
max_selected_candidates=1,
|
|
|
quality_threshold=0.9
|
|
|
)
|
|
|
engine = MutationEngine(constrained_config)
|
|
|
|
|
|
result = engine.execute_mutation(
|
|
|
spec,
|
|
|
function_metadata,
|
|
|
strategy=MutationStrategy.HEURISTIC
|
|
|
)
|
|
|
|
|
|
assert len(result.selected_candidates) <= constrained_config.max_selected_candidates
|
|
|
|
|
|
def test_mutation_session_management(self):
|
|
|
"""测试突变会话管理"""
|
|
|
# 创建多个会话
|
|
|
spec1 = "void test1(int x) { }"
|
|
|
spec2 = "void test2(int y) { }"
|
|
|
|
|
|
session1 = self.engine.create_mutation_session(spec1, {"name": "test1", "parameters": []})
|
|
|
session2 = self.engine.create_mutation_session(spec2, {"name": "test2", "parameters": []})
|
|
|
|
|
|
# 获取活跃会话
|
|
|
active_sessions = self.engine.get_active_sessions()
|
|
|
assert len(active_sessions) >= 2
|
|
|
assert session1.session_id in [s.session_id for s in active_sessions]
|
|
|
assert session2.session_id in [s.session_id for s in active_sessions]
|
|
|
|
|
|
# 清理会话
|
|
|
self.engine.cleanup_session(session1.session_id)
|
|
|
active_sessions_after = self.engine.get_active_sessions()
|
|
|
assert session1.session_id not in [s.session_id for s in active_sessions_after]
|
|
|
|
|
|
def test_mutation_statistics(self):
|
|
|
"""测试突变统计"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
function_metadata = {"name": "test", "parameters": [{"name": "x", "type": "int"}]}
|
|
|
|
|
|
result = self.engine.execute_mutation(
|
|
|
spec,
|
|
|
function_metadata,
|
|
|
strategy=MutationStrategy.HEURISTIC
|
|
|
)
|
|
|
|
|
|
stats = self.engine.get_mutation_statistics()
|
|
|
assert "total_sessions" in stats
|
|
|
assert "average_candidates_per_session" in stats
|
|
|
assert "success_rate" in stats
|
|
|
|
|
|
|
|
|
class TestMutateModuleIntegration:
|
|
|
"""Mutate模块集成测试"""
|
|
|
|
|
|
def test_complete_mutation_workflow(self):
|
|
|
"""测试完整突变工作流"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
function_metadata = {"name": "test", "parameters": [{"name": "x", "type": "int"}]}
|
|
|
|
|
|
# 创建突变引擎
|
|
|
config = MutationConfig(
|
|
|
max_candidates_per_function=10,
|
|
|
max_selected_candidates=3,
|
|
|
quality_threshold=0.6
|
|
|
)
|
|
|
engine = MutationEngine(config)
|
|
|
|
|
|
# 执行突变
|
|
|
result = engine.execute_mutation(
|
|
|
spec,
|
|
|
function_metadata,
|
|
|
strategy=MutationStrategy.HEURISTIC
|
|
|
)
|
|
|
|
|
|
# 验证结果
|
|
|
assert isinstance(result, MutationResult)
|
|
|
assert result.session_id is not None
|
|
|
assert len(result.all_candidates) > 0
|
|
|
assert len(result.selected_candidates) > 0
|
|
|
assert len(result.selected_candidates) <= config.max_selected_candidates
|
|
|
|
|
|
# 验证选中的候选者质量
|
|
|
for candidate in result.selected_candidates:
|
|
|
assert candidate.confidence >= config.quality_threshold
|
|
|
|
|
|
def test_mutation_with_verification_integration(self):
|
|
|
"""测试与验证的集成"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
function_metadata = {"name": "test", "parameters": [{"name": "x", "type": "int"}]}
|
|
|
|
|
|
config = MutationConfig(
|
|
|
max_candidates_per_function=5,
|
|
|
max_selected_candidates=2,
|
|
|
quality_threshold=0.5
|
|
|
)
|
|
|
engine = MutationEngine(config)
|
|
|
|
|
|
# 模拟验证结果
|
|
|
def mock_verify(candidate):
|
|
|
# 模拟一些候选者验证成功，一些失败
|
|
|
if "assume" in candidate.mutated_spec:
|
|
|
return VerificationResult(
|
|
|
status=VerificationStatus.SUCCESSFUL,
|
|
|
verification_time=2.0,
|
|
|
memory_usage=512,
|
|
|
is_successful=True
|
|
|
)
|
|
|
else:
|
|
|
return VerificationResult(
|
|
|
status=VerificationStatus.FAILED,
|
|
|
verification_time=1.0,
|
|
|
memory_usage=256,
|
|
|
is_successful=False
|
|
|
)
|
|
|
|
|
|
result = engine.execute_mutation(
|
|
|
spec,
|
|
|
function_metadata,
|
|
|
strategy=MutationStrategy.HEURISTIC,
|
|
|
verification_callback=mock_verify
|
|
|
)
|
|
|
|
|
|
assert isinstance(result, MutationResult)
|
|
|
# 验证成功的候选者应该被优先选择
|
|
|
|
|
|
def test_error_handling_integration(self):
|
|
|
"""测试错误处理集成"""
|
|
|
# 测试无效输入
|
|
|
with pytest.raises(MutationError):
|
|
|
engine = MutationEngine(MutationConfig())
|
|
|
engine.execute_mutation("", {}, strategy=MutationStrategy.HEURISTIC)
|
|
|
|
|
|
# 测试配置错误
|
|
|
with pytest.raises(ResourceError):
|
|
|
invalid_config = MutationConfig(
|
|
|
max_candidates_per_function=-1,
|
|
|
max_selected_candidates=-1
|
|
|
)
|
|
|
engine = MutationEngine(invalid_config)
|
|
|
|
|
|
def test_performance_considerations(self):
|
|
|
"""测试性能考虑"""
|
|
|
spec = "void test(int x) { __CPROVER_assume(x > 0); }"
|
|
|
function_metadata = {"name": "test", "parameters": [{"name": "x", "type": "int"}]}
|
|
|
|
|
|
config = MutationConfig(
|
|
|
max_candidates_per_function=50, # 较大数量测试性能
|
|
|
max_selected_candidates=10,
|
|
|
quality_threshold=0.3
|
|
|
)
|
|
|
engine = MutationEngine(config)
|
|
|
|
|
|
# 测试执行时间
|
|
|
import time
|
|
|
start_time = time.time()
|
|
|
result = engine.execute_mutation(
|
|
|
spec,
|
|
|
function_metadata,
|
|
|
strategy=MutationStrategy.HEURISTIC
|
|
|
)
|
|
|
end_time = time.time()
|
|
|
|
|
|
execution_time = end_time - start_time
|
|
|
assert execution_time < 10.0 # 应该在合理时间内完成
|
|
|
|
|
|
assert isinstance(result, MutationResult)
|
|
|
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
pytest.main([__file__, "-v"]) |
