NB-076
e2a8d53e60
## 修复内容 ### C1: _mark_eval 反向操作符 (coverage.py) - EVALUATE 约束匹配支持 操作符 - WHEN OTHER 的自动检测（全部 WHEN 被否定时） ### C2: _mark_perform 反向操作符 (coverage.py) - PERFORM 同 _mark_if 的反向操作符匹配 - PERFORM UNTIL 条件截断后桥接器通过 branch_names 识别类型 ### H1: parse_single_condition 传递 fields (coverage.py) - collect_decision_points 调用时传 fields 参数 - NOT 前缀条件解析 (NOT WS-X > 50 → WS-X <= 50) ### H4: generate_data 输入约束 (__init__.py) - 文档注明接收原始源码，非预处理后文本 ### M1: not_map break (cond.py) - NOT 操作符映射循环添加 break ## 覆盖测试结果 - IF: 100% (T/F) - NOT IF: 100% (NOT_TRUE/NOT_FALSE) - PERFORM UNTIL: 100% (ENTER/SKIP) - EVALUATE: 100% (4 WHENs) - Nested IF: 100% (4 branches) - S15 回归: 17/17 PASS Co-Authored-By: Claude <noreply@anthropic.com>
234 lines
8.3 KiB
Python
234 lines
8.3 KiB
Python
"""Non-exploding path enumeration — per-decision-point coverage, O(N) paths.
|
|
|
|
Strategy:
|
|
1. Walk the tree once to collect ALL decision points and their "access paths"
|
|
2. For each decision point D, generate 2 paths:
|
|
- D=True with ancestor and descendant access constraints
|
|
- D=False with ancestor and descendant access constraints
|
|
3. Total: 2 * N paths, where N = number of decision points
|
|
|
|
This guarantees every branch is exercised at least once, without O(2^N) explosion.
|
|
"""
|
|
|
|
import re
|
|
import logging
|
|
from .models import BrSeq, BrIf, BrEval, BrPerform, BrSearch, Assign, CallNode, CondNot, CondLeaf, ExitNode, GoTo
|
|
from .cond import parse_single_condition, parse_compound_condition, is_field, collect_leaves, mcdc_sets
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
_STOP = ('__STOP__', '', None, True)
|
|
|
|
|
|
def _parse_condition(condition_text, fields):
|
|
"""Parse an IF condition into (field, op, value) or None."""
|
|
parsed = parse_single_condition(condition_text, fields)
|
|
if parsed and is_field(parsed[0], fields):
|
|
return parsed
|
|
if parsed:
|
|
return parsed
|
|
return None
|
|
|
|
|
|
def _invert_condition(parsed):
|
|
"""Invert a parsed condition (True ↔ False)."""
|
|
if parsed is None:
|
|
return None
|
|
field, op, val = parsed
|
|
inv_op = {'=': '<>', '<>': '=', '>': '<=', '<': '>=', '>=': '<', '<=': '>'}.get(op, op)
|
|
return (field, inv_op, val)
|
|
|
|
|
|
# ── Collect all decision points with access paths ──
|
|
|
|
def _collect_all_dps(node, fields, path_cons=None, path_assign=None, depth=0):
|
|
"""Walk tree, collect list of (decision_point, access_path) tuples.
|
|
|
|
Returns list of dicts:
|
|
{ "node": decision_point_node,
|
|
"kind": "IF"|"EVALUATE"|"PERFORM"|"SEARCH"|"AT_END",
|
|
"access_constraints": [constraints to reach this point],
|
|
"branches": list of (branch_label, body_node_children)
|
|
"true_idx": index of "True" branch in branches,
|
|
"false_idx": index of "False" branch (or None),
|
|
}
|
|
"""
|
|
path_cons = list(path_cons or [])
|
|
path_assign = dict(path_assign or {})
|
|
result = []
|
|
|
|
if isinstance(node, BrIf):
|
|
parsed = _parse_condition(node.condition, fields)
|
|
dp = {
|
|
"node": node, "kind": "IF",
|
|
"condition": node.condition,
|
|
"parsed": parsed,
|
|
"access_constraints": list(path_cons),
|
|
"true_idx": 0,
|
|
"false_idx": 1 if parsed else None,
|
|
}
|
|
result.append(dp)
|
|
|
|
# Recurse into both branches
|
|
t_cons = list(path_cons)
|
|
f_cons = list(path_cons)
|
|
if parsed:
|
|
field, op, val = parsed
|
|
t_cons.append((field, op, val, True))
|
|
f_cons.append((field, op, val, False))
|
|
result.extend(_collect_all_dps(node.true_seq, fields, t_cons, path_assign, depth + 1))
|
|
result.extend(_collect_all_dps(node.false_seq, fields, f_cons, path_assign, depth + 1))
|
|
|
|
elif isinstance(node, BrEval):
|
|
dp = {
|
|
"node": node, "kind": "EVALUATE",
|
|
"subject": node.subject,
|
|
"access_constraints": list(path_cons),
|
|
}
|
|
result.append(dp)
|
|
for value, seq in node.when_list:
|
|
w_cons = list(path_cons)
|
|
if is_field(node.subject, fields):
|
|
w_cons.append((node.subject, '=', value, True))
|
|
result.extend(_collect_all_dps(seq, fields, w_cons, path_assign, depth + 1))
|
|
if node.has_other:
|
|
result.extend(_collect_all_dps(node.other_seq, fields, list(path_cons), path_assign, depth + 1))
|
|
|
|
elif isinstance(node, BrPerform):
|
|
if node.perf_type in ('until', 'para_until', 'varying', 'para_varying'):
|
|
parsed = _parse_condition(node.condition, fields)
|
|
dp = {
|
|
"node": node, "kind": "PERFORM",
|
|
"condition": node.condition,
|
|
"parsed": parsed,
|
|
"access_constraints": list(path_cons),
|
|
}
|
|
result.append(dp)
|
|
if parsed:
|
|
field, op, val = parsed
|
|
body_cons = list(path_cons) + [(field, op, val, False)]
|
|
else:
|
|
body_cons = list(path_cons)
|
|
result.extend(_collect_all_dps(node.body_seq, fields, body_cons, path_assign, depth + 1))
|
|
else:
|
|
result.extend(_collect_all_dps(node.body_seq, fields, list(path_cons), path_assign, depth + 1))
|
|
|
|
elif isinstance(node, BrSeq):
|
|
for child in node.children:
|
|
result.extend(_collect_all_dps(child, fields, path_cons, path_assign, depth))
|
|
|
|
elif isinstance(node, BrSearch):
|
|
dp = {
|
|
"node": node, "kind": "SEARCH",
|
|
"access_constraints": list(path_cons),
|
|
}
|
|
result.append(dp)
|
|
result.extend(_collect_all_dps(node.at_end_seq, fields, list(path_cons), path_assign, depth + 1))
|
|
for _, seq in node.when_list:
|
|
result.extend(_collect_all_dps(seq, fields, list(path_cons), path_assign, depth + 1))
|
|
|
|
return result
|
|
|
|
|
|
def _make_path_for_branch(dp, branch_idx, fields):
|
|
"""Create a single path (constraints, assignments) for one branch of a decision point."""
|
|
constraints = list(dp.get("access_constraints", []))
|
|
|
|
kind = dp["kind"]
|
|
|
|
if kind == "IF":
|
|
parsed = dp.get("parsed")
|
|
if parsed is None:
|
|
return ([], {})
|
|
field, op, val = parsed
|
|
want_true = (branch_idx == dp.get("true_idx", 0))
|
|
if not want_true:
|
|
field2, op2, val2 = _invert_condition(parsed)
|
|
field, op, val = field2, op2, val2
|
|
constraints.append((field, op, val, True))
|
|
# Pick body, just take first assignment
|
|
node = dp["node"]
|
|
body_seq = node.true_seq if branch_idx == 0 else node.false_seq
|
|
return (constraints, {})
|
|
|
|
if kind == "EVALUATE":
|
|
node = dp["node"]
|
|
n_when = len(node.when_list)
|
|
if branch_idx < n_when:
|
|
value, seq = node.when_list[branch_idx]
|
|
if is_field(node.subject, fields):
|
|
constraints.append((node.subject, '=', value, True))
|
|
prior_cases = [v for v, _ in node.when_list[:branch_idx]]
|
|
for prior in prior_cases:
|
|
constraints.append((node.subject, '<>', prior, True))
|
|
return (constraints, {})
|
|
|
|
if kind == "PERFORM":
|
|
parsed = dp.get("parsed")
|
|
if parsed is None:
|
|
return ([], {})
|
|
field, op, val = parsed
|
|
if branch_idx == 0:
|
|
constraints.append((field, op, val, False))
|
|
else:
|
|
constraints.append((field, op, val, True))
|
|
return (constraints, {})
|
|
|
|
return ([], {})
|
|
|
|
|
|
# ── Public API ──
|
|
|
|
def enum_paths(node, fields):
|
|
"""Linear path enumeration: one True + one False per decision point.
|
|
|
|
Returns list of (constraints, assignments) tuples.
|
|
Total paths = 2 * number_of_decision_points (capped at 1000).
|
|
"""
|
|
all_dps = _collect_all_dps(node, fields)
|
|
|
|
MAX_PATH = 1000
|
|
paths = []
|
|
|
|
# Start with one neutral path (no constraints)
|
|
paths.append(([], {}))
|
|
|
|
for dp in all_dps:
|
|
kind = dp["kind"]
|
|
|
|
if kind == "IF":
|
|
true_path = _make_path_for_branch(dp, dp.get("true_idx", 0), fields)
|
|
false_path = _make_path_for_branch(dp, dp.get("false_idx", 1) if dp.get("false_idx") is not None else dp.get("true_idx", 0), fields)
|
|
if true_path:
|
|
paths.append(true_path)
|
|
if false_path:
|
|
paths.append(false_path)
|
|
|
|
elif kind == "EVALUATE":
|
|
node = dp["node"]
|
|
for i in range(len(node.when_list)):
|
|
bp = _make_path_for_branch(dp, i, fields)
|
|
if bp: paths.append(bp)
|
|
if node.has_other:
|
|
other_cons = list(dp.get("access_constraints", []))
|
|
for v, _ in node.when_list:
|
|
if is_field(node.subject, fields):
|
|
other_cons.append((node.subject, '<>', v, True))
|
|
paths.append((other_cons, {}))
|
|
|
|
elif kind == "PERFORM":
|
|
enter_path = _make_path_for_branch(dp, 0, fields)
|
|
skip_path = _make_path_for_branch(dp, 1, fields)
|
|
if enter_path: paths.append(enter_path)
|
|
if skip_path: paths.append(skip_path)
|
|
|
|
if len(paths) >= MAX_PATH:
|
|
paths = paths[:MAX_PATH]
|
|
break
|
|
|
|
return paths
|
|
|
|
|
|
def _filter_stop(cons):
|
|
return [c for c in cons if c is not _STOP]
|