Functions
	run_build (command, cwd)

	discover_applications ()

	run_application (executable, seconds, shutdown_timeout)

	main ()

Variables
	ROOT = Path(__file__).resolve().parents[2]

tuple	APPLICATION_FOLDERS = ("ContentExamples", "TestApplications")

dict	EXCLUDED_APPLICATIONS = {"TextureBenchmark"}

	file

Detailed Description

Build and launch existing Rendering Engine example/test applications.

Runs on Linux and FreeBSD. Verifies successful compilation and that
applications remain running during a short observation period.
Requires a graphical environment; not intended for headless CI.

Function Documentation

◆ discover_applications()

application_smoke_tests.discover_applications ( )

Definition at line 32 of file application_smoke_tests.py.

def discover_applications():
    apps = []
    for folder in APPLICATION_FOLDERS:
        parent = ROOT / folder
        if not parent.is_dir():
            raise RuntimeError(f"Missing directory: {parent}")
        for project in sorted(parent.iterdir()):
            if project.name in EXCLUDED_APPLICATIONS:
                continue
            if project.is_dir() and (project / "build_project.sh").is_file():
                apps.append(project)
    if not apps:
        raise RuntimeError("No application build scripts found")
    return apps
 
 

◆ main()

application_smoke_tests.main ( )

Definition at line 86 of file application_smoke_tests.py.

def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--release", action="store_true", help="Build Release rather than Debug")
    parser.add_argument("--seconds", type=float, default=3.0, help="GUI observation time (default 3)")
    parser.add_argument("--shutdown-timeout", type=float, default=3.0)
    parser.add_argument("--skip-engine-build", action="store_true", help="Reuse existing engine build")
    args = parser.parse_args()
    if os.name != "posix" or not (
        sys.platform == "linux" or sys.platform.startswith("freebsd")
    ):
        parser.error("This smoke test supports Linux and FreeBSD only")
    if args.seconds <= 0 or args.shutdown_timeout <= 0:
        parser.error("Timeouts must be positive")
 
    build_type = "Release" if args.release else "Debug"
    build_flag = "--release" if args.release else "--debug"
    apps = discover_applications()
    print(f"Rendering Engine root: {ROOT}")
    print(f"Build configuration: {build_type}")
    print(f"Applications found: {len(apps)}", flush=True)
 
    if not args.skip_engine_build:
        run_build(["sh", str(ROOT / "build_engine.sh"), "--engine-only", build_flag], ROOT)
 
    results = []
    for app in apps:
        print(f"\n=== {app.name} ===", flush=True)
        try:
            run_build(["sh", str(app / "build_project.sh"), build_flag], app)
            executable = ROOT / "Build" / "UserApplications" / app.name / build_type / app.name
            if not executable.is_file():
                raise RuntimeError(f"Executable not found: {executable}")
            if not os.access(executable, os.X_OK):
                raise RuntimeError(f"Executable not executable: {executable}")
            status, reason = run_application(executable, args.seconds, args.shutdown_timeout)
        except (OSError, RuntimeError) as exc:
            status, reason = "FAIL", str(exc)
        results.append((app.name, status, reason))
        print(f"{status}: {app.name}: {reason}", flush=True)
 
    print("\n=== Summary ===")
    for name, status, reason in results:
        print(f"{status:4} {name}: {reason}")
    passed = sum(status == "PASS" for _, status, _ in results)
    print(f"Passed {passed}/{len(results)}")
    return 0 if passed == len(results) else 1
 
 

◆ run_application()

application_smoke_tests.run_application	(	executable,
		seconds,
		shutdown_timeout
	)

Definition at line 48 of file application_smoke_tests.py.

def run_application(executable, seconds, shutdown_timeout):
    # Child uses its own process group so cleanup also handles descendants.
    with open(os.devnull, "rb") as devnull:
        process = subprocess.Popen(
            [str(executable)], cwd=executable.parent, stdin=devnull,
            start_new_session=True,
        )
        try:
            try:
                code = process.wait(timeout=seconds)
            except subprocess.TimeoutExpired:
                code = None
 
            if code is not None:
                if code == 0:
                    return "PASS", "Exited normally (code 0)"
                return "FAIL", f"Exited unexpectedly (code {code})"
 
            # The GUI is still alive after the observation window.
            os.killpg(process.pid, signal.SIGTERM)
            try:
                code = process.wait(timeout=shutdown_timeout)
            except subprocess.TimeoutExpired:
                os.killpg(process.pid, signal.SIGKILL)
                process.wait()
                return "FAIL", "Did not stop after SIGTERM; SIGKILL required"
 
            if code in (-signal.SIGTERM, 128 + signal.SIGTERM):
                return "PASS", f"Stayed alive {seconds:g}s; terminated by test runner (code {code})"
            if code == 0:
                return "PASS", "Stayed alive; shutdown returned code 0"
            return "FAIL", f"Unexpected exit code during shutdown: {code}"
        finally:
            if process.poll() is None:
                os.killpg(process.pid, signal.SIGKILL)
                process.wait()
 
 

◆ run_build()

application_smoke_tests.run_build	(	command,
		cwd
	)

Definition at line 25 of file application_smoke_tests.py.

def run_build(command, cwd):
    print(f"\n$ {' '.join(map(str, command))}", flush=True)
    result = subprocess.run(command, cwd=cwd, check=False)
    if result.returncode != 0:
        raise RuntimeError(f"Build failed (exit code {result.returncode}): {command}")
 
 

Variable Documentation

◆ APPLICATION_FOLDERS

tuple application_smoke_tests.APPLICATION_FOLDERS = ("ContentExamples", "TestApplications")

Definition at line 21 of file application_smoke_tests.py.

◆ EXCLUDED_APPLICATIONS

dict application_smoke_tests.EXCLUDED_APPLICATIONS = {"TextureBenchmark"}

Definition at line 22 of file application_smoke_tests.py.

◆ file

application_smoke_tests.file

Definition at line 138 of file application_smoke_tests.py.

◆ ROOT

application_smoke_tests.ROOT = Path(__file__).resolve().parents[2]

Definition at line 20 of file application_smoke_tests.py.

Functions

Variables