dario/marte-benchmark-suite
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
marte-benchmark-suite/scenarios/S03H3_execution_profiles/validate.sh
T
dario 4b5fbb6c23 S03-H3 CLOSED baseline
2026-08-27 11:12:22 +02:00

509 lines
22 KiB
Bash
Executable File
Raw Permalink Blame History

#!/usr/bin/env bash
set -u
set -o pipefail
readonly MINIMUM_SAMPLES="50"
readonly EXPECTED_PARSER_SHA256="91c4d66770197e1986ed91eb6a4870e7da7df5a522ffdf4329b6d9250f238307"
readonly EXPECTED_H1_VERIFIER_SHA256="2f1c41b186bd2e79a9fb51fab0461a7a0dce104bf0852c0ec1ade2c55a017443"
readonly EXPECTED_TEST_CONFIG_SHA256="d037561b32760fbd0e2aec9f1eefc5efda27b1918eca4742c89092a8a2f7e92e"
readonly EXPECTED_DIAGNOSTIC_CONFIG_SHA256="cd999ff249452298d650a22c8fe5b0b03bf48c0735f4630befdec8209cbb13a3"
SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"
SUITE="$(cd -- "$SCRIPT_DIR/../.." && pwd -P)"
PARSER="$SUITE/scenarios/S03_semantic_sentinels/parse_s03_binary.py"
H1_VERIFIER="$SUITE/scenarios/S03H1_execution_profiles/verify_s03h1_config.py"
MINIMAL_VERIFIER="$SCRIPT_DIR/verify_s03h3_minimal_structure.py"
TEST_CONFIG="$SUITE/configurations/generated/S03H1/from_patcher/smoke_s03h1_execution_profiles_test_from_s02.marte"
DIAGNOSTIC_CONFIG="$SUITE/configurations/generated/S03H1/from_patcher/smoke_s03h1_execution_profiles_diagnostic_from_s02.marte"
MINIMAL_CONFIG="$SUITE/configurations/generated/S03H3/from_patcher/smoke_s03h3_execution_profiles_minimal_from_s03h1_test.marte"
MODE="NOT_PROVIDED"
MODE_STATUS="NOT_DEMONSTRATED"
PROFILE_CONFIG_STATUS="NOT_DEMONSTRATED"
PROFILE_RUNTIME_STATUS="NOT_DEMONSTRATED"
OBSERVABILITY_STATUS="NOT_DEMONSTRATED"
OBSERVABILITY_REASON="NOT_EVALUATED"
FUNCTIONAL_STATUS="NOT_DEMONSTRATED"
SEMANTIC_STATUS="NOT_DEMONSTRATED"
TIMING_STATUS="NOT_EVALUATED"
MEASUREMENT_ELIGIBILITY="NO"
COMPLETE_SAMPLE_COUNT="NOT_DEMONSTRATED"
CONFIG_REPORT=""
RUNTIME_CONFIG_REPORT=""
BINARY_REPORT=""
HASH_REPORT=""
cleanup() {
rm -f -- \
"${CONFIG_REPORT:-}" \
"${RUNTIME_CONFIG_REPORT:-}" \
"${BINARY_REPORT:-}" \
"${HASH_REPORT:-}" 2>/dev/null || true
}
trap cleanup EXIT HUP INT TERM
emit_contract() {
printf 'MODE=%s\n' "$MODE"
printf 'MODE_STATUS=%s\n' "$MODE_STATUS"
printf 'PROFILE_CONFIG_STATUS=%s\n' "$PROFILE_CONFIG_STATUS"
printf 'PROFILE_RUNTIME_STATUS=%s\n' "$PROFILE_RUNTIME_STATUS"
printf 'OBSERVABILITY_STATUS=%s\n' "$OBSERVABILITY_STATUS"
printf 'OBSERVABILITY_REASON=%s\n' "$OBSERVABILITY_REASON"
printf 'FUNCTIONAL_STATUS=%s\n' "$FUNCTIONAL_STATUS"
printf 'SEMANTIC_STATUS=%s\n' "$SEMANTIC_STATUS"
printf 'TIMING_STATUS=%s\n' "$TIMING_STATUS"
printf 'MEASUREMENT_ELIGIBILITY=%s\n' "$MEASUREMENT_ELIGIBILITY"
printf 'COMPLETE_SAMPLE_COUNT=%s\n' "$COMPLETE_SAMPLE_COUNT"
}
fail_early() {
local code="$1"
local reason="$2"
printf '[NON DIMOSTRATO] %s\n' "$reason" >&2
OBSERVABILITY_REASON="$reason"
emit_contract
printf 'VALIDATION_RESULT=FAIL_REQUIRED_INPUT\n'
exit "$code"
}
count_lines() {
local pattern="$1"
local file="$2"
grep -Ec "$pattern" "$file" || true
}
report_value_exact() {
local key="$1"
local file="$2"
local count
count="$(grep -Ec "^${key}=" "$file" || true)"
if [ "$count" -ne 1 ]; then
return 1
fi
sed -n "s/^${key}=//p" "$file"
}
verify_identity() {
local file="$1"
local expected="$2"
[ -f "$file" ] || return 1
[ "$(sha256sum -- "$file" | awk '{print $1}')" = "$expected" ]
}
if [ "$#" -ne 2 ]; then
printf 'Uso: %s MINIMAL|TEST|DIAGNOSTIC <directory-run|run.log>\n' "$0" >&2
emit_contract
printf 'VALIDATION_RESULT=FAIL_INVALID_USAGE\n'
exit 2
fi
MODE="$1"
case "$MODE" in
MINIMAL)
SELECTED_CONFIG="$MINIMAL_CONFIG"
;;
TEST)
SELECTED_CONFIG="$TEST_CONFIG"
EXPECTED_SELECTED_CONFIG_SHA256="$EXPECTED_TEST_CONFIG_SHA256"
;;
DIAGNOSTIC)
SELECTED_CONFIG="$DIAGNOSTIC_CONFIG"
EXPECTED_SELECTED_CONFIG_SHA256="$EXPECTED_DIAGNOSTIC_CONFIG_SHA256"
;;
*)
MODE_STATUS="FAIL"
PROFILE_CONFIG_STATUS="FAIL"
PROFILE_RUNTIME_STATUS="FAIL"
OBSERVABILITY_STATUS="FAIL"
OBSERVABILITY_REASON="UNKNOWN_MODE"
emit_contract
printf 'VALIDATION_RESULT=FAIL_UNKNOWN_MODE\n'
exit 2
;;
esac
INPUT_PATH="$2"
if [ -d "$INPUT_PATH" ]; then
RUN_DIR="$(cd -- "$INPUT_PATH" && pwd -P)"
RUN_LOG="$RUN_DIR/run.log"
elif [ -f "$INPUT_PATH" ]; then
RUN_LOG="$(cd -- "$(dirname -- "$INPUT_PATH")" && pwd -P)/$(basename -- "$INPUT_PATH")"
RUN_DIR="$(dirname -- "$RUN_LOG")"
else
fail_early 21 "INPUT_PATH_NOT_FOUND"
fi
RUN_CONFIG="$RUN_DIR/configuration.marte"
OUTPUT_FILE="$RUN_DIR/s03_output.bin"
RUNNER_SUMMARY="$RUN_DIR/runner_summary.txt"
RUN_HASHES="$RUN_DIR/hashes.sha256"
MODE_FILE="$RUN_DIR/s03h3_mode.txt"
verify_identity "$PARSER" "$EXPECTED_PARSER_SHA256" || \
fail_early 21 "PARSER_IDENTITY_NOT_DEMONSTRATED"
verify_identity "$H1_VERIFIER" "$EXPECTED_H1_VERIFIER_SHA256" || \
fail_early 21 "H1_VERIFIER_IDENTITY_NOT_DEMONSTRATED"
[ -x "$MINIMAL_VERIFIER" ] || fail_early 21 "MINIMAL_VERIFIER_NOT_EXECUTABLE"
for required_file in \
"$RUN_LOG" \
"$RUN_CONFIG" \
"$OUTPUT_FILE" \
"$RUNNER_SUMMARY" \
"$RUN_HASHES" \
"$MODE_FILE" \
"$SELECTED_CONFIG"
do
[ -f "$required_file" ] || fail_early 21 "REQUIRED_FILE_MISSING"
done
[ -s "$RUN_LOG" ] || fail_early 21 "RUN_LOG_EMPTY"
[ -s "$RUN_HASHES" ] || fail_early 21 "RUN_HASH_MANIFEST_EMPTY"
SELECTED_CONFIG_SHA256="$(sha256sum -- "$SELECTED_CONFIG" | awk '{print $1}')"
if [ "$MODE" = "MINIMAL" ]; then
EXPECTED_SELECTED_CONFIG_SHA256="$SELECTED_CONFIG_SHA256"
fi
CANONICAL_CONFIG_IDENTITY_STATUS="PASS"
if [ "$SELECTED_CONFIG_SHA256" != "$EXPECTED_SELECTED_CONFIG_SHA256" ]; then
CANONICAL_CONFIG_IDENTITY_STATUS="FAIL"
fi
MODE_FILE_CONTENT_STATUS="PASS"
MODE_DECLARATION_COUNT=0
SCENARIO_DECLARATION_COUNT=0
CONFIG_HASH_DECLARATION_COUNT=0
while IFS= read -r metadata_line || [ -n "$metadata_line" ]; do
case "$metadata_line" in
'')
;;
SCENARIO=S03H3)
SCENARIO_DECLARATION_COUNT=$((SCENARIO_DECLARATION_COUNT + 1))
;;
MODE=MINIMAL|MODE=TEST|MODE=DIAGNOSTIC)
MODE_DECLARATION_COUNT=$((MODE_DECLARATION_COUNT + 1))
[ "${metadata_line#MODE=}" = "$MODE" ] || MODE_FILE_CONTENT_STATUS="FAIL"
;;
SELECTED_CONFIG_SHA256=*)
CONFIG_HASH_DECLARATION_COUNT=$((CONFIG_HASH_DECLARATION_COUNT + 1))
declared_config_sha256="${metadata_line#SELECTED_CONFIG_SHA256=}"
if [[ ! "$declared_config_sha256" =~ ^[0-9a-f]{64}$ ]] ||
[ "$declared_config_sha256" != "$EXPECTED_SELECTED_CONFIG_SHA256" ] ||
[ "$declared_config_sha256" != "$SELECTED_CONFIG_SHA256" ]; then
MODE_FILE_CONTENT_STATUS="FAIL"
fi
;;
*)
MODE_FILE_CONTENT_STATUS="FAIL"
;;
esac
done <"$MODE_FILE"
if [ "$MODE_FILE_CONTENT_STATUS" = "PASS" ] &&
[ "$CANONICAL_CONFIG_IDENTITY_STATUS" = "PASS" ] &&
[ "$MODE_DECLARATION_COUNT" -eq 1 ] &&
[ "$SCENARIO_DECLARATION_COUNT" -eq 1 ] &&
[ "$CONFIG_HASH_DECLARATION_COUNT" -eq 1 ]; then
MODE_STATUS="PASS"
else
MODE_STATUS="FAIL"
fi
CONFIG_REPORT="$(mktemp "${TMPDIR:-/tmp}/s03h3_config.XXXXXX")" || \
fail_early 21 "CONFIG_REPORT_CREATION_FAILED"
RUNTIME_CONFIG_REPORT="$(mktemp "${TMPDIR:-/tmp}/s03h3_runtime.XXXXXX")" || \
fail_early 21 "RUNTIME_REPORT_CREATION_FAILED"
BINARY_REPORT="$(mktemp "${TMPDIR:-/tmp}/s03h3_binary.XXXXXX")" || \
fail_early 21 "BINARY_REPORT_CREATION_FAILED"
HASH_REPORT="$(mktemp "${TMPDIR:-/tmp}/s03h3_hashes.XXXXXX")" || \
fail_early 21 "HASH_REPORT_CREATION_FAILED"
EXPECTED_FILENAME="$RUN_DIR/s03_output.bin"
CONFIG_RC=1
RUNTIME_CONFIG_RC=1
CANONICAL_STRUCTURAL_COMPLETENESS_STATUS="NOT_APPLICABLE"
MINIMAL_RUNTIME_CONFIG_STATUS="NOT_APPLICABLE"
if [ "$MODE" = "MINIMAL" ]; then
PYTHONHASHSEED=0 python3 "$MINIMAL_VERIFIER" \
CANONICAL "$TEST_CONFIG" "$MINIMAL_CONFIG" \
>"$CONFIG_REPORT" 2>&1
CONFIG_RC=$?
PYTHONHASHSEED=0 python3 "$MINIMAL_VERIFIER" \
RUNTIME "$MINIMAL_CONFIG" "$RUN_CONFIG" "$RUN_DIR" \
>"$RUNTIME_CONFIG_REPORT" 2>&1
RUNTIME_CONFIG_RC=$?
CANONICAL_STRUCTURAL_COMPLETENESS_STATUS="$(
report_value_exact CANONICAL_STRUCTURAL_COMPLETENESS_STATUS "$CONFIG_REPORT" || printf FAIL
)"
MINIMAL_RUNTIME_CONFIG_STATUS="$(
report_value_exact MINIMAL_RUNTIME_CONFIG_STATUS "$RUNTIME_CONFIG_REPORT" || printf FAIL
)"
if [ "$CONFIG_RC" -eq 0 ] &&
[ "$RUNTIME_CONFIG_RC" -eq 0 ] &&
[ "$CANONICAL_STRUCTURAL_COMPLETENESS_STATUS" = "PASS" ] &&
[ "$MINIMAL_RUNTIME_CONFIG_STATUS" = "PASS" ]; then
PROFILE_CONFIG_STATUS="PASS"
else
PROFILE_CONFIG_STATUS="FAIL"
fi
else
PYTHONHASHSEED=0 python3 "$H1_VERIFIER" \
"$MODE" "$RUN_CONFIG" "$EXPECTED_FILENAME" \
>"$CONFIG_REPORT" 2>&1
CONFIG_RC=$?
RUNTIME_CONFIG_RC=0
PROFILE_CONFIG_STATUS="$(
report_value_exact CONFIG_PROFILE_VERIFICATION_STATUS "$CONFIG_REPORT" || printf FAIL
)"
fi
GAMTIMER_RUNTIME_LINES="$(count_lines '^\[Information - RealTimeApplicationConfigurationBuilder\.cpp:[0-9]+\]: Resolving for function GAMTimer \[idx: 0\][[:space:]]*$' "$RUN_LOG")"
SENTINEL_RUNTIME_LINES="$(count_lines '^\[Information - RealTimeApplicationConfigurationBuilder\.cpp:[0-9]+\]: Resolving for function SentinelProducer \[idx: 1\][[:space:]]*$' "$RUN_LOG")"
GAMDISPLAY_IDX2_LINES="$(count_lines '^\[Information - RealTimeApplicationConfigurationBuilder\.cpp:[0-9]+\]: Resolving for function GAMDisplay \[idx: 2\][[:space:]]*$' "$RUN_LOG")"
IOGAM_IDX2_LINES="$(count_lines '^\[Information - RealTimeApplicationConfigurationBuilder\.cpp:[0-9]+\]: Resolving for function IOGAM_Writer \[idx: 2\][[:space:]]*$' "$RUN_LOG")"
IOGAM_IDX3_LINES="$(count_lines '^\[Information - RealTimeApplicationConfigurationBuilder\.cpp:[0-9]+\]: Resolving for function IOGAM_Writer \[idx: 3\][[:space:]]*$' "$RUN_LOG")"
FUNCTION_RESOLUTION_LINES="$(count_lines '^\[Information - RealTimeApplicationConfigurationBuilder\.cpp:[0-9]+\]: Resolving for function .* \[idx: [0-9]+\][[:space:]]*$' "$RUN_LOG")"
GAMTIMER_OBJECT_RESOLUTION_LINES="$(count_lines '^\[Information - RealTimeApplicationConfigurationBuilder\.cpp:[0-9]+\]: Resolving GAMTimer[[:space:]]*$' "$RUN_LOG")"
SENTINEL_OBJECT_RESOLUTION_LINES="$(count_lines '^\[Information - RealTimeApplicationConfigurationBuilder\.cpp:[0-9]+\]: Resolving SentinelProducer[[:space:]]*$' "$RUN_LOG")"
GAMDISPLAY_OBJECT_RESOLUTION_LINES="$(count_lines '^\[Information - RealTimeApplicationConfigurationBuilder\.cpp:[0-9]+\]: Resolving GAMDisplay[[:space:]]*$' "$RUN_LOG")"
IOGAM_OBJECT_RESOLUTION_LINES="$(count_lines '^\[Information - RealTimeApplicationConfigurationBuilder\.cpp:[0-9]+\]: Resolving IOGAM_Writer[[:space:]]*$' "$RUN_LOG")"
case "$MODE" in
MINIMAL)
if [ "$GAMTIMER_RUNTIME_LINES" -eq 1 ] &&
[ "$SENTINEL_RUNTIME_LINES" -eq 1 ] &&
[ "$GAMDISPLAY_IDX2_LINES" -eq 0 ] &&
[ "$IOGAM_IDX2_LINES" -eq 1 ] &&
[ "$IOGAM_IDX3_LINES" -eq 0 ] &&
[ "$GAMTIMER_OBJECT_RESOLUTION_LINES" -eq 1 ] &&
[ "$SENTINEL_OBJECT_RESOLUTION_LINES" -eq 1 ] &&
[ "$GAMDISPLAY_OBJECT_RESOLUTION_LINES" -eq 0 ] &&
[ "$IOGAM_OBJECT_RESOLUTION_LINES" -eq 1 ] &&
[ "$FUNCTION_RESOLUTION_LINES" -eq 3 ]; then
PROFILE_RUNTIME_STATUS="PASS"
else
PROFILE_RUNTIME_STATUS="FAIL"
fi
;;
TEST|DIAGNOSTIC)
if [ "$GAMTIMER_RUNTIME_LINES" -eq 1 ] &&
[ "$SENTINEL_RUNTIME_LINES" -eq 1 ] &&
[ "$GAMDISPLAY_IDX2_LINES" -eq 1 ] &&
[ "$IOGAM_IDX2_LINES" -eq 0 ] &&
[ "$IOGAM_IDX3_LINES" -eq 1 ] &&
[ "$GAMTIMER_OBJECT_RESOLUTION_LINES" -eq 1 ] &&
[ "$SENTINEL_OBJECT_RESOLUTION_LINES" -eq 1 ] &&
[ "$GAMDISPLAY_OBJECT_RESOLUTION_LINES" -eq 1 ] &&
[ "$IOGAM_OBJECT_RESOLUTION_LINES" -eq 1 ] &&
[ "$FUNCTION_RESOLUTION_LINES" -eq 4 ]; then
PROFILE_RUNTIME_STATUS="PASS"
else
PROFILE_RUNTIME_STATUS="FAIL"
fi
;;
esac
PYTHONHASHSEED=0 python3 "$PARSER" "$OUTPUT_FILE" --min-samples "$MINIMUM_SAMPLES" \
>"$BINARY_REPORT" 2>&1
PARSER_RC=$?
sha256sum -c --strict "$RUN_HASHES" >"$HASH_REPORT" 2>&1
HASH_RC=$?
FUNCTIONAL_BINARY_STATUS="$(report_value_exact FUNCTIONAL_BINARY_STATUS "$BINARY_REPORT" || printf FAIL)"
SEMANTIC_BINARY_STATUS="$(report_value_exact SEMANTIC_BINARY_STATUS "$BINARY_REPORT" || printf FAIL)"
BINARY_STATUS="$(report_value_exact BINARY_STATUS "$BINARY_REPORT" || printf FAIL)"
PARSER_PAYLOAD_ALIGNMENT_STATUS="$(report_value_exact PAYLOAD_ALIGNMENT_STATUS "$BINARY_REPORT" || printf FAIL)"
COMPLETE_SAMPLE_COUNT="$(report_value_exact COMPLETE_SAMPLE_COUNT "$BINARY_REPORT" || printf NOT_DEMONSTRATED)"
COMPLETE_SAMPLE_COUNT_STATUS="FAIL"
case "$COMPLETE_SAMPLE_COUNT" in
''|*[!0-9]*) ;;
*)
if [ "$PARSER_RC" -eq 0 ] &&
[ "$FUNCTIONAL_BINARY_STATUS" = "PASS" ] &&
[ "$SEMANTIC_BINARY_STATUS" = "PASS" ] &&
[ "$BINARY_STATUS" = "PASS" ] &&
[ "$PARSER_PAYLOAD_ALIGNMENT_STATUS" = "PASS" ]; then
COMPLETE_SAMPLE_COUNT_STATUS="PASS"
fi
;;
esac
LOGGER_SIGNAL_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: (Counter|Time|State1_Thread1_CycleTime|SentinelScalarA|SentinelScalarB|SentinelVector) \[[0-9]+:[0-9]+\]:' "$RUN_LOG")"
LOGGER_COUNTER_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: Counter \[0:0\]:' "$RUN_LOG")"
LOGGER_TIME_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: Time \[0:0\]:' "$RUN_LOG")"
LOGGER_CYCLE_TIME_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: State1_Thread1_CycleTime \[0:0\]:' "$RUN_LOG")"
LOGGER_SCALAR_A_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: SentinelScalarA \[0:0\]:' "$RUN_LOG")"
LOGGER_SCALAR_B_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: SentinelScalarB \[0:0\]:' "$RUN_LOG")"
LOGGER_VECTOR_LINES="$(count_lines '^\[Information - LoggerBroker\.cpp:[0-9]+\]: SentinelVector \[0:2\]:' "$RUN_LOG")"
if [ "$COMPLETE_SAMPLE_COUNT_STATUS" != "PASS" ]; then
OBSERVABILITY_STATUS="NOT_DEMONSTRATED"
OBSERVABILITY_REASON="COMPLETE_SAMPLE_COUNT_NOT_AUTHORITATIVE"
elif [ "$MODE" = "MINIMAL" ] || [ "$MODE" = "TEST" ]; then
if [ "$LOGGER_SIGNAL_LINES" -eq 0 ] &&
[ "$LOGGER_COUNTER_LINES" -eq 0 ] &&
[ "$LOGGER_TIME_LINES" -eq 0 ] &&
[ "$LOGGER_CYCLE_TIME_LINES" -eq 0 ] &&
[ "$LOGGER_SCALAR_A_LINES" -eq 0 ] &&
[ "$LOGGER_SCALAR_B_LINES" -eq 0 ] &&
[ "$LOGGER_VECTOR_LINES" -eq 0 ]; then
OBSERVABILITY_STATUS="PASS"
OBSERVABILITY_REASON="NONE"
else
OBSERVABILITY_STATUS="FAIL"
OBSERVABILITY_REASON="UNEXPECTED_LOGGER_SIGNAL_LINES"
fi
else
if [ "$LOGGER_COUNTER_LINES" -eq "$COMPLETE_SAMPLE_COUNT" ] &&
[ "$LOGGER_TIME_LINES" -eq "$COMPLETE_SAMPLE_COUNT" ] &&
[ "$LOGGER_CYCLE_TIME_LINES" -eq "$COMPLETE_SAMPLE_COUNT" ] &&
[ "$LOGGER_SCALAR_A_LINES" -eq "$COMPLETE_SAMPLE_COUNT" ] &&
[ "$LOGGER_SCALAR_B_LINES" -eq "$COMPLETE_SAMPLE_COUNT" ] &&
[ "$LOGGER_VECTOR_LINES" -eq "$COMPLETE_SAMPLE_COUNT" ] &&
[ "$LOGGER_SIGNAL_LINES" -eq $((6 * COMPLETE_SAMPLE_COUNT)) ]; then
OBSERVABILITY_STATUS="PASS"
OBSERVABILITY_REASON="NONE"
elif [ "$LOGGER_COUNTER_LINES" -eq "$LOGGER_TIME_LINES" ] &&
[ "$LOGGER_COUNTER_LINES" -eq "$LOGGER_CYCLE_TIME_LINES" ] &&
[ "$LOGGER_COUNTER_LINES" -eq "$LOGGER_SCALAR_A_LINES" ] &&
[ "$LOGGER_COUNTER_LINES" -eq "$LOGGER_SCALAR_B_LINES" ] &&
[ "$LOGGER_COUNTER_LINES" -eq "$LOGGER_VECTOR_LINES" ]; then
OBSERVABILITY_STATUS="NOT_DEMONSTRATED"
OBSERVABILITY_REASON="SHUTDOWN_SKEW"
else
OBSERVABILITY_STATUS="FAIL"
OBSERVABILITY_REASON="LOGGER_BINARY_COUNT_MISMATCH"
fi
fi
START_LINES="$(count_lines '^\[Information - RealTimeLoader\.cpp:[0-9]+\]: Started application in state State1[[:space:]]*$' "$RUN_LOG")"
APPLICATION_START_LINES="$(count_lines '^\[Information - MARTeApp\.cpp:[0-9]+\]: Application starting[[:space:]]*$' "$RUN_LOG")"
FILE_OPEN_LINES="$(count_lines '^\[Information - FileWriter\.cpp:[0-9]+\]: Going to open file with name ' "$RUN_LOG")"
SIGINT_LINES="$(count_lines '^\[Information - Bootstrap\.cpp:[0-9]+\]: Application recieved SIGINT\.[[:space:]]*$' "$RUN_LOG")"
STOP_OK_LINES="$(count_lines '^\[Information - Bootstrap\.cpp:[0-9]+\]: Application successfully stopped\.[[:space:]]*$' "$RUN_LOG")"
TERMINATED_LINES="$(count_lines '^\[NoError - MARTeApp\.cpp:[0-9]+\]: Application terminated[[:space:]]*$' "$RUN_LOG")"
STARTUP_ERROR_LINES="$(count_lines 'Failed dlopen|Failed CreateByName|Failed to Initialise object|Failed to initialise the ObjectRegistryDatabase|Could not Initialise the loader' "$RUN_LOG")"
FATAL_ERROR_LINES="$(count_lines '^\[FatalError ' "$RUN_LOG")"
OS_ERROR_LINES="$(count_lines '^\[OSError ' "$RUN_LOG")"
ERROR_LINES="$(count_lines '^\[Error ' "$RUN_LOG")"
INITIALISATION_ERROR_LINES="$(count_lines '^\[InitialisationEr ' "$RUN_LOG")"
PRIORITY_FAIL_LINES="$(count_lines '^\[Warning - Threads\.cpp:[0-9]+\]: Failed to change the thread priority' "$RUN_LOG")"
DOUBLE_STOP_LINES="$(count_lines '^\[FatalError - RealTimeApplication\.cpp:[0-9]+\]: Could not stop the RealTimeApplication\. Was it ever started\?[[:space:]]*$' "$RUN_LOG")"
ASYNC_CLOSE_LINES="$(count_lines '^\[FatalError - MemoryMapAsyncOutputBroker\.cpp:[0-9]+\]: Could not Close the EventSem\.[[:space:]]*$' "$RUN_LOG")"
MUTEX_DESTROY_LINES="$(count_lines '^\[OSError - EventSem\.cpp:[0-9]+\]: Error: pthread_mutex_destroy\(\)[[:space:]]*$' "$RUN_LOG")"
UNCLASSIFIED_FATAL_LINES=$((FATAL_ERROR_LINES - DOUBLE_STOP_LINES - ASYNC_CLOSE_LINES))
UNCLASSIFIED_OS_ERROR_LINES=$((OS_ERROR_LINES - MUTEX_DESTROY_LINES))
[ "$UNCLASSIFIED_FATAL_LINES" -ge 0 ] || UNCLASSIFIED_FATAL_LINES=0
[ "$UNCLASSIFIED_OS_ERROR_LINES" -ge 0 ] || UNCLASSIFIED_OS_ERROR_LINES=0
MARTE_EXIT_CODE="$(sed -n 's/^Exit code MARTe:[[:space:]]*//p' "$RUNNER_SUMMARY" | tail -n 1)"
TEE_EXIT_CODE="$(sed -n 's/^Exit code tee:[[:space:]]*//p' "$RUNNER_SUMMARY" | tail -n 1)"
[ -n "$MARTE_EXIT_CODE" ] || MARTE_EXIT_CODE="NOT_AVAILABLE"
[ -n "$TEE_EXIT_CODE" ] || TEE_EXIT_CODE="NOT_AVAILABLE"
case "$MARTE_EXIT_CODE" in
137) TIMING_STATUS="NOT_VALID_EXIT_137_SIGKILL" ;;
*)
if [ "$PRIORITY_FAIL_LINES" -ge 1 ]; then
TIMING_STATUS="NOT_VALID_PRIORITY_NOT_APPLIED"
else
TIMING_STATUS="UNASSESSED_DT_SEMANTICS"
fi
;;
esac
if [ "$MODE_STATUS" = "PASS" ] &&
[ "$PROFILE_CONFIG_STATUS" = "PASS" ] &&
[ "$PROFILE_RUNTIME_STATUS" = "PASS" ] &&
[ "$OBSERVABILITY_STATUS" = "PASS" ] &&
[ "$FUNCTIONAL_BINARY_STATUS" = "PASS" ] &&
[ "$START_LINES" -eq 1 ] &&
[ "$APPLICATION_START_LINES" -eq 1 ] &&
[ "$FILE_OPEN_LINES" -eq 1 ] &&
[ "$STARTUP_ERROR_LINES" -eq 0 ] &&
[ "$HASH_RC" -eq 0 ] &&
[ "$TEE_EXIT_CODE" = "0" ] &&
[ "$UNCLASSIFIED_FATAL_LINES" -eq 0 ] &&
[ "$UNCLASSIFIED_OS_ERROR_LINES" -eq 0 ] &&
[ "$ERROR_LINES" -eq 0 ] &&
[ "$INITIALISATION_ERROR_LINES" -eq 0 ]; then
FUNCTIONAL_STATUS="PASS"
else
FUNCTIONAL_STATUS="NOT_DEMONSTRATED"
fi
if [ "$MODE_STATUS" = "PASS" ] &&
[ "$PROFILE_CONFIG_STATUS" = "PASS" ] &&
[ "$SEMANTIC_BINARY_STATUS" = "PASS" ]; then
SEMANTIC_STATUS="PASS"
elif [ "$SEMANTIC_BINARY_STATUS" = "FAIL" ]; then
SEMANTIC_STATUS="FAIL"
else
SEMANTIC_STATUS="NOT_DEMONSTRATED"
fi
printf '============================================================\n'
printf 'VALIDAZIONE S03-H3 - MINIMAL / TEST / DIAGNOSTIC\n'
printf '============================================================\n'
printf 'Run directory: %s\n' "$RUN_DIR"
printf 'CANONICAL_STRUCTURAL_COMPLETENESS_STATUS=%s\n' "$CANONICAL_STRUCTURAL_COMPLETENESS_STATUS"
printf 'MINIMAL_RUNTIME_CONFIG_STATUS=%s\n' "$MINIMAL_RUNTIME_CONFIG_STATUS"
printf 'FUNCTION_RESOLUTION_LINES=%s\n' "$FUNCTION_RESOLUTION_LINES"
printf 'LOGGER_SIGNAL_LINES=%s\n' "$LOGGER_SIGNAL_LINES"
printf 'LOGGER_COUNTER_LINES=%s\n' "$LOGGER_COUNTER_LINES"
printf 'LOGGER_TIME_LINES=%s\n' "$LOGGER_TIME_LINES"
printf 'LOGGER_CYCLE_TIME_LINES=%s\n' "$LOGGER_CYCLE_TIME_LINES"
printf 'LOGGER_SCALAR_A_LINES=%s\n' "$LOGGER_SCALAR_A_LINES"
printf 'LOGGER_SCALAR_B_LINES=%s\n' "$LOGGER_SCALAR_B_LINES"
printf 'LOGGER_VECTOR_LINES=%s\n' "$LOGGER_VECTOR_LINES"
printf 'PARSER_RC=%s\n' "$PARSER_RC"
printf 'HASH_VERIFICATION_STATUS=%s\n' "$( [ "$HASH_RC" -eq 0 ] && printf PASS || printf FAIL )"
printf '\n--- CONFIGURATION VERIFIER DETAIL ---\n'
if [ "$MODE" = "MINIMAL" ]; then
sed 's/^/MINIMAL_CANONICAL_VERIFIER_/' "$CONFIG_REPORT"
sed 's/^/MINIMAL_RUNTIME_VERIFIER_/' "$RUNTIME_CONFIG_REPORT"
else
cat -- "$CONFIG_REPORT"
fi
printf '\n--- BINARY PARSER DETAIL ---\n'
sed 's/^/BINARY_PARSER_/' "$BINARY_REPORT"
printf '\n--- HASH DETAIL ---\n'
cat -- "$HASH_REPORT"
printf '\n--- CONTRATTO S03-H3 ---\n'
emit_contract
if [ "$FUNCTIONAL_STATUS" != "PASS" ] || [ "$SEMANTIC_STATUS" != "PASS" ]; then
printf 'VALIDATION_RESULT=FUNCTIONAL_OR_SEMANTIC_NOT_DEMONSTRATED\n'
exit 20
fi
if [ "$SIGINT_LINES" -ge 1 ] &&
[ "$STOP_OK_LINES" -ge 1 ] &&
[ "$TERMINATED_LINES" -ge 1 ] &&
[ "$FATAL_ERROR_LINES" -eq 0 ] &&
[ "$OS_ERROR_LINES" -eq 0 ] &&
[ "$ERROR_LINES" -eq 0 ] &&
[ "$INITIALISATION_ERROR_LINES" -eq 0 ]; then
printf 'VALIDATION_RESULT=PASS_CLEAN_SHUTDOWN\n'
exit 0
fi
KNOWN_SHUTDOWN_TOTAL=$((DOUBLE_STOP_LINES + ASYNC_CLOSE_LINES + MUTEX_DESTROY_LINES))
if [ "$SIGINT_LINES" -ge 1 ] &&
[ "$STOP_OK_LINES" -ge 1 ] &&
[ "$TERMINATED_LINES" -ge 1 ] &&
[ "$KNOWN_SHUTDOWN_TOTAL" -ge 1 ] &&
[ "$UNCLASSIFIED_FATAL_LINES" -eq 0 ] &&
[ "$UNCLASSIFIED_OS_ERROR_LINES" -eq 0 ] &&
[ "$ERROR_LINES" -eq 0 ] &&
[ "$INITIALISATION_ERROR_LINES" -eq 0 ]; then
printf 'VALIDATION_RESULT=PASS_KNOWN_SHUTDOWN_ANOMALY\n'
exit 10
fi
printf 'VALIDATION_RESULT=PASS_UNCLASSIFIED_SHUTDOWN_ANOMALY\n'
exit 11
Reference in New Issue View Git Blame Copy Permalink