fm-weck 1.5.2__py3-none-any.whl → 1.6.0__py3-none-any.whl

fm_weck/__init__.py

@@ -8,4 +8,4 @@
 from .config import Config  # noqa: F401
 from .image_mgr import ImageMgr  # noqa: F401
 
-__version__ = "1.5.2"
+__version__ = "1.6.0"

fm_weck/capture.py

@@ -12,7 +12,7 @@ from typing import Literal
 
 
 class Capture:
-    def __init__(self, target: io.TextIOBase, stream: Literal["stdout, stderr, stdin"] = "stdout"):
+    def __init__(self, target: io.TextIOBase, stream: Literal["stdout", "stderr", "stdin"] = "stdout"):
         self.io_stream = getattr(sys, stream)
         self._copy = os.dup(self.io_stream.fileno())
         os.dup2(target.fileno(), self.io_stream.fileno())

fm_weck/cli.py

@@ -41,7 +41,7 @@ from fm_weck.config import _SEARCH_ORDER
 from fm_weck.resources import fm_tools_choice_map, iter_fm_data, property_choice_map
 
 from . import __version__
-from .exceptions import NoImageError
+from .exceptions import NoImageError, ZenodoError
 
 logger = logging.getLogger(__name__)
 
@@ -130,6 +130,12 @@ def add_shared_args_for_run_modes(parser):
     add_tool_arg(parser, nargs=None)
 
 
+def add_shared_args_for_zenodo_modes(parser):
+    parser.add_argument(
+        "--token", help="Specify the Zenodo token to be used one time, without saving it.", type=str, default=None
+    )
+
+
 def add_shared_args_for_client(parser):
     parser.add_argument(
         "--host",
@@ -338,6 +344,43 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
     ).completer = ShellCompletion.versions_completer  # type: ignore[assignment]
     versions.set_defaults(main=main_versions)
 
+    pull = subparsers.add_parser("pull", help="Pull an image from Zenodo.")
+    pull.add_argument(
+        "DOI",
+        help="The DOI of an image to be pulled from Zenodo.",
+        type=str,
+        default=None,
+    )
+    pull.add_argument("--dir", "-d", help="The directory to download the image to.", type=str, default=None)
+    pull.add_argument("--force", "-f", help="Force pull an image.", action="store_true")
+    pull.add_argument("--sandbox", help="Use Zenodo sandbox.", action="store_true")
+    pull.set_defaults(main=main_pull)
+
+    push = subparsers.add_parser("push", help="Push an image to Zenodo.")
+    push.add_argument(
+        "IMAGE",
+        help="The image to be pushed to Zenodo.",
+        type=str,
+        default=None,
+    )
+    push.add_argument("--sandbox", help="Use Zenodo sandbox.", action="store_true")
+    add_shared_args_for_zenodo_modes(push)
+    push.set_defaults(main=main_push)
+
+    publish = subparsers.add_parser("publish", help="Publish an image on Zenodo.")
+    publish.add_argument(
+        "IMAGE",
+        help="The image to be published to Zenodo.",
+        type=str,
+        default=None,
+    )
+    publish.add_argument("--sandbox", help="Use Zenodo sandbox.", action="store_true")
+    add_shared_args_for_zenodo_modes(publish)
+    publish.set_defaults(main=main_publish)
+
+    config = subparsers.add_parser("config", help="Change the value of a config element.")
+    config.add_argument("--token", help="Save the Zenodo token to be used with the Zenodo API.", type=str, default=None)
+    config.set_defaults(main=main_config)
     server = subparsers.add_parser("server", aliases=["s"], help="Run fm-weck remotely on a server.")
     server.add_argument(
         "--port",
@@ -581,6 +624,9 @@ def main_runexec(args: argparse.Namespace):
         command=args.argument_list,
     )
 
+    if result is None:
+        return 1  # Indicate failure due to runexec setup issues
+
     return result.exit_code
 
 
