Back to home page

EIC code displayed by LXR

 
 

    


File indexing completed on 2026-11-20 09:34:02

0001 """Offline tests of runner mechanics only; fake commands do not validate ROOT."""
0002 import json
0003 import os
0004 from pathlib import Path
0005 import subprocess
0006 import sys
0007 import tempfile
0008 import time
0009 import unittest
0010 
0011 RUNNER = Path(__file__).resolve().with_name("run.py")
0012 VALIDATOR = Path(__file__).resolve().with_name("validate.sh")
0013 EXPECTED_REJECTION = "FAIL: ROOT write / calibration: exit 1; expected marker 'LFHCAL_SMOKE_OK: write'"
0014 STANDARD_EXECUTABLES = [
0015     "Convert", "DataPrep", "CalibrateData", "DataAna", "Display",
0016     "CompareCalib", "CompareAna", "CompareInjection", "HGCROCStudy",
0017     "CompareWaveform",
0018 ]
0019 DECODER_EXECUTABLES = [
0020     "HGCROC_Conversion", "ParseCalibSamples", "CompareHGCROCCalib",
0021     "EvaluateRecoEffi", "h2g_run",
0022 ]
0023 
0024 
0025 class RunnerTests(unittest.TestCase):
0026     def setUp(self):
0027         self.temp = tempfile.TemporaryDirectory(prefix="smoke runner tests ")
0028         self.addCleanup(self.temp.cleanup)
0029         self.directory = Path(self.temp.name)
0030         self.build = self.directory / "build artifacts"
0031         self.build.mkdir()
0032         self.calls = self.directory / "calls.jsonl"
0033         self.env = dict(os.environ, SMOKE_TEST_CALLS=str(self.calls))
0034         for name in ("libLFHCAL.so", "libLFHCAL_rdict.pcm", "libLFHCAL.rootmap"):
0035             (self.build / name).write_text("fixture artifact, not a real library\n")
0036         script = f"#!{sys.executable}\n" + '''import json, os, pathlib, subprocess, sys, time
0037 name = pathlib.Path(sys.argv[0]).name
0038 with open(os.environ["SMOKE_TEST_CALLS"], "a") as stream:
0039     stream.write(json.dumps({"name": name, "args": sys.argv[1:], "cwd": os.getcwd(),
0040                              "mode": os.environ.get("LFHCAL_SMOKE_MODE")}) + "\\n")
0041 if name == os.environ.get("SMOKE_TEST_CHILD_HANG"):
0042     child_code = "import pathlib, time; time.sleep(0.8); pathlib.Path(" + repr(os.environ["SMOKE_TEST_CHILD_MARKER"]) + ").touch()"
0043     subprocess.Popen([sys.executable, "-c", child_code])
0044     time.sleep(5)
0045 if name == os.environ.get("SMOKE_TEST_HANG"):
0046     time.sleep(5)
0047 if name == os.environ.get("SMOKE_TEST_FAIL"):
0048     print("injected command failure")
0049     sys.exit(17)
0050 if name == os.environ.get("SMOKE_TEST_EMPTY"):
0051     sys.exit(0)
0052 if name in ''' + repr(STANDARD_EXECUTABLES + DECODER_EXECUTABLES) + ''':
0053     print("Usage: " + name)
0054 elif name == "root":
0055     print("LFHCAL_SMOKE_OK: " + os.environ["LFHCAL_SMOKE_MODE"])
0056 else:
0057     print("fixture-version")
0058 '''
0059         for name in (*STANDARD_EXECUTABLES, *DECODER_EXECUTABLES,
0060                      "root", "root-config", "yall-run"):
0061             path = self.build / ("h2g_decode/h2g_run" if name == "h2g_run" else name)
0062             path.parent.mkdir(parents=True, exist_ok=True)
0063             path.write_text(script)
0064             path.chmod(0o755)
0065 
0066     def run_suite(self, *extra, layout=None):
0067         return subprocess.run([sys.executable, str(RUNNER),
0068                                *(layout or ["--build-dir", str(self.build)]),
0069                                "--root", str(self.build / "root"),
0070                                "--root-config", str(self.build / "root-config"), *extra],
0071                               env=self.env, text=True, capture_output=True)
0072 
0073     def recorded(self):
0074         return [json.loads(line) for line in self.calls.read_text().splitlines()]
0075 
0076     def test_default_checks_are_bounded_and_do_not_run_yall(self):
0077         result = self.run_suite()
0078         self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0079         calls = self.recorded()
0080         self.assertEqual([row["name"] for row in calls],
0081                          ["root-config", *STANDARD_EXECUTABLES, "root", "root"])
0082         self.assertEqual(calls[0]["args"], ["--version"])
0083         standard_calls = calls[1:1 + len(STANDARD_EXECUTABLES)]
0084         self.assertTrue(all(row["args"] == ["-h"] for row in standard_calls))
0085         self.assertEqual([row["mode"] for row in calls[-2:]], ["write", "read"])
0086         self.assertEqual(calls[-1]["args"][:4], ["-n", "-l", "-b", "-q"])
0087         self.assertEqual(len({row["cwd"] for row in calls}), 1)
0088         self.assertFalse(Path(calls[0]["cwd"]).exists(), "temporary fixture directory leaked")
0089         self.assertIn("NOT REQUESTED: decoder-enabled", result.stdout)
0090         self.assertIn("NOT REQUESTED: Yall", result.stdout)
0091 
0092     def test_decoder_checks_are_explicit_and_bounded(self):
0093         result = self.run_suite("--decoder")
0094         self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0095         calls = self.recorded()
0096         self.assertEqual([row["name"] for row in calls],
0097                          ["root-config", *STANDARD_EXECUTABLES,
0098                           *DECODER_EXECUTABLES, "root", "root"])
0099         startup_calls = calls[1:1 + len(STANDARD_EXECUTABLES) + len(DECODER_EXECUTABLES)]
0100         self.assertTrue(all(row["args"] == ["-h"] for row in startup_calls))
0101         self.assertNotIn("NOT REQUESTED: decoder-enabled", result.stdout)
0102 
0103     def test_requested_decoder_component_must_exist(self):
0104         (self.build / "ParseCalibSamples").unlink()
0105         result = self.run_suite("--decoder")
0106         self.assertEqual(result.returncode, 1)
0107         self.assertIn("ParseCalibSamples", result.stderr)
0108         self.assertFalse(self.calls.exists())
0109 
0110     def test_yall_is_version_only(self):
0111         result = self.run_suite("--yall", str(self.build / "yall-run"))
0112         self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0113         self.assertEqual(self.recorded()[-1]["args"], ["--version"])
0114         self.assertEqual(self.recorded()[-1]["name"], "yall-run")
0115 
0116     def test_nonzero_command_fails_and_stops(self):
0117         self.env["SMOKE_TEST_FAIL"] = "Convert"
0118         result = self.run_suite()
0119         self.assertEqual(result.returncode, 1)
0120         self.assertIn("exit 17", result.stderr)
0121         self.assertEqual([row["name"] for row in self.recorded()], ["root-config", "Convert"])
0122 
0123     def test_zero_exit_without_help_text_fails_and_stops(self):
0124         self.env["SMOKE_TEST_EMPTY"] = "Display"
0125         result = self.run_suite()
0126         self.assertEqual(result.returncode, 1)
0127         self.assertIn("Display startup: exit 0; expected marker 'Usage:'", result.stderr)
0128         self.assertEqual([row["name"] for row in self.recorded()],
0129                          ["root-config", *STANDARD_EXECUTABLES[:5]])
0130 
0131     def test_zero_exit_without_root_success_marker_is_failure(self):
0132         self.env["SMOKE_TEST_EMPTY"] = "root"
0133         result = self.run_suite()
0134         self.assertEqual(result.returncode, 1)
0135         self.assertIn("expected marker", result.stderr)
0136 
0137     def test_empty_version_fails(self):
0138         for name, extra in (("root-config", []), ("yall-run", ["--yall", str(self.build / "yall-run")])):
0139             with self.subTest(name=name):
0140                 self.env["SMOKE_TEST_EMPTY"] = name
0141                 result = self.run_suite(*extra)
0142                 self.assertEqual(result.returncode, 1)
0143                 self.assertIn("empty output", result.stderr)
0144 
0145     def test_timeout_is_failure(self):
0146         self.env["SMOKE_TEST_HANG"] = "Convert"
0147         result = self.run_suite("--timeout", "0.3")
0148         self.assertEqual(result.returncode, 1)
0149         self.assertIn("timed out", result.stderr)
0150 
0151     @unittest.skipUnless(os.name == "posix", "process-group cleanup is POSIX-specific")
0152     def test_timeout_terminates_command_descendants(self):
0153         marker = self.directory / "child-survived"
0154         self.env["SMOKE_TEST_CHILD_HANG"] = "root"
0155         self.env["SMOKE_TEST_CHILD_MARKER"] = str(marker)
0156         result = self.run_suite("--timeout", "0.3")
0157         self.assertEqual(result.returncode, 1)
0158         self.assertIn("timed out", result.stderr)
0159         time.sleep(0.9)
0160         self.assertFalse(marker.exists(), "timed-out command left its child running")
0161 
0162     def test_missing_dictionary_fails_before_execution(self):
0163         (self.build / "libLFHCAL_rdict.pcm").unlink()
0164         result = self.run_suite()
0165         self.assertEqual(result.returncode, 1)
0166         self.assertIn("dictionary artifact", result.stderr)
0167         self.assertFalse(self.calls.exists())
0168 
0169     def test_missing_executable_fails(self):
0170         (self.build / "DataPrep").unlink()
0171         result = self.run_suite()
0172         self.assertEqual(result.returncode, 1)
0173         self.assertIn("Executable not found", result.stderr)
0174 
0175     def test_explicit_layout_does_not_guess_library(self):
0176         result = self.run_suite(layout=["--bin-dir", str(self.build)])
0177         self.assertEqual(result.returncode, 2)
0178         result = self.run_suite(layout=["--bin-dir", str(self.build),
0179                                        "--library", str(self.build / "libLFHCAL.so")])
0180         self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0181 
0182     def test_invalid_timeout_rejected(self):
0183         for value in ("0", "-1", "nan", "inf"):
0184             with self.subTest(value=value):
0185                 result = self.run_suite("--timeout", value)
0186                 self.assertEqual(result.returncode, 2)
0187 
0188 
0189 class ValidationHelperTests(unittest.TestCase):
0190     def setUp(self):
0191         self.temp = tempfile.TemporaryDirectory(prefix="smoke validator tests ")
0192         self.addCleanup(self.temp.cleanup)
0193         self.directory = Path(self.temp.name)
0194         self.state = self.directory / "calls"
0195         python = self.directory / "python3"
0196         python.write_text("""#!/bin/sh
0197 if [ "$VALIDATE_EXPECT_DECODER" = 1 ]; then
0198   found=0
0199   for arg in "$@"; do
0200     if [ "$arg" = --decoder ]; then
0201       found=1
0202     fi
0203   done
0204   if [ "$found" -ne 1 ]; then
0205     echo "missing forwarded --decoder" >&2
0206     exit 9
0207   fi
0208 fi
0209 count=0
0210 if [ -f "$VALIDATE_TEST_STATE" ]; then
0211   count=$(cat "$VALIDATE_TEST_STATE")
0212 fi
0213 count=$((count + 1))
0214 echo "$count" >"$VALIDATE_TEST_STATE"
0215 if [ "$count" -eq 2 ] && [ "$VALIDATE_EXPECT_EXTERNAL_FALSE" = 1 ]; then
0216   root_command=
0217   next_is_root=0
0218   for arg in "$@"; do
0219     if [ "$next_is_root" -eq 1 ]; then
0220       root_command=$arg
0221       next_is_root=0
0222     elif [ "$arg" = --root ]; then
0223       next_is_root=1
0224     fi
0225   done
0226   case "$root_command" in
0227     /*) ;;
0228     *) echo "injected ROOT command is not an external path: $root_command" >&2; exit 8 ;;
0229   esac
0230   if [ ! -x "$root_command" ]; then
0231     echo "injected ROOT command is not executable: $root_command" >&2
0232     exit 8
0233   fi
0234 fi
0235 if [ "$count" -eq 1 ]; then
0236   echo "ordinary smoke output"
0237   if [ "$VALIDATE_TEST_CASE" = baseline_failure ]; then
0238     echo "genuine baseline failure" >&2
0239     exit 7
0240   fi
0241   exit 0
0242 fi
0243 case "$VALIDATE_TEST_CASE" in
0244   expected)
0245     echo "FAIL: ROOT write / calibration: exit 1; expected marker 'LFHCAL_SMOKE_OK: write'" >&2
0246     exit 1 ;;
0247   unexpected_success)
0248     echo "injected command unexpectedly passed"
0249     exit 0 ;;
0250   wrong_stage)
0251     echo "FAIL: Convert startup: exit 1; expected marker 'Usage:'" >&2
0252     exit 1 ;;
0253   wrong_exit)
0254     echo "FAIL: ROOT write / calibration: exit 1; expected marker 'LFHCAL_SMOKE_OK: write'" >&2
0255     exit 2 ;;
0256   timeout)
0257     echo "FAIL: ROOT write / calibration: timed out after 0.1 seconds" >&2
0258     exit 1 ;;
0259 esac
0260 """)
0261         python.chmod(0o755)
0262 
0263     def run_helper(self, case, *extra, expect_external_false=False):
0264         env = dict(os.environ,
0265                    PATH=f"{self.directory}{os.pathsep}{os.environ.get('PATH', '')}",
0266                    VALIDATE_TEST_STATE=str(self.state),
0267                    VALIDATE_TEST_CASE=case,
0268                    VALIDATE_EXPECT_DECODER="1" if "--decoder" in extra else "0",
0269                    VALIDATE_EXPECT_EXTERNAL_FALSE="1" if expect_external_false else "0")
0270         return subprocess.run([str(VALIDATOR), "--build-dir", "build", "--timeout", "60", *extra],
0271                               env=env, text=True, capture_output=True)
0272 
0273     def test_expected_rejection_is_accepted(self):
0274         result = self.run_helper("expected")
0275         self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0276         self.assertIn("NORMAL SMOKE TESTS", result.stdout)
0277         self.assertIn("ERROR-DETECTION TEST: deliberately forcing ROOT to fail", result.stdout)
0278         self.assertIn("PASS: expected error detected", result.stdout)
0279         self.assertNotIn(EXPECTED_REJECTION, result.stdout + result.stderr)
0280         self.assertEqual(self.state.read_text().strip(), "2")
0281 
0282     def test_decoder_selection_is_forwarded_to_both_runs(self):
0283         result = self.run_helper("expected", "--decoder")
0284         self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0285         self.assertEqual(self.state.read_text().strip(), "2")
0286 
0287     def test_external_false_executable_is_forwarded(self):
0288         result = self.run_helper("expected", expect_external_false=True)
0289         self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0290         self.assertEqual(self.state.read_text().strip(), "2")
0291 
0292     def test_unexpected_success_is_rejected(self):
0293         result = self.run_helper("unexpected_success")
0294         self.assertEqual(result.returncode, 1)
0295         self.assertIn("got exit 0", result.stderr)
0296         self.assertIn("injected command unexpectedly passed", result.stderr)
0297 
0298     def test_wrong_stage_is_rejected(self):
0299         result = self.run_helper("wrong_stage")
0300         self.assertEqual(result.returncode, 1)
0301         self.assertIn("Convert startup", result.stderr)
0302 
0303     def test_wrong_exit_is_rejected(self):
0304         result = self.run_helper("wrong_exit")
0305         self.assertEqual(result.returncode, 1)
0306         self.assertIn("got exit 2", result.stderr)
0307         self.assertIn(EXPECTED_REJECTION, result.stderr)
0308 
0309     def test_timeout_is_rejected(self):
0310         result = self.run_helper("timeout")
0311         self.assertEqual(result.returncode, 1)
0312         self.assertIn("timed out after 0.1 seconds", result.stderr)
0313 
0314     def test_baseline_failure_stops_before_injection_and_stays_visible(self):
0315         result = self.run_helper("baseline_failure")
0316         self.assertEqual(result.returncode, 7)
0317         self.assertIn("ordinary smoke output", result.stdout)
0318         self.assertIn("genuine baseline failure", result.stderr)
0319         self.assertNotIn("ERROR-DETECTION TEST", result.stdout + result.stderr)
0320         self.assertEqual(self.state.read_text().strip(), "1")
0321 
0322 
0323 if __name__ == "__main__":
0324     unittest.main()