S03-H3 CLOSED baseline
This commit is contained in:
+589
@@ -0,0 +1,589 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Fail-closed parser for the MARTe2 S03 FileWriter binary contract."""
|
||||
|
||||
import argparse
|
||||
import struct
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
UINT32_TYPE_HEX = "0408"
|
||||
UINT32_BYTES = 4
|
||||
SIGNAL_HEADER_BYTES = 2 + 32 + 4
|
||||
|
||||
SENTINEL_SCALAR_A = 324508639 # 0x13579BDF
|
||||
SENTINEL_SCALAR_B = 610839776 # 0x2468ACE0
|
||||
SENTINEL_VECTOR = (16909060, 286397204, 555885348)
|
||||
|
||||
EXPECTED_SIGNALS = (
|
||||
("Counter", UINT32_TYPE_HEX, 1),
|
||||
("Time", UINT32_TYPE_HEX, 1),
|
||||
("State1_Thread1_CycleTime", UINT32_TYPE_HEX, 1),
|
||||
("SentinelScalarA", UINT32_TYPE_HEX, 1),
|
||||
("SentinelScalarB", UINT32_TYPE_HEX, 1),
|
||||
("SentinelVector", UINT32_TYPE_HEX, 3),
|
||||
)
|
||||
|
||||
EXPECTED_OFFSETS = (0, 4, 8, 12, 16, 20)
|
||||
EXPECTED_RECORD_BYTES = 32
|
||||
EXPECTED_HEADER_BYTES = 4 + len(EXPECTED_SIGNALS) * SIGNAL_HEADER_BYTES
|
||||
|
||||
STATUS_ORDER = (
|
||||
"HEADER_STATUS",
|
||||
"RECORD_LAYOUT_STATUS",
|
||||
"PAYLOAD_ALIGNMENT_STATUS",
|
||||
"TRUNCATION_STATUS",
|
||||
"SIGNAL_COUNT_STATUS",
|
||||
"SIGNAL_NAMES_STATUS",
|
||||
"SIGNAL_TYPES_STATUS",
|
||||
"SIGNAL_ELEMENTS_STATUS",
|
||||
"SIGNAL_ORDER_STATUS",
|
||||
"COUNTER_STATUS",
|
||||
"TIME_STATUS",
|
||||
"CYCLE_TIME_STATUS",
|
||||
"SENTINEL_SCALAR_A_STATUS",
|
||||
"SENTINEL_SCALAR_B_STATUS",
|
||||
"SENTINEL_VECTOR_STATUS",
|
||||
"SENTINEL_SEQUENCE_STATUS",
|
||||
"FUNCTIONAL_BINARY_STATUS",
|
||||
"SEMANTIC_BINARY_STATUS",
|
||||
"BINARY_STATUS",
|
||||
)
|
||||
|
||||
|
||||
def safe_value(value):
|
||||
return str(value).replace("\r", "\\r").replace("\n", "\\n")
|
||||
|
||||
|
||||
class Report:
|
||||
def __init__(self):
|
||||
self.status = {name: "NOT_EVALUATED" for name in STATUS_ORDER}
|
||||
self.details = {}
|
||||
self.first_error = {
|
||||
"FIRST_ERROR_CODE": "NONE",
|
||||
"EXPECTED": "NOT_APPLICABLE",
|
||||
"OBSERVED": "NOT_APPLICABLE",
|
||||
"RECORD_INDEX": "NOT_APPLICABLE",
|
||||
"SIGNAL_NAME": "NOT_APPLICABLE",
|
||||
"ELEMENT_INDEX": "NOT_APPLICABLE",
|
||||
"BYTE_OFFSET": "NOT_APPLICABLE",
|
||||
}
|
||||
|
||||
def set_error(
|
||||
self,
|
||||
code,
|
||||
expected="NOT_APPLICABLE",
|
||||
observed="NOT_APPLICABLE",
|
||||
record_index="NOT_APPLICABLE",
|
||||
signal_name="NOT_APPLICABLE",
|
||||
element_index="NOT_APPLICABLE",
|
||||
byte_offset="NOT_APPLICABLE",
|
||||
):
|
||||
if self.first_error["FIRST_ERROR_CODE"] != "NONE":
|
||||
return
|
||||
self.first_error.update(
|
||||
{
|
||||
"FIRST_ERROR_CODE": safe_value(code),
|
||||
"EXPECTED": safe_value(expected),
|
||||
"OBSERVED": safe_value(observed),
|
||||
"RECORD_INDEX": safe_value(record_index),
|
||||
"SIGNAL_NAME": safe_value(signal_name),
|
||||
"ELEMENT_INDEX": safe_value(element_index),
|
||||
"BYTE_OFFSET": safe_value(byte_offset),
|
||||
}
|
||||
)
|
||||
|
||||
def emit(self):
|
||||
for key in STATUS_ORDER:
|
||||
print(f"{key}={self.status[key]}")
|
||||
for key in sorted(self.details):
|
||||
print(f"{key}={safe_value(self.details[key])}")
|
||||
for key in (
|
||||
"FIRST_ERROR_CODE",
|
||||
"EXPECTED",
|
||||
"OBSERVED",
|
||||
"RECORD_INDEX",
|
||||
"SIGNAL_NAME",
|
||||
"ELEMENT_INDEX",
|
||||
"BYTE_OFFSET",
|
||||
):
|
||||
print(f"{key}={self.first_error[key]}")
|
||||
|
||||
|
||||
def padded_name(raw):
|
||||
try:
|
||||
return raw.split(b"\x00", 1)[0].decode("ascii")
|
||||
except UnicodeDecodeError:
|
||||
return raw.split(b"\x00", 1)[0].decode("ascii", errors="replace")
|
||||
|
||||
|
||||
def finish_early(report, exit_code):
|
||||
report.status["FUNCTIONAL_BINARY_STATUS"] = "FAIL"
|
||||
report.status["SEMANTIC_BINARY_STATUS"] = "NOT_DEMONSTRATED"
|
||||
report.status["BINARY_STATUS"] = "FAIL"
|
||||
report.emit()
|
||||
return exit_code
|
||||
|
||||
|
||||
def parse_binary(path, min_samples):
|
||||
report = Report()
|
||||
|
||||
try:
|
||||
data = path.read_bytes()
|
||||
except OSError as exc:
|
||||
report.status["HEADER_STATUS"] = "FAIL"
|
||||
report.status["TRUNCATION_STATUS"] = "FAIL"
|
||||
report.details["FILE_SIZE_BYTES"] = "NOT_AVAILABLE"
|
||||
report.set_error("FILE_READ_ERROR", observed=exc)
|
||||
return report, finish_early(report, 31), True
|
||||
|
||||
report.details["FILE_SIZE_BYTES"] = len(data)
|
||||
report.details["EXPECTED_HEADER_BYTES"] = EXPECTED_HEADER_BYTES
|
||||
report.details["EXPECTED_RECORD_BYTES"] = EXPECTED_RECORD_BYTES
|
||||
report.details["EXPECTED_SIGNAL_COUNT"] = len(EXPECTED_SIGNALS)
|
||||
|
||||
if len(data) < 4:
|
||||
report.status["HEADER_STATUS"] = "FAIL"
|
||||
report.status["TRUNCATION_STATUS"] = "FAIL"
|
||||
report.status["SIGNAL_COUNT_STATUS"] = "NOT_EVALUATED"
|
||||
report.set_error(
|
||||
"HEADER_TOO_SMALL",
|
||||
expected="AT_LEAST_4_BYTES",
|
||||
observed=f"{len(data)}_BYTES",
|
||||
byte_offset=len(data),
|
||||
)
|
||||
return report, 31, False
|
||||
|
||||
signal_count = struct.unpack_from("<I", data, 0)[0]
|
||||
report.details["OBSERVED_SIGNAL_COUNT"] = signal_count
|
||||
|
||||
if signal_count > 4096:
|
||||
report.status["HEADER_STATUS"] = "FAIL"
|
||||
report.status["TRUNCATION_STATUS"] = "FAIL"
|
||||
report.status["SIGNAL_COUNT_STATUS"] = "FAIL"
|
||||
report.set_error(
|
||||
"SIGNAL_COUNT_UNREASONABLE",
|
||||
expected=len(EXPECTED_SIGNALS),
|
||||
observed=signal_count,
|
||||
byte_offset=0,
|
||||
)
|
||||
return report, 32, False
|
||||
|
||||
if signal_count == len(EXPECTED_SIGNALS):
|
||||
report.status["SIGNAL_COUNT_STATUS"] = "PASS"
|
||||
else:
|
||||
report.status["SIGNAL_COUNT_STATUS"] = "FAIL"
|
||||
report.set_error(
|
||||
"SIGNAL_COUNT_MISMATCH",
|
||||
expected=len(EXPECTED_SIGNALS),
|
||||
observed=signal_count,
|
||||
byte_offset=0,
|
||||
)
|
||||
|
||||
offset = 4
|
||||
observed = []
|
||||
for index in range(signal_count):
|
||||
if offset + SIGNAL_HEADER_BYTES > len(data):
|
||||
report.status["HEADER_STATUS"] = "FAIL"
|
||||
report.status["TRUNCATION_STATUS"] = "FAIL"
|
||||
report.set_error(
|
||||
"TRUNCATED_SIGNAL_HEADER",
|
||||
expected=SIGNAL_HEADER_BYTES,
|
||||
observed=max(0, len(data) - offset),
|
||||
signal_name=f"SIGNAL_{index}",
|
||||
byte_offset=offset,
|
||||
)
|
||||
report.details["OBSERVED_HEADER_BYTES"] = offset
|
||||
return report, 33, False
|
||||
|
||||
type_offset = offset
|
||||
type_hex = data[offset : offset + 2].hex()
|
||||
offset += 2
|
||||
name_offset = offset
|
||||
name = padded_name(data[offset : offset + 32])
|
||||
offset += 32
|
||||
elements_offset = offset
|
||||
elements = struct.unpack_from("<I", data, offset)[0]
|
||||
offset += 4
|
||||
|
||||
observed.append(
|
||||
{
|
||||
"name": name,
|
||||
"type_hex": type_hex,
|
||||
"elements": elements,
|
||||
"type_offset": type_offset,
|
||||
"name_offset": name_offset,
|
||||
"elements_offset": elements_offset,
|
||||
}
|
||||
)
|
||||
report.details[f"SIGNAL_{index}_NAME"] = name
|
||||
report.details[f"SIGNAL_{index}_TYPE_HEX"] = type_hex
|
||||
report.details[f"SIGNAL_{index}_NUMBER_OF_ELEMENTS"] = elements
|
||||
|
||||
report.status["HEADER_STATUS"] = "PASS"
|
||||
report.details["OBSERVED_HEADER_BYTES"] = offset
|
||||
header_bytes = offset
|
||||
|
||||
observed_names = [item["name"] for item in observed]
|
||||
expected_names = [item[0] for item in EXPECTED_SIGNALS]
|
||||
report.details["OBSERVED_SIGNAL_NAMES"] = ",".join(observed_names)
|
||||
report.details["EXPECTED_SIGNAL_NAMES"] = ",".join(expected_names)
|
||||
|
||||
duplicates = sorted({name for name in observed_names if observed_names.count(name) > 1})
|
||||
if duplicates:
|
||||
report.status["SIGNAL_NAMES_STATUS"] = "FAIL"
|
||||
report.status["SIGNAL_ORDER_STATUS"] = "FAIL"
|
||||
report.set_error(
|
||||
"DUPLICATE_SIGNAL_NAME",
|
||||
expected="UNIQUE_NAMES",
|
||||
observed=",".join(duplicates),
|
||||
)
|
||||
elif sorted(observed_names) == sorted(expected_names):
|
||||
report.status["SIGNAL_NAMES_STATUS"] = "PASS"
|
||||
if observed_names == expected_names:
|
||||
report.status["SIGNAL_ORDER_STATUS"] = "PASS"
|
||||
else:
|
||||
report.status["SIGNAL_ORDER_STATUS"] = "FAIL"
|
||||
first_index = next(
|
||||
index
|
||||
for index, pair in enumerate(zip(observed_names, expected_names))
|
||||
if pair[0] != pair[1]
|
||||
)
|
||||
report.set_error(
|
||||
"SIGNAL_ORDER_MISMATCH",
|
||||
expected=expected_names[first_index],
|
||||
observed=observed_names[first_index],
|
||||
signal_name=observed_names[first_index],
|
||||
byte_offset=observed[first_index]["name_offset"],
|
||||
)
|
||||
else:
|
||||
report.status["SIGNAL_NAMES_STATUS"] = "FAIL"
|
||||
report.status["SIGNAL_ORDER_STATUS"] = "FAIL"
|
||||
mismatch_index = 0
|
||||
for mismatch_index in range(min(len(observed_names), len(expected_names))):
|
||||
if observed_names[mismatch_index] != expected_names[mismatch_index]:
|
||||
break
|
||||
observed_name = (
|
||||
observed_names[mismatch_index]
|
||||
if mismatch_index < len(observed_names)
|
||||
else "MISSING"
|
||||
)
|
||||
expected_name = (
|
||||
expected_names[mismatch_index]
|
||||
if mismatch_index < len(expected_names)
|
||||
else "NO_ADDITIONAL_SIGNAL"
|
||||
)
|
||||
byte_offset = (
|
||||
observed[mismatch_index]["name_offset"]
|
||||
if mismatch_index < len(observed)
|
||||
else header_bytes
|
||||
)
|
||||
report.set_error(
|
||||
"SIGNAL_NAME_MISMATCH",
|
||||
expected=expected_name,
|
||||
observed=observed_name,
|
||||
signal_name=observed_name,
|
||||
byte_offset=byte_offset,
|
||||
)
|
||||
|
||||
types_ok = len(observed) == len(EXPECTED_SIGNALS)
|
||||
elements_ok = len(observed) == len(EXPECTED_SIGNALS)
|
||||
observed_offsets = []
|
||||
running_offset = 0
|
||||
|
||||
for index, item in enumerate(observed):
|
||||
observed_offsets.append(running_offset)
|
||||
width = UINT32_BYTES if item["type_hex"] == UINT32_TYPE_HEX else UINT32_BYTES
|
||||
running_offset += width * item["elements"]
|
||||
report.details[f"SIGNAL_{index}_OBSERVED_OFFSET"] = observed_offsets[-1]
|
||||
if index < len(EXPECTED_OFFSETS):
|
||||
report.details[f"SIGNAL_{index}_EXPECTED_OFFSET"] = EXPECTED_OFFSETS[index]
|
||||
|
||||
if index >= len(EXPECTED_SIGNALS):
|
||||
types_ok = False
|
||||
elements_ok = False
|
||||
continue
|
||||
|
||||
expected_name, expected_type, expected_elements = EXPECTED_SIGNALS[index]
|
||||
if item["type_hex"] != expected_type:
|
||||
types_ok = False
|
||||
report.set_error(
|
||||
"SIGNAL_TYPE_MISMATCH",
|
||||
expected=expected_type,
|
||||
observed=item["type_hex"],
|
||||
signal_name=expected_name,
|
||||
byte_offset=item["type_offset"],
|
||||
)
|
||||
if item["elements"] != expected_elements:
|
||||
elements_ok = False
|
||||
report.set_error(
|
||||
"SIGNAL_ELEMENTS_MISMATCH",
|
||||
expected=expected_elements,
|
||||
observed=item["elements"],
|
||||
signal_name=expected_name,
|
||||
byte_offset=item["elements_offset"],
|
||||
)
|
||||
|
||||
report.status["SIGNAL_TYPES_STATUS"] = "PASS" if types_ok else "FAIL"
|
||||
report.status["SIGNAL_ELEMENTS_STATUS"] = "PASS" if elements_ok else "FAIL"
|
||||
report.details["OBSERVED_RECORD_BYTES_FROM_HEADER"] = running_offset
|
||||
|
||||
layout_ok = all(
|
||||
report.status[name] == "PASS"
|
||||
for name in (
|
||||
"SIGNAL_COUNT_STATUS",
|
||||
"SIGNAL_NAMES_STATUS",
|
||||
"SIGNAL_TYPES_STATUS",
|
||||
"SIGNAL_ELEMENTS_STATUS",
|
||||
"SIGNAL_ORDER_STATUS",
|
||||
)
|
||||
) and observed_offsets == list(EXPECTED_OFFSETS)
|
||||
|
||||
report.status["RECORD_LAYOUT_STATUS"] = "PASS" if layout_ok else "FAIL"
|
||||
if not layout_ok and report.first_error["FIRST_ERROR_CODE"] == "NONE":
|
||||
report.set_error(
|
||||
"RECORD_LAYOUT_MISMATCH",
|
||||
expected=EXPECTED_RECORD_BYTES,
|
||||
observed=running_offset,
|
||||
)
|
||||
|
||||
payload_bytes = len(data) - header_bytes
|
||||
remainder_bytes = payload_bytes % EXPECTED_RECORD_BYTES
|
||||
sample_count = payload_bytes // EXPECTED_RECORD_BYTES
|
||||
report.details["PAYLOAD_BYTES"] = payload_bytes
|
||||
report.details["PAYLOAD_REMAINDER_BYTES"] = remainder_bytes
|
||||
report.details["COMPLETE_SAMPLE_COUNT"] = sample_count
|
||||
report.details["MINIMUM_SAMPLE_COUNT"] = min_samples
|
||||
|
||||
if remainder_bytes == 0:
|
||||
report.status["PAYLOAD_ALIGNMENT_STATUS"] = "PASS"
|
||||
report.status["TRUNCATION_STATUS"] = "PASS"
|
||||
else:
|
||||
report.status["PAYLOAD_ALIGNMENT_STATUS"] = "FAIL"
|
||||
report.status["TRUNCATION_STATUS"] = "FAIL"
|
||||
report.set_error(
|
||||
"PAYLOAD_SIZE_NOT_MULTIPLE_OF_RECORD",
|
||||
expected=f"MULTIPLE_OF_{EXPECTED_RECORD_BYTES}",
|
||||
observed=f"REMAINDER_{remainder_bytes}",
|
||||
byte_offset=header_bytes + sample_count * EXPECTED_RECORD_BYTES,
|
||||
)
|
||||
|
||||
if sample_count < min_samples:
|
||||
report.set_error(
|
||||
"INSUFFICIENT_SAMPLES",
|
||||
expected=f"AT_LEAST_{min_samples}",
|
||||
observed=sample_count,
|
||||
)
|
||||
|
||||
records = []
|
||||
if remainder_bytes == 0:
|
||||
for record_index in range(sample_count):
|
||||
start = header_bytes + record_index * EXPECTED_RECORD_BYTES
|
||||
records.append(struct.unpack_from("<8I", data, start))
|
||||
|
||||
counters = [record[0] for record in records]
|
||||
times = [record[1] for record in records]
|
||||
cycle_times = [record[2] for record in records]
|
||||
|
||||
counter_error = None
|
||||
if counters:
|
||||
if counters[0] != 1:
|
||||
counter_error = (0, 1, counters[0])
|
||||
else:
|
||||
for index in range(1, len(counters)):
|
||||
if counters[index] != counters[index - 1] + 1:
|
||||
counter_error = (index, counters[index - 1] + 1, counters[index])
|
||||
break
|
||||
else:
|
||||
counter_error = ("NOT_APPLICABLE", "AT_LEAST_ONE_RECORD", "NO_RECORDS")
|
||||
|
||||
if counter_error is None:
|
||||
report.status["COUNTER_STATUS"] = "PASS"
|
||||
else:
|
||||
report.status["COUNTER_STATUS"] = "FAIL"
|
||||
record_index, expected_counter, observed_counter = counter_error
|
||||
byte_offset = (
|
||||
header_bytes + int(record_index) * EXPECTED_RECORD_BYTES
|
||||
if isinstance(record_index, int)
|
||||
else header_bytes
|
||||
)
|
||||
report.set_error(
|
||||
"COUNTER_SEQUENCE_MISMATCH",
|
||||
expected=expected_counter,
|
||||
observed=observed_counter,
|
||||
record_index=record_index,
|
||||
signal_name="Counter",
|
||||
element_index=0,
|
||||
byte_offset=byte_offset,
|
||||
)
|
||||
|
||||
time_error = None
|
||||
for index in range(1, len(times)):
|
||||
if times[index] < times[index - 1]:
|
||||
time_error = (index, f">={times[index - 1]}", times[index])
|
||||
break
|
||||
if records and time_error is None:
|
||||
report.status["TIME_STATUS"] = "PASS"
|
||||
else:
|
||||
report.status["TIME_STATUS"] = "FAIL"
|
||||
if time_error is not None:
|
||||
record_index, expected_time, observed_time = time_error
|
||||
report.set_error(
|
||||
"TIME_REGRESSION",
|
||||
expected=expected_time,
|
||||
observed=observed_time,
|
||||
record_index=record_index,
|
||||
signal_name="Time",
|
||||
element_index=0,
|
||||
byte_offset=header_bytes + record_index * EXPECTED_RECORD_BYTES + 4,
|
||||
)
|
||||
|
||||
nonzero_cycle_times = [value for value in cycle_times if value > 0]
|
||||
if records and nonzero_cycle_times:
|
||||
report.status["CYCLE_TIME_STATUS"] = "PASS"
|
||||
else:
|
||||
report.status["CYCLE_TIME_STATUS"] = "FAIL"
|
||||
report.set_error(
|
||||
"NO_NONZERO_CYCLE_TIME",
|
||||
expected="AT_LEAST_ONE_NONZERO_SAMPLE",
|
||||
observed=len(nonzero_cycle_times),
|
||||
signal_name="State1_Thread1_CycleTime",
|
||||
byte_offset=header_bytes + 8,
|
||||
)
|
||||
|
||||
sentinel_failures = {
|
||||
"A": None,
|
||||
"B": None,
|
||||
"VECTOR": None,
|
||||
}
|
||||
|
||||
for record_index, record in enumerate(records):
|
||||
if sentinel_failures["A"] is None and record[3] != SENTINEL_SCALAR_A:
|
||||
sentinel_failures["A"] = (record_index, 0, SENTINEL_SCALAR_A, record[3], 12)
|
||||
if sentinel_failures["B"] is None and record[4] != SENTINEL_SCALAR_B:
|
||||
sentinel_failures["B"] = (record_index, 0, SENTINEL_SCALAR_B, record[4], 16)
|
||||
for element_index, expected_value in enumerate(SENTINEL_VECTOR):
|
||||
observed_value = record[5 + element_index]
|
||||
if sentinel_failures["VECTOR"] is None and observed_value != expected_value:
|
||||
sentinel_failures["VECTOR"] = (
|
||||
record_index,
|
||||
element_index,
|
||||
expected_value,
|
||||
observed_value,
|
||||
20 + element_index * UINT32_BYTES,
|
||||
)
|
||||
|
||||
for key, status_name, signal_name in (
|
||||
("A", "SENTINEL_SCALAR_A_STATUS", "SentinelScalarA"),
|
||||
("B", "SENTINEL_SCALAR_B_STATUS", "SentinelScalarB"),
|
||||
("VECTOR", "SENTINEL_VECTOR_STATUS", "SentinelVector"),
|
||||
):
|
||||
failure = sentinel_failures[key]
|
||||
if records and failure is None:
|
||||
report.status[status_name] = "PASS"
|
||||
else:
|
||||
report.status[status_name] = "FAIL"
|
||||
if failure is not None:
|
||||
record_index, element_index, expected_value, observed_value, field_offset = failure
|
||||
code = {
|
||||
"A": "SENTINEL_SCALAR_A_MISMATCH",
|
||||
"B": "SENTINEL_SCALAR_B_MISMATCH",
|
||||
"VECTOR": "SENTINEL_VECTOR_MISMATCH",
|
||||
}[key]
|
||||
report.set_error(
|
||||
code,
|
||||
expected=expected_value,
|
||||
observed=observed_value,
|
||||
record_index=record_index,
|
||||
signal_name=signal_name,
|
||||
element_index=element_index,
|
||||
byte_offset=header_bytes
|
||||
+ record_index * EXPECTED_RECORD_BYTES
|
||||
+ field_offset,
|
||||
)
|
||||
|
||||
sentinel_values_ok = all(
|
||||
report.status[name] == "PASS"
|
||||
for name in (
|
||||
"SENTINEL_SCALAR_A_STATUS",
|
||||
"SENTINEL_SCALAR_B_STATUS",
|
||||
"SENTINEL_VECTOR_STATUS",
|
||||
)
|
||||
)
|
||||
report.status["SENTINEL_SEQUENCE_STATUS"] = (
|
||||
"PASS" if sentinel_values_ok and records else "FAIL"
|
||||
)
|
||||
|
||||
if counters:
|
||||
report.details["COUNTER_FIRST"] = counters[0]
|
||||
report.details["COUNTER_LAST"] = counters[-1]
|
||||
if times:
|
||||
report.details["TIME_FIRST"] = times[0]
|
||||
report.details["TIME_LAST"] = times[-1]
|
||||
report.details["NONZERO_CYCLE_TIME_SAMPLES"] = len(nonzero_cycle_times)
|
||||
if nonzero_cycle_times:
|
||||
report.details["CYCLE_TIME_MIN"] = min(nonzero_cycle_times)
|
||||
report.details["CYCLE_TIME_MAX"] = max(nonzero_cycle_times)
|
||||
|
||||
base_header_ok = len(observed) >= 3 and all(
|
||||
(
|
||||
observed[index]["name"],
|
||||
observed[index]["type_hex"],
|
||||
observed[index]["elements"],
|
||||
)
|
||||
== EXPECTED_SIGNALS[index]
|
||||
for index in range(3)
|
||||
)
|
||||
|
||||
functional_ok = (
|
||||
report.status["HEADER_STATUS"] == "PASS"
|
||||
and base_header_ok
|
||||
and report.status["PAYLOAD_ALIGNMENT_STATUS"] == "PASS"
|
||||
and sample_count >= min_samples
|
||||
and report.status["COUNTER_STATUS"] == "PASS"
|
||||
and report.status["TIME_STATUS"] == "PASS"
|
||||
and report.status["CYCLE_TIME_STATUS"] == "PASS"
|
||||
)
|
||||
|
||||
semantic_ok = (
|
||||
layout_ok
|
||||
and report.status["PAYLOAD_ALIGNMENT_STATUS"] == "PASS"
|
||||
and sample_count >= min_samples
|
||||
and sentinel_values_ok
|
||||
and report.status["SENTINEL_SEQUENCE_STATUS"] == "PASS"
|
||||
)
|
||||
|
||||
report.status["FUNCTIONAL_BINARY_STATUS"] = "PASS" if functional_ok else "FAIL"
|
||||
report.status["SEMANTIC_BINARY_STATUS"] = "PASS" if semantic_ok else "FAIL"
|
||||
report.status["BINARY_STATUS"] = (
|
||||
"PASS" if functional_ok and semantic_ok else "FAIL"
|
||||
)
|
||||
|
||||
return report, 0 if report.status["BINARY_STATUS"] == "PASS" else 40, False
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Validate the S03 MARTe2 FileWriter binary contract."
|
||||
)
|
||||
parser.add_argument("binary", type=Path)
|
||||
parser.add_argument("--min-samples", type=int, default=50)
|
||||
args = parser.parse_args()
|
||||
|
||||
if args.min_samples < 1:
|
||||
parser.error("--min-samples must be at least 1")
|
||||
|
||||
report, exit_code, already_emitted = parse_binary(args.binary, args.min_samples)
|
||||
if not already_emitted:
|
||||
if report.status["FUNCTIONAL_BINARY_STATUS"] == "NOT_EVALUATED":
|
||||
report.status["FUNCTIONAL_BINARY_STATUS"] = "FAIL"
|
||||
if report.status["SEMANTIC_BINARY_STATUS"] == "NOT_EVALUATED":
|
||||
report.status["SEMANTIC_BINARY_STATUS"] = "NOT_DEMONSTRATED"
|
||||
if report.status["BINARY_STATUS"] == "NOT_EVALUATED":
|
||||
report.status["BINARY_STATUS"] = "FAIL"
|
||||
report.emit()
|
||||
return exit_code
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
Reference in New Issue
Block a user