@@ -666,6 +712,69 @@ def main_versions(args: argparse.Namespace):
     VersionListing(tool_paths).print_versions()
 
 
+def main_pull(args: argparse.Namespace):
+    from .engine import Engine
+    from .zenodo import ZenodoMgr
+
+    config = Config()
+    engine = Engine.from_config(config)
+
+    try:
+        zenodo_mgr = ZenodoMgr(
+            engine=engine, access_token=None, image=None, doi=args.DOI, is_sandbox=args.sandbox, config=config._config
+        )
+        zenodo_mgr.pull(args.dir, args.force)
+    except ZenodoError as e:
+        logger.error(e)
+        return 1
+    return 0
+
+
+def main_push(args: argparse.Namespace):
+    from .engine import Engine
+    from .zenodo import ZenodoMgr
+
+    config = Config()
+    engine = Engine.from_config(config)
+
+    try:
+        zenodo_mgr = ZenodoMgr(
+            engine, access_token=args.token, image=args.IMAGE, doi=None, is_sandbox=args.sandbox, config=config._config
+        )
+        zenodo_mgr.push()
+    except (ValueError, ZenodoError) as e:
+        logger.error(e)
+        return 1
+    return 0
+
+
+def main_publish(args: argparse.Namespace):
+    from .engine import Engine
+    from .zenodo import ZenodoMgr
+
+    config = Config()
+    engine = Engine.from_config(config)
+
+    try:
+        zenodo_mgr = ZenodoMgr(
+            engine, access_token=args.token, image=args.IMAGE, doi=None, is_sandbox=args.sandbox, config=config._config
+        )
+        zenodo_mgr.publish()
+    except ZenodoError as e:
+        logger.error(e)
+        return 1
+    return 0
+
+
+def main_config(args: argparse.Namespace):
+    if args.token:
+        from .zenodo import ZenodoMgr
+
+        ZenodoMgr.save_zenodo_token(Config(), args.token)
+
+    return 0
+
+
 def main_server(args: argparse.Namespace):
     from .grpc_service import serve
 
@@ -757,7 +866,7 @@ def _do_smoke_test_mode(fm_data, shelve_space, tool, gitlab_ci_mode) -> int:
             "Smoke test failed (exit code %d).\n"
             "- Tool: %s\n"
             "- Tool cache dir (host): %s\n"
-            "- Script name: smoketest.sh or smoke_test.sh\n"
+            "- Script name: smoketest.sh\n"
             "Last 50 lines of output:\n%s",
             result.exit_code,
             tool.stem,
@@ -824,8 +933,8 @@ def main_smoke_test(args: argparse.Namespace):
     except NoSmokeTestFileError as e:
         print(
             f"{e}\n"
-            "Expected a smoke test script named 'smoketest.sh' or 'smoke_test.sh' in the tool directory.\n"
-            "Action: Add a minimal script 'smoke_test.sh' to the root of the tool directory that exercises the tool.\n"
+            "Expected a smoke test script named 'smoketest.sh' in the tool directory.\n"
+            "Action: Add a minimal script 'smoketest.sh' to the root of the tool directory that exercises the tool.\n"
             "The top level contents of the tool directory were:\n"
             f"{os.linesep.join([str(p.name) for p in shelve_space.iterdir()])}",
         )

fm_weck/config.py

@@ -14,8 +14,6 @@ from functools import cache
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Optional, Tuple, TypeVar
 
-from werkzeug.utils import secure_filename
-
 try:
     from fm_tools.fmtool import FmTool
     from fm_tools.fmtoolversion import FmToolVersion
@@ -37,7 +35,7 @@ except ImportError:
                 raise ImportError("fm_tools is not imported.")
 
 
-from fm_weck.resources import RUN_WITH_OVERLAY, RUNEXEC_SCRIPT
+from fm_weck.resources import RUN_WITH_OVERLAY
 
 from .file_util import copy_ensuring_unix_line_endings
 
