617 lines
21 KiB
Python
617 lines
21 KiB
Python
"""非DB COBOL程序的编译·执行·验证层（被 __init__.py 的 --gcov/--run 调用）
|
||
|
||
V3 编译方式（Windows 本地 cobc）+ SOURCE 分组执行+字段对比+出力保存。
|
||
"""
|
||
|
||
import logging
|
||
import os
|
||
import re
|
||
import shutil
|
||
import subprocess
|
||
from dataclasses import dataclass, field
|
||
from pathlib import Path
|
||
|
||
from . import file_io
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
# ── 数据模型 ──
|
||
|
||
|
||
@dataclass
|
||
class GroupInfo:
|
||
"""一组执行用例（SOURCE 版）"""
|
||
name: str
|
||
records: list[dict]
|
||
expected_outputs: list[dict]
|
||
expected_returncode: int = 0
|
||
fd_field_dicts: dict = field(default_factory=dict)
|
||
open_dir: dict = field(default_factory=dict)
|
||
select_info: dict = field(default_factory=dict)
|
||
overlap_mask: list[bool] = field(default_factory=list)
|
||
multi_write_fds: set = field(default_factory=set)
|
||
command_args: list = field(default_factory=list)
|
||
|
||
|
||
@dataclass
|
||
class CompareDetail:
|
||
"""单字段对比结果（兼容 __init__.py 的 DetailItem 接口）"""
|
||
field: str
|
||
expected: str
|
||
actual: str
|
||
match: bool
|
||
|
||
|
||
@dataclass
|
||
class GroupResult:
|
||
"""单组执行+对比结果"""
|
||
name: str
|
||
returncode: int
|
||
passed: bool
|
||
details: list[CompareDetail] = field(default_factory=list)
|
||
error_message: str = ''
|
||
|
||
|
||
# ── 路径解析（V3）──
|
||
|
||
|
||
def _resolve_sub_dir(source_dir: str) -> str:
|
||
p = Path(source_dir).resolve()
|
||
for d in [p.parent / 'sub', p / 'sub']:
|
||
if d.is_dir():
|
||
return str(d)
|
||
return str(p.parent / 'sub')
|
||
|
||
|
||
def _resolve_cpy_dir(source_dir: str) -> str:
|
||
p = Path(source_dir).resolve()
|
||
for d in [p.parent / 'cpy', p / 'cpy']:
|
||
if d.is_dir():
|
||
return str(d)
|
||
return str(p.parent / 'cpy')
|
||
|
||
|
||
def _input_assign_names(select_info: dict, open_dir: dict,
|
||
fd_fields: dict) -> list[str]:
|
||
names = []
|
||
seen = set()
|
||
for fd_name in fd_fields:
|
||
direction = (open_dir or {}).get(fd_name, '')
|
||
if direction not in ('INPUT', 'I-O'):
|
||
continue
|
||
assign = select_info.get(fd_name, {}).get('assign', '')
|
||
if assign and assign not in seen:
|
||
seen.add(assign)
|
||
names.append(assign)
|
||
return names
|
||
|
||
|
||
def _output_assign_names(select_info: dict, open_dir: dict,
|
||
fd_fields: dict) -> list[str]:
|
||
names = []
|
||
seen = set()
|
||
for fd_name in fd_fields:
|
||
direction = (open_dir or {}).get(fd_name, '')
|
||
if direction not in ('OUTPUT', 'I-O'):
|
||
continue
|
||
assign = select_info.get(fd_name, {}).get('assign', '')
|
||
if assign and assign not in seen:
|
||
seen.add(assign)
|
||
names.append(assign)
|
||
return names
|
||
|
||
|
||
# ── SUB 模块编译（V3）──
|
||
|
||
|
||
def compile_sub_modules(sub_dir: str, work_dir: str,
|
||
cpy_dir: str | None = None,
|
||
log_dir: str | None = None) -> list[str]:
|
||
sub_path = Path(sub_dir)
|
||
work_path = Path(work_dir)
|
||
work_path.mkdir(parents=True, exist_ok=True)
|
||
o_files = []
|
||
|
||
if not sub_path.is_dir():
|
||
logger.warning(f" SUB目录不存在: {sub_dir}")
|
||
return o_files
|
||
|
||
for cbl in sorted(sub_path.glob('*.cbl')):
|
||
o_path = work_path / f'{cbl.stem}.o'
|
||
gcno_path = work_path / f'{cbl.stem}.gcno'
|
||
if o_path.exists() and gcno_path.exists():
|
||
o_files.append(str(o_path))
|
||
continue
|
||
|
||
cmd = ['cobc', '-c', '-g', '--coverage', '-o', str(o_path)]
|
||
if cpy_dir:
|
||
cmd.extend(['-I', cpy_dir])
|
||
cmd.append(str(cbl))
|
||
|
||
logger.info(f" SUB: {cbl.name}")
|
||
orig = os.getcwd()
|
||
try:
|
||
os.chdir(str(work_path))
|
||
r = subprocess.run(cmd, capture_output=True, text=True, timeout=120, errors='replace')
|
||
finally:
|
||
os.chdir(orig)
|
||
if log_dir:
|
||
log_path = Path(log_dir) / 'compile' / f"sub_{cbl.stem}.log"
|
||
log_path.parent.mkdir(parents=True, exist_ok=True)
|
||
log_path.write_text(
|
||
f"COMMAND: {' '.join(cmd)}\n"
|
||
f"RETURNCODE: {r.returncode}\n\n"
|
||
f"STDOUT:\n{r.stdout}\n\n"
|
||
f"STDERR:\n{r.stderr}",
|
||
encoding='utf-8'
|
||
)
|
||
if r.returncode != 0:
|
||
logger.warning(f" SUB编译失败 {cbl.name}: {r.stderr.strip()[:200]}")
|
||
continue
|
||
o_files.append(str(o_path))
|
||
|
||
return o_files
|
||
|
||
|
||
def compile_program(program_name: str, source_dir: str, work_dir: str,
|
||
sub_objects: list[str],
|
||
cpy_dir: str | None = None,
|
||
log_dir: str | None = None) -> str:
|
||
work_path = Path(work_dir)
|
||
work_path.mkdir(parents=True, exist_ok=True)
|
||
|
||
src = Path(source_dir) / f'{program_name}.cbl'
|
||
if not src.exists():
|
||
raise FileNotFoundError(f"源文件不存在: {src}")
|
||
|
||
exe = work_path / f'{program_name}.exe'
|
||
|
||
cmd = ['cobc', '-x', '-g', '--coverage', '-o', str(exe)]
|
||
if cpy_dir:
|
||
cmd.extend(['-I', cpy_dir])
|
||
cmd.append(str(src))
|
||
cmd.extend(sub_objects)
|
||
|
||
logger.info(f" LINK: {program_name}.exe")
|
||
orig = os.getcwd()
|
||
try:
|
||
os.chdir(str(work_path))
|
||
r = subprocess.run(cmd, capture_output=True, text=True, timeout=120, errors='replace')
|
||
finally:
|
||
os.chdir(orig)
|
||
if log_dir:
|
||
log_path = Path(log_dir) / 'compile' / f"{program_name}.log"
|
||
log_path.parent.mkdir(parents=True, exist_ok=True)
|
||
log_path.write_text(
|
||
f"COMMAND: {' '.join(cmd)}\n"
|
||
f"RETURNCODE: {r.returncode}\n\n"
|
||
f"STDOUT:\n{r.stdout}\n\n"
|
||
f"STDERR:\n{r.stderr}",
|
||
encoding='utf-8'
|
||
)
|
||
if r.returncode != 0:
|
||
raise RuntimeError(f"编译失败 {program_name}: {r.stderr.strip()[:500]}")
|
||
return str(exe)
|
||
|
||
|
||
# ── 目录管理（SOURCE）──
|
||
|
||
|
||
def _clean_gcda(temp_dir: str):
|
||
for f in Path(temp_dir).glob('*.gcda'):
|
||
try:
|
||
f.unlink()
|
||
except OSError:
|
||
pass
|
||
|
||
|
||
# ── 工具函数（SOURCE）──
|
||
|
||
|
||
def _build_fd_field_dicts(fd_fields: dict, fields_dict: list) -> dict:
|
||
name_map = {f['name']: f for f in fields_dict}
|
||
result = {}
|
||
for fd_name, names in fd_fields.items():
|
||
result[fd_name] = []
|
||
for n in names:
|
||
if n in name_map:
|
||
pi = name_map[n].get('pic_info', {})
|
||
if pi.get('type') == 'unknown':
|
||
continue
|
||
result[fd_name].append(name_map[n])
|
||
return result
|
||
|
||
|
||
def _name_to_field(fields_dict: list[dict]) -> dict:
|
||
return {f['name']: f for f in fields_dict
|
||
if not f.get('is_88') and not f.get('is_filler')}
|
||
|
||
|
||
# ── 读取出力（SOURCE）──
|
||
|
||
|
||
def read_outputs(fd_field_dicts: dict, open_dir: dict,
|
||
select_info: dict, temp_dir: str) -> dict[str, list[dict]]:
|
||
result = {}
|
||
for fd_name, fds in fd_field_dicts.items():
|
||
direction = open_dir.get(fd_name, '')
|
||
if direction not in ('OUTPUT', 'I-O'):
|
||
continue
|
||
sel = select_info.get(fd_name, {})
|
||
if isinstance(sel, dict):
|
||
assign = sel.get('assign', fd_name)
|
||
org = sel.get('organization', 'SEQUENTIAL')
|
||
rec_mode = sel.get('recording_mode', 'F')
|
||
else:
|
||
assign = sel
|
||
org = 'SEQUENTIAL'
|
||
rec_mode = 'F'
|
||
outpath = os.path.join(temp_dir, assign)
|
||
if not os.path.exists(outpath):
|
||
logger.warning(f" 出力文件不存在: {outpath}")
|
||
continue
|
||
line_seq = (org == 'LINE SEQUENTIAL')
|
||
try:
|
||
records = file_io.read_output_file(
|
||
outpath, fds, line_sequential=line_seq, recording_mode=rec_mode
|
||
)
|
||
result[fd_name] = records
|
||
except Exception as e:
|
||
logger.warning(f" 读取出力文件失败 {outpath}: {e}")
|
||
continue
|
||
return result
|
||
|
||
|
||
# ── 对比（SOURCE）──
|
||
|
||
|
||
def compare_outputs(actual: list[dict], expected: list[dict],
|
||
fd_fields: list[dict],
|
||
subset_match: bool = False) -> tuple[bool, list[CompareDetail]]:
|
||
all_pass = True
|
||
details = []
|
||
|
||
if subset_match:
|
||
for exp in expected:
|
||
for fd in fd_fields:
|
||
fname = fd['name']
|
||
expected_val = exp.get(fname, '')
|
||
if not expected_val:
|
||
continue
|
||
found = any(
|
||
act.get(fname, '') == expected_val
|
||
for act in actual
|
||
)
|
||
if not found:
|
||
all_pass = False
|
||
details.append(CompareDetail(
|
||
field=fname,
|
||
expected=expected_val,
|
||
actual='(not found in actual)',
|
||
match=False,
|
||
))
|
||
return all_pass, details
|
||
|
||
if len(actual) != len(expected):
|
||
logger.warning(f" compare_outputs: actual={len(actual)} vs expected={len(expected)}")
|
||
for i, (act, exp) in enumerate(zip(actual, expected)):
|
||
for fd in fd_fields:
|
||
fname = fd['name']
|
||
actual_val = act.get(fname, '')
|
||
expected_val = exp.get(fname, '')
|
||
match = (actual_val == expected_val)
|
||
if not match:
|
||
all_pass = False
|
||
details.append(CompareDetail(
|
||
field=f'{fname}[{i}]',
|
||
expected=expected_val,
|
||
actual=actual_val,
|
||
match=match,
|
||
))
|
||
|
||
if len(actual) != len(expected):
|
||
all_pass = False
|
||
details.append(CompareDetail(
|
||
field='record_count',
|
||
expected=str(len(expected)),
|
||
actual=str(len(actual)),
|
||
match=False,
|
||
))
|
||
|
||
return all_pass, details
|
||
|
||
|
||
# ── 单组执行（SOURCE 改 - Native）──
|
||
|
||
|
||
def run_group(group: GroupInfo, exe_path: str, temp_dir: str,
|
||
log_dir: str | None = None) -> GroupResult:
|
||
logger.info(f" 执行组: {group.name} ({len(group.records)} 条记录)")
|
||
|
||
exe = Path(exe_path).resolve()
|
||
work_dir = Path(temp_dir).resolve()
|
||
|
||
orig = os.getcwd()
|
||
try:
|
||
os.chdir(str(work_dir))
|
||
result = subprocess.run(
|
||
[str(exe)] + list(group.command_args or []), capture_output=True, text=True,
|
||
encoding='utf-8', errors='replace', timeout=60,
|
||
)
|
||
except subprocess.TimeoutExpired:
|
||
return GroupResult(name=group.name, returncode=-1, passed=False,
|
||
error_message='timeout')
|
||
finally:
|
||
os.chdir(orig)
|
||
|
||
if log_dir:
|
||
log_path = Path(log_dir) / f"{group.name}.log"
|
||
log_path.parent.mkdir(parents=True, exist_ok=True)
|
||
log_path.write_text(
|
||
f"COMMAND: {' '.join([str(exe)])}\n"
|
||
f"RETURNCODE: {result.returncode}\n\n"
|
||
f"STDOUT:\n{result.stdout}\n\n"
|
||
f"STDERR:\n{result.stderr}",
|
||
encoding='utf-8'
|
||
)
|
||
|
||
rc = result.returncode
|
||
all_pass = (rc == group.expected_returncode)
|
||
all_details = []
|
||
|
||
if rc != group.expected_returncode:
|
||
all_details.append(CompareDetail(
|
||
field='returncode',
|
||
expected=str(group.expected_returncode),
|
||
actual=str(rc),
|
||
match=False,
|
||
))
|
||
|
||
return GroupResult(
|
||
name=group.name,
|
||
returncode=rc,
|
||
passed=all_pass,
|
||
details=all_details,
|
||
)
|
||
|
||
|
||
# ── 主编排 ──
|
||
|
||
|
||
def run_all(program_name: str, outdir: str, temp_dir: str,
|
||
fields_dict: list[dict], fd_fields: dict,
|
||
select_info: dict, open_dir: dict,
|
||
term_types: list[str], records: list[dict],
|
||
expected_records: list[dict] | None = None,
|
||
source_dir: str | None = None,
|
||
path_infos: list | None = None,
|
||
multi_write_fds: set | None = None,
|
||
skip_records: list[dict] | None = None,
|
||
skip_term_types: list[str] | None = None
|
||
) -> tuple[list[GroupResult], dict[int, int] | None]:
|
||
"""完整编排：编译 → 准备目录 → 逐组执行 → 出力保存。
|
||
|
||
Returns:
|
||
(results_list, merged_gcov_data)
|
||
merged_gcov_data is None when no gcov runs.
|
||
"""
|
||
source_dir = source_dir or str(Path(outdir).parent)
|
||
work_dir = Path(temp_dir).resolve()
|
||
work_dir.mkdir(parents=True, exist_ok=True)
|
||
expected = expected_records or []
|
||
path_infos = path_infos or []
|
||
multi_write_fds = multi_write_fds or set()
|
||
|
||
fd_field_dicts = _build_fd_field_dicts(fd_fields, fields_dict)
|
||
assign_names = _input_assign_names(select_info, open_dir, fd_fields)
|
||
log_dir = os.path.join(outdir, 'logs')
|
||
|
||
def _is_output_fd(fd_name: str) -> bool:
|
||
dir_val = open_dir.get(fd_name, '')
|
||
return dir_val in ('OUTPUT', 'I-O')
|
||
|
||
# ── 1. SUB 编译（V3）──
|
||
sub_dir = _resolve_sub_dir(source_dir)
|
||
cpy_dir = _resolve_cpy_dir(source_dir)
|
||
sub_o = compile_sub_modules(sub_dir, str(work_dir), cpy_dir, log_dir=log_dir)
|
||
|
||
# ── 2. 主程序编译（V3）──
|
||
exe_path = compile_program(
|
||
program_name, source_dir, str(work_dir), sub_o, cpy_dir, log_dir=log_dir
|
||
)
|
||
|
||
# ── 3. 场景定义 ──
|
||
scenes = [("main", records, term_types, expected,
|
||
Path(outdir) / 'main' / 'input', Path(outdir) / 'main' / 'output')]
|
||
if skip_records:
|
||
skip_expected = [{}] * len(skip_records)
|
||
skip_term = skip_term_types or ['normal'] * len(skip_records)
|
||
scenes.append(("skip", skip_records, skip_term, skip_expected,
|
||
Path(outdir) / 'skip' / 'input', Path(outdir) / 'skip' / 'output'))
|
||
|
||
results = []
|
||
gcov_data_sets = []
|
||
gcov_root = work_dir / "gcov"
|
||
|
||
for scene_id, scene_recs, scene_terms, scene_expected, src_in_dir, dst_out_dir in scenes:
|
||
# ── 3a. 入力ファイル配置（主程序 + 被调子程序的输入文件全部复制）──
|
||
# 仅复制 assign_names 会漏掉子程序输入文件（测试驱动调用读文件自程序时
|
||
# 会 OPEN 失败 ABEND）。复制目录内全部非 JSON 文件（.json 为 V3 元数据）。
|
||
if src_in_dir.is_dir():
|
||
for src in sorted(src_in_dir.iterdir()):
|
||
if not src.is_file() or src.suffix.lower() == '.json':
|
||
continue
|
||
shutil.copy2(str(src), str(work_dir / src.name))
|
||
|
||
# ── 3b. 清理旧 gcda ──
|
||
_clean_gcda(str(work_dir))
|
||
|
||
# ── 3c. 过滤 non-abend ──
|
||
filtered_exp = []
|
||
normal_recs = []
|
||
abend_pairs = [] # (rec, command_args)
|
||
for i, rec in enumerate(scene_expected):
|
||
term = scene_terms[i] if i < len(scene_terms) else 'normal'
|
||
if term != 'abend':
|
||
filtered_exp.append(rec)
|
||
for i, rec in enumerate(scene_recs):
|
||
term = scene_terms[i] if i < len(scene_terms) else 'normal'
|
||
if term == 'abend':
|
||
abend_pairs.append((rec, list((rec.get('__CLI_ARGS__') or {}).values())))
|
||
else:
|
||
normal_recs.append(rec)
|
||
|
||
group = GroupInfo(
|
||
name=f"{program_name}_{scene_id}",
|
||
records=normal_recs,
|
||
expected_outputs=filtered_exp,
|
||
expected_returncode=0,
|
||
fd_field_dicts=fd_field_dicts,
|
||
open_dir=open_dir,
|
||
select_info=select_info,
|
||
multi_write_fds=multi_write_fds,
|
||
)
|
||
|
||
# ── 3d. 执行 ──
|
||
r = run_group(group, exe_path, str(work_dir), log_dir=log_dir)
|
||
results.append(r)
|
||
|
||
status = '✓' if r.passed else '✗'
|
||
logger.info(f" 组 '{group.name}': returncode={r.returncode}, {status}")
|
||
|
||
# ── 3d-2. abend 记录单独执行（带命令行参数，触发 ABEND/异常返回）──
|
||
for ab_idx, (ab_rec, ab_args) in enumerate(abend_pairs):
|
||
ab_group = GroupInfo(
|
||
name=f"{program_name}_{scene_id}_abend_{ab_idx + 1}",
|
||
records=[ab_rec], expected_outputs=[],
|
||
expected_returncode=1,
|
||
fd_field_dicts=fd_field_dicts,
|
||
open_dir=open_dir,
|
||
select_info=select_info,
|
||
multi_write_fds=multi_write_fds,
|
||
command_args=ab_args,
|
||
)
|
||
r2 = run_group(ab_group, exe_path, str(work_dir), log_dir=log_dir)
|
||
results.append(r2)
|
||
status2 = '✓' if r2.passed else '✗'
|
||
logger.info(f" 组 '{ab_group.name}': returncode={r2.returncode}, {status2}")
|
||
|
||
# ── 3e. 出力保存 ──
|
||
dst_out_dir.mkdir(parents=True, exist_ok=True)
|
||
for fd_name in fd_field_dicts:
|
||
if not _is_output_fd(fd_name):
|
||
continue
|
||
sel = select_info.get(fd_name, {})
|
||
assign = sel.get('assign', fd_name) if isinstance(sel, dict) else fd_name
|
||
src = os.path.join(str(work_dir), assign)
|
||
if os.path.exists(src):
|
||
shutil.copy2(src, str(dst_out_dir / assign))
|
||
|
||
# ── 3f. .gcda 隔离（.gcno 是共享的，COPY；.gcda 是每场景独立的，MOVE）
|
||
scene_gcov_dir = gcov_root / f"run_{scene_id}"
|
||
scene_gcov_dir.mkdir(parents=True, exist_ok=True)
|
||
for f in work_dir.glob("*.gcda"):
|
||
if f.is_file() and f.stat().st_size > 0:
|
||
dst = scene_gcov_dir / f.name
|
||
if dst.exists():
|
||
dst.unlink()
|
||
shutil.move(str(f), str(dst))
|
||
for f in work_dir.glob("*.gcno"):
|
||
if f.is_file() and f.stat().st_size > 0:
|
||
dst = scene_gcov_dir / f.name
|
||
shutil.copy2(str(f), str(dst))
|
||
|
||
# ── 3g. 收集该场景的 gcov 数据 ──
|
||
from .gcov import run_gcov as _run_gcov
|
||
scene_data = _run_gcov(program_name, str(scene_gcov_dir))
|
||
if scene_data:
|
||
gcov_data_sets.append(scene_data)
|
||
|
||
logger.info(f" {scene_id} 完了, output={dst_out_dir}")
|
||
|
||
# ── 4. 合并 gcov ──
|
||
merged_gcov = None
|
||
if gcov_data_sets:
|
||
merged_gcov = {}
|
||
for ds in gcov_data_sets:
|
||
for line, count in ds.items():
|
||
merged_gcov[line] = max(merged_gcov.get(line, 0), count)
|
||
logger.info(f" Merged gcov from {len(gcov_data_sets)} runs ({len(merged_gcov)} lines)")
|
||
|
||
return results, merged_gcov
|
||
|
||
|
||
# ── run_and_compare（被 --run 调用，SOURCE 兼容）──
|
||
|
||
|
||
def run_and_compare(program_name: str, outdir: str,
|
||
fields_dict: list[dict], fd_fields: dict,
|
||
select_info: dict, open_dir: dict,
|
||
term_types: list[str], records: list[dict]) -> dict:
|
||
"""旧版接口兼容包装。返回 {normal_pass, normal_count, ...}。"""
|
||
fd_field_dicts = _build_fd_field_dicts(fd_fields, fields_dict)
|
||
|
||
normal_recs = []
|
||
abend_recs = []
|
||
for i, term in enumerate(term_types):
|
||
if term == 'abend' and i < len(records):
|
||
abend_recs.append(records[i])
|
||
elif i < len(records):
|
||
normal_recs.append(records[i])
|
||
|
||
result = {
|
||
'normal_pass': False, 'normal_count': 0,
|
||
'abend_pass': 0, 'abend_total': len(abend_recs),
|
||
'output_summary': {},
|
||
}
|
||
|
||
temp_dir = os.path.join(outdir, '.run_cache')
|
||
source_dir = os.path.join(outdir, '..', 'input')
|
||
log_dir = os.path.join(outdir, 'logs')
|
||
|
||
work_dir = Path(temp_dir)
|
||
work_dir.mkdir(parents=True, exist_ok=True)
|
||
_clean_gcda(temp_dir)
|
||
|
||
sub_dir = _resolve_sub_dir(source_dir)
|
||
cpy_dir = _resolve_cpy_dir(source_dir)
|
||
sub_o = compile_sub_modules(sub_dir, temp_dir, cpy_dir, log_dir=log_dir)
|
||
exe_path = compile_program(program_name, source_dir, temp_dir, sub_o, cpy_dir, log_dir=log_dir)
|
||
|
||
if normal_recs:
|
||
group = GroupInfo(
|
||
name='normal', records=normal_recs, expected_outputs=[],
|
||
fd_field_dicts=fd_field_dicts, open_dir=open_dir,
|
||
select_info=select_info,
|
||
)
|
||
r = run_group(group, exe_path, temp_dir, log_dir=log_dir)
|
||
result['normal_pass'] = (r.returncode == 0)
|
||
result['normal_returncode'] = r.returncode
|
||
for fd_name in fd_field_dicts:
|
||
sel = select_info.get(fd_name, {})
|
||
assign = sel.get('assign', fd_name) if isinstance(sel, dict) else fd_name
|
||
outpath = os.path.join(temp_dir, assign)
|
||
fds = fd_field_dicts.get(fd_name, [])
|
||
org = sel.get('organization', 'SEQUENTIAL') if isinstance(sel, dict) else 'SEQUENTIAL'
|
||
line_seq = (org == 'LINE SEQUENTIAL')
|
||
try:
|
||
recs = file_io.read_output_file(outpath, fds, line_sequential=line_seq)
|
||
result['output_summary'][fd_name] = len(recs)
|
||
except Exception:
|
||
result['output_summary'][fd_name] = -1
|
||
|
||
for i, rec in enumerate(abend_recs):
|
||
group = GroupInfo(
|
||
name=f'abend_{i+1}', records=[rec], expected_outputs=[],
|
||
expected_returncode=1,
|
||
fd_field_dicts=fd_field_dicts, open_dir=open_dir,
|
||
select_info=select_info,
|
||
command_args=list((rec.get('__CLI_ARGS__') or {}).values()),
|
||
)
|
||
r = run_group(group, exe_path, temp_dir, log_dir=log_dir)
|
||
if r.returncode != 0:
|
||
result['abend_pass'] += 1
|
||
|
||
return result
|