@@ -170,6 +168,8 @@ class Config(object):
         return self.cache_location / ".checksums.dbm"
 
     def get_shelve_space_for(self, fm_data: FmToolVersion) -> Path:
+        from werkzeug.utils import secure_filename
+
         shelve = self.cache_location
         # Remove leading http:// or https:// from the raw archive location
         raw_location = fm_data.get_archive_location().raw
@@ -195,9 +195,6 @@ class Config(object):
     def _system_is_not_posix():
         return not (sys.platform.startswith("linux") or sys.platform == "darwin")
 
-    def make_runexec_script_available(self) -> Path | None:
-        return self.make_script_available(RUNEXEC_SCRIPT)
-
     def make_script_available(self, target_name: str = RUN_WITH_OVERLAY) -> Path | None:
         script_dir = self.cache_location / ".scripts"
         target = script_dir / target_name

fm_weck/engine.py

@@ -205,7 +205,7 @@ class Engine(ABC):
 
         return base + [self.image, *_command]
 
-    def assemble_smoke_test_command(self, command: tuple[str, ...]):
+    def assemble_smoke_test_command(self, command: list[str | Path]) -> list[str | Path]:
         base = self.base_command()
         if self.add_benchexec_capabilities:
             base += self.benchexec_capabilities()
@@ -224,7 +224,7 @@ class Engine(ABC):
 
         return base + command
 
-    def _prep_command(self, command: tuple[str, ...]) -> tuple[str, ...]:
+    def _prep_command(self, command: Iterable[str]) -> tuple[str | Path, ...]:
         """We want to map absolute paths of the current working directory to the
         working directory of the container."""
 
@@ -369,6 +369,33 @@ class Engine(ABC):
 
             return tag
 
+        def inspect_image(self, image: str):
+            cmd = self.engine() + ["inspect", image]
+            logger.debug("Running command: %s", cmd)
+            return subprocess.run(cmd, capture_output=True).returncode
+
+        def save_image(self, image: str, output_path: Path):
+            cmd = self.engine() + ["save", "--format", "oci-archive", "--output", output_path, image]
+            logger.debug("Running command: %s", cmd)
+            logging.info("Saving image to file... this may take a while.")
+            subprocess.run(cmd, capture_output=True)
+            logging.info("Image saved.")
+
+        def load_image(self, image: str | Path):
+            cmd = self.engine() + ["load", "--input", str(image)]
+            logger.debug("Running command: %s", cmd)
+            subprocess.run(cmd, capture_output=True)
+
+        def tag_image(self, image: str, tag: str):
+            cmd = self.engine() + ["tag", image, tag]
+            logger.debug("Running command: %s", cmd)
+            subprocess.run(cmd, capture_output=True)
+
+        def tag_exists(self, tag: str) -> bool:
+            cmd = self.engine() + ["images", "--format", "{{.Repository}}:{{.Tag}}"]
+            result = subprocess.run(cmd, capture_output=True, text=True)
+            return tag in result.stdout
+
     def _run_process_without_attaching_io(
         self, command: tuple[str, ...] | list[str], timeout_sec: Optional[float] = None
     ) -> RunResult:
@@ -381,7 +408,7 @@ class Engine(ABC):
         signal.signal(signal.SIGINT, terminate_process_group)
         signal.signal(signal.SIGTERM, terminate_process_group)
 
-        logger.debug("\n\nRunning command:\n%s\n\n", " ".join(map(str, command)))
+        logger.debug("\n\nRunning command:\n%s\n\n", " ".join(map(str, command)))  # type: ignore
         process = subprocess.Popen(command)
 
         try:
@@ -408,7 +435,7 @@ class Engine(ABC):
         register_signal(signal.SIGINT, terminate_process_group)
         register_signal(signal.SIGTERM, terminate_process_group)
 
-        logger.debug("\n\nRunning command:\n%s\n\n", " ".join(map(str, command)))
+        logger.debug("\n\nRunning command:\n%s\n\n", " ".join(map(str, command)))  # type: ignore
 
         process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
         full_stdout = io.StringIO()

fm_weck/exceptions.py

@@ -66,3 +66,7 @@ def failure_to_error_code(failure: "Failure"):
         "EXCEPTION": ErrorCode.EC_UNKNOWN_ERROR,
     }
     return FAILURE_KIND_TO_ERROR_CODE.get(failure.kind, ErrorCode.EC_RUN_FAILED)
+
+
+class ZenodoError(Exception):
+    pass

fm_weck/image_mgr.py

@@ -6,6 +6,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
+import tempfile
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -25,6 +26,7 @@ if TYPE_CHECKING:
     from fm_weck.engine import Engine
 
 CONTAINERFILE = Path(__file__).parent / "resources" / "Containerfile"
+logger = logging.getLogger(__name__)
 
 logger = logging.getLogger(__name__)
 
@@ -64,3 +66,67 @@ class ImageMgr(object):
             spinner.ok("✅ ")
 
         return tag
+
+    def prepare_image_for_zenodo(self, engine: "Engine", image_name: str) -> tuple[str, str, Path]:
+        """
+        Prepare an image for Zenodo upload, by retreiving the image tarball.
+
+        :return: A tuple containing the normalized image name and tarball path.
+
+        Raises:
+            ValueError: If the image is invalid or does not exist.
+        """
+        if ":" not in image_name:
+            raise ValueError(f"Image specification should contain a tag: '{image_name}:tag'.")
+        elif image_name.split(":")[1] == "latest":
+            raise ValueError("Image specification should not use the 'latest' tag.")
+
+        build_cmd = engine.image_from(CONTAINERFILE)
+
+        if build_cmd.inspect_image(image_name) != 0:
+            self.print_dockerfile_warning()
+            raise ValueError(f"Image '{image_name}' is invalid or does not exist. Check your chosen engine.")
+
+        with tempfile.NamedTemporaryFile(delete=False) as image_tar:
+            image_tar_path = Path(image_tar.name)
+            build_cmd.save_image(image_name, image_tar_path)
+            return image_name.split(":")[0], image_name.split(":")[1], image_tar_path
+
+    def check_if_doi_exists_locally(self, engine: "Engine", doi: str) -> str:
+        """
+        Check if an image tagged with the given DOI already exists locally.
+
+        :return: The DOI if it does not exist locally, otherwise empty string.
+        """
+        build_cmd = engine.image_from(CONTAINERFILE)
+        tag = doi.split(".")[-1]
+
+        if build_cmd.tag_exists(tag):
+            return ""
+        else:
+            return doi
+
+    def load_image(self, engine: "Engine", image_tar: Path, tag: str | None = None) -> None:
+        image_cmd = engine.image_from(CONTAINERFILE)
+        image_cmd.load_image(image_tar)
+        if tag:
+            image_name = image_tar.stem.split(".")[0]
+            image_cmd.tag_image(image_name, tag)
+
+    def tag_image(self, engine: "Engine", image: str, tag: str) -> None:
+        image_cmd = engine.image_from(CONTAINERFILE)
+        image_cmd.tag_image(image, tag)
+
+    @staticmethod
+    def print_dockerfile_warning():
+        print(
+            "\033[31m" + "\nWarning:" + "\033[0m\n"
+            "Building images from Dockerfiles is not supported for this process. "
+            "Please use pre-built images instead.\n"
+            "To build your own image, you can use Docker or Podman, ensuring that "
+            "the image is fully functional and tested before permanently "
+            "storing it on Zenodo.\n"
+            "This approach helps maintain Zenodo's quality and avoids cluttering it "
+            "with unfinished or untested images.\n"
+            "We encourage verifying and finalizing images before uploading them to Zenodo.\n"
+        )

fm_weck/resources/__init__.py

@@ -9,8 +9,6 @@ import importlib.resources as pkg_resources
 from functools import cache
 from pathlib import Path
 
-from . import fm_tools, properties
-
 # During the build of the wheel file, the fm-tools/data directory is copied
 # to the wheel file under fm_weck/resources/fm_tools
 
@@ -20,7 +18,8 @@ RUNEXEC_SCRIPT = "runexec"
 
 
 def iter_fm_data():
-    for entry in pkg_resources.files(fm_tools).iterdir():
+    root = pkg_resources.files(__package__) / "fm_tools"
+    for entry in root.iterdir():
         if entry.name.endswith((".yml", ".yaml")):
             with pkg_resources.as_file(entry) as path:
                 fm_data_path = Path(path)
@@ -29,7 +28,8 @@ def iter_fm_data():
 
 
 def iter_properties():
-    for entry in pkg_resources.files(properties).iterdir():
+    root = pkg_resources.files(__package__) / "properties"
+    for entry in root.iterdir():
         with pkg_resources.as_file(entry) as path:
             prop_path = Path(path)
             if prop_path.is_file():

fm_weck/resources/fm_tools/2ls.yml

@@ -31,17 +31,39 @@ versions:
   - version: "svcomp25"
     doi: "10.5281/zenodo.10184626"
     benchexec_toolinfo_options: ['--graphml-witness', 'witness.graphml']
+    base_container_images:
+      - docker.io/ubuntu:24.04
     required_ubuntu_packages: []
+    full_container_images:
+      - registry.gitlab.com/sosy-lab/benchmarking/competition-scripts/user:2025
   - version: "svcomp24"
     doi: "10.5281/zenodo.10184626"
     benchexec_toolinfo_options: ['--graphml-witness', 'witness.graphml']
+    base_container_images:
+      - docker.io/ubuntu:22.04
     required_ubuntu_packages: []
+    full_container_images:
+      - registry.gitlab.com/sosy-lab/benchmarking/competition-scripts/user:2024
   - version: "svcomp23"
     url: "https://gitlab.com/sosy-lab/sv-comp/archives-2023/-/raw/svcomp23/2023/2ls.zip"
     benchexec_toolinfo_options: ['--graphml-witness', 'witness.graphml']
+    base_container_images:
+      - docker.io/ubuntu:22.04
     required_ubuntu_packages: []
+    full_container_images:
+      - registry.gitlab.com/sosy-lab/benchmarking/competition-scripts/user:2023
 
 competition_participations:
+  - competition: "SV-COMP 2026"
+    track: "Verification"
+    tool_version: "svcomp25"
+    jury_member:
+      name: Hors Concours
+      institution: --
+      country: --
+      url:
+    label:
+      - inactive
   - competition: "SV-COMP 2025"
     track: "Verification"
     tool_version: "svcomp25"

fm_weck/resources/fm_tools/afltc.yml

@@ -0,0 +1,59 @@
+id: afltc
+name: AFL-to-Test-Case
+description: |
+  AFL-to-Test-Case is a tool that uses AFL to produce test cases.
+input_languages:
+  - C
+project_url: "https://gitlab.com/sosy-lab/software/test-to-witness"
+repository_url: "https://gitlab.com/sosy-lab/software/test-to-witness"
+spdx_license_identifier: Apache-2.0
+benchexec_toolinfo_module: benchexec.tools.afltc
+fmtools_format_version: "2.0"
+fmtools_entry_maintainers:
+  - ricffb
+  - lemberger
+
+maintainers:
+  - orcid: 0000-0003-0291-815X
+    name: Thomas Lemberger
+    institution: LMU Munich
+    country: Germany
+    url: https://thomaslemberger.com/
+  - orcid: 0000-0002-4768-4054
+    name: Henrik Wachowitz
+    institution: LMU Munich
+    country: Germany
+    url: https://www.sosy-lab.org/people/wachowitz/
+
+versions:
+  - version: "testcomp26"
+    doi: 10.5281/zenodo.18060896
+    benchexec_toolinfo_options: []
+    required_ubuntu_packages: [gcc-13, g++-13, gdb, lcov, clang-18, clang-tools-18, libc++1-18, libc++abi1-18, libc++abi-18-dev, libclang1-18, libclang-18-dev, libclang-rt-18-dev, libclang-cpp18, liblld-18, liblldb-18, libllvm18, libomp5-18, lld-18, lldb-18, llvm-18, gcc-13-multilib, gcc-multilib]
+    base_container_images:
+      - docker.io/ubuntu:24.04
+    full_container_images:
+      - registry.gitlab.com/sosy-lab/benchmarking/competition-scripts/10.5281/zenodo.18005978
+      - docker.io/aflplusplus/aflplusplus:stable
+
+competition_participations:
+  - competition: "Test-Comp 2026"
+    track: "Test Generation"
+    tool_version: "testcomp26"
+    jury_member:
+      orcid: 0000-0002-4768-4054
+      name: Henrik Wachowitz
+      institution: LMU Munich
+      country: Germany
+      url: https://www.sosy-lab.org/people/wachowitz/
+    participants:
+      - orcid: 0000-0003-0291-815X
+        name: Thomas Lemberger
+      - orcid: 0000-0002-4768-4054
+        name: Henrik Wachowitz
+
+techniques: ["Fuzzing"]
+
+frameworks_solvers: ["AFL++"]
+
+literature: []

fm_weck/resources/fm_tools/aise.yml

@@ -8,7 +8,7 @@ input_languages:
 project_url: https://github.com/zbchen/aise-verifier
 repository_url: https://github.com/zbchen/aise-verifier
 spdx_license_identifier: GPL-3.0-or-later
-benchexec_toolinfo_module: "https://gitlab.com/sosy-lab/software/benchexec/-/raw/main/benchexec/tools/aise.py"
+benchexec_toolinfo_module: benchexec.tools.aise
 fmtools_format_version: "2.0"
 fmtools_entry_maintainers:
   - liar1007
@@ -21,6 +21,12 @@ maintainers:
     url: https://zbchen.github.io/
 
 versions:
+  - version: "svcomp26"
+    doi: "10.5281/zenodo.17876286"
+    benchexec_toolinfo_options: []
+    required_ubuntu_packages: []
+    base_container_images:
+      - docker.io/ubuntu:24.04
   - version: "svcomp25"
     doi: "10.5281/zenodo.14203693"
     benchexec_toolinfo_options: []
@@ -31,6 +37,24 @@ versions:
     required_ubuntu_packages: []
 
 competition_participations:
+  - competition: "SV-COMP 2026"
+    track: "Verification"
+    tool_version: "svcomp26"
+    jury_member:
+      orcid: 0000-0002-4066-7892
+      name: Zhenbang Chen
+      institution: National University of Defense Technology
+      country: China
+      url: https://zbchen.github.io/
+    participants:
+      - orcid: 0009-0004-0979-7340
+        name: Yao Lin
+      - orcid: 0009-0005-7947-3509
+        name: Zhen Wang
+      - orcid: 0000-0002-4066-7892
+        name: Zhenbang Chen
+      - orcid: 0000-0003-0637-8744
+        name: Ji Wang
   - competition: "SV-COMP 2025"
     track: "Verification"
     tool_version: "svcomp25"
@@ -58,6 +82,9 @@ frameworks_solvers:
   - Z3
 
 literature:
+  - doi: 10.1007/978-3-031-90660-2_12
+    title: "AISE v2.0: Combining Loop Transformations (Competition Contribution)"
+    year: 2025
   - doi: 10.1007/978-3-031-57256-2_19
     title: "AISE: A Symbolic Verifier by Synergizing Abstract Interpretation and Symbolic Execution (Competition Contribution)"
     year: 2024

fm_weck/resources/fm_tools/aprove.yml

@@ -24,6 +24,13 @@ maintainers:
     url: https://verify.rwth-aachen.de/jckassing/
 
 versions:
+  - version: "svcomp26"
+    doi: "10.5281/zenodo.17491801"
+    benchexec_toolinfo_options: []
+    required_ubuntu_packages:
+      - openjdk-21-jre-headless
+    base_container_images:
+      - docker.io/ubuntu:24.04
   - version: "svcomp25"
     doi: "10.5281/zenodo.14192730"
     benchexec_toolinfo_options: []
@@ -43,6 +50,18 @@ versions:
       - registry.gitlab.com/sosy-lab/benchmarking/competition-scripts/user:2022
 
 competition_participations:
+  - competition: "SV-COMP 2026"
+    track: "Verification"
+    tool_version: "svcomp26"
+    jury_member:
+      orcid: 0000-0003-3187-9217
+      name: Nils Lommen
+      institution: RWTH Aachen
+      country: Germany
+      url: https://verify.rwth-aachen.de/nlommen/
+    participants:
+      - orcid: 0000-0003-3187-9217
+        name: Nils Lommen
   - competition: "SV-COMP 2025"
     track: "Verification"
     tool_version: "svcomp25"
@@ -52,6 +71,9 @@ competition_participations:
       institution: RWTH Aachen
       country: Germany
       url: https://verify.rwth-aachen.de/nlommen/
+    participants:
+      - orcid: 0000-0003-3187-9217
+        name: Nils Lommen
   - competition: "SV-COMP 2022"
     track: "Verification"
     tool_version: "svcomp22"
@@ -69,6 +91,9 @@ frameworks_solvers:
   - Z3
 
 literature:
+  - doi: 10.1007/978-3-031-90660-2_13
+    title: "AProVE (KoAT + LoAT) (Competition Contribution)"
+    year: 2025
   - doi: 10.1007/978-3-030-99527-0_21
     title: "AProVE: Non-Termination Witnesses for C Programs (Competition Contribution)"
     year: 2022

fm_weck/resources/fm_tools/brick.yml

@@ -1,11 +1,17 @@
 id: brick
 name: BRICK
+description: |
+  BRICK is a bounded reachability checker for embedded C programs. 
+  BRICK conducts a path-oriented style checking of the bounded state space of 
+  the program, that enumerates and checks all the possible paths of the program 
+  in the threshold one by one. BRICK locates and records unsatisfiable core path segments 
+  to prune the search space to alleviate the path explosion problem.
 input_languages:
   - C
 project_url: https://github.com/brick-tool-dev/BRICK-2.0
 repository_url: https://github.com/brick-tool-dev/BRICK-2.0
 spdx_license_identifier: MIT
-benchexec_toolinfo_module: "https://gitlab.com/sosy-lab/software/benchexec/-/raw/main/benchexec/tools/brick.py"
+benchexec_toolinfo_module: benchexec.tools.brick
 fmtools_format_version: "2.0"
 fmtools_entry_maintainers:
   - brick-tool-dev
@@ -18,6 +24,15 @@ maintainers:
     url:
 
 versions:
+  - version: "svcomp26"
+    doi: "10.5281/zenodo.17630615"
+    benchexec_toolinfo_options: []
+    required_ubuntu_packages:
+      - clang
+      - libc6-dev-i386
+      - llvm
+    base_container_images:
+      - docker.io/ubuntu:24.04
   - version: "svcomp25"
     doi: "10.5281/zenodo.14203153"
     benchexec_toolinfo_options: []
@@ -32,6 +47,15 @@ versions:
     required_ubuntu_packages: []
 
 competition_participations:
+  - competition: "SV-COMP 2026"
+    track: "Verification"
+    tool_version: "svcomp26"
+    jury_member:
+      orcid: 0000-0003-0517-7801
+      name: Lei Bu
+      institution: Nanjing University
+      country: China
+      url:
   - competition: "SV-COMP 2025"
     track: "Verification"
     tool_version: "svcomp